Debian Codegraph @

mcs/tools/cil-strip/Mono.Cecil/ReflectionWriter.cs

raw
1 //
2 // ReflectionWriter.cs
3 //
4 // Author:
5 // Jb Evain ([email protected])
6 //
7 // (C) 2005 - 2007 Jb Evain
8 //
9 // Permission is hereby granted, free of charge, to any person obtaining
10 // a copy of this software and associated documentation files (the
11 // "Software"), to deal in the Software without restriction, including
12 // without limitation the rights to use, copy, modify, merge, publish,
13 // distribute, sublicense, and/or sell copies of the Software, and to
14 // permit persons to whom the Software is furnished to do so, subject to
15 // the following conditions:
16 //
17 // The above copyright notice and this permission notice shall be
18 // included in all copies or substantial portions of the Software.
19 //
20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 //
28
29 namespace Mono.Cecil {
30
31 using System;
32 using System.Collections;
33 using System.Globalization;
34 using System.Text;
35
36 using Mono.Cecil.Binary;
37 using Mono.Cecil.Cil;
38 using Mono.Cecil.Metadata;
39 using Mono.Cecil.Signatures;
40
41 internal sealed class ReflectionWriter : BaseReflectionVisitor {
42
43 StructureWriter m_structureWriter;
44 ModuleDefinition m_mod;
45 SignatureWriter m_sigWriter;
46 CodeWriter m_codeWriter;
47 MetadataWriter m_mdWriter;
48 MetadataTableWriter m_tableWriter;
49 MetadataRowWriter m_rowWriter;
50
51 bool m_saveSymbols;
52 string m_asmOutput;
53 ISymbolWriter m_symbolWriter;
54
55 ArrayList m_typeDefStack;
56 ArrayList m_methodStack;
57 ArrayList m_fieldStack;
58 ArrayList m_genericParamStack;
59 IDictionary m_typeSpecTokenCache;
60 IDictionary m_memberRefTokenCache;
61
62 uint m_methodIndex;
63 uint m_fieldIndex;
64 uint m_paramIndex;
65 uint m_eventIndex;
66 uint m_propertyIndex;
67
68 MemoryBinaryWriter m_constWriter;
69
70 public StructureWriter StructureWriter {
71 get { return m_structureWriter; }
72 set {
73 m_structureWriter = value;
74
75 Initialize ();
76 }
77 }
78
79 public CodeWriter CodeWriter {
80 get { return m_codeWriter; }
81 }
82
83 public bool SaveSymbols {
84 get { return m_saveSymbols; }
85 set { m_saveSymbols = value; }
86 }
87
88 public string OutputFile
89 {
90 get { return m_asmOutput; }
91 set { m_asmOutput = value; }
92 }
93
94 public ISymbolWriter SymbolWriter {
95 get { return m_symbolWriter; }
96 set { m_symbolWriter = value; }
97 }
98
99 public SignatureWriter SignatureWriter {
100 get { return m_sigWriter; }
101 }
102
103 public MetadataWriter MetadataWriter {
104 get { return m_mdWriter; }
105 }
106
107 public MetadataTableWriter MetadataTableWriter {
108 get { return m_tableWriter; }
109 }
110
111 public MetadataRowWriter MetadataRowWriter {
112 get { return m_rowWriter; }
113 }
114
115 public ReflectionWriter (ModuleDefinition mod)
116 {
117 m_mod = mod;
118 }
119
120 void Initialize ()
121 {
122 m_mdWriter = new MetadataWriter (
123 m_mod.Assembly,
124 m_mod.Image.MetadataRoot,
125 m_structureWriter.Assembly.Kind,
126 m_mod.Assembly.Runtime,
127 m_structureWriter.GetWriter ());
128 m_tableWriter = m_mdWriter.GetTableVisitor ();
129 m_rowWriter = m_tableWriter.GetRowVisitor () as MetadataRowWriter;
130 m_sigWriter = new SignatureWriter (m_mdWriter);
131 m_codeWriter = new CodeWriter (this, m_mdWriter.CilWriter);
132
133 m_typeDefStack = new ArrayList ();
134 m_methodStack = new ArrayList ();
135 m_fieldStack = new ArrayList ();
136 m_genericParamStack = new ArrayList ();
137 m_typeSpecTokenCache = new Hashtable ();
138 m_memberRefTokenCache = new Hashtable ();
139
140 m_methodIndex = 1;
141 m_fieldIndex = 1;
142 m_paramIndex = 1;
143 m_eventIndex = 1;
144 m_propertyIndex = 1;
145
146 m_constWriter = new MemoryBinaryWriter ();
147 }
148
149 public TypeReference GetCoreType (string name)
150 {
151 return m_mod.Controller.Reader.SearchCoreType (name);
152 }
153
154 public static uint GetRidFor (IMetadataTokenProvider tp)
155 {
156 return tp.MetadataToken.RID;
157 }
158
159 public uint GetRidFor (AssemblyNameReference asmName)
160 {
161 return (uint) m_mod.AssemblyReferences.IndexOf (asmName) + 1;
162 }
163
164 public uint GetRidFor (ModuleDefinition mod)
165 {
166 return (uint) m_mod.Assembly.Modules.IndexOf (mod) + 1;
167 }
168
169 public uint GetRidFor (ModuleReference modRef)
170 {
171 return (uint) m_mod.ModuleReferences.IndexOf (modRef) + 1;
172 }
173
174 static bool IsTypeSpec (TypeReference type)
175 {
176 return type is TypeSpecification || type is GenericParameter;
177 }
178
179 public MetadataToken GetTypeDefOrRefToken (TypeReference type)
180 {
181 if (IsTypeSpec (type)) {
182 uint sig = m_sigWriter.AddTypeSpec (GetTypeSpecSig (type));
183 if (m_typeSpecTokenCache.Contains (sig))
184 return (MetadataToken) m_typeSpecTokenCache [sig];
185
186 TypeSpecTable tsTable = m_tableWriter.GetTypeSpecTable ();
187 TypeSpecRow tsRow = m_rowWriter.CreateTypeSpecRow (sig);
188 tsTable.Rows.Add (tsRow);
189
190 MetadataToken token = new MetadataToken (TokenType.TypeSpec, (uint) tsTable.Rows.Count);
191 if (! (type is GenericParameter))
192 type.MetadataToken = token;
193
194 m_typeSpecTokenCache [sig] = token;
195 return token;
196 } else if (type != null)
197 return type.MetadataToken;
198 else // <Module> and interfaces
199 return new MetadataToken (TokenType.TypeRef, 0);
200 }
201
202 public MetadataToken GetMemberRefToken (MemberReference member)
203 {
204 if (member is MethodSpecification)
205 return GetMemberRefToken (((MethodSpecification) member).ElementMethod);
206 if (member is IMemberDefinition)
207 return member.MetadataToken;
208 if (m_memberRefTokenCache.Contains (member))
209 return (MetadataToken) m_memberRefTokenCache [member];
210
211 MemberRefTable mrTable = m_tableWriter.GetMemberRefTable ();
212
213 uint sig = 0;
214 if (member is FieldReference)
215 sig = m_sigWriter.AddFieldSig (GetFieldSig ((FieldReference) member));
216 else if (member is MethodReference)
217 sig = m_sigWriter.AddMethodRefSig (GetMethodRefSig ((MethodReference) member));
218
219 MetadataToken declaringType = GetTypeDefOrRefToken (member.DeclaringType);
220 uint name = m_mdWriter.AddString (member.Name);
221
222 for (int i = 0; i < mrTable.Rows.Count; i++) {
223 MemberRefRow row = mrTable [i];
224 if (row.Class == declaringType && row.Name == name && row.Signature == sig)
225 return MetadataToken.FromMetadataRow (TokenType.MemberRef, i);
226 }
227
228 MemberRefRow mrRow = m_rowWriter.CreateMemberRefRow (
229 declaringType,
230 name,
231 sig);
232
233 mrTable.Rows.Add (mrRow);
234 member.MetadataToken = new MetadataToken (
235 TokenType.MemberRef, (uint) mrTable.Rows.Count);
236 m_memberRefTokenCache [member] = member.MetadataToken;
237 return member.MetadataToken;
238 }
239
240 public MetadataToken GetMethodSpecToken (GenericInstanceMethod gim)
241 {
242 uint sig = m_sigWriter.AddMethodSpec (GetMethodSpecSig (gim));
243 MethodSpecTable msTable = m_tableWriter.GetMethodSpecTable ();
244
245 MetadataToken meth = GetMemberRefToken (gim.ElementMethod);
246
247 for (int i = 0; i < msTable.Rows.Count; i++) {
248 MethodSpecRow row = msTable [i];
249 if (row.Method == meth && row.Instantiation == sig)
250 return MetadataToken.FromMetadataRow (TokenType.MethodSpec, i);
251 }
252
253 MethodSpecRow msRow = m_rowWriter.CreateMethodSpecRow (
254 meth,
255 sig);
256 msTable.Rows.Add (msRow);
257 gim.MetadataToken = new MetadataToken (TokenType.MethodSpec, (uint) msTable.Rows.Count);
258 return gim.MetadataToken;
259 }
260
261 public override void VisitModuleDefinition (ModuleDefinition mod)
262 {
263 mod.FullLoad ();
264 }
265
266 public override void VisitTypeDefinitionCollection (TypeDefinitionCollection types)
267 {
268 TypeDefTable tdTable = m_tableWriter.GetTypeDefTable ();
269
270 if (types [Constants.ModuleType] == null)
271 types.Add (new TypeDefinition (
272 Constants.ModuleType, string.Empty, TypeAttributes.NotPublic));
273
274 foreach (TypeDefinition t in types)
275 m_typeDefStack.Add (t);
276
277 m_typeDefStack.Sort (TableComparers.TypeDef.Instance);
278
279 for (int i = 0; i < m_typeDefStack.Count; i++) {
280 TypeDefinition t = (TypeDefinition) m_typeDefStack [i];
281 if (t.Module.Assembly != m_mod.Assembly)
282 throw new ReflectionException ("A type as not been correctly imported");
283
284 t.MetadataToken = new MetadataToken (TokenType.TypeDef, (uint) (i + 1));
285 }
286
287 foreach (TypeDefinition t in m_typeDefStack) {
288 TypeDefRow tdRow = m_rowWriter.CreateTypeDefRow (
289 t.Attributes,
290 m_mdWriter.AddString (t.Name),
291 m_mdWriter.AddString (t.Namespace),
292 GetTypeDefOrRefToken (t.BaseType),
293 0,
294 0);
295
296 tdTable.Rows.Add (tdRow);
297 }
298 }
299
300 public void CompleteTypeDefinitions ()
301 {
302 TypeDefTable tdTable = m_tableWriter.GetTypeDefTable ();
303
304 for (int i = 0; i < m_typeDefStack.Count; i++) {
305 TypeDefRow tdRow = tdTable [i];
306 TypeDefinition t = (TypeDefinition) m_typeDefStack [i];
307 tdRow.FieldList = m_fieldIndex;
308 tdRow.MethodList = m_methodIndex;
309 if (t.HasFields) {
310 foreach (FieldDefinition field in t.Fields)
311 VisitFieldDefinition (field);
312 }
313 if (t.HasConstructors) {
314 foreach (MethodDefinition ctor in t.Constructors)
315 VisitMethodDefinition (ctor);
316 }
317 if (t.HasMethods) {
318 foreach (MethodDefinition meth in t.Methods)
319 VisitMethodDefinition (meth);
320 }
321
322 if (t.HasLayoutInfo)
323 WriteLayout (t);
324 }
325
326 foreach (FieldDefinition field in m_fieldStack) {
327 if (field.HasCustomAttributes)
328 VisitCustomAttributeCollection (field.CustomAttributes);
329 if (field.MarshalSpec != null)
330 VisitMarshalSpec (field.MarshalSpec);
331 }
332
333 foreach (MethodDefinition meth in m_methodStack) {
334 if (meth.ReturnType.HasCustomAttributes)
335 VisitCustomAttributeCollection (meth.ReturnType.CustomAttributes);
336 if (meth.HasParameters) {
337 foreach (ParameterDefinition param in meth.Parameters) {
338 if (param.HasCustomAttributes)
339 VisitCustomAttributeCollection (param.CustomAttributes);
340 }
341 }
342 if (meth.HasGenericParameters)
343 VisitGenericParameterCollection (meth.GenericParameters);
344 if (meth.HasOverrides)
345 VisitOverrideCollection (meth.Overrides);
346 if (meth.HasCustomAttributes)
347 VisitCustomAttributeCollection (meth.CustomAttributes);
348 if (meth.HasSecurityDeclarations)
349 VisitSecurityDeclarationCollection (meth.SecurityDeclarations);
350 if (meth.PInvokeInfo != null) {
351 meth.Attributes |= MethodAttributes.PInvokeImpl;
352 VisitPInvokeInfo (meth.PInvokeInfo);
353 }
354 }
355
356 foreach (TypeDefinition t in m_typeDefStack)
357 t.Accept (this);
358 }
359
360 public override void VisitTypeReferenceCollection (TypeReferenceCollection refs)
361 {
362 ArrayList orderedTypeRefs = new ArrayList (refs.Count);
363 foreach (TypeReference tr in refs)
364 orderedTypeRefs.Add (tr);
365
366 orderedTypeRefs.Sort (TableComparers.TypeRef.Instance);
367
368 TypeRefTable trTable = m_tableWriter.GetTypeRefTable ();
369 foreach (TypeReference t in orderedTypeRefs) {
370 MetadataToken scope;
371
372 if (t.Module.Assembly != m_mod.Assembly)
373 throw new ReflectionException ("A type as not been correctly imported");
374
375 if (t.Scope == null)
376 continue;
377
378 if (t.DeclaringType != null)
379 scope = new MetadataToken (TokenType.TypeRef, GetRidFor (t.DeclaringType));
380 else if (t.Scope is AssemblyNameReference)
381 scope = new MetadataToken (TokenType.AssemblyRef,
382 GetRidFor ((AssemblyNameReference) t.Scope));
383 else if (t.Scope is ModuleDefinition)
384 scope = new MetadataToken (TokenType.Module,
385 GetRidFor ((ModuleDefinition) t.Scope));
386 else if (t.Scope is ModuleReference)
387 scope = new MetadataToken (TokenType.ModuleRef,
388 GetRidFor ((ModuleReference) t.Scope));
389 else
390 scope = new MetadataToken (TokenType.ExportedType, 0);
391
392 TypeRefRow trRow = m_rowWriter.CreateTypeRefRow (
393 scope,
394 m_mdWriter.AddString (t.Name),
395 m_mdWriter.AddString (t.Namespace));
396
397 trTable.Rows.Add (trRow);
398 t.MetadataToken = new MetadataToken (TokenType.TypeRef, (uint) trTable.Rows.Count);
399 }
400 }
401
402 public override void VisitGenericParameterCollection (GenericParameterCollection parameters)
403 {
404 if (parameters.Count == 0)
405 return;
406
407 foreach (GenericParameter gp in parameters)
408 m_genericParamStack.Add (gp);
409 }
410
411 public override void VisitInterfaceCollection (InterfaceCollection interfaces)
412 {
413 if (interfaces.Count == 0)
414 return;
415
416 InterfaceImplTable iiTable = m_tableWriter.GetInterfaceImplTable ();
417 foreach (TypeReference interf in interfaces) {
418 InterfaceImplRow iiRow = m_rowWriter.CreateInterfaceImplRow (
419 GetRidFor (interfaces.Container),
420 GetTypeDefOrRefToken (interf));
421
422 iiTable.Rows.Add (iiRow);
423 }
424 }
425
426 public override void VisitExternTypeCollection (ExternTypeCollection externs)
427 {
428 if (externs.Count == 0)
429 return;
430
431 ExportedTypeTable etTable = m_tableWriter.GetExportedTypeTable ();
432 foreach (TypeReference ext in externs) {
433 TypeDefinition td = ext.Resolve ();
434 if (td == null)
435 continue;
436
437 MetadataToken scope = GetExportedTypeScope (td);
438
439 ExportedTypeRow etRow = m_rowWriter.CreateExportedTypeRow (
440 td.Attributes,
441 0,
442 m_mdWriter.AddString (td.Name),
443 m_mdWriter.AddString (td.Namespace),
444 scope);
445
446 etTable.Rows.Add (etRow);
447 ext.MetadataToken = new MetadataToken (TokenType.ExportedType, (uint) etTable.Rows.Count);
448 }
449 }
450
451 MetadataToken GetExportedTypeScope (TypeDefinition t)
452 {
453 if (t.DeclaringType != null)
454 return t.DeclaringType.MetadataToken;
455
456 if (t.Scope is AssemblyNameReference)
457 return new MetadataToken (TokenType.AssemblyRef, GetRidFor ((AssemblyNameReference) t.Scope));
458
459 if (t.Scope is ModuleDefinition)
460 return new MetadataToken (TokenType.Module, GetRidFor ((ModuleDefinition) t.Scope));
461
462 throw new NotImplementedException ();
463 }
464
465 public override void VisitOverrideCollection (OverrideCollection meths)
466 {
467 if (meths.Count == 0)
468 return;
469
470 MethodImplTable miTable = m_tableWriter.GetMethodImplTable ();
471 foreach (MethodReference ov in meths) {
472 MethodImplRow miRow = m_rowWriter.CreateMethodImplRow (
473 GetRidFor (meths.Container.DeclaringType as TypeDefinition),
474 new MetadataToken (TokenType.Method, GetRidFor (meths.Container)),
475 GetMemberRefToken (ov));
476
477 miTable.Rows.Add (miRow);
478 }
479 }
480
481 public override void VisitNestedTypeCollection (NestedTypeCollection nestedTypes)
482 {
483 if (nestedTypes.Count == 0)
484 return;
485
486 NestedClassTable ncTable = m_tableWriter.GetNestedClassTable ();
487 foreach (TypeDefinition nested in nestedTypes) {
488 NestedClassRow ncRow = m_rowWriter.CreateNestedClassRow (
489 nested.MetadataToken.RID,
490 GetRidFor (nestedTypes.Container));
491
492 ncTable.Rows.Add (ncRow);
493 }
494 }
495
496 public override void VisitParameterDefinitionCollection (ParameterDefinitionCollection parameters)
497 {
498 if (parameters.Count == 0)
499 return;
500
501 ushort seq = 1;
502 ParamTable pTable = m_tableWriter.GetParamTable ();
503 foreach (ParameterDefinition param in parameters)
504 InsertParameter (pTable, param, seq++);
505 }
506
507 void InsertParameter (ParamTable pTable, ParameterDefinition param, ushort seq)
508 {
509 ParamRow pRow = m_rowWriter.CreateParamRow (
510 param.Attributes,
511 seq,
512 m_mdWriter.AddString (param.Name));
513
514 pTable.Rows.Add (pRow);
515 param.MetadataToken = new MetadataToken (TokenType.Param, (uint) pTable.Rows.Count);
516
517 if (param.MarshalSpec != null)
518 param.MarshalSpec.Accept (this);
519
520 if (param.HasConstant)
521 WriteConstant (param, param.ParameterType);
522
523 m_paramIndex++;
524 }
525
526 static bool RequiresParameterRow (MethodReturnType mrt)
527 {
528 return mrt.HasConstant || mrt.MarshalSpec != null ||
529 mrt.CustomAttributes.Count > 0 || mrt.Parameter.Attributes != (ParameterAttributes) 0;
530 }
531
532 public override void VisitMethodDefinition (MethodDefinition method)
533 {
534 MethodTable mTable = m_tableWriter.GetMethodTable ();
535 MethodRow mRow = m_rowWriter.CreateMethodRow (
536 RVA.Zero,
537 method.ImplAttributes,
538 method.Attributes,
539 m_mdWriter.AddString (method.Name),
540 m_sigWriter.AddMethodDefSig (GetMethodDefSig (method)),
541 m_paramIndex);
542
543 mTable.Rows.Add (mRow);
544 m_methodStack.Add (method);
545 method.MetadataToken = new MetadataToken (TokenType.Method, (uint) mTable.Rows.Count);
546 m_methodIndex++;
547
548 if (RequiresParameterRow (method.ReturnType))
549 InsertParameter (m_tableWriter.GetParamTable (), method.ReturnType.Parameter, 0);
550
551 VisitParameterDefinitionCollection (method.Parameters);
552 }
553
554 public override void VisitPInvokeInfo (PInvokeInfo pinvk)
555 {
556 ImplMapTable imTable = m_tableWriter.GetImplMapTable ();
557 ImplMapRow imRow = m_rowWriter.CreateImplMapRow (
558 pinvk.Attributes,
559 new MetadataToken (TokenType.Method, GetRidFor (pinvk.Method)),
560 m_mdWriter.AddString (pinvk.EntryPoint),
561 GetRidFor (pinvk.Module));
562
563 imTable.Rows.Add (imRow);
564 }
565
566 public override void VisitEventDefinitionCollection (EventDefinitionCollection events)
567 {
568 if (events.Count == 0)
569 return;
570
571 EventMapTable emTable = m_tableWriter.GetEventMapTable ();
572 EventMapRow emRow = m_rowWriter.CreateEventMapRow (
573 GetRidFor (events.Container),
574 m_eventIndex);
575
576 emTable.Rows.Add (emRow);
577 VisitCollection (events);
578 }
579
580 public override void VisitEventDefinition (EventDefinition evt)
581 {
582 EventTable eTable = m_tableWriter.GetEventTable ();
583 EventRow eRow = m_rowWriter.CreateEventRow (
584 evt.Attributes,
585 m_mdWriter.AddString (evt.Name),
586 GetTypeDefOrRefToken (evt.EventType));
587
588 eTable.Rows.Add (eRow);
589 evt.MetadataToken = new MetadataToken (TokenType.Event, (uint) eTable.Rows.Count);
590
591 if (evt.AddMethod != null)
592 WriteSemantic (MethodSemanticsAttributes.AddOn, evt, evt.AddMethod);
593
594 if (evt.InvokeMethod != null)
595 WriteSemantic (MethodSemanticsAttributes.Fire, evt, evt.InvokeMethod);
596
597 if (evt.RemoveMethod != null)
598 WriteSemantic (MethodSemanticsAttributes.RemoveOn, evt, evt.RemoveMethod);
599
600 m_eventIndex++;
601 }
602
603 public override void VisitFieldDefinition (FieldDefinition field)
604 {
605 FieldTable fTable = m_tableWriter.GetFieldTable ();
606 FieldRow fRow = m_rowWriter.CreateFieldRow (
607 field.Attributes,
608 m_mdWriter.AddString (field.Name),
609 m_sigWriter.AddFieldSig (GetFieldSig (field)));
610
611 fTable.Rows.Add (fRow);
612 field.MetadataToken = new MetadataToken (TokenType.Field, (uint) fTable.Rows.Count);
613 m_fieldIndex++;
614
615 if (field.HasConstant)
616 WriteConstant (field, field.FieldType);
617
618 if (field.HasLayoutInfo)
619 WriteLayout (field);
620
621 m_fieldStack.Add (field);
622 }
623
624 public override void VisitPropertyDefinitionCollection (PropertyDefinitionCollection properties)
625 {
626 if (properties.Count == 0)
627 return;
628
629 PropertyMapTable pmTable = m_tableWriter.GetPropertyMapTable ();
630 PropertyMapRow pmRow = m_rowWriter.CreatePropertyMapRow (
631 GetRidFor (properties.Container),
632 m_propertyIndex);
633
634 pmTable.Rows.Add (pmRow);
635 VisitCollection (properties);
636 }
637
638 public override void VisitPropertyDefinition (PropertyDefinition property)
639 {
640 PropertyTable pTable = m_tableWriter.GetPropertyTable ();
641 PropertyRow pRow = m_rowWriter.CreatePropertyRow (
642 property.Attributes,
643 m_mdWriter.AddString (property.Name),
644 m_sigWriter.AddPropertySig (GetPropertySig (property)));
645
646 pTable.Rows.Add (pRow);
647 property.MetadataToken = new MetadataToken (TokenType.Property, (uint) pTable.Rows.Count);
648
649 if (property.GetMethod != null)
650 WriteSemantic (MethodSemanticsAttributes.Getter, property, property.GetMethod);
651
652 if (property.SetMethod != null)
653 WriteSemantic (MethodSemanticsAttributes.Setter, property, property.SetMethod);
654
655 if (property.HasConstant)
656 WriteConstant (property, property.PropertyType);
657
658 m_propertyIndex++;
659 }
660
661 public override void VisitSecurityDeclarationCollection (SecurityDeclarationCollection secDecls)
662 {
663 if (secDecls.Count == 0)
664 return;
665
666 DeclSecurityTable dsTable = m_tableWriter.GetDeclSecurityTable ();
667 foreach (SecurityDeclaration secDec in secDecls) {
668 DeclSecurityRow dsRow = m_rowWriter.CreateDeclSecurityRow (
669 secDec.Action,
670 secDecls.Container.MetadataToken,
671 m_mdWriter.AddBlob (secDec.Resolved ?
672 m_mod.GetAsByteArray (secDec) : secDec.Blob));
673
674 dsTable.Rows.Add (dsRow);
675 }
676 }
677
678 public override void VisitCustomAttributeCollection (CustomAttributeCollection customAttrs)
679 {
680 if (customAttrs.Count == 0)
681 return;
682
683 CustomAttributeTable caTable = m_tableWriter.GetCustomAttributeTable ();
684 foreach (CustomAttribute ca in customAttrs) {
685 MetadataToken parent;
686 if (customAttrs.Container is AssemblyDefinition)
687 parent = new MetadataToken (TokenType.Assembly, 1);
688 else if (customAttrs.Container is ModuleDefinition)
689 parent = new MetadataToken (TokenType.Module, 1);
690 else if (customAttrs.Container is IMetadataTokenProvider)
691 parent = ((IMetadataTokenProvider) customAttrs.Container).MetadataToken;
692 else
693 throw new ReflectionException ("Unknown Custom Attribute parent");
694
695 uint value = ca.Resolved ?
696 m_sigWriter.AddCustomAttribute (GetCustomAttributeSig (ca), ca.Constructor) :
697 m_mdWriter.AddBlob (m_mod.GetAsByteArray (ca));
698 CustomAttributeRow caRow = m_rowWriter.CreateCustomAttributeRow (
699 parent,
700 GetMemberRefToken (ca.Constructor),
701 value);
702
703 caTable.Rows.Add (caRow);
704 }
705 }
706
707 public override void VisitMarshalSpec (MarshalSpec marshalSpec)
708 {
709 FieldMarshalTable fmTable = m_tableWriter.GetFieldMarshalTable ();
710 FieldMarshalRow fmRow = m_rowWriter.CreateFieldMarshalRow (
711 marshalSpec.Container.MetadataToken,
712 m_sigWriter.AddMarshalSig (GetMarshalSig (marshalSpec)));
713
714 fmTable.Rows.Add (fmRow);
715 }
716
717 void WriteConstant (IHasConstant hc, TypeReference type)
718 {
719 ConstantTable cTable = m_tableWriter.GetConstantTable ();
720 ElementType et;
721 if (type is TypeDefinition && (type as TypeDefinition).IsEnum) {
722 Type t = hc.Constant.GetType ();
723 if (t.IsEnum)
724 t = Enum.GetUnderlyingType (t);
725
726 et = GetCorrespondingType (string.Concat (t.Namespace, '.', t.Name));
727 } else
728 et = GetCorrespondingType (type.FullName);
729
730 if (et == ElementType.Object || et == ElementType.Type || et == ElementType.String)
731 et = hc.Constant == null ?
732 ElementType.Class :
733 GetCorrespondingType (hc.Constant.GetType ().FullName);
734
735 ConstantRow cRow = m_rowWriter.CreateConstantRow (
736 et,
737 hc.MetadataToken,
738 m_mdWriter.AddBlob (EncodeConstant (et, hc.Constant)));
739
740 cTable.Rows.Add (cRow);
741 }
742
743 void WriteLayout (FieldDefinition field)
744 {
745 FieldLayoutTable flTable = m_tableWriter.GetFieldLayoutTable ();
746 FieldLayoutRow flRow = m_rowWriter.CreateFieldLayoutRow (
747 field.Offset,
748 GetRidFor (field));
749
750 flTable.Rows.Add (flRow);
751 }
752
753 void WriteLayout (TypeDefinition type)
754 {
755 ClassLayoutTable clTable = m_tableWriter.GetClassLayoutTable ();
756 ClassLayoutRow clRow = m_rowWriter.CreateClassLayoutRow (
757 type.PackingSize,
758 type.ClassSize,
759 GetRidFor (type));
760
761 clTable.Rows.Add (clRow);
762 }
763
764 void WriteSemantic (MethodSemanticsAttributes attrs,
765 IMetadataTokenProvider member, MethodDefinition meth)
766 {
767 MethodSemanticsTable msTable = m_tableWriter.GetMethodSemanticsTable ();
768 MethodSemanticsRow msRow = m_rowWriter.CreateMethodSemanticsRow (
769 attrs,
770 GetRidFor (meth),
771 member.MetadataToken);
772
773 msTable.Rows.Add (msRow);
774 }
775
776 void SortTables ()
777 {
778 TablesHeap th = m_mdWriter.GetMetadataRoot ().Streams.TablesHeap;
779 th.Sorted = 0;
780
781 if (th.HasTable (NestedClassTable.RId))
782 m_tableWriter.GetNestedClassTable ().Rows.Sort (
783 TableComparers.NestedClass.Instance);
784 th.Sorted |= ((long) 1 << NestedClassTable.RId);
785
786 if (th.HasTable (InterfaceImplTable.RId))
787 m_tableWriter.GetInterfaceImplTable ().Rows.Sort (
788 TableComparers.InterfaceImpl.Instance);
789 th.Sorted |= ((long) 1 << InterfaceImplTable.RId);
790
791 if (th.HasTable (ConstantTable.RId))
792 m_tableWriter.GetConstantTable ().Rows.Sort (
793 TableComparers.Constant.Instance);
794 th.Sorted |= ((long) 1 << ConstantTable.RId);
795
796 if (th.HasTable (MethodSemanticsTable.RId))
797 m_tableWriter.GetMethodSemanticsTable ().Rows.Sort (
798 TableComparers.MethodSem.Instance);
799 th.Sorted |= ((long) 1 << MethodSemanticsTable.RId);
800
801 if (th.HasTable (FieldMarshalTable.RId))
802 m_tableWriter.GetFieldMarshalTable ().Rows.Sort (
803 TableComparers.FieldMarshal.Instance);
804 th.Sorted |= ((long) 1 << FieldMarshalTable.RId);
805
806 if (th.HasTable (ClassLayoutTable.RId))
807 m_tableWriter.GetClassLayoutTable ().Rows.Sort (
808 TableComparers.TypeLayout.Instance);
809 th.Sorted |= ((long) 1 << ClassLayoutTable.RId);
810
811 if (th.HasTable (FieldLayoutTable.RId))
812 m_tableWriter.GetFieldLayoutTable ().Rows.Sort (
813 TableComparers.FieldLayout.Instance);
814 th.Sorted |= ((long) 1 << FieldLayoutTable.RId);
815
816 if (th.HasTable (ImplMapTable.RId))
817 m_tableWriter.GetImplMapTable ().Rows.Sort (
818 TableComparers.PInvoke.Instance);
819 th.Sorted |= ((long) 1 << ImplMapTable.RId);
820
821 if (th.HasTable (FieldRVATable.RId))
822 m_tableWriter.GetFieldRVATable ().Rows.Sort (
823 TableComparers.FieldRVA.Instance);
824 th.Sorted |= ((long) 1 << FieldRVATable.RId);
825
826 if (th.HasTable (MethodImplTable.RId))
827 m_tableWriter.GetMethodImplTable ().Rows.Sort (
828 TableComparers.Override.Instance);
829 th.Sorted |= ((long) 1 << MethodImplTable.RId);
830
831 if (th.HasTable (CustomAttributeTable.RId))
832 m_tableWriter.GetCustomAttributeTable ().Rows.Sort (
833 TableComparers.CustomAttribute.Instance);
834 th.Sorted |= ((long) 1 << CustomAttributeTable.RId);
835
836 if (th.HasTable (DeclSecurityTable.RId))
837 m_tableWriter.GetDeclSecurityTable ().Rows.Sort (
838 TableComparers.SecurityDeclaration.Instance);
839 th.Sorted |= ((long) 1 << DeclSecurityTable.RId);
840 }
841
842 void CompleteGenericTables ()
843 {
844 if (m_genericParamStack.Count == 0)
845 return;
846
847 TablesHeap th = m_mdWriter.GetMetadataRoot ().Streams.TablesHeap;
848 GenericParamTable gpTable = m_tableWriter.GetGenericParamTable ();
849
850 m_genericParamStack.Sort (TableComparers.GenericParam.Instance);
851
852 foreach (GenericParameter gp in m_genericParamStack) {
853 GenericParamRow gpRow = m_rowWriter.CreateGenericParamRow (
854 (ushort) gp.Owner.GenericParameters.IndexOf (gp),
855 gp.Attributes,
856 gp.Owner.MetadataToken,
857 m_mdWriter.AddString (gp.Name));
858
859 gpTable.Rows.Add (gpRow);
860 gp.MetadataToken = new MetadataToken (TokenType.GenericParam, (uint) gpTable.Rows.Count);
861
862 if (gp.HasCustomAttributes)
863 VisitCustomAttributeCollection (gp.CustomAttributes);
864
865 if (!gp.HasConstraints)
866 continue;
867
868 GenericParamConstraintTable gpcTable = m_tableWriter.GetGenericParamConstraintTable ();
869
870 foreach (TypeReference constraint in gp.Constraints) {
871 GenericParamConstraintRow gpcRow = m_rowWriter.CreateGenericParamConstraintRow (
872 (uint) gpTable.Rows.Count,
873 GetTypeDefOrRefToken (constraint));
874
875 gpcTable.Rows.Add (gpcRow);
876 }
877 }
878
879 th.Sorted |= ((long) 1 << GenericParamTable.RId);
880 th.Sorted |= ((long) 1 << GenericParamConstraintTable.RId);
881 }
882
883 public override void TerminateModuleDefinition (ModuleDefinition module)
884 {
885 if (module.Assembly.HasCustomAttributes)
886 VisitCustomAttributeCollection (module.Assembly.CustomAttributes);
887 if (module.Assembly.HasSecurityDeclarations)
888 VisitSecurityDeclarationCollection (module.Assembly.SecurityDeclarations);
889 if (module.HasCustomAttributes)
890 VisitCustomAttributeCollection (module.CustomAttributes);
891
892 if (module.ExternTypes.Count > 0)
893 VisitExternTypeCollection (module.ExternTypes);
894
895 CompleteGenericTables ();
896 SortTables ();
897
898 MethodTable mTable = m_tableWriter.GetMethodTable ();
899 for (int i = 0; i < m_methodStack.Count; i++) {
900 MethodDefinition meth = (MethodDefinition) m_methodStack [i];
901 if (meth.HasBody)
902 mTable [i].RVA = m_codeWriter.WriteMethodBody (meth);
903 }
904
905 if (m_fieldStack.Count > 0) {
906 FieldRVATable frTable = null;
907 foreach (FieldDefinition field in m_fieldStack) {
908 if (field.InitialValue != null && field.InitialValue.Length > 0) {
909 if (frTable == null)
910 frTable = m_tableWriter.GetFieldRVATable ();
911
912 FieldRVARow frRow = m_rowWriter.CreateFieldRVARow (
913 m_mdWriter.GetDataCursor (),
914 field.MetadataToken.RID);
915
916 m_mdWriter.AddData (field.InitialValue.Length + 3 & (~3));
917 m_mdWriter.AddFieldInitData (field.InitialValue);
918
919 frTable.Rows.Add (frRow);
920 }
921 }
922 }
923
924 if (m_symbolWriter != null)
925 m_symbolWriter.Dispose ();
926
927 if (m_mod.Assembly.EntryPoint != null)
928 m_mdWriter.EntryPointToken =
929 ((uint) TokenType.Method) | GetRidFor (m_mod.Assembly.EntryPoint);
930
931 m_mod.Image.MetadataRoot.Accept (m_mdWriter);
932 }
933
934 public static ElementType GetCorrespondingType (string fullName)
935 {
936 switch (fullName) {
937 case Constants.Boolean :
938 return ElementType.Boolean;
939 case Constants.Char :
940 return ElementType.Char;
941 case Constants.SByte :
942 return ElementType.I1;
943 case Constants.Int16 :
944 return ElementType.I2;
945 case Constants.Int32 :
946 return ElementType.I4;
947 case Constants.Int64 :
948 return ElementType.I8;
949 case Constants.Byte :
950 return ElementType.U1;
951 case Constants.UInt16 :
952 return ElementType.U2;
953 case Constants.UInt32 :
954 return ElementType.U4;
955 case Constants.UInt64 :
956 return ElementType.U8;
957 case Constants.Single :
958 return ElementType.R4;
959 case Constants.Double :
960 return ElementType.R8;
961 case Constants.String :
962 return ElementType.String;
963 case Constants.Type :
964 return ElementType.Type;
965 case Constants.Object :
966 return ElementType.Object;
967 default:
968 return ElementType.Class;
969 }
970 }
971
972 byte [] EncodeConstant (ElementType et, object value)
973 {
974 m_constWriter.Empty ();
975
976 if (value == null)
977 et = ElementType.Class;
978
979 IConvertible ic = value as IConvertible;
980 IFormatProvider fp = CultureInfo.CurrentCulture.NumberFormat;
981
982 switch (et) {
983 case ElementType.Boolean :
984 m_constWriter.Write ((byte) (ic.ToBoolean (fp) ? 1 : 0));
985 break;
986 case ElementType.Char :
987 m_constWriter.Write ((ushort) ic.ToChar (fp));
988 break;
989 case ElementType.I1 :
990 m_constWriter.Write (ic.ToSByte (fp));
991 break;
992 case ElementType.I2 :
993 m_constWriter.Write (ic.ToInt16 (fp));
994 break;
995 case ElementType.I4 :
996 m_constWriter.Write (ic.ToInt32 (fp));
997 break;
998 case ElementType.I8 :
999 m_constWriter.Write (ic.ToInt64 (fp));
1000 break;
1001 case ElementType.U1 :
1002 m_constWriter.Write (ic.ToByte (fp));
1003 break;
1004 case ElementType.U2 :
1005 m_constWriter.Write (ic.ToUInt16 (fp));
1006 break;
1007 case ElementType.U4 :
1008 m_constWriter.Write (ic.ToUInt32 (fp));
1009 break;
1010 case ElementType.U8 :
1011 m_constWriter.Write (ic.ToUInt64 (fp));
1012 break;
1013 case ElementType.R4 :
1014 m_constWriter.Write (ic.ToSingle (fp));
1015 break;
1016 case ElementType.R8 :
1017 m_constWriter.Write (ic.ToDouble (fp));
1018 break;
1019 case ElementType.String :
1020 m_constWriter.Write (Encoding.Unicode.GetBytes ((string) value));
1021 break;
1022 case ElementType.Class :
1023 m_constWriter.Write (new byte [4]);
1024 break;
1025 default :
1026 throw new ArgumentException ("Non valid element for a constant");
1027 }
1028
1029 return m_constWriter.ToArray ();
1030 }
1031
1032 public SigType GetSigType (TypeReference type)
1033 {
1034 string name = type.FullName;
1035
1036 switch (name) {
1037 case Constants.Void :
1038 return new SigType (ElementType.Void);
1039 case Constants.Object :
1040 return new SigType (ElementType.Object);
1041 case Constants.Boolean :
1042 return new SigType (ElementType.Boolean);
1043 case Constants.String :
1044 return new SigType (ElementType.String);
1045 case Constants.Char :
1046 return new SigType (ElementType.Char);
1047 case Constants.SByte :
1048 return new SigType (ElementType.I1);
1049 case Constants.Byte :
1050 return new SigType (ElementType.U1);
1051 case Constants.Int16 :
1052 return new SigType (ElementType.I2);
1053 case Constants.UInt16 :
1054 return new SigType (ElementType.U2);
1055 case Constants.Int32 :
1056 return new SigType (ElementType.I4);
1057 case Constants.UInt32 :
1058 return new SigType (ElementType.U4);
1059 case Constants.Int64 :
1060 return new SigType (ElementType.I8);
1061 case Constants.UInt64 :
1062 return new SigType (ElementType.U8);
1063 case Constants.Single :
1064 return new SigType (ElementType.R4);
1065 case Constants.Double :
1066 return new SigType (ElementType.R8);
1067 case Constants.IntPtr :
1068 return new SigType (ElementType.I);
1069 case Constants.UIntPtr :
1070 return new SigType (ElementType.U);
1071 case Constants.TypedReference :
1072 return new SigType (ElementType.TypedByRef);
1073 }
1074
1075 if (type is GenericParameter) {
1076 GenericParameter gp = type as GenericParameter;
1077 int pos = gp.Owner.GenericParameters.IndexOf (gp);
1078 if (gp.Owner is TypeReference)
1079 return new VAR (pos);
1080 else if (gp.Owner is MethodReference)
1081 return new MVAR (pos);
1082 else
1083 throw new ReflectionException ("Unkown generic parameter type");
1084 } else if (type is GenericInstanceType) {
1085 GenericInstanceType git = type as GenericInstanceType;
1086 GENERICINST gi = new GENERICINST ();
1087 gi.ValueType = git.IsValueType;
1088 gi.Type = GetTypeDefOrRefToken (git.ElementType);
1089 gi.Signature = new GenericInstSignature ();
1090 gi.Signature.Arity = git.GenericArguments.Count;
1091 gi.Signature.Types = new GenericArg [gi.Signature.Arity];
1092 for (int i = 0; i < git.GenericArguments.Count; i++)
1093 gi.Signature.Types [i] = GetGenericArgSig (git.GenericArguments [i]);
1094
1095 return gi;
1096 } else if (type is ArrayType) {
1097 ArrayType aryType = type as ArrayType;
1098 if (aryType.IsSizedArray) {
1099 SZARRAY szary = new SZARRAY ();
1100 szary.CustomMods = GetCustomMods (aryType.ElementType);
1101 szary.Type = GetSigType (aryType.ElementType);
1102 return szary;
1103 }
1104
1105 // not optimized
1106 ArrayShape shape = new ArrayShape ();
1107 shape.Rank = aryType.Dimensions.Count;
1108 shape.NumSizes = 0;
1109
1110 for (int i = 0; i < shape.Rank; i++) {
1111 ArrayDimension dim = aryType.Dimensions [i];
1112 if (dim.UpperBound > 0)
1113 shape.NumSizes++;
1114 }
1115
1116 shape.Sizes = new int [shape.NumSizes];
1117 shape.NumLoBounds = shape.Rank;
1118 shape.LoBounds = new int [shape.NumLoBounds];
1119
1120 for (int i = 0; i < shape.Rank; i++) {
1121 ArrayDimension dim = aryType.Dimensions [i];
1122 shape.LoBounds [i] = dim.LowerBound;
1123 if (dim.UpperBound > 0)
1124 shape.Sizes [i] = dim.UpperBound - dim.LowerBound + 1;
1125 }
1126
1127 ARRAY ary = new ARRAY ();
1128 ary.Shape = shape;
1129 ary.CustomMods = GetCustomMods (aryType.ElementType);
1130 ary.Type = GetSigType (aryType.ElementType);
1131 return ary;
1132 } else if (type is PointerType) {
1133 PTR p = new PTR ();
1134 TypeReference elementType = (type as PointerType).ElementType;
1135 p.Void = elementType.FullName == Constants.Void;
1136 if (!p.Void) {
1137 p.CustomMods = GetCustomMods (elementType);
1138 p.PtrType = GetSigType (elementType);
1139 }
1140 return p;
1141 } else if (type is FunctionPointerType) {
1142 FNPTR fp = new FNPTR ();
1143 FunctionPointerType fptr = type as FunctionPointerType;
1144
1145 int sentinel = fptr.GetSentinel ();
1146 if (sentinel < 0)
1147 fp.Method = GetMethodDefSig (fptr);
1148 else
1149 fp.Method = GetMethodRefSig (fptr);
1150
1151 return fp;
1152 } else if (type is TypeSpecification) {
1153 return GetSigType ((type as TypeSpecification).ElementType);
1154 } else if (type.IsValueType) {
1155 VALUETYPE vt = new VALUETYPE ();
1156 vt.Type = GetTypeDefOrRefToken (type);
1157 return vt;
1158 } else {
1159 CLASS c = new CLASS ();
1160 c.Type = GetTypeDefOrRefToken (type);
1161 return c;
1162 }
1163 }
1164
1165 public GenericArg GetGenericArgSig (TypeReference type)
1166 {
1167 GenericArg arg = new GenericArg (GetSigType (type));
1168 arg.CustomMods = GetCustomMods (type);
1169 return arg;
1170 }
1171
1172 public CustomMod [] GetCustomMods (TypeReference type)
1173 {
1174 ModType modifier = type as ModType;
1175 if (modifier == null)
1176 return CustomMod.EmptyCustomMod;
1177
1178 ArrayList cmods = new ArrayList ();
1179 do {
1180 CustomMod cmod = new CustomMod ();
1181 cmod.TypeDefOrRef = GetTypeDefOrRefToken (modifier.ModifierType);
1182
1183 if (modifier is ModifierOptional)
1184 cmod.CMOD = CustomMod.CMODType.OPT;
1185 else if (modifier is ModifierRequired)
1186 cmod.CMOD = CustomMod.CMODType.REQD;
1187
1188 cmods.Add (cmod);
1189 modifier = modifier.ElementType as ModType;
1190 } while (modifier != null);
1191
1192 return cmods.ToArray (typeof (CustomMod)) as CustomMod [];
1193 }
1194
1195 public Signature GetMemberRefSig (MemberReference member)
1196 {
1197 if (member is FieldReference)
1198 return GetFieldSig (member as FieldReference);
1199 else
1200 return GetMemberRefSig (member as MethodReference);
1201 }
1202
1203 public FieldSig GetFieldSig (FieldReference field)
1204 {
1205 FieldSig sig = new FieldSig ();
1206 sig.CallingConvention |= 0x6;
1207 sig.Field = true;
1208 sig.CustomMods = GetCustomMods (field.FieldType);
1209 sig.Type = GetSigType (field.FieldType);
1210 return sig;
1211 }
1212
1213 Param [] GetParametersSig (ParameterDefinitionCollection parameters)
1214 {
1215 Param [] ret = new Param [parameters.Count];
1216 for (int i = 0; i < ret.Length; i++) {
1217 ParameterDefinition pDef = parameters [i];
1218 Param p = new Param ();
1219 p.CustomMods = GetCustomMods (pDef.ParameterType);
1220 if (pDef.ParameterType.FullName == Constants.TypedReference)
1221 p.TypedByRef = true;
1222 else if (IsByReferenceType (pDef.ParameterType)) {
1223 p.ByRef = true;
1224 p.Type = GetSigType (pDef.ParameterType);
1225 } else
1226 p.Type = GetSigType (pDef.ParameterType);
1227 ret [i] = p;
1228 }
1229 return ret;
1230 }
1231
1232 void CompleteMethodSig (IMethodSignature meth, MethodSig sig)
1233 {
1234 sig.HasThis = meth.HasThis;
1235 sig.ExplicitThis = meth.ExplicitThis;
1236 if (sig.HasThis)
1237 sig.CallingConvention |= 0x20;
1238 if (sig.ExplicitThis)
1239 sig.CallingConvention |= 0x40;
1240
1241 if ((meth.CallingConvention & MethodCallingConvention.VarArg) != 0)
1242 sig.CallingConvention |= 0x5;
1243
1244 sig.ParamCount = meth.Parameters.Count;
1245 sig.Parameters = GetParametersSig (meth.Parameters);
1246
1247 RetType rtSig = new RetType ();
1248 rtSig.CustomMods = GetCustomMods (meth.ReturnType.ReturnType);
1249
1250 if (meth.ReturnType.ReturnType.FullName == Constants.Void)
1251 rtSig.Void = true;
1252 else if (meth.ReturnType.ReturnType.FullName == Constants.TypedReference)
1253 rtSig.TypedByRef = true;
1254 else if (IsByReferenceType (meth.ReturnType.ReturnType)) {
1255 rtSig.ByRef = true;
1256 rtSig.Type = GetSigType (meth.ReturnType.ReturnType);
1257 } else
1258 rtSig.Type = GetSigType (meth.ReturnType.ReturnType);
1259
1260 sig.RetType = rtSig;
1261 }
1262
1263 static bool IsByReferenceType (TypeReference type)
1264 {
1265 TypeSpecification ts = type as TypeSpecification;
1266 while (ts != null) {
1267 if (ts is ReferenceType)
1268 return true;
1269 ts = ts.ElementType as TypeSpecification;
1270 }
1271 return false;
1272 }
1273
1274 public MethodRefSig GetMethodRefSig (IMethodSignature meth)
1275 {
1276 MethodReference methodRef = meth as MethodReference;
1277 if (methodRef != null && methodRef.GenericParameters.Count > 0)
1278 return GetMethodDefSig (meth);
1279
1280 MethodRefSig methSig = new MethodRefSig ();
1281
1282 CompleteMethodSig (meth, methSig);
1283
1284 int sentinel = meth.GetSentinel ();
1285 if (sentinel >= 0)
1286 methSig.Sentinel = sentinel;
1287
1288 if ((meth.CallingConvention & MethodCallingConvention.C) != 0)
1289 methSig.CallingConvention |= 0x1;
1290 else if ((meth.CallingConvention & MethodCallingConvention.StdCall) != 0)
1291 methSig.CallingConvention |= 0x2;
1292 else if ((meth.CallingConvention & MethodCallingConvention.ThisCall) != 0)
1293 methSig.CallingConvention |= 0x3;
1294 else if ((meth.CallingConvention & MethodCallingConvention.FastCall) != 0)
1295 methSig.CallingConvention |= 0x4;
1296
1297 return methSig;
1298 }
1299
1300 public MethodDefSig GetMethodDefSig (IMethodSignature meth)
1301 {
1302 MethodDefSig sig = new MethodDefSig ();
1303
1304 CompleteMethodSig (meth, sig);
1305
1306 MethodReference methodRef = meth as MethodReference;
1307 if (methodRef != null && methodRef.GenericParameters.Count > 0) {
1308 sig.CallingConvention |= 0x10;
1309 sig.GenericParameterCount = methodRef.GenericParameters.Count;
1310 }
1311
1312 return sig;
1313 }
1314
1315 public PropertySig GetPropertySig (PropertyDefinition prop)
1316 {
1317 PropertySig ps = new PropertySig ();
1318 ps.CallingConvention |= 0x8;
1319
1320 bool hasThis;
1321 bool explicitThis;
1322 MethodCallingConvention mcc;
1323 ParameterDefinitionCollection parameters = prop.Parameters;
1324
1325 MethodDefinition meth;
1326 if (prop.GetMethod != null)
1327 meth = prop.GetMethod;
1328 else if (prop.SetMethod != null)
1329 meth = prop.SetMethod;
1330 else
1331 meth = null;
1332
1333 if (meth != null) {
1334 hasThis = meth.HasThis;
1335 explicitThis = meth.ExplicitThis;
1336 mcc = meth.CallingConvention;
1337 } else {
1338 hasThis = explicitThis = false;
1339 mcc = MethodCallingConvention.Default;
1340 }
1341
1342 if (hasThis)
1343 ps.CallingConvention |= 0x20;
1344 if (explicitThis)
1345 ps.CallingConvention |= 0x40;
1346
1347 if ((mcc & MethodCallingConvention.VarArg) != 0)
1348 ps.CallingConvention |= 0x5;
1349
1350 int paramCount = parameters != null ? parameters.Count : 0;
1351
1352 ps.ParamCount = paramCount;
1353 ps.Parameters = GetParametersSig (parameters);
1354 ps.CustomMods = GetCustomMods (prop.PropertyType);
1355 ps.Type = GetSigType (prop.PropertyType);
1356
1357 return ps;
1358 }
1359
1360 public TypeSpec GetTypeSpecSig (TypeReference type)
1361 {
1362 TypeSpec ts = new TypeSpec ();
1363 ts.CustomMods = GetCustomMods (type);
1364 ts.Type = GetSigType (type);
1365 return ts;
1366 }
1367
1368 public MethodSpec GetMethodSpecSig (GenericInstanceMethod gim)
1369 {
1370 GenericInstSignature gis = new GenericInstSignature ();
1371 gis.Arity = gim.GenericArguments.Count;
1372 gis.Types = new GenericArg [gis.Arity];
1373 for (int i = 0; i < gis.Arity; i++)
1374 gis.Types [i] = GetGenericArgSig (gim.GenericArguments [i]);
1375
1376 return new MethodSpec (gis);
1377 }
1378
1379 static string GetObjectTypeName (object o)
1380 {
1381 Type t = o.GetType ();
1382 return string.Concat (t.Namespace, ".", t.Name);
1383 }
1384
1385 static CustomAttrib.Elem CreateElem (TypeReference type, object value)
1386 {
1387 CustomAttrib.Elem elem = new CustomAttrib.Elem ();
1388 elem.Value = value;
1389 elem.ElemType = type;
1390 elem.FieldOrPropType = GetCorrespondingType (type.FullName);
1391
1392 switch (elem.FieldOrPropType) {
1393 case ElementType.Boolean :
1394 case ElementType.Char :
1395 case ElementType.R4 :
1396 case ElementType.R8 :
1397 case ElementType.I1 :
1398 case ElementType.I2 :
1399 case ElementType.I4 :
1400 case ElementType.I8 :
1401 case ElementType.U1 :
1402 case ElementType.U2 :
1403 case ElementType.U4 :
1404 case ElementType.U8 :
1405 elem.Simple = true;
1406 break;
1407 case ElementType.String:
1408 elem.String = true;
1409 break;
1410 case ElementType.Type:
1411 elem.Type = true;
1412 break;
1413 case ElementType.Object:
1414 elem.BoxedValueType = true;
1415 if (value == null)
1416 elem.FieldOrPropType = ElementType.String;
1417 else
1418 elem.FieldOrPropType = GetCorrespondingType (
1419 GetObjectTypeName (value));
1420 break;
1421 }
1422
1423 return elem;
1424 }
1425
1426 static CustomAttrib.FixedArg CreateFixedArg (TypeReference type, object value)
1427 {
1428 CustomAttrib.FixedArg fa = new CustomAttrib.FixedArg ();
1429 if (value is object []) {
1430 fa.SzArray = true;
1431 object [] values = value as object [];
1432 TypeReference obj = ((ArrayType) type).ElementType;
1433 fa.NumElem = (uint) values.Length;
1434 fa.Elems = new CustomAttrib.Elem [values.Length];
1435 for (int i = 0; i < values.Length; i++)
1436 fa.Elems [i] = CreateElem (obj, values [i]);
1437 } else {
1438 fa.Elems = new CustomAttrib.Elem [1];
1439 fa.Elems [0] = CreateElem (type, value);
1440 }
1441
1442 return fa;
1443 }
1444
1445 static CustomAttrib.NamedArg CreateNamedArg (TypeReference type, string name,
1446 object value, bool field)
1447 {
1448 CustomAttrib.NamedArg na = new CustomAttrib.NamedArg ();
1449 na.Field = field;
1450 na.Property = !field;
1451
1452 na.FieldOrPropName = name;
1453 na.FieldOrPropType = GetCorrespondingType (type.FullName);
1454 na.FixedArg = CreateFixedArg (type, value);
1455
1456 return na;
1457 }
1458
1459 public static CustomAttrib GetCustomAttributeSig (CustomAttribute ca)
1460 {
1461 CustomAttrib cas = new CustomAttrib (ca.Constructor);
1462 cas.Prolog = CustomAttrib.StdProlog;
1463
1464 cas.FixedArgs = new CustomAttrib.FixedArg [ca.Constructor.Parameters.Count];
1465
1466 for (int i = 0; i < cas.FixedArgs.Length; i++)
1467 cas.FixedArgs [i] = CreateFixedArg (
1468 ca.Constructor.Parameters [i].ParameterType, ca.ConstructorParameters [i]);
1469
1470 int nn = ca.Fields.Count + ca.Properties.Count;
1471 cas.NumNamed = (ushort) nn;
1472 cas.NamedArgs = new CustomAttrib.NamedArg [nn];
1473
1474 if (cas.NamedArgs.Length > 0) {
1475 int curs = 0;
1476 foreach (DictionaryEntry entry in ca.Fields) {
1477 string field = (string) entry.Key;
1478 cas.NamedArgs [curs++] = CreateNamedArg (
1479 ca.GetFieldType (field), field, entry.Value, true);
1480 }
1481
1482 foreach (DictionaryEntry entry in ca.Properties) {
1483 string property = (string) entry.Key;
1484 cas.NamedArgs [curs++] = CreateNamedArg (
1485 ca.GetPropertyType (property), property, entry.Value, false);
1486 }
1487 }
1488
1489 return cas;
1490 }
1491
1492 static MarshalSig GetMarshalSig (MarshalSpec mSpec)
1493 {
1494 MarshalSig ms = new MarshalSig (mSpec.NativeIntrinsic);
1495
1496 if (mSpec is ArrayMarshalSpec) {
1497 ArrayMarshalSpec amd = mSpec as ArrayMarshalSpec;
1498 MarshalSig.Array ar = new MarshalSig.Array ();
1499 ar.ArrayElemType = amd.ElemType;
1500 ar.NumElem = amd.NumElem;
1501 ar.ParamNum = amd.ParamNum;
1502 ar.ElemMult = amd.ElemMult;
1503 ms.Spec = ar;
1504 } else if (mSpec is CustomMarshalerSpec) {
1505 CustomMarshalerSpec cmd = mSpec as CustomMarshalerSpec;
1506 MarshalSig.CustomMarshaler cm = new MarshalSig.CustomMarshaler ();
1507 cm.Guid = cmd.Guid.ToString ();
1508 cm.UnmanagedType = cmd.UnmanagedType;
1509 cm.ManagedType = cmd.ManagedType;
1510 cm.Cookie = cmd.Cookie;
1511 ms.Spec = cm;
1512 } else if (mSpec is FixedArraySpec) {
1513 FixedArraySpec fad = mSpec as FixedArraySpec;
1514 MarshalSig.FixedArray fa = new MarshalSig.FixedArray ();
1515 fa.ArrayElemType = fad.ElemType;
1516 fa.NumElem = fad.NumElem;
1517 ms.Spec = fa;
1518 } else if (mSpec is FixedSysStringSpec) {
1519 MarshalSig.FixedSysString fss = new MarshalSig.FixedSysString ();
1520 fss.Size = (mSpec as FixedSysStringSpec).Size;
1521 ms.Spec = fss;
1522 } else if (mSpec is SafeArraySpec) {
1523 MarshalSig.SafeArray sa = new MarshalSig.SafeArray ();
1524 sa.ArrayElemType = (mSpec as SafeArraySpec).ElemType;
1525 ms.Spec = sa;
1526 }
1527
1528 return ms;
1529 }
1530
1531 public void WriteSymbols (ModuleDefinition module)
1532 {
1533 if (!m_saveSymbols)
1534 return;
1535
1536 if (m_asmOutput == null)
1537 m_asmOutput = module.Assembly.Name.Name + "." + (module.Assembly.Kind == AssemblyKind.Dll ? "dll" : "exe");
1538
1539 if (m_symbolWriter == null)
1540 m_symbolWriter = SymbolStoreHelper.GetWriter (module, m_asmOutput);
1541
1542 foreach (TypeDefinition type in module.Types) {
1543 if (type.HasMethods) {
1544 foreach (MethodDefinition method in type.Methods)
1545 WriteSymbols (method);
1546 }
1547 if (type.HasConstructors) {
1548 foreach (MethodDefinition ctor in type.Constructors)
1549 WriteSymbols (ctor);
1550 }
1551 }
1552
1553 m_symbolWriter.Dispose ();
1554 }
1555
1556 void WriteSymbols (MethodDefinition meth)
1557 {
1558 if (!meth.HasBody)
1559 return;
1560
1561 m_symbolWriter.Write (meth.Body);
1562 }
1563 }
1564 }