/// <summary>Initializes a new instance of the <see cref="DebugPointerType"/> class.</summary> /// <param name="debugElementType">Debug type of the pointee</param> /// <param name="module"><see cref="BitcodeModule"/> used for creating the pointer type and debug information</param> /// <param name="addressSpace">Target address space for the pointer [Default: 0]</param> /// <param name="name">Name of the type [Default: null]</param> /// <param name="alignment">Alignment on pointer</param> public DebugPointerType(IDebugType <ITypeRef, DIType> debugElementType, BitcodeModule module, uint addressSpace = 0, string name = null, uint alignment = 0) : this(debugElementType.ValidateNotNull(nameof(debugElementType)).NativeType , module , debugElementType.ValidateNotNull(nameof(debugElementType)).DIType , addressSpace , name , alignment ) { }
private static DICompositeType BuildDebugType([ValidatedNotNull] IArrayType llvmType , [ValidatedNotNull] IDebugType <ITypeRef, DIType> elementType , [ValidatedNotNull] BitcodeModule module , uint count , uint lowerBound , uint alignment ) { llvmType.ValidateNotNull(nameof(llvmType)); elementType.ValidateNotNull(nameof(elementType)); module.ValidateNotNull(nameof(module)); if (llvmType.ElementType.GetTypeRef( ) != elementType.GetTypeRef( )) { throw new ArgumentException(Resources.ElementType_doesn_t_match_array_element_type); } if (llvmType.IsSized) { return(module.DIBuilder.CreateArrayType(module.Layout.BitSizeOf(llvmType) , alignment , elementType.DIType ! // validated not null in constructor , module.DIBuilder.CreateSubRange(lowerBound, count) )); } return(module.DIBuilder.CreateReplaceableCompositeType(Tag.ArrayType , string.Empty , module.DICompileUnit ?? default , default
/// <summary>Initializes a new instance of the <see cref="DebugArrayType"/> class.</summary> /// <param name="elementType">Type of elements in the array</param> /// <param name="module"><see cref="BitcodeModule"/> to use for the context of the debug information</param> /// <param name="count">Number of elements in the array</param> /// <param name="lowerBound"><see cref="LowerBound"/> value for the array indices [Default: 0]</param> public DebugArrayType(IDebugType <ITypeRef, DIType> elementType, BitcodeModule module, uint count, uint lowerBound = 0) : this(elementType.ValidateNotNull(nameof(elementType)).CreateArrayType(count) , elementType , module , count , lowerBound ) { }
/// <summary>Creates a FunctionType with Debug information</summary> /// <param name="diBuilder"><see cref="DebugInfoBuilder"/>to use to create the debug information</param> /// <param name="isVarArg">Flag to indicate if this function is variadic</param> /// <param name="retType">Return type of the function</param> /// <param name="argTypes">Argument types of the function</param> /// <returns>Function signature</returns> public DebugFunctionType CreateFunctionType(DebugInfoBuilder diBuilder , bool isVarArg , [ValidatedNotNull] IDebugType <ITypeRef, DIType> retType , [ValidatedNotNull] IEnumerable <IDebugType <ITypeRef, DIType> > argTypes ) { diBuilder.ValidateNotNull(nameof(diBuilder)); retType.ValidateNotNull(nameof(retType)); argTypes.ValidateNotNull(nameof(retType)); if (!retType.HasDebugInfo( )) { throw new ArgumentNullException(nameof(retType), Resources.Return_type_does_not_have_debug_information); } var nativeArgTypes = new List <ITypeRef>( ); var debugArgTypes = new List <DIType>( ); var msg = new StringBuilder(Resources.One_or_more_parameter_types_are_not_valid); bool hasParamErrors = false; foreach (var indexedPair in argTypes.Select((t, i) => new { Type = t, Index = i })) { if (indexedPair.Type == null) { msg.AppendFormat(CultureInfo.CurrentCulture, Resources.Argument_0_is_null, indexedPair.Index); hasParamErrors = true; } else { nativeArgTypes.Add(indexedPair.Type.NativeType); debugArgTypes.Add(indexedPair.Type.DIType); if (indexedPair.Type.HasDebugInfo( )) { continue; } msg.AppendFormat(CultureInfo.CurrentCulture, Resources.Argument_0_does_not_contain_debug_type_information, indexedPair.Index); hasParamErrors = true; } } // if any parameters have errors, then provide a hopefully helpful message indicating which one(s) if (hasParamErrors) { throw new ArgumentException(msg.ToString( ), nameof(argTypes)); } var llvmType = GetFunctionType(retType.NativeType, nativeArgTypes, isVarArg); var diType = diBuilder.CreateSubroutineType(0, retType.DIType, debugArgTypes); Debug.Assert(diType != null && !diType.IsTemporary, Resources.Assert_Should_have_a_valid_non_temp_type_by_now); return(new DebugFunctionType(llvmType, diType)); }
/// <summary>Creates a FunctionType with Debug information</summary> /// <param name="diBuilder"><see cref="DebugInfoBuilder"/>to use to create the debug information</param> /// <param name="isVarArg">Flag to indicate if this function is variadic</param> /// <param name="retType">Return type of the function</param> /// <param name="argTypes">Argument types of the function</param> /// <returns>Function signature</returns> public DebugFunctionType CreateFunctionType(DebugInfoBuilder diBuilder , bool isVarArg , [ValidatedNotNull] IDebugType <ITypeRef, DIType> retType , [ValidatedNotNull] IEnumerable <IDebugType <ITypeRef, DIType> > argTypes ) { diBuilder.ValidateNotNull(nameof(diBuilder)); retType.ValidateNotNull(nameof(retType)); argTypes.ValidateNotNull(nameof(retType)); if (!retType.HasDebugInfo( )) { throw new ArgumentNullException(nameof(retType), "Return type does not have debug information"); } var nativeArgTypes = new List <ITypeRef>( ); var debugArgTypes = new List <DIType>( ); var msg = new StringBuilder("One or more parameter types are not valid:\n"); bool hasParamErrors = false; foreach (var indexedPair in argTypes.Select((t, i) => new { Type = t, Index = i })) { if (indexedPair.Type == null) { msg.AppendFormat("\tArgument {0} is null", indexedPair.Index); hasParamErrors = true; } else { nativeArgTypes.Add(indexedPair.Type.NativeType); debugArgTypes.Add(indexedPair.Type.DIType); if (indexedPair.Type.HasDebugInfo( )) { continue; } msg.AppendFormat("\tArgument {0} does not contain debug type information", indexedPair.Index); hasParamErrors = true; } } // if any parameters don't have errors, then provide a hopefully helpful message indicating which one(s) if (hasParamErrors) { throw new ArgumentException(msg.ToString( ), nameof(argTypes)); } var llvmType = GetFunctionType(retType.NativeType, nativeArgTypes, isVarArg); var diType = diBuilder.CreateSubroutineType(0, retType.DIType, debugArgTypes); Debug.Assert(diType != null && !diType.IsTemporary, "Should have a valid non temp type by now"); return(new DebugFunctionType(llvmType, diType)); }
/// <summary>Initializes a new instance of the <see cref="DebugArrayType"/> class</summary> /// <param name="llvmType">Underlying LLVM array type to bind debug info to</param> /// <param name="elementType">Array element type with debug information</param> /// <param name="module">module to use for creating debug information</param> /// <param name="count">Number of elements in the array</param> /// <param name="lowerBound">Lower bound of the array [default = 0]</param> /// <param name="alignment">Alignment for the type</param> public DebugArrayType(IArrayType llvmType , IDebugType <ITypeRef, DIType> elementType , BitcodeModule module , uint count , uint lowerBound = 0 , uint alignment = 0 ) : base(llvmType, BuildDebugType(llvmType, elementType, module, count, lowerBound, alignment)) { elementType.ValidateNotNull(nameof(elementType)); elementType.DIType.ValidateNotNull($"{nameof( elementType )}.{nameof( elementType.DIType )}"); DebugElementType = elementType; }
/// <summary>Initializes a new instance of the <see cref="DebugFunctionType"/> class.</summary> /// <param name="llvmType">Native LLVM function signature</param> /// <param name="module"><see cref="BitcodeModule"/> to use when construction debug information</param> /// <param name="debugFlags"><see cref="DebugInfoFlags"/> for this signature</param> /// <param name="retType">Return type for the function</param> /// <param name="argTypes">Potentially empty set of argument types for the signature</param> public DebugFunctionType(IFunctionType llvmType , BitcodeModule module , DebugInfoFlags debugFlags , IDebugType <ITypeRef, DIType> retType , params IDebugType <ITypeRef, DIType>[] argTypes ) : base(llvmType.ValidateNotNull(nameof(llvmType)) , module.ValidateNotNull(nameof(module)) .DIBuilder.CreateSubroutineType(debugFlags , retType.ValidateNotNull(nameof(retType)).DIType , argTypes.Select(t => t.DIType) ) ) { }
/// <summary>Initializes a new instance of the <see cref="DebugArrayType"/> class</summary> /// <param name="llvmType">Underlying LLVM array type to bind debug info to</param> /// <param name="elementType">Array element type with debug information</param> /// <param name="module">module to use for creating debug information</param> /// <param name="count">Number of elements in the array</param> /// <param name="lowerBound">Lower bound of the array [default = 0]</param> /// <param name="alignment">Alignment for the type</param> public DebugArrayType(IArrayType llvmType , IDebugType <ITypeRef, DIType> elementType , BitcodeModule module , uint count , uint lowerBound = 0 , uint alignment = 0 ) : base(llvmType) { llvmType.ValidateNotNull(nameof(llvmType)); elementType.ValidateNotNull(nameof(elementType)); if (llvmType.ElementType.GetTypeRef() != elementType.GetTypeRef()) { throw new ArgumentException("elementType doesn't match array element type"); } DIType = CreateDebugInfoForArray(llvmType, elementType, module, count, lowerBound, alignment); DebugElementType = elementType; }