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

   1 //
   2 // AggressiveRefletionReader.cs
   3 //
   4 // Author:
   5 //   Jb Evain (jbevain@gmail.com)
   6 //
   7 // (C) 2005 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
  33         using Mono.Cecil.Metadata;
  34         using Mono.Cecil.Signatures;
  35
  36         internal sealed class AggressiveReflectionReader : ReflectionReader {
  37
  38                 public AggressiveReflectionReader (ModuleDefinition module) : base (module)
  39                 {
  40                 }
  41
  42                 public override void VisitTypeDefinitionCollection (TypeDefinitionCollection types)
  43                 {
  44                         base.VisitTypeDefinitionCollection (types);
  45
  46                         ReadGenericParameterConstraints ();
  47                         ReadClassLayoutInfos ();
  48                         ReadFieldLayoutInfos ();
  49                         ReadPInvokeInfos ();
  50                         ReadProperties ();
  51                         ReadEvents ();
  52                         ReadSemantics ();
  53                         ReadInterfaces ();
  54                         ReadOverrides ();
  55                         ReadSecurityDeclarations ();
  56                         ReadCustomAttributes ();
  57                         ReadConstants ();
  58                         ReadExternTypes ();
  59                         ReadMarshalSpecs ();
  60                         ReadInitialValues ();
  61
  62                         m_events = null;
  63                         m_properties = null;
  64                         m_parameters = null;
  65                 }
  66
  67                 void ReadGenericParameterConstraints ()
  68                 {
  69                         if (!m_tHeap.HasTable (GenericParamConstraintTable.RId))
  70                                 return;
  71
  72                         GenericParamConstraintTable gpcTable = m_tableReader.GetGenericParamConstraintTable ();
  73                         for (int i = 0; i < gpcTable.Rows.Count; i++) {
  74                                 GenericParamConstraintRow gpcRow = gpcTable [i];
  75                                 GenericParameter gp = GetGenericParameterAt (gpcRow.Owner);
  76
  77                                 gp.Constraints.Add (GetTypeDefOrRef (gpcRow.Constraint, new GenericContext (gp.Owner)));
  78                         }
  79                 }
  80
  81                 void ReadClassLayoutInfos ()
  82                 {
  83                         if (!m_tHeap.HasTable (ClassLayoutTable.RId))
  84                                 return;
  85
  86                         ClassLayoutTable clTable = m_tableReader.GetClassLayoutTable ();
  87                         for (int i = 0; i < clTable.Rows.Count; i++) {
  88                                 ClassLayoutRow clRow = clTable [i];
  89                                 TypeDefinition type = GetTypeDefAt (clRow.Parent);
  90                                 type.PackingSize = clRow.PackingSize;
  91                                 type.ClassSize = clRow.ClassSize;
  92                         }
  93                 }
  94
  95                 void ReadFieldLayoutInfos ()
  96                 {
  97                         if (!m_tHeap.HasTable (FieldLayoutTable.RId))
  98                                 return;
  99
 100                         FieldLayoutTable flTable = m_tableReader.GetFieldLayoutTable ();
 101                         for (int i = 0; i < flTable.Rows.Count; i++) {
 102                                 FieldLayoutRow flRow = flTable [i];
 103                                 FieldDefinition field = GetFieldDefAt (flRow.Field);
 104                                 field.Offset = flRow.Offset;
 105                         }
 106                 }
 107
 108                 void ReadPInvokeInfos ()
 109                 {
 110                         if (!m_tHeap.HasTable (ImplMapTable.RId))
 111                                 return;
 112
 113                         ImplMapTable imTable = m_tableReader.GetImplMapTable ();
 114                         for (int i = 0; i < imTable.Rows.Count; i++) {
 115                                 ImplMapRow imRow = imTable [i];
 116                                 if (imRow.MemberForwarded.TokenType == TokenType.Method) { // should always be true
 117                                         MethodDefinition meth = GetMethodDefAt (imRow.MemberForwarded.RID);
 118                                         meth.PInvokeInfo = new PInvokeInfo (
 119                                                 meth, imRow.MappingFlags, MetadataRoot.Streams.StringsHeap [imRow.ImportName],
 120                                                 Module.ModuleReferences [(int) imRow.ImportScope - 1]);
 121                                 }
 122                         }
 123                 }
 124
 125                 void ReadProperties ()
 126                 {
 127                         if (!m_tHeap.HasTable (PropertyTable.RId)) {
 128                                 m_properties = new PropertyDefinition [0];
 129                                 return;
 130                         }
 131
 132                         PropertyTable propsTable = m_tableReader.GetPropertyTable ();
 133                         PropertyMapTable pmapTable = m_tableReader.GetPropertyMapTable ();
 134                         m_properties = new PropertyDefinition [propsTable.Rows.Count];
 135                         for (int i = 0; i < pmapTable.Rows.Count; i++) {
 136                                 PropertyMapRow pmapRow = pmapTable [i];
 137                                 if (pmapRow.Parent == 0)
 138                                         continue;
 139
 140                                 TypeDefinition owner = GetTypeDefAt (pmapRow.Parent);
 141
 142                                 GenericContext context = new GenericContext (owner);
 143
 144                                 int start = (int) pmapRow.PropertyList, last = propsTable.Rows.Count + 1, end;
 145                                 if (i < pmapTable.Rows.Count - 1)
 146                                         end = (int) pmapTable [i + 1].PropertyList;
 147                                 else
 148                                         end = last;
 149
 150                                 if (end > last)
 151                                         end = last;
 152
 153                                 for (int j = start; j < end; j++) {
 154                                         PropertyRow prow = propsTable [j - 1];
 155                                         PropertySig psig = m_sigReader.GetPropSig (prow.Type);
 156                                         PropertyDefinition pdef = new PropertyDefinition (
 157                                                 m_root.Streams.StringsHeap [prow.Name],
 158                                                 GetTypeRefFromSig (psig.Type, context),
 159                                         prow.Flags);
 160                                         pdef.MetadataToken = MetadataToken.FromMetadataRow (TokenType.Property, j - 1);
 161
 162                                         pdef.PropertyType = GetModifierType (psig.CustomMods, pdef.PropertyType);
 163
 164                                         if (!IsDeleted (pdef))
 165                                                 owner.Properties.Add (pdef);
 166
 167                                         m_properties [j - 1] = pdef;
 168                                 }
 169                         }
 170                 }
 171
 172                 void ReadEvents ()
 173                 {
 174                         if (!m_tHeap.HasTable (EventTable.RId)) {
 175                                 m_events = new EventDefinition [0];
 176                                 return;
 177                         }
 178
 179                         EventTable evtTable = m_tableReader.GetEventTable ();
 180                         EventMapTable emapTable = m_tableReader.GetEventMapTable ();
 181                         m_events = new EventDefinition [evtTable.Rows.Count];
 182                         for (int i = 0; i < emapTable.Rows.Count; i++) {
 183                                 EventMapRow emapRow = emapTable [i];
 184                                 if (emapRow.Parent == 0)
 185                                         continue;
 186
 187                                 TypeDefinition owner = GetTypeDefAt (emapRow.Parent);
 188                                 GenericContext context = new GenericContext (owner);
 189
 190                                 int start = (int) emapRow.EventList, last = evtTable.Rows.Count + 1, end;
 191                                 if (i < (emapTable.Rows.Count - 1))
 192                                         end = (int) emapTable [i + 1].EventList;
 193                                 else
 194                                         end = last;
 195
 196                                 if (end > last)
 197                                         end = last;
 198
 199                                 for (int j = start; j < end; j++) {
 200                                         EventRow erow = evtTable [j - 1];
 201                                         EventDefinition edef = new EventDefinition (
 202                                                 m_root.Streams.StringsHeap [erow.Name],
 203                                                 GetTypeDefOrRef (erow.EventType, context), erow.EventFlags);
 204                                         edef.MetadataToken = MetadataToken.FromMetadataRow (TokenType.Event, j - 1);
 205
 206                                         if (!IsDeleted (edef))
 207                                                 owner.Events.Add (edef);
 208
 209                                         m_events [j - 1] = edef;
 210                                 }
 211                         }
 212                 }
 213
 214                 void ReadSemantics ()
 215                 {
 216                         if (!m_tHeap.HasTable (MethodSemanticsTable.RId))
 217                                 return;
 218
 219                         MethodSemanticsTable semTable = m_tableReader.GetMethodSemanticsTable ();
 220                         for (int i = 0; i < semTable.Rows.Count; i++) {
 221                                 MethodSemanticsRow semRow = semTable [i];
 222                                 MethodDefinition semMeth = GetMethodDefAt (semRow.Method);
 223                                 semMeth.SemanticsAttributes = semRow.Semantics;
 224                                 switch (semRow.Association.TokenType) {
 225                                 case TokenType.Event :
 226                                         EventDefinition evt = GetEventDefAt (semRow.Association.RID);
 227                                         if ((semRow.Semantics & MethodSemanticsAttributes.AddOn) != 0)
 228                                                 evt.AddMethod = semMeth;
 229                                         else if ((semRow.Semantics & MethodSemanticsAttributes.Fire) != 0)
 230                                                 evt.InvokeMethod = semMeth;
 231                                         else if ((semRow.Semantics & MethodSemanticsAttributes.RemoveOn) != 0)
 232                                                 evt.RemoveMethod = semMeth;
 233                                         break;
 234                                 case TokenType.Property :
 235                                         PropertyDefinition prop = GetPropertyDefAt (semRow.Association.RID);
 236                                         if ((semRow.Semantics & MethodSemanticsAttributes.Getter) != 0)
 237                                                 prop.GetMethod = semMeth;
 238                                         else if ((semRow.Semantics & MethodSemanticsAttributes.Setter) != 0)
 239                                                 prop.SetMethod = semMeth;
 240                                         break;
 241                                 }
 242                         }
 243                 }
 244
 245                 void ReadInterfaces ()
 246                 {
 247                         if (!m_tHeap.HasTable (InterfaceImplTable.RId))
 248                                 return;
 249
 250                         InterfaceImplTable intfsTable = m_tableReader.GetInterfaceImplTable ();
 251                         for (int i = 0; i < intfsTable.Rows.Count; i++) {
 252                                 InterfaceImplRow intfsRow = intfsTable [i];
 253                                 TypeDefinition owner = GetTypeDefAt (intfsRow.Class);
 254                                 owner.Interfaces.Add (GetTypeDefOrRef (intfsRow.Interface, new GenericContext (owner)));
 255                         }
 256                 }
 257
 258                 void ReadOverrides ()
 259                 {
 260                         if (!m_tHeap.HasTable (MethodImplTable.RId))
 261                                 return;
 262
 263                         MethodImplTable implTable = m_tableReader.GetMethodImplTable ();
 264                         for (int i = 0; i < implTable.Rows.Count; i++) {
 265                                 MethodImplRow implRow = implTable [i];
 266                                 if (implRow.MethodBody.TokenType == TokenType.Method) {
 267                                         MethodDefinition owner = GetMethodDefAt (implRow.MethodBody.RID);
 268                                         switch (implRow.MethodDeclaration.TokenType) {
 269                                         case TokenType.Method :
 270                                                 owner.Overrides.Add (
 271                                                         GetMethodDefAt (implRow.MethodDeclaration.RID));
 272                                                 break;
 273                                         case TokenType.MemberRef :
 274                                                 owner.Overrides.Add (
 275                                                         (MethodReference) GetMemberRefAt (
 276                                                                 implRow.MethodDeclaration.RID, new GenericContext (owner)));
 277                                                 break;
 278                                         }
 279                                 }
 280                         }
 281                 }
 282
 283                 void ReadSecurityDeclarations ()
 284                 {
 285                         if (!m_tHeap.HasTable (DeclSecurityTable.RId))
 286                                 return;
 287
 288                         DeclSecurityTable dsTable = m_tableReader.GetDeclSecurityTable ();
 289                         for (int i = 0; i < dsTable.Rows.Count; i++) {
 290                                 DeclSecurityRow dsRow = dsTable [i];
 291                                 SecurityDeclaration dec = BuildSecurityDeclaration (dsRow);
 292
 293                                 if (dsRow.Parent.RID == 0)
 294                                         continue;
 295
 296                                 IHasSecurity owner = null;
 297                                 switch (dsRow.Parent.TokenType) {
 298                                 case TokenType.Assembly :
 299                                         owner = this.Module.Assembly;
 300                                         break;
 301                                 case TokenType.TypeDef :
 302                                         owner = GetTypeDefAt (dsRow.Parent.RID);
 303                                         break;
 304                                 case TokenType.Method :
 305                                         owner = GetMethodDefAt (dsRow.Parent.RID);
 306                                         break;
 307                                 }
 308
 309                                 owner.SecurityDeclarations.Add (dec);
 310                         }
 311                 }
 312
 313                 void ReadCustomAttributes ()
 314                 {
 315                         if (!m_tHeap.HasTable (CustomAttributeTable.RId))
 316                                 return;
 317
 318                         CustomAttributeTable caTable = m_tableReader.GetCustomAttributeTable ();
 319                         for (int i = 0; i < caTable.Rows.Count; i++) {
 320                                 CustomAttributeRow caRow = caTable [i];
 321                                 MethodReference ctor;
 322
 323                                 if (caRow.Type.RID == 0)
 324                                         continue;
 325
 326                                 if (caRow.Type.TokenType == TokenType.Method)
 327                                         ctor = GetMethodDefAt (caRow.Type.RID);
 328                                 else
 329                                         ctor = GetMemberRefAt (caRow.Type.RID, new GenericContext ()) as MethodReference;
 330
 331                                 CustomAttrib ca = m_sigReader.GetCustomAttrib (caRow.Value, ctor);
 332                                 CustomAttribute cattr = BuildCustomAttribute (ctor, m_root.Streams.BlobHeap.Read (caRow.Value), ca);
 333
 334                                 if (caRow.Parent.RID == 0)
 335                                         continue;
 336
 337                                 ICustomAttributeProvider owner = null;
 338                                 switch (caRow.Parent.TokenType) {
 339                                 case TokenType.Assembly :
 340                                         owner = this.Module.Assembly;
 341                                         break;
 342                                 case TokenType.Module :
 343                                         owner = this.Module;
 344                                         break;
 345                                 case TokenType.TypeDef :
 346                                         owner = GetTypeDefAt (caRow.Parent.RID);
 347                                         break;
 348                                 case TokenType.TypeRef :
 349                                         owner = GetTypeRefAt (caRow.Parent.RID);
 350                                         break;
 351                                 case TokenType.Field :
 352                                         owner = GetFieldDefAt (caRow.Parent.RID);
 353                                         break;
 354                                 case TokenType.Method :
 355                                         owner = GetMethodDefAt (caRow.Parent.RID);
 356                                         break;
 357                                 case TokenType.Property :
 358                                         owner = GetPropertyDefAt (caRow.Parent.RID);
 359                                         break;
 360                                 case TokenType.Event :
 361                                         owner = GetEventDefAt (caRow.Parent.RID);
 362                                         break;
 363                                 case TokenType.Param :
 364                                         owner = GetParamDefAt (caRow.Parent.RID);
 365                                         break;
 366                                 case TokenType.GenericParam :
 367                                         owner = GetGenericParameterAt (caRow.Parent.RID);
 368                                         break;
 369                                 default :
 370                                         //TODO: support other ?
 371                                         break;
 372                                 }
 373
 374                                 if (owner != null)
 375                                         owner.CustomAttributes.Add (cattr);
 376                         }
 377                 }
 378
 379                 void ReadConstants ()
 380                 {
 381                         if (!m_tHeap.HasTable (ConstantTable.RId))
 382                                 return;
 383
 384                         ConstantTable csTable = m_tableReader.GetConstantTable ();
 385                         for (int i = 0; i < csTable.Rows.Count; i++) {
 386                                 ConstantRow csRow = csTable [i];
 387
 388                                 object constant = GetConstant (csRow.Value, csRow.Type);
 389
 390                                 IHasConstant owner = null;
 391                                 switch (csRow.Parent.TokenType) {
 392                                 case TokenType.Field :
 393                                         owner = GetFieldDefAt (csRow.Parent.RID);
 394                                         break;
 395                                 case TokenType.Property :
 396                                         owner = GetPropertyDefAt (csRow.Parent.RID);
 397                                         break;
 398                                 case TokenType.Param :
 399                                         owner = GetParamDefAt (csRow.Parent.RID);
 400                                         break;
 401                                 }
 402
 403                                 owner.Constant = constant;
 404                         }
 405                 }
 406
 407                 void ReadExternTypes ()
 408                 {
 409                         base.VisitExternTypeCollection (Module.ExternTypes);
 410                 }
 411
 412                 void ReadMarshalSpecs ()
 413                 {
 414                         if (!m_tHeap.HasTable (FieldMarshalTable.RId))
 415                                 return;
 416
 417                         FieldMarshalTable fmTable = m_tableReader.GetFieldMarshalTable ();
 418                         for (int i = 0; i < fmTable.Rows.Count; i++) {
 419                                 FieldMarshalRow fmRow = fmTable [i];
 420
 421                                 if (fmRow.Parent.RID == 0)
 422                                         continue;
 423
 424                                 IHasMarshalSpec owner = null;
 425                                 switch (fmRow.Parent.TokenType) {
 426                                 case TokenType.Field:
 427                                         owner = GetFieldDefAt (fmRow.Parent.RID);
 428                                         break;
 429                                 case TokenType.Param:
 430                                         owner = GetParamDefAt (fmRow.Parent.RID);
 431                                         break;
 432                                 }
 433
 434                                 owner.MarshalSpec = BuildMarshalDesc (
 435                                         m_sigReader.GetMarshalSig (fmRow.NativeType), owner);
 436                         }
 437                 }
 438
 439                 void ReadInitialValues ()
 440                 {
 441                         if (!m_tHeap.HasTable (FieldRVATable.RId))
 442                                 return;
 443
 444                         FieldRVATable frTable = m_tableReader.GetFieldRVATable ();
 445                         for (int i = 0; i < frTable.Rows.Count; i++) {
 446                                 FieldRVARow frRow = frTable [i];
 447                                 FieldDefinition field = GetFieldDefAt (frRow.Field);
 448                                 field.RVA = frRow.RVA;
 449                                 SetInitialValue (field);
 450                         }
 451                 }
 452         }
 453 }