public void CGenDecln(Env env, CGenState state) {
// .text
// [.globl <func>]
// <func>:
// pushl %ebp
// movl %esp, %ebp
//
state.TEXT();
Env.Entry entry = env.Find(name).Value;
state.COMMENT(ToString());
switch (entry.kind) {
case Env.EntryKind.GLOBAL:
switch (scs) {
case Decln.SCS.AUTO:
case Decln.SCS.EXTERN:
state.GLOBL(name);
break;
case Decln.SCS.STATIC:
// static definition
break;
default:
throw new InvalidOperationException();
}
break;
default:
throw new InvalidOperationException();
}
state.CGenFuncStart(name);
state.InFunction(GotoLabelsGrabber.GrabLabels(this.stmt));
stmt.CGenStmt(env, state);
state.CGenLabel(state.ReturnLabel);
state.OutFunction();
// leave
// ret
state.LEAVE();
state.RET();
state.NEWLINE();
}
public override void CGenAddress(Env env, CGenState state)
{
Env.Entry entry = env.Find(name).Value;
Int32 offset = entry.offset;
switch (entry.kind) {
case Env.EntryKind.FRAME:
case Env.EntryKind.STACK:
state.LEA(offset, Reg.EBP, Reg.EAX);
return;
case Env.EntryKind.GLOBAL:
state.LEA(name, Reg.EAX);
return;
case Env.EntryKind.ENUM:
case Env.EntryKind.TYPEDEF:
default:
throw new InvalidProgramException("cannot get the address of " + entry.kind);
}
}
public override Reg CGenValue(Env env, CGenState state)
{
Env.Entry entry = env.Find(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 (type.kind) {
case ExprType.Kind.LONG:
case ExprType.Kind.ULONG:
case ExprType.Kind.POINTER:
// %eax = offset(%ebp)
state.MOVL(offset, Reg.EBP, Reg.EAX);
return Reg.EAX;
case ExprType.Kind.FLOAT:
// %st(0) = offset(%ebp)
state.FLDS(offset, Reg.EBP);
return Reg.ST0;
case ExprType.Kind.DOUBLE:
// %st(0) = offset(%ebp)
state.FLDL(offset, Reg.EBP);
return Reg.ST0;
case ExprType.Kind.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 ExprType.Kind.VOID:
throw new InvalidProgramException("How could a variable be void?");
// %eax = $0
// state.MOVL(0, Reg.EAX);
// return Reg.EAX;
case ExprType.Kind.FUNCTION:
throw new InvalidProgramException("How could a variable be a function designator?");
// %eax = function_name
// state.MOVL(name, Reg.EAX);
// return Reg.EAX;
case ExprType.Kind.CHAR:
// %eax = [char -> long](off(%ebp))
state.MOVSBL(offset, Reg.EBP, Reg.EAX);
return Reg.EAX;
case ExprType.Kind.UCHAR:
// %eax = [uchar -> ulong](off(%ebp))
state.MOVZBL(offset, Reg.EBP, Reg.EAX);
return Reg.EAX;
case ExprType.Kind.SHORT:
// %eax = [short -> long](off(%ebp))
state.MOVSWL(offset, Reg.EBP, Reg.EAX);
return Reg.EAX;
case ExprType.Kind.USHORT:
// %eax = [ushort -> ulong](off(%ebp))
state.MOVZWL(offset, Reg.EBP, Reg.EAX);
return Reg.EAX;
case ExprType.Kind.ARRAY:
// %eax = (off(%ebp))
state.LEA(offset, Reg.EBP, Reg.EAX); // source address
return Reg.EAX;
default:
throw new InvalidOperationException($"Cannot get value of {type.kind}");
}
case Env.EntryKind.GLOBAL:
switch (type.kind) {
case ExprType.Kind.CHAR:
state.MOVSBL(name, Reg.EAX);
return Reg.EAX;
case ExprType.Kind.UCHAR:
state.MOVZBL(name, Reg.EAX);
return Reg.EAX;
case ExprType.Kind.SHORT:
state.MOVSWL(name, Reg.EAX);
return Reg.EAX;
case ExprType.Kind.USHORT:
state.MOVZWL(name, Reg.EAX);
return Reg.EAX;
case ExprType.Kind.LONG:
case ExprType.Kind.ULONG:
case ExprType.Kind.POINTER:
state.MOVL(name, Reg.EAX);
return Reg.EAX;
case ExprType.Kind.FUNCTION:
state.MOVL("$" + name, Reg.EAX);
return Reg.EAX;
case ExprType.Kind.FLOAT:
state.FLDS(name);
return Reg.ST0;
case ExprType.Kind.DOUBLE:
state.FLDL(name);
return Reg.ST0;
case ExprType.Kind.STRUCT_OR_UNION:
state.MOVL($"${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 ExprType.Kind.VOID:
throw new InvalidProgramException("How could a variable be void?");
//state.MOVL(0, Reg.EAX);
//return Reg.EAX;
case ExprType.Kind.ARRAY:
state.MOVL($"${name}", Reg.EAX);
return Reg.EAX;
default:
throw new InvalidProgramException("cannot get the value of a " + type.kind.ToString());
}
case Env.EntryKind.TYPEDEF:
default:
throw new InvalidProgramException("cannot get the value of a " + entry.kind.ToString());
}
}
// * 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 (scs) {
case SCS.AUTO:
state.GLOBL(name);
break;
case SCS.EXTERN:
throw new InvalidProgramException();
case SCS.STATIC:
break;
case SCS.TYPEDEF:
// Ignore.
return;
default:
throw new InvalidProgramException();
}
state.DATA();
state.ALIGN(ExprType.ALIGN_LONG);
state.CGenLabel(name);
Int32 last = 0;
initr.Iterate(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 ExprType.Kind.CHAR:
case ExprType.Kind.UCHAR:
case ExprType.Kind.SHORT:
case ExprType.Kind.USHORT:
throw new NotImplementedException();
case ExprType.Kind.LONG:
state.LONG(((ConstLong)expr).value);
break;
case ExprType.Kind.ULONG:
state.LONG((Int32)((ConstULong)expr).value);
break;
case ExprType.Kind.POINTER:
state.LONG((Int32)((ConstPtr)expr).value);
break;
case ExprType.Kind.FLOAT:
byte[] float_bytes = BitConverter.GetBytes(((ConstFloat)expr).value);
Int32 intval = BitConverter.ToInt32(float_bytes, 0);
state.LONG(intval);
break;
case ExprType.Kind.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 (scs) {
case SCS.AUTO:
// .comm name,size,align
break;
case SCS.EXTERN:
break;
case SCS.STATIC:
// .local name
// .comm name,size,align
state.LOCAL(name);
break;
case SCS.TYPEDEF:
// Ignore.
return;
default:
throw new InvalidProgramException();
}
if (type.kind != ExprType.Kind.FUNCTION) {
state.COMM(name, 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(name).Value.offset;
if (this.initr.IsNone) {
return;
}
Initr initr = this.initr.Value;
initr.Iterate(type, (Int32 offset, Expr expr) => {
Reg ret = expr.CGenValue(env, state);
switch (expr.type.kind) {
case ExprType.Kind.CHAR:
case ExprType.Kind.UCHAR:
state.MOVB(Reg.EAX, pos + offset, Reg.EBP);
break;
case ExprType.Kind.SHORT:
case ExprType.Kind.USHORT:
state.MOVW(Reg.EAX, pos + offset, Reg.EBP);
break;
case ExprType.Kind.DOUBLE:
state.FSTPL(pos + offset, Reg.EBP);
break;
case ExprType.Kind.FLOAT:
state.FSTPS(pos + offset, Reg.EBP);
break;
case ExprType.Kind.LONG:
case ExprType.Kind.ULONG:
case ExprType.Kind.POINTER:
state.MOVL(Reg.EAX, pos + offset, Reg.EBP);
break;
case ExprType.Kind.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 ExprType.Kind.ARRAY:
case ExprType.Kind.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
}
