tools/linker/Mono.Linker.Steps/MarkStep.cs

   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 _queue;
  41
  42                 public MarkStep ()
  43                 {
  44                         _queue = new Queue ();
  45                 }
  46
  47                 public void Process (LinkContext context)
  48                 {
  49                         _context = context;
  50
  51                         Initialize ();
  52                         Process ();
  53                 }
  54
  55                 void Initialize ()
  56                 {
  57                         foreach (AssemblyDefinition assembly in _context.GetAssemblies ())
  58                                 InitializeAssembly (assembly);
  59                 }
  60
  61                 void InitializeAssembly (AssemblyDefinition assembly)
  62                 {
  63                         MarkAssembly (assembly);
  64                         foreach (TypeDefinition type in assembly.MainModule.Types) {
  65                                 if (!Annotations.IsMarked (type))
  66                                         continue;
  67
  68                                 InitializeType (type);
  69                         }
  70                 }
  71
  72                 void InitializeType (TypeDefinition type)
  73                 {
  74                         MarkType (type);
  75
  76                         if (type.HasFields)
  77                                 InitializeFields (type);
  78                         if (type.HasMethods)
  79                                 InitializeMethods (type.Methods);
  80                         if (type.HasConstructors)
  81                                 InitializeMethods (type.Constructors);
  82                 }
  83
  84                 void InitializeFields (TypeDefinition type)
  85                 {
  86                         foreach (FieldDefinition field in type.Fields)
  87                                 if (Annotations.IsMarked (field))
  88                                         MarkField (field);
  89                 }
  90
  91                 void InitializeMethods (ICollection methods)
  92                 {
  93                         foreach (MethodDefinition method in methods)
  94                                 if (Annotations.IsMarked (method))
  95                                         _queue.Enqueue (method);
  96                 }
  97
  98                 void Process ()
  99                 {
 100                         if (QueueIsEmpty ())
 101                                 throw new InvalidOperationException ("No entry methods");
 102
 103                         while (!QueueIsEmpty ()) {
 104                                 MethodDefinition method = (MethodDefinition) _queue.Dequeue ();
 105                                 ProcessMethod (method);
 106                         }
 107                 }
 108
 109                 bool QueueIsEmpty ()
 110                 {
 111                         return _queue.Count == 0;
 112                 }
 113
 114                 void MarkMethodBody (MethodBody body)
 115                 {
 116                         foreach (VariableDefinition var in body.Variables)
 117                                 MarkType (var.VariableType);
 118
 119                         foreach (ExceptionHandler eh in body.ExceptionHandlers)
 120                                 if (eh.Type == ExceptionHandlerType.Catch)
 121                                         MarkType (eh.CatchType);
 122
 123                         foreach (Instruction instruction in body.Instructions)
 124                                 MarkInstruction (instruction);
 125                 }
 126
 127                 void MarkMarshalSpec (IHasMarshalSpec spec)
 128                 {
 129                         CustomMarshalerSpec marshaler = spec.MarshalSpec as CustomMarshalerSpec;
 130                         if (marshaler == null)
 131                                 return;
 132
 133                         TypeDefinition type = _context.GetType (marshaler.ManagedType);
 134                         MarkType (type);
 135                 }
 136
 137                 void MarkCustomAttributes (ICustomAttributeProvider provider)
 138                 {
 139                         if (!provider.HasCustomAttributes)
 140                                 return;
 141
 142                         foreach (CustomAttribute ca in provider.CustomAttributes)
 143                                 MarkCustomAttribute (ca);
 144                 }
 145
 146                 void MarkCustomAttribute (CustomAttribute ca)
 147                 {
 148                         MarkMethod (ca.Constructor);
 149
 150                         if (!ca.Resolved) {
 151                                 ca = ca.Clone ();
 152                                 ca.Resolve ();
 153                         }
 154
 155                         if (!ca.Resolved)
 156                                 return;
 157
 158                         MarkCustomAttributeParameters (ca);
 159
 160                         TypeDefinition type = ca.Constructor.DeclaringType.Resolve ();
 161
 162                         MarkCustomAttributeProperties (ca, type);
 163                         MarkCustomAttributeFields (ca, type);
 164                 }
 165
 166                 void MarkCustomAttributeProperties (CustomAttribute ca, TypeDefinition attribute)
 167                 {
 168                         foreach (DictionaryEntry de in ca.Properties) {
 169                                 string propertyname = (string) de.Key;
 170
 171                                 PropertyDefinition [] properties = attribute.Properties.GetProperties (propertyname);
 172
 173                                 if (properties != null && properties.Length != 0 && properties [0].SetMethod != null)
 174                                         MarkMethod (properties [0].SetMethod);
 175
 176                                 TypeReference propType = ca.GetPropertyType (propertyname);
 177                                 MarkIfType (propType, de.Value);
 178                         }
 179                 }
 180
 181                 void MarkCustomAttributeFields (CustomAttribute ca, TypeDefinition attribute)
 182                 {
 183                         foreach (DictionaryEntry de in ca.Fields) {
 184                                 string fieldname = (string) de.Key;
 185
 186                                 FieldDefinition field = attribute.Fields.GetField (fieldname);
 187                                 if (field != null)
 188                                         MarkField (field);
 189
 190                                 TypeReference fieldType = ca.GetFieldType (fieldname);
 191                                 MarkIfType (fieldType, de.Value);
 192                         }
 193                 }
 194
 195                 void MarkCustomAttributeParameters (CustomAttribute ca)
 196                 {
 197                         for (int i = 0; i < ca.Constructor.Parameters.Count; i++) {
 198                                 ParameterDefinition param = ca.Constructor.Parameters [i];
 199                                 MarkIfType (param.ParameterType, ca.ConstructorParameters [i]);
 200                         }
 201                 }
 202
 203                 void MarkIfType (TypeReference slotType, object value)
 204                 {
 205                         if (slotType.FullName != Constants.Type)
 206                                 return;
 207
 208                         TypeDefinition type = _context.GetType ((string) value);
 209
 210                         MarkType (type);
 211                 }
 212
 213                 static bool CheckProcessed (IAnnotationProvider provider)
 214                 {
 215                         if (Annotations.IsProcessed (provider))
 216                                 return true;
 217
 218                         Annotations.Processed (provider);
 219                         return false;
 220                 }
 221
 222                 void MarkAssembly (AssemblyDefinition assembly)
 223                 {
 224                         if (CheckProcessed (assembly))
 225                                 return;
 226
 227                         MarkCustomAttributes (assembly);
 228
 229                         foreach (ModuleDefinition module in assembly.Modules)
 230                                 MarkCustomAttributes (module);
 231                 }
 232
 233                 void MarkField (FieldReference reference)
 234                 {
 235                         if (IgnoreScope (reference.DeclaringType.Scope))
 236                                 return;
 237
 238                         FieldDefinition field = ResolveFieldDefinition (reference);
 239
 240                         if (field == null)
 241                                 throw new ResolutionException (reference);
 242
 243                         if (CheckProcessed (field))
 244                                 return;
 245
 246                         MarkType (field.DeclaringType);
 247                         MarkType (field.FieldType);
 248                         MarkCustomAttributes (field);
 249                         MarkMarshalSpec (field);
 250
 251                         Annotations.Mark (field);
 252                 }
 253
 254                 bool IgnoreScope (IMetadataScope scope)
 255                 {
 256                         AssemblyDefinition assembly = ResolveAssembly (scope);
 257                         return Annotations.GetAction (assembly) != AssemblyAction.Link;
 258                 }
 259
 260                 FieldDefinition ResolveFieldDefinition (FieldReference field)
 261                 {
 262                         FieldDefinition fd = field as FieldDefinition;
 263                         if (fd == null)
 264                                 fd = field.Resolve ();
 265
 266                         return fd;
 267                 }
 268
 269                 void MarkType (TypeReference reference)
 270                 {
 271                         if (reference == null)
 272                                 return;
 273
 274                         reference = GetOriginalType (reference);
 275
 276                         if (reference is GenericParameter)
 277                                 return;
 278
 279                         if (IgnoreScope (reference.Scope))
 280                                 return;
 281
 282                         TypeDefinition type = ResolveTypeDefinition (reference);
 283
 284                         if (type == null)
 285                                 throw new ResolutionException (reference);
 286
 287                         if (CheckProcessed (type))
 288                                 return;
 289
 290                         MarkType (type.BaseType);
 291                         MarkType (type.DeclaringType);
 292                         MarkCustomAttributes(type);
 293
 294                         if (IsMulticastDelegate (type))
 295                                 MarkMethodCollection (type.Constructors);
 296
 297                         if (IsSerializable (type) && type.HasConstructors) {
 298                                 MarkMethodsIf (type.Constructors, IsDefaultConstructorPredicate);
 299                                 MarkMethodsIf (type.Constructors, IsSpecialSerializationConstructorPredicate);
 300                         }
 301
 302                         MarkGenericParameterProvider (type);
 303
 304                         if (type.IsValueType)
 305                                 MarkFields (type);
 306
 307                         if (type.HasInterfaces) {
 308                                 foreach (TypeReference iface in type.Interfaces)
 309                                         MarkType (iface);
 310                         }
 311
 312                         if (type.HasConstructors)
 313                                 MarkMethodsIf (type.Constructors, IsStaticConstructorPredicate);
 314
 315                         if (type.HasMethods)
 316                                 MarkMethodsIf (type.Methods, IsVirtualPredicate);
 317
 318                         Annotations.Mark (type);
 319
 320                         ApplyPreserveInfo (type);
 321                 }
 322
 323                 void MarkGenericParameterProvider (IGenericParameterProvider provider)
 324                 {
 325                         if (!provider.HasGenericParameters)
 326                                 return;
 327
 328                         foreach (GenericParameter parameter in provider.GenericParameters)
 329                                 MarkGenericParameter (parameter);
 330                 }
 331
 332                 void MarkGenericParameter (GenericParameter parameter)
 333                 {
 334                         MarkCustomAttributes (parameter);
 335                         foreach (TypeReference constraint in parameter.Constraints)
 336                                 MarkType (constraint);
 337                 }
 338
 339                 static MethodPredicate IsSpecialSerializationConstructorPredicate = new MethodPredicate (IsSpecialSerializationConstructor);
 340
 341                 static bool IsSpecialSerializationConstructor (MethodDefinition method)
 342                 {
 343                         if (!IsConstructor (method))
 344                                 return false;
 345
 346                         ParameterDefinitionCollection parameters = method.Parameters;
 347                         if (parameters.Count != 2)
 348                                 return false;
 349
 350                         return parameters [0].ParameterType.Name == "SerializationInfo" &&
 351                                 parameters [1].ParameterType.Name == "StreamingContext";
 352                 }
 353
 354                 delegate bool MethodPredicate (MethodDefinition method);
 355
 356                 void MarkMethodsIf (ICollection methods, MethodPredicate predicate)
 357                 {
 358                         foreach (MethodDefinition method in methods)
 359                                 if (predicate (method))
 360                                         MarkMethod (method);
 361                 }
 362
 363                 static MethodPredicate IsDefaultConstructorPredicate = new MethodPredicate (IsDefaultConstructor);
 364
 365                 static bool IsDefaultConstructor (MethodDefinition method)
 366                 {
 367                         return IsConstructor (method) && method.Parameters.Count == 0;
 368                 }
 369
 370                 static bool IsConstructor (MethodDefinition method)
 371                 {
 372                         return method.Name == MethodDefinition.Ctor && method.IsSpecialName &&
 373                                 method.IsRuntimeSpecialName;
 374                 }
 375
 376                 static MethodPredicate IsVirtualPredicate = new MethodPredicate (IsVirtual);
 377
 378                 static bool IsVirtual (MethodDefinition method)
 379                 {
 380                         return method.IsVirtual;
 381                 }
 382
 383                 static MethodPredicate IsStaticConstructorPredicate = new MethodPredicate (IsStaticConstructor);
 384
 385                 static bool IsStaticConstructor (MethodDefinition method)
 386                 {
 387                         return method.Name == MethodDefinition.Cctor && method.IsSpecialName &&
 388                                 method.IsRuntimeSpecialName;
 389                 }
 390
 391                 static bool IsSerializable (TypeDefinition td)
 392                 {
 393                         return (td.Attributes & TypeAttributes.Serializable) != 0;
 394                 }
 395
 396                 static bool IsMulticastDelegate (TypeDefinition td)
 397                 {
 398                         return td.BaseType != null && td.BaseType.FullName == "System.MulticastDelegate";
 399                 }
 400
 401                 TypeDefinition ResolveTypeDefinition (TypeReference type)
 402                 {
 403                         TypeDefinition td = type as TypeDefinition;
 404                         if (td == null)
 405                                 td = type.Resolve ();
 406
 407                         return td;
 408                 }
 409
 410                 TypeReference GetOriginalType (TypeReference type)
 411                 {
 412                         while (type is TypeSpecification) {
 413                                 GenericInstanceType git = type as GenericInstanceType;
 414                                 if (git != null)
 415                                         MarkGenericArguments (git);
 416
 417                                 ModType mod = type as ModType;
 418                                 if (mod != null)
 419                                         MarkModifierType (mod);
 420
 421                                 type = ((TypeSpecification) type).ElementType;
 422                         }
 423
 424                         return type;
 425                 }
 426
 427                 void MarkModifierType (ModType mod)
 428                 {
 429                         MarkType (mod.ModifierType);
 430                 }
 431
 432                 void MarkGenericArguments (IGenericInstance instance)
 433                 {
 434                         foreach (TypeReference argument in instance.GenericArguments)
 435                                 MarkType (argument);
 436                 }
 437
 438                 void ApplyPreserveInfo (TypeDefinition type)
 439                 {
 440                         if (!Annotations.IsPreserved (type))
 441                                 return;
 442
 443                         switch (Annotations.GetPreserve (type)) {
 444                         case TypePreserve.All:
 445                                 MarkFields (type);
 446                                 MarkMethods (type);
 447                                 break;
 448                         case TypePreserve.Fields:
 449                                 MarkFields (type);
 450                                 break;
 451                         case TypePreserve.Methods:
 452                                 MarkMethods (type);
 453                                 break;
 454                         }
 455                 }
 456
 457                 void MarkFields (TypeDefinition type)
 458                 {
 459                         if (!type.HasFields)
 460                                 return;
 461
 462                         foreach (FieldDefinition field in type.Fields)
 463                                 MarkField (field);
 464                 }
 465
 466                 void MarkMethods (TypeDefinition type)
 467                 {
 468                         if (type.HasMethods)
 469                                 MarkMethodCollection (type.Methods);
 470                         if (type.HasConstructors)
 471                                 MarkMethodCollection (type.Constructors);
 472                 }
 473
 474                 void MarkMethodCollection (IEnumerable methods)
 475                 {
 476                         foreach (MethodDefinition method in methods)
 477                                 MarkMethod (method);
 478                 }
 479
 480                 void MarkMethod (MethodReference reference)
 481                 {
 482                         reference = GetOriginalMethod (reference);
 483
 484                         if (reference.DeclaringType is ArrayType)
 485                                 return;
 486
 487                         if (IgnoreScope (reference.DeclaringType.Scope))
 488                                 return;
 489
 490                         MethodDefinition method = ResolveMethodDefinition (reference);
 491
 492                         if (method == null)
 493                                 throw new ResolutionException (reference);
 494
 495                         Annotations.SetAction (method, MethodAction.Parse);
 496
 497                         _queue.Enqueue (method);
 498                 }
 499
 500                 AssemblyDefinition ResolveAssembly (IMetadataScope scope)
 501                 {
 502                         AssemblyDefinition assembly = _context.Resolve (scope);
 503                         MarkAssembly (assembly);
 504                         return assembly;
 505                 }
 506
 507                 MethodReference GetOriginalMethod (MethodReference method)
 508                 {
 509                         while (method is MethodSpecification) {
 510                                 GenericInstanceMethod gim = method as GenericInstanceMethod;
 511                                 if (gim != null)
 512                                         MarkGenericArguments (gim);
 513
 514                                 method = ((MethodSpecification) method).ElementMethod;
 515                         }
 516
 517                         return method;
 518                 }
 519
 520                 MethodDefinition ResolveMethodDefinition (MethodReference method)
 521                 {
 522                         MethodDefinition md = method as MethodDefinition;
 523                         if (md == null)
 524                                 md = method.Resolve ();
 525
 526                         return md;
 527                 }
 528
 529                 void ProcessMethod (MethodDefinition method)
 530                 {
 531                         if (CheckProcessed (method))
 532                                 return;
 533
 534                         MarkType (method.DeclaringType);
 535                         MarkCustomAttributes (method);
 536
 537                         MarkGenericParameterProvider (method);
 538
 539                         if (IsPropertyMethod (method))
 540                                 MarkProperty (GetProperty (method));
 541                         else if (IsEventMethod (method))
 542                                 MarkEvent (GetEvent (method));
 543
 544                         if (method.HasParameters) {
 545                                 foreach (ParameterDefinition pd in method.Parameters) {
 546                                         MarkType (pd.ParameterType);
 547                                         MarkCustomAttributes (pd);
 548                                         MarkMarshalSpec (pd);
 549                                 }
 550                         }
 551
 552                         if (method.HasOverrides) {
 553                                 foreach (MethodReference ov in method.Overrides)
 554                                         MarkMethod (ov);
 555                         }
 556
 557                         MarkType (method.ReturnType.ReturnType);
 558                         MarkCustomAttributes (method.ReturnType);
 559                         MarkMarshalSpec (method.ReturnType);
 560
 561                         if (ShouldParseMethodBody (method))
 562                                 MarkMethodBody (method.Body);
 563
 564                         Annotations.Mark (method);
 565                 }
 566
 567                 bool ShouldParseMethodBody (MethodDefinition method)
 568                 {
 569                         if (!method.HasBody)
 570                                 return false;
 571
 572                         AssemblyDefinition assembly = ResolveAssembly (method.DeclaringType.Scope);
 573                         return (Annotations.GetAction (method) == MethodAction.ForceParse ||
 574                                 (Annotations.GetAction (assembly) == AssemblyAction.Link && Annotations.GetAction (method) == MethodAction.Parse));
 575                 }
 576
 577                 static bool IsPropertyMethod (MethodDefinition md)
 578                 {
 579                         return (md.SemanticsAttributes & MethodSemanticsAttributes.Getter) != 0 ||
 580                                 (md.SemanticsAttributes & MethodSemanticsAttributes.Setter) != 0;
 581                 }
 582
 583                 static bool IsEventMethod (MethodDefinition md)
 584                 {
 585                         return (md.SemanticsAttributes & MethodSemanticsAttributes.AddOn) != 0 ||
 586                                 (md.SemanticsAttributes & MethodSemanticsAttributes.Fire) != 0 ||
 587                                 (md.SemanticsAttributes & MethodSemanticsAttributes.RemoveOn) != 0;
 588                 }
 589
 590                 static PropertyDefinition GetProperty (MethodDefinition md)
 591                 {
 592                         TypeDefinition declaringType = (TypeDefinition) md.DeclaringType;
 593                         foreach (PropertyDefinition prop in declaringType.Properties)
 594                                 if (prop.GetMethod == md || prop.SetMethod == md)
 595                                         return prop;
 596
 597                         return null;
 598                 }
 599
 600                 static EventDefinition GetEvent (MethodDefinition md)
 601                 {
 602                         TypeDefinition declaringType = (TypeDefinition) md.DeclaringType;
 603                         foreach (EventDefinition evt in declaringType.Events)
 604                                 if (evt.AddMethod == md || evt.InvokeMethod == md || evt.RemoveMethod == md)
 605                                         return evt;
 606
 607                         return null;
 608                 }
 609
 610                 void MarkProperty (PropertyDefinition prop)
 611                 {
 612                         MarkCustomAttributes (prop);
 613                 }
 614
 615                 void MarkEvent (EventDefinition evt)
 616                 {
 617                         MarkCustomAttributes (evt);
 618                         MarkMethodIfNotNull (evt.AddMethod);
 619                         MarkMethodIfNotNull (evt.InvokeMethod);
 620                         MarkMethodIfNotNull (evt.RemoveMethod);
 621                 }
 622
 623                 void MarkMethodIfNotNull (MethodReference method)
 624                 {
 625                         if (method == null)
 626                                 return;
 627
 628                         MarkMethod (method);
 629                 }
 630
 631                 void MarkInstruction (Instruction instruction)
 632                 {
 633                         switch (instruction.OpCode.OperandType) {
 634                         case OperandType.InlineField:
 635                                 MarkField ((FieldReference) instruction.Operand);
 636                                 break;
 637                         case OperandType.InlineMethod:
 638                                 MarkMethod ((MethodReference) instruction.Operand);
 639                                 break;
 640                         case OperandType.InlineTok:
 641                                 object token = instruction.Operand;
 642                                 if (token is TypeReference)
 643                                         MarkType ((TypeReference) token);
 644                                 else if (token is MethodReference)
 645                                         MarkMethod ((MethodReference) token);
 646                                 else
 647                                         MarkField ((FieldReference) token);
 648                                 break;
 649                         case OperandType.InlineType:
 650                                 MarkType ((TypeReference) instruction.Operand);
 651                                 break;
 652                         default:
 653                                 break;
 654                         }
 655                 }
 656         }
 657 }