/*
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);
}
}
}
|