本文整理汇总了C#中InstructionNode.AddBranchTarget方法的典型用法代码示例。如果您正苦于以下问题：C# InstructionNode.AddBranchTarget方法的具体用法？C# InstructionNode.AddBranchTarget怎么用？C# InstructionNode.AddBranchTarget使用的例子？那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类InstructionNode的用法示例。
在下文中一共展示了InstructionNode.AddBranchTarget方法的6个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: Decode
/// <summary>
/// Decodes the specified instruction.
/// </summary>
/// <param name="ctx">The context.</param>
/// <param name="decoder">The instruction decoder, which holds the code stream.</param>
public override void Decode(InstructionNode ctx, IInstructionDecoder decoder)
{
// Decode base classes first
base.Decode(ctx, decoder);
foreach (var target in (int[])decoder.Instruction.Operand)
{
var block = decoder.GetBlock(target);
ctx.AddBranchTarget(block);
}
ctx.AddBranchTarget(decoder.GetBlock(decoder.Instruction.Next.Value));
}示例2: Decode
/// <summary>
/// Decodes the specified instruction.
/// </summary>
/// <param name="ctx">The context.</param>
/// <param name="decoder">The instruction decoder, which holds the code stream.</param>
public override void Decode(InstructionNode ctx, IInstructionDecoder decoder)
{
// Decode base classes first
base.Decode(ctx, decoder);
var block = decoder.GetBlock((int)decoder.Instruction.Operand);
ctx.AddBranchTarget(block);
}示例3: Decode
/// <summary>
/// Decodes the specified instruction.
/// </summary>
/// <param name="ctx">The context.</param>
/// <param name="decoder">The instruction decoder, which holds the code stream.</param>
public override void Decode(InstructionNode ctx, IInstructionDecoder decoder)
{
// Decode base classes first
base.Decode(ctx, decoder);
if (OpCode.Ret != opcode)
throw new ArgumentException(@"Invalid opcode.", @"codeReader");
if (decoder.Method.Signature.ReturnType.IsVoid)
ctx.OperandCount = 0;
else
ctx.OperandCount = 1;
var block = decoder.GetBlock(BasicBlock.EpilogueLabel);
ctx.AddBranchTarget(block);
}示例4: Decode
/// <summary>
/// Decodes the specified instruction.
/// </summary>
/// <param name="ctx">The context.</param>
/// <param name="decoder">The instruction decoder, which holds the code stream.</param>
public override void Decode(InstructionNode ctx, IInstructionDecoder decoder)
{
// Decode base classes first
base.Decode(ctx, decoder);
// Read the branch target
// Is this a short branch target?
if (opcode == OpCode.Brfalse_s || opcode == OpCode.Brtrue_s ||
opcode == OpCode.Brfalse || opcode == OpCode.Brtrue)
{
var block = decoder.GetBlock((int)decoder.Instruction.Operand);
ctx.AddBranchTarget(block);
}
else if (opcode == OpCode.Switch)
{
// Don't do anything, the derived class will do everything
}
else
{
throw new NotSupportedException(@"Invalid opcode " + opcode.ToString() + " specified for UnaryBranchInstruction.");
}
}示例5: CopyInstructions
protected BasicBlocks CopyInstructions()
{
var newBasicBlocks = new BasicBlocks();
var mapBlocks = new Dictionary<BasicBlock, BasicBlock>(BasicBlocks.Count);
var map = new Dictionary<Operand, Operand>();
foreach (var block in BasicBlocks)
{
var newBlock = newBasicBlocks.CreateBlock(block.Label);
mapBlocks.Add(block, newBlock);
}
var newPrologueBlock = newBasicBlocks.GetByLabel(BasicBlock.PrologueLabel);
foreach (var operand in MethodCompiler.Parameters)
{
if (operand.Definitions.Count > 0)
{
var newOp = Map(operand, map);
var newOperand = Operand.CreateVirtualRegister(operand.Type, -operand.Index);
newPrologueBlock.BeforeLast.Insert(new InstructionNode(IRInstruction.Move, newOperand, newOp));
// redirect map from parameter to virtual register going forward
map.Remove(operand);
map.Add(operand, newOperand);
}
}
foreach (var block in BasicBlocks)
{
var newBlock = newBasicBlocks.GetByLabel(block.Label);
for (var node = block.First.Next; !node.IsBlockEndInstruction; node = node.Next)
{
if (node.IsEmpty)
continue;
var newNode = new InstructionNode(node.Instruction, node.OperandCount, node.ResultCount);
newNode.Size = node.Size;
newNode.ConditionCode = node.ConditionCode;
if (node.BranchTargets != null)
{
// copy targets
foreach (var target in node.BranchTargets)
{
newNode.AddBranchTarget(mapBlocks[target]);
}
}
// copy results
for (int i = 0; i < node.ResultCount; i++)
{
var op = node.GetResult(i);
var newOp = Map(op, map);
newNode.SetResult(i, newOp);
}
// copy operands
for (int i = 0; i < node.OperandCount; i++)
{
var op = node.GetOperand(i);
var newOp = Map(op, map);
newNode.SetOperand(i, newOp);
}
// copy other
if (node.MosaType != null)
newNode.MosaType = node.MosaType;
if (node.MosaField != null)
newNode.MosaField = node.MosaField;
if (node.InvokeMethod != null)
newNode.InvokeMethod = node.InvokeMethod;
newBlock.BeforeLast.Insert(newNode);
}
}
var trace = CreateTraceLog("InlineMap");
if (trace.Active)
{
foreach (var entry in map)
{
trace.Log(entry.Value.ToString() + " from: " + entry.Key.ToString());
}
}
return newBasicBlocks;
}示例6: Inline
protected void Inline(InstructionNode callNode, BasicBlocks blocks)
{
var mapBlocks = new Dictionary<BasicBlock, BasicBlock>(blocks.Count);
var map = new Dictionary<Operand, Operand>();
var nextBlock = Split(callNode);
// create basic blocks
foreach (var block in blocks)
{
var newBlock = CreateNewBlock();
mapBlocks.Add(block, newBlock);
}
// copy instructions
foreach (var block in blocks)
{
var newBlock = mapBlocks[block];
for (var node = block.First.Next; !node.IsBlockEndInstruction; node = node.Next)
{
if (node.IsEmpty)
continue;
if (node.Instruction == IRInstruction.Prologue)
continue;
if (node.Instruction == IRInstruction.Epilogue)
continue;
if (node.Instruction == IRInstruction.Return)
{
if (callNode.Result != null)
{
var newOp = Map(node.Operand1, map, callNode);
newBlock.BeforeLast.Insert(new InstructionNode(IRInstruction.Move, callNode.Result, newOp));
}
newBlock.BeforeLast.Insert(new InstructionNode(IRInstruction.Jmp, nextBlock));
continue;
}
var newNode = new InstructionNode(node.Instruction, node.OperandCount, node.ResultCount);
newNode.Size = node.Size;
newNode.ConditionCode = node.ConditionCode;
if (node.BranchTargets != null)
{
// copy targets
foreach (var target in node.BranchTargets)
{
newNode.AddBranchTarget(mapBlocks[target]);
}
}
// copy results
for (int i = 0; i < node.ResultCount; i++)
{
var op = node.GetResult(i);
var newOp = Map(op, map, callNode);
newNode.SetResult(i, newOp);
}
// copy operands
for (int i = 0; i < node.OperandCount; i++)
{
var op = node.GetOperand(i);
var newOp = Map(op, map, callNode);
newNode.SetOperand(i, newOp);
}
// copy other
if (node.MosaType != null)
newNode.MosaType = node.MosaType;
if (node.MosaField != null)
newNode.MosaField = node.MosaField;
if (node.InvokeMethod != null)
newNode.InvokeMethod = node.InvokeMethod;
newBlock.BeforeLast.Insert(newNode);
}
}
callNode.SetInstruction(IRInstruction.Jmp, mapBlocks[blocks.PrologueBlock]);
}