mcs/mcs/codegen.cs

   1 //
   2 // codegen.cs: The code generator
   3 //
   4 // Author:
   5 //   Miguel de Icaza (miguel@ximian.com)
   6 //
   7 // (C) 2001 Ximian, Inc.
   8 //
   9
  10 using System;
  11 using System.Collections;
  12 using System.Reflection;
  13 using System.Reflection.Emit;
  14 using System.Diagnostics.SymbolStore;
  15
  16 namespace Mono.CSharp {
  17
  18         /// <summary>
  19         ///    Code generator class.
  20         /// </summary>
  21         public class CodeGen {
  22                 static AppDomain current_domain;
  23                 public static AssemblyBuilder AssemblyBuilder;
  24                 public static ModuleBuilder   ModuleBuilder;
  25
  26                 static public ISymbolWriter SymbolWriter;
  27
  28                 public static string Basename (string name)
  29                 {
  30                         int pos = name.LastIndexOf ("/");
  31
  32                         if (pos != -1)
  33                                 return name.Substring (pos + 1);
  34
  35                         pos = name.LastIndexOf ("\\");
  36                         if (pos != -1)
  37                                 return name.Substring (pos + 1);
  38
  39                         return name;
  40                 }
  41
  42                 public static string Dirname (string name)
  43                 {
  44                         int pos = name.LastIndexOf ("/");
  45
  46                         if (pos != -1)
  47                                 return name.Substring (0, pos);
  48
  49                         pos = name.LastIndexOf ("\\");
  50                         if (pos != -1)
  51                                 return name.Substring (0, pos);
  52
  53                         return ".";
  54                 }
  55
  56                 static string TrimExt (string name)
  57                 {
  58                         int pos = name.LastIndexOf (".");
  59
  60                         return name.Substring (0, pos);
  61                 }
  62
  63                 static public string FileName;
  64
  65                 //
  66                 // This routine initializes the Mono runtime SymbolWriter.
  67                 //
  68                 static void InitMonoSymbolWriter (string basename, string[] debug_args)
  69                 {
  70                         string symbol_output = basename + "-debug.s";
  71
  72                         Type itype = SymbolWriter.GetType ();
  73                         if (itype == null)
  74                                 return;
  75
  76                         Type[] arg_types = new Type [2];
  77                         arg_types [0] = typeof (string);
  78                         arg_types [1] = typeof (string[]);
  79
  80                         MethodInfo initialize = itype.GetMethod ("Initialize", arg_types);
  81                         if (initialize == null)
  82                                 return;
  83
  84                         object[] args = new object [2];
  85                         args [0] = symbol_output;
  86                         args [1] = debug_args;
  87
  88                         initialize.Invoke (SymbolWriter, args);
  89                 }
  90
  91                 //
  92                 // Initializes the symbol writer
  93                 //
  94                 static void InitializeSymbolWriter (string basename, string[] args)
  95                 {
  96                         SymbolWriter = ModuleBuilder.GetSymWriter ();
  97
  98                         //
  99                         // If we got an ISymbolWriter instance, initialize it.
 100                         //
 101                         if (SymbolWriter == null)
 102                                 return;
 103
 104                         //
 105                         // Due to lacking documentation about the first argument of the
 106                         // Initialize method, we cannot use Microsoft's default symbol
 107                         // writer yet.
 108                         //
 109                         // If we're using the mono symbol writer, the SymbolWriter object
 110                         // is of type MonoSymbolWriter - but that's defined in a dynamically
 111                         // loaded DLL - that's why we're doing a comparision based on the type
 112                         // name here instead of using `SymbolWriter is MonoSymbolWriter'.
 113                         //
 114                         Type sym_type = ((object) SymbolWriter).GetType ();
 115
 116                         switch (sym_type.Name){
 117                         case "MonoSymbolWriter":
 118                                 InitMonoSymbolWriter (basename, args);
 119                                 break;
 120
 121                         default:
 122                                 Report.Error (
 123                                         -18, "Cannot generate debugging information on this platform");
 124                                 break;
 125                         }
 126                 }
 127
 128                 //
 129                 // Initializes the code generator variables
 130                 //
 131                 static public void Init (string name, string output, bool want_debugging_support,
 132                                          string[] debug_args)
 133                 {
 134                         AssemblyName an;
 135
 136                         FileName = output;
 137                         an = new AssemblyName ();
 138                         an.Name = TrimExt (Basename (name));
 139                         current_domain = AppDomain.CurrentDomain;
 140                         AssemblyBuilder = current_domain.DefineDynamicAssembly (
 141                                 an, AssemblyBuilderAccess.RunAndSave, Dirname (name));
 142
 143                         //
 144                         // Pass a path-less name to DefineDynamicModule.  Wonder how
 145                         // this copes with output in different directories then.
 146                         // FIXME: figure out how this copes with --output /tmp/blah
 147                         //
 148                         // If the third argument is true, the ModuleBuilder will dynamically
 149                         // load the default symbol writer.
 150                         //
 151                         ModuleBuilder = AssemblyBuilder.DefineDynamicModule (
 152                                 Basename (name), Basename (output), want_debugging_support);
 153
 154                         if (want_debugging_support)
 155                                 InitializeSymbolWriter (an.Name, debug_args);
 156                 }
 157
 158                 static public void Save (string name)
 159                 {
 160                         try {
 161                                 AssemblyBuilder.Save (Basename (name));
 162                         } catch (System.IO.IOException io){
 163                                 Report.Error (16, "Coult not write to file `"+name+"', cause: " + io.Message);
 164                         }
 165                 }
 166
 167                 static public void SaveSymbols ()
 168                 {
 169                         if (SymbolWriter != null) {
 170                                 // If we have a symbol writer, call its Close() method to write
 171                                 // the symbol file to disk.
 172                                 //
 173                                 // When using Mono's default symbol writer, the Close() method must
 174                                 // be called after the assembly has already been written to disk since
 175                                 // it opens the assembly and reads its metadata.
 176                                 SymbolWriter.Close ();
 177                         }
 178                 }
 179         }
 180
 181         /// <summary>
 182         ///   An Emit Context is created for each body of code (from methods,
 183         ///   properties bodies, indexer bodies or constructor bodies)
 184         /// </summary>
 185         public class EmitContext {
 186                 public DeclSpace DeclSpace;
 187                 public TypeContainer TypeContainer;
 188                 public ILGenerator   ig;
 189
 190                 /// <summary>
 191                 ///   This variable tracks the `checked' state of the compilation,
 192                 ///   it controls whether we should generate code that does overflow
 193                 ///   checking, or if we generate code that ignores overflows.
 194                 ///
 195                 ///   The default setting comes from the command line option to generate
 196                 ///   checked or unchecked code plus any source code changes using the
 197                 ///   checked/unchecked statements or expressions.   Contrast this with
 198                 ///   the ConstantCheckState flag.
 199                 /// </summary>
 200
 201                 public bool CheckState;
 202
 203                 /// <summary>
 204                 ///   The constant check state is always set to `true' and cant be changed
 205                 ///   from the command line.  The source code can change this setting with
 206                 ///   the `checked' and `unchecked' statements and expressions.
 207                 /// </summary>
 208                 public bool ConstantCheckState;
 209
 210                 /// <summary>
 211                 ///   Whether we are emitting code inside a static or instance method
 212                 /// </summary>
 213                 public bool IsStatic;
 214
 215                 /// <summary>
 216                 ///   Whether we are emitting a field initializer
 217                 /// </summary>
 218                 public bool IsFieldInitializer;
 219
 220                 /// <summary>
 221                 ///   The value that is allowed to be returned or NULL if there is no
 222                 ///   return type.
 223                 /// </summary>
 224                 public Type ReturnType;
 225
 226                 /// <summary>
 227                 ///   Points to the Type (extracted from the TypeContainer) that
 228                 ///   declares this body of code
 229                 /// </summary>
 230                 public Type ContainerType;
 231
 232                 /// <summary>
 233                 ///   Whether this is generating code for a constructor
 234                 /// </summary>
 235                 public bool IsConstructor;
 236
 237                 /// <summary>
 238                 ///   Whether we're control flow analysis enabled
 239                 /// </summary>
 240                 public bool DoFlowAnalysis;
 241
 242                 /// <summary>
 243                 ///   Keeps track of the Type to LocalBuilder temporary storage created
 244                 ///   to store structures (used to compute the address of the structure
 245                 ///   value on structure method invocations)
 246                 /// </summary>
 247                 public Hashtable temporary_storage;
 248
 249                 public Block CurrentBlock;
 250
 251                 /// <summary>
 252                 ///   The location where we store the return value.
 253                 /// </summary>
 254                 LocalBuilder return_value;
 255
 256                 /// <summary>
 257                 ///   The location where return has to jump to return the
 258                 ///   value
 259                 /// </summary>
 260                 public Label ReturnLabel;
 261
 262                 /// <summary>
 263                 ///   If we already defined the ReturnLabel
 264                 /// </summary>
 265                 public bool HasReturnLabel;
 266
 267                 /// <summary>
 268                 ///   Whether we are in a Finally block
 269                 /// </summary>
 270                 public bool InFinally;
 271
 272                 /// <summary>
 273                 ///   Whether we are in a Try block
 274                 /// </summary>
 275                 public bool InTry;
 276
 277                 /// <summary>
 278                 ///   Whether we are in a Catch block
 279                 /// </summary>
 280                 public bool InCatch;
 281
 282                 /// <summary>
 283                 ///  Whether we are inside an unsafe block
 284                 /// </summary>
 285                 public bool InUnsafe;
 286
 287                 /// <summary>
 288                 ///   Whether we break from a loop or not
 289                 /// </summary>
 290                 public bool Breaks;
 291
 292                 /// <summary>
 293                 ///   Location for this EmitContext
 294                 /// </summary>
 295                 public Location loc;
 296
 297                 /// <summary>
 298                 ///   Used to flag that it is ok to define types recursively, as the
 299                 ///   expressions are being evaluated as part of the type lookup
 300                 ///   during the type resolution process
 301                 /// </summary>
 302                 public bool ResolvingTypeTree;
 303
 304                 /// <summary>
 305                 ///   Inside an enum definition, we do not resolve enumeration values
 306                 ///   to their enumerations, but rather to the underlying type/value
 307                 ///   This is so EnumVal + EnumValB can be evaluated.
 308                 ///
 309                 ///   There is no "E operator + (E x, E y)", so during an enum evaluation
 310                 ///   we relax the rules
 311                 /// </summary>
 312                 public bool InEnumContext;
 313
 314                 protected Stack FlowStack;
 315
 316                 public EmitContext (TypeContainer parent, DeclSpace ds, Location l, ILGenerator ig,
 317                                     Type return_type, int code_flags, bool is_constructor)
 318                 {
 319                         this.ig = ig;
 320
 321                         TypeContainer = parent;
 322                         DeclSpace = ds;
 323                         CheckState = RootContext.Checked;
 324                         ConstantCheckState = true;
 325
 326                         IsStatic = (code_flags & Modifiers.STATIC) != 0;
 327                         ReturnType = return_type;
 328                         IsConstructor = is_constructor;
 329                         CurrentBlock = null;
 330
 331                         if (parent != null){
 332                                 // Can only be null for the ResolveType contexts.
 333                                 ContainerType = parent.TypeBuilder;
 334                                 if (parent.UnsafeContext)
 335                                         InUnsafe = true;
 336                                 else
 337                                         InUnsafe = (code_flags & Modifiers.UNSAFE) != 0;
 338                         }
 339                         loc = l;
 340
 341                         FlowStack = new Stack ();
 342
 343                         if (ReturnType == TypeManager.void_type)
 344                                 ReturnType = null;
 345                 }
 346
 347                 public EmitContext (TypeContainer tc, Location l, ILGenerator ig,
 348                                     Type return_type, int code_flags, bool is_constructor)
 349                         : this (tc, tc, l, ig, return_type, code_flags, is_constructor)
 350                 {
 351                 }
 352
 353                 public EmitContext (TypeContainer tc, Location l, ILGenerator ig,
 354                                     Type return_type, int code_flags)
 355                         : this (tc, tc, l, ig, return_type, code_flags, false)
 356                 {
 357                 }
 358
 359                 public FlowBranching CurrentBranching {
 360                         get {
 361                                 return (FlowBranching) FlowStack.Peek ();
 362                         }
 363                 }
 364
 365                 // <summary>
 366                 //   Starts a new code branching.  This inherits the state of all local
 367                 //   variables and parameters from the current branching.
 368                 // </summary>
 369                 public FlowBranching StartFlowBranching (FlowBranchingType type, Location loc)
 370                 {
 371                         FlowBranching cfb = new FlowBranching (CurrentBranching, type, null, loc);
 372
 373                         FlowStack.Push (cfb);
 374
 375                         return cfb;
 376                 }
 377
 378                 // <summary>
 379                 //   Starts a new code branching for block `block'.
 380                 // </summary>
 381                 public FlowBranching StartFlowBranching (Block block)
 382                 {
 383                         FlowBranching cfb;
 384                         FlowBranchingType type;
 385
 386                         if (CurrentBranching.Type == FlowBranchingType.SWITCH)
 387                                 type = FlowBranchingType.SWITCH_SECTION;
 388                         else
 389                                 type = FlowBranchingType.BLOCK;
 390
 391                         cfb = new FlowBranching (CurrentBranching, type, block, block.StartLocation);
 392
 393                         FlowStack.Push (cfb);
 394
 395                         return cfb;
 396                 }
 397
 398                 // <summary>
 399                 //   Ends a code branching.  Merges the state of locals and parameters
 400                 //   from all the children of the ending branching.
 401                 // </summary>
 402                 public FlowReturns EndFlowBranching ()
 403                 {
 404                         FlowBranching cfb = (FlowBranching) FlowStack.Pop ();
 405
 406                         return CurrentBranching.MergeChild (cfb);
 407                 }
 408
 409                 // <summary>
 410                 //   Kills the current code branching.  This throws away any changed state
 411                 //   information and should only be used in case of an error.
 412                 // </summary>
 413                 public void KillFlowBranching ()
 414                 {
 415                         FlowBranching cfb = (FlowBranching) FlowStack.Pop ();
 416                 }
 417
 418                 // <summary>
 419                 //   Checks whether the local variable `vi' is already initialized
 420                 //   at the current point of the method's control flow.
 421                 //   If this method returns false, the caller must report an
 422                 //   error 165.
 423                 // </summary>
 424                 public bool IsVariableAssigned (VariableInfo vi)
 425                 {
 426                         if (DoFlowAnalysis)
 427                                 return CurrentBranching.IsVariableAssigned (vi);
 428                         else
 429                                 return true;
 430                 }
 431
 432                 // <summary>
 433                 //   Marks the local variable `vi' as being initialized at the current
 434                 //   current point of the method's control flow.
 435                 // </summary>
 436                 public void SetVariableAssigned (VariableInfo vi)
 437                 {
 438                         if (DoFlowAnalysis)
 439                                 CurrentBranching.SetVariableAssigned (vi);
 440                 }
 441
 442                 // <summary>
 443                 //   Checks whether the parameter `number' is already initialized
 444                 //   at the current point of the method's control flow.
 445                 //   If this method returns false, the caller must report an
 446                 //   error 165.  This is only necessary for `out' parameters and the
 447                 //   call will always succeed for non-`out' parameters.
 448                 // </summary>
 449                 public bool IsParameterAssigned (int number)
 450                 {
 451                         if (DoFlowAnalysis)
 452                                 return CurrentBranching.IsParameterAssigned (number);
 453                         else
 454                                 return true;
 455                 }
 456
 457                 // <summary>
 458                 //   Marks the parameter `number' as being initialized at the current
 459                 //   current point of the method's control flow.  This is only necessary
 460                 //   for `out' parameters.
 461                 // </summary>
 462                 public void SetParameterAssigned (int number)
 463                 {
 464                         if (DoFlowAnalysis)
 465                                 CurrentBranching.SetParameterAssigned (number);
 466                 }
 467
 468                 public void EmitTopBlock (Block block, InternalParameters ip, Location loc)
 469                 {
 470                         bool has_ret = false;
 471
 472 //                      Console.WriteLine ("Emitting: " + loc);
 473
 474                         if (CodeGen.SymbolWriter != null)
 475                                 Mark (loc);
 476
 477                         if (block != null){
 478                                 int errors = Report.Errors;
 479
 480                                 block.EmitMeta (this, block);
 481
 482                                 if (Report.Errors == errors){
 483                                         bool old_do_flow_analysis = DoFlowAnalysis;
 484                                         DoFlowAnalysis = true;
 485
 486                                         FlowBranching cfb = new FlowBranching (block, ip, loc);
 487                                         FlowStack.Push (cfb);
 488
 489                                         if (!block.Resolve (this)) {
 490                                                 FlowStack.Pop ();
 491                                                 DoFlowAnalysis = old_do_flow_analysis;
 492                                                 return;
 493                                         }
 494
 495                                         cfb = (FlowBranching) FlowStack.Pop ();
 496                                         cfb.MergeTopBlock ();
 497
 498                                         DoFlowAnalysis = old_do_flow_analysis;
 499
 500                                         has_ret = block.Emit (this);
 501
 502                                         if (Report.Errors == errors){
 503                                                 if (RootContext.WarningLevel >= 3)
 504                                                         block.UsageWarning ();
 505                                         }
 506                                 }
 507                         }
 508
 509                         if (ReturnType != null && !has_ret){
 510                                 //
 511                                 // FIXME: we need full flow analysis to implement this
 512                                 // correctly and emit an error instead of a warning.
 513                                 //
 514                                 //
 515                                 Report.Error (161, loc, "Not all code paths return a value");
 516                                 return;
 517                         }
 518
 519                         if (HasReturnLabel)
 520                                 ig.MarkLabel (ReturnLabel);
 521                         if (return_value != null){
 522                                 ig.Emit (OpCodes.Ldloc, return_value);
 523                                 ig.Emit (OpCodes.Ret);
 524                         } else {
 525                                 if (!InTry){
 526                                         if (!has_ret || HasReturnLabel)
 527                                                 ig.Emit (OpCodes.Ret);
 528                                 }
 529                         }
 530                 }
 531
 532                 /// <summary>
 533                 ///   This is called immediately before emitting an IL opcode to tell the symbol
 534                 ///   writer to which source line this opcode belongs.
 535                 /// </summary>
 536                 public void Mark (Location loc)
 537                 {
 538                         if (!Location.IsNull (loc)) {
 539                                 ISymbolDocumentWriter doc = loc.SymbolDocument;
 540
 541                                 if (doc != null)
 542                                         ig.MarkSequencePoint (doc, loc.Row, 0,  loc.Row, 0);
 543                         }               }
 544
 545
 546                 /// <summary>
 547                 ///   Returns a temporary storage for a variable of type t as
 548                 ///   a local variable in the current body.
 549                 /// </summary>
 550                 public LocalBuilder GetTemporaryStorage (Type t)
 551                 {
 552                         LocalBuilder location;
 553
 554                         if (temporary_storage != null){
 555                                 location = (LocalBuilder) temporary_storage [t];
 556                                 if (location != null)
 557                                         return location;
 558                         }
 559
 560                         location = ig.DeclareLocal (t);
 561
 562                         return location;
 563                 }
 564
 565                 public void FreeTemporaryStorage (LocalBuilder b)
 566                 {
 567                         // Empty for now.
 568                 }
 569
 570                 /// <summary>
 571                 ///   Current loop begin and end labels.
 572                 /// </summary>
 573                 public Label LoopBegin, LoopEnd;
 574
 575                 /// <summary>
 576                 ///   Whether we are inside a loop and break/continue are possible.
 577                 /// </summary>
 578                 public bool  InLoop;
 579
 580                 /// <summary>
 581                 ///   This is incremented each time we enter a try/catch block and
 582                 ///   decremented if we leave it.
 583                 /// </summary>
 584                 public int   TryCatchLevel;
 585
 586                 /// <summary>
 587                 ///   The TryCatchLevel at the begin of the current loop.
 588                 /// </summary>
 589                 public int   LoopBeginTryCatchLevel;
 590
 591                 /// <summary>
 592                 ///   Default target in a switch statement.   Only valid if
 593                 ///   InSwitch is true
 594                 /// </summary>
 595                 public Label DefaultTarget;
 596
 597                 /// <summary>
 598                 ///   If this is non-null, points to the current switch statement
 599                 /// </summary>
 600                 public Switch Switch;
 601
 602                 /// <summary>
 603                 ///   ReturnValue creates on demand the LocalBuilder for the
 604                 ///   return value from the function.  By default this is not
 605                 ///   used.  This is only required when returns are found inside
 606                 ///   Try or Catch statements.
 607                 /// </summary>
 608                 public LocalBuilder TemporaryReturn ()
 609                 {
 610                         if (return_value == null){
 611                                 return_value = ig.DeclareLocal (ReturnType);
 612                                 ReturnLabel = ig.DefineLabel ();
 613                                 HasReturnLabel = true;
 614                         }
 615
 616                         return return_value;
 617                 }
 618
 619                 /// <summary>
 620                 ///   A dynamic This that is shared by all variables in a emitcontext.
 621                 ///   Created on demand.
 622                 /// </summary>
 623                 public Expression my_this;
 624                 public Expression This {
 625                         get {
 626                                 if (my_this == null) {
 627                                         if (CurrentBlock != null)
 628                                                 my_this = new This (CurrentBlock, loc);
 629                                         else
 630                                                 my_this = new This (loc);
 631
 632                                         my_this = my_this.Resolve (this);
 633                                 }
 634
 635                                 return my_this;
 636                         }
 637                 }
 638         }
 639 }