MethodEpilogueAdder.cs :  » Aspect-Oriented-Frameworks » Runtime-Assembly-Instrumentation-Library » rail » Transformation » C# / CSharp Open Source

Home
C# / CSharp Open Source
1.2.6.4 mono .net core
2.2.6.4 mono core
3.Aspect Oriented Frameworks
4.Bloggers
5.Build Systems
6.Business Application
7.Charting Reporting Tools
8.Chat Servers
9.Code Coverage Tools
10.Content Management Systems CMS
11.CRM ERP
12.Database
13.Development
14.Email
15.Forum
16.Game
17.GIS
18.GUI
19.IDEs
20.Installers Generators
21.Inversion of Control Dependency Injection
22.Issue Tracking
23.Logging Tools
24.Message
25.Mobile
26.Network Clients
27.Network Servers
28.Office
29.PDF
30.Persistence Frameworks
31.Portals
32.Profilers
33.Project Management
34.RSS RDF
35.Rule Engines
36.Script
37.Search Engines
38.Sound Audio
39.Source Control
40.SQL Clients
41.Template Engines
42.Testing
43.UML
44.Web Frameworks
45.Web Service
46.Web Testing
47.Wiki Engines
48.Windows Presentation Foundation
49.Workflows
50.XML Parsers
C# / C Sharp
C# / C Sharp by API
C# / CSharp Tutorial
C# / CSharp Open Source » Aspect Oriented Frameworks » Runtime Assembly Instrumentation Library 
Runtime Assembly Instrumentation Library » rail » Transformation » MethodEpilogueAdder.cs
/*
  The contents of this file are subject to the Mozilla Public License Version 1.1 (the "License"); 
  you may not use this file except in compliance with the License. You may obtain a copy of the License at 
  http://www.mozilla.org/MPL/ 
  Software distributed under the License is distributed on an "AS IS" basis, 
  WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language 
  governing rights and limitations under the License. 

  The Original Code is RAIL(Runtime Assembly Instrumentation Library) Alpha Version.
  The Initial Developer of the Original Code is University of Coimbra,
  Computer Science Department, Dependable Systems Group. Copyright (C) University of Coimbra. 
  All Rights Reserved.  
*/
using System;
using Rail.Reflect;
using System.Reflection;
using System.Reflection.Emit;
using System.Collections;
using Rail.MSIL;

namespace Rail.Transformation{
  /// <summary>
  /// Useful add new instructions to the end of the method.
  /// Copy the MSIL instructions in a method to the end of other method
  /// <remarks>
  /// When copying the instructions of a method to the other, we must assure
  /// that the parameters of the method to add are the same or less then the
  /// number of parameters in the method being instrumented, and the poarameters
  /// also have of be of the same type and defined in the same order.
  /// For accessing local variable we have to diferent approaches, the first one
  /// is using the local variables of the method being instrumented, this way the 
  /// order and type of the local variables have to be the same in both methods.
  /// The second approach creates the local variables in the instrumented method
  /// to use with the added code.
  /// The access to fields and methods present in the method to add must be possible from
  /// the method where the instructions are being added.
  /// </remarks>
  /// </summary>
  public class MethodEpilogueAdder : EmptyVisitor
  {
    /// <summary>
    /// 
    /// </summary>
    private readonly Code CodeToAdd;
    /// <summary>
    /// 
    /// </summary>
    private readonly MethodBody MethodBodyToAdd;
    /// <summary>
    /// 
    /// </summary>
    private bool CreateLocals;

    
    /// <summary>
    /// Adds the code in MethodToAdd to the end of the method
    /// </summary>
    /// <param name="MethodToAdd">The method which instructions</param>
    /// <param name="CreateLocals">Bool value used to explicit if the local variables used
    /// in the method to add must be created in the method being instrumented</param>
    public MethodEpilogueAdder(RMethodDef MethodToAdd, bool CreateLocals)
    {
      if (MethodToAdd!=null)
      {
        this.CodeToAdd = MethodToAdd.MethodBody.GetCode();
        this.MethodBodyToAdd = MethodToAdd.MethodBody;
      }
      this.CreateLocals = CreateLocals;

    }

    /// <summary>
    /// Method used to instrument the code of <code>RMethodDef</code> and 
    /// <code>RConstructorDef</code> 
    /// </summary>
    /// <param name="method">The method which method body is to be instrumented</param>
    private void VisitMethodBody(RMethodBase method)
    {    
      #region Changes the body of the method
      
      MSIL.MethodBody mb = null;
      if (method is RConstructor)
        mb = ((RConstructorDef)method).MethodBody;
      else if (method is RMethod)
        mb = ((RMethodDef)method).MethodBody;

      MSIL.Code code = null;
      int originalLocalsCount = mb.LocalVarsCount;
      if (mb!=null)
        code = mb.GetCode();
      if (code!=null)
      {
        code[code.InstructionCount-1] = new ILNone(OpCodes.Nop);
        Instruction tempInstruction;
        for (int i = 0; i< code.InstructionCount-1;i++)
        {
          tempInstruction = code[i];
          if (tempInstruction.OpCode.Value==OpCodes.Ret.Value)
            code[i] = new ILBranch(OpCodes.Br_S,code[code.InstructionCount-1]);
        }
      }
      if (this.CreateLocals)
        if (this.MethodBodyToAdd.LocalVarsCount>0)
        {
          for (int j=0;j<this.MethodBodyToAdd.LocalVarsCount;j++)
          {
            mb.DefineLocalVariable(this.MethodBodyToAdd.GetLocalVar(j).Type);
          }
        }

      for (int i = 0; i< this.CodeToAdd.InstructionCount;i++)
      {
        if (this.CodeToAdd[i] is ILLocalVariable && this.CreateLocals)
        {
          ILLocalVariable instr = null;
          #region for stloc
          if (this.CodeToAdd[i].OpCode.Value==OpCodes.Stloc_0.Value)
          {
            if (originalLocalsCount==0)
              instr = new ILLocalVariable(OpCodes.Stloc_0,mb.GetLocalVar(0));
            else if (originalLocalsCount==1)
              instr = new ILLocalVariable(OpCodes.Stloc_1,mb.GetLocalVar(1));
            else if (originalLocalsCount==2)
              instr = new ILLocalVariable(OpCodes.Stloc_2,mb.GetLocalVar(2));
            else if (originalLocalsCount==3)
              instr = new ILLocalVariable(OpCodes.Stloc_3,mb.GetLocalVar(3));
            else 
              instr = new ILLocalVariable(OpCodes.Stloc,mb.GetLocalVar(originalLocalsCount));
          }
          else if (this.CodeToAdd[i].OpCode.Value==OpCodes.Stloc_1.Value)
          {
            if (originalLocalsCount==0)
              instr = new ILLocalVariable(OpCodes.Stloc_1,mb.GetLocalVar(1));
            else if (originalLocalsCount==1)
              instr = new ILLocalVariable(OpCodes.Stloc_2,mb.GetLocalVar(2));
            else if (originalLocalsCount==2)
              instr = new ILLocalVariable(OpCodes.Stloc_3,mb.GetLocalVar(3));
            else 
              instr = new ILLocalVariable(OpCodes.Stloc,mb.GetLocalVar(originalLocalsCount+1));
          }
          else if (this.CodeToAdd[i].OpCode.Value==OpCodes.Stloc_2.Value)
          {
            if (originalLocalsCount==0)
              instr = new ILLocalVariable(OpCodes.Stloc_2,mb.GetLocalVar(2));
            else if (originalLocalsCount==1)
              instr = new ILLocalVariable(OpCodes.Stloc_3,mb.GetLocalVar(3));
            else 
              instr = new ILLocalVariable(OpCodes.Stloc,mb.GetLocalVar(originalLocalsCount+2));
          }
          else if (this.CodeToAdd[i].OpCode.Value==OpCodes.Stloc_3.Value)
          {
            if (originalLocalsCount==0)
              instr = new ILLocalVariable(OpCodes.Stloc_3,mb.GetLocalVar(3));
            else 
              instr = new ILLocalVariable(OpCodes.Stloc,mb.GetLocalVar(originalLocalsCount+3));
          }

          #endregion

          #region for ldloc
          if (this.CodeToAdd[i].OpCode.Value==OpCodes.Ldloc_0.Value)
          {
            if (originalLocalsCount==0)
              instr = new ILLocalVariable(OpCodes.Ldloc_0,mb.GetLocalVar(0));
            else if (originalLocalsCount==1)
              instr = new ILLocalVariable(OpCodes.Ldloc_1,mb.GetLocalVar(1));
            else if (originalLocalsCount==2)
              instr = new ILLocalVariable(OpCodes.Ldloc_2,mb.GetLocalVar(2));
            else if (originalLocalsCount==3)
              instr = new ILLocalVariable(OpCodes.Ldloc_3,mb.GetLocalVar(3));
            else 
              instr = new ILLocalVariable(OpCodes.Ldloc,mb.GetLocalVar(originalLocalsCount));
          }
          else if (this.CodeToAdd[i].OpCode.Value==OpCodes.Ldloc_1.Value)
          {
            if (originalLocalsCount==0)
              instr = new ILLocalVariable(OpCodes.Ldloc_1,mb.GetLocalVar(1));
            else if (originalLocalsCount==1)
              instr = new ILLocalVariable(OpCodes.Ldloc_2,mb.GetLocalVar(2));
            else if (originalLocalsCount==2)
              instr = new ILLocalVariable(OpCodes.Ldloc_3,mb.GetLocalVar(3));
            else 
              instr = new ILLocalVariable(OpCodes.Ldloc,mb.GetLocalVar(originalLocalsCount+1));
          }
          else if (this.CodeToAdd[i].OpCode.Value==OpCodes.Ldloc_2.Value)
          {
            if (originalLocalsCount==0)
              instr = new ILLocalVariable(OpCodes.Ldloc_2,mb.GetLocalVar(2));
            else if (originalLocalsCount==1)
              instr = new ILLocalVariable(OpCodes.Ldloc_3,mb.GetLocalVar(3));
            else 
              instr = new ILLocalVariable(OpCodes.Ldloc,mb.GetLocalVar(originalLocalsCount+2));
          }
          else if (this.CodeToAdd[i].OpCode.Value==OpCodes.Ldloc_3.Value)
          {
            if (originalLocalsCount==0)
              instr = new ILLocalVariable(OpCodes.Ldloc_3,mb.GetLocalVar(3));
            else 
              instr = new ILLocalVariable(OpCodes.Ldloc,mb.GetLocalVar(originalLocalsCount+3));
          }

          #endregion

          #region for Ldloca
          if (this.CodeToAdd[i].OpCode.Value==OpCodes.Ldloca.Value)
          {
            ILLocalVariable ilLoca = (ILLocalVariable)this.CodeToAdd[i];
            int indx = 0;
            for (indx=0;indx<this.MethodBodyToAdd.LocalVarsCount;indx++)
            {
              if (ilLoca.Equals(this.MethodBodyToAdd.GetLocalVar(indx)))
                break;
            }
            instr = new ILLocalVariable(OpCodes.Ldloca,mb.GetLocalVar(originalLocalsCount+indx));
          }
          #endregion
          
          #region for Ldloca_S
          if (this.CodeToAdd[i].OpCode.Value==OpCodes.Ldloca_S.Value)
          {
            ILLocalVariable ilLoca = (ILLocalVariable)this.CodeToAdd[i];
            int indx = 0;
            for (indx=0;indx<this.MethodBodyToAdd.LocalVarsCount;indx++)
            {
              if (ilLoca.Local.Equals(this.MethodBodyToAdd.GetLocalVar(indx)))
                break;
            }
            instr = new ILLocalVariable(OpCodes.Ldloca_S,mb.GetLocalVar(originalLocalsCount+indx));
          }
          #endregion

          if (instr!=null)
          {
            IEnumerator iEnum = this.CodeToAdd[i].GetTargeters();
            if (iEnum!=null)
              while(iEnum.MoveNext())
                instr.AddTargeter((ITargeter)iEnum.Current);
            code.Add(instr);
          }
        }
        else
        {
          code.Add(this.CodeToAdd[i]);
        }
      }

      #endregion
      
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="method"></param>
    public override void VisitMethod(RMethodDef method) 
    {
      //check the method body
      VisitMethodBody((RMethodBase)method);
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="method"></param>
    public override void VisitConstructor(RConstructorDef method) 
    {
      //Check the method body
      VisitMethodBody((RMethodBase)method);
    }



  }
}
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.