/// <summary>Initializes a new instance of the <see cref="DebugUnionType"/> class.</summary> /// <param name="llvmType">Underlying native type this debug type describes</param> /// <param name="module">Module to contain the debug metadata for this type</param> /// <param name="scope">Scope containing this type</param> /// <param name="name">Debug/source name of the type</param> /// <param name="file">Source file containing this type</param> /// <param name="line">Line number for this type</param> /// <param name="debugFlags">Debug flags for this type</param> /// <param name="elements">Descriptors for the members of the type</param> public DebugUnionType(IStructType llvmType , BitcodeModule module , DIScope scope , string name , DIFile file , uint line , DebugInfoFlags debugFlags , IEnumerable <DebugMemberInfo> elements ) : base(llvmType) { llvmType.ValidateNotNull(nameof(llvmType)); module.ValidateNotNull(nameof(module)); scope.ValidateNotNull(nameof(scope)); file.ValidateNotNull(nameof(file)); if (!llvmType.IsOpaque) { throw new ArgumentException(Resources.Struct_type_used_as_basis_for_a_union_must_not_have_a_body, nameof(llvmType)); } DIType = module.DIBuilder .CreateReplaceableCompositeType(Tag.UnionType , name , scope , file , line ); SetBody(module, scope, file, line, debugFlags, elements); }
/// <summary> /// Creates a new tuple value representing a Q# value of user defined type. /// The casts to get the opaque and typed pointer respectively are executed lazily. When needed, /// the instructions are emitted using the current builder. /// Registers the value with the scope manager, unless registerWithScopeManager is set to false. /// </summary> /// <param name="elementTypes">The Q# types of the tuple items</param> /// <param name="context">Generation context where constants are defined and generated if needed</param> internal TupleValue(UserDefinedType?type, ImmutableArray <ResolvedType> elementTypes, GenerationContext context, bool registerWithScopeManager = true) { this.sharedState = context; this.customType = type; this.ElementTypes = elementTypes; this.StructType = this.sharedState.Types.TypedTuple(elementTypes.Select(context.LlvmTypeFromQsharpType)); this.opaquePointer = this.CreateOpaquePointerCache(this.AllocateTuple(registerWithScopeManager)); this.typedPointer = this.CreateTypedPointerCache(); this.tupleElementPointers = this.CreateTupleElementPointersCaches(); }
public void ReferenceDeclaration(IStructType declaration) { if (declaration is IIntermediateStructType) { this.ReferenceDeclaration((IIntermediateStructType)declaration); } else { this.Formatter.ReferenceDeclaration(declaration); } }
private static void CreateDoCopyFunctionBody(BitcodeModule module , DataLayout layout , Function doCopyFunc , IStructType foo , GlobalVariable bar , GlobalVariable baz , Function copyFunc ) { var bytePtrType = module.Context.Int8Type.CreatePointerType( ); // create block for the function body, only need one for this simple sample var blk = doCopyFunc.AppendBasicBlock("entry"); // create instruction builder to build the body var instBuilder = new InstructionBuilder(blk); bool param0ByVal = copyFunc.Attributes[FunctionAttributeIndex.Parameter0].Contains(AttributeKind.ByVal); if (!param0ByVal) { // create a temp local copy of the global structure var dstAddr = instBuilder.Alloca(foo) .RegisterName("agg.tmp") .Alignment(layout.CallFrameAlignmentOf(foo)); var bitCastDst = instBuilder.BitCast(dstAddr, bytePtrType) .SetDebugLocation(25, 11, doCopyFunc.DISubProgram); var bitCastSrc = instBuilder.BitCast(bar, bytePtrType) .SetDebugLocation(25, 11, doCopyFunc.DISubProgram); instBuilder.MemCpy(module , bitCastDst , bitCastSrc , module.Context.CreateConstant(layout.ByteSizeOf(foo)) , ( int )layout.CallFrameAlignmentOf(foo) , false ).SetDebugLocation(25, 11, doCopyFunc.DISubProgram); instBuilder.Call(copyFunc, dstAddr, baz) .SetDebugLocation(25, 5, doCopyFunc.DISubProgram); } else { instBuilder.Call(copyFunc, bar, baz) .SetDebugLocation(25, 5, doCopyFunc.DISubProgram) .AddAttributes(FunctionAttributeIndex.Parameter0, copyFunc.Parameters[0].Attributes); } instBuilder.Return( ) .SetDebugLocation(26, 1, doCopyFunc.DISubProgram); }
/// <summary>Creates a constant instance of a specified structure type from a set of values</summary> /// <param name="type">Type of the structure to create</param> /// <param name="values">Set of values to use in forming the structure</param> /// <returns>Newly created <see cref="Constant"/></returns> /// <remarks> /// <note type="note">The actual concrete return type depends on the parameters provided and will be one of the following: /// <list type="table"> /// <listheader> /// <term><see cref="Constant"/> derived type</term><description>Description</description> /// </listheader> /// <item><term>ConstantAggregateZero</term><description>If all the member values are zero constants</description></item> /// <item><term>UndefValue</term><description>If all the member values are UndefValue</description></item> /// <item><term>ConstantStruct</term><description>All other cases</description></item> /// </list> /// </note> /// </remarks> public Constant CreateNamedConstantStruct(IStructType type, IEnumerable <Constant> values) { if (type == null) { throw new ArgumentNullException(nameof(type)); } if (type.Context != this) { throw new ArgumentException("Cannot create named constant struct with type from another context", nameof(type)); } var valueList = values as IList <Constant> ?? values.ToList( ); var valueHandles = valueList.Select(v => v.ValueHandle).ToArray( ); if (type.Members.Count != valueHandles.Length) { throw new ArgumentException("Number of values provided must match the number of elements in the specified type"); } var mismatchedTypes = from indexedVal in valueList.Select((v, i) => new { Value = v, Index = i }) where indexedVal.Value.NativeType != type.Members[indexedVal.Index] select indexedVal; if (mismatchedTypes.Any( )) { var msg = new StringBuilder("One or more values provided do not match the corresponding member type:"); msg.AppendLine( ); foreach (var mismatch in mismatchedTypes) { msg.AppendFormat("\t[{0}]: member type={1}; value type={2}" , mismatch.Index , type.Members[mismatch.Index] , valueList[mismatch.Index].NativeType ); } throw new ArgumentException(msg.ToString( )); } // To interop correctly, we need to have an array of at least size one. uint valuesLength = (uint)valueHandles.Length; if (valuesLength == 0) { valueHandles = new LLVMValueRef[1]; } var handle = NativeMethods.ConstNamedStruct(type.GetTypeRef( ), out valueHandles[0], valuesLength); return(Value.FromHandle <Constant>(handle)); }
public DebugUnionType(IStructType llvmType , NativeModule module , DIScope scope , string name , DIFile file , uint line , DebugInfoFlags debugFlags , IEnumerable <DebugMemberInfo> elements ) : base(llvmType) { if (llvmType == null) { throw new ArgumentNullException(nameof(llvmType)); } if (module == null) { throw new ArgumentNullException(nameof(module)); } if (scope == null) { throw new ArgumentNullException(nameof(scope)); } if (file == null) { throw new ArgumentNullException(nameof(file)); } if (!llvmType.IsOpaque) { throw new ArgumentException("Struct type used as basis for a union must not have a body", nameof(llvmType)); } DIType = module.DIBuilder .CreateReplaceableCompositeType(Tag.UnionType , name , scope , file , line ); SetBody(module, scope, file, line, debugFlags, elements); }
/// <summary> /// Creates a new tuple value representing a Q# value of user defined type from the given tuple pointer. /// The casts to get the opaque and typed pointer respectively are executed lazily. When needed, /// instructions are emitted using the current builder. /// </summary> /// <param name="type">Optionally the user defined type tha that the tuple represents</param> /// <param name="tuple">Either an opaque or a typed pointer to the tuple data structure</param> /// <param name="elementTypes">The Q# types of the tuple items</param> /// <param name="context">Generation context where constants are defined and generated if needed</param> internal TupleValue(UserDefinedType?type, Value tuple, ImmutableArray <ResolvedType> elementTypes, GenerationContext context) { var isTypedTuple = Types.IsTypedTuple(tuple.NativeType); var isOpaqueTuple = !tuple.IsNull && Types.IsTupleOrUnit(tuple.NativeType); if (!isTypedTuple && !isOpaqueTuple) { throw new ArgumentException("expecting either an opaque or a typed tuple"); } this.sharedState = context; this.customType = type; this.ElementTypes = elementTypes; this.StructType = this.sharedState.Types.TypedTuple(elementTypes.Select(context.LlvmTypeFromQsharpType)); this.opaquePointer = this.CreateOpaquePointerCache(isOpaqueTuple ? tuple : null); this.typedPointer = this.CreateTypedPointerCache(isTypedTuple ? tuple : null); this.tupleElementPointers = this.CreateTupleElementPointersCaches(); }
/// <summary>Creates a constant instance of a specified structure type from a set of values</summary> /// <param name="type">Type of the structure to create</param> /// <param name="values">Set of values to use in forming the structure</param> /// <returns>Newly created <see cref="Constant"/></returns> /// <remarks> /// <note type="note">The actual concrete return type depends on the parameters provided and will be one of the following: /// <list type="table"> /// <listheader> /// <term><see cref="Constant"/> derived type</term><description>Description</description> /// </listheader> /// <item><term>ConstantAggregateZero</term><description>If all the member values are zero constants</description></item> /// <item><term>UndefValue</term><description>If all the member values are UndefValue</description></item> /// <item><term>ConstantStruct</term><description>All other cases</description></item> /// </list> /// </note> /// </remarks> public Constant CreateNamedConstantStruct(IStructType type, IEnumerable <Constant> values) { type.ValidateNotNull(nameof(type)); values.ValidateNotNull(nameof(values)); if (type.Context != this) { throw new ArgumentException(Resources.Cannot_create_named_constant_struct_with_type_from_another_context, nameof(type)); } var valueList = values as IList <Constant> ?? values.ToList( ); var valueHandles = valueList.Select(v => v.ValueHandle).ToArray( ); if (type.Members.Count != valueHandles.Length) { throw new ArgumentException(Resources.Number_of_values_provided_must_match_the_number_of_elements_in_the_specified_type); } var mismatchedTypes = from indexedVal in valueList.Select((v, i) => new { Value = v, Index = i }) where indexedVal.Value.NativeType != type.Members[indexedVal.Index] select indexedVal; if (mismatchedTypes.Any( )) { var msg = new StringBuilder(Resources.One_or_more_values_provided_do_not_match_the_corresponding_member_type_); msg.AppendLine( ); foreach (var mismatch in mismatchedTypes) { msg.AppendFormat(CultureInfo.CurrentCulture , Resources.MismatchedType_0_member_type_equals_1_value_type_equals_2 , mismatch.Index , type.Members[mismatch.Index] , valueList[mismatch.Index].NativeType ); } throw new ArgumentException(msg.ToString( )); } var handle = LLVMConstNamedStruct(type.GetTypeRef( ), valueHandles, (uint)valueHandles.Length); return(Value.FromHandle <Constant>(handle)); }
// constructor internal Types(Context context) { this.context = context; this.Int = context.Int64Type; this.Double = context.DoubleType; this.Bool = context.BoolType; this.Pauli = context.GetIntType(2); this.Range = context.CreateStructType(TypeNames.Range, false, context.Int64Type, context.Int64Type, context.Int64Type); this.Result = context.CreateStructType(TypeNames.Result).CreatePointerType(); this.Qubit = context.CreateStructType(TypeNames.Qubit).CreatePointerType(); this.String = context.CreateStructType(TypeNames.String).CreatePointerType(); this.BigInt = context.CreateStructType(TypeNames.BigInt).CreatePointerType(); this.Tuple = context.CreateStructType(TypeNames.Tuple).CreatePointerType(); this.Array = context.CreateStructType(TypeNames.Array).CreatePointerType(); this.Callable = context.CreateStructType(TypeNames.Callable).CreatePointerType(); this.FunctionSignature = context.GetFunctionType(context.VoidType, this.Tuple, this.Tuple, this.Tuple); this.CallableTable = this.FunctionSignature.CreatePointerType().CreateArrayType(4); this.CaptureCountFunction = context.GetFunctionType(context.VoidType, this.Tuple, context.Int32Type); this.CallableMemoryManagementTable = this.CaptureCountFunction.CreatePointerType().CreateArrayType(2); }
public void ReferenceDeclaration(IStructType declaration) { }
protected abstract IStructInstance OnCreateStruct(ISymbolInfo entry, IStructType structType, ISymbol parent);
internal StructInstance(ISymbol parent, IStructType type, string instanceName, int fieldOffset) : base(parent, type, instanceName, fieldOffset, ((ISymbolFactoryServicesProvider)parent).FactoryServices) { base.category = DataTypeCategory.Struct; }
internal StructInstance(AdsSymbolEntry entry, IStructType type, ISymbol parent, ISymbolFactoryServices factoryServices) : base(entry, type, parent, factoryServices) { base.category = DataTypeCategory.Struct; }
public StructTypeWrapper(IStructType <TAttributeGroup, TGenericParameter, TInterfaceReference, TEventCollection, TPropertyCollection, TIndexerCollection, TMethodCollection, TFieldCollection, TConstructor, TOperatorOverload, TConversionOperator, TNestedClassCollection, TNestedDelegate, TNestedEnum, TNestedInterface, TNestedStructCollection, TStaticConstructor> type) { WrappedObject = type; }
public override void TranslateType(IStructType structureType) { this.Provider.GenerateCodeFromType(structureType.GenerateCodeDom(this.Options), base.Target, this.Options.Options); }
public ulong OffsetOfElement(IStructType structType, uint element) { VerifySized(structType, nameof(structType)); return(LLVMOffsetOfElement(DataLayoutHandle, structType.GetTypeRef( ), element)); }
public void ReferenceDeclaration(IStructType declaration) { referenceStack.Push(declaration); }
internal _Method(IStructType parent, IStructPropertyMethodMember original) : base(parent, original) { }
/// <summary>Creates a constant instance of a specified structure type from a set of values</summary> /// <param name="type">Type of the structure to create</param> /// <param name="values">Set of values to use in forming the structure</param> /// <returns>Newly created <see cref="Constant"/></returns> /// <remarks> /// <note type="note">The actual concrete return type depends on the parameters provided and will be one of the following: /// <list type="table"> /// <listheader> /// <term><see cref="Constant"/> derived type</term><description>Description</description> /// </listheader> /// <item><term>ConstantAggregateZero</term><description>If all the member values are zero constants</description></item> /// <item><term>UndefValue</term><description>If all the member values are UndefValue</description></item> /// <item><term>ConstantStruct</term><description>All other cases</description></item> /// </list> /// </note> /// </remarks> public Constant CreateNamedConstantStruct(IStructType type, params Constant[] values) { return(CreateNamedConstantStruct(type, (IEnumerable <Constant>)values)); }
public MethodMember(ICliMetadataMethodDefinitionTableRow metadataEntry, _ICliAssembly assembly, IStructType parent, IGeneralGenericSignatureMemberUniqueIdentifier uniqueIdentifier, PropertyMethodType methodType) : base(metadataEntry, assembly, parent, uniqueIdentifier) { this.methodType = methodType; }
internal _MethodMember(IStructType parent, IStructMethodMember method) : base(parent, method) { }
public uint ElementAtOffset(IStructType structType, ulong offset) { VerifySized(structType, nameof(structType)); return(LLVMElementAtOffset(DataLayoutHandle, structType.GetTypeRef( ), offset)); }
/// <summary> /// Translates a structure-based declared type. /// </summary> /// <param name="structureType">The <see cref="IStructType"/> to translate.</param> public abstract void TranslateType(IStructType structureType);
/// <summary>Gets the offset of a structure element in bits</summary> /// <param name="llvmType">Structure type to get the element offset of</param> /// <param name="element">Index of the element in the structure</param> /// <returns>Offset of the element in bits</returns> public ulong BitOffsetOfElement(IStructType llvmType, uint element) => OffsetOfElement(llvmType, element) * 8;
protected override IStructInstance OnCreateStruct(ISymbolInfo entry, IStructType structType, ISymbol parent) => (!structType.HasRpcMethods ? new StructInstance((AdsSymbolEntry)entry, (StructType)structType, parent, base.services) : new RpcStructInstance((AdsSymbolEntry)entry, (RpcStructType)structType, parent, base.services));