mcs/ilasm/codegen/CodeGen.cs

   1 //
   2 // Mono.ILASM.CodeGen.cs
   3 //
   4 // Author(s):
   5 //  Sergey Chaban (serge@wildwestsoftware.com)
   6 //  Jackson Harper (Jackson@LatitudeGeo.com)
   7 //
   8 // (C) Sergey Chaban
   9 // (C) 2003 Jackson Harper, All rights reserved
  10 //
  11
  12 using PEAPI;
  13 using System;
  14 using System.IO;
  15 using System.Collections;
  16 using System.Reflection;
  17 using System.Reflection.Emit;
  18
  19 namespace Mono.ILASM {
  20
  21         public class CodeGen {
  22
  23                 private PEFile pefile;
  24                 private string assembly_name;
  25                 private Report report;
  26                 private ExternAssembly current_assemblyref;
  27                 private ExternModule current_moduleref;
  28                 private string current_namespace;
  29                 private TypeDef current_typedef;
  30                 private MethodDef current_methoddef;
  31                 private Stack typedef_stack;
  32                 private SymbolWriter symwriter;
  33
  34                 private byte [] assembly_public_key;
  35                 private int assembly_major_version;
  36                 private int assembly_minor_version;
  37                 private int assembly_build_version;
  38                 private int assembly_revision_version;
  39                 private string assembly_locale;
  40                 private int assembly_hash_algorithm;
  41                 private ArrayList assembly_custom_attributes;
  42
  43                 private TypeManager type_manager;
  44                 private ExternTable extern_table;
  45                 private Hashtable global_field_table;
  46                 private Hashtable global_method_table;
  47                 private ArrayList data_list;
  48                 private FileRef file_ref;
  49
  50                 private ArrayList defcont_list;
  51
  52                 private int sub_system;
  53                 private int cor_flags;
  54                 private long image_base;
  55
  56                 private string output_file;
  57                 private string debug_file;
  58                 private bool is_dll;
  59                 private bool is_assembly;
  60
  61                 private string module_name;
  62
  63                 public CodeGen (string output_file, bool is_dll, bool is_assembly,
  64                                 bool debugging_info, Report report)
  65                 {
  66                         this.output_file = output_file;
  67                         this.is_dll = is_dll;
  68                         this.is_assembly = is_assembly;
  69                         this.report = report;
  70
  71                         if (debugging_info)
  72                                 symwriter = new SymbolWriter (CreateDebugFile (output_file));
  73
  74                         type_manager = new TypeManager (this);
  75                         extern_table = new ExternTable ();
  76                         typedef_stack = new Stack ();
  77                         global_field_table = new Hashtable ();
  78                         global_method_table = new Hashtable ();
  79
  80                         data_list = new ArrayList ();
  81
  82                         defcont_list = new ArrayList ();
  83
  84                         sub_system = -1;
  85                         cor_flags = -1;
  86                         image_base = -1;
  87                 }
  88
  89                 private string CreateDebugFile (string output_file)
  90                 {
  91                         int ext_index = output_file.LastIndexOf ('.');
  92
  93                         if (ext_index == -1)
  94                                 ext_index = output_file.Length;
  95
  96                         return String.Format ("{0}.{1}", output_file.Substring (0, ext_index),
  97                                               "mdb");
  98                 }
  99
 100                 public PEFile PEFile {
 101                         get { return pefile; }
 102                 }
 103
 104                 public Report Report {
 105                         get { return report; }
 106                 }
 107
 108                 public SymbolWriter SymbolWriter {
 109                         get { return symwriter; }
 110                 }
 111
 112                 public string CurrentNameSpace {
 113                         get { return current_namespace; }
 114                         set { current_namespace = value; }
 115                 }
 116
 117                 public TypeDef CurrentTypeDef {
 118                         get { return current_typedef; }
 119                 }
 120
 121                 public MethodDef CurrentMethodDef {
 122                         get { return current_methoddef; }
 123                 }
 124
 125                 public ExternAssembly CurrentAssemblyRef {
 126                         get { return current_assemblyref; }
 127                 }
 128
 129                 public ExternModule CurrentModuleRef {
 130                         get { return current_moduleref; }
 131                 }
 132
 133                 public ExternTable ExternTable {
 134                         get { return extern_table; }
 135                 }
 136
 137                 public TypeManager TypeManager {
 138                         get { return type_manager; }
 139                 }
 140
 141                 public void SetSubSystem (int sub_system)
 142                 {
 143                         this.sub_system = sub_system;
 144                 }
 145
 146                 public void SetCorFlags (int cor_flags)
 147                 {
 148                         this.cor_flags = cor_flags;
 149                 }
 150
 151                 public void SetImageBase (long image_base)
 152                 {
 153                         this.image_base = image_base;
 154                 }
 155
 156                 public void SetAssemblyName (string name)
 157                 {
 158                         assembly_name = name;
 159                 }
 160
 161                 public void SetModuleName (string module_name)
 162                 {
 163                         this.module_name = module_name;
 164                 }
 165
 166                 public void SetFileRef (FileRef file_ref)
 167                 {
 168                         this.file_ref = file_ref;
 169                 }
 170
 171                 public bool IsThisAssembly (string name)
 172                 {
 173                         return (name == assembly_name);
 174                 }
 175
 176                 public bool IsThisModule (string name)
 177                 {
 178                         return (name == module_name);
 179                 }
 180
 181                 public void BeginSourceFile (string name)
 182                 {
 183                         if (symwriter != null)
 184                                 symwriter.BeginSourceFile (name);
 185                 }
 186
 187                 public void EndSourceFile ()
 188                 {
 189                         if (symwriter != null)
 190                                 symwriter.EndSourceFile ();
 191                 }
 192
 193                 public void BeginTypeDef (TypeAttr attr, string name, IClassRef parent,
 194                                 ArrayList impl_list, Location location)
 195                 {
 196                         TypeDef outer = null;
 197                         string cache_name = CacheName (name);
 198
 199                         if (typedef_stack.Count > 0) {
 200                                 outer = (TypeDef) typedef_stack.Peek ();
 201                                 cache_name = CacheName (outer.Name + '/' + name);
 202                         }
 203
 204                         TypeDef typedef = type_manager[cache_name];
 205
 206                         if (typedef != null) {
 207                                 // Class head is allready defined, we are just reopening the class
 208                                 current_typedef = typedef;
 209                                 typedef_stack.Push (current_typedef);
 210                                 return;
 211                         }
 212
 213                         typedef = new TypeDef (attr, current_namespace,
 214                                         name, parent, impl_list, location);
 215
 216                         if (outer != null)
 217                                 typedef.OuterType = outer;
 218
 219                         type_manager[cache_name] = typedef;
 220                         current_typedef = typedef;
 221                         typedef_stack.Push (typedef);
 222                 }
 223
 224                 public void AddFieldDef (FieldDef fielddef)
 225                 {
 226                         if (current_typedef != null) {
 227                                 current_typedef.AddFieldDef (fielddef);
 228                         } else {
 229                                 global_field_table.Add (fielddef.Name,
 230                                                 fielddef);
 231                         }
 232                 }
 233
 234                 public void AddDataDef (DataDef datadef)
 235                 {
 236                         data_list.Add (datadef);
 237                 }
 238
 239                 public PEAPI.DataConstant GetDataConst (string name)
 240                 {
 241                         foreach (DataDef def in data_list) {
 242                                 if (def.Name == name)
 243                                         return (DataConstant) def.PeapiConstant;
 244                         }
 245                         return null;
 246
 247                 }
 248
 249                 public void BeginMethodDef (MethodDef methoddef)
 250                 {
 251                         if (current_typedef != null) {
 252                                 current_typedef.AddMethodDef (methoddef);
 253                         } else {
 254                                 global_method_table.Add (methoddef.Signature,
 255                                                 methoddef);
 256                         }
 257
 258                         current_methoddef = methoddef;
 259                 }
 260
 261                 public void EndMethodDef (Location location)
 262                 {
 263                         if (symwriter != null)
 264                                 symwriter.EndMethod (location);
 265
 266                         current_methoddef = null;
 267                 }
 268
 269                 public void EndTypeDef ()
 270                 {
 271                         typedef_stack.Pop ();
 272
 273                         if (typedef_stack.Count > 0)
 274                                 current_typedef = (TypeDef) typedef_stack.Peek ();
 275                         else
 276                                 current_typedef = null;
 277
 278                 }
 279
 280                 public void BeginAssemblyRef (string name, AssemblyName asmb_name)
 281                 {
 282                         current_assemblyref = ExternTable.AddAssembly (name, asmb_name);
 283                 }
 284
 285                 public void EndAssemblyRef ()
 286                 {
 287                         current_assemblyref = null;
 288                 }
 289
 290                 public void AddToDefineContentsList (TypeDef typedef)
 291                 {
 292                         defcont_list.Add (typedef);
 293                 }
 294
 295                 public void SetAssemblyPublicKey (byte [] public_key)
 296                 {
 297                         assembly_public_key = public_key;
 298                 }
 299
 300                 public void SetAssemblyVersion (int major, int minor, int build, int revision)
 301                 {
 302                         assembly_major_version = major;
 303                         assembly_minor_version = minor;
 304                         assembly_build_version = build;
 305                         assembly_revision_version = revision;
 306                 }
 307
 308                 public void SetAssemblyLocale (string locale)
 309                 {
 310                         assembly_locale = locale;
 311                 }
 312
 313                 public void SetAssemblyHashAlgorithm (int algorithm)
 314                 {
 315                         assembly_hash_algorithm = algorithm;
 316                 }
 317
 318                 public void AddAssemblyCustomAttribute (CustomAttr attribute)
 319                 {
 320                         if (assembly_custom_attributes == null)
 321                                 assembly_custom_attributes = new ArrayList ();
 322                         assembly_custom_attributes.Add (attribute);
 323                 }
 324
 325                 public void Write ()
 326                 {
 327                         FileStream out_stream = null;
 328
 329                         try {
 330                                 out_stream = new FileStream (output_file, FileMode.Create, FileAccess.Write);
 331                                 pefile = new PEFile (assembly_name, module_name, is_dll, is_assembly, out_stream);
 332                                 PEAPI.Assembly asmb = pefile.GetThisAssembly ();
 333
 334                                 if (file_ref != null)
 335                                         file_ref.Resolve (this);
 336
 337                                 extern_table.Resolve (this);
 338                                 type_manager.DefineAll ();
 339
 340                                 foreach (FieldDef fielddef in global_field_table.Values) {
 341                                         fielddef.Define (this);
 342                                 }
 343
 344                                 foreach (MethodDef methoddef in global_method_table.Values) {
 345                                         methoddef.Define (this);
 346                                 }
 347
 348                                 foreach (TypeDef typedef in defcont_list) {
 349                                         typedef.DefineContents (this);
 350                                 }
 351
 352                                 if (assembly_custom_attributes != null) {
 353                                         foreach (CustomAttr cattr in assembly_custom_attributes)
 354                                                 cattr.AddTo (this, asmb);
 355                                 }
 356
 357                                 if (sub_system != -1)
 358                                         pefile.SetSubSystem ((PEAPI.SubSystem) sub_system);
 359                                 if (cor_flags != -1)
 360                                         pefile.SetCorFlags (cor_flags);
 361
 362                                 asmb.AddAssemblyInfo(assembly_major_version,
 363                                                 assembly_minor_version, assembly_build_version,
 364                                                 assembly_revision_version, assembly_public_key,
 365                                                 (uint) assembly_hash_algorithm, assembly_locale);
 366
 367                                 pefile.WritePEFile ();
 368
 369                                 if (symwriter != null) {
 370                                         Guid guid = pefile.GetThisModule ().Guid;
 371                                         symwriter.Write (guid);
 372                                 }
 373                         } catch {
 374                                 throw;
 375                         } finally {
 376                                 if (out_stream != null)
 377                                         out_stream.Close ();
 378                         }
 379                 }
 380
 381                 public PEAPI.Method ResolveMethod (string signature)
 382                 {
 383                         MethodDef methoddef = (MethodDef) global_method_table[signature];
 384
 385                         return methoddef.Resolve (this);
 386                 }
 387
 388                 public PEAPI.Method ResolveVarargMethod (string signature,
 389                                 CodeGen code_gen, PEAPI.Type[] opt)
 390                 {
 391                         MethodDef methoddef = (MethodDef) global_method_table[signature];
 392                         methoddef.Resolve (code_gen);
 393
 394                         return methoddef.GetVarargSig (opt);
 395                 }
 396
 397                 public PEAPI.Field ResolveField (string name)
 398                 {
 399                         FieldDef fielddef = (FieldDef) global_field_table[name];
 400
 401                         return fielddef.Resolve (this);
 402                 }
 403
 404                 private string CacheName (string name)
 405                 {
 406                         if (current_namespace == null ||
 407                                         current_namespace == String.Empty)
 408                                 return name;
 409
 410                         return current_namespace + "." + name;
 411                 }
 412         }
 413
 414 }
 415