?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2010-05-31 Jb Evain <jbevain@novell.com>
[mcs.git] / tools / linker / Mono.Linker.Steps / MarkStep.cs
blob745ed9483335a66b15995bca02c0022d512b3250
1 //
2 // MarkStep.cs
3 //
4 // Author:
5 // Jb Evain (jbevain@gmail.com)
6 //
7 // (C) 2006 Jb Evain
8 // (C) 2007 Novell, Inc.
9 //
10 // Permission is hereby granted, free of charge, to any person obtaining
11 // a copy of this software and associated documentation files (the
12 // "Software"), to deal in the Software without restriction, including
13 // without limitation the rights to use, copy, modify, merge, publish,
14 // distribute, sublicense, and/or sell copies of the Software, and to
15 // permit persons to whom the Software is furnished to do so, subject to
16 // the following conditions:
17 //
18 // The above copyright notice and this permission notice shall be
19 // included in all copies or substantial portions of the Software.
20 //
21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
28 //
29
30 using System;
31 using System.Collections;
32 using Mono.Cecil;
33 using Mono.Cecil.Cil;
34
35 namespace Mono.Linker.Steps {
36
37 public class MarkStep : IStep {
38
39 LinkContext _context;
40 Queue _methods;
41 ArrayList _virtual_methods;
42
43 public MarkStep ()
44 {
45 _methods = new Queue ();
46 _virtual_methods = new ArrayList ();
47 }
48
49 public void Process (LinkContext context)
50 {
51 _context = context;
52
53 Initialize ();
54 Process ();
55 }
56
57 void Initialize ()
58 {
59 foreach (AssemblyDefinition assembly in _context.GetAssemblies ())
60 InitializeAssembly (assembly);
61 }
62
63 protected virtual void InitializeAssembly (AssemblyDefinition assembly)
64 {
65 MarkAssembly (assembly);
66 foreach (TypeDefinition type in assembly.MainModule.Types) {
67 if (!Annotations.IsMarked (type))
68 continue;
69
70 InitializeType (type);
71 }
72 }
73
74 void InitializeType (TypeDefinition type)
75 {
76 MarkType (type);
77
78 if (type.HasFields)
79 InitializeFields (type);
80 if (type.HasMethods)
81 InitializeMethods (type.Methods);
82 if (type.HasConstructors)
83 InitializeMethods (type.Constructors);
84 }
85
86 void InitializeFields (TypeDefinition type)
87 {
88 foreach (FieldDefinition field in type.Fields)
89 if (Annotations.IsMarked (field))
90 MarkField (field);
91 }
92
93 void InitializeMethods (ICollection methods)
94 {
95 foreach (MethodDefinition method in methods)
96 if (Annotations.IsMarked (method))
97 EnqueueMethod (method);
98 }
99
100 void Process ()
101 {
102 if (QueueIsEmpty ())
103 throw new InvalidOperationException ("No entry methods");
104
105 while (!QueueIsEmpty ()) {
106 ProcessQueue ();
107 ProcessVirtualMethods ();
108 }
109 }
110
111 void ProcessQueue ()
112 {
113 while (!QueueIsEmpty ()) {
114 MethodDefinition method = (MethodDefinition) _methods.Dequeue ();
115 ProcessMethod (method);
116 }
117 }
118
119 bool QueueIsEmpty ()
120 {
121 return _methods.Count == 0;
122 }
123
124 protected virtual void EnqueueMethod (MethodDefinition method)
125 {
126 _methods.Enqueue (method);
127 }
128
129 void ProcessVirtualMethods ()
130 {
131 foreach (MethodDefinition method in _virtual_methods)
132 ProcessVirtualMethod (method);
133 }
134
135 void ProcessVirtualMethod (MethodDefinition method)
136 {
137 IList overrides = Annotations.GetOverrides (method);
138 if (overrides == null)
139 return;
140
141 foreach (MethodDefinition @override in overrides)
142 ProcessOverride (@override);
143 }
144
145 void ProcessOverride (MethodDefinition method)
146 {
147 if (!Annotations.IsMarked (method.DeclaringType))
148 return;
149
150 if (Annotations.IsProcessed (method))
151 return;
152
153 if (Annotations.IsMarked (method))
154 return;
155
156 MarkMethod (method);
157 ProcessVirtualMethod (method);
158 }
159
160 void MarkMethodBody (MethodBody body)
161 {
162 foreach (VariableDefinition var in body.Variables)
163 MarkType (var.VariableType);
164
165 foreach (ExceptionHandler eh in body.ExceptionHandlers)
166 if (eh.Type == ExceptionHandlerType.Catch)
167 MarkType (eh.CatchType);
168
169 foreach (Instruction instruction in body.Instructions)
170 MarkInstruction (instruction);
171 }
172
173 void MarkMarshalSpec (IHasMarshalSpec spec)
174 {
175 CustomMarshalerSpec marshaler = spec.MarshalSpec as CustomMarshalerSpec;
176 if (marshaler == null)
177 return;
178
179 TypeDefinition type = _context.GetType (marshaler.ManagedType);
180 MarkType (type);
181 }
182
183 void MarkCustomAttributes (ICustomAttributeProvider provider)
184 {
185 if (!provider.HasCustomAttributes)
186 return;
187
188 foreach (CustomAttribute ca in provider.CustomAttributes)
189 MarkCustomAttribute (ca);
190 }
191
192 void MarkCustomAttribute (CustomAttribute ca)
193 {
194 MarkMethod (ca.Constructor);
195
196 if (!ca.Resolved) {
197 ca = ca.Clone ();
198 ca.Resolve ();
199 }
200
201 if (!ca.Resolved)
202 return;
203
204 MarkCustomAttributeParameters (ca);
205
206 TypeReference constructor_type = ca.Constructor.DeclaringType;
207 TypeDefinition type = constructor_type.Resolve ();
208 if (type == null)
209 throw new ResolutionException (constructor_type);
210
211 MarkCustomAttributeProperties (ca, type);
212 MarkCustomAttributeFields (ca, type);
213 }
214
215 void MarkCustomAttributeProperties (CustomAttribute ca, TypeDefinition attribute)
216 {
217 foreach (DictionaryEntry de in ca.Properties) {
218 string propertyname = (string) de.Key;
219
220 PropertyDefinition property = GetProperty (attribute, propertyname);
221 if (property != null)
222 MarkMethod (property.SetMethod);
223
224 TypeReference propType = ca.GetPropertyType (propertyname);
225 MarkIfType (propType, de.Value);
226 }
227 }
228
229 PropertyDefinition GetProperty (TypeDefinition type, string propertyname)
230 {
231 while (type != null) {
232 PropertyDefinition [] properties = type.Properties.GetProperties (propertyname);
233 if (properties != null && properties.Length != 0 && properties [0].SetMethod != null)
234 return properties [0];
235
236 type = type.BaseType != null ? ResolveTypeDefinition (type.BaseType) : null;
237 }
238
239 return null;
240 }
241
242 void MarkCustomAttributeFields (CustomAttribute ca, TypeDefinition attribute)
243 {
244 foreach (DictionaryEntry de in ca.Fields) {
245 string fieldname = (string) de.Key;
246
247 FieldDefinition field = GetField (attribute, fieldname);
248 if (field != null)
249 MarkField (field);
250
251 TypeReference fieldType = ca.GetFieldType (fieldname);
252 MarkIfType (fieldType, de.Value);
253 }
254 }
255
256 FieldDefinition GetField (TypeDefinition type, string fieldname)
257 {
258 while (type != null) {
259 FieldDefinition field = type.Fields.GetField (fieldname);
260 if (field != null)
261 return field;
262
263 type = type.BaseType != null ? ResolveTypeDefinition (type.BaseType) : null;
264 }
265
266 return null;
267 }
268
269 void MarkCustomAttributeParameters (CustomAttribute ca)
270 {
271 for (int i = 0; i < ca.Constructor.Parameters.Count; i++) {
272 ParameterDefinition param = ca.Constructor.Parameters [i];
273 MarkIfType (param.ParameterType, ca.ConstructorParameters [i]);
274 }
275 }
276
277 void MarkIfType (TypeReference slotType, object value)
278 {
279 if (slotType.FullName != Constants.Type)
280 return;
281
282 string type_name = (string) value;
283
284 try {
285 var type = TypeParser.ParseType (slotType.Module, type_name);
286 if (type == null)
287 return;
288
289 MarkType (type);
290 } catch {
291 return;
292 }
293 }
294
295 protected static bool CheckProcessed (IAnnotationProvider provider)
296 {
297 if (Annotations.IsProcessed (provider))
298 return true;
299
300 Annotations.Processed (provider);
301 return false;
302 }
303
304 void MarkAssembly (AssemblyDefinition assembly)
305 {
306 if (CheckProcessed (assembly))
307 return;
308
309 MarkCustomAttributes (assembly);
310
311 foreach (ModuleDefinition module in assembly.Modules)
312 MarkCustomAttributes (module);
313 }
314
315 void MarkField (FieldReference reference)
316 {
317 // if (IgnoreScope (reference.DeclaringType.Scope))
318 // return;
319
320 FieldDefinition field = ResolveFieldDefinition (reference);
321
322 if (field == null)
323 throw new ResolutionException (reference);
324
325 if (CheckProcessed (field))
326 return;
327
328 MarkType (field.DeclaringType);
329 MarkType (field.FieldType);
330 MarkCustomAttributes (field);
331 MarkMarshalSpec (field);
332
333 Annotations.Mark (field);
334 }
335
336 protected virtual bool IgnoreScope (IMetadataScope scope)
337 {
338 AssemblyDefinition assembly = ResolveAssembly (scope);
339 return Annotations.GetAction (assembly) != AssemblyAction.Link;
340 }
341
342 FieldDefinition ResolveFieldDefinition (FieldReference field)
343 {
344 FieldDefinition fd = field as FieldDefinition;
345 if (fd == null)
346 fd = field.Resolve ();
347
348 return fd;
349 }
350
351 void MarkScope (IMetadataScope scope)
352 {
353 IAnnotationProvider provider = scope as IAnnotationProvider;
354 if (provider == null)
355 return;
356
357 Annotations.Mark (provider);
358 }
359
360 protected virtual void MarkType (TypeReference reference)
361 {
362 if (reference == null)
363 return;
364
365 reference = GetOriginalType (reference);
366
367 if (reference is GenericParameter)
368 return;
369
370 // if (IgnoreScope (reference.Scope))
371 // return;
372
373 TypeDefinition type = ResolveTypeDefinition (reference);
374
375 if (type == null)
376 throw new ResolutionException (reference);
377
378 if (CheckProcessed (type))
379 return;
380
381 MarkScope (type.Scope);
382 MarkType (type.BaseType);
383 MarkType (type.DeclaringType);
384 MarkCustomAttributes (type);
385
386 if (IsMulticastDelegate (type)) {
387 MarkMethodCollection (type.Constructors);
388 MarkMethodCollection (type.Methods);
389 }
390
391 if (IsSerializable (type) && type.HasConstructors) {
392 MarkMethodsIf (type.Constructors, IsDefaultConstructorPredicate);
393 MarkMethodsIf (type.Constructors, IsSpecialSerializationConstructorPredicate);
394 }
395
396 MarkTypeSpecialCustomAttributes (type);
397
398 MarkGenericParameterProvider (type);
399
400 if (type.IsValueType)
401 MarkFields (type);
402
403 if (type.HasInterfaces) {
404 foreach (TypeReference iface in type.Interfaces)
405 MarkType (iface);
406 }
407
408 if (type.HasMethods)
409 MarkMethodsIf (type.Methods, IsVirtualAndHasPreservedParent);
410
411 if (type.HasConstructors)
412 MarkMethodsIf (type.Constructors, IsStaticConstructorPredicate);
413
414 Annotations.Mark (type);
415
416 ApplyPreserveInfo (type);
417 }
418
419 void MarkTypeSpecialCustomAttributes (TypeDefinition type)
420 {
421 if (!type.HasCustomAttributes)
422 return;
423
424 foreach (CustomAttribute attribute in type.CustomAttributes) {
425 switch (attribute.Constructor.DeclaringType.FullName) {
426 case "System.Xml.Serialization.XmlSchemaProviderAttribute":
427 MarkXmlSchemaProvider (type, attribute);
428 break;
429 }
430 }
431 }
432
433 void MarkMethodSpecialCustomAttributes (MethodDefinition method)
434 {
435 if (!method.HasCustomAttributes)
436 return;
437
438 foreach (CustomAttribute attribute in method.CustomAttributes) {
439 switch (attribute.Constructor.DeclaringType.FullName) {
440 case "System.Web.Services.Protocols.SoapHeaderAttribute":
441 MarkSoapHeader (method, attribute);
442 break;
443 }
444 }
445 }
446
447 void MarkXmlSchemaProvider (TypeDefinition type, CustomAttribute attribute)
448 {
449 string method_name;
450 if (!TryGetStringArgument (attribute, out method_name))
451 return;
452
453 MarkNamedMethod (type, method_name);
454 }
455
456 static bool TryGetStringArgument (CustomAttribute attribute, out string argument)
457 {
458 argument = null;
459
460 if (!attribute.Resolved || attribute.ConstructorParameters.Count < 1)
461 return false;
462
463 argument = attribute.ConstructorParameters [0] as string;
464
465 return argument != null;
466 }
467
468 void MarkNamedMethod (TypeDefinition type, string method_name)
469 {
470 if (!type.HasMethods)
471 return;
472
473 foreach (MethodDefinition method in type.Methods) {
474 if (method.Name != method_name)
475 continue;
476
477 MarkMethod (method);
478 }
479 }
480
481 void MarkSoapHeader (MethodDefinition method, CustomAttribute attribute)
482 {
483 string member_name;
484 if (!TryGetStringArgument (attribute, out member_name))
485 return;
486
487 MarkNamedField (method.DeclaringType, member_name);
488 MarkNamedProperty (method.DeclaringType, member_name);
489 }
490
491 void MarkNamedField (TypeDefinition type, string field_name)
492 {
493 if (!type.HasFields)
494 return;
495
496 foreach (FieldDefinition field in type.Fields) {
497 if (field.Name != field_name)
498 continue;
499
500 MarkField (field);
501 }
502 }
503
504 void MarkNamedProperty (TypeDefinition type, string property_name)
505 {
506 if (!type.HasProperties)
507 return;
508
509 foreach (PropertyDefinition property in type.Properties) {
510 if (property.Name != property_name)
511 continue;
512
513 MarkMethod (property.GetMethod);
514 MarkMethod (property.SetMethod);
515 }
516 }
517
518 void MarkGenericParameterProvider (IGenericParameterProvider provider)
519 {
520 if (!provider.HasGenericParameters)
521 return;
522
523 foreach (GenericParameter parameter in provider.GenericParameters)
524 MarkGenericParameter (parameter);
525 }
526
527 void MarkGenericParameter (GenericParameter parameter)
528 {
529 MarkCustomAttributes (parameter);
530 foreach (TypeReference constraint in parameter.Constraints)
531 MarkType (constraint);
532 }
533
534 bool IsVirtualAndHasPreservedParent (MethodDefinition method)
535 {
536 if (!method.IsVirtual)
537 return false;
538
539 var base_list = Annotations.GetBaseMethods (method);
540 if (base_list == null)
541 return false;
542
543 foreach (MethodDefinition @base in base_list) {
544 if (IgnoreScope (@base.DeclaringType.Scope))
545 return true;
546
547 if (IsVirtualAndHasPreservedParent (@base))
548 return true;
549 }
550
551 return false;
552 }
553
554 static MethodPredicate IsSpecialSerializationConstructorPredicate = new MethodPredicate (IsSpecialSerializationConstructor);
555
556 static bool IsSpecialSerializationConstructor (MethodDefinition method)
557 {
558 if (!IsConstructor (method))
559 return false;
560
561 ParameterDefinitionCollection parameters = method.Parameters;
562 if (parameters.Count != 2)
563 return false;
564
565 return parameters [0].ParameterType.Name == "SerializationInfo" &&
566 parameters [1].ParameterType.Name == "StreamingContext";
567 }
568
569 delegate bool MethodPredicate (MethodDefinition method);
570
571 void MarkMethodsIf (ICollection methods, MethodPredicate predicate)
572 {
573 foreach (MethodDefinition method in methods)
574 if (predicate (method))
575 MarkMethod (method);
576 }
577
578 static MethodPredicate IsDefaultConstructorPredicate = new MethodPredicate (IsDefaultConstructor);
579
580 static bool IsDefaultConstructor (MethodDefinition method)
581 {
582 return IsConstructor (method) && method.Parameters.Count == 0;
583 }
584
585 static bool IsConstructor (MethodDefinition method)
586 {
587 return method.Name == MethodDefinition.Ctor && method.IsSpecialName &&
588 method.IsRuntimeSpecialName;
589 }
590
591 static MethodPredicate IsStaticConstructorPredicate = new MethodPredicate (IsStaticConstructor);
592
593 static bool IsStaticConstructor (MethodDefinition method)
594 {
595 return method.Name == MethodDefinition.Cctor && method.IsSpecialName &&
596 method.IsRuntimeSpecialName;
597 }
598
599 static bool IsSerializable (TypeDefinition td)
600 {
601 return (td.Attributes & TypeAttributes.Serializable) != 0;
602 }
603
604 static bool IsMulticastDelegate (TypeDefinition td)
605 {
606 return td.BaseType != null && td.BaseType.FullName == "System.MulticastDelegate";
607 }
608
609 TypeDefinition ResolveTypeDefinition (TypeReference type)
610 {
611 TypeDefinition td = type as TypeDefinition;
612 if (td == null)
613 td = type.Resolve ();
614
615 return td;
616 }
617
618 protected TypeReference GetOriginalType (TypeReference type)
619 {
620 while (type is TypeSpecification) {
621 GenericInstanceType git = type as GenericInstanceType;
622 if (git != null)
623 MarkGenericArguments (git);
624
625 ModType mod = type as ModType;
626 if (mod != null)
627 MarkModifierType (mod);
628
629 type = ((TypeSpecification) type).ElementType;
630 }
631
632 return type;
633 }
634
635 void MarkModifierType (ModType mod)
636 {
637 MarkType (mod.ModifierType);
638 }
639
640 void MarkGenericArguments (IGenericInstance instance)
641 {
642 foreach (TypeReference argument in instance.GenericArguments)
643 MarkType (argument);
644
645 MarkGenericArgumentConstructors (instance);
646 }
647
648 void MarkGenericArgumentConstructors (IGenericInstance instance)
649 {
650 var arguments = instance.GenericArguments;
651
652 var generic_element = GetGenericProviderFromInstance (instance);
653 if (generic_element == null)
654 return;
655
656 var parameters = generic_element.GenericParameters;
657
658 if (arguments.Count != parameters.Count)
659 return;
660
661 for (int i = 0; i < arguments.Count; i++) {
662 var argument = arguments [i];
663 var parameter = parameters [i];
664
665 if (!parameter.HasDefaultConstructorConstraint)
666 continue;
667
668 var argument_definition = ResolveTypeDefinition (argument);
669 if (argument_definition == null)
670 continue;
671
672 MarkMethodsIf (argument_definition.Constructors, ctor => !ctor.IsStatic && !ctor.HasParameters);
673 }
674 }
675
676 IGenericParameterProvider GetGenericProviderFromInstance (IGenericInstance instance)
677 {
678 var method = instance as GenericInstanceMethod;
679 if (method != null)
680 return method.ElementMethod;
681
682 var type = instance as GenericInstanceType;
683 if (type != null)
684 return type.ElementType;
685
686 return null;
687 }
688
689 void ApplyPreserveInfo (TypeDefinition type)
690 {
691 ApplyPreserveMethods (type);
692
693 if (!Annotations.IsPreserved (type))
694 return;
695
696 switch (Annotations.GetPreserve (type)) {
697 case TypePreserve.All:
698 MarkFields (type);
699 MarkMethods (type);
700 break;
701 case TypePreserve.Fields:
702 MarkFields (type);
703 break;
704 case TypePreserve.Methods:
705 MarkMethods (type);
706 break;
707 }
708 }
709
710 void ApplyPreserveMethods (TypeDefinition type)
711 {
712 var list = Annotations.GetPreservedMethods (type);
713 if (list == null)
714 return;
715
716 foreach (MethodDefinition method in list)
717 MarkMethod (method);
718 }
719
720 void MarkFields (TypeDefinition type)
721 {
722 if (!type.HasFields)
723 return;
724
725 foreach (FieldDefinition field in type.Fields)
726 MarkField (field);
727 }
728
729 void MarkMethods (TypeDefinition type)
730 {
731 if (type.HasMethods)
732 MarkMethodCollection (type.Methods);
733 if (type.HasConstructors)
734 MarkMethodCollection (type.Constructors);
735 }
736
737 void MarkMethodCollection (IEnumerable methods)
738 {
739 foreach (MethodDefinition method in methods)
740 MarkMethod (method);
741 }
742
743 void MarkMethod (MethodReference reference)
744 {
745 reference = GetOriginalMethod (reference);
746
747 if (reference.DeclaringType is ArrayType)
748 return;
749
750 // if (IgnoreScope (reference.DeclaringType.Scope))
751 // return;
752
753 MethodDefinition method = ResolveMethodDefinition (reference);
754
755 if (method == null)
756 throw new ResolutionException (reference);
757
758 if (Annotations.GetAction (method) == MethodAction.Nothing)
759 Annotations.SetAction (method, MethodAction.Parse);
760
761 EnqueueMethod (method);
762 }
763
764 AssemblyDefinition ResolveAssembly (IMetadataScope scope)
765 {
766 AssemblyDefinition assembly = _context.Resolve (scope);
767 MarkAssembly (assembly);
768 return assembly;
769 }
770
771 MethodReference GetOriginalMethod (MethodReference method)
772 {
773 while (method is MethodSpecification) {
774 GenericInstanceMethod gim = method as GenericInstanceMethod;
775 if (gim != null)
776 MarkGenericArguments (gim);
777
778 method = ((MethodSpecification) method).ElementMethod;
779 }
780
781 return method;
782 }
783
784 MethodDefinition ResolveMethodDefinition (MethodReference method)
785 {
786 MethodDefinition md = method as MethodDefinition;
787 if (md == null)
788 md = method.Resolve ();
789
790 return md;
791 }
792
793 void ProcessMethod (MethodDefinition method)
794 {
795 if (CheckProcessed (method))
796 return;
797
798 MarkType (method.DeclaringType);
799 MarkCustomAttributes (method);
800
801 MarkGenericParameterProvider (method);
802
803 if (IsPropertyMethod (method))
804 MarkProperty (GetProperty (method));
805 else if (IsEventMethod (method))
806 MarkEvent (GetEvent (method));
807
808 if (method.HasParameters) {
809 foreach (ParameterDefinition pd in method.Parameters) {
810 MarkType (pd.ParameterType);
811 MarkCustomAttributes (pd);
812 MarkMarshalSpec (pd);
813 }
814 }
815
816 if (method.HasOverrides) {
817 foreach (MethodReference ov in method.Overrides)
818 MarkMethod (ov);
819 }
820
821 MarkMethodSpecialCustomAttributes (method);
822
823 if (method.IsVirtual)
824 _virtual_methods.Add (method);
825
826 MarkBaseMethods (method);
827
828 MarkType (method.ReturnType.ReturnType);
829 MarkCustomAttributes (method.ReturnType);
830 MarkMarshalSpec (method.ReturnType);
831
832 if (ShouldParseMethodBody (method))
833 MarkMethodBody (method.Body);
834
835 Annotations.Mark (method);
836 }
837
838 void MarkBaseMethods (MethodDefinition method)
839 {
840 IList base_methods = Annotations.GetBaseMethods (method);
841 if (base_methods == null)
842 return;
843
844 foreach (MethodDefinition base_method in base_methods) {
845 MarkMethod (base_method);
846 MarkBaseMethods (base_method);
847 }
848 }
849
850 bool ShouldParseMethodBody (MethodDefinition method)
851 {
852 if (!method.HasBody)
853 return false;
854
855 AssemblyDefinition assembly = ResolveAssembly (method.DeclaringType.Scope);
856 return (Annotations.GetAction (method) == MethodAction.ForceParse ||
857 (Annotations.GetAction (assembly) == AssemblyAction.Link && Annotations.GetAction (method) == MethodAction.Parse));
858 }
859
860 static bool IsPropertyMethod (MethodDefinition md)
861 {
862 return (md.SemanticsAttributes & MethodSemanticsAttributes.Getter) != 0 ||
863 (md.SemanticsAttributes & MethodSemanticsAttributes.Setter) != 0;
864 }
865
866 static bool IsEventMethod (MethodDefinition md)
867 {
868 return (md.SemanticsAttributes & MethodSemanticsAttributes.AddOn) != 0 ||
869 (md.SemanticsAttributes & MethodSemanticsAttributes.Fire) != 0 ||
870 (md.SemanticsAttributes & MethodSemanticsAttributes.RemoveOn) != 0;
871 }
872
873 static PropertyDefinition GetProperty (MethodDefinition md)
874 {
875 TypeDefinition declaringType = (TypeDefinition) md.DeclaringType;
876 foreach (PropertyDefinition prop in declaringType.Properties)
877 if (prop.GetMethod == md || prop.SetMethod == md)
878 return prop;
879
880 return null;
881 }
882
883 static EventDefinition GetEvent (MethodDefinition md)
884 {
885 TypeDefinition declaringType = (TypeDefinition) md.DeclaringType;
886 foreach (EventDefinition evt in declaringType.Events)
887 if (evt.AddMethod == md || evt.InvokeMethod == md || evt.RemoveMethod == md)
888 return evt;
889
890 return null;
891 }
892
893 void MarkProperty (PropertyDefinition prop)
894 {
895 MarkCustomAttributes (prop);
896 }
897
898 void MarkEvent (EventDefinition evt)
899 {
900 MarkCustomAttributes (evt);
901 MarkMethodIfNotNull (evt.AddMethod);
902 MarkMethodIfNotNull (evt.InvokeMethod);
903 MarkMethodIfNotNull (evt.RemoveMethod);
904 }
905
906 void MarkMethodIfNotNull (MethodReference method)
907 {
908 if (method == null)
909 return;
910
911 MarkMethod (method);
912 }
913
914 void MarkInstruction (Instruction instruction)
915 {
916 switch (instruction.OpCode.OperandType) {
917 case OperandType.InlineField:
918 MarkField ((FieldReference) instruction.Operand);
919 break;
920 case OperandType.InlineMethod:
921 MarkMethod ((MethodReference) instruction.Operand);
922 break;
923 case OperandType.InlineTok:
924 object token = instruction.Operand;
925 if (token is TypeReference)
926 MarkType ((TypeReference) token);
927 else if (token is MethodReference)
928 MarkMethod ((MethodReference) token);
929 else
930 MarkField ((FieldReference) token);
931 break;
932 case OperandType.InlineType:
933 MarkType ((TypeReference) instruction.Operand);
934 break;
935 default:
936 break;
937 }
938 }
939 }
940 }
git-svn mirror of mcs