/Mono.Cecil/AssemblyWriter.cs

http://github.com/jbevain/cecil · C# · 3334 lines · 2662 code · 659 blank · 13 comment · 387 complexity · c49fef0cb35b6db20b02f33df08c51b7 MD5 · raw file

Large files are truncated click here to view the full file

  1. //
  2. // Author:
  3. // Jb Evain (jbevain@gmail.com)
  4. //
  5. // Copyright (c) 2008 - 2015 Jb Evain
  6. // Copyright (c) 2008 - 2011 Novell, Inc.
  7. //
  8. // Licensed under the MIT/X11 license.
  9. //
  10. using System;
  11. using System.Collections.Generic;
  12. using System.IO;
  13. using System.IO.Compression;
  14. using System.Text;
  15. using System.Security.Cryptography;
  16. using Mono;
  17. using Mono.Collections.Generic;
  18. using Mono.Cecil.Cil;
  19. using Mono.Cecil.Metadata;
  20. using Mono.Cecil.PE;
  21. using RVA = System.UInt32;
  22. using RID = System.UInt32;
  23. using CodedRID = System.UInt32;
  24. using StringIndex = System.UInt32;
  25. using BlobIndex = System.UInt32;
  26. using GuidIndex = System.UInt32;
  27. namespace Mono.Cecil {
  28. using ModuleRow = Row<StringIndex, GuidIndex>;
  29. using TypeRefRow = Row<CodedRID, StringIndex, StringIndex>;
  30. using TypeDefRow = Row<TypeAttributes, StringIndex, StringIndex, CodedRID, RID, RID>;
  31. using FieldRow = Row<FieldAttributes, StringIndex, BlobIndex>;
  32. using MethodRow = Row<RVA, MethodImplAttributes, MethodAttributes, StringIndex, BlobIndex, RID>;
  33. using ParamRow = Row<ParameterAttributes, ushort, StringIndex>;
  34. using InterfaceImplRow = Row<uint, CodedRID>;
  35. using MemberRefRow = Row<CodedRID, StringIndex, BlobIndex>;
  36. using ConstantRow = Row<ElementType, CodedRID, BlobIndex>;
  37. using CustomAttributeRow = Row<CodedRID, CodedRID, BlobIndex>;
  38. using FieldMarshalRow = Row<CodedRID, BlobIndex>;
  39. using DeclSecurityRow = Row<SecurityAction, CodedRID, BlobIndex>;
  40. using ClassLayoutRow = Row<ushort, uint, RID>;
  41. using FieldLayoutRow = Row<uint, RID>;
  42. using EventMapRow = Row<RID, RID>;
  43. using EventRow = Row<EventAttributes, StringIndex, CodedRID>;
  44. using PropertyMapRow = Row<RID, RID>;
  45. using PropertyRow = Row<PropertyAttributes, StringIndex, BlobIndex>;
  46. using MethodSemanticsRow = Row<MethodSemanticsAttributes, RID, CodedRID>;
  47. using MethodImplRow = Row<RID, CodedRID, CodedRID>;
  48. using ImplMapRow = Row<PInvokeAttributes, CodedRID, StringIndex, RID>;
  49. using FieldRVARow = Row<RVA, RID>;
  50. using AssemblyRow = Row<AssemblyHashAlgorithm, ushort, ushort, ushort, ushort, AssemblyAttributes, uint, uint, uint>;
  51. using AssemblyRefRow = Row<ushort, ushort, ushort, ushort, AssemblyAttributes, uint, uint, uint, uint>;
  52. using FileRow = Row<FileAttributes, StringIndex, BlobIndex>;
  53. using ExportedTypeRow = Row<TypeAttributes, uint, StringIndex, StringIndex, CodedRID>;
  54. using ManifestResourceRow = Row<uint, ManifestResourceAttributes, StringIndex, CodedRID>;
  55. using NestedClassRow = Row<RID, RID>;
  56. using GenericParamRow = Row<ushort, GenericParameterAttributes, CodedRID, StringIndex>;
  57. using MethodSpecRow = Row<CodedRID, BlobIndex>;
  58. using GenericParamConstraintRow = Row<RID, CodedRID>;
  59. using DocumentRow = Row<BlobIndex, GuidIndex, BlobIndex, GuidIndex>;
  60. using MethodDebugInformationRow = Row<RID, BlobIndex>;
  61. using LocalScopeRow = Row<RID, RID, RID, RID, uint, uint>;
  62. using LocalVariableRow = Row<VariableAttributes, ushort, StringIndex>;
  63. using LocalConstantRow = Row<StringIndex, BlobIndex>;
  64. using ImportScopeRow = Row<RID, BlobIndex>;
  65. using StateMachineMethodRow = Row<RID, RID>;
  66. using CustomDebugInformationRow = Row<CodedRID, GuidIndex, BlobIndex>;
  67. static class ModuleWriter {
  68. public static void WriteModule (ModuleDefinition module, Disposable<Stream> stream, WriterParameters parameters)
  69. {
  70. using (stream)
  71. Write (module, stream, parameters);
  72. }
  73. static void Write (ModuleDefinition module, Disposable<Stream> stream, WriterParameters parameters)
  74. {
  75. if ((module.Attributes & ModuleAttributes.ILOnly) == 0)
  76. throw new NotSupportedException ("Writing mixed-mode assemblies is not supported");
  77. if (module.HasImage && module.ReadingMode == ReadingMode.Deferred) {
  78. var immediate_reader = new ImmediateModuleReader (module.Image);
  79. immediate_reader.ReadModule (module, resolve_attributes: false);
  80. immediate_reader.ReadSymbols (module);
  81. }
  82. module.MetadataSystem.Clear ();
  83. if (module.symbol_reader != null)
  84. module.symbol_reader.Dispose ();
  85. var name = module.assembly != null ? module.assembly.Name : null;
  86. var fq_name = stream.value.GetFileName ();
  87. var timestamp = parameters.Timestamp ?? module.timestamp;
  88. var symbol_writer_provider = parameters.SymbolWriterProvider;
  89. if (symbol_writer_provider == null && parameters.WriteSymbols)
  90. symbol_writer_provider = new DefaultSymbolWriterProvider ();
  91. if (parameters.HasStrongNameKey && name != null) {
  92. name.PublicKey = CryptoService.GetPublicKey (parameters);
  93. module.Attributes |= ModuleAttributes.StrongNameSigned;
  94. }
  95. if (parameters.DeterministicMvid)
  96. module.Mvid = Guid.Empty;
  97. var metadata = new MetadataBuilder (module, fq_name, timestamp, symbol_writer_provider);
  98. try {
  99. module.metadata_builder = metadata;
  100. using (var symbol_writer = GetSymbolWriter (module, fq_name, symbol_writer_provider, parameters)) {
  101. metadata.SetSymbolWriter (symbol_writer);
  102. BuildMetadata (module, metadata);
  103. if (parameters.DeterministicMvid)
  104. metadata.ComputeDeterministicMvid ();
  105. var writer = ImageWriter.CreateWriter (module, metadata, stream);
  106. stream.value.SetLength (0);
  107. writer.WriteImage ();
  108. if (parameters.HasStrongNameKey)
  109. CryptoService.StrongName (stream.value, writer, parameters);
  110. }
  111. } finally {
  112. module.metadata_builder = null;
  113. }
  114. }
  115. static void BuildMetadata (ModuleDefinition module, MetadataBuilder metadata)
  116. {
  117. if (!module.HasImage) {
  118. metadata.BuildMetadata ();
  119. return;
  120. }
  121. module.Read (metadata, (builder, _) => {
  122. builder.BuildMetadata ();
  123. return builder;
  124. });
  125. }
  126. static ISymbolWriter GetSymbolWriter (ModuleDefinition module, string fq_name, ISymbolWriterProvider symbol_writer_provider, WriterParameters parameters)
  127. {
  128. if (symbol_writer_provider == null)
  129. return null;
  130. if (parameters.SymbolStream != null)
  131. return symbol_writer_provider.GetSymbolWriter (module, parameters.SymbolStream);
  132. return symbol_writer_provider.GetSymbolWriter (module, fq_name);
  133. }
  134. }
  135. abstract class MetadataTable {
  136. public abstract int Length { get; }
  137. public bool IsLarge {
  138. get { return Length > ushort.MaxValue; }
  139. }
  140. public abstract void Write (TableHeapBuffer buffer);
  141. public abstract void Sort ();
  142. }
  143. abstract class OneRowTable<TRow> : MetadataTable where TRow : struct {
  144. internal TRow row;
  145. public sealed override int Length {
  146. get { return 1; }
  147. }
  148. public sealed override void Sort ()
  149. {
  150. }
  151. }
  152. abstract class MetadataTable<TRow> : MetadataTable where TRow : struct {
  153. internal TRow [] rows = new TRow [2];
  154. internal int length;
  155. public sealed override int Length {
  156. get { return length; }
  157. }
  158. public int AddRow (TRow row)
  159. {
  160. if (rows.Length == length)
  161. Grow ();
  162. rows [length++] = row;
  163. return length;
  164. }
  165. void Grow ()
  166. {
  167. var rows = new TRow [this.rows.Length * 2];
  168. Array.Copy (this.rows, rows, this.rows.Length);
  169. this.rows = rows;
  170. }
  171. public override void Sort ()
  172. {
  173. }
  174. }
  175. abstract class SortedTable<TRow> : MetadataTable<TRow>, IComparer<TRow> where TRow : struct {
  176. public sealed override void Sort ()
  177. {
  178. MergeSort<TRow>.Sort (rows, 0, this.length, this);
  179. }
  180. protected static int Compare (uint x, uint y)
  181. {
  182. return x == y ? 0 : x > y ? 1 : -1;
  183. }
  184. public abstract int Compare (TRow x, TRow y);
  185. }
  186. sealed class ModuleTable : OneRowTable<ModuleRow> {
  187. public override void Write (TableHeapBuffer buffer)
  188. {
  189. buffer.WriteUInt16 (0); // Generation
  190. buffer.WriteString (row.Col1); // Name
  191. buffer.WriteGuid (row.Col2); // Mvid
  192. buffer.WriteUInt16 (0); // EncId
  193. buffer.WriteUInt16 (0); // EncBaseId
  194. }
  195. }
  196. sealed class TypeRefTable : MetadataTable<TypeRefRow> {
  197. public override void Write (TableHeapBuffer buffer)
  198. {
  199. for (int i = 0; i < length; i++) {
  200. buffer.WriteCodedRID (
  201. rows [i].Col1, CodedIndex.ResolutionScope); // Scope
  202. buffer.WriteString (rows [i].Col2); // Name
  203. buffer.WriteString (rows [i].Col3); // Namespace
  204. }
  205. }
  206. }
  207. sealed class TypeDefTable : MetadataTable<TypeDefRow> {
  208. public override void Write (TableHeapBuffer buffer)
  209. {
  210. for (int i = 0; i < length; i++) {
  211. buffer.WriteUInt32 ((uint) rows [i].Col1); // Attributes
  212. buffer.WriteString (rows [i].Col2); // Name
  213. buffer.WriteString (rows [i].Col3); // Namespace
  214. buffer.WriteCodedRID (
  215. rows [i].Col4, CodedIndex.TypeDefOrRef); // Extends
  216. buffer.WriteRID (rows [i].Col5, Table.Field); // FieldList
  217. buffer.WriteRID (rows [i].Col6, Table.Method); // MethodList
  218. }
  219. }
  220. }
  221. sealed class FieldTable : MetadataTable<FieldRow> {
  222. public override void Write (TableHeapBuffer buffer)
  223. {
  224. for (int i = 0; i < length; i++) {
  225. buffer.WriteUInt16 ((ushort) rows [i].Col1); // Attributes
  226. buffer.WriteString (rows [i].Col2); // Name
  227. buffer.WriteBlob (rows [i].Col3); // Signature
  228. }
  229. }
  230. }
  231. sealed class MethodTable : MetadataTable<MethodRow> {
  232. public override void Write (TableHeapBuffer buffer)
  233. {
  234. for (int i = 0; i < length; i++) {
  235. buffer.WriteUInt32 (rows [i].Col1); // RVA
  236. buffer.WriteUInt16 ((ushort) rows [i].Col2); // ImplFlags
  237. buffer.WriteUInt16 ((ushort) rows [i].Col3); // Flags
  238. buffer.WriteString (rows [i].Col4); // Name
  239. buffer.WriteBlob (rows [i].Col5); // Signature
  240. buffer.WriteRID (rows [i].Col6, Table.Param); // ParamList
  241. }
  242. }
  243. }
  244. sealed class ParamTable : MetadataTable<ParamRow> {
  245. public override void Write (TableHeapBuffer buffer)
  246. {
  247. for (int i = 0; i < length; i++) {
  248. buffer.WriteUInt16 ((ushort) rows [i].Col1); // Attributes
  249. buffer.WriteUInt16 (rows [i].Col2); // Sequence
  250. buffer.WriteString (rows [i].Col3); // Name
  251. }
  252. }
  253. }
  254. sealed class InterfaceImplTable : MetadataTable<InterfaceImplRow> {
  255. public override void Write (TableHeapBuffer buffer)
  256. {
  257. for (int i = 0; i < length; i++) {
  258. buffer.WriteRID (rows [i].Col1, Table.TypeDef); // Class
  259. buffer.WriteCodedRID (rows [i].Col2, CodedIndex.TypeDefOrRef); // Interface
  260. }
  261. }
  262. /*public override int Compare (InterfaceImplRow x, InterfaceImplRow y)
  263. {
  264. return (int) (x.Col1 == y.Col1 ? y.Col2 - x.Col2 : x.Col1 - y.Col1);
  265. }*/
  266. }
  267. sealed class MemberRefTable : MetadataTable<MemberRefRow> {
  268. public override void Write (TableHeapBuffer buffer)
  269. {
  270. for (int i = 0; i < length; i++) {
  271. buffer.WriteCodedRID (rows [i].Col1, CodedIndex.MemberRefParent);
  272. buffer.WriteString (rows [i].Col2);
  273. buffer.WriteBlob (rows [i].Col3);
  274. }
  275. }
  276. }
  277. sealed class ConstantTable : SortedTable<ConstantRow> {
  278. public override void Write (TableHeapBuffer buffer)
  279. {
  280. for (int i = 0; i < length; i++) {
  281. buffer.WriteUInt16 ((ushort) rows [i].Col1);
  282. buffer.WriteCodedRID (rows [i].Col2, CodedIndex.HasConstant);
  283. buffer.WriteBlob (rows [i].Col3);
  284. }
  285. }
  286. public override int Compare (ConstantRow x, ConstantRow y)
  287. {
  288. return Compare (x.Col2, y.Col2);
  289. }
  290. }
  291. sealed class CustomAttributeTable : SortedTable<CustomAttributeRow> {
  292. public override void Write (TableHeapBuffer buffer)
  293. {
  294. for (int i = 0; i < length; i++) {
  295. buffer.WriteCodedRID (rows [i].Col1, CodedIndex.HasCustomAttribute); // Parent
  296. buffer.WriteCodedRID (rows [i].Col2, CodedIndex.CustomAttributeType); // Type
  297. buffer.WriteBlob (rows [i].Col3);
  298. }
  299. }
  300. public override int Compare (CustomAttributeRow x, CustomAttributeRow y)
  301. {
  302. return Compare (x.Col1, y.Col1);
  303. }
  304. }
  305. sealed class FieldMarshalTable : SortedTable<FieldMarshalRow> {
  306. public override void Write (TableHeapBuffer buffer)
  307. {
  308. for (int i = 0; i < length; i++) {
  309. buffer.WriteCodedRID (rows [i].Col1, CodedIndex.HasFieldMarshal);
  310. buffer.WriteBlob (rows [i].Col2);
  311. }
  312. }
  313. public override int Compare (FieldMarshalRow x, FieldMarshalRow y)
  314. {
  315. return Compare (x.Col1, y.Col1);
  316. }
  317. }
  318. sealed class DeclSecurityTable : SortedTable<DeclSecurityRow> {
  319. public override void Write (TableHeapBuffer buffer)
  320. {
  321. for (int i = 0; i < length; i++) {
  322. buffer.WriteUInt16 ((ushort) rows [i].Col1);
  323. buffer.WriteCodedRID (rows [i].Col2, CodedIndex.HasDeclSecurity);
  324. buffer.WriteBlob (rows [i].Col3);
  325. }
  326. }
  327. public override int Compare (DeclSecurityRow x, DeclSecurityRow y)
  328. {
  329. return Compare (x.Col2, y.Col2);
  330. }
  331. }
  332. sealed class ClassLayoutTable : SortedTable<ClassLayoutRow> {
  333. public override void Write (TableHeapBuffer buffer)
  334. {
  335. for (int i = 0; i < length; i++) {
  336. buffer.WriteUInt16 (rows [i].Col1); // PackingSize
  337. buffer.WriteUInt32 (rows [i].Col2); // ClassSize
  338. buffer.WriteRID (rows [i].Col3, Table.TypeDef); // Parent
  339. }
  340. }
  341. public override int Compare (ClassLayoutRow x, ClassLayoutRow y)
  342. {
  343. return Compare (x.Col3, y.Col3);
  344. }
  345. }
  346. sealed class FieldLayoutTable : SortedTable<FieldLayoutRow> {
  347. public override void Write (TableHeapBuffer buffer)
  348. {
  349. for (int i = 0; i < length; i++) {
  350. buffer.WriteUInt32 (rows [i].Col1); // Offset
  351. buffer.WriteRID (rows [i].Col2, Table.Field); // Parent
  352. }
  353. }
  354. public override int Compare (FieldLayoutRow x, FieldLayoutRow y)
  355. {
  356. return Compare (x.Col2, y.Col2);
  357. }
  358. }
  359. sealed class StandAloneSigTable : MetadataTable<uint> {
  360. public override void Write (TableHeapBuffer buffer)
  361. {
  362. for (int i = 0; i < length; i++)
  363. buffer.WriteBlob (rows [i]);
  364. }
  365. }
  366. sealed class EventMapTable : MetadataTable<EventMapRow> {
  367. public override void Write (TableHeapBuffer buffer)
  368. {
  369. for (int i = 0; i < length; i++) {
  370. buffer.WriteRID (rows [i].Col1, Table.TypeDef); // Parent
  371. buffer.WriteRID (rows [i].Col2, Table.Event); // EventList
  372. }
  373. }
  374. }
  375. sealed class EventTable : MetadataTable<EventRow> {
  376. public override void Write (TableHeapBuffer buffer)
  377. {
  378. for (int i = 0; i < length; i++) {
  379. buffer.WriteUInt16 ((ushort) rows [i].Col1); // Flags
  380. buffer.WriteString (rows [i].Col2); // Name
  381. buffer.WriteCodedRID (rows [i].Col3, CodedIndex.TypeDefOrRef); // EventType
  382. }
  383. }
  384. }
  385. sealed class PropertyMapTable : MetadataTable<PropertyMapRow> {
  386. public override void Write (TableHeapBuffer buffer)
  387. {
  388. for (int i = 0; i < length; i++) {
  389. buffer.WriteRID (rows [i].Col1, Table.TypeDef); // Parent
  390. buffer.WriteRID (rows [i].Col2, Table.Property); // PropertyList
  391. }
  392. }
  393. }
  394. sealed class PropertyTable : MetadataTable<PropertyRow> {
  395. public override void Write (TableHeapBuffer buffer)
  396. {
  397. for (int i = 0; i < length; i++) {
  398. buffer.WriteUInt16 ((ushort) rows [i].Col1); // Flags
  399. buffer.WriteString (rows [i].Col2); // Name
  400. buffer.WriteBlob (rows [i].Col3); // Type
  401. }
  402. }
  403. }
  404. sealed class MethodSemanticsTable : SortedTable<MethodSemanticsRow> {
  405. public override void Write (TableHeapBuffer buffer)
  406. {
  407. for (int i = 0; i < length; i++) {
  408. buffer.WriteUInt16 ((ushort) rows [i].Col1); // Flags
  409. buffer.WriteRID (rows [i].Col2, Table.Method); // Method
  410. buffer.WriteCodedRID (rows [i].Col3, CodedIndex.HasSemantics); // Association
  411. }
  412. }
  413. public override int Compare (MethodSemanticsRow x, MethodSemanticsRow y)
  414. {
  415. return Compare (x.Col3, y.Col3);
  416. }
  417. }
  418. sealed class MethodImplTable : MetadataTable<MethodImplRow> {
  419. public override void Write (TableHeapBuffer buffer)
  420. {
  421. for (int i = 0; i < length; i++) {
  422. buffer.WriteRID (rows [i].Col1, Table.TypeDef); // Class
  423. buffer.WriteCodedRID (rows [i].Col2, CodedIndex.MethodDefOrRef); // MethodBody
  424. buffer.WriteCodedRID (rows [i].Col3, CodedIndex.MethodDefOrRef); // MethodDeclaration
  425. }
  426. }
  427. }
  428. sealed class ModuleRefTable : MetadataTable<uint> {
  429. public override void Write (TableHeapBuffer buffer)
  430. {
  431. for (int i = 0; i < length; i++)
  432. buffer.WriteString (rows [i]); // Name
  433. }
  434. }
  435. sealed class TypeSpecTable : MetadataTable<uint> {
  436. public override void Write (TableHeapBuffer buffer)
  437. {
  438. for (int i = 0; i < length; i++)
  439. buffer.WriteBlob (rows [i]); // Signature
  440. }
  441. }
  442. sealed class ImplMapTable : SortedTable<ImplMapRow> {
  443. public override void Write (TableHeapBuffer buffer)
  444. {
  445. for (int i = 0; i < length; i++) {
  446. buffer.WriteUInt16 ((ushort) rows [i].Col1); // Flags
  447. buffer.WriteCodedRID (rows [i].Col2, CodedIndex.MemberForwarded); // MemberForwarded
  448. buffer.WriteString (rows [i].Col3); // ImportName
  449. buffer.WriteRID (rows [i].Col4, Table.ModuleRef); // ImportScope
  450. }
  451. }
  452. public override int Compare (ImplMapRow x, ImplMapRow y)
  453. {
  454. return Compare (x.Col2, y.Col2);
  455. }
  456. }
  457. sealed class FieldRVATable : SortedTable<FieldRVARow> {
  458. internal int position;
  459. public override void Write (TableHeapBuffer buffer)
  460. {
  461. position = buffer.position;
  462. for (int i = 0; i < length; i++) {
  463. buffer.WriteUInt32 (rows [i].Col1); // RVA
  464. buffer.WriteRID (rows [i].Col2, Table.Field); // Field
  465. }
  466. }
  467. public override int Compare (FieldRVARow x, FieldRVARow y)
  468. {
  469. return Compare (x.Col2, y.Col2);
  470. }
  471. }
  472. sealed class AssemblyTable : OneRowTable<AssemblyRow> {
  473. public override void Write (TableHeapBuffer buffer)
  474. {
  475. buffer.WriteUInt32 ((uint) row.Col1); // AssemblyHashAlgorithm
  476. buffer.WriteUInt16 (row.Col2); // MajorVersion
  477. buffer.WriteUInt16 (row.Col3); // MinorVersion
  478. buffer.WriteUInt16 (row.Col4); // Build
  479. buffer.WriteUInt16 (row.Col5); // Revision
  480. buffer.WriteUInt32 ((uint) row.Col6); // Flags
  481. buffer.WriteBlob (row.Col7); // PublicKey
  482. buffer.WriteString (row.Col8); // Name
  483. buffer.WriteString (row.Col9); // Culture
  484. }
  485. }
  486. sealed class AssemblyRefTable : MetadataTable<AssemblyRefRow> {
  487. public override void Write (TableHeapBuffer buffer)
  488. {
  489. for (int i = 0; i < length; i++) {
  490. buffer.WriteUInt16 (rows [i].Col1); // MajorVersion
  491. buffer.WriteUInt16 (rows [i].Col2); // MinorVersion
  492. buffer.WriteUInt16 (rows [i].Col3); // Build
  493. buffer.WriteUInt16 (rows [i].Col4); // Revision
  494. buffer.WriteUInt32 ((uint) rows [i].Col5); // Flags
  495. buffer.WriteBlob (rows [i].Col6); // PublicKeyOrToken
  496. buffer.WriteString (rows [i].Col7); // Name
  497. buffer.WriteString (rows [i].Col8); // Culture
  498. buffer.WriteBlob (rows [i].Col9); // Hash
  499. }
  500. }
  501. }
  502. sealed class FileTable : MetadataTable<FileRow> {
  503. public override void Write (TableHeapBuffer buffer)
  504. {
  505. for (int i = 0; i < length; i++) {
  506. buffer.WriteUInt32 ((uint) rows [i].Col1);
  507. buffer.WriteString (rows [i].Col2);
  508. buffer.WriteBlob (rows [i].Col3);
  509. }
  510. }
  511. }
  512. sealed class ExportedTypeTable : MetadataTable<ExportedTypeRow> {
  513. public override void Write (TableHeapBuffer buffer)
  514. {
  515. for (int i = 0; i < length; i++) {
  516. buffer.WriteUInt32 ((uint) rows [i].Col1);
  517. buffer.WriteUInt32 (rows [i].Col2);
  518. buffer.WriteString (rows [i].Col3);
  519. buffer.WriteString (rows [i].Col4);
  520. buffer.WriteCodedRID (rows [i].Col5, CodedIndex.Implementation);
  521. }
  522. }
  523. }
  524. sealed class ManifestResourceTable : MetadataTable<ManifestResourceRow> {
  525. public override void Write (TableHeapBuffer buffer)
  526. {
  527. for (int i = 0; i < length; i++) {
  528. buffer.WriteUInt32 (rows [i].Col1);
  529. buffer.WriteUInt32 ((uint) rows [i].Col2);
  530. buffer.WriteString (rows [i].Col3);
  531. buffer.WriteCodedRID (rows [i].Col4, CodedIndex.Implementation);
  532. }
  533. }
  534. }
  535. sealed class NestedClassTable : SortedTable<NestedClassRow> {
  536. public override void Write (TableHeapBuffer buffer)
  537. {
  538. for (int i = 0; i < length; i++) {
  539. buffer.WriteRID (rows [i].Col1, Table.TypeDef); // NestedClass
  540. buffer.WriteRID (rows [i].Col2, Table.TypeDef); // EnclosingClass
  541. }
  542. }
  543. public override int Compare (NestedClassRow x, NestedClassRow y)
  544. {
  545. return Compare (x.Col1, y.Col1);
  546. }
  547. }
  548. sealed class GenericParamTable : MetadataTable<GenericParamRow> {
  549. public override void Write (TableHeapBuffer buffer)
  550. {
  551. for (int i = 0; i < length; i++) {
  552. buffer.WriteUInt16 (rows [i].Col1); // Number
  553. buffer.WriteUInt16 ((ushort) rows [i].Col2); // Flags
  554. buffer.WriteCodedRID (rows [i].Col3, CodedIndex.TypeOrMethodDef); // Owner
  555. buffer.WriteString (rows [i].Col4); // Name
  556. }
  557. }
  558. }
  559. sealed class MethodSpecTable : MetadataTable<MethodSpecRow> {
  560. public override void Write (TableHeapBuffer buffer)
  561. {
  562. for (int i = 0; i < length; i++) {
  563. buffer.WriteCodedRID (rows [i].Col1, CodedIndex.MethodDefOrRef); // Method
  564. buffer.WriteBlob (rows [i].Col2); // Instantiation
  565. }
  566. }
  567. }
  568. sealed class GenericParamConstraintTable : MetadataTable<GenericParamConstraintRow> {
  569. public override void Write (TableHeapBuffer buffer)
  570. {
  571. for (int i = 0; i < length; i++) {
  572. buffer.WriteRID (rows [i].Col1, Table.GenericParam); // Owner
  573. buffer.WriteCodedRID (rows [i].Col2, CodedIndex.TypeDefOrRef); // Constraint
  574. }
  575. }
  576. }
  577. sealed class DocumentTable : MetadataTable<DocumentRow> {
  578. public override void Write (TableHeapBuffer buffer)
  579. {
  580. for (int i = 0; i < length; i++) {
  581. buffer.WriteBlob (rows [i].Col1); // Name
  582. buffer.WriteGuid (rows [i].Col2); // HashAlgorithm
  583. buffer.WriteBlob (rows [i].Col3); // Hash
  584. buffer.WriteGuid (rows [i].Col4); // Language
  585. }
  586. }
  587. }
  588. sealed class MethodDebugInformationTable : MetadataTable<MethodDebugInformationRow> {
  589. public override void Write (TableHeapBuffer buffer)
  590. {
  591. for (int i = 0; i < length; i++) {
  592. buffer.WriteRID (rows [i].Col1, Table.Document); // Document
  593. buffer.WriteBlob (rows [i].Col2); // SequencePoints
  594. }
  595. }
  596. }
  597. sealed class LocalScopeTable : MetadataTable<LocalScopeRow> {
  598. public override void Write (TableHeapBuffer buffer)
  599. {
  600. for (int i = 0; i < length; i++) {
  601. buffer.WriteRID (rows [i].Col1, Table.Method); // Method
  602. buffer.WriteRID (rows [i].Col2, Table.ImportScope); // ImportScope
  603. buffer.WriteRID (rows [i].Col3, Table.LocalVariable); // VariableList
  604. buffer.WriteRID (rows [i].Col4, Table.LocalConstant); // ConstantList
  605. buffer.WriteUInt32 (rows [i].Col5); // StartOffset
  606. buffer.WriteUInt32 (rows [i].Col6); // Length
  607. }
  608. }
  609. }
  610. sealed class LocalVariableTable : MetadataTable<LocalVariableRow> {
  611. public override void Write (TableHeapBuffer buffer)
  612. {
  613. for (int i = 0; i < length; i++) {
  614. buffer.WriteUInt16 ((ushort) rows [i].Col1); // Attributes
  615. buffer.WriteUInt16 (rows [i].Col2); // Index
  616. buffer.WriteString (rows [i].Col3); // Name
  617. }
  618. }
  619. }
  620. sealed class LocalConstantTable : MetadataTable<LocalConstantRow> {
  621. public override void Write (TableHeapBuffer buffer)
  622. {
  623. for (int i = 0; i < length; i++) {
  624. buffer.WriteString (rows [i].Col1); // Name
  625. buffer.WriteBlob (rows [i].Col2); // Signature
  626. }
  627. }
  628. }
  629. sealed class ImportScopeTable : MetadataTable<ImportScopeRow> {
  630. public override void Write (TableHeapBuffer buffer)
  631. {
  632. for (int i = 0; i < length; i++) {
  633. buffer.WriteRID (rows [i].Col1, Table.ImportScope); // Parent
  634. buffer.WriteBlob (rows [i].Col2); // Imports
  635. }
  636. }
  637. }
  638. sealed class StateMachineMethodTable : MetadataTable<StateMachineMethodRow> {
  639. public override void Write (TableHeapBuffer buffer)
  640. {
  641. for (int i = 0; i < length; i++) {
  642. buffer.WriteRID (rows [i].Col1, Table.Method); // MoveNextMethod
  643. buffer.WriteRID (rows [i].Col2, Table.Method); // KickoffMethod
  644. }
  645. }
  646. }
  647. sealed class CustomDebugInformationTable : SortedTable<CustomDebugInformationRow> {
  648. public override void Write (TableHeapBuffer buffer)
  649. {
  650. for (int i = 0; i < length; i++) {
  651. buffer.WriteCodedRID (rows [i].Col1, CodedIndex.HasCustomDebugInformation); // Parent
  652. buffer.WriteGuid (rows [i].Col2); // Kind
  653. buffer.WriteBlob (rows [i].Col3); // Value
  654. }
  655. }
  656. public override int Compare (CustomDebugInformationRow x, CustomDebugInformationRow y)
  657. {
  658. return Compare(x.Col1, y.Col1);
  659. }
  660. }
  661. sealed class MetadataBuilder {
  662. readonly internal ModuleDefinition module;
  663. readonly internal ISymbolWriterProvider symbol_writer_provider;
  664. internal ISymbolWriter symbol_writer;
  665. readonly internal TextMap text_map;
  666. readonly internal string fq_name;
  667. readonly internal uint timestamp;
  668. readonly Dictionary<TypeRefRow, MetadataToken> type_ref_map;
  669. readonly Dictionary<uint, MetadataToken> type_spec_map;
  670. readonly Dictionary<MemberRefRow, MetadataToken> member_ref_map;
  671. readonly Dictionary<MethodSpecRow, MetadataToken> method_spec_map;
  672. readonly Collection<GenericParameter> generic_parameters;
  673. readonly internal CodeWriter code;
  674. readonly internal DataBuffer data;
  675. readonly internal ResourceBuffer resources;
  676. readonly internal StringHeapBuffer string_heap;
  677. readonly internal GuidHeapBuffer guid_heap;
  678. readonly internal UserStringHeapBuffer user_string_heap;
  679. readonly internal BlobHeapBuffer blob_heap;
  680. readonly internal TableHeapBuffer table_heap;
  681. readonly internal PdbHeapBuffer pdb_heap;
  682. internal MetadataToken entry_point;
  683. internal RID type_rid = 1;
  684. internal RID field_rid = 1;
  685. internal RID method_rid = 1;
  686. internal RID param_rid = 1;
  687. internal RID property_rid = 1;
  688. internal RID event_rid = 1;
  689. internal RID local_variable_rid = 1;
  690. internal RID local_constant_rid = 1;
  691. readonly TypeRefTable type_ref_table;
  692. readonly TypeDefTable type_def_table;
  693. readonly FieldTable field_table;
  694. readonly MethodTable method_table;
  695. readonly ParamTable param_table;
  696. readonly InterfaceImplTable iface_impl_table;
  697. readonly MemberRefTable member_ref_table;
  698. readonly ConstantTable constant_table;
  699. readonly CustomAttributeTable custom_attribute_table;
  700. readonly DeclSecurityTable declsec_table;
  701. readonly StandAloneSigTable standalone_sig_table;
  702. readonly EventMapTable event_map_table;
  703. readonly EventTable event_table;
  704. readonly PropertyMapTable property_map_table;
  705. readonly PropertyTable property_table;
  706. readonly TypeSpecTable typespec_table;
  707. readonly MethodSpecTable method_spec_table;
  708. internal MetadataBuilder metadata_builder;
  709. readonly DocumentTable document_table;
  710. readonly MethodDebugInformationTable method_debug_information_table;
  711. readonly LocalScopeTable local_scope_table;
  712. readonly LocalVariableTable local_variable_table;
  713. readonly LocalConstantTable local_constant_table;
  714. readonly ImportScopeTable import_scope_table;
  715. readonly StateMachineMethodTable state_machine_method_table;
  716. readonly CustomDebugInformationTable custom_debug_information_table;
  717. readonly Dictionary<ImportScopeRow, MetadataToken> import_scope_map;
  718. readonly Dictionary<string, MetadataToken> document_map;
  719. public MetadataBuilder (ModuleDefinition module, string fq_name, uint timestamp, ISymbolWriterProvider symbol_writer_provider)
  720. {
  721. this.module = module;
  722. this.text_map = CreateTextMap ();
  723. this.fq_name = fq_name;
  724. this.timestamp = timestamp;
  725. this.symbol_writer_provider = symbol_writer_provider;
  726. this.code = new CodeWriter (this);
  727. this.data = new DataBuffer ();
  728. this.resources = new ResourceBuffer ();
  729. this.string_heap = new StringHeapBuffer ();
  730. this.guid_heap = new GuidHeapBuffer ();
  731. this.user_string_heap = new UserStringHeapBuffer ();
  732. this.blob_heap = new BlobHeapBuffer ();
  733. this.table_heap = new TableHeapBuffer (module, this);
  734. this.type_ref_table = GetTable<TypeRefTable> (Table.TypeRef);
  735. this.type_def_table = GetTable<TypeDefTable> (Table.TypeDef);
  736. this.field_table = GetTable<FieldTable> (Table.Field);
  737. this.method_table = GetTable<MethodTable> (Table.Method);
  738. this.param_table = GetTable<ParamTable> (Table.Param);
  739. this.iface_impl_table = GetTable<InterfaceImplTable> (Table.InterfaceImpl);
  740. this.member_ref_table = GetTable<MemberRefTable> (Table.MemberRef);
  741. this.constant_table = GetTable<ConstantTable> (Table.Constant);
  742. this.custom_attribute_table = GetTable<CustomAttributeTable> (Table.CustomAttribute);
  743. this.declsec_table = GetTable<DeclSecurityTable> (Table.DeclSecurity);
  744. this.standalone_sig_table = GetTable<StandAloneSigTable> (Table.StandAloneSig);
  745. this.event_map_table = GetTable<EventMapTable> (Table.EventMap);
  746. this.event_table = GetTable<EventTable> (Table.Event);
  747. this.property_map_table = GetTable<PropertyMapTable> (Table.PropertyMap);
  748. this.property_table = GetTable<PropertyTable> (Table.Property);
  749. this.typespec_table = GetTable<TypeSpecTable> (Table.TypeSpec);
  750. this.method_spec_table = GetTable<MethodSpecTable> (Table.MethodSpec);
  751. var row_equality_comparer = new RowEqualityComparer ();
  752. type_ref_map = new Dictionary<TypeRefRow, MetadataToken> (row_equality_comparer);
  753. type_spec_map = new Dictionary<uint, MetadataToken> ();
  754. member_ref_map = new Dictionary<MemberRefRow, MetadataToken> (row_equality_comparer);
  755. method_spec_map = new Dictionary<MethodSpecRow, MetadataToken> (row_equality_comparer);
  756. generic_parameters = new Collection<GenericParameter> ();
  757. this.document_table = GetTable<DocumentTable> (Table.Document);
  758. this.method_debug_information_table = GetTable<MethodDebugInformationTable> (Table.MethodDebugInformation);
  759. this.local_scope_table = GetTable<LocalScopeTable> (Table.LocalScope);
  760. this.local_variable_table = GetTable<LocalVariableTable> (Table.LocalVariable);
  761. this.local_constant_table = GetTable<LocalConstantTable> (Table.LocalConstant);
  762. this.import_scope_table = GetTable<ImportScopeTable> (Table.ImportScope);
  763. this.state_machine_method_table = GetTable<StateMachineMethodTable> (Table.StateMachineMethod);
  764. this.custom_debug_information_table = GetTable<CustomDebugInformationTable> (Table.CustomDebugInformation);
  765. this.document_map = new Dictionary<string, MetadataToken> (StringComparer.Ordinal);
  766. this.import_scope_map = new Dictionary<ImportScopeRow, MetadataToken> (row_equality_comparer);
  767. }
  768. public MetadataBuilder (ModuleDefinition module, PortablePdbWriterProvider writer_provider)
  769. {
  770. this.module = module;
  771. this.text_map = new TextMap ();
  772. this.symbol_writer_provider = writer_provider;
  773. this.string_heap = new StringHeapBuffer ();
  774. this.guid_heap = new GuidHeapBuffer ();
  775. this.user_string_heap = new UserStringHeapBuffer ();
  776. this.blob_heap = new BlobHeapBuffer ();
  777. this.table_heap = new TableHeapBuffer (module, this);
  778. this.pdb_heap = new PdbHeapBuffer();
  779. this.document_table = GetTable<DocumentTable> (Table.Document);
  780. this.method_debug_information_table = GetTable<MethodDebugInformationTable> (Table.MethodDebugInformation);
  781. this.local_scope_table = GetTable<LocalScopeTable> (Table.LocalScope);
  782. this.local_variable_table = GetTable<LocalVariableTable> (Table.LocalVariable);
  783. this.local_constant_table = GetTable<LocalConstantTable> (Table.LocalConstant);
  784. this.import_scope_table = GetTable<ImportScopeTable> (Table.ImportScope);
  785. this.state_machine_method_table = GetTable<StateMachineMethodTable> (Table.StateMachineMethod);
  786. this.custom_debug_information_table = GetTable<CustomDebugInformationTable> (Table.CustomDebugInformation);
  787. var row_equality_comparer = new RowEqualityComparer ();
  788. this.document_map = new Dictionary<string, MetadataToken> ();
  789. this.import_scope_map = new Dictionary<ImportScopeRow, MetadataToken> (row_equality_comparer);
  790. }
  791. public void SetSymbolWriter (ISymbolWriter writer)
  792. {
  793. symbol_writer = writer;
  794. if (symbol_writer == null && module.HasImage && module.Image.HasDebugTables ())
  795. symbol_writer = new PortablePdbWriter (this, module);
  796. }
  797. TextMap CreateTextMap ()
  798. {
  799. var map = new TextMap ();
  800. map.AddMap (TextSegment.ImportAddressTable, module.Architecture == TargetArchitecture.I386 ? 8 : 0);
  801. map.AddMap (TextSegment.CLIHeader, 0x48, 8);
  802. return map;
  803. }
  804. TTable GetTable<TTable> (Table table) where TTable : MetadataTable, new ()
  805. {
  806. return table_heap.GetTable<TTable> (table);
  807. }
  808. uint GetStringIndex (string @string)
  809. {
  810. if (string.IsNullOrEmpty (@string))
  811. return 0;
  812. return string_heap.GetStringIndex (@string);
  813. }
  814. uint GetGuidIndex (Guid guid)
  815. {
  816. return guid_heap.GetGuidIndex (guid);
  817. }
  818. uint GetBlobIndex (ByteBuffer blob)
  819. {
  820. if (blob.length == 0)
  821. return 0;
  822. return blob_heap.GetBlobIndex (blob);
  823. }
  824. uint GetBlobIndex (byte [] blob)
  825. {
  826. if (blob.IsNullOrEmpty ())
  827. return 0;
  828. return GetBlobIndex (new ByteBuffer (blob));
  829. }
  830. public void BuildMetadata ()
  831. {
  832. BuildModule ();
  833. table_heap.string_offsets = string_heap.WriteStrings ();
  834. table_heap.ComputeTableInformations ();
  835. table_heap.WriteTableHeap ();
  836. }
  837. void BuildModule ()
  838. {
  839. var table = GetTable<ModuleTable> (Table.Module);
  840. table.row.Col1 = GetStringIndex (module.Name);
  841. table.row.Col2 = GetGuidIndex (module.Mvid);
  842. var assembly = module.Assembly;
  843. if (assembly != null)
  844. BuildAssembly ();
  845. if (module.HasAssemblyReferences)
  846. AddAssemblyReferences ();
  847. if (module.HasModuleReferences)
  848. AddModuleReferences ();
  849. if (module.HasResources)
  850. AddResources ();
  851. if (module.HasExportedTypes)
  852. AddExportedTypes ();
  853. BuildTypes ();
  854. if (assembly != null) {
  855. if (assembly.HasCustomAttributes)
  856. AddCustomAttributes (assembly);
  857. if (assembly.HasSecurityDeclarations)
  858. AddSecurityDeclarations (assembly);
  859. }
  860. if (module.HasCustomAttributes)
  861. AddCustomAttributes (module);
  862. if (module.EntryPoint != null)
  863. entry_point = LookupToken (module.EntryPoint);
  864. }
  865. void BuildAssembly ()
  866. {
  867. var assembly = module.Assembly;
  868. var name = assembly.Name;
  869. var table = GetTable<AssemblyTable> (Table.Assembly);
  870. table.row = new AssemblyRow (
  871. name.HashAlgorithm,
  872. (ushort) name.Version.Major,
  873. (ushort) name.Version.Minor,
  874. (ushort) name.Version.Build,
  875. (ushort) name.Version.Revision,
  876. name.Attributes,
  877. GetBlobIndex (name.PublicKey),
  878. GetStringIndex (name.Name),
  879. GetStringIndex (name.Culture));
  880. if (assembly.Modules.Count > 1)
  881. BuildModules ();
  882. }
  883. void BuildModules ()
  884. {
  885. var modules = this.module.Assembly.Modules;
  886. var table = GetTable<FileTable> (Table.File);
  887. for (int i = 0; i < modules.Count; i++) {
  888. var module = modules [i];
  889. if (module.IsMain)
  890. continue;
  891. #if NET_CORE
  892. throw new NotSupportedException ();
  893. #else
  894. var parameters = new WriterParameters {
  895. SymbolWriterProvider = symbol_writer_provider,
  896. };
  897. var file_name = GetModuleFileName (module.Name);
  898. module.Write (file_name, parameters);
  899. var hash = CryptoService.ComputeHash (file_name);
  900. table.AddRow (new FileRow (
  901. FileAttributes.ContainsMetaData,
  902. GetStringIndex (module.Name),
  903. GetBlobIndex (hash)));
  904. #endif
  905. }
  906. }
  907. #if !NET_CORE
  908. string GetModuleFileName (string name)
  909. {
  910. if (string.IsNullOrEmpty (name))
  911. throw new NotSupportedException ();
  912. var path = Path.GetDirectoryName (fq_name);
  913. return Path.Combine (path, name);
  914. }
  915. #endif
  916. void AddAssemblyReferences ()
  917. {
  918. var references = module.AssemblyReferences;
  919. var table = GetTable<AssemblyRefTable> (Table.AssemblyRef);
  920. if (module.IsWindowsMetadata ())
  921. module.Projections.RemoveVirtualReferences (references);
  922. for (int i = 0; i < references.Count; i++) {
  923. var reference = references [i];
  924. var key_or_token = reference.PublicKey.IsNullOrEmpty ()
  925. ? reference.PublicKeyToken
  926. : reference.PublicKey;
  927. var version = reference.Version;
  928. var rid = table.AddRow (new AssemblyRefRow (
  929. (ushort) version.Major,
  930. (ushort) version.Minor,
  931. (ushort) version.Build,
  932. (ushort) version.Revision,
  933. reference.Attributes,
  934. GetBlobIndex (key_or_token),
  935. GetStringIndex (reference.Name),
  936. GetStringIndex (reference.Culture),
  937. GetBlobIndex (reference.Hash)));
  938. reference.token = new MetadataToken (TokenType.AssemblyRef, rid);
  939. }
  940. if (module.IsWindowsMetadata ())
  941. module.Projections.AddVirtualReferences (references);
  942. }
  943. void AddModuleReferences ()
  944. {
  945. var references = module.ModuleReferences;
  946. var table = GetTable<ModuleRefTable> (Table.ModuleRef);
  947. for (int i = 0; i < references.Count; i++) {
  948. var reference = references [i];
  949. reference.token = new MetadataToken (
  950. TokenType.ModuleRef,
  951. table.AddRow (GetStringIndex (reference.Name)));
  952. }
  953. }
  954. void AddResources ()
  955. {
  956. var resources = module.Resources;
  957. var table = GetTable<ManifestResourceTable> (Table.ManifestResource);
  958. for (int i = 0; i < resources.Count; i++) {
  959. var resource = resources [i];
  960. var row = new ManifestResourceRow (
  961. 0,
  962. resource.Attributes,
  963. GetStringIndex (resource.Name),
  964. 0);
  965. switch (resource.ResourceType) {
  966. case ResourceType.Embedded:
  967. row.Col1 = AddEmbeddedResource ((EmbeddedResource) resource);
  968. break;
  969. case ResourceType.Linked:
  970. row.Col4 = CodedIndex.Implementation.CompressMetadataToken (
  971. new MetadataToken (
  972. TokenType.File,
  973. AddLinkedResource ((LinkedResource) resource)));
  974. break;
  975. case ResourceType.AssemblyLinked:
  976. row.Col4 = CodedIndex.Implementation.CompressMetadataToken (
  977. ((AssemblyLinkedResource) resource).Assembly.MetadataToken);
  978. break;
  979. default:
  980. throw new NotSupportedException ();
  981. }
  982. table.AddRow (row);
  983. }
  984. }
  985. uint AddLinkedResource (LinkedResource resource)
  986. {
  987. var table = GetTable<FileTable> (Table.File);
  988. var hash = resource.Hash;
  989. if (hash.IsNullOrEmpty ())
  990. hash = CryptoService.ComputeHash (resource.File);
  991. return (uint) table.AddRow (new FileRow (
  992. FileAttributes.ContainsNoMetaData,
  993. GetStringIndex (resource.File),
  994. GetBlobIndex (hash)));
  995. }
  996. uint AddEmbeddedResource (EmbeddedResource resource)
  997. {
  998. return resources.AddResource (resource.GetResourceData ());
  999. }
  1000. void AddExportedTypes ()
  1001. {
  1002. var exported_types = module.ExportedTypes;
  1003. var table = GetTable<ExportedTypeTable> (Table.ExportedType);
  1004. for (int i = 0; i < exported_types.Count; i++) {
  1005. var exported_type = exported_types [i];
  1006. var rid = table.AddRow (new ExportedTypeRow (
  1007. exported_type.Attributes,
  1008. (uint) exported_type.Identifier,
  1009. GetStringIndex (exported_type.Name),
  1010. GetStringIndex (exported_type.Namespace),
  1011. MakeCodedRID (GetExportedTypeScope (exported_type), CodedIndex.Implementation)));
  1012. exported_type.token = new MetadataToken (TokenType.ExportedType, rid);
  1013. }
  1014. }
  1015. MetadataToken GetExportedTypeScope (ExportedType exported_type)
  1016. {
  1017. if (exported_type.DeclaringType != null)
  1018. return exported_type.DeclaringType.MetadataToken;
  1019. var scope = exported_type.Scope;
  1020. switch (scope.MetadataToken.TokenType) {
  1021. case TokenType.AssemblyRef:
  1022. return scope.MetadataToken;
  1023. case TokenType.ModuleRef:
  1024. var file_table = GetTable<FileTable> (Table.File);
  1025. for (int i = 0; i < file_table.length; i++)
  1026. if (file_table.rows [i].Col2 == GetStringIndex (scope.Name))
  1027. return new MetadataToken (TokenType.File, i + 1);
  1028. break;
  1029. }
  1030. throw new NotSupportedException ();
  1031. }
  1032. void BuildTypes ()
  1033. {
  1034. if (!module.HasTypes)
  1035. return;
  1036. AttachTokens ();
  1037. AddTypes ();
  1038. AddGenericParameters ();
  1039. }
  1040. void AttachTokens ()
  1041. {
  1042. var types = module.Types;
  1043. for (int i = 0; i < types.Count; i++)
  1044. AttachTypeToken (types [i]);
  1045. }
  1046. void AttachTypeToken (TypeDefinition type)
  1047. {
  1048. type.token = new MetadataToken (TokenType.TypeDef, type_rid++);
  1049. type.fields_range.Start = field_rid;
  1050. type.methods_range.Start = method_rid;
  1051. if (type.HasFields)
  1052. AttachFieldsToken (type);
  1053. if (type.HasMethods)
  1054. AttachMethodsToken (type);
  1055. if (type.HasNestedTypes)
  1056. AttachNestedTypesToken (type);
  1057. }
  1058. void AttachNestedTypesToken (TypeDefinition type)
  1059. {
  1060. var nested_types = type.NestedTypes;
  1061. for (int i = 0; i < nested_types.Count; i++)
  1062. AttachTypeToken (nested_types [i]);
  1063. }
  1064. void AttachFieldsToken (TypeDefinition type)
  1065. {
  1066. var fields = type.Fields;
  1067. type.fields_range.Length = (uint) fields.Count;
  1068. for (int i = 0; i < fields.Count; i++)
  1069. fields [i].token = new MetadataToken (TokenType.Field, field_rid++);
  1070. }
  1071. void AttachMethodsToken (TypeDefinition type)
  1072. {
  1073. var methods = type.Methods;
  1074. type.methods_range.Length = (uint) methods.Count;
  1075. for (int i = 0; i < methods.Count; i++)
  1076. methods [i].token = new MetadataToken (TokenType.Method, method_rid++);
  1077. }
  1078. MetadataToken GetTypeToken (TypeReference type)
  1079. {
  1080. if (type == null)
  1081. return MetadataToken.Zero;
  1082. if (type.IsDefinition)
  1083. return type.token;
  1084. if (type.IsTypeSpecification ())
  1085. return GetTypeSpecToken (type);
  1086. return GetTypeRefToken (type);
  1087. }
  1088. MetadataToken GetTypeSpecToken (TypeReference type)
  1089. {
  1090. var row = GetBlobIndex (GetTypeSpecSignature (type));
  1091. MetadataToken token;
  1092. if (type_spec_map.TryGetValue (row, out token))
  1093. return token;
  1094. return AddTypeSpecification (type, row);
  1095. }
  1096. MetadataToken AddTypeSpecification (TypeReference type, uint row)
  1097. {
  1098. type.token = new MetadataToken (TokenType.TypeSpec, typespec_table.AddRow (row));
  1099. var token = type.token;
  1100. type_spec_map.Add (row, token);
  1101. return token;
  1102. }
  1103. MetadataToken GetTypeRefToken (TypeReference type)
  1104. {
  1105. var projection = WindowsRuntimeProjections.RemoveProjection (type);
  1106. var row = CreateTypeRefRow (type);
  1107. MetadataToken token;
  1108. if (!type_ref_map.TryGetValue (row, out token))
  1109. token = AddTypeReference (type, row);
  1110. WindowsRuntimeProjections.ApplyProjection (type, projection);
  1111. return token;
  1112. }
  1113. TypeRefRow CreateTypeRefRow (TypeReference type)
  1114. {
  1115. var scope_token = GetScopeToken (type);
  1116. return new TypeRefRow (
  1117. MakeCodedRID (scope_token, CodedIndex.ResolutionScope),
  1118. GetStringIndex (type.Name),
  1119. GetStringIndex (type.Namespace));
  1120. }
  1121. MetadataToken GetScopeToken (TypeReference type)
  1122. {
  1123. if (type.IsNested)
  1124. return GetTypeRefToken (type.DeclaringType);
  1125. var scope = type.Scope;
  1126. if (scope == null)
  1127. return MetadataToken.Zero;
  1128. return scope.MetadataToken;
  1129. }
  1130. static CodedRID MakeCodedRID (IMetadataTokenProvider provider, CodedIndex index)
  1131. {
  1132. return MakeCodedRID (provider.MetadataToken, index);
  1133. }
  1134. static CodedRID MakeCodedRID (MetadataToken token, CodedIndex index)
  1135. {
  1136. return index.CompressMetadataToken (token);
  1137. }
  1138. MetadataToken AddTypeReference (TypeReference type, TypeRefRow row)
  1139. {
  1140. type.token = new MetadataToken (TokenType.TypeRef, type_ref_table.AddRow (row));
  1141. var token = type.token;
  1142. type_ref_map.Add (row, token);
  1143. return token;
  1144. }
  1145. void AddTypes ()
  1146. {
  1147. var types = module.Types;
  1148. for (int i = 0; i < types.Count; i++)
  1149. AddType (types [i]);
  1150. }
  1151. void AddType (TypeDefinition type)
  1152. {
  1153. var treatment = WindowsRuntimeProjections.RemoveProjection (type);
  1154. type_def_table.AddRow (new TypeDefRow (
  1155. type.Attributes,
  1156. GetStringIndex (type.Name),
  1157. GetStringIndex (type.Namespace),
  1158. MakeCodedRID (GetTypeToken (type.BaseType), CodedIndex.TypeDefOrRef),
  1159. type.fields_range.Start,
  1160. type.methods_range.Start));
  1161. if (type.HasGenericParameters)
  1162. AddGenericParameters (type);
  1163. if (type.HasInterfaces)
  1164. AddInterfaces (type);
  1165. AddLayoutInfo (type);
  1166. if (type.HasFields)
  1167. AddFields (type);
  1168. if (type.HasMethods)
  1169. AddMethods (type);
  1170. if (type.HasProperties)
  1171. AddProperties (type);
  1172. if (type.HasEvents)
  1173. AddEvents (type);
  1174. if (type.HasCustomAttributes)
  1175. AddCustomAttributes (type);
  1176. if (type.HasSecurityDeclarations)
  1177. AddSecurityDeclarations (type);
  1178. if (type.HasNestedTypes)
  1179. AddNestedTypes (type);
  1180. WindowsRuntimeProjections.ApplyProjection (type, treatment);
  1181. }
  1182. void AddGenericParameters (IGenericParameterProvider owner)
  1183. {
  1184. var parameters = owner.GenericParameters;
  1185. for (int i = 0; i < parameters.Count; i++)
  1186. generic_parameters.Add (parameters [i]);
  1187. }
  1188. sealed class GenericParameterComparer : IComparer<GenericParameter> {
  1189. public int Compare (GenericParameter a, GenericParameter b)
  1190. {
  1191. var a_owner = MakeCodedRID (a.Owner, CodedIndex.TypeOrMethodDef);
  1192. var b_owner = MakeCodedRID (b.Owner, CodedIndex.TypeOrMethodDef);
  1193. if (a_owner == b_owner) {
  1194. var a_pos = a.Position;
  1195. var b_pos = b.Position;
  1196. return a_pos == b_pos ? 0 : a_pos > b_pos ? 1 : -1;
  1197. }
  1198. return a_owner > b_owner ? 1 : -1;
  1199. }
  1200. }
  1201. void AddGenericParameters ()
  1202. {
  1203. var items = this.generic_parameters.items;
  1204. var size = this.generic_parameters.size;
  1205. Array.Sort (items, 0, size, new GenericParameterComparer ());
  1206. var generic_param_table = GetTable<GenericParamTable> (Table.GenericParam);
  1207. var generic_param_constraint_table = GetTable<GenericParamConstraintTable> (Table.GenericParamConstraint);
  1208. for (int i = 0; i < size; i++) {
  1209. var generic_parameter = items [i];
  1210. var rid = generic_param_table.AddRow (new GenericParamRow (
  1211. (ushort) generic_parameter.Position,
  1212. generic_parameter.Attributes,
  1213. MakeCodedRID (generic_parameter.Owner, CodedIndex.TypeOrMethodDef),
  1214. GetStringIndex (generic_parameter.Name)));
  1215. generic_parameter.token = new MetadataToken (TokenType.GenericParam, rid);
  1216. if (generic_parameter.HasConstraints)
  1217. AddConstraints (generic_parameter, generic_param_constraint_table);
  1218. if (generic_parameter.HasCustomAttributes)
  1219. AddCustomAttributes (generic_parameter);
  1220. }
  1221. }
  1222. void AddConstraints (GenericParameter generic_parameter, GenericParamConstraintTable table)
  1223. {
  1224. var constraints = generic_parameter.Constraints;
  1225. var gp_rid = generic_parameter.token.RID;
  1226. for (int i = 0; i < constraints.Count; i++) {
  1227. var constraint = constraints [i];
  1228. var rid = table.AddRow (new GenericParamConstraintRow (
  1229. gp_rid,
  1230. MakeCodedRID (GetTypeToken (constraint.ConstraintType), CodedIndex.TypeDefOrRef)));
  1231. constraint.token = new MetadataToken (TokenType.GenericParamConstraint, rid);
  1232. if (constraint.HasCustomAttributes)
  1233. AddCustomAttributes (constraint);
  1234. }
  1235. }
  1236. void AddInterfaces (TypeDefinition type)
  1237. {
  1238. var interfaces = type.Interfaces;
  1239. var type_rid = type.token.RID;
  1240. for (int i = 0; i < interfaces.Count; i++) {
  1241. var iface_impl = interfaces [i];
  1242. var rid = iface_impl_table.AddRow (new InterfaceImplRow (
  1243. type_rid,
  1244. MakeCodedRID (GetTypeToken (iface_impl.InterfaceType), CodedIndex.TypeDefOrRef)));
  1245. iface_impl.token = new MetadataToken (TokenType.InterfaceImpl, rid);
  1246. if (iface_impl.HasCustomAttributes)
  1247. AddCustomAttributes (iface_impl);
  1248. }
  1249. }
  1250. void AddLayoutInfo (TypeDefinition type)
  1251. {
  1252. if (type.HasLayoutInfo) {
  1253. var table = GetTable<ClassLayoutTable> (Table.ClassLayout);
  1254. table.AddRow (new ClassLayoutRow (
  1255. (ushort) type.PackingSize,
  1256. (uint) type.ClassSize,
  1257. type.token.RID));
  1258. return;
  1259. }
  1260. if (type.IsValueType && HasNoInstanceField (type)) {
  1261. var table = GetTable<ClassLayoutTable> (Table.ClassLayout);
  1262. table.AddRow (new ClassLayoutRow (0, 1, type.token.RID));
  1263. }
  1264. }
  1265. static bool HasNoInstanceField (TypeDefinition type)
  1266. {
  1267. if (!type.HasFields)
  1268. return true;
  1269. var fields = type.Fields;
  1270. for (int i = 0; i < fields.Count; i++)
  1271. if (!fields [i].IsStatic)
  1272. return false;
  1273. return true;
  1274. }
  1275. void AddNestedTypes (TypeDefinition type)
  1276. {
  1277. var nested_types = type.NestedTypes;
  1278. var nested_table = GetTable<NestedClassTable> (Table.NestedClass);
  1279. for (int i = 0; i < nested_types.Count; i++) {
  1280. var nested = nested_types [i];
  1281. AddType (nested);
  1282. nested_table.AddRow (new NestedClassRow (nested.token.RID, type.token.RID));
  1283. }
  1284. }
  1285. void AddFields (TypeDefinition type)
  1286. {
  1287. var fields = type.Fields;
  1288. for (int i = 0; i < fields.Count; i++)
  1289. AddField (fields [i]);
  1290. }
  1291. void AddField (FieldDefinition field)
  1292. {
  1293. var projection = WindowsRuntimeProjections.RemoveProjection (field);
  1294. field_table.AddRow (new FieldRow (
  1295. field.Attributes,
  1296. GetStringIndex (field.Name),
  1297. GetBlobIndex (GetFieldSignature (field))));
  1298. if (!field.InitialValue.IsNullOrEmpty ())
  1299. AddFieldRVA (field);
  1300. if (field.HasLayoutInfo)
  1301. AddFieldLayout (field);
  1302. if (field.HasCustomAttributes)
  1303. AddCustomAttributes (field);
  1304. if (field.HasConstant)
  1305. AddConstant (field, field.FieldType);
  1306. if (field.HasMarshalInfo)
  1307. AddMarshalInfo (field);
  1308. WindowsRuntimeProjections.ApplyProjection (field, projection);
  1309. }
  1310. void AddFieldRVA (FieldDefinition field)
  1311. {
  1312. var table = GetTable<FieldRVATable> (Table.FieldRVA);
  1313. table.AddRow (new FieldRVARow (
  1314. data.AddData (field.InitialValue),
  1315. field.token.RID));
  1316. }
  1317. void AddFieldLayout (FieldDefinition field)
  1318. {
  1319. var table = GetTable<FieldLayoutTable> (Table.FieldLayout);
  1320. table.AddRow (new FieldLayoutRow ((uint) field.Offset, field.token.RID));
  1321. }
  1322. void AddMethods (TypeDefinition type)
  1323. {
  1324. var methods = type.Methods;
  1325. for (int i = 0; i < methods.Count; i++)
  1326. AddMethod (methods [i]);
  1327. }
  1328. void AddMethod (MethodDefinition method)
  1329. {
  1330. var projection = WindowsRuntimeProjections.RemoveProjection (method);
  1331. method_table.AddRow (new MethodRow (
  1332. method.HasBody ? code.WriteMethodBody (method) : 0,
  1333. method.ImplAttributes,
  1334. method.Attributes,
  1335. GetStringIndex (method.Name),
  1336. GetBlobIndex (GetMethodSignature (method)),
  1337. param_rid));
  1338. AddParameters (method);
  1339. if (method.HasGenericParameters)
  1340. AddGenericParameters (method);
  1341. if (method.IsPInvokeImpl)
  1342. AddPInvokeInfo (method);
  1343. if (method.HasCustomAttributes)
  1344. AddCustomAttributes (method);
  1345. if (method.HasSecurityDeclarations)
  1346. AddSecurityDeclarations (method);
  1347. if (method.HasOverrides)
  1348. AddOverrides (method);
  1349. WindowsRuntimeProjections.ApplyProjection (method, projection);
  1350. }
  1351. void AddParameters (MethodDefinition method)
  1352. {
  1353. var return_parameter = method.MethodReturnType.parameter;
  1354. if (return_parameter != null && RequiresParameterRow (return_parameter))
  1355. AddParameter (0, return_parameter, param_table);
  1356. if (!method.HasParameters)
  1357. return;
  1358. var parameters = method.Parameters;
  1359. for (int i = 0; i < parameters.Count; i++) {
  1360. var parameter = parameters [i];
  1361. if (!RequiresParameterRow (parameter))
  1362. continue;
  1363. AddParameter ((ushort) (i + 1), parameter, param_table);
  1364. }
  1365. }
  1366. v