public ThrowStatement( Location location, InstructionId exceptionThrowerInstruction) : base(location) { ExceptionThrowerInstruction = exceptionThrowerInstruction; }
internal void Emit(InstructionId instructionId, Operand o0, Operand o1, Operand o2) { o0 = o0 ?? Operand.Invalid; o1 = o1 ?? Operand.Invalid; o2 = o2 ?? Operand.Invalid; _codeBuffer.Emit(instructionId, o0, o1, o2, Operand.Invalid, _instructionOptions); }
public ExceptionStatement( Location location, InstructionId parentExceptionThrowerInstruction) : base(location) { ParentExceptionThrowerInstruction = parentExceptionThrowerInstruction; }
public Instruction(InstructionId instructionId, char firstRegister) { InstructionId = instructionId; FirstRegister = firstRegister; SecondRegister = null; FirstConstant = null; SecondConstant = null; }
public Instruction(InstructionId instructionId, long firstConstant, long secondConstant) { InstructionId = instructionId; FirstRegister = null; SecondRegister = null; FirstConstant = firstConstant; SecondConstant = secondConstant; }
public FinallyStatement( Location location, InstructionId bodyStart, InstructionId finallyBlockStart) : base(location) { BodyStart = new Continuation(bodyStart); FinallyBlockStart = new Continuation(finallyBlockStart); }
public Instruction(InstructionId instructionId, long firstConstant, char secondRegister) { InstructionId = instructionId; FirstRegister = null; SecondRegister = secondRegister; FirstConstant = firstConstant; SecondConstant = null; }
public CatchStatement( Location location, InstructionId exceptionThrowerInstruction, InstructionId bodyBlockStart, InstructionId catchBlockStart) : base(location) { ExceptionThrowerInstruction = exceptionThrowerInstruction; BodyBlockStart = new Continuation(bodyBlockStart); CatchBlockStart = new Continuation(catchBlockStart); }
private void CreateInstructionNode(InstructionId instructionId, Operand[] operands) { var options = _assembler.GetInstructionOptionsAndReset(); if (instructionId.IsJump()) { LabelNode target = null; JumpNode next = null; CodeNodeFlags flags = 0; if (!options.IsSet(InstructionOptions.Unfollow)) { if (operands[0].IsLabel()) { target = _assembler.GetLabelData(operands[0].Id).ContextData; } else { options |= InstructionOptions.Unfollow; } } flags |= instructionId == InstructionId.Jmp ? CodeNodeFlags.Jmp | CodeNodeFlags.Taken : CodeNodeFlags.Jcc; if (target != null) { next = target.From; } // The 'jmp' is always taken, conditional jump can contain hint, we detect it. if (instructionId == InstructionId.Jmp) { flags |= CodeNodeFlags.Taken; } else if (options.IsSet(InstructionOptions.Taken)) { flags |= CodeNodeFlags.Taken; } var node = new JumpNode(instructionId, options, operands); node.Flags |= flags; node.Target = target; if (target != null) { node.NextJump = next; target.From = node; target.ReferenceCount++; } AddNode(node); return; } var inst = new InstructionNode(instructionId, options, operands); AddNode(inst); }
private static void PrepareSingleVariableInstruction(InstructionId instId, VariableAttributes va) { switch (instId) { // - andn reg, reg ; Set all bits in reg to 0. // - xor/pxor reg, reg ; Set all bits in reg to 0. // - sub/psub reg, reg ; Set all bits in reg to 0. // - pcmpgt reg, reg ; Set all bits in reg to 0. // - pcmpeq reg, reg ; Set all bits in reg to 1. case InstructionId.Pandn: case InstructionId.Xor: case InstructionId.Xorpd: case InstructionId.Xorps: case InstructionId.Pxor: case InstructionId.Sub: case InstructionId.Psubb: case InstructionId.Psubw: case InstructionId.Psubd: case InstructionId.Psubq: case InstructionId.Psubsb: case InstructionId.Psubsw: case InstructionId.Psubusb: case InstructionId.Psubusw: case InstructionId.Pcmpeqb: case InstructionId.Pcmpeqw: case InstructionId.Pcmpeqd: case InstructionId.Pcmpeqq: case InstructionId.Pcmpgtb: case InstructionId.Pcmpgtw: case InstructionId.Pcmpgtd: case InstructionId.Pcmpgtq: va.Flags &= ~VariableFlags.RReg; break; // - and reg, reg ; Nop. // - or reg, reg ; Nop. // - xchg reg, reg ; Nop. case InstructionId.And: case InstructionId.Andpd: case InstructionId.Andps: case InstructionId.Pand: case InstructionId.Or: case InstructionId.Orpd: case InstructionId.Orps: case InstructionId.Por: case InstructionId.Xchg: va.Flags &= ~VariableFlags.WReg; break; } }
public InstructionNode(InstructionId instructionId, InstructionOptions instructionOptions, Operand[] operands) : base(CodeNodeType.Instruction) { InstructionId = instructionId; InstructionOptions = instructionOptions; Operands = operands; MemoryOperandIndex = Constants.InvalidValue; for (var i = 0; i < operands.Length; i++) { if (!operands[i].IsMemory()) { continue; } MemoryOperandIndex = i; break; } Flags |= CodeNodeFlags.Removable; }
public (IInstruction Instruction, int AdditionalBytes) Read(byte[] data, int start = 0, int?length = null) { length = RangeUtils.Calculate(data.Length, start, length); if (length < 0) { throw new ArgumentException(); } else if (length < 2) { return(null, 2 - length.Value); } else { InstructionId id = GetInstructionId(data, start); if (instructions.TryGetValue(id, out InstructionReader reader)) { return(reader.Read(data, start, length)); } throw new InvalidOperationException($"No reader registered for {id}."); } }
internal void Emit(InstructionId instructionId, Operand o0, Operand o1, Operand o2, Operand o3, Operand o4) { CreateInstructionNode(instructionId, new[] { o0, o1, o2, o3, o4 }); }
internal void Emit(InstructionId instructionId, Operand o0, Operand o1, Operand o2, ulong o3) { CreateInstructionNode(instructionId, new[] { o0, o1, o2, new Immediate(o3), }); }
internal void Emit(InstructionId instructionId, Operand o0, Operand o1, long o2) { CreateInstructionNode(instructionId, new[] { o0, o1, new Immediate(o2), }); }
internal void Emit(InstructionId instructionId, Operand o0, Operand o1) { CreateInstructionNode(instructionId, new[] { o0, o1 }); }
internal void Emit(InstructionId instructionId, Operand o0, ulong o1) { CreateInstructionNode(instructionId, new[] { o0, new Immediate(o1) }); }
internal void Emit(InstructionId instructionId, ulong o0) { CreateInstructionNode(instructionId, new Operand[] { new Immediate(o0) }); }
internal void Emit(InstructionId instructionId, Operand o0, Operand o1, Operand o2, Operand o3, InstructionOptions options) { _instructionOptions = options; Emit(instructionId, o0, o1, o2, o3); }
internal void Emit(InstructionId instructionId) { _codeBuffer.Emit(instructionId, Operand.Invalid, Operand.Invalid, Operand.Invalid, Operand.Invalid, _instructionOptions); }
internal void Emit(InstructionId instructionId, Operand o0) { o0 = o0 ?? Operand.Invalid; _codeBuffer.Emit(instructionId, o0, Operand.Invalid, Operand.Invalid, Operand.Invalid, _instructionOptions); }
public static string GetDescription(this InstructionId instructionId) { var fi = instructionId.GetType().GetField(instructionId.ToString()); return(fi.GetCustomAttributes(typeof(DescriptionAttribute), false) is DescriptionAttribute[] attributes && attributes.Length > 0 ? attributes[0].Description : null); }
internal void Emit(InstructionId instructionId) { CreateInstructionNode(instructionId, new Operand[0]); }
public JumpNode(InstructionId instructionId, InstructionOptions instructionOptions, Operand[] operands) : base(instructionId, instructionOptions, operands) { }
public override string ToString() { return(InstructionId.GetDescription() + " " + (FirstRegister ?? FirstConstant.Value) + " " + (FirstRegister.HasValue ? (FirstConstant ?? SecondRegister.Value) : (SecondRegister ?? SecondConstant.Value))); }