public FieldSpec DefineInitializedData (byte[] data, Location loc)
{
Struct size_type;
if (!size_types.TryGetValue (data.Length, out size_type)) {
//
// Build common type for this data length. We cannot use
// DefineInitializedData because it creates public type,
// and its name is not unique among modules
//
size_type = new Struct (null, this, new MemberName ("$ArrayType=" + data.Length, Location), Modifiers.PRIVATE | Modifiers.COMPILER_GENERATED, null);
size_type.CreateType ();
size_type.DefineType ();
size_types.Add (data.Length, size_type);
var pa = Module.PredefinedAttributes.StructLayout;
if (pa.Constructor != null || pa.ResolveConstructor (Location, TypeManager.short_type)) {
var argsEncoded = new AttributeEncoder (false);
argsEncoded.Encode ((short) LayoutKind.Explicit);
var field_size = pa.GetField ("Size", TypeManager.int32_type, Location);
var pack = pa.GetField ("Pack", TypeManager.int32_type, Location);
if (field_size != null) {
argsEncoded.EncodeNamedArguments (
new[] { field_size, pack },
new[] { new IntConstant ((int) data.Length, Location), new IntConstant (1, Location) }
);
}
pa.EmitAttribute (size_type.TypeBuilder, argsEncoded);
}
}
var name = "$field-" + fields.ToString ("X");
++fields;
const Modifiers fmod = Modifiers.STATIC | Modifiers.INTERNAL;
var fbuilder = TypeBuilder.DefineField (name, size_type.CurrentType.GetMetaInfo (), ModifiersExtensions.FieldAttr (fmod) | FieldAttributes.HasFieldRVA);
#if STATIC
fbuilder.__SetDataAndRVA (data);
#else
if (set_data == null)
set_data = typeof (FieldBuilder).GetMethod ("SetRVAData", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
try {
set_data.Invoke (fbuilder, new object[] { data });
} catch {
Report.RuntimeMissingSupport (loc, "SetRVAData");
}
#endif
return new FieldSpec (CurrentType, null, size_type.CurrentType, fbuilder, fmod);
}
public FieldSpec DefineInitializedData (byte[] data, Location loc)
{
Struct size_type;
if (!size_types.TryGetValue (data.Length, out size_type)) {
//
// Build common type for this data length. We cannot use
// DefineInitializedData because it creates public type,
// and its name is not unique among modules
//
size_type = new Struct (null, this, new MemberName ("$ArrayType=" + data.Length, Location), Modifiers.PRIVATE | Modifiers.COMPILER_GENERATED, null);
size_type.CreateType ();
size_type.DefineType ();
size_types.Add (data.Length, size_type);
var pa = Module.PredefinedAttributes.StructLayout;
if (pa.Constructor != null || pa.ResolveConstructor (Location, Compiler.BuildinTypes.Short)) {
var argsEncoded = new AttributeEncoder ();
argsEncoded.Encode ((short) LayoutKind.Explicit);
var field_size = pa.GetField ("Size", Compiler.BuildinTypes.Int, Location);
var pack = pa.GetField ("Pack", Compiler.BuildinTypes.Int, Location);
if (field_size != null) {
argsEncoded.EncodeNamedArguments (
new[] { field_size, pack },
new[] { new IntConstant (Compiler.BuildinTypes, (int) data.Length, Location), new IntConstant (Compiler.BuildinTypes, 1, Location) }
);
}
pa.EmitAttribute (size_type.TypeBuilder, argsEncoded);
}
}
var name = "$field-" + fields.ToString ("X");
++fields;
const Modifiers fmod = Modifiers.STATIC | Modifiers.INTERNAL;
var fbuilder = TypeBuilder.DefineField (name, size_type.CurrentType.GetMetaInfo (), ModifiersExtensions.FieldAttr (fmod) | FieldAttributes.HasFieldRVA);
fbuilder.__SetDataAndRVA (data);
return new FieldSpec (CurrentType, null, size_type.CurrentType, fbuilder, fmod);
}
void EmitFieldSize (int buffer_size)
{
int type_size = BuiltinTypeSpec.GetSize (MemberType);
if (buffer_size > int.MaxValue / type_size) {
Report.Error (1664, Location, "Fixed size buffer `{0}' of length `{1}' and type `{2}' exceeded 2^31 limit",
GetSignatureForError (), buffer_size.ToString (), TypeManager.CSharpName (MemberType));
return;
}
AttributeEncoder encoder;
var ctor = Module.PredefinedMembers.StructLayoutAttributeCtor.Resolve (Location);
if (ctor == null)
return;
var field_size = Module.PredefinedMembers.StructLayoutSize.Resolve (Location);
var field_charset = Module.PredefinedMembers.StructLayoutCharSet.Resolve (Location);
if (field_size == null || field_charset == null)
return;
var char_set = CharSet ?? Module.DefaultCharSet ?? 0;
encoder = new AttributeEncoder ();
encoder.Encode ((short)LayoutKind.Sequential);
encoder.EncodeNamedArguments (
new [] { field_size, field_charset },
new Constant [] {
new IntConstant (Compiler.BuiltinTypes, buffer_size * type_size, Location),
new IntConstant (Compiler.BuiltinTypes, (int) char_set, Location)
}
);
fixed_buffer_type.SetCustomAttribute ((ConstructorInfo) ctor.GetMetaInfo (), encoder.ToArray ());
//
// Don't emit FixedBufferAttribute attribute for private types
//
if ((ModFlags & Modifiers.PRIVATE) != 0)
return;
ctor = Module.PredefinedMembers.FixedBufferAttributeCtor.Resolve (Location);
if (ctor == null)
return;
encoder = new AttributeEncoder ();
encoder.EncodeTypeName (MemberType);
encoder.Encode (buffer_size);
encoder.EncodeEmptyNamedArguments ();
FieldBuilder.SetCustomAttribute ((ConstructorInfo) ctor.GetMetaInfo (), encoder.ToArray ());
}
public override void EncodeAttributeValue (IMemberContext rc, AttributeEncoder enc, TypeSpec targetType)
{
enc.Stream.Write ((ushort) Value);
}
public override void EncodeAttributeValue (IMemberContext rc, AttributeEncoder enc, TypeSpec targetType)
{
// Type it as string cast
if (targetType == TypeManager.object_type || targetType == InternalType.Null)
enc.Encode (TypeManager.string_type);
var ac = targetType as ArrayContainer;
if (ac != null) {
if (ac.Rank != 1 || ac.Element.IsArray)
base.EncodeAttributeValue (rc, enc, targetType);
else
enc.Stream.Write (uint.MaxValue);
} else {
enc.Stream.Write (byte.MaxValue);
}
}
void EmitIndexerName ()
{
if (!seen_normal_indexers)
return;
PredefinedAttribute pa = Module.PredefinedAttributes.DefaultMember;
if (pa.Constructor == null &&
!pa.ResolveConstructor (Location, TypeManager.string_type))
return;
var encoder = new AttributeEncoder ();
encoder.Encode (GetAttributeDefaultMember ());
encoder.EncodeEmptyNamedArguments ();
pa.EmitAttribute (TypeBuilder, encoder);
}
void EmitFieldSize(int buffer_size)
{
PredefinedAttribute pa;
AttributeEncoder encoder;
pa = Module.PredefinedAttributes.StructLayout;
if (pa.Constructor == null && !pa.ResolveConstructor (Location, TypeManager.short_type))
return;
var char_set_type = Module.PredefinedTypes.CharSet.Resolve (Location);
if (char_set_type == null)
return;
var field_size = pa.GetField ("Size", TypeManager.int32_type, Location);
var field_charset = pa.GetField ("CharSet", char_set_type, Location);
if (field_size == null || field_charset == null)
return;
var char_set = CharSet ?? Module.DefaultCharSet ?? 0;
encoder = new AttributeEncoder ();
encoder.Encode ((short)LayoutKind.Sequential);
encoder.EncodeNamedArguments (
new [] { field_size, field_charset },
new Constant [] { new IntConstant (buffer_size, Location), new IntConstant ((int) char_set, Location) }
);
pa.EmitAttribute (fixed_buffer_type, encoder);
//
// Don't emit FixedBufferAttribute attribute for private types
//
if ((ModFlags & Modifiers.PRIVATE) != 0)
return;
pa = Module.PredefinedAttributes.FixedBuffer;
if (pa.Constructor == null && !pa.ResolveConstructor (Location, TypeManager.type_type, TypeManager.int32_type))
return;
encoder = new AttributeEncoder ();
encoder.EncodeTypeName (MemberType);
encoder.Encode (buffer_size);
encoder.EncodeEmptyNamedArguments ();
pa.EmitAttribute (FieldBuilder, encoder);
}
public override void EncodeAttributeValue (IMemberContext rc, AttributeEncoder enc, TypeSpec targetType)
{
enc.Encode (Value);
}
/// <summary>
/// Emit attribute for Attributable symbol
/// </summary>
public void Emit (Dictionary<Attribute, List<Attribute>> allEmitted)
{
var ctor = Resolve ();
if (ctor == null)
return;
var predefined = context.Compiler.PredefinedAttributes;
AttributeUsageAttribute usage_attr = Type.GetAttributeUsage (predefined.AttributeUsage);
if ((usage_attr.ValidOn & Target) == 0) {
Report.Error (592, Location, "The attribute `{0}' is not valid on this declaration type. " +
"It is valid on `{1}' declarations only",
GetSignatureForError (), GetValidTargets ());
return;
}
AttributeEncoder encoder = new AttributeEncoder (false);
if (PosArguments != null) {
var param_types = ctor.Parameters.Types;
for (int j = 0; j < PosArguments.Count; ++j) {
var pt = param_types[j];
var arg_expr = PosArguments[j].Expr;
if (j == 0) {
if (Type == predefined.IndexerName || Type == predefined.Conditional) {
string v = ((StringConstant) arg_expr).Value;
if (!Tokenizer.IsValidIdentifier (v) || Tokenizer.IsKeyword (v)) {
context.Compiler.Report.Error (633, arg_expr.Location,
"The argument to the `{0}' attribute must be a valid identifier", GetSignatureForError ());
}
} else if (Type == predefined.Guid) {
try {
string v = ((StringConstant) arg_expr).Value;
new Guid (v);
} catch (Exception e) {
Error_AttributeEmitError (e.Message);
return;
}
} else if (Type == predefined.AttributeUsage) {
int v = ((IntConstant)((EnumConstant) arg_expr).Child).Value;
if (v == 0) {
context.Compiler.Report.Error (591, Location, "Invalid value for argument to `{0}' attribute",
"System.AttributeUsage");
}
} else if (Type == predefined.MethodImpl && pt == TypeManager.short_type &&
!System.Enum.IsDefined (typeof (MethodImplOptions), ((Constant) arg_expr).GetValue ().ToString ())) {
Error_AttributeEmitError ("Incorrect argument value.");
return;
}
}
arg_expr.EncodeAttributeValue (context, encoder, pt);
}
}
if (named_values != null) {
encoder.Stream.Write ((ushort) named_values.Count);
foreach (var na in named_values) {
if (na.Key is FieldExpr)
encoder.Stream.Write ((byte) 0x53);
else
encoder.Stream.Write ((byte) 0x54);
encoder.Encode (na.Key.Type);
encoder.Encode (na.Value.Name);
na.Value.Expr.EncodeAttributeValue (context, encoder, na.Key.Type);
}
} else {
encoder.Stream.Write ((ushort) 0);
}
byte[] cdata = encoder.ToArray ();
try {
foreach (Attributable target in targets)
target.ApplyAttributeBuilder (this, ctor, cdata, predefined);
} catch (Exception e) {
Error_AttributeEmitError (e.Message);
return;
}
if (!usage_attr.AllowMultiple && allEmitted != null) {
if (allEmitted.ContainsKey (this)) {
var a = allEmitted [this];
if (a == null) {
a = new List<Attribute> (2);
allEmitted [this] = a;
}
a.Add (this);
} else {
allEmitted.Add (this, null);
}
}
if (!RootContext.VerifyClsCompliance)
return;
// Here we are testing attribute arguments for array usage (error 3016)
if (Owner.IsClsComplianceRequired ()) {
if (PosArguments != null)
PosArguments.CheckArrayAsAttribute (context.Compiler);
if (NamedArguments == null)
return;
NamedArguments.CheckArrayAsAttribute (context.Compiler);
}
}
public virtual void EncodeAttributeValue(IMemberContext rc, AttributeEncoder enc, TypeSpec targetType)
{
Attribute.Error_AttributeArgumentNotValid (rc, loc);
}
void EmitFieldSize (int buffer_size)
{
int type_size = BuiltinTypeSpec.GetSize (MemberType);
if (buffer_size > int.MaxValue / type_size) {
Report.Error (1664, Location, "Fixed size buffer `{0}' of length `{1}' and type `{2}' exceeded 2^31 limit",
GetSignatureForError (), buffer_size.ToString (), MemberType.GetSignatureForError ());
return;
}
AttributeEncoder encoder;
MethodSpec ctor;
var char_set = CharSetValue ?? Module.DefaultCharSet ?? 0;
#if STATIC
//
// Set struct layout without resolving StructLayoutAttribute which is not always available
//
TypeAttributes attribs = TypeAttributes.SequentialLayout;
switch (char_set) {
case CharSet.None:
case CharSet.Ansi:
attribs |= TypeAttributes.AnsiClass;
break;
case CharSet.Auto:
attribs |= TypeAttributes.AutoClass;
break;
case CharSet.Unicode:
attribs |= TypeAttributes.UnicodeClass;
break;
}
fixed_buffer_type.__SetAttributes (fixed_buffer_type.Attributes | attribs);
fixed_buffer_type.__SetLayout (0, buffer_size * type_size);
#else
ctor = Module.PredefinedMembers.StructLayoutAttributeCtor.Resolve (Location);
if (ctor == null)
return;
var field_size = Module.PredefinedMembers.StructLayoutSize.Resolve (Location);
var field_charset = Module.PredefinedMembers.StructLayoutCharSet.Resolve (Location);
if (field_size == null || field_charset == null)
return;
encoder = new AttributeEncoder ();
encoder.Encode ((short)LayoutKind.Sequential);
encoder.EncodeNamedArguments (
new [] { field_size, field_charset },
new Constant [] {
new IntConstant (Compiler.BuiltinTypes, buffer_size * type_size, Location),
new IntConstant (Compiler.BuiltinTypes, (int) char_set, Location)
}
);
fixed_buffer_type.SetCustomAttribute ((ConstructorInfo) ctor.GetMetaInfo (), encoder.ToArray ());
#endif
//
// Don't emit FixedBufferAttribute attribute for private types
//
if ((ModFlags & Modifiers.PRIVATE) != 0)
return;
ctor = Module.PredefinedMembers.FixedBufferAttributeCtor.Resolve (Location);
if (ctor == null)
return;
encoder = new AttributeEncoder ();
encoder.EncodeTypeName (MemberType);
encoder.Encode (buffer_size);
encoder.EncodeEmptyNamedArguments ();
FieldBuilder.SetCustomAttribute ((ConstructorInfo) ctor.GetMetaInfo (), encoder.ToArray ());
}
public override void EncodeAttributeValue(IMemberContext rc, AttributeEncoder enc, TypeSpec targetType)
{
Child.EncodeAttributeValue (rc, enc, Child.Type);
}
public override void EncodeAttributeValue (IMemberContext rc, AttributeEncoder enc, TypeSpec targetType)
{
throw new NotSupportedException ();
}
void EmitFieldSize (int buffer_size)
{
int type_size = Expression.GetTypeSize (MemberType);
if (buffer_size > int.MaxValue / type_size) {
Report.Error (1664, Location, "Fixed size buffer `{0}' of length `{1}' and type `{2}' exceeded 2^31 limit",
GetSignatureForError (), buffer_size.ToString (), TypeManager.CSharpName (MemberType));
return;
}
PredefinedAttribute pa;
AttributeEncoder encoder;
pa = Module.PredefinedAttributes.StructLayout;
if (pa.Constructor == null && !pa.ResolveConstructor (Location, TypeManager.short_type))
return;
var char_set_type = Module.PredefinedTypes.CharSet.Resolve (Location);
if (char_set_type == null)
return;
var field_size = pa.GetField ("Size", TypeManager.int32_type, Location);
var field_charset = pa.GetField ("CharSet", char_set_type, Location);
if (field_size == null || field_charset == null)
return;
var char_set = CharSet ?? Module.DefaultCharSet;
encoder = new AttributeEncoder ();
encoder.Encode ((short)LayoutKind.Sequential);
encoder.EncodeNamedArguments (
new [] { field_size, field_charset },
new Constant [] { new IntConstant (buffer_size * type_size, Location), new IntConstant ((int) char_set, Location) }
);
pa.EmitAttribute (fixed_buffer_type, encoder);
//
// Don't emit FixedBufferAttribute attribute for private types
//
if ((ModFlags & Modifiers.PRIVATE) != 0)
return;
pa = Module.PredefinedAttributes.FixedBuffer;
if (pa.Constructor == null && !pa.ResolveConstructor (Location, TypeManager.type_type, TypeManager.int32_type))
return;
encoder = new AttributeEncoder ();
encoder.EncodeTypeName (MemberType);
encoder.Encode (buffer_size);
encoder.EncodeEmptyNamedArguments ();
pa.EmitAttribute (FieldBuilder, encoder);
}
public override void EncodeAttributeValue (IMemberContext rc, AttributeEncoder enc, TypeSpec targetType)
{
// cast to object
if (type != targetType)
enc.Encode (type);
enc.Encode (Value);
}
public override void EncodeAttributeValue (IMemberContext rc, AttributeEncoder enc, TypeSpec targetType, TypeSpec parameterType)
{
enc.Encode ((ushort) Value);
}
public override void EncodeAttributeValue (IMemberContext rc, AttributeEncoder enc, TypeSpec targetType)
{
switch (targetType.BuiltinType) {
case BuiltinTypeSpec.Type.Object:
// Type it as string cast
enc.Encode (rc.Module.Compiler.BuiltinTypes.String);
goto case BuiltinTypeSpec.Type.String;
case BuiltinTypeSpec.Type.String:
case BuiltinTypeSpec.Type.Type:
enc.Encode (byte.MaxValue);
return;
default:
var ac = targetType as ArrayContainer;
if (ac != null && ac.Rank == 1 && !ac.Element.IsArray) {
enc.Encode (uint.MaxValue);
return;
}
break;
}
base.EncodeAttributeValue (rc, enc, targetType);
}
public void Emit ()
{
if (RootContext.Target == Target.Module) {
module_target_attrs = new AssemblyAttributesPlaceholder (module, name);
module_target_attrs.CreateType ();
module_target_attrs.DefineType ();
module_target_attrs.Define ();
module.AddCompilerGeneratedClass (module_target_attrs);
} else if (added_modules != null) {
ReadModulesAssemblyAttributes ();
}
module.Emit ();
if (module.HasExtensionMethod) {
var pa = Compiler.PredefinedAttributes.Extension;
if (pa.IsDefined) {
SetCustomAttribute (pa.Constructor, AttributeEncoder.Empty);
}
}
if (!wrap_non_exception_throws_custom) {
PredefinedAttribute pa = Compiler.PredefinedAttributes.RuntimeCompatibility;
if (pa.IsDefined && pa.ResolveBuilder ()) {
var prop = pa.GetProperty ("WrapNonExceptionThrows", TypeManager.bool_type, Location.Null);
if (prop != null) {
AttributeEncoder encoder = new AttributeEncoder (false);
encoder.EncodeNamedPropertyArgument (prop, new BoolLiteral (true, Location.Null));
SetCustomAttribute (pa.Constructor, encoder.ToArray ());
}
}
}
if (declarative_security != null) {
MethodInfo add_permission = typeof (AssemblyBuilder).GetMethod ("AddPermissionRequests", BindingFlags.Instance | BindingFlags.NonPublic);
object builder_instance = Builder;
try {
// Microsoft runtime hacking
if (add_permission == null) {
var assembly_builder = typeof (AssemblyBuilder).Assembly.GetType ("System.Reflection.Emit.AssemblyBuilderData");
add_permission = assembly_builder.GetMethod ("AddPermissionRequests", BindingFlags.Instance | BindingFlags.NonPublic);
FieldInfo fi = typeof (AssemblyBuilder).GetField ("m_assemblyData", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.GetField);
builder_instance = fi.GetValue (Builder);
}
var args = new PermissionSet [3];
declarative_security.TryGetValue (SecurityAction.RequestMinimum, out args [0]);
declarative_security.TryGetValue (SecurityAction.RequestOptional, out args [1]);
declarative_security.TryGetValue (SecurityAction.RequestRefuse, out args [2]);
add_permission.Invoke (builder_instance, args);
} catch {
Report.RuntimeMissingSupport (Location.Null, "assembly permission setting");
}
}
CheckReferencesPublicToken ();
SetEntryPoint ();
}
void EmitIndexerName ()
{
if (!has_normal_indexers)
return;
var ctor = Module.PredefinedMembers.DefaultMemberAttributeCtor.Get ();
if (ctor == null)
return;
var encoder = new AttributeEncoder ();
encoder.Encode (GetAttributeDefaultMember ());
encoder.EncodeEmptyNamedArguments ();
TypeBuilder.SetCustomAttribute ((ConstructorInfo) ctor.GetMetaInfo (), encoder.ToArray ());
}
public override void EncodeAttributeValue (IMemberContext rc, AttributeEncoder enc, TypeSpec targetType)
{
// Type it as string cast
if (targetType.BuiltinType == BuiltinTypeSpec.Type.Object)
enc.Encode (rc.Module.Compiler.BuiltinTypes.String);
var ac = targetType as ArrayContainer;
if (ac != null) {
if (ac.Rank != 1 || ac.Element.IsArray)
base.EncodeAttributeValue (rc, enc, targetType);
else
enc.Encode (uint.MaxValue);
} else {
enc.Encode (byte.MaxValue);
}
}
