public override void CGenStmt(Env env, CGenState state) {
if (this.ExprOpt.IsSome) {
Int32 stack_size = state.StackSize;
this.ExprOpt.Value.CGenValue(state);
state.CGenForceStackSizeTo(stack_size);
}
}
public override void CGenStmt(Env env, CGenState state) {
foreach (Tuple<Env, Decln> decln in this.Declns) {
decln.Item2.CGenDecln(decln.Item1, state);
}
foreach (Tuple<Env, Stmt> stmt in this.Stmts) {
stmt.Item2.CGenStmt(stmt.Item1, state);
}
}
public void CGenDecln(Env env, CGenState state) {
// .text
// [.globl <func>]
// <func>:
// pushl %ebp
// movl %esp, %ebp
//
state.TEXT();
Env.Entry entry = env.Find(this.name).Value;
state.COMMENT(ToString());
switch (entry.Kind) {
case Env.EntryKind.GLOBAL:
switch (this.scs) {
case StorageClass.AUTO:
case StorageClass.EXTERN:
state.GLOBL(this.name);
break;
case StorageClass.STATIC:
// static definition
break;
default:
throw new InvalidOperationException();
}
break;
default:
throw new InvalidOperationException();
}
state.CGenFuncStart(this.name);
state.InFunction(GotoLabelsGrabber.GrabLabels(this.stmt));
this.stmt.CGenStmt(env, state);
state.CGenLabel(state.ReturnLabel);
state.OutFunction();
// leave
// ret
state.LEAVE();
state.RET();
state.NEWLINE();
}
public ConstDouble(Double value, Env env)
: base(env) {
this.Value = value;
}
public Variable(ExprType type, String name, Env env) {
this.Name = name;
this.Env = env;
this.Type = type;
}
// MakeCast
// ========
// input: Expr, Type
// output: TypeCast
// converts Expr to Type
//
public static Expr MakeCast(Expr expr, ExprType type, Env env) {
// if two types are equal, return Expr
if (EqualType(expr.Type, type)) {
return expr;
}
// from pointer
if (expr.Type.Kind == ExprTypeKind.POINTER) {
return FromPointer(expr, type, env);
}
// to pointer
if (type.Kind == ExprTypeKind.POINTER) {
return ToPointer(expr, type, env);
}
switch (expr.Type.Kind) {
// from signed integral
case ExprTypeKind.CHAR:
case ExprTypeKind.SHORT:
case ExprTypeKind.LONG:
return SignedIntegralToArith(expr, type);
// from unsigned integral
case ExprTypeKind.UCHAR:
case ExprTypeKind.USHORT:
case ExprTypeKind.ULONG:
return UnsignedIntegralToArith(expr, type);
// from float
case ExprTypeKind.FLOAT:
case ExprTypeKind.DOUBLE:
return FloatToArith(expr, type);
case ExprTypeKind.VOID:
case ExprTypeKind.POINTER:
case ExprTypeKind.FUNCTION:
case ExprTypeKind.ARRAY:
case ExprTypeKind.INCOMPLETE_ARRAY:
case ExprTypeKind.STRUCT_OR_UNION:
default:
throw new InvalidOperationException("Error: expression Type not supported for casting from.");
}
}
/// <summary>
/// From:
/// pointer
/// To:
/// pointer, integral
/// </summary>
public static Expr FromPointer(Expr expr, ExprType type, Env env) {
ExprTypeKind from = expr.Type.Kind;
ExprTypeKind to = type.Kind;
if (from != ExprTypeKind.POINTER) {
throw new InvalidOperationException("Expected a pointer.");
}
// if we are casting to another pointer, do a nop
if (to == ExprTypeKind.POINTER) {
if (expr.IsConstExpr) {
return new ConstPtr(((ConstPtr)expr).Value, type, env);
}
return new TypeCast(TypeCastType.NOP, expr, type, env);
}
// if we are casting to an integral
if (type.IsIntegral) {
// pointer -> ulong -> whatever integral
if (expr.IsConstExpr) {
expr = new ConstULong(((ConstPtr)expr).Value, env);
} else {
expr = new TypeCast(TypeCastType.NOP, expr, new ULongType(type.IsConst, type.IsVolatile), env);
}
return MakeCast(expr, type, env);
}
throw new InvalidOperationException("Casting from a pointer to an unsupported Type.");
}
public Reg CGenExprStmt(Env env, Expr expr, CGenState state) {
Int32 stack_size = state.StackSize;
Reg ret = expr.CGenValue(state);
state.CGenForceStackSizeTo(stack_size);
return ret;
}
public ConstPtr(UInt32 value, ExprType type, Env env)
: base(env) {
this.Value = value;
this.Type = type;
}
protected ConstExpr(Env env) {
this.Env = env;
}
public ConstUChar(Byte value, Env env)
: base(env) {
this.Value = value;
}
public ConstUShort(UInt16 value, Env env)
: base(env) {
this.Value = value;
}
public ConstULong(UInt32 value, Env env)
: base(env) {
this.Value = value;
}
public ConstStringLiteral(String value, Env env)
: base(env) {
this.Value = value;
}
public override void CGenStmt(Env env, CGenState state) {
state.CGenLabel(state.GotoLabel(this.Label));
state.CGenForceStackSizeTo(state.StackSize);
this.Stmt.CGenStmt(env, state);
}
public override void CGenStmt(Env env, CGenState state) {
Int32 label = state.BreakLabel;
state.JMP(label);
}
public override void CGenStmt(Env env, CGenState state) {
Int32 start_label = state.RequestLabel();
Int32 finish_label = state.RequestLabel();
Int32 continue_label = state.RequestLabel();
// start:
state.CGenLabel(start_label);
// Body
state.InLoop(continue_label, finish_label);
this.Body.CGenStmt(env, state);
state.OutLabels();
state.CGenLabel(continue_label);
// test Cond
Reg ret = CGenExprStmt(env, this.Cond, state);
CGenTest(ret, state);
state.JNZ(start_label);
state.CGenLabel(finish_label);
}
public abstract void CGenStmt(Env env, CGenState state);
public override void CGenStmt(Env env, CGenState state) {
// Init
this.Init.Map(_ => CGenExprStmt(env, _, state));
Int32 start_label = state.RequestLabel();
Int32 finish_label = state.RequestLabel();
Int32 continue_label = state.RequestLabel();
// start:
state.CGenLabel(start_label);
// test cont
this.Cond.Map(_ => {
Reg ret = CGenExprStmt(env, _, state);
CGenTest(ret, state);
return ret;
});
// jz finish
state.JZ(finish_label);
// Body
state.InLoop(continue_label, finish_label);
this.Body.CGenStmt(env, state);
state.OutLabels();
// continue:
state.CGenLabel(continue_label);
// Loop
this.Loop.Map(_ => CGenExprStmt(env, _, state));
// jmp start
state.JMP(start_label);
// finish:
state.CGenLabel(finish_label);
}
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);
}
public override void CGenStmt(Env env, CGenState state) {
// Inside a switch statement, the initializations are ignored,
// but the stack size should be changed.
List<Tuple<Env, Decln>> declns;
List<Tuple<Env, Stmt>> stmts;
var compoundStmt = this.Stmt as CompoundStmt;
if (compoundStmt == null) {
throw new NotImplementedException();
}
declns = compoundStmt.Declns;
stmts = compoundStmt.Stmts;
// Track all case values.
IReadOnlyList<Int32> values = CaseLabelsGrabber.GrabLabels(this);
// Make sure there are no duplicates.
if (values.Distinct().Count() != values.Count) {
throw new InvalidOperationException("case labels not unique.");
}
// Request labels for these values.
Dictionary<Int32, Int32> value_to_label = values.ToDictionary(value => value, value => state.RequestLabel());
Int32 label_finish = state.RequestLabel();
Int32 num_default_stmts = stmts.Count(_ => _.Item2 is DefaultStmt);
if (num_default_stmts > 1) {
throw new InvalidOperationException("duplicate defaults.");
}
Int32 label_default =
num_default_stmts == 1 ?
state.RequestLabel() :
label_finish;
Int32 saved_stack_size = state.StackSize;
Int32 stack_size =
declns.Any() ?
declns.Last().Item1.StackSize :
saved_stack_size;
// 1. Evaluate Expr.
CGenExprStmt(env, this.Expr, state);
// 2. Expand stack.
state.CGenForceStackSizeTo(stack_size);
// 3. Make the Jump list.
foreach (KeyValuePair<Int32, Int32> value_label_pair in value_to_label) {
state.CMPL(value_label_pair.Key, Reg.EAX);
state.JZ(value_label_pair.Value);
}
state.JMP(label_default);
// 4. List all the statements.
state.InSwitch(label_finish, label_default, value_to_label);
foreach (Tuple<Env, Stmt> env_stmt_pair in stmts) {
env_stmt_pair.Item2.CGenStmt(env_stmt_pair.Item1, state);
}
state.OutLabels();
// 5. finish:
state.CGenLabel(label_finish);
// 6. Restore stack size.
state.CGenForceStackSizeTo(saved_stack_size);
}
private TypeCast(TypeCastType kind, Expr expr, ExprType type, Env env) {
this.Expr = expr;
this.Kind = kind;
this.Type = type;
this.Env = env;
}
public override void CGenStmt(Env env, CGenState state) {
Int32 label = state.CaseLabel(this.Value);
state.CGenLabel(label);
this.Stmt.CGenStmt(env, state);
}
/// <summary>
/// From:
/// pointer, integral
/// To:
/// pointer
/// </summary>
public static Expr ToPointer(Expr expr, ExprType type, Env env) {
ExprTypeKind from = expr.Type.Kind;
ExprTypeKind to = type.Kind;
if (to != ExprTypeKind.POINTER) {
throw new InvalidOperationException("Error: expected casting to pointer.");
}
if (from == ExprTypeKind.POINTER) {
if (expr.IsConstExpr) {
return new ConstPtr(((ConstPtr)expr).Value, type, env);
}
return new TypeCast(TypeCastType.NOP, expr, type, env);
}
if (expr.Type.IsIntegral) {
// if we are casting from an integral
// whatever integral -> ulong
switch (expr.Type.Kind) {
case ExprTypeKind.CHAR:
case ExprTypeKind.SHORT:
case ExprTypeKind.LONG:
expr = SignedIntegralToArith(expr, new ULongType(type.IsConst, type.IsVolatile));
break;
case ExprTypeKind.UCHAR:
case ExprTypeKind.USHORT:
case ExprTypeKind.ULONG:
expr = UnsignedIntegralToArith(expr, new ULongType(type.IsConst, type.IsVolatile));
break;
default:
break;
}
// ulong -> pointer
if (expr.IsConstExpr) {
return new ConstPtr(((ConstULong)expr).Value, type, env);
}
return new TypeCast(TypeCastType.NOP, expr, type, env);
}
if (expr.Type is FunctionType) {
if (!expr.Type.EqualType(((PointerType)type).RefType)) {
throw new InvalidOperationException("Casting from an incompatible function.");
}
// TODO: only allow compatible Type?
return new TypeCast(TypeCastType.NOP, expr, type, env);
}
if (expr.Type is ArrayType) {
// TODO: allow any pointer Type to cast to?
return new TypeCast(TypeCastType.NOP, expr, type, env);
}
throw new InvalidOperationException("Error: casting from an unsupported Type to pointer.");
}
public override void CGenStmt(Env env, CGenState state) {
Int32 label = state.DefaultLabel;
state.CGenLabel(label);
this.Stmt.CGenStmt(env, state);
}
public override void CGenStmt(Env env, CGenState state) {
Reg ret = CGenExprStmt(env, this.Cond, state);
CGenTest(ret, state);
Int32 false_label = state.RequestLabel();
Int32 finish_label = state.RequestLabel();
state.JZ(false_label);
this.TrueStmt.CGenStmt(env, state);
state.JMP(finish_label);
state.CGenLabel(false_label);
this.FalseStmt.CGenStmt(env, state);
state.CGenLabel(finish_label);
}
public override void CGenStmt(Env env, CGenState state) {
Int32 label = state.GotoLabel(this.Label);
state.JMP(label);
}
// * 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 ConstFloat(Single value, Env env)
: base(env) {
this.Value = value;
}
