// %eax = left, %ebx = right, stack unchanged private void CGenPrepareIntegralOperands(CGenState state) { // 1. Load Left to EAX. // // regs: // %eax = Left // // stack: // +-----+ // | ... | <- %esp // +-----+ // if (this.Left.CGenValue(state) != Reg.EAX) { throw new InvalidOperationException(); } // 2. Push Left to stack. // // regs: // %eax = Left // // stack: // +-----+ // | ... | // +-----+ // | Left | <- %esp has decreased by 4 // +-----+ // Int32 stack_size = state.CGenPushLong(Reg.EAX); // 3. Load Right to EAX. // // regs: // %eax = Right // // stack: // +-----+ // | ... | // +-----+ // | Left | <- %esp // +-----+ // if (this.Right.CGenValue(state) != Reg.EAX) { throw new InvalidOperationException(); } // 4. Move Right into EBX. Pop Left from stack, into EAX. // // regs: // %eax = Left // %ebx = Right // // stack: // +-----+ // | ... | <- %esp has moved back. // +-----+ // state.MOVL(Reg.EAX, Reg.EBX); state.CGenPopLong(stack_size, Reg.EAX); }
public override Reg CGenValue(CGenState state) { state.MOVL((Int32)this.Value, Reg.EAX); return Reg.EAX; }
// * function; // * extern function; // * static function; // * obj; // * obj = Init; // * static obj; // * static obj = Init; // * extern obj; // * extern obj = Init; public void CGenDecln(Env env, CGenState state) { if (env.IsGlobal()) { if (this.initr.IsSome) { Initr initr = this.initr.Value; switch (this.scs) { case StorageClass.AUTO: state.GLOBL(this.name); break; case StorageClass.EXTERN: throw new InvalidProgramException(); case StorageClass.STATIC: break; case StorageClass.TYPEDEF: // Ignore. return; default: throw new InvalidProgramException(); } state.DATA(); state.ALIGN(ExprType.ALIGN_LONG); state.CGenLabel(this.name); Int32 last = 0; initr.Iterate(this.type, (Int32 offset, Expr expr) => { if (offset > last) { state.ZERO(offset - last); } if (!expr.IsConstExpr) { throw new InvalidOperationException("Cannot initialize with non-const expression."); } switch (expr.Type.Kind) { // TODO: without const char/short, how do I initialize? case ExprTypeKind.CHAR: case ExprTypeKind.UCHAR: case ExprTypeKind.SHORT: case ExprTypeKind.USHORT: throw new NotImplementedException(); case ExprTypeKind.LONG: state.LONG(((ConstLong)expr).Value); break; case ExprTypeKind.ULONG: state.LONG((Int32)((ConstULong)expr).Value); break; case ExprTypeKind.POINTER: state.LONG((Int32)((ConstPtr)expr).Value); break; case ExprTypeKind.FLOAT: byte[] float_bytes = BitConverter.GetBytes(((ConstFloat)expr).Value); Int32 intval = BitConverter.ToInt32(float_bytes, 0); state.LONG(intval); break; case ExprTypeKind.DOUBLE: byte[] double_bytes = BitConverter.GetBytes(((ConstDouble)expr).Value); Int32 first_int = BitConverter.ToInt32(double_bytes, 0); Int32 second_int = BitConverter.ToInt32(double_bytes, 4); state.LONG(first_int); state.LONG(second_int); break; default: throw new InvalidProgramException(); } last = offset + expr.Type.SizeOf; }); } else { // Global without initialization. switch (this.scs) { case StorageClass.AUTO: // .comm name,size,align break; case StorageClass.EXTERN: break; case StorageClass.STATIC: // .local name // .comm name,size,align state.LOCAL(this.name); break; case StorageClass.TYPEDEF: // Ignore. return; default: throw new InvalidProgramException(); } if (this.type.Kind != ExprTypeKind.FUNCTION) { state.COMM(this.name, this.type.SizeOf, ExprType.ALIGN_LONG); } } state.NEWLINE(); } else { // stack object state.CGenExpandStackTo(env.StackSize, ToString()); Int32 stack_size = env.StackSize; // pos should be equal to stack_size, but whatever... Int32 pos = env.Find(this.name).Value.Offset; if (this.initr.IsNone) { return; } Initr initr = this.initr.Value; initr.Iterate(this.type, (Int32 offset, Expr expr) => { Reg ret = expr.CGenValue(state); switch (expr.Type.Kind) { case ExprTypeKind.CHAR: case ExprTypeKind.UCHAR: state.MOVB(Reg.EAX, pos + offset, Reg.EBP); break; case ExprTypeKind.SHORT: case ExprTypeKind.USHORT: state.MOVW(Reg.EAX, pos + offset, Reg.EBP); break; case ExprTypeKind.DOUBLE: state.FSTPL(pos + offset, Reg.EBP); break; case ExprTypeKind.FLOAT: state.FSTPS(pos + offset, Reg.EBP); break; case ExprTypeKind.LONG: case ExprTypeKind.ULONG: case ExprTypeKind.POINTER: state.MOVL(Reg.EAX, pos + offset, Reg.EBP); break; case ExprTypeKind.STRUCT_OR_UNION: state.MOVL(Reg.EAX, Reg.ESI); state.LEA(pos + offset, Reg.EBP, Reg.EDI); state.MOVL(expr.Type.SizeOf, Reg.ECX); state.CGenMemCpy(); break; case ExprTypeKind.ARRAY: case ExprTypeKind.FUNCTION: throw new InvalidProgramException($"How could a {expr.Type.Kind} be in a init list?"); default: throw new InvalidProgramException(); } state.CGenForceStackSizeTo(stack_size); }); } // stack object }
public override sealed Reg CGenValue(CGenState state) { // 1. Get the address of expr. // // regs: // %eax = &expr // // stack: // +-------+ // | ..... | <- %esp // +-------+ // this.Expr.CGenAddress(state); // 2. Push address. // // regs: // %eax = &expr // // stack: // +-------+ // | ..... | // +-------+ // | &expr | <- %esp // +-------+ // Int32 stack_size = state.CGenPushLong(Reg.EAX); // 3. Get current Value of expr. // // 1) If expr is an integral or pointer: // // regs: // %eax = expr // // stack: // +-------+ // | ..... | // +-------+ // | &expr | <- %esp // +-------+ // // // 2) If expr is a float: // // regs: // %eax = &expr // // stack: // +-------+ // | ..... | // +-------+ // | &expr | <- %esp // +-------+ // // float stack: // +-------+ // | expr | <- %st(0) // +-------+ // Reg ret = this.Expr.CGenValue(state); switch (ret) { case Reg.EAX: // expr is an integral or pointer. // 4. Pop address to %ecx. // // regs: // %eax = expr // %ecx = &expr // // stack: // +-------+ // | ..... | <- %esp // +-------+ // state.CGenPopLong(stack_size, Reg.ECX); // 5. Cache current Value of Expr in %ebx. // // regs: // %eax = expr // %ebx = expr // %ecx = &expr // // stack: // +-------+ // | ..... | <- %esp // +-------+ // state.MOVL(Reg.EAX, Reg.EBX); // 6. Calculate the new value in %ebx or %eax and save. // Set %eax to be the return Value. // // regs: // %eax = expr or (expr +- 1) // %ebx = (expr +- 1) or expr // %ecx = &expr // // stack: // +-------+ // | ..... | <- %esp // +-------+ // switch (this.Expr.Type.Kind) { case ExprTypeKind.CHAR: case ExprTypeKind.UCHAR: CalcAndSaveByte(state); return Reg.EAX; case ExprTypeKind.SHORT: case ExprTypeKind.USHORT: CalcAndSaveWord(state); return Reg.EAX; case ExprTypeKind.LONG: case ExprTypeKind.ULONG: CalcAndSaveByte(state); return Reg.EAX; case ExprTypeKind.POINTER: CalcAndSavePtr(state); return Reg.EAX; default: throw new InvalidProgramException(); } case Reg.ST0: // Expr is a float. // 4. Pop address to %ecx. // // regs: // %ecx = &expr // // stack: // +-------+ // | ..... | <- %esp // +-------+ // state.CGenPopLong(stack_size, Reg.ECX); // 5. Load 1.0 to FPU stack. // // regs: // %ecx = &expr // // stack: // +-------+ // | ..... | <- %esp // +-------+ // // float stack: // +-------+ // | expr | <- %st(1) // +-------+ // | 1.0 | <- %st(0) // +-------+ // state.FLD1(); // 6. Calculate the new value and save back. // Set %st(0) to be the new or original Value. // // regs: // %ecx = &Expr // // stack: // +-------+ // | ..... | <- %esp // +-------+ // // float stack: // +---------------------+ // | expr or (epxr +- 1) | <- %st(0) // +---------------------+ // switch (this.Expr.Type.Kind) { case ExprTypeKind.FLOAT: CalcAndSaveFloat(state); return Reg.ST0; case ExprTypeKind.DOUBLE: CalcAndSaveDouble(state); return Reg.ST0; default: throw new InvalidProgramException(); } default: throw new InvalidProgramException(); } }
public override void CalcAndSavePtr(CGenState state) { state.SUBL(this.Expr.Type.SizeOf, Reg.EAX); state.MOVL(Reg.EAX, 0, Reg.ECX); }
public override void CalcAndSaveLong(CGenState state) { state.SUBL(1, Reg.EAX); state.MOVL(Reg.EAX, 0, Reg.ECX); }
public override Reg CGenValue(CGenState state) { Reg ret = this.Expr.CGenValue(state); if (ret != Reg.EAX) { throw new InvalidProgramException(); } if (this.Expr.Type.Kind != ExprTypeKind.POINTER) { throw new InvalidProgramException(); } ExprType type = ((PointerType)this.Expr.Type).RefType; switch (type.Kind) { case ExprTypeKind.ARRAY: case ExprTypeKind.FUNCTION: return Reg.EAX; case ExprTypeKind.CHAR: state.MOVSBL(0, Reg.EAX, Reg.EAX); return Reg.EAX; case ExprTypeKind.UCHAR: state.MOVZBL(0, Reg.EAX, Reg.EAX); return Reg.EAX; case ExprTypeKind.SHORT: state.MOVSWL(0, Reg.EAX, Reg.EAX); return Reg.EAX; case ExprTypeKind.USHORT: state.MOVZWL(0, Reg.EAX, Reg.EAX); return Reg.EAX; case ExprTypeKind.LONG: case ExprTypeKind.ULONG: case ExprTypeKind.POINTER: state.MOVL(0, Reg.EAX, Reg.EAX); return Reg.EAX; case ExprTypeKind.FLOAT: state.FLDS(0, Reg.EAX); return Reg.ST0; case ExprTypeKind.DOUBLE: state.FLDL(0, Reg.EAX); return Reg.ST0; case ExprTypeKind.STRUCT_OR_UNION: //// %esi = src address //state.MOVL(Reg.EAX, Reg.ESI); //// %edi = dst address //state.CGenExpandStackBy(Utils.RoundUp(Type.SizeOf, 4)); //state.LEA(0, Reg.ESP, Reg.EDI); //// %ecx = nbytes //state.MOVL(Type.SizeOf, Reg.ECX); //state.CGenMemCpy(); //return Reg.STACK; return Reg.EAX; case ExprTypeKind.VOID: default: throw new InvalidProgramException(); } }
public override Reg CGenValue(CGenState state) { // %eax is the address of the struct/union if (this.Expr.CGenValue(state) != Reg.EAX) { throw new InvalidProgramException(); } if (this.Expr.Type.Kind != ExprTypeKind.STRUCT_OR_UNION) { throw new InvalidProgramException(); } // size of the struct or union Int32 struct_size = this.Expr.Type.SizeOf; // offset inside the pack Int32 attrib_offset = ((StructOrUnionType)this.Expr.Type) .Attribs .First(_ => _.name == this.Name) .offset; // can't be a function designator. switch (this.Type.Kind) { case ExprTypeKind.ARRAY: case ExprTypeKind.STRUCT_OR_UNION: state.ADDL(attrib_offset, Reg.EAX); return Reg.EAX; case ExprTypeKind.CHAR: state.MOVSBL(attrib_offset, Reg.EAX, Reg.EAX); return Reg.EAX; case ExprTypeKind.UCHAR: state.MOVZBL(attrib_offset, Reg.EAX, Reg.EAX); return Reg.EAX; case ExprTypeKind.SHORT: state.MOVSWL(attrib_offset, Reg.EAX, Reg.EAX); return Reg.EAX; case ExprTypeKind.USHORT: state.MOVZWL(attrib_offset, Reg.EAX, Reg.EAX); return Reg.EAX; case ExprTypeKind.LONG: case ExprTypeKind.ULONG: case ExprTypeKind.POINTER: state.MOVL(attrib_offset, Reg.EAX, Reg.EAX); return Reg.EAX; case ExprTypeKind.FLOAT: state.FLDS(attrib_offset, Reg.EAX); return Reg.ST0; case ExprTypeKind.DOUBLE: state.FLDL(attrib_offset, Reg.EAX); return Reg.ST0; default: throw new InvalidProgramException(); } }
public override Reg CGenValue(CGenState state) { // GCC's IA-32 calling convention // Caller is responsible to push all arguments to the stack in reverse order. // Each argument is at least aligned to 4 bytes - even a char would take 4 bytes. // The return Value is stored in %eax, or %st(0), if it is a scalar. // // The stack would look like this after pushing all the arguments: // +--------+ // | .... | // +--------+ // | argn | // +--------+ // | .... | // +--------+ // | arg2 | // +--------+ // | arg1 | // +--------+ <- %esp before call // // Things are different with structs and unions. // Since structs may not fit in 4 bytes, it has to be returned in memory. // Caller allocates a chunk of memory for the struct and push the address of it as an extra argument. // Callee returns %eax with that address. // // The stack would look like this after pushing all the arguments: // +--------+ // +--> | struct | <- struct should be returned here. // | +--------+ // | | argn | // | +--------+ // | | .... | // | +--------+ // | | arg2 | // | +--------+ // | | arg1 | // | +--------+ // +----| addr | <- %esp before call // +--------+ // state.NEWLINE(); state.COMMENT($"Before pushing the arguments, stack size = {state.StackSize}."); var r_pack = Utils.PackArguments(this.Args.Select(_ => _.Type).ToList()); Int32 pack_size = r_pack.Item1; IReadOnlyList<Int32> offsets = r_pack.Item2; if (this.Type is StructOrUnionType) { // If the function returns a struct // Allocate space for return Value. state.COMMENT("Allocate space for returning stack."); state.CGenExpandStackWithAlignment(this.Type.SizeOf, this.Type.Alignment); // Temporarily store the address in %eax. state.MOVL(Reg.ESP, Reg.EAX); // add an extra argument and move all other arguments upwards. pack_size += ExprType.SIZEOF_POINTER; offsets = offsets.Select(_ => _ + ExprType.SIZEOF_POINTER).ToList(); } // Allocate space for arguments. // If returning struct, the extra pointer is included. state.COMMENT($"Arguments take {pack_size} bytes."); state.CGenExpandStackBy(pack_size); state.NEWLINE(); // Store the address as the first argument. if (this.Type is StructOrUnionType) { state.COMMENT("Putting extra argument for struct return address."); state.MOVL(Reg.EAX, 0, Reg.ESP); state.NEWLINE(); } // This is the stack size before calling the function. Int32 header_base = -state.StackSize; // Push the arguments onto the stack in reverse order for (Int32 i = this.Args.Count; i-- > 0;) { Expr arg = this.Args[i]; Int32 pos = header_base + offsets[i]; state.COMMENT($"Argument {i} is at {pos}"); Reg ret = arg.CGenValue(state); switch (arg.Type.Kind) { case ExprTypeKind.ARRAY: case ExprTypeKind.CHAR: case ExprTypeKind.UCHAR: case ExprTypeKind.SHORT: case ExprTypeKind.USHORT: case ExprTypeKind.LONG: case ExprTypeKind.ULONG: case ExprTypeKind.POINTER: if (ret != Reg.EAX) { throw new InvalidProgramException(); } state.MOVL(Reg.EAX, pos, Reg.EBP); break; case ExprTypeKind.DOUBLE: if (ret != Reg.ST0) { throw new InvalidProgramException(); } state.FSTPL(pos, Reg.EBP); break; case ExprTypeKind.FLOAT: if (ret != Reg.ST0) { throw new InvalidProgramException(); } state.FSTPL(pos, Reg.EBP); break; case ExprTypeKind.STRUCT_OR_UNION: if (ret != Reg.EAX) { throw new InvalidProgramException(); } state.MOVL(Reg.EAX, Reg.ESI); state.LEA(pos, Reg.EBP, Reg.EDI); state.MOVL(arg.Type.SizeOf, Reg.ECX); state.CGenMemCpy(); break; default: throw new InvalidProgramException(); } state.NEWLINE(); } // When evaluating arguments, the stack might be changed. // We must restore the stack. state.CGenForceStackSizeTo(-header_base); // Get function address if (this.Func.Type is FunctionType) { this.Func.CGenAddress(state); } else if (this.Func.Type is PointerType) { this.Func.CGenValue(state); } else { throw new InvalidProgramException(); } state.CALL("*%eax"); state.COMMENT("Function returned."); state.NEWLINE(); if (this.Type.Kind == ExprTypeKind.FLOAT || this.Type.Kind == ExprTypeKind.DOUBLE) { return Reg.ST0; } return Reg.EAX; }
public override Reg CGenValue(CGenState state) { Env.Entry entry = this.Env.Find(this.Name).Value; Int32 offset = entry.Offset; //if (entry.Kind == Env.EntryKind.STACK) { // offset = -offset; //} switch (entry.Kind) { case Env.EntryKind.ENUM: // 1. If the variable is an enum constant, // return the Value in %eax. state.MOVL(offset, Reg.EAX); return Reg.EAX; case Env.EntryKind.FRAME: case Env.EntryKind.STACK: // 2. If the variable is a function argument or a local variable, // the address would be offset(%ebp). switch (this.Type.Kind) { case ExprTypeKind.LONG: case ExprTypeKind.ULONG: case ExprTypeKind.POINTER: // %eax = offset(%ebp) state.MOVL(offset, Reg.EBP, Reg.EAX); return Reg.EAX; case ExprTypeKind.FLOAT: // %st(0) = offset(%ebp) state.FLDS(offset, Reg.EBP); return Reg.ST0; case ExprTypeKind.DOUBLE: // %st(0) = offset(%ebp) state.FLDL(offset, Reg.EBP); return Reg.ST0; case ExprTypeKind.STRUCT_OR_UNION: // %eax = address state.LEA(offset, Reg.EBP, Reg.EAX); return Reg.EAX; //state.LEA(offset, Reg.EBP, Reg.ESI); // source address //state.CGenExpandStackBy(Utils.RoundUp(Type.SizeOf, 4)); //state.LEA(0, Reg.ESP, Reg.EDI); // destination address //state.MOVL(Type.SizeOf, Reg.ECX); // nbytes //state.CGenMemCpy(); //return Reg.STACK; case ExprTypeKind.VOID: throw new InvalidProgramException("How could a variable be void?"); // %eax = $0 // state.MOVL(0, Reg.EAX); // return Reg.EAX; case ExprTypeKind.FUNCTION: throw new InvalidProgramException("How could a variable be a function designator?"); // %eax = function_name // state.MOVL(name, Reg.EAX); // return Reg.EAX; case ExprTypeKind.CHAR: // %eax = [char -> long](off(%ebp)) state.MOVSBL(offset, Reg.EBP, Reg.EAX); return Reg.EAX; case ExprTypeKind.UCHAR: // %eax = [uchar -> ulong](off(%ebp)) state.MOVZBL(offset, Reg.EBP, Reg.EAX); return Reg.EAX; case ExprTypeKind.SHORT: // %eax = [short -> long](off(%ebp)) state.MOVSWL(offset, Reg.EBP, Reg.EAX); return Reg.EAX; case ExprTypeKind.USHORT: // %eax = [ushort -> ulong](off(%ebp)) state.MOVZWL(offset, Reg.EBP, Reg.EAX); return Reg.EAX; case ExprTypeKind.ARRAY: // %eax = (off(%ebp)) state.LEA(offset, Reg.EBP, Reg.EAX); // source address return Reg.EAX; default: throw new InvalidOperationException($"Cannot get value of {this.Type.Kind}"); } case Env.EntryKind.GLOBAL: switch (this.Type.Kind) { case ExprTypeKind.CHAR: state.MOVSBL(this.Name, Reg.EAX); return Reg.EAX; case ExprTypeKind.UCHAR: state.MOVZBL(this.Name, Reg.EAX); return Reg.EAX; case ExprTypeKind.SHORT: state.MOVSWL(this.Name, Reg.EAX); return Reg.EAX; case ExprTypeKind.USHORT: state.MOVZWL(this.Name, Reg.EAX); return Reg.EAX; case ExprTypeKind.LONG: case ExprTypeKind.ULONG: case ExprTypeKind.POINTER: state.MOVL(this.Name, Reg.EAX); return Reg.EAX; case ExprTypeKind.FUNCTION: state.MOVL("$" + this.Name, Reg.EAX); return Reg.EAX; case ExprTypeKind.FLOAT: state.FLDS(this.Name); return Reg.ST0; case ExprTypeKind.DOUBLE: state.FLDL(this.Name); return Reg.ST0; case ExprTypeKind.STRUCT_OR_UNION: state.MOVL($"${this.Name}", Reg.EAX); return Reg.EAX; //state.LEA(name, Reg.ESI); // source address //state.CGenExpandStackBy(Utils.RoundUp(Type.SizeOf, 4)); //state.LEA(0, Reg.ESP, Reg.EDI); // destination address //state.MOVL(Type.SizeOf, Reg.ECX); // nbytes //state.CGenMemCpy(); //return Reg.STACK; case ExprTypeKind.VOID: throw new InvalidProgramException("How could a variable be void?"); //state.MOVL(0, Reg.EAX); //return Reg.EAX; case ExprTypeKind.ARRAY: state.MOVL($"${this.Name}", Reg.EAX); return Reg.EAX; default: throw new InvalidProgramException("cannot get the Value of a " + this.Type.Kind); } case Env.EntryKind.TYPEDEF: default: throw new InvalidProgramException("cannot get the Value of a " + entry.Kind); } }
public override Reg CGenValue(CGenState state) { // 1. %eax = &left this.Left.CGenAddress(state); // 2. push %eax Int32 pos = state.CGenPushLong(Reg.EAX); Reg ret = this.Right.CGenValue(state); switch (this.Left.Type.Kind) { case ExprTypeKind.CHAR: case ExprTypeKind.UCHAR: // pop %ebx // now %ebx = %Left state.CGenPopLong(pos, Reg.EBX); // *%ebx = %al state.MOVB(Reg.AL, 0, Reg.EBX); return Reg.EAX; case ExprTypeKind.SHORT: case ExprTypeKind.USHORT: // pop %ebx // now %ebx = %Left state.CGenPopLong(pos, Reg.EBX); // *%ebx = %al state.MOVW(Reg.AX, 0, Reg.EBX); return Reg.EAX; case ExprTypeKind.LONG: case ExprTypeKind.ULONG: case ExprTypeKind.POINTER: // pop %ebx // now %ebx = &Left state.CGenPopLong(pos, Reg.EBX); // *%ebx = %al state.MOVL(Reg.EAX, 0, Reg.EBX); return Reg.EAX; case ExprTypeKind.FLOAT: // pop %ebx // now %ebx = &Left state.CGenPopLong(pos, Reg.EBX); // *%ebx = %st(0) state.FSTS(0, Reg.EBX); return Reg.ST0; case ExprTypeKind.DOUBLE: // pop %ebx // now %ebx = &Left state.CGenPopLong(pos, Reg.EBX); // *%ebx = %st(0) state.FSTL(0, Reg.EBX); return Reg.ST0; case ExprTypeKind.STRUCT_OR_UNION: // pop %edi // now %edi = &Left state.CGenPopLong(pos, Reg.EDI); // %esi = &Right state.MOVL(Reg.EAX, Reg.ESI); // %ecx = nbytes state.MOVL(this.Left.Type.SizeOf, Reg.ECX); state.CGenMemCpy(); // %eax = &Left state.MOVL(Reg.EDI, Reg.EAX); return Reg.EAX; case ExprTypeKind.FUNCTION: case ExprTypeKind.VOID: case ExprTypeKind.ARRAY: case ExprTypeKind.INCOMPLETE_ARRAY: default: throw new InvalidProgramException("cannot assign to a " + this.Type.Kind); } }
public override Reg CGenValue(CGenState state) { Int32 label_set = state.label_idx; state.label_idx++; Int32 label_finish = state.label_idx; state.label_idx++; Reg ret = this.Left.CGenValue(state); switch (ret) { case Reg.EAX: state.TESTL(Reg.EAX, Reg.EAX); state.JNZ(label_set); break; case Reg.ST0: state.FLDZ(); state.FUCOMIP(); state.FSTP(Reg.ST0); state.JNZ(label_set); break; default: throw new InvalidProgramException(); } ret = this.Right.CGenValue(state); switch (ret) { case Reg.EAX: state.TESTL(Reg.EAX, Reg.EAX); state.JNZ(label_set); break; case Reg.ST0: state.FLDZ(); state.FUCOMIP(); state.FSTP(Reg.ST0); state.JNZ(label_set); break; default: throw new InvalidProgramException(); } state.MOVL(0, Reg.EAX); state.JMP(label_finish); state.CGenLabel(label_set); state.MOVL(1, Reg.EAX); state.CGenLabel(label_finish); return Reg.EAX; }
public override void OperateULong(CGenState state) { state.CLTD(); state.DIVL(Reg.EBX); state.MOVL(Reg.EDX, Reg.EAX); }
public override void CGenStmt(Env env, CGenState state) { ExprType ret_type = env.GetCurrentFunction().ReturnType; Int32 stack_size = state.StackSize; if (this.ExprOpt.IsSome) { // Evaluate the Value. this.ExprOpt.Value.CGenValue(state); // If the function returns a struct, copy it to the address given by 8(%ebp). if (this.ExprOpt.Value.Type is StructOrUnionType) { state.MOVL(Reg.EAX, Reg.ESI); state.MOVL(2 * ExprType.SIZEOF_POINTER, Reg.EBP, Reg.EDI); state.MOVL(this.ExprOpt.Value.Type.SizeOf, Reg.ECX); state.CGenMemCpy(); state.MOVL(2 * ExprType.SIZEOF_POINTER, Reg.EBP, Reg.EAX); } // Restore stack size. state.CGenForceStackSizeTo(stack_size); } // Jump to end of the function. state.JMP(state.ReturnLabel); }