public override void Transform(IRType type) { if (!type.IsAbstract && (type.IsGeneric || type.NestedInsideOfType != null || type.IsArrayType || type.IsManagedPointerType || type.IsUnmanagedPointerType)) { if (type.VirtualMethodTree[3].ParentType != type) { // It doesn't already implement ToString() itself. IRMethod ts = new IRMethod(type.Assembly); ts.ParentType = type; ts.ReturnType = type.Assembly.AppDomain.System_String; ts.Parameters.Add(new IRParameter(type.Assembly) { ParentMethod = ts, Type = type }); ts.VirtualMethodIndex = 3; var r = new IRReturnInstruction(); r.ParentMethod = ts; r.Linearized = true; var loc = new IRLinearizedLocation(r, IRLinearizedLocationType.String); loc.String.Value = type.ToString(); r.Sources.Add(loc); ts.Instructions.Add(r); ts.ParentTypeMethodIndex = type.Methods.Count; type.Methods.Add(ts); type.VirtualMethodTree[3] = ts; if (!ts.Resolved) // This adds it to the Domain's Methods list. throw new Exception(); } } }
public IRCallExpression(IRType returnType, string targetName, params IRExpression[] arguments) : base(returnType) { TargetName = targetName; Arguments.AddRange(arguments); }
public IRLoadRuntimeHandleInstruction(IRType pTargetType, IRMethod pTargetMethod, IRField pTargetField) : base(IROpcode.LoadRuntimeHandle) { TargetType = pTargetType; TargetMethod = pTargetMethod; TargetField = pTargetField; }
public override void Linearize(Stack <IRStackObject> pStack) { for (int count = 0; count < Target.Parameters.Count; ++count) { Sources.Add(new IRLinearizedLocation(pStack.Pop().LinearizedTarget)); } if (Target.ReturnType != null) { IRStackObject returned = new IRStackObject(); IRType retType = Target.ReturnType; if (retType.IsTemporaryVar) { retType = Target.ParentType.GenericParameters[retType.TemporaryVarOrMVarIndex]; } else if (retType.IsTemporaryMVar) { retType = Target.GenericParameters[retType.TemporaryVarOrMVarIndex]; } returned.Type = retType; returned.LinearizedTarget = new IRLinearizedLocation(IRLinearizedLocationType.Local); returned.LinearizedTarget.Local.LocalIndex = AddLinearizedLocal(pStack, retType); Destination = new IRLinearizedLocation(returned.LinearizedTarget); pStack.Push(returned); } }
public IRExpression Cast(IRType type) { if (type == Type) { return(this); } return(new IRConversionExpression(type, this)); }
public IRVariable(IRType type, string name) : base(type) { if (type == IRPrimitive.Void) { throw new IRTypeException(); } Name = name; }
private static IRType ResolveSimpleReturn(IRType tp, IRMethod target) { if (tp.IsTemporaryVar) return target.ParentType.GenericParameters[tp.TemporaryVarOrMVarIndex]; else if (tp.IsTemporaryMVar) return target.GenericParameters[tp.TemporaryVarOrMVarIndex]; else if (tp.IsArrayType) return target.Assembly.AppDomain.GetArrayType(ResolveSimpleReturn(tp.ArrayElementType, target)); else return tp; }
internal override void SemanticValidation(Semantic.SemanticContext semanticContext) { Expression.SemanticValidation(semanticContext); if (!(Expression.GetIRType() is NumericType)) { throw new Semantic.SemanticValidationException("No se puede PreDecrement"); } else { returnType = new IntType(); } }
internal override void SemanticValidation(Semantic.SemanticContext semanticContext) { Expression.SemanticValidation(semanticContext); if (!(Expression.GetIRType() is BoolType)) { throw new Semantic.SemanticValidationException("No se puede negar"); } else { returnType = new BoolType(); //a exp tiene que poder negarse } }
public override void Linearize(Stack <IRStackObject> pStack) { Sources.Add(new IRLinearizedLocation(pStack.Pop().LinearizedTarget)); IRType arrayType = ParentMethod.Assembly.AppDomain.GetArrayType(Type); IRStackObject result = new IRStackObject(); result.Type = arrayType; result.LinearizedTarget = new IRLinearizedLocation(IRLinearizedLocationType.Local); result.LinearizedTarget.Local.LocalIndex = AddLinearizedLocal(pStack, arrayType); Destination = new IRLinearizedLocation(result.LinearizedTarget); pStack.Push(result); }
private int GetTypeSizeInWords(IRType type) { if (type is IntType) { return(1); } else if (type is StructType) { var strucType = type as StructType; return(strucType.DeclarationStatement.OfType <IdDeclarationStatement>().Sum(dec => GetTypeSizeInWords(dec.Type))); } return(0); }
public IRStore(IRBasicBlock parentBlock, IRType type, IRExpression address, IRExpression operand) : base(parentBlock) { if (type == IRPrimitive.Void || type == IRPrimitive.Bool) { throw new IRTypeException(); } Type = type; Address = address; Operand = operand; Uses.UnionWith(Address.GetAllVariables()); Uses.UnionWith(Operand.GetAllVariables()); }
public override void Linearize(Stack<IRStackObject> pStack) { Sources.Add(new IRLinearizedLocation(pStack.Pop().LinearizedTarget)); Destination = new IRLinearizedLocation(IRLinearizedLocationType.ArrayElement); Destination.ArrayElement.IndexLocation = new IRLinearizedLocation(pStack.Pop().LinearizedTarget); var arraySource = pStack.Pop(); Destination.ArrayElement.ArrayLocation = new IRLinearizedLocation(arraySource.LinearizedTarget); if (Type == null) { Type = arraySource.Type.ArrayType; } Destination.ArrayElement.ElementType = Type; }
internal override void SemanticValidation(Semantic.SemanticContext semanticContext) { Left.SemanticValidation(semanticContext); Right.SemanticValidation(semanticContext); if (!(Left.GetIRType() is NumericType && Right.GetIRType() is NumericType)) { throw new Semantic.SemanticValidationException("No se puede asignar"); } else { returnType = Left.GetIRType(); //evaluar cual tipo de podría asignar dependiendo de su tamanio } }
internal override void SemanticValidation(Semantic.SemanticContext semanticContext) { Left.SemanticValidation(semanticContext); Right.SemanticValidation(semanticContext); if (!(Left.GetIRType() is NumericType && Right.GetIRType() is NumericType)) { throw new Semantic.SemanticValidationException("No se puede operar"); } else { returnType = Left.GetIRType(); } }
public override void Linearize(Stack <IRStackObject> pStack) { Sources.Add(new IRLinearizedLocation(pStack.Pop().LinearizedTarget)); Destination = new IRLinearizedLocation(IRLinearizedLocationType.ArrayElement); Destination.ArrayElement.IndexLocation = new IRLinearizedLocation(pStack.Pop().LinearizedTarget); var arraySource = pStack.Pop(); Destination.ArrayElement.ArrayLocation = new IRLinearizedLocation(arraySource.LinearizedTarget); if (Type == null) { Type = arraySource.Type.ArrayType; } Destination.ArrayElement.ElementType = Type; }
public override void Linearize(Stack<IRStackObject> pStack) { Sources.Add(new IRLinearizedLocation(this, pStack.Pop().LinearizedTarget)); Destination = new IRLinearizedLocation(this, IRLinearizedLocationType.Indirect); var addressLocation = pStack.Pop(); Destination.Indirect.AddressLocation = new IRLinearizedLocation(this, addressLocation.LinearizedTarget); if (Type == null) { if (addressLocation.Type.IsManagedPointerType) Type = addressLocation.Type.ManagedPointerType; else Type = addressLocation.Type.UnmanagedPointerType; } if (Type == null) throw new Exception(); Destination.Indirect.Type = Type; }
public override void Linearize(Stack <IRStackObject> pStack) { IRStackObject value2 = pStack.Pop(); IRStackObject value1 = pStack.Pop(); Sources.Add(new IRLinearizedLocation(value1.LinearizedTarget)); Sources.Add(new IRLinearizedLocation(value2.LinearizedTarget)); IRType resultType = ParentMethod.Assembly.AppDomain.BinaryNumericResult(value1.Type, value2.Type); IRStackObject result = new IRStackObject(); result.Type = resultType; result.LinearizedTarget = new IRLinearizedLocation(IRLinearizedLocationType.Local); result.LinearizedTarget.Local.LocalIndex = AddLinearizedLocal(pStack, resultType); Destination = new IRLinearizedLocation(result.LinearizedTarget); pStack.Push(result); }
public override void Linearize(Stack<IRStackObject> pStack) { IRLinearizedLocation source = new IRLinearizedLocation(IRLinearizedLocationType.ArrayElement); source.ArrayElement.IndexLocation = new IRLinearizedLocation(pStack.Pop().LinearizedTarget); var arraySource = pStack.Pop(); source.ArrayElement.ArrayLocation = new IRLinearizedLocation(arraySource.LinearizedTarget); if (Type == null) { Type = arraySource.Type.ArrayType; } source.ArrayElement.ElementType = Type; Sources.Add(source); IRStackObject result = new IRStackObject(); result.Type = Type; result.LinearizedTarget = new IRLinearizedLocation(IRLinearizedLocationType.Local); result.LinearizedTarget.Local.LocalIndex = AddLinearizedLocal(pStack, Type); Destination = new IRLinearizedLocation(result.LinearizedTarget); pStack.Push(result); }
public override void Linearize(Stack<IRStackObject> pStack) { IRLinearizedLocation source = new IRLinearizedLocation(this, IRLinearizedLocationType.ArrayElementAddress); source.ArrayElementAddress.IndexLocation = new IRLinearizedLocation(this, pStack.Pop().LinearizedTarget); var arraySource = pStack.Pop(); source.ArrayElementAddress.ArrayLocation = new IRLinearizedLocation(this, arraySource.LinearizedTarget); if (Type == null) { Type = arraySource.Type.ArrayElementType; } if (Type == null) throw new Exception(); source.ArrayElementAddress.ElementType = Type; Sources.Add(source); IRStackObject result = new IRStackObject(); result.Type = ParentMethod.Assembly.AppDomain.System_IntPtr; result.LinearizedTarget = new IRLinearizedLocation(this, IRLinearizedLocationType.Local); result.LinearizedTarget.Local.LocalIndex = AddLinearizedLocal(pStack, ParentMethod.Assembly.AppDomain.System_IntPtr); Destination = new IRLinearizedLocation(this, result.LinearizedTarget); pStack.Push(result); }
public override void Linearize(Stack<IRStackObject> pStack) { IRLinearizedLocation source = new IRLinearizedLocation(this, IRLinearizedLocationType.Indirect); var addressLocation = pStack.Pop(); source.Indirect.AddressLocation = new IRLinearizedLocation(this, addressLocation.LinearizedTarget); if (Type == null) { if (addressLocation.Type.IsManagedPointerType) Type = addressLocation.Type.ManagedPointerType; else Type = addressLocation.Type.UnmanagedPointerType; } if (Type == null) throw new Exception(); source.Indirect.Type = Type; Sources.Add(source); IRStackObject result = new IRStackObject(); result.Type = Type; result.LinearizedTarget = new IRLinearizedLocation(this, IRLinearizedLocationType.Local); result.LinearizedTarget.Local.LocalIndex = AddLinearizedLocal(pStack, Type); Destination = new IRLinearizedLocation(this, result.LinearizedTarget); pStack.Push(result); }
public override void Linearize(Stack <IRStackObject> pStack) { IRLinearizedLocation source = new IRLinearizedLocation(IRLinearizedLocationType.ArrayElement); source.ArrayElement.IndexLocation = new IRLinearizedLocation(pStack.Pop().LinearizedTarget); var arraySource = pStack.Pop(); source.ArrayElement.ArrayLocation = new IRLinearizedLocation(arraySource.LinearizedTarget); if (Type == null) { Type = arraySource.Type.ArrayType; } source.ArrayElement.ElementType = Type; Sources.Add(source); IRStackObject result = new IRStackObject(); result.Type = Type; result.LinearizedTarget = new IRLinearizedLocation(IRLinearizedLocationType.Local); result.LinearizedTarget.Local.LocalIndex = AddLinearizedLocal(pStack, Type); Destination = new IRLinearizedLocation(result.LinearizedTarget); pStack.Push(result); }
public override void Linearize(Stack <IRStackObject> pStack) { IRType handleType = null; if (TargetType != null) { handleType = ParentMethod.Assembly.AppDomain.System_RuntimeTypeHandle; } else if (TargetMethod != null) { handleType = ParentMethod.Assembly.AppDomain.System_RuntimeMethodHandle; } else if (TargetField != null) { handleType = ParentMethod.Assembly.AppDomain.System_RuntimeFieldHandle; } else { throw new NullReferenceException(); } IRLinearizedLocation value = new IRLinearizedLocation(IRLinearizedLocationType.RuntimeHandle); value.RuntimeHandle.HandleType = handleType; value.RuntimeHandle.TargetType = TargetType; value.RuntimeHandle.TargetMethod = TargetMethod; value.RuntimeHandle.TargetField = TargetField; Sources.Add(value); IRStackObject result = new IRStackObject(); result.Type = handleType; result.LinearizedTarget = new IRLinearizedLocation(IRLinearizedLocationType.Local); result.LinearizedTarget.Local.LocalIndex = AddLinearizedLocal(pStack, handleType); Destination = new IRLinearizedLocation(result.LinearizedTarget); pStack.Push(result); }
public IRInitializeObjectInstruction(IRType pType) : base(IROpcode.InitializeObject) { Type = pType; }
public IRConvertCheckedInstruction(IRType pType, IROverflowType pOverflowType) : base(IROpcode.ConvertChecked) { Type = pType; OverflowType = pOverflowType; }
public IRLoadTypedReferenceInstruction(IRType pType) : base(IROpcode.LoadTypedReference) { Type = pType; }
public IRStoreArrayElementInstruction(IRType pType) : base(IROpcode.StoreArrayElement) { Type = pType; }
public IRCopyObjectInstruction(IRType pType) : base(IROpcode.CopyObject) { Type = pType; }
/// <summary> /// This creates a shallow clone of this method, but /// does a deep clone of it's instructions, parameters, and locals. /// </summary> /// <param name="newParent">The parent for the new method.</param> /// <returns>The clone of this method.</returns> public IRMethod Clone(IRType newParent) { if (newParent == null) throw new Exception(); IRMethod m = new IRMethod(this.Assembly); if (this.PresolvedMethod) m.mParentMethod = this.GenericMethod; else m.mParentMethod = this; m.ParentType = newParent; m.GenericMethod = this.GenericMethod; m.GenericParameters.AddRange(this.GenericParameters); if (this.mInstructions.Count != 0 && Assembly.AppDomain.CurrentCompileStage >= 3) { m.mBoundInstructions = true; this.Instructions.ForEach(i => m.mInstructions.Add(i.Clone(m))); m.Instructions.FixClonedTargetInstructions(); } if (this.mLocals.Count != 0 && Assembly.AppDomain.CurrentCompileStage >= 3) { m.mBoundLocals = true; this.mLocals.ForEach(l => m.mLocals.Add(l.Clone(m))); } this.mParameters.ForEach(p => m.mParameters.Add(p.Clone(m))); m.MaximumStackDepth = this.MaximumStackDepth; m.Name = this.Name; m.Flags = this.Flags; m.ImplFlags = this.ImplFlags; m.ReturnType = this.ReturnType; return m; }
public VarDeclaration(string id, Expression initializationExpression, IRType type) { this.Id = id; this.InitializationExpression = initializationExpression; this.Type = type; }
public IRCastInstruction(IRType pType, bool pThrowExceptionOnFailure) : base(IROpcode.Cast) { Type = pType; ThrowExceptionOnFailure = pThrowExceptionOnFailure; }
public static void EmitStaticConstructorCheck(LIRMethod m, IRType targetType, IRType curType, bool forceEmit = false) { if (targetType.HasStaticConstructor && (forceEmit || targetType != curType)) { var con = targetType.StaticConstructor; if ( ( con.Instructions.Count == 1 && con.Instructions[0].Opcode == IROpcode.Return ) || ( con.Instructions.Count == 2 && con.Instructions[0].Opcode == IROpcode.Nop && con.Instructions[1].Opcode == IROpcode.Return ) ) { // We don't need a static constructor call } else { StaticConstructorCalledEmittableDataItem d = null; if (!KnownStaticConstructors.TryGetValue(targetType, out d)) { d = new StaticConstructorCalledEmittableDataItem(targetType); m.CompileUnit.AddData(d); KnownStaticConstructors.Add(targetType, d); } new LIRInstructions.Comment(m, "Static Constructor Check"); var c = m.RequestLocal(targetType.Assembly.AppDomain.System_Boolean); new LIRInstructions.Move(m, new Indirect(d.Label), c, targetType.Assembly.AppDomain.System_Boolean); Label called = new Label(); new LIRInstructions.BranchTrue(m, c, called); m.ReleaseLocal(c); new LIRInstructions.Move(m, (LIRImm)1, new Indirect(d.Label), targetType.Assembly.AppDomain.System_Boolean); new LIRInstructions.Call(m, con); m.MarkLabel(called); } } }
public StaticConstructorCalledEmittableDataItem(IRType tp) { this.TypeName = tp.ToString(); }
public IRSizeOfInstruction(IRType pType) : base(IROpcode.SizeOf) { Type = pType; }
internal override void SemanticValidation(Semantic.SemanticContext semanticContext) { returnType = new FloatType(); }
public IRExpression(IRType type) { Type = type; }
public IRUnboxInstruction(IRType pType, bool pValue) : base(IROpcode.Unbox) { Type = pType; GetValue = pValue; }
public int AddLinearizedLocal(Stack<IRStackObject> pStack, IRType pType) { IRLocal local = null; if (!LinearizedStackLocalLookup.TryGetValue(new Tuple<int, IRType>(pStack.Count, pType), out local)) { local = new IRLocal(Assembly); local.ParentMethod = this; local.Type = pType; local.Index = Locals.Count; Locals.Add(local); LinearizedStackLocalLookup[new Tuple<int, IRType>(pStack.Count, pType)] = local; } return local.Index; }
public IdDeclarationStatement(string id, Expression initializationExpression, IRType type) { this.Id = id; this.InitializationExpression = initializationExpression; this.Type = type; }
public IRStoreObjectInstruction(IRType pType) : base(IROpcode.StoreObject) { Type = pType; }
public IRConvertUncheckedInstruction(IRType pType) : base(IROpcode.ConvertUnchecked) { TargetType = pType; }
public int AddLinearizedLocal(Stack<IRStackObject> pStack, IRType pType) { return ParentMethod.AddLinearizedLocal(pStack, pType); }
/// <summary> /// Creates a shallow copy of this field. /// </summary> /// <returns>The shallow copy.</returns> public IRField Clone(IRType newParent) { IRField f = new IRField(this.Assembly); f.Name = this.Name; f.Flags = this.Flags; f.ParentType = newParent; f.Type = this.Type; f.mParentField = this.Type == null ? this : null; return f; }
public IRLoadArrayElementInstruction(IRType pType) : base(IROpcode.LoadArrayElement) { Type = pType; }
public override IEnumerable <IRInstruction> GetIRInstructions(IRContext context, IRBasicBlock parentBlock) { switch (Instruction.Id) { case ArmInstructionId.ARM_INS_ADD: if (Instruction.Details.Operands[0].Register.Id == ArmRegisterId.ARM_REG_PC) { yield break; } if (Instruction.DisassembleMode == ArmDisassembleMode.Thumb && Instruction.Details.Operands.Length == 2) { yield return(new IRAssignment(parentBlock, GetIROperand(context, 0), GetIROperand(context, 0) + GetIRSecondOperand(context, 1))); } else if (Instruction.DisassembleMode == ArmDisassembleMode.Thumb && Instruction.Details.Operands.Length == 3 && Instruction.Details.Operands[2].Type == ArmOperandType.Immediate && Instruction.Details.Operands[2].Immediate == 0) { yield return(new IRAssignment(parentBlock, GetIROperand(context, 0), GetIROperand(context, 1))); } else { yield return(new IRAssignment(parentBlock, GetIROperand(context, 0), GetIROperand(context, 1) + GetIRSecondOperand(context, 2))); } break; case ArmInstructionId.ARM_INS_SUB: if (Instruction.DisassembleMode == ArmDisassembleMode.Thumb && Instruction.Details.Operands.Length == 2) { yield return(new IRAssignment(parentBlock, GetIROperand(context, 0), GetIROperand(context, 0) - GetIRSecondOperand(context, 1))); } else { yield return(new IRAssignment(parentBlock, GetIROperand(context, 0), GetIROperand(context, 1) - GetIRSecondOperand(context, 2))); } break; case ArmInstructionId.ARM_INS_RSB: yield return(new IRAssignment(parentBlock, GetIROperand(context, 0), GetIRSecondOperand(context, 2) - GetIROperand(context, 1))); break; case ArmInstructionId.ARM_INS_AND: yield return(new IRAssignment(parentBlock, GetIROperand(context, 0), GetIROperand(context, 1) & GetIRSecondOperand(context, 2))); break; case ArmInstructionId.ARM_INS_ORR: yield return(new IRAssignment(parentBlock, GetIROperand(context, 0), GetIROperand(context, 1) | GetIRSecondOperand(context, 2))); break; case ArmInstructionId.ARM_INS_EOR: yield return(new IRAssignment(parentBlock, GetIROperand(context, 0), GetIROperand(context, 1) ^ GetIRSecondOperand(context, 2))); break; case ArmInstructionId.ARM_INS_BIC: yield return(new IRAssignment(parentBlock, GetIROperand(context, 0), GetIROperand(context, 1) & ~GetIRSecondOperand(context, 2))); break; case ArmInstructionId.ARM_INS_LSL: if (Instruction.DisassembleMode == ArmDisassembleMode.Arm) { goto case ArmInstructionId.ARM_INS_MOV; } yield return(new IRAssignment(parentBlock, GetIROperand(context, 0), GetIROperand(context, 1).ShiftLeft(GetIRSecondOperand(context, 2)))); break; case ArmInstructionId.ARM_INS_LSR: if (Instruction.DisassembleMode == ArmDisassembleMode.Arm) { goto case ArmInstructionId.ARM_INS_MOV; } yield return(new IRAssignment(parentBlock, GetIROperand(context, 0), GetIROperand(context, 1).ShiftRightLogical(GetIRSecondOperand(context, 2)))); break; case ArmInstructionId.ARM_INS_ASR: if (Instruction.DisassembleMode == ArmDisassembleMode.Arm) { goto case ArmInstructionId.ARM_INS_MOV; } yield return(new IRAssignment(parentBlock, GetIROperand(context, 0), GetIROperand(context, 1).ShiftRightArithmetic(GetIRSecondOperand(context, 2)))); break; case ArmInstructionId.ARM_INS_ROR: if (Instruction.DisassembleMode == ArmDisassembleMode.Arm) { goto case ArmInstructionId.ARM_INS_MOV; } throw new NotImplementedException(); break; case ArmInstructionId.ARM_INS_RRX: if (Instruction.DisassembleMode == ArmDisassembleMode.Arm) { goto case ArmInstructionId.ARM_INS_MOV; } throw new NotImplementedException(); break; case ArmInstructionId.ARM_INS_MOV: yield return(new IRAssignment(parentBlock, GetIROperand(context, 0), GetIRSecondOperand(context, 1))); break; case ArmInstructionId.ARM_INS_MVN: yield return(new IRAssignment(parentBlock, GetIROperand(context, 0), ~GetIRSecondOperand(context, 1))); break; case ArmInstructionId.ARM_INS_MUL: yield return(new IRAssignment(parentBlock, GetIROperand(context, 0), GetIROperand(context, 1) * GetIROperand(context, 2))); break; case ArmInstructionId.ARM_INS_MLA: yield return(new IRAssignment(parentBlock, GetIROperand(context, 0), GetIROperand(context, 1) * GetIROperand(context, 2) + GetIROperand(context, 3))); break; case ArmInstructionId.ARM_INS_SMULL: yield return(new IRAssignment(parentBlock, GetIROperand(context, 0), (GetIROperand(context, 2).Cast(IRPrimitive.S32).Cast(IRPrimitive.S64) * GetIROperand(context, 3).Cast(IRPrimitive.S32).Cast(IRPrimitive.S64)).Cast(IRPrimitive.U32))); yield return(new IRAssignment(parentBlock, GetIROperand(context, 1), (GetIROperand(context, 2).Cast(IRPrimitive.S32).Cast(IRPrimitive.S64) * GetIROperand(context, 3).Cast(IRPrimitive.S32).Cast(IRPrimitive.S64)).ShiftRightLogical(32) .Cast(IRPrimitive.U32))); break; case ArmInstructionId.ARM_INS_LDR: case ArmInstructionId.ARM_INS_LDRH: case ArmInstructionId.ARM_INS_LDRSH: case ArmInstructionId.ARM_INS_LDRB: case ArmInstructionId.ARM_INS_LDRSB: { IRType type = IRPrimitive.Void; switch (Instruction.Id) { case ArmInstructionId.ARM_INS_LDR: type = IRPrimitive.U32; break; case ArmInstructionId.ARM_INS_LDRH: type = IRPrimitive.U16; break; case ArmInstructionId.ARM_INS_LDRSH: type = IRPrimitive.S16; break; case ArmInstructionId.ARM_INS_LDRB: type = IRPrimitive.U8; break; case ArmInstructionId.ARM_INS_LDRSB: type = IRPrimitive.S8; break; } if (Instruction.Details.WriteBack) { throw new NotImplementedException("Unimplemented instruction!"); } if (Instruction.Details.Operands[1].Memory.Base.Id == ArmRegisterId.ARM_REG_SP) { yield return(new IRAssignment(parentBlock, GetIROperand(context, 0), context.VariableMapping[VariableUses.First(v => v.Location == VariableLocation.Stack)])); break; } if (Instruction.Details.Operands[1].Memory.Index == null && Instruction.Details.Operands[1].Memory.Displacement == 0) { yield return(new IRAssignment(parentBlock, GetIROperand(context, 0), new IRDerefExpression(type, GetIROperand(context, 1)).Cast(IRPrimitive.U32))); break; } else if (Instruction.Details.Operands[1].Memory.Index == null) { var deref = new IRDerefExpression(type, GetIROperand(context, 1) + (uint)Instruction.Details.Operands[1].Memory.Displacement); yield return(new IRAssignment(parentBlock, GetIROperand(context, 0), deref.Cast(IRPrimitive.U32))); break; } else { if (Instruction.Details.Operands[1].ShiftOperation == ArmShiftOperation.Invalid || (Instruction.Details.Operands[1].ShiftOperation == ArmShiftOperation.ARM_SFT_LSL && Instruction.Details.Operands[1].ShiftValue == 0)) { var deref = new IRDerefExpression(type, GetIROperand(context, 1) + GetIROperand(context, 2)); yield return(new IRAssignment(parentBlock, GetIROperand(context, 0), deref.Cast(IRPrimitive.U32))); break; } else { throw new NotImplementedException("Unimplemented instruction!"); } } } case ArmInstructionId.ARM_INS_STR: case ArmInstructionId.ARM_INS_STRH: case ArmInstructionId.ARM_INS_STRB: { var type = IRPrimitive.Void; switch (Instruction.Id) { case ArmInstructionId.ARM_INS_STR: type = IRPrimitive.U32; break; case ArmInstructionId.ARM_INS_STRH: type = IRPrimitive.U16; break; case ArmInstructionId.ARM_INS_STRB: type = IRPrimitive.U8; break; } if (Instruction.Details.WriteBack) { throw new NotImplementedException("Unimplemented instruction!"); } if (Instruction.Details.Operands[1].Memory.Base.Id == ArmRegisterId.ARM_REG_SP) { yield return(new IRAssignment(parentBlock, context.VariableMapping[VariableDefs.First(v => v.Location == VariableLocation.Stack)], GetIROperand(context, 0))); break; } if (Instruction.Details.Operands[1].Memory.Index == null && Instruction.Details.Operands[1].Memory.Displacement == 0) { yield return(new IRStore(parentBlock, type, GetIROperand(context, 1), GetIROperand(context, 0))); break; } else if (Instruction.Details.Operands[1].Memory.Index == null) { yield return(new IRStore(parentBlock, type, GetIROperand(context, 1) + (uint)Instruction.Details.Operands[1].Memory.Displacement, GetIROperand(context, 0))); break; } else { if (Instruction.Details.Operands[1].ShiftOperation == ArmShiftOperation.Invalid || (Instruction.Details.Operands[1].ShiftOperation == ArmShiftOperation.ARM_SFT_LSL && Instruction.Details.Operands[1].ShiftValue == 0)) { yield return(new IRStore(parentBlock, type, GetIROperand(context, 1) + GetIROperand(context, 2), GetIROperand(context, 0))); break; } else { throw new NotImplementedException("Unimplemented instruction!"); } } } case ArmInstructionId.ARM_INS_BL: yield return(new IRAssignment(parentBlock, context.VariableMapping[VariableDefs .First(v => v.Location == VariableLocation.Register && v.Address == 0)], new IRCallExpression(IRPrimitive.U32, $"sub_{Instruction.Details.Operands[0].Immediate:X08}", context.VariableMapping[VariableUses .First(v => v.Location == VariableLocation.Register && v.Address == 0)], context.VariableMapping[VariableUses .First(v => v.Location == VariableLocation.Register && v.Address == 1)], context.VariableMapping[VariableUses .First(v => v.Location == VariableLocation.Register && v.Address == 2)], context.VariableMapping[VariableUses .First(v => v.Location == VariableLocation.Register && v.Address == 3)] ))); break; case ArmInstructionId.ARM_INS_BLX: if (Instruction.Details.Operands[0].Type == ArmOperandType.Immediate) { goto case ArmInstructionId.ARM_INS_BL; } yield return(new IRAssignment(parentBlock, context.VariableMapping[VariableDefs .First(v => v.Location == VariableLocation.Register && v.Address == 0)], new IRCallExpression(IRPrimitive.U32, ((Variable)Operands[0].op).Name, context.VariableMapping[VariableUses .First(v => v.Location == VariableLocation.Register && v.Address == 0)], context.VariableMapping[VariableUses .First(v => v.Location == VariableLocation.Register && v.Address == 1)], context.VariableMapping[VariableUses .First(v => v.Location == VariableLocation.Register && v.Address == 2)], context.VariableMapping[VariableUses .First(v => v.Location == VariableLocation.Register && v.Address == 3)] ))); break; case ArmInstructionId.ARM_INS_LDM: if (Instruction.Details.Operands[0].Register.Id == ArmRegisterId.ARM_REG_SP && Instruction.Details.WriteBack) { break; } goto default; case ArmInstructionId.ARM_INS_STMDB: if (Instruction.Details.Operands[0].Register.Id == ArmRegisterId.ARM_REG_SP && Instruction.Details.WriteBack) { break; } goto default; case ArmInstructionId.ARM_INS_PUSH: case ArmInstructionId.ARM_INS_POP: case ArmInstructionId.ARM_INS_CMP: case ArmInstructionId.ARM_INS_B: case ArmInstructionId.ARM_INS_BX: break; default: throw new NotImplementedException("Unimplemented instruction!"); } }
private int GetTypeSizeInBytes(IRType type) { return(GetTypeSizeInWords(type) * 4); }
public Parameter(IRType type, string id) { // TODO: Complete member initialization this.type = type; this.id = id; }
public IRNewArrayInstruction(IRType pElementType) : base(IROpcode.NewArray) { ElementType = pElementType; }
public virtual void Transform(IRType type) { throw new NotImplementedException("This pass doesn't implement a transform for types!"); }
public IRBoxInstruction(IRType pType) : base(IROpcode.Box) { Type = pType; }
public IRNewArrayInstruction(IRType pType) : base(IROpcode.NewArray) { Type = pType; }
public IRLoadObjectInstruction(IRType pType) : base(IROpcode.LoadObject) { Type = pType; }