From 16aa0ac315f96f62dc7bf3588a8219ea4b1ee6f6 Mon Sep 17 00:00:00 2001 From: drmortalwombat <90205530+drmortalwombat@users.noreply.github.com> Date: Mon, 6 Sep 2021 21:36:45 +0200 Subject: [PATCH] Renamed non conforming member variables --- oscar64/ByteCodeGenerator.cpp | 1246 ++++++++++--------- oscar64/ByteCodeGenerator.h | 12 +- oscar64/InterCode.cpp | 2042 ++++++++++++++++---------------- oscar64/InterCode.h | 127 +- oscar64/InterCodeGenerator.cpp | 968 +++++++-------- 5 files changed, 2154 insertions(+), 2241 deletions(-) diff --git a/oscar64/ByteCodeGenerator.cpp b/oscar64/ByteCodeGenerator.cpp index 0b55a90..b4ab708 100644 --- a/oscar64/ByteCodeGenerator.cpp +++ b/oscar64/ByteCodeGenerator.cpp @@ -181,7 +181,7 @@ void ByteCodeInstruction::Assemble(ByteCodeGenerator* generator, ByteCodeBasicBl block->PutCode(generator, mCode); block->PutByte(mRegister); ByteCodeRelocation rl; - rl.mAddr = block->code.Size(); + rl.mAddr = block->mCode.Size(); rl.mFunction = mFunction; rl.mLower = true; rl.mUpper = true; @@ -227,7 +227,7 @@ void ByteCodeInstruction::Assemble(ByteCodeGenerator* generator, ByteCodeBasicBl if (mRelocate) { ByteCodeRelocation rl; - rl.mAddr = block->code.Size(); + rl.mAddr = block->mCode.Size(); rl.mFunction = mFunction; rl.mLower = true; rl.mUpper = true; @@ -247,7 +247,7 @@ void ByteCodeInstruction::Assemble(ByteCodeGenerator* generator, ByteCodeBasicBl if (mRelocate) { ByteCodeRelocation rl; - rl.mAddr = block->code.Size(); + rl.mAddr = block->mCode.Size(); rl.mFunction = mFunction; rl.mLower = true; rl.mUpper = true; @@ -404,7 +404,7 @@ void ByteCodeInstruction::Assemble(ByteCodeGenerator* generator, ByteCodeBasicBl block->PutCode(generator, mCode); ByteCodeRelocation rl; - rl.mAddr = block->code.Size(); + rl.mAddr = block->mCode.Size(); rl.mFunction = false; rl.mLower = true; rl.mUpper = true; @@ -448,28 +448,28 @@ void ByteCodeInstruction::Assemble(ByteCodeGenerator* generator, ByteCodeBasicBl void ByteCodeBasicBlock::PutByte(uint8 code) { - this->code.Insert(code); + this->mCode.Insert(code); } void ByteCodeBasicBlock::PutWord(uint16 code) { - this->code.Insert((uint8)(code & 0xff)); - this->code.Insert((uint8)(code >> 8)); + this->mCode.Insert((uint8)(code & 0xff)); + this->mCode.Insert((uint8)(code >> 8)); } void ByteCodeBasicBlock::PutDWord(uint32 code) { - this->code.Insert((uint8)(code & 0xff)); - this->code.Insert((uint8)((code >> 8) & 0xff)); - this->code.Insert((uint8)((code >> 16) & 0xff)); - this->code.Insert((uint8)((code >> 24) & 0xff)); + this->mCode.Insert((uint8)(code & 0xff)); + this->mCode.Insert((uint8)((code >> 8) & 0xff)); + this->mCode.Insert((uint8)((code >> 16) & 0xff)); + this->mCode.Insert((uint8)((code >> 24) & 0xff)); } void ByteCodeBasicBlock::PutBytes(const uint8* code, int num) { while (num--) { - this->code.Insert(*code++); + this->mCode.Insert(*code++); } } @@ -498,13 +498,12 @@ int ByteCodeBasicBlock::PutBranch(ByteCodeGenerator* generator, ByteCode code, i ByteCodeBasicBlock::ByteCodeBasicBlock(void) : mRelocations({ 0 }), mIns(ByteCodeInstruction(BC_NOP)) { - trueJump = falseJump = NULL; - trueLink = falseLink = NULL; + mTrueJump = mFalseJump = NULL; + mTrueLink = mFalseLink = NULL; mOffset = 0x7fffffff; - copied = false; - knownShortBranch = false; - killed = false; - bypassed = false; + mCopied = false; + mKnownShortBranch = false; + mBypassed = false; } void ByteCodeBasicBlock::IntConstToAccu(__int64 val) @@ -536,53 +535,53 @@ void ByteCodeBasicBlock::IntConstToAddr(__int64 val) void ByteCodeBasicBlock::LoadConstant(InterCodeProcedure* proc, const InterInstruction& ins) { - if (ins.ttype == IT_FLOAT) + if (ins.mTType == IT_FLOAT) { union { float f; int v; } cc; - cc.f = ins.fvalue; + cc.f = ins.mFloatValue; ByteCodeInstruction bins(BC_CONST_32); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; bins.mValue = cc.v; mIns.Push(bins); } - else if (ins.ttype == IT_POINTER) + else if (ins.mTType == IT_POINTER) { - if (ins.mem == IM_GLOBAL) + if (ins.mMemory == IM_GLOBAL) { ByteCodeInstruction bins(BC_LEA_ABS); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; - bins.mVIndex = ins.vindex; - bins.mValue = ins.ivalue; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; + bins.mVIndex = ins.mVarIndex; + bins.mValue = ins.mIntValue; bins.mRelocate = true; bins.mFunction = false; mIns.Push(bins); } - else if (ins.mem == IM_ABSOLUTE) + else if (ins.mMemory == IM_ABSOLUTE) { ByteCodeInstruction bins(BC_LEA_ABS); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; - bins.mValue = ins.ivalue; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; + bins.mValue = ins.mIntValue; mIns.Push(bins); } - else if (ins.mem == IM_LOCAL) + else if (ins.mMemory == IM_LOCAL) { ByteCodeInstruction bins(BC_LEA_LOCAL); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; - bins.mValue = ins.ivalue + proc->mLocalVars[ins.vindex].mOffset; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; + bins.mValue = ins.mIntValue + proc->mLocalVars[ins.mVarIndex].mOffset; mIns.Push(bins); } - else if (ins.mem == IM_PARAM) + else if (ins.mMemory == IM_PARAM) { ByteCodeInstruction bins(BC_LEA_LOCAL); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; - bins.mValue = ins.ivalue + ins.vindex + proc->mLocalSize + 2; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; + bins.mValue = ins.mIntValue + ins.mVarIndex + proc->mLocalSize + 2; mIns.Push(bins); } - else if (ins.mem == IM_PROCEDURE) + else if (ins.mMemory == IM_PROCEDURE) { ByteCodeInstruction bins(BC_CONST_16); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; - bins.mVIndex = ins.vindex; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; + bins.mVIndex = ins.mVarIndex; bins.mValue = 0; bins.mRelocate = true; bins.mFunction = true; @@ -592,8 +591,8 @@ void ByteCodeBasicBlock::LoadConstant(InterCodeProcedure* proc, const InterInstr else { ByteCodeInstruction bins(BC_CONST_16); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; - bins.mValue = ins.ivalue; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; + bins.mValue = ins.mIntValue; mIns.Push(bins); } @@ -602,145 +601,88 @@ void ByteCodeBasicBlock::LoadConstant(InterCodeProcedure* proc, const InterInstr void ByteCodeBasicBlock::CopyValue(InterCodeProcedure* proc, const InterInstruction& ins) { ByteCodeInstruction sins(BC_ADDR_REG); - sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - sins.mRegisterFinal = ins.sfinal[1]; + sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + sins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(sins); ByteCodeInstruction dins(BC_LOAD_REG_16); - dins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - dins.mRegisterFinal = ins.sfinal[0]; + dins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + dins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(dins); ByteCodeInstruction cins(BC_COPY); - cins.mValue = ins.opsize; + cins.mValue = ins.mOperandSize; mIns.Push(cins); } void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterInstruction& ins) { - if (ins.stype[0] == IT_FLOAT) + if (ins.mSType[0] == IT_FLOAT) { - if (ins.stemp[1] < 0) + if (ins.mSTemp[1] < 0) { - if (ins.stemp[0] < 0) + if (ins.mMemory == IM_GLOBAL) { - FloatConstToAccu(ins.sfconst[0]); + ByteCodeInstruction bins(BC_STORE_ABS_32); + bins.mRelocate = true; + bins.mVIndex = ins.mVarIndex; + bins.mValue = ins.mSIntConst[1]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + mIns.Push(bins); + } + else if (ins.mMemory == IM_ABSOLUTE) + { + ByteCodeInstruction bins(BC_STORE_ABS_32); + bins.mValue = ins.mSIntConst[1]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + mIns.Push(bins); + } + else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM) + { + int index = ins.mSIntConst[1]; + if (ins.mMemory == IM_LOCAL) + index += proc->mLocalVars[ins.mVarIndex].mOffset; + else + index += ins.mVarIndex + proc->mLocalSize + 2; - if (ins.mem == IM_GLOBAL) + if (index <= 252) { - ByteCodeInstruction bins(BC_STORE_ABS_32); - bins.mRelocate = true; - bins.mVIndex = ins.vindex; - bins.mValue = ins.siconst[1]; - bins.mRegister = BC_REG_ACCU; + ByteCodeInstruction bins(BC_STORE_LOCAL_32); + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; + bins.mValue = index; mIns.Push(bins); } - else if (ins.mem == IM_ABSOLUTE) + else { - ByteCodeInstruction bins(BC_STORE_ABS_32); - bins.mValue = ins.siconst[1]; - bins.mRegister = BC_REG_ACCU; - mIns.Push(bins); - } - else if (ins.mem == IM_LOCAL || ins.mem == IM_PARAM) - { - int index = ins.siconst[1]; - if (ins.mem == IM_LOCAL) - index += proc->mLocalVars[ins.vindex].mOffset; - else - index += ins.vindex + proc->mLocalSize + 2; - - if (index <= 252) - { - ByteCodeInstruction bins(BC_STORE_LOCAL_32); - bins.mRegister = BC_REG_ACCU; - bins.mValue = index; - mIns.Push(bins); - } - else - { - ByteCodeInstruction lins(BC_LEA_LOCAL); - lins.mRegister = BC_REG_ADDR; - lins.mValue = index; - mIns.Push(lins); - ByteCodeInstruction bins(BC_STORE_ADDR_32); - bins.mRegister = BC_REG_ACCU; - mIns.Push(bins); - } - } - else if (ins.mem == IM_FRAME) - { - ByteCodeInstruction bins(BC_STORE_FRAME_32); - bins.mRegister = BC_REG_ACCU; - bins.mValue = ins.vindex + ins.siconst[1] + 2; + ByteCodeInstruction lins(BC_LEA_LOCAL); + lins.mRegister = BC_REG_ADDR; + lins.mValue = index; + mIns.Push(lins); + ByteCodeInstruction bins(BC_STORE_ADDR_32); + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); } } - else + else if (ins.mMemory == IM_FRAME) { - if (ins.mem == IM_GLOBAL) - { - ByteCodeInstruction bins(BC_STORE_ABS_32); - bins.mRelocate = true; - bins.mVIndex = ins.vindex; - bins.mValue = ins.siconst[1]; - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - mIns.Push(bins); - } - else if (ins.mem == IM_ABSOLUTE) - { - ByteCodeInstruction bins(BC_STORE_ABS_32); - bins.mValue = ins.siconst[1]; - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - mIns.Push(bins); - } - else if (ins.mem == IM_LOCAL || ins.mem == IM_PARAM) - { - int index = ins.siconst[1]; - if (ins.mem == IM_LOCAL) - index += proc->mLocalVars[ins.vindex].mOffset; - else - index += ins.vindex + proc->mLocalSize + 2; - - if (index <= 252) - { - ByteCodeInstruction bins(BC_STORE_LOCAL_32); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; - bins.mValue = index; - mIns.Push(bins); - } - else - { - ByteCodeInstruction lins(BC_LEA_LOCAL); - lins.mRegister = BC_REG_ADDR; - lins.mValue = index; - mIns.Push(lins); - ByteCodeInstruction bins(BC_STORE_ADDR_32); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; - mIns.Push(bins); - } - } - else if (ins.mem == IM_FRAME) - { - ByteCodeInstruction bins(BC_STORE_FRAME_32); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; - bins.mValue = ins.vindex + ins.siconst[1] + 2; - mIns.Push(bins); - } + ByteCodeInstruction bins(BC_STORE_FRAME_32); + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; + bins.mValue = ins.mVarIndex + ins.mSIntConst[1] + 2; + mIns.Push(bins); } } else { - if (ins.stemp[0] < 0) + if (ins.mSTemp[0] < 0) { - IntConstToAccu(ins.siconst[0]); + IntConstToAccu(ins.mSIntConst[0]); - if (ins.mem == IM_INDIRECT) + if (ins.mMemory == IM_INDIRECT) { ByteCodeInstruction lins(BC_ADDR_REG); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - lins.mRegisterFinal = ins.sfinal[1]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + lins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(lins); ByteCodeInstruction bins(BC_STORE_ADDR_32); bins.mRegister = BC_REG_ACCU; @@ -749,51 +691,51 @@ void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterI } else { - if (ins.mem == IM_INDIRECT) + if (ins.mMemory == IM_INDIRECT) { ByteCodeInstruction lins(BC_ADDR_REG); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - lins.mRegisterFinal = ins.sfinal[1]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + lins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(lins); ByteCodeInstruction bins(BC_STORE_ADDR_32); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); } } } } - else if (ins.stype[0] == IT_POINTER) + else if (ins.mSType[0] == IT_POINTER) { - if (ins.stemp[1] < 0) + if (ins.mSTemp[1] < 0) { - if (ins.stemp[0] < 0) + if (ins.mSTemp[0] < 0) { - IntConstToAccu(ins.siconst[0]); + IntConstToAccu(ins.mSIntConst[0]); - if (ins.mem == IM_GLOBAL) + if (ins.mMemory == IM_GLOBAL) { ByteCodeInstruction bins(BC_STORE_ABS_16); bins.mRelocate = true; - bins.mVIndex = ins.vindex; - bins.mValue = ins.siconst[1]; + bins.mVIndex = ins.mVarIndex; + bins.mValue = ins.mSIntConst[1]; bins.mRegister = BC_REG_ACCU; mIns.Push(bins); } - else if (ins.mem == IM_ABSOLUTE) + else if (ins.mMemory == IM_ABSOLUTE) { ByteCodeInstruction bins(BC_STORE_ABS_16); - bins.mValue = ins.siconst[1]; + bins.mValue = ins.mSIntConst[1]; bins.mRegister = BC_REG_ACCU; mIns.Push(bins); } - else if (ins.mem == IM_LOCAL || ins.mem == IM_PARAM) + else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM) { - int index = ins.siconst[1]; - if (ins.mem == IM_LOCAL) - index += proc->mLocalVars[ins.vindex].mOffset; + int index = ins.mSIntConst[1]; + if (ins.mMemory == IM_LOCAL) + index += proc->mLocalVars[ins.mVarIndex].mOffset; else - index += ins.vindex + proc->mLocalSize + 2; + index += ins.mVarIndex + proc->mLocalSize + 2; if (index <= 254) { @@ -813,46 +755,46 @@ void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterI mIns.Push(bins); } } - else if (ins.mem == IM_FRAME) + else if (ins.mMemory == IM_FRAME) { ByteCodeInstruction bins(BC_STORE_FRAME_16); bins.mRegister = BC_REG_ACCU; - bins.mValue = ins.vindex + ins.siconst[1] + 2; + bins.mValue = ins.mVarIndex + ins.mSIntConst[1] + 2; mIns.Push(bins); } } else { - if (ins.mem == IM_GLOBAL) + if (ins.mMemory == IM_GLOBAL) { ByteCodeInstruction bins(BC_STORE_ABS_16); bins.mRelocate = true; - bins.mVIndex = ins.vindex; - bins.mValue = ins.siconst[1]; - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; + bins.mVIndex = ins.mVarIndex; + bins.mValue = ins.mSIntConst[1]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; mIns.Push(bins); } - else if (ins.mem == IM_ABSOLUTE) + else if (ins.mMemory == IM_ABSOLUTE) { ByteCodeInstruction bins(BC_STORE_ABS_16); - bins.mValue = ins.siconst[1]; - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mValue = ins.mSIntConst[1]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); } - else if (ins.mem == IM_LOCAL || ins.mem == IM_PARAM) + else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM) { - int index = ins.siconst[1]; - if (ins.mem == IM_LOCAL) - index += proc->mLocalVars[ins.vindex].mOffset; + int index = ins.mSIntConst[1]; + if (ins.mMemory == IM_LOCAL) + index += proc->mLocalVars[ins.mVarIndex].mOffset; else - index += ins.vindex + proc->mLocalSize + 2; + index += ins.mVarIndex + proc->mLocalSize + 2; if (index <= 254) { ByteCodeInstruction bins(BC_STORE_LOCAL_16); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; bins.mValue = index; mIns.Push(bins); } @@ -863,32 +805,32 @@ void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterI lins.mValue = index; mIns.Push(lins); ByteCodeInstruction bins(BC_STORE_ADDR_16); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); } } - else if (ins.mem == IM_FRAME) + else if (ins.mMemory == IM_FRAME) { ByteCodeInstruction bins(BC_STORE_FRAME_16); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; - bins.mValue = ins.vindex + ins.siconst[1] + 2; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; + bins.mValue = ins.mVarIndex + ins.mSIntConst[1] + 2; mIns.Push(bins); } } } else { - if (ins.stemp[0] < 0) + if (ins.mSTemp[0] < 0) { - IntConstToAccu(ins.siconst[0]); + IntConstToAccu(ins.mSIntConst[0]); - if (ins.mem == IM_INDIRECT) + if (ins.mMemory == IM_INDIRECT) { ByteCodeInstruction lins(BC_ADDR_REG); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - lins.mRegisterFinal = ins.sfinal[1]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + lins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(lins); ByteCodeInstruction bins(BC_STORE_ADDR_16); bins.mRegister = BC_REG_ACCU; @@ -897,15 +839,15 @@ void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterI } else { - if (ins.mem == IM_INDIRECT) + if (ins.mMemory == IM_INDIRECT) { ByteCodeInstruction lins(BC_ADDR_REG); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - lins.mRegisterFinal = ins.sfinal[1]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + lins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(lins); ByteCodeInstruction bins(BC_STORE_ADDR_16); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); } } @@ -913,37 +855,37 @@ void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterI } else { - if (ins.stemp[1] < 0) + if (ins.mSTemp[1] < 0) { - if (ins.stemp[0] < 0) + if (ins.mSTemp[0] < 0) { - IntConstToAccu(ins.siconst[0]); + IntConstToAccu(ins.mSIntConst[0]); - if (ins.opsize == 1) + if (ins.mOperandSize == 1) { - if (ins.mem == IM_GLOBAL) + if (ins.mMemory == IM_GLOBAL) { ByteCodeInstruction bins(BC_STORE_ABS_8); bins.mRelocate = true; - bins.mVIndex = ins.vindex; - bins.mValue = ins.siconst[1]; + bins.mVIndex = ins.mVarIndex; + bins.mValue = ins.mSIntConst[1]; bins.mRegister = BC_REG_ACCU; mIns.Push(bins); } - else if (ins.mem == IM_ABSOLUTE) + else if (ins.mMemory == IM_ABSOLUTE) { ByteCodeInstruction bins(BC_STORE_ABS_8); - bins.mValue = ins.siconst[1]; + bins.mValue = ins.mSIntConst[1]; bins.mRegister = BC_REG_ACCU; mIns.Push(bins); } - else if (ins.mem == IM_LOCAL || ins.mem == IM_PARAM) + else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM) { - int index = ins.siconst[1]; - if (ins.mem == IM_LOCAL) - index += proc->mLocalVars[ins.vindex].mOffset; + int index = ins.mSIntConst[1]; + if (ins.mMemory == IM_LOCAL) + index += proc->mLocalVars[ins.mVarIndex].mOffset; else - index += ins.vindex + proc->mLocalSize + 2; + index += ins.mVarIndex + proc->mLocalSize + 2; if (index <= 255) { @@ -963,39 +905,39 @@ void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterI mIns.Push(bins); } } - else if (ins.mem == IM_FRAME) + else if (ins.mMemory == IM_FRAME) { ByteCodeInstruction bins(BC_STORE_FRAME_8); bins.mRegister = BC_REG_ACCU; - bins.mValue = ins.vindex + ins.siconst[1] + 2; + bins.mValue = ins.mVarIndex + ins.mSIntConst[1] + 2; mIns.Push(bins); } } - else if (ins.opsize == 2) + else if (ins.mOperandSize == 2) { - if (ins.mem == IM_GLOBAL) + if (ins.mMemory == IM_GLOBAL) { ByteCodeInstruction bins(BC_STORE_ABS_16); bins.mRelocate = true; - bins.mVIndex = ins.vindex; - bins.mValue = ins.siconst[1]; + bins.mVIndex = ins.mVarIndex; + bins.mValue = ins.mSIntConst[1]; bins.mRegister = BC_REG_ACCU; mIns.Push(bins); } - else if (ins.mem == IM_ABSOLUTE) + else if (ins.mMemory == IM_ABSOLUTE) { ByteCodeInstruction bins(BC_STORE_ABS_16); - bins.mValue = ins.siconst[1]; + bins.mValue = ins.mSIntConst[1]; bins.mRegister = BC_REG_ACCU; mIns.Push(bins); } - else if (ins.mem == IM_LOCAL || ins.mem == IM_PARAM) + else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM) { - int index = ins.siconst[1]; - if (ins.mem == IM_LOCAL) - index += proc->mLocalVars[ins.vindex].mOffset; + int index = ins.mSIntConst[1]; + if (ins.mMemory == IM_LOCAL) + index += proc->mLocalVars[ins.mVarIndex].mOffset; else - index += ins.vindex + proc->mLocalSize + 2; + index += ins.mVarIndex + proc->mLocalSize + 2; if (index <= 254) { @@ -1015,50 +957,50 @@ void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterI mIns.Push(bins); } } - else if (ins.mem == IM_FRAME) + else if (ins.mMemory == IM_FRAME) { ByteCodeInstruction bins(BC_STORE_FRAME_16); bins.mRegister = BC_REG_ACCU; - bins.mValue = ins.vindex + ins.siconst[1] + 2; + bins.mValue = ins.mVarIndex + ins.mSIntConst[1] + 2; mIns.Push(bins); } } } else { - if (ins.opsize == 1) + if (ins.mOperandSize == 1) { - if (ins.mem == IM_GLOBAL) + if (ins.mMemory == IM_GLOBAL) { ByteCodeInstruction bins(BC_STORE_ABS_8); bins.mRelocate = true; - bins.mVIndex = ins.vindex; - bins.mValue = ins.siconst[1]; - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mVIndex = ins.mVarIndex; + bins.mValue = ins.mSIntConst[1]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); } - else if (ins.mem == IM_ABSOLUTE) + else if (ins.mMemory == IM_ABSOLUTE) { ByteCodeInstruction bins(BC_STORE_ABS_8); - bins.mValue = ins.siconst[1]; - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mValue = ins.mSIntConst[1]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); } - else if (ins.mem == IM_LOCAL || ins.mem == IM_PARAM) + else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM) { - int index = ins.siconst[1]; - if (ins.mem == IM_LOCAL) - index += proc->mLocalVars[ins.vindex].mOffset; + int index = ins.mSIntConst[1]; + if (ins.mMemory == IM_LOCAL) + index += proc->mLocalVars[ins.mVarIndex].mOffset; else - index += ins.vindex + proc->mLocalSize + 2; + index += ins.mVarIndex + proc->mLocalSize + 2; if (index <= 255) { ByteCodeInstruction bins(BC_STORE_LOCAL_8); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; bins.mValue = index; mIns.Push(bins); } @@ -1069,53 +1011,53 @@ void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterI lins.mValue = index; mIns.Push(lins); ByteCodeInstruction bins(BC_STORE_ADDR_8); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); } } - else if (ins.mem == IM_FRAME) + else if (ins.mMemory == IM_FRAME) { ByteCodeInstruction bins(BC_STORE_FRAME_8); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; - bins.mValue = ins.vindex + ins.siconst[1] + 2; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; + bins.mValue = ins.mVarIndex + ins.mSIntConst[1] + 2; mIns.Push(bins); } } - else if (ins.opsize == 2) + else if (ins.mOperandSize == 2) { - if (ins.mem == IM_GLOBAL) + if (ins.mMemory == IM_GLOBAL) { ByteCodeInstruction bins(BC_STORE_ABS_16); bins.mRelocate = true; - bins.mVIndex = ins.vindex; - bins.mValue = ins.siconst[1]; - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mVIndex = ins.mVarIndex; + bins.mValue = ins.mSIntConst[1]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); } - else if (ins.mem == IM_ABSOLUTE) + else if (ins.mMemory == IM_ABSOLUTE) { ByteCodeInstruction bins(BC_STORE_ABS_16); - bins.mValue = ins.siconst[1]; - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mValue = ins.mSIntConst[1]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); } - else if (ins.mem == IM_LOCAL || ins.mem == IM_PARAM) + else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM) { - int index = ins.siconst[1]; - if (ins.mem == IM_LOCAL) - index += proc->mLocalVars[ins.vindex].mOffset; + int index = ins.mSIntConst[1]; + if (ins.mMemory == IM_LOCAL) + index += proc->mLocalVars[ins.mVarIndex].mOffset; else - index += ins.vindex + proc->mLocalSize + 2; + index += ins.mVarIndex + proc->mLocalSize + 2; if (index <= 254) { ByteCodeInstruction bins(BC_STORE_LOCAL_16); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; bins.mValue = index; mIns.Push(bins); } @@ -1126,17 +1068,17 @@ void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterI lins.mValue = index; mIns.Push(lins); ByteCodeInstruction bins(BC_STORE_ADDR_16); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); } } - else if (ins.mem == IM_FRAME) + else if (ins.mMemory == IM_FRAME) { ByteCodeInstruction bins(BC_STORE_FRAME_16); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; - bins.mValue = ins.vindex + ins.siconst[1] + 2; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; + bins.mValue = ins.mVarIndex + ins.mSIntConst[1] + 2; mIns.Push(bins); } } @@ -1144,23 +1086,23 @@ void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterI } else { - if (ins.stemp[0] < 0) + if (ins.mSTemp[0] < 0) { - IntConstToAccu(ins.siconst[0]); + IntConstToAccu(ins.mSIntConst[0]); - if (ins.mem == IM_INDIRECT) + if (ins.mMemory == IM_INDIRECT) { ByteCodeInstruction lins(BC_ADDR_REG); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - lins.mRegisterFinal = ins.sfinal[1]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + lins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(lins); - if (ins.opsize == 1) + if (ins.mOperandSize == 1) { ByteCodeInstruction bins(BC_STORE_ADDR_8); bins.mRegister = BC_REG_ACCU; mIns.Push(bins); } - else if (ins.opsize == 2) + else if (ins.mOperandSize == 2) { ByteCodeInstruction bins(BC_STORE_ADDR_16); bins.mRegister = BC_REG_ACCU; @@ -1170,24 +1112,24 @@ void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterI } else { - if (ins.mem == IM_INDIRECT) + if (ins.mMemory == IM_INDIRECT) { ByteCodeInstruction lins(BC_ADDR_REG); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - lins.mRegisterFinal = ins.sfinal[1]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + lins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(lins); - if (ins.opsize == 1) + if (ins.mOperandSize == 1) { ByteCodeInstruction bins(BC_STORE_ADDR_8); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); } - else if (ins.opsize == 2) + else if (ins.mOperandSize == 2) { ByteCodeInstruction bins(BC_STORE_ADDR_16); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); } } @@ -1198,38 +1140,38 @@ void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterI void ByteCodeBasicBlock::LoadDirectValue(InterCodeProcedure* proc, const InterInstruction& ins) { - if (ins.ttype == IT_FLOAT) + if (ins.mTType == IT_FLOAT) { - if (ins.stemp[0] < 0) + if (ins.mSTemp[0] < 0) { - if (ins.mem == IM_GLOBAL) + if (ins.mMemory == IM_GLOBAL) { ByteCodeInstruction bins(BC_LOAD_ABS_32); bins.mRelocate = true; - bins.mVIndex = ins.vindex; - bins.mValue = ins.siconst[0]; - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + bins.mVIndex = ins.mVarIndex; + bins.mValue = ins.mSIntConst[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(bins); } - else if (ins.mem == IM_ABSOLUTE) + else if (ins.mMemory == IM_ABSOLUTE) { ByteCodeInstruction bins(BC_LOAD_ABS_32); - bins.mValue = ins.siconst[0]; - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + bins.mValue = ins.mSIntConst[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(bins); } - else if (ins.mem == IM_LOCAL || ins.mem == IM_PARAM) + else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM) { - int index = ins.siconst[0]; - if (ins.mem == IM_LOCAL) - index += proc->mLocalVars[ins.vindex].mOffset; + int index = ins.mSIntConst[0]; + if (ins.mMemory == IM_LOCAL) + index += proc->mLocalVars[ins.mVarIndex].mOffset; else - index += ins.vindex + proc->mLocalSize + 2; + index += ins.mVarIndex + proc->mLocalSize + 2; if (index <= 254) { ByteCodeInstruction bins(BC_LOAD_LOCAL_32); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; bins.mValue = index; mIns.Push(bins); } @@ -1240,57 +1182,57 @@ void ByteCodeBasicBlock::LoadDirectValue(InterCodeProcedure* proc, const InterIn lins.mValue = index; mIns.Push(lins); ByteCodeInstruction bins(BC_LOAD_ADDR_32); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(bins); } } } else { - if (ins.mem == IM_INDIRECT) + if (ins.mMemory == IM_INDIRECT) { ByteCodeInstruction lins(BC_ADDR_REG); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - lins.mRegisterFinal = ins.sfinal[0]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + lins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(lins); ByteCodeInstruction bins(BC_LOAD_ADDR_32); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(bins); } } } - else if (ins.ttype == IT_POINTER) + else if (ins.mTType == IT_POINTER) { - if (ins.stemp[0] < 0) + if (ins.mSTemp[0] < 0) { - if (ins.mem == IM_GLOBAL) + if (ins.mMemory == IM_GLOBAL) { ByteCodeInstruction bins(BC_LOAD_ABS_16); bins.mRelocate = true; - bins.mVIndex = ins.vindex; - bins.mValue = ins.siconst[0]; - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + bins.mVIndex = ins.mVarIndex; + bins.mValue = ins.mSIntConst[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(bins); } - else if (ins.mem == IM_ABSOLUTE) + else if (ins.mMemory == IM_ABSOLUTE) { ByteCodeInstruction bins(BC_LOAD_ABS_16); - bins.mValue = ins.siconst[0]; - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + bins.mValue = ins.mSIntConst[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(bins); } - else if (ins.mem == IM_LOCAL || ins.mem == IM_PARAM) + else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM) { - int index = ins.siconst[0]; - if (ins.mem == IM_LOCAL) - index += proc->mLocalVars[ins.vindex].mOffset; + int index = ins.mSIntConst[0]; + if (ins.mMemory == IM_LOCAL) + index += proc->mLocalVars[ins.mVarIndex].mOffset; else - index += ins.vindex + proc->mLocalSize + 2; + index += ins.mVarIndex + proc->mLocalSize + 2; if (index <= 254) { ByteCodeInstruction bins(BC_LOAD_LOCAL_16); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; bins.mValue = index; mIns.Push(bins); } @@ -1301,59 +1243,59 @@ void ByteCodeBasicBlock::LoadDirectValue(InterCodeProcedure* proc, const InterIn lins.mValue = index; mIns.Push(lins); ByteCodeInstruction bins(BC_LOAD_ADDR_16); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(bins); } } } else { - if (ins.mem == IM_INDIRECT) + if (ins.mMemory == IM_INDIRECT) { ByteCodeInstruction lins(BC_ADDR_REG); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - lins.mRegisterFinal = ins.sfinal[0]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + lins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(lins); ByteCodeInstruction bins(BC_LOAD_ADDR_16); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(bins); } } } else { - if (ins.stemp[0] < 0) + if (ins.mSTemp[0] < 0) { - if (ins.opsize == 1) + if (ins.mOperandSize == 1) { - if (ins.mem == IM_GLOBAL) + if (ins.mMemory == IM_GLOBAL) { - ByteCodeInstruction bins(ins.ttype == IT_SIGNED ? BC_LOAD_ABS_I8 : BC_LOAD_ABS_U8); + ByteCodeInstruction bins(ins.mTType == IT_SIGNED ? BC_LOAD_ABS_I8 : BC_LOAD_ABS_U8); bins.mRelocate = true; - bins.mVIndex = ins.vindex; - bins.mValue = ins.siconst[0]; - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + bins.mVIndex = ins.mVarIndex; + bins.mValue = ins.mSIntConst[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(bins); } - else if (ins.mem == IM_ABSOLUTE) + else if (ins.mMemory == IM_ABSOLUTE) { - ByteCodeInstruction bins(ins.ttype == IT_SIGNED ? BC_LOAD_ABS_I8 : BC_LOAD_ABS_U8); - bins.mValue = ins.siconst[0]; - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + ByteCodeInstruction bins(ins.mTType == IT_SIGNED ? BC_LOAD_ABS_I8 : BC_LOAD_ABS_U8); + bins.mValue = ins.mSIntConst[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(bins); } - else if (ins.mem == IM_LOCAL || ins.mem == IM_PARAM) + else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM) { - int index = ins.siconst[0]; - if (ins.mem == IM_LOCAL) - index += proc->mLocalVars[ins.vindex].mOffset; + int index = ins.mSIntConst[0]; + if (ins.mMemory == IM_LOCAL) + index += proc->mLocalVars[ins.mVarIndex].mOffset; else - index += ins.vindex + proc->mLocalSize + 2; + index += ins.mVarIndex + proc->mLocalSize + 2; if (index <= 255) { - ByteCodeInstruction bins(ins.ttype == IT_SIGNED ? BC_LOAD_LOCAL_I8 : BC_LOAD_LOCAL_U8); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + ByteCodeInstruction bins(ins.mTType == IT_SIGNED ? BC_LOAD_LOCAL_I8 : BC_LOAD_LOCAL_U8); + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; bins.mValue = index; mIns.Push(bins); } @@ -1363,42 +1305,42 @@ void ByteCodeBasicBlock::LoadDirectValue(InterCodeProcedure* proc, const InterIn lins.mRegister = BC_REG_ADDR; lins.mValue = index; mIns.Push(lins); - ByteCodeInstruction bins(ins.ttype == IT_SIGNED ? BC_LOAD_ADDR_I8 : BC_LOAD_ADDR_U8); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + ByteCodeInstruction bins(ins.mTType == IT_SIGNED ? BC_LOAD_ADDR_I8 : BC_LOAD_ADDR_U8); + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(bins); } } } - else if (ins.opsize == 2) + else if (ins.mOperandSize == 2) { - if (ins.mem == IM_GLOBAL) + if (ins.mMemory == IM_GLOBAL) { ByteCodeInstruction bins(BC_LOAD_ABS_16); bins.mRelocate = true; - bins.mVIndex = ins.vindex; - bins.mValue = ins.siconst[0]; - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + bins.mVIndex = ins.mVarIndex; + bins.mValue = ins.mSIntConst[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(bins); } - else if (ins.mem == IM_ABSOLUTE) + else if (ins.mMemory == IM_ABSOLUTE) { ByteCodeInstruction bins(BC_LOAD_ABS_16); - bins.mValue = ins.siconst[0]; - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + bins.mValue = ins.mSIntConst[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(bins); } - else if (ins.mem == IM_LOCAL || ins.mem == IM_PARAM) + else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM) { - int index = ins.siconst[0]; - if (ins.mem == IM_LOCAL) - index += proc->mLocalVars[ins.vindex].mOffset; + int index = ins.mSIntConst[0]; + if (ins.mMemory == IM_LOCAL) + index += proc->mLocalVars[ins.mVarIndex].mOffset; else - index += ins.vindex + proc->mLocalSize + 2; + index += ins.mVarIndex + proc->mLocalSize + 2; if (index <= 254) { ByteCodeInstruction bins(BC_LOAD_LOCAL_16); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; bins.mValue = index; mIns.Push(bins); } @@ -1409,7 +1351,7 @@ void ByteCodeBasicBlock::LoadDirectValue(InterCodeProcedure* proc, const InterIn lins.mValue = index; mIns.Push(lins); ByteCodeInstruction bins(BC_LOAD_ADDR_16); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(bins); } } @@ -1417,32 +1359,32 @@ void ByteCodeBasicBlock::LoadDirectValue(InterCodeProcedure* proc, const InterIn } else { - if (ins.mem == IM_INDIRECT) + if (ins.mMemory == IM_INDIRECT) { ByteCodeInstruction lins(BC_ADDR_REG); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - lins.mRegisterFinal = ins.sfinal[0]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + lins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(lins); - if (ins.opsize == 1) + if (ins.mOperandSize == 1) { - if (ins.ttype == IT_SIGNED) + if (ins.mTType == IT_SIGNED) { ByteCodeInstruction bins(BC_LOAD_ADDR_I8); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(bins); } else { ByteCodeInstruction bins(BC_LOAD_ADDR_U8); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(bins); } } - else if (ins.opsize == 2) + else if (ins.mOperandSize == 2) { ByteCodeInstruction bins(BC_LOAD_ADDR_16); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(bins); } } @@ -1452,54 +1394,54 @@ void ByteCodeBasicBlock::LoadDirectValue(InterCodeProcedure* proc, const InterIn void ByteCodeBasicBlock::LoadEffectiveAddress(InterCodeProcedure* proc, const InterInstruction& ins) { - if (ins.stemp[0] < 0) + if (ins.mSTemp[0] < 0) { - if (ins.stemp[1] == ins.ttemp) + if (ins.mSTemp[1] == ins.mTTemp) { ByteCodeInstruction bins(BC_BINOP_ADDI_16); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; - bins.mValue = ins.siconst[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; + bins.mValue = ins.mSIntConst[0]; mIns.Push(bins); } else { ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - lins.mRegisterFinal = ins.sfinal[1]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + lins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(lins); ByteCodeInstruction ains(BC_BINOP_ADDI_16); ains.mRegister = BC_REG_ACCU; - ains.mValue = ins.siconst[0]; + ains.mValue = ins.mSIntConst[0]; mIns.Push(ains); ByteCodeInstruction sins(BC_STORE_REG_16); - sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(sins); } } else { ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - lins.mRegisterFinal = ins.sfinal[1]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + lins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(lins); ByteCodeInstruction ains(BC_BINOP_ADDR_16); - ains.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - ains.mRegisterFinal = ins.sfinal[0]; + ains.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + ains.mRegisterFinal = ins.mSFinal[0]; mIns.Push(ains); ByteCodeInstruction sins(BC_STORE_REG_16); - sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(sins); } } void ByteCodeBasicBlock::CallFunction(InterCodeProcedure* proc, const InterInstruction& ins) { - if (ins.stemp[0] < 0) + if (ins.mSTemp[0] < 0) { ByteCodeInstruction bins(BC_LEA_ABS); bins.mRelocate = true; bins.mFunction = true; - bins.mVIndex = ins.vindex; + bins.mVIndex = ins.mVarIndex; bins.mValue = 0; bins.mRegister = BC_REG_ADDR; mIns.Push(bins); @@ -1507,26 +1449,26 @@ void ByteCodeBasicBlock::CallFunction(InterCodeProcedure* proc, const InterInstr else { ByteCodeInstruction bins(BC_ADDR_REG); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); } ByteCodeInstruction cins(BC_CALL); mIns.Push(cins); - if (ins.ttemp >= 0) + if (ins.mTTemp >= 0) { - if (ins.ttype == IT_FLOAT) + if (ins.mTType == IT_FLOAT) { ByteCodeInstruction bins(BC_STORE_REG_32); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(bins); } else { ByteCodeInstruction bins(BC_STORE_REG_16); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(bins); } } @@ -1534,11 +1476,11 @@ void ByteCodeBasicBlock::CallFunction(InterCodeProcedure* proc, const InterInstr void ByteCodeBasicBlock::CallAssembler(InterCodeProcedure* proc, const InterInstruction& ins) { - if (ins.stemp[0] < 0) + if (ins.mSTemp[0] < 0) { ByteCodeInstruction bins(BC_JSR); bins.mRelocate = true; - bins.mVIndex = ins.vindex; + bins.mVIndex = ins.mVarIndex; mIns.Push(bins); } } @@ -1548,7 +1490,7 @@ ByteCode ByteCodeBasicBlock::RelationalOperator(InterCodeProcedure* proc, const ByteCode code; bool csigned = false; - switch (ins.oper) + switch (ins.mOperator) { default: case IA_CMPEQ: @@ -1588,54 +1530,54 @@ ByteCode ByteCodeBasicBlock::RelationalOperator(InterCodeProcedure* proc, const break; } - if (ins.stype[0] == IT_FLOAT) + if (ins.mSType[0] == IT_FLOAT) { ByteCodeInstruction lins(BC_LOAD_REG_32); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - lins.mRegisterFinal = ins.sfinal[0]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + lins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(lins); ByteCodeInstruction cins(BC_BINOP_CMP_F32); - cins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - cins.mRegisterFinal = ins.sfinal[1]; + cins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + cins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(cins); } else { - if (ins.stemp[1] < 0) + if (ins.mSTemp[1] < 0) { ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - lins.mRegisterFinal = ins.sfinal[0]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + lins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(lins); if (csigned) { ByteCodeInstruction cins(BC_BINOP_CMPSI_16); - cins.mValue = ins.siconst[1]; + cins.mValue = ins.mSIntConst[1]; mIns.Push(cins); } else { ByteCodeInstruction cins(BC_BINOP_CMPUI_16); - cins.mValue = ins.siconst[1]; + cins.mValue = ins.mSIntConst[1]; mIns.Push(cins); } } - else if (ins.stemp[0] < 0) + else if (ins.mSTemp[0] < 0) { ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - lins.mRegisterFinal = ins.sfinal[1]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + lins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(lins); if (csigned) { ByteCodeInstruction cins(BC_BINOP_CMPSI_16); - cins.mValue = ins.siconst[0]; + cins.mValue = ins.mSIntConst[0]; mIns.Push(cins); } else { ByteCodeInstruction cins(BC_BINOP_CMPUI_16); - cins.mValue = ins.siconst[0]; + cins.mValue = ins.mSIntConst[0]; mIns.Push(cins); } code = TransposeBranchCondition(code); @@ -1643,21 +1585,21 @@ ByteCode ByteCodeBasicBlock::RelationalOperator(InterCodeProcedure* proc, const else { ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - lins.mRegisterFinal = ins.sfinal[0]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + lins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(lins); if (csigned) { ByteCodeInstruction cins(BC_BINOP_CMPSR_16); - cins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - cins.mRegisterFinal = ins.sfinal[1]; + cins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + cins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(cins); } else { ByteCodeInstruction cins(BC_BINOP_CMPUR_16); - cins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - cins.mRegisterFinal = ins.sfinal[1]; + cins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + cins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(cins); } } @@ -1668,9 +1610,9 @@ ByteCode ByteCodeBasicBlock::RelationalOperator(InterCodeProcedure* proc, const static ByteCode ByteCodeBinRegOperator(const InterInstruction& ins) { - if (ins.ttype == IT_FLOAT) + if (ins.mTType == IT_FLOAT) { - switch (ins.oper) + switch (ins.mOperator) { case IA_ADD: return BC_BINOP_ADD_F32; case IA_SUB: return BC_BINOP_SUB_F32; @@ -1684,7 +1626,7 @@ static ByteCode ByteCodeBinRegOperator(const InterInstruction& ins) } else { - switch (ins.oper) + switch (ins.mOperator) { case IA_ADD: return BC_BINOP_ADDR_16; case IA_SUB: return BC_BINOP_SUBR_16; @@ -1709,7 +1651,7 @@ static ByteCode ByteCodeBinRegOperator(const InterInstruction& ins) static ByteCode ByteCodeBinImmOperator(const InterInstruction& ins) { - switch (ins.oper) + switch (ins.mOperator) { case IA_ADD: return BC_BINOP_ADDI_16; case IA_SUB: return BC_BINOP_SUBI_16; @@ -1727,35 +1669,35 @@ static ByteCode ByteCodeBinImmOperator(const InterInstruction& ins) void ByteCodeBasicBlock::NumericConversion(InterCodeProcedure* proc, const InterInstruction& ins) { - switch (ins.oper) + switch (ins.mOperator) { case IA_FLOAT2INT: { ByteCodeInstruction lins(BC_LOAD_REG_32); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - lins.mRegisterFinal = ins.sfinal[0]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + lins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(lins); - ByteCodeInstruction bins(ins.ttype == IT_SIGNED ? BC_CONV_F32_I16 : BC_CONV_F32_U16); + ByteCodeInstruction bins(ins.mTType == IT_SIGNED ? BC_CONV_F32_I16 : BC_CONV_F32_U16); mIns.Push(bins); ByteCodeInstruction sins(BC_STORE_REG_16); - sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(sins); } break; case IA_INT2FLOAT: { ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - lins.mRegisterFinal = ins.sfinal[0]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + lins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(lins); - ByteCodeInstruction bins(ins.stype[0] == IT_SIGNED ? BC_CONV_I16_F32 : BC_CONV_U16_F32); + ByteCodeInstruction bins(ins.mSType[0] == IT_SIGNED ? BC_CONV_I16_F32 : BC_CONV_U16_F32); mIns.Push(bins); ByteCodeInstruction sins(BC_STORE_REG_32); - sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(sins); } break; @@ -1764,14 +1706,14 @@ void ByteCodeBasicBlock::NumericConversion(InterCodeProcedure* proc, const Inter void ByteCodeBasicBlock::UnaryOperator(InterCodeProcedure* proc, const InterInstruction& ins) { - if (ins.ttype == IT_FLOAT) + if (ins.mTType == IT_FLOAT) { ByteCodeInstruction lins(BC_LOAD_REG_32); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - lins.mRegisterFinal = ins.sfinal[0]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + lins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(lins); - switch (ins.oper) + switch (ins.mOperator) { case IA_NEG: { @@ -1796,17 +1738,17 @@ void ByteCodeBasicBlock::UnaryOperator(InterCodeProcedure* proc, const InterInst } ByteCodeInstruction sins(BC_STORE_REG_32); - sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(sins); } else { ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - lins.mRegisterFinal = ins.sfinal[0]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + lins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(lins); - switch (ins.oper) + switch (ins.mOperator) { case IA_NEG: { @@ -1822,37 +1764,37 @@ void ByteCodeBasicBlock::UnaryOperator(InterCodeProcedure* proc, const InterInst } ByteCodeInstruction sins(BC_STORE_REG_16); - sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(sins); } } void ByteCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterInstruction& ins) { - if (ins.ttype == IT_FLOAT) + if (ins.mTType == IT_FLOAT) { ByteCode bc = ByteCodeBinRegOperator(ins); ByteCodeInstruction lins(BC_LOAD_REG_32); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - lins.mRegisterFinal = ins.sfinal[1]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + lins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(lins); ByteCodeInstruction bins(bc); - if (ins.stemp[1] == ins.stemp[0]) + if (ins.mSTemp[1] == ins.mSTemp[0]) bins.mRegister = BC_REG_ACCU; else - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); ByteCodeInstruction sins(BC_STORE_REG_32); - sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(sins); } else { - switch (ins.oper) + switch (ins.mOperator) { case IA_ADD: case IA_OR: @@ -1861,113 +1803,113 @@ void ByteCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterIns ByteCode bc = ByteCodeBinRegOperator(ins); ByteCode bci = ByteCodeBinImmOperator(ins); - if (ins.stemp[1] < 0) + if (ins.mSTemp[1] < 0) { - if (ins.stemp[0] == ins.ttemp) + if (ins.mSTemp[0] == ins.mTTemp) { ByteCodeInstruction bins(bci); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; - bins.mValue = ins.siconst[1]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; + bins.mValue = ins.mSIntConst[1]; mIns.Push(bins); return; } ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - lins.mRegisterFinal = ins.sfinal[0]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + lins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(lins); ByteCodeInstruction bins(bci); bins.mRegister = BC_REG_ACCU; - bins.mValue = ins.siconst[1]; + bins.mValue = ins.mSIntConst[1]; mIns.Push(bins); } - else if (ins.stemp[0] < 0) + else if (ins.mSTemp[0] < 0) { - if (ins.stemp[1] == ins.ttemp) + if (ins.mSTemp[1] == ins.mTTemp) { ByteCodeInstruction bins(bci); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; - bins.mValue = ins.siconst[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; + bins.mValue = ins.mSIntConst[0]; mIns.Push(bins); return; } ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - lins.mRegisterFinal = ins.sfinal[1]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + lins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(lins); ByteCodeInstruction bins(bci); bins.mRegister = BC_REG_ACCU; - bins.mValue = ins.siconst[0]; + bins.mValue = ins.mSIntConst[0]; mIns.Push(bins); } else { ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - lins.mRegisterFinal = ins.sfinal[1]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + lins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(lins); ByteCodeInstruction bins(bc); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); } } break; case IA_SUB: - if (ins.stemp[1] < 0) + if (ins.mSTemp[1] < 0) { - if (ins.stemp[0] == ins.ttemp) + if (ins.mSTemp[0] == ins.mTTemp) { ByteCodeInstruction bins(BC_BINOP_SUBI_16); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; - bins.mValue = ins.siconst[1]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; + bins.mValue = ins.mSIntConst[1]; mIns.Push(bins); return; } ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - lins.mRegisterFinal = ins.sfinal[0]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + lins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(lins); ByteCodeInstruction bins(BC_BINOP_SUBI_16); bins.mRegister = BC_REG_ACCU; - bins.mValue = ins.siconst[1]; + bins.mValue = ins.mSIntConst[1]; mIns.Push(bins); } - else if (ins.stemp[0] < 0) + else if (ins.mSTemp[0] < 0) { - if (ins.stemp[1] == ins.ttemp) + if (ins.mSTemp[1] == ins.mTTemp) { ByteCodeInstruction bins(BC_BINOP_ADDI_16); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; - bins.mValue = - ins.siconst[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; + bins.mValue = - ins.mSIntConst[0]; mIns.Push(bins); return; } ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - lins.mRegisterFinal = ins.sfinal[1]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + lins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(lins); ByteCodeInstruction bins(BC_BINOP_ADDI_16); bins.mRegister = BC_REG_ACCU; - bins.mValue = - ins.siconst[0]; + bins.mValue = - ins.mSIntConst[0]; mIns.Push(bins); } else { ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - lins.mRegisterFinal = ins.sfinal[1]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + lins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(lins); ByteCodeInstruction bins(BC_BINOP_SUBR_16); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); } break; @@ -1975,114 +1917,114 @@ void ByteCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterIns { ByteCode bc = ByteCodeBinRegOperator(ins); ByteCode bci = ByteCodeBinImmOperator(ins); - if (ins.stemp[1] < 0) + if (ins.mSTemp[1] < 0) { - if (ins.siconst[1] >= 0 && ins.siconst[1] <= 255) + if (ins.mSIntConst[1] >= 0 && ins.mSIntConst[1] <= 255) { - if (ins.stemp[0] == ins.ttemp) + if (ins.mSTemp[0] == ins.mTTemp) { ByteCodeInstruction bins(bci); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; - bins.mValue = ins.siconst[1]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; + bins.mValue = ins.mSIntConst[1]; mIns.Push(bins); return; } ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - lins.mRegisterFinal = ins.sfinal[0]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + lins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(lins); ByteCodeInstruction bins(bci); bins.mRegister = BC_REG_ACCU; - bins.mValue = ins.siconst[1]; + bins.mValue = ins.mSIntConst[1]; mIns.Push(bins); } else { - IntConstToAccu(ins.siconst[1]); + IntConstToAccu(ins.mSIntConst[1]); ByteCodeInstruction bins(bc); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); } } - else if (ins.stemp[0] < 0) + else if (ins.mSTemp[0] < 0) { - if (ins.siconst[0] >= 0 && ins.siconst[0] <= 255) + if (ins.mSIntConst[0] >= 0 && ins.mSIntConst[0] <= 255) { - if (ins.stemp[1] == ins.ttemp) + if (ins.mSTemp[1] == ins.mTTemp) { ByteCodeInstruction bins(bci); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - bins.mRegisterFinal = ins.sfinal[1]; - bins.mValue = ins.siconst[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + bins.mRegisterFinal = ins.mSFinal[1]; + bins.mValue = ins.mSIntConst[0]; mIns.Push(bins); return; } ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - lins.mRegisterFinal = ins.sfinal[1]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + lins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(lins); ByteCodeInstruction bins(bci); bins.mRegister = BC_REG_ACCU; - bins.mValue = ins.siconst[0]; + bins.mValue = ins.mSIntConst[0]; mIns.Push(bins); } else { - IntConstToAccu(ins.siconst[0]); + IntConstToAccu(ins.mSIntConst[0]); ByteCodeInstruction bins(bc); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - bins.mRegisterFinal = ins.sfinal[1]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + bins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(bins); } } else { ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - lins.mRegisterFinal = ins.sfinal[1]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + lins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(lins); ByteCodeInstruction bins(bc); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); } } break; case IA_XOR: { ByteCode bc = ByteCodeBinRegOperator(ins); - if (ins.stemp[1] < 0) + if (ins.mSTemp[1] < 0) { - IntConstToAccu(ins.siconst[1]); + IntConstToAccu(ins.mSIntConst[1]); ByteCodeInstruction bins(bc); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); } - else if (ins.stemp[0] < 0) + else if (ins.mSTemp[0] < 0) { - IntConstToAccu(ins.siconst[0]); + IntConstToAccu(ins.mSIntConst[0]); ByteCodeInstruction bins(bc); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - bins.mRegisterFinal = ins.sfinal[1]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + bins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(bins); } else { ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - lins.mRegisterFinal = ins.sfinal[1]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + lins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(lins); ByteCodeInstruction bins(bc); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); } } break; @@ -2092,22 +2034,22 @@ void ByteCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterIns case IA_MODU: { ByteCode bc = ByteCodeBinRegOperator(ins); - if (ins.stemp[1] < 0) + if (ins.mSTemp[1] < 0) { - IntConstToAccu(ins.siconst[1]); + IntConstToAccu(ins.mSIntConst[1]); ByteCodeInstruction bins(bc); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); } - else if (ins.stemp[0] < 0) + else if (ins.mSTemp[0] < 0) { ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - lins.mRegisterFinal = ins.sfinal[1]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + lins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(lins); - IntConstToAddr(ins.siconst[0]); + IntConstToAddr(ins.mSIntConst[0]); ByteCodeInstruction bins(bc); bins.mRegister = BC_REG_ADDR; @@ -2116,13 +2058,13 @@ void ByteCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterIns else { ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - lins.mRegisterFinal = ins.sfinal[1]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + lins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(lins); ByteCodeInstruction bins(bc); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); } } break; @@ -2134,36 +2076,36 @@ void ByteCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterIns ByteCode rbc = ByteCodeBinRegOperator(ins); ByteCode ibc = ByteCodeBinImmOperator(ins); - if (ins.stemp[1] < 0) + if (ins.mSTemp[1] < 0) { - IntConstToAccu(ins.siconst[1]); + IntConstToAccu(ins.mSIntConst[1]); ByteCodeInstruction bins(rbc); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); } - else if (ins.stemp[0] < 0) + else if (ins.mSTemp[0] < 0) { ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - lins.mRegisterFinal = ins.sfinal[1]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + lins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(lins); ByteCodeInstruction bins(ibc); - bins.mValue = ins.siconst[0]; + bins.mValue = ins.mSIntConst[0]; mIns.Push(bins); } else { ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[1]]; - lins.mRegisterFinal = ins.sfinal[1]; + lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]; + lins.mRegisterFinal = ins.mSFinal[1]; mIns.Push(lins); ByteCodeInstruction bins(rbc); - bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.stemp[0]]; - bins.mRegisterFinal = ins.sfinal[0]; + bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]; + bins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(bins); } @@ -2171,21 +2113,21 @@ void ByteCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterIns } ByteCodeInstruction sins(BC_STORE_REG_16); - sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.ttemp]; + sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp]; mIns.Push(sins); } } void ByteCodeBasicBlock::Compile(InterCodeProcedure* iproc, ByteCodeProcedure* proc, InterCodeBasicBlock* sblock) { - num = sblock->num; + mIndex = sblock->mIndex; int i = 0; - while (i < sblock->code.Size()) + while (i < sblock->mInstructions.Size()) { - const InterInstruction & ins = sblock->code[i]; + const InterInstruction & ins = sblock->mInstructions[i]; - switch (ins.code) + switch (ins.mCode) { case IC_STORE: StoreDirectValue(iproc, ins); @@ -2198,14 +2140,14 @@ void ByteCodeBasicBlock::Compile(InterCodeProcedure* iproc, ByteCodeProcedure* p break; case IC_LOAD_TEMPORARY: { - if (ins.stemp[0] != ins.ttemp) + if (ins.mSTemp[0] != ins.mTTemp) { ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.stemp[0]]; - lins.mRegisterFinal = ins.sfinal[0]; + lins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.mSTemp[0]]; + lins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(lins); ByteCodeInstruction sins(BC_STORE_REG_16); - sins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.ttemp]; + sins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.mTTemp]; mIns.Push(sins); } } break; @@ -2233,23 +2175,23 @@ void ByteCodeBasicBlock::Compile(InterCodeProcedure* iproc, ByteCodeProcedure* p case IC_PUSH_FRAME: { ByteCodeInstruction bins(BC_PUSH_FRAME); - bins.mValue = ins.ivalue + 2; + bins.mValue = ins.mIntValue + 2; mIns.Push(bins); } break; case IC_POP_FRAME: { ByteCodeInstruction bins(BC_POP_FRAME); - bins.mValue = ins.ivalue + 2; + bins.mValue = ins.mIntValue + 2; mIns.Push(bins); } break; case IC_RELATIONAL_OPERATOR: - if (sblock->code[i + 1].code == IC_BRANCH) + if (sblock->mInstructions[i + 1].mCode == IC_BRANCH) { ByteCode code = RelationalOperator(iproc, ins); - this->Close(proc->CompileBlock(iproc, sblock->trueJump), proc->CompileBlock(iproc, sblock->falseJump), code); + this->Close(proc->CompileBlock(iproc, sblock->mTrueJump), proc->CompileBlock(iproc, sblock->mFalseJump), code); i++; return; } @@ -2259,26 +2201,26 @@ void ByteCodeBasicBlock::Compile(InterCodeProcedure* iproc, ByteCodeProcedure* p ByteCodeInstruction bins(ByteCode(code - BC_BRANCHS_EQ + BC_SET_EQ)); mIns.Push(bins); ByteCodeInstruction sins(BC_STORE_REG_16); - sins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.ttemp]; + sins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.mTTemp]; mIns.Push(sins); } break; case IC_RETURN_VALUE: - if (ins.stemp[0] < 0) - IntConstToAccu(ins.siconst[0]); - else if (ins.stype[0] == IT_FLOAT) + if (ins.mSTemp[0] < 0) + IntConstToAccu(ins.mSIntConst[0]); + else if (ins.mSType[0] == IT_FLOAT) { ByteCodeInstruction lins(BC_LOAD_REG_32); - lins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.stemp[0]]; - lins.mRegisterFinal = ins.sfinal[0]; + lins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.mSTemp[0]]; + lins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(lins); } else { ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.stemp[0]]; - lins.mRegisterFinal = ins.sfinal[0]; + lins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.mSTemp[0]]; + lins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(lins); } @@ -2290,34 +2232,34 @@ void ByteCodeBasicBlock::Compile(InterCodeProcedure* iproc, ByteCodeProcedure* p return; case IC_TYPECAST: - if (ins.stemp[0] >= 0 && ins.ttemp != ins.stemp[0]) + if (ins.mSTemp[0] >= 0 && ins.mTTemp != ins.mSTemp[0]) { ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.stemp[0]]; - lins.mRegisterFinal = ins.sfinal[0]; + lins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.mSTemp[0]]; + lins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(lins); ByteCodeInstruction sins(BC_STORE_REG_16); - sins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.ttemp]; + sins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.mTTemp]; mIns.Push(sins); } break; case IC_BRANCH: - if (ins.stemp[0] < 0) + if (ins.mSTemp[0] < 0) { - if (ins.siconst[0] == 0) - this->Close(proc->CompileBlock(iproc, sblock->falseJump), nullptr, BC_JUMPS); + if (ins.mSIntConst[0] == 0) + this->Close(proc->CompileBlock(iproc, sblock->mFalseJump), nullptr, BC_JUMPS); else - this->Close(proc->CompileBlock(iproc, sblock->trueJump), nullptr, BC_JUMPS); + this->Close(proc->CompileBlock(iproc, sblock->mTrueJump), nullptr, BC_JUMPS); } else { ByteCodeInstruction lins(BC_LOAD_REG_16); - lins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.stemp[0]]; - lins.mRegisterFinal = ins.sfinal[0]; + lins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.mSTemp[0]]; + lins.mRegisterFinal = ins.mSFinal[0]; mIns.Push(lins); - this->Close(proc->CompileBlock(iproc, sblock->trueJump), proc->CompileBlock(iproc, sblock->falseJump), BC_BRANCHS_NE); + this->Close(proc->CompileBlock(iproc, sblock->mTrueJump), proc->CompileBlock(iproc, sblock->mFalseJump), BC_BRANCHS_NE); } return; @@ -2326,7 +2268,7 @@ void ByteCodeBasicBlock::Compile(InterCodeProcedure* iproc, ByteCodeProcedure* p i++; } - this->Close(proc->CompileBlock(iproc, sblock->trueJump), nullptr, BC_JUMPS); + this->Close(proc->CompileBlock(iproc, sblock->mTrueJump), nullptr, BC_JUMPS); } void ByteCodeBasicBlock::PeepHoleOptimizer(void) @@ -2442,7 +2384,7 @@ void ByteCodeBasicBlock::PeepHoleOptimizer(void) { mIns[i + 1].mRegister = mIns[i + 0].mRegister; mIns[i + 0].mCode = BC_NOP; - branch = TransposeBranchCondition(branch); + mBranch = TransposeBranchCondition(mBranch); } } if (i + 1 < mIns.Size()) @@ -2543,18 +2485,18 @@ void ByteCodeBasicBlock::Assemble(ByteCodeGenerator* generator) for (int i = 0; i < mIns.Size(); i++) mIns[i].Assemble(generator, this); - if (this->trueJump) - this->trueJump->Assemble(generator); - if (this->falseJump) - this->falseJump->Assemble(generator); + if (this->mTrueJump) + this->mTrueJump->Assemble(generator); + if (this->mFalseJump) + this->mFalseJump->Assemble(generator); } } void ByteCodeBasicBlock::Close(ByteCodeBasicBlock* trueJump, ByteCodeBasicBlock* falseJump, ByteCode branch) { - this->trueJump = this->trueLink = trueJump; - this->falseJump = this->falseLink = falseJump; - this->branch = branch; + this->mTrueJump = this->mTrueLink = trueJump; + this->mFalseJump = this->mFalseLink = falseJump; + this->mBranch = branch; } static int BranchByteSize(int from, int to) @@ -2575,18 +2517,18 @@ static int JumpByteSize(int from, int to) ByteCodeBasicBlock* ByteCodeBasicBlock::BypassEmptyBlocks(void) { - if (bypassed) + if (mBypassed) return this; - else if (!falseJump && code.Size() == 0) - return trueJump->BypassEmptyBlocks(); + else if (!mFalseJump && mCode.Size() == 0) + return mTrueJump->BypassEmptyBlocks(); else { - bypassed = true; + mBypassed = true; - if (falseJump) - falseJump = falseJump->BypassEmptyBlocks(); - if (trueJump) - trueJump = trueJump->BypassEmptyBlocks(); + if (mFalseJump) + mFalseJump = mFalseJump->BypassEmptyBlocks(); + if (mTrueJump) + mTrueJump = mTrueJump->BypassEmptyBlocks(); return this; } @@ -2599,9 +2541,9 @@ void ByteCodeBasicBlock::CopyCode(ByteCodeGenerator* generator, uint8 * target) int pos, at; uint8 b; - if (!copied) + if (!mCopied) { - copied = true; + mCopied = true; for (int i = 0; i < mRelocations.Size(); i++) { @@ -2610,45 +2552,45 @@ void ByteCodeBasicBlock::CopyCode(ByteCodeGenerator* generator, uint8 * target) generator->mRelocations.Push(rl); } - next = mOffset + code.Size(); + next = mOffset + mCode.Size(); - if (falseJump) + if (mFalseJump) { - if (falseJump->mOffset <= mOffset) + if (mFalseJump->mOffset <= mOffset) { - if (trueJump->mOffset <= mOffset) + if (mTrueJump->mOffset <= mOffset) { - next += PutBranch(generator, branch, trueJump->mOffset - next); - next += PutBranch(generator, BC_JUMPS, falseJump->mOffset - next); + next += PutBranch(generator, mBranch, mTrueJump->mOffset - next); + next += PutBranch(generator, BC_JUMPS, mFalseJump->mOffset - next); } else { - next += PutBranch(generator, InvertBranchCondition(branch), falseJump->mOffset - next); + next += PutBranch(generator, InvertBranchCondition(mBranch), mFalseJump->mOffset - next); } } else { - next += PutBranch(generator, branch, trueJump->mOffset - next); + next += PutBranch(generator, mBranch, mTrueJump->mOffset - next); } } - else if (trueJump) + else if (mTrueJump) { - if (trueJump->mOffset != next) + if (mTrueJump->mOffset != next) { - next += PutBranch(generator, BC_JUMPS, trueJump->mOffset - next); + next += PutBranch(generator, BC_JUMPS, mTrueJump->mOffset - next); } } assert(next - mOffset == mSize); - for (i = 0; i < code.Size(); i++) + for (i = 0; i < mCode.Size(); i++) { - code.Lookup(i, target[i + mOffset]); + mCode.Lookup(i, target[i + mOffset]); } - if (trueJump) trueJump->CopyCode(generator, target); - if (falseJump) falseJump->CopyCode(generator, target); + if (mTrueJump) mTrueJump->CopyCode(generator, target); + if (mFalseJump) mFalseJump->CopyCode(generator, target); } } @@ -2659,40 +2601,40 @@ void ByteCodeBasicBlock::CalculateOffset(int& total) if (mOffset > total) { mOffset = total; - next = total + code.Size(); + next = total + mCode.Size(); - if (falseJump) + if (mFalseJump) { - if (falseJump->mOffset <= total) + if (mFalseJump->mOffset <= total) { // falseJump has been placed - if (trueJump->mOffset <= total) + if (mTrueJump->mOffset <= total) { // trueJump and falseJump have been placed, not much to do - next = next + BranchByteSize(next, trueJump->mOffset); - total = next + JumpByteSize(next, falseJump->mOffset); + next = next + BranchByteSize(next, mTrueJump->mOffset); + total = next + JumpByteSize(next, mFalseJump->mOffset); mSize = total - mOffset; } else { // trueJump has not been placed, but falseJump has - total = next + BranchByteSize(next, falseJump->mOffset); + total = next + BranchByteSize(next, mFalseJump->mOffset); mSize = total - mOffset; - trueJump->CalculateOffset(total); + mTrueJump->CalculateOffset(total); } } - else if (trueJump->mOffset <= total) + else if (mTrueJump->mOffset <= total) { // falseJump has not been placed, but trueJump has - total = next + BranchByteSize(next, trueJump->mOffset); + total = next + BranchByteSize(next, mTrueJump->mOffset); mSize = total - mOffset; - falseJump->CalculateOffset(total); + mFalseJump->CalculateOffset(total); } - else if (knownShortBranch) + else if (mKnownShortBranch) { // neither falseJump nor trueJump have been placed, // but we know from previous iteration that we can do @@ -2701,11 +2643,11 @@ void ByteCodeBasicBlock::CalculateOffset(int& total) total = next + 2; mSize = total - mOffset; - falseJump->CalculateOffset(total); - if (trueJump->mOffset > total) + mFalseJump->CalculateOffset(total); + if (mTrueJump->mOffset > total) { // trueJump was not placed in the process, so lets place it now - trueJump->CalculateOffset(total); + mTrueJump->CalculateOffset(total); } } else @@ -2717,40 +2659,40 @@ void ByteCodeBasicBlock::CalculateOffset(int& total) total = next + 3; mSize = total - mOffset; - falseJump->CalculateOffset(total); - if (trueJump->mOffset > total) + mFalseJump->CalculateOffset(total); + if (mTrueJump->mOffset > total) { // trueJump was not placed in the process, so lets place it now - trueJump->CalculateOffset(total); + mTrueJump->CalculateOffset(total); } - if (BranchByteSize(next, trueJump->mOffset) < 3) + if (BranchByteSize(next, mTrueJump->mOffset) < 3) { // oh, we can replace by a short branch - knownShortBranch = true; + mKnownShortBranch = true; total = next + 2; mSize = total - mOffset; - falseJump->CalculateOffset(total); - if (trueJump->mOffset > total) + mFalseJump->CalculateOffset(total); + if (mTrueJump->mOffset > total) { // trueJump was not placed in the process, so lets place it now - trueJump->CalculateOffset(total); + mTrueJump->CalculateOffset(total); } } } } - else if (trueJump) + else if (mTrueJump) { - if (trueJump->mOffset <= total) + if (mTrueJump->mOffset <= total) { // trueJump has been placed, so append the branch size - total = next + JumpByteSize(next, trueJump->mOffset); + total = next + JumpByteSize(next, mTrueJump->mOffset); mSize = total - mOffset; } else @@ -2760,14 +2702,14 @@ void ByteCodeBasicBlock::CalculateOffset(int& total) total = next; mSize = total - mOffset; - trueJump->CalculateOffset(total); + mTrueJump->CalculateOffset(total); } } else { // no exit from block - total += code.Size(); + total += mCode.Size(); mSize = total - mOffset; } } @@ -2785,8 +2727,8 @@ ByteCodeProcedure::~ByteCodeProcedure(void) void ByteCodeProcedure::Compile(ByteCodeGenerator* generator, InterCodeProcedure* proc) { - tblocks = new ByteCodeBasicBlock * [proc->blocks.Size()]; - for (int i = 0; i < proc->blocks.Size(); i++) + tblocks = new ByteCodeBasicBlock * [proc->mBlocks.Size()]; + for (int i = 0; i < proc->mBlocks.Size(); i++) tblocks[i] = nullptr; int tempSave = proc->mTempSize > 16 ? proc->mTempSize - 16 : 0; @@ -2811,7 +2753,7 @@ void ByteCodeProcedure::Compile(ByteCodeGenerator* generator, InterCodeProcedure } exitBlock->PutCode(generator, BC_RETURN); exitBlock->PutByte(tempSave); exitBlock->PutWord(proc->mLocalSize + 2 + tempSave); - entryBlock->Compile(proc, this, proc->blocks[0]); + entryBlock->Compile(proc, this, proc->mBlocks[0]); entryBlock->Assemble(generator); int total; @@ -2833,11 +2775,11 @@ void ByteCodeProcedure::Compile(ByteCodeGenerator* generator, InterCodeProcedure ByteCodeBasicBlock* ByteCodeProcedure::CompileBlock(InterCodeProcedure* iproc, InterCodeBasicBlock* sblock) { - if (tblocks[sblock->num]) - return tblocks[sblock->num]; + if (tblocks[sblock->mIndex]) + return tblocks[sblock->mIndex]; ByteCodeBasicBlock * block = new ByteCodeBasicBlock(); - tblocks[sblock->num] = block; + tblocks[sblock->mIndex] = block; block->Compile(iproc, this, sblock); return block; diff --git a/oscar64/ByteCodeGenerator.h b/oscar64/ByteCodeGenerator.h index 244188b..b0821cf 100644 --- a/oscar64/ByteCodeGenerator.h +++ b/oscar64/ByteCodeGenerator.h @@ -175,18 +175,18 @@ public: class ByteCodeBasicBlock { public: - DynamicArray code; - int num; + DynamicArray mCode; + int mIndex; - ByteCodeBasicBlock * trueJump, * falseJump; - ByteCodeBasicBlock * trueLink, * falseLink; - ByteCode branch; + ByteCodeBasicBlock * mTrueJump, * mFalseJump; + ByteCodeBasicBlock * mTrueLink, * mFalseLink; + ByteCode mBranch; GrowingArray mIns; GrowingArray mRelocations; int mOffset, mSize; - bool placed, copied, knownShortBranch, killed, bypassed, mAssembled; + bool mPlaced, mCopied, mKnownShortBranch, mBypassed, mAssembled; ByteCodeBasicBlock(void); diff --git a/oscar64/InterCode.cpp b/oscar64/InterCode.cpp index 491dc49..2846595 100644 --- a/oscar64/InterCode.cpp +++ b/oscar64/InterCode.cpp @@ -7,31 +7,31 @@ ValueSet::ValueSet(void) { - size = 32; - num = 0; - instructions = new InterInstructionPtr[size]; + mSize = 32; + mNum = 0; + mInstructions = new InterInstructionPtr[mSize]; } ValueSet::ValueSet(const ValueSet& values) { int i; - size = values.size; - num = values.num; - instructions = new InterInstructionPtr[size]; + mSize = values.mSize; + mNum = values.mNum; + mInstructions = new InterInstructionPtr[mSize]; - for (i = 0; i < num; i++) - instructions[i] = values.instructions[i]; + for (i = 0; i < mNum; i++) + mInstructions[i] = values.mInstructions[i]; } ValueSet::~ValueSet(void) { - delete[] instructions; + delete[] mInstructions; } void ValueSet::FlushAll(void) { - num = 0; + mNum = 0; } void ValueSet::FlushCallAliases(void) @@ -40,17 +40,17 @@ void ValueSet::FlushCallAliases(void) i = 0; - while (i < num) + while (i < mNum) { - if ((instructions[i]->code == IC_LOAD || instructions[i]->code == IC_STORE) && instructions[i]->mem != IM_PARAM && instructions[i]->mem != IM_LOCAL) + if ((mInstructions[i]->mCode == IC_LOAD || mInstructions[i]->mCode == IC_STORE) && mInstructions[i]->mMemory != IM_PARAM && mInstructions[i]->mMemory != IM_LOCAL) { // // potential alias load // - num--; - if (i < num) + mNum--; + if (i < mNum) { - instructions[i] = instructions[num]; + mInstructions[i] = mInstructions[mNum]; } } else @@ -213,29 +213,29 @@ void ValueSet::InsertValue(InterInstruction& ins) InterInstructionPtr* nins; int i; - if (num == size) + if (mNum == mSize) { - size *= 2; - nins = new InterInstructionPtr[size]; - for (i = 0; i < num; i++) - nins[i] = instructions[i]; - delete[] instructions; - instructions = nins; + mSize *= 2; + nins = new InterInstructionPtr[mSize]; + for (i = 0; i < mNum; i++) + nins[i] = mInstructions[i]; + delete[] mInstructions; + mInstructions = nins; } - instructions[num++] = &ins; + mInstructions[mNum++] = &ins; } static bool MemPtrRange(const InterInstruction* ins, const GrowingInstructionPtrArray& tvalue, InterMemory& mem, int& vindex, int& offset) { - while (ins && ins->mem == IM_INDIRECT && ins->code == IC_LEA) - ins = tvalue[ins->stemp[1]]; + while (ins && ins->mMemory == IM_INDIRECT && ins->mCode == IC_LEA) + ins = tvalue[ins->mSTemp[1]]; - if (ins && (ins->code == IC_CONSTANT || ins->code == IC_LEA)) + if (ins && (ins->mCode == IC_CONSTANT || ins->mCode == IC_LEA)) { - mem = ins->mem; - vindex = ins->vindex; - offset = ins->ivalue; + mem = ins->mMemory; + vindex = ins->mVarIndex; + offset = ins->mIntValue; return true; } @@ -246,18 +246,18 @@ static bool MemPtrRange(const InterInstruction* ins, const GrowingInstructionPtr static bool MemRange(const InterInstruction * ins, const GrowingInstructionPtrArray& tvalue, InterMemory& mem, int& vindex, int& offset) { - if (ins->mem == IM_INDIRECT) + if (ins->mMemory == IM_INDIRECT) { - if (ins->code == IC_LOAD) - return MemPtrRange(tvalue[ins->stemp[0]], tvalue, mem, vindex, offset); + if (ins->mCode == IC_LOAD) + return MemPtrRange(tvalue[ins->mSTemp[0]], tvalue, mem, vindex, offset); else - return MemPtrRange(tvalue[ins->stemp[1]], tvalue, mem, vindex, offset); + return MemPtrRange(tvalue[ins->mSTemp[1]], tvalue, mem, vindex, offset); } if (ins) { - mem = ins->mem; - vindex = ins->vindex; - offset = ins->ivalue; + mem = ins->mMemory; + vindex = ins->mVarIndex; + offset = ins->mIntValue; return true; } @@ -275,7 +275,7 @@ static bool StoreAliasing(const InterInstruction * lins, const InterInstruction* { if (smem == lmem && svindex == lvindex) { - if (soffset + sins->opsize >= loffset && loffset + lins->opsize >= soffset) + if (soffset + sins->mOperandSize >= loffset && loffset + lins->mOperandSize >= soffset) return true; } @@ -292,21 +292,21 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr { int i, value, temp; - temp = ins.ttemp; + temp = ins.mTTemp; if (temp >= 0) { i = 0; - while (i < num) + while (i < mNum) { - if (temp == instructions[i]->ttemp || - temp == instructions[i]->stemp[0] || - temp == instructions[i]->stemp[1] || - temp == instructions[i]->stemp[2]) + if (temp == mInstructions[i]->mTTemp || + temp == mInstructions[i]->mSTemp[0] || + temp == mInstructions[i]->mSTemp[1] || + temp == mInstructions[i]->mSTemp[2]) { - num--; - if (i < num) - instructions[i] = instructions[num]; + mNum--; + if (i < mNum) + mInstructions[i] = mInstructions[mNum]; } else i++; @@ -315,58 +315,58 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr for (i = 0; i < 3; i++) { - temp = ins.stemp[i]; + temp = ins.mSTemp[i]; if (temp >= 0 && tvalue[temp]) { - ins.stemp[i] = tvalue[temp]->ttemp; + ins.mSTemp[i] = tvalue[temp]->mTTemp; } } - switch (ins.code) + switch (ins.mCode) { case IC_LOAD: i = 0; - while (i < num && - (instructions[i]->code != IC_LOAD || - instructions[i]->stemp[0] != ins.stemp[0] || - instructions[i]->opsize != ins.opsize)) + while (i < mNum && + (mInstructions[i]->mCode != IC_LOAD || + mInstructions[i]->mSTemp[0] != ins.mSTemp[0] || + mInstructions[i]->mOperandSize != ins.mOperandSize)) { i++; } - if (i < num) + if (i < mNum) { - ins.code = IC_LOAD_TEMPORARY; - ins.stemp[0] = instructions[i]->ttemp; - ins.stype[0] = instructions[i]->ttype; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + ins.mSTemp[0] = mInstructions[i]->mTTemp; + ins.mSType[0] = mInstructions[i]->mTType; + assert(ins.mSTemp[0] >= 0); } else { i = 0; - while (i < num && - (instructions[i]->code != IC_STORE || - instructions[i]->stemp[1] != ins.stemp[0] || - instructions[i]->opsize != ins.opsize)) + while (i < mNum && + (mInstructions[i]->mCode != IC_STORE || + mInstructions[i]->mSTemp[1] != ins.mSTemp[0] || + mInstructions[i]->mOperandSize != ins.mOperandSize)) { i++; } - if (i < num) + if (i < mNum) { - if (instructions[i]->stemp[0] < 0) + if (mInstructions[i]->mSTemp[0] < 0) { - ins.code = IC_CONSTANT; - ins.stemp[0] = -1; - ins.stype[0] = instructions[i]->stype[0]; - ins.ivalue = instructions[i]->siconst[0]; + ins.mCode = IC_CONSTANT; + ins.mSTemp[0] = -1; + ins.mSType[0] = mInstructions[i]->mSType[0]; + ins.mIntValue = mInstructions[i]->mSIntConst[0]; } else { - ins.code = IC_LOAD_TEMPORARY; - ins.stemp[0] = instructions[i]->stemp[0]; - ins.stype[0] = instructions[i]->stype[0]; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + ins.mSTemp[0] = mInstructions[i]->mSTemp[0]; + ins.mSType[0] = mInstructions[i]->mSType[0]; + assert(ins.mSTemp[0] >= 0); } } else @@ -378,13 +378,13 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr break; case IC_STORE: i = 0; - while (i < num) + while (i < mNum) { - if ((instructions[i]->code == IC_LOAD || instructions[i]->code == IC_STORE) && StoreAliasing(instructions[i], &ins, tvalue, aliasedLocals)) + if ((mInstructions[i]->mCode == IC_LOAD || mInstructions[i]->mCode == IC_STORE) && StoreAliasing(mInstructions[i], &ins, tvalue, aliasedLocals)) { - num--; - if (num > 0) - instructions[i] = instructions[num]; + mNum--; + if (mNum > 0) + mInstructions[i] = mInstructions[mNum]; } else i++; @@ -394,13 +394,13 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr break; case IC_COPY: i = 0; - while (i < num) + while (i < mNum) { - if ((instructions[i]->code == IC_LOAD || instructions[i]->code == IC_STORE) && StoreAliasing(instructions[i], &ins, tvalue, aliasedLocals)) + if ((mInstructions[i]->mCode == IC_LOAD || mInstructions[i]->mCode == IC_STORE) && StoreAliasing(mInstructions[i], &ins, tvalue, aliasedLocals)) { - num--; - if (num > 0) - instructions[i] = instructions[num]; + mNum--; + if (mNum > 0) + mInstructions[i] = mInstructions[mNum]; } else i++; @@ -409,26 +409,26 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr break; case IC_CONSTANT: - switch (ins.ttype) + switch (ins.mTType) { case IT_FLOAT: i = 0; - while (i < num && - (instructions[i]->code != IC_CONSTANT || - instructions[i]->ttype != ins.ttype || - instructions[i]->fvalue != ins.fvalue)) + while (i < mNum && + (mInstructions[i]->mCode != IC_CONSTANT || + mInstructions[i]->mTType != ins.mTType || + mInstructions[i]->mFloatValue != ins.mFloatValue)) { i++; } break; case IT_POINTER: i = 0; - while (i < num && - (instructions[i]->code != IC_CONSTANT || - instructions[i]->ttype != ins.ttype || - instructions[i]->ivalue != ins.ivalue || - instructions[i]->mem != ins.mem || - instructions[i]->vindex != ins.vindex)) + while (i < mNum && + (mInstructions[i]->mCode != IC_CONSTANT || + mInstructions[i]->mTType != ins.mTType || + mInstructions[i]->mIntValue != ins.mIntValue || + mInstructions[i]->mMemory != ins.mMemory || + mInstructions[i]->mVarIndex != ins.mVarIndex)) { i++; } @@ -436,21 +436,21 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr default: i = 0; - while (i < num && - (instructions[i]->code != IC_CONSTANT || - instructions[i]->ttype != ins.ttype || - instructions[i]->ivalue != ins.ivalue)) + while (i < mNum && + (mInstructions[i]->mCode != IC_CONSTANT || + mInstructions[i]->mTType != ins.mTType || + mInstructions[i]->mIntValue != ins.mIntValue)) { i++; } } - if (i < num) + if (i < mNum) { - ins.code = IC_LOAD_TEMPORARY; - ins.stemp[0] = instructions[i]->ttemp; - ins.stype[0] = instructions[i]->ttype; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + ins.mSTemp[0] = mInstructions[i]->mTTemp; + ins.mSType[0] = mInstructions[i]->mTType; + assert(ins.mSTemp[0] >= 0); } else { @@ -460,21 +460,21 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr case IC_LEA: i = 0; - while (i < num && - (instructions[i]->code != IC_LEA || - instructions[i]->stemp[0] != ins.stemp[0] || - instructions[i]->stemp[1] != ins.stemp[1])) + while (i < mNum && + (mInstructions[i]->mCode != IC_LEA || + mInstructions[i]->mSTemp[0] != ins.mSTemp[0] || + mInstructions[i]->mSTemp[1] != ins.mSTemp[1])) { i++; } - if (i < num) + if (i < mNum) { - ins.code = IC_LOAD_TEMPORARY; - ins.stemp[0] = instructions[i]->ttemp; - ins.stype[0] = instructions[i]->ttype; - ins.stemp[1] = -1; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + ins.mSTemp[0] = mInstructions[i]->mTTemp; + ins.mSType[0] = mInstructions[i]->mTType; + ins.mSTemp[1] = -1; + assert(ins.mSTemp[0] >= 0); } else { @@ -483,32 +483,32 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr break; case IC_BINARY_OPERATOR: - switch (ins.stype[0]) + switch (ins.mSType[0]) { case IT_FLOAT: - if (ins.stemp[1] >= 0 && tvalue[ins.stemp[1]] && tvalue[ins.stemp[1]]->code == IC_CONSTANT && - ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_CONSTANT) + if (ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_CONSTANT && + ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT) { - ins.code = IC_CONSTANT; - ins.fvalue = ConstantFolding(ins.oper, tvalue[ins.stemp[1]]->fvalue, tvalue[ins.stemp[0]]->fvalue); - ins.stemp[0] = -1; - ins.stemp[1] = -1; + ins.mCode = IC_CONSTANT; + ins.mFloatValue = ConstantFolding(ins.mOperator, tvalue[ins.mSTemp[1]]->mFloatValue, tvalue[ins.mSTemp[0]]->mFloatValue); + ins.mSTemp[0] = -1; + ins.mSTemp[1] = -1; i = 0; - while (i < num && - (instructions[i]->code != IC_CONSTANT || - instructions[i]->ttype != ins.ttype || - instructions[i]->fvalue != ins.fvalue)) + while (i < mNum && + (mInstructions[i]->mCode != IC_CONSTANT || + mInstructions[i]->mTType != ins.mTType || + mInstructions[i]->mFloatValue != ins.mFloatValue)) { i++; } - if (i < num) + if (i < mNum) { - ins.code = IC_LOAD_TEMPORARY; - ins.stemp[0] = instructions[i]->ttemp; - ins.stype[0] = instructions[i]->ttype; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + ins.mSTemp[0] = mInstructions[i]->mTTemp; + ins.mSType[0] = mInstructions[i]->mTType; + assert(ins.mSTemp[0] >= 0); } else { @@ -518,22 +518,22 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr else { i = 0; - while (i < num && - (instructions[i]->code != IC_BINARY_OPERATOR || - instructions[i]->oper != ins.oper || - instructions[i]->stemp[0] != ins.stemp[0] || - instructions[i]->stemp[1] != ins.stemp[1])) + while (i < mNum && + (mInstructions[i]->mCode != IC_BINARY_OPERATOR || + mInstructions[i]->mOperator != ins.mOperator || + mInstructions[i]->mSTemp[0] != ins.mSTemp[0] || + mInstructions[i]->mSTemp[1] != ins.mSTemp[1])) { i++; } - if (i < num) + if (i < mNum) { - ins.code = IC_LOAD_TEMPORARY; - ins.stemp[0] = instructions[i]->ttemp; - ins.stype[0] = instructions[i]->ttype; - ins.stemp[1] = -1; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + ins.mSTemp[0] = mInstructions[i]->mTTemp; + ins.mSType[0] = mInstructions[i]->mTType; + ins.mSTemp[1] = -1; + assert(ins.mSTemp[0] >= 0); } else { @@ -544,104 +544,104 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr case IT_POINTER: break; default: - if (ins.stemp[1] >= 0 && tvalue[ins.stemp[1]] && tvalue[ins.stemp[1]]->code == IC_CONSTANT && - ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_CONSTANT) + if (ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_CONSTANT && + ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT) { - ins.code = IC_CONSTANT; - ins.ivalue = ConstantFolding(ins.oper, tvalue[ins.stemp[1]]->ivalue, tvalue[ins.stemp[0]]->ivalue); - ins.stemp[0] = -1; - ins.stemp[1] = -1; + ins.mCode = IC_CONSTANT; + ins.mIntValue = ConstantFolding(ins.mOperator, tvalue[ins.mSTemp[1]]->mIntValue, tvalue[ins.mSTemp[0]]->mIntValue); + ins.mSTemp[0] = -1; + ins.mSTemp[1] = -1; UpdateValue(ins, tvalue, aliasedLocals); return; } - if (ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_CONSTANT) + if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT) { - if ((ins.oper == IA_ADD || ins.oper == IA_SUB || - ins.oper == IA_OR || ins.oper == IA_XOR || - ins.oper == IA_SHL || ins.oper == IA_SHR || ins.oper == IA_SAR) && tvalue[ins.stemp[0]]->ivalue == 0 || - (ins.oper == IA_MUL || ins.oper == IA_DIVU || ins.oper == IA_DIVS) && tvalue[ins.stemp[0]]->ivalue == 1 || - (ins.oper == IA_AND) && tvalue[ins.stemp[0]]->ivalue == -1) + if ((ins.mOperator == IA_ADD || ins.mOperator == IA_SUB || + ins.mOperator == IA_OR || ins.mOperator == IA_XOR || + ins.mOperator == IA_SHL || ins.mOperator == IA_SHR || ins.mOperator == IA_SAR) && tvalue[ins.mSTemp[0]]->mIntValue == 0 || + (ins.mOperator == IA_MUL || ins.mOperator == IA_DIVU || ins.mOperator == IA_DIVS) && tvalue[ins.mSTemp[0]]->mIntValue == 1 || + (ins.mOperator == IA_AND) && tvalue[ins.mSTemp[0]]->mIntValue == -1) { - ins.code = IC_LOAD_TEMPORARY; - ins.stemp[0] = ins.stemp[1]; - ins.stype[0] = ins.stype[1]; - ins.stemp[1] = -1; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + ins.mSTemp[0] = ins.mSTemp[1]; + ins.mSType[0] = ins.mSType[1]; + ins.mSTemp[1] = -1; + assert(ins.mSTemp[0] >= 0); UpdateValue(ins, tvalue, aliasedLocals); return; } - else if ((ins.oper == IA_MUL || ins.oper == IA_AND) && tvalue[ins.stemp[0]]->ivalue == 0) + else if ((ins.mOperator == IA_MUL || ins.mOperator == IA_AND) && tvalue[ins.mSTemp[0]]->mIntValue == 0) { - ins.code = IC_CONSTANT; - ins.ivalue = 0; - ins.stemp[0] = -1; - ins.stemp[1] = -1; + ins.mCode = IC_CONSTANT; + ins.mIntValue = 0; + ins.mSTemp[0] = -1; + ins.mSTemp[1] = -1; UpdateValue(ins, tvalue, aliasedLocals); return; } } - else if (ins.stemp[1] >= 0 && tvalue[ins.stemp[1]] && tvalue[ins.stemp[1]]->code == IC_CONSTANT) + else if (ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_CONSTANT) { - if ((ins.oper == IA_ADD || ins.oper == IA_OR || ins.oper == IA_XOR) && tvalue[ins.stemp[1]]->ivalue == 0 || - (ins.oper == IA_MUL) && tvalue[ins.stemp[1]]->ivalue == 1 || - (ins.oper == IA_AND) && tvalue[ins.stemp[1]]->ivalue == -1) + if ((ins.mOperator == IA_ADD || ins.mOperator == IA_OR || ins.mOperator == IA_XOR) && tvalue[ins.mSTemp[1]]->mIntValue == 0 || + (ins.mOperator == IA_MUL) && tvalue[ins.mSTemp[1]]->mIntValue == 1 || + (ins.mOperator == IA_AND) && tvalue[ins.mSTemp[1]]->mIntValue == -1) { - ins.code = IC_LOAD_TEMPORARY; - ins.stemp[1] = -1; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + ins.mSTemp[1] = -1; + assert(ins.mSTemp[0] >= 0); UpdateValue(ins, tvalue, aliasedLocals); return; } - else if ((ins.oper == IA_MUL || ins.oper == IA_AND || - ins.oper == IA_SHL || ins.oper == IA_SHR || ins.oper == IA_SAR) && tvalue[ins.stemp[1]]->ivalue == 0) + else if ((ins.mOperator == IA_MUL || ins.mOperator == IA_AND || + ins.mOperator == IA_SHL || ins.mOperator == IA_SHR || ins.mOperator == IA_SAR) && tvalue[ins.mSTemp[1]]->mIntValue == 0) { - ins.code = IC_CONSTANT; - ins.ivalue = 0; - ins.stemp[0] = -1; - ins.stemp[1] = -1; + ins.mCode = IC_CONSTANT; + ins.mIntValue = 0; + ins.mSTemp[0] = -1; + ins.mSTemp[1] = -1; UpdateValue(ins, tvalue, aliasedLocals); return; } - else if (ins.oper == IA_SUB && tvalue[ins.stemp[1]]->ivalue == 0) + else if (ins.mOperator == IA_SUB && tvalue[ins.mSTemp[1]]->mIntValue == 0) { - ins.code = IC_UNARY_OPERATOR; - ins.oper = IA_NEG; - ins.stemp[1] = -1; + ins.mCode = IC_UNARY_OPERATOR; + ins.mOperator = IA_NEG; + ins.mSTemp[1] = -1; UpdateValue(ins, tvalue, aliasedLocals); return; } } - else if (ins.stemp[0] == ins.stemp[1]) + else if (ins.mSTemp[0] == ins.mSTemp[1]) { - if (ins.oper == IA_SUB || ins.oper == IA_XOR) + if (ins.mOperator == IA_SUB || ins.mOperator == IA_XOR) { - ins.code = IC_CONSTANT; - ins.ivalue = 0; - ins.stemp[0] = -1; - ins.stemp[1] = -1; + ins.mCode = IC_CONSTANT; + ins.mIntValue = 0; + ins.mSTemp[0] = -1; + ins.mSTemp[1] = -1; UpdateValue(ins, tvalue, aliasedLocals); return; } - else if (ins.oper == IA_AND || ins.oper == IA_OR) + else if (ins.mOperator == IA_AND || ins.mOperator == IA_OR) { - ins.code = IC_LOAD_TEMPORARY; - ins.stemp[1] = -1; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + ins.mSTemp[1] = -1; + assert(ins.mSTemp[0] >= 0); UpdateValue(ins, tvalue, aliasedLocals); @@ -650,22 +650,22 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr } i = 0; - while (i < num && - (instructions[i]->code != IC_BINARY_OPERATOR || - instructions[i]->oper != ins.oper || - instructions[i]->stemp[0] != ins.stemp[0] || - instructions[i]->stemp[1] != ins.stemp[1])) + while (i < mNum && + (mInstructions[i]->mCode != IC_BINARY_OPERATOR || + mInstructions[i]->mOperator != ins.mOperator || + mInstructions[i]->mSTemp[0] != ins.mSTemp[0] || + mInstructions[i]->mSTemp[1] != ins.mSTemp[1])) { i++; } - if (i < num) + if (i < mNum) { - ins.code = IC_LOAD_TEMPORARY; - ins.stemp[0] = instructions[i]->ttemp; - ins.stype[0] = instructions[i]->ttype; - ins.stemp[1] = -1; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + ins.mSTemp[0] = mInstructions[i]->mTTemp; + ins.mSType[0] = mInstructions[i]->mTType; + ins.mSTemp[1] = -1; + assert(ins.mSTemp[0] >= 0); } else { @@ -676,29 +676,29 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr break; case IC_CONVERSION_OPERATOR: - if (ins.oper == IA_INT2FLOAT) + if (ins.mOperator == IA_INT2FLOAT) { - if (ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_CONSTANT) + if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT) { - ins.code = IC_CONSTANT; - ins.fvalue = (double)(tvalue[ins.stemp[0]]->ivalue); - ins.stemp[0] = -1; + ins.mCode = IC_CONSTANT; + ins.mFloatValue = (double)(tvalue[ins.mSTemp[0]]->mIntValue); + ins.mSTemp[0] = -1; i = 0; - while (i < num && - (instructions[i]->code != IC_CONSTANT || - instructions[i]->ttype != ins.ttype || - instructions[i]->fvalue != ins.fvalue)) + while (i < mNum && + (mInstructions[i]->mCode != IC_CONSTANT || + mInstructions[i]->mTType != ins.mTType || + mInstructions[i]->mFloatValue != ins.mFloatValue)) { i++; } - if (i < num) + if (i < mNum) { - ins.code = IC_LOAD_TEMPORARY; - ins.stemp[0] = instructions[i]->ttemp; - ins.stype[0] = instructions[i]->ttype; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + ins.mSTemp[0] = mInstructions[i]->mTTemp; + ins.mSType[0] = mInstructions[i]->mTType; + assert(ins.mSTemp[0] >= 0); } else { @@ -708,21 +708,21 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr else { i = 0; - while (i < num && - (instructions[i]->code != IC_CONVERSION_OPERATOR || - instructions[i]->oper != ins.oper || - instructions[i]->stemp[0] != ins.stemp[0])) + while (i < mNum && + (mInstructions[i]->mCode != IC_CONVERSION_OPERATOR || + mInstructions[i]->mOperator != ins.mOperator || + mInstructions[i]->mSTemp[0] != ins.mSTemp[0])) { i++; } - if (i < num) + if (i < mNum) { - ins.code = IC_LOAD_TEMPORARY; - ins.stemp[0] = instructions[i]->ttemp; - ins.stype[0] = instructions[i]->ttype; - ins.stemp[1] = -1; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + ins.mSTemp[0] = mInstructions[i]->mTTemp; + ins.mSType[0] = mInstructions[i]->mTType; + ins.mSTemp[1] = -1; + assert(ins.mSTemp[0] >= 0); } else { @@ -730,36 +730,36 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr } } } - else if (ins.oper == IA_FLOAT2INT) + else if (ins.mOperator == IA_FLOAT2INT) { } break; case IC_UNARY_OPERATOR: - switch (ins.stype[0]) + switch (ins.mSType[0]) { case IT_FLOAT: - if (ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_CONSTANT) + if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT) { - ins.code = IC_CONSTANT; - ins.fvalue = ConstantFolding(ins.oper, tvalue[ins.stemp[0]]->fvalue); - ins.stemp[0] = -1; + ins.mCode = IC_CONSTANT; + ins.mFloatValue = ConstantFolding(ins.mOperator, tvalue[ins.mSTemp[0]]->mFloatValue); + ins.mSTemp[0] = -1; i = 0; - while (i < num && - (instructions[i]->code != IC_CONSTANT || - instructions[i]->ttype != ins.ttype || - instructions[i]->fvalue != ins.fvalue)) + while (i < mNum && + (mInstructions[i]->mCode != IC_CONSTANT || + mInstructions[i]->mTType != ins.mTType || + mInstructions[i]->mFloatValue != ins.mFloatValue)) { i++; } - if (i < num) + if (i < mNum) { - ins.code = IC_LOAD_TEMPORARY; - ins.stemp[0] = instructions[i]->ttemp; - ins.stype[0] = instructions[i]->ttype; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + ins.mSTemp[0] = mInstructions[i]->mTTemp; + ins.mSType[0] = mInstructions[i]->mTType; + assert(ins.mSTemp[0] >= 0); } else { @@ -769,21 +769,21 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr else { i = 0; - while (i < num && - (instructions[i]->code != IC_UNARY_OPERATOR || - instructions[i]->oper != ins.oper || - instructions[i]->stemp[0] != ins.stemp[0])) + while (i < mNum && + (mInstructions[i]->mCode != IC_UNARY_OPERATOR || + mInstructions[i]->mOperator != ins.mOperator || + mInstructions[i]->mSTemp[0] != ins.mSTemp[0])) { i++; } - if (i < num) + if (i < mNum) { - ins.code = IC_LOAD_TEMPORARY; - ins.stemp[0] = instructions[i]->ttemp; - ins.stype[0] = instructions[i]->ttype; - ins.stemp[1] = -1; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + ins.mSTemp[0] = mInstructions[i]->mTTemp; + ins.mSType[0] = mInstructions[i]->mTType; + ins.mSTemp[1] = -1; + assert(ins.mSTemp[0] >= 0); } else { @@ -794,27 +794,27 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr case IT_POINTER: break; default: - if (ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_CONSTANT) + if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT) { - ins.code = IC_CONSTANT; - ins.ivalue = ConstantFolding(ins.oper, tvalue[ins.stemp[0]]->ivalue); - ins.stemp[0] = -1; + ins.mCode = IC_CONSTANT; + ins.mIntValue = ConstantFolding(ins.mOperator, tvalue[ins.mSTemp[0]]->mIntValue); + ins.mSTemp[0] = -1; i = 0; - while (i < num && - (instructions[i]->code != IC_CONSTANT || - instructions[i]->ttype != ins.ttype || - instructions[i]->ivalue != ins.ivalue)) + while (i < mNum && + (mInstructions[i]->mCode != IC_CONSTANT || + mInstructions[i]->mTType != ins.mTType || + mInstructions[i]->mIntValue != ins.mIntValue)) { i++; } - if (i < num) + if (i < mNum) { - ins.code = IC_LOAD_TEMPORARY; - ins.stemp[0] = instructions[i]->ttemp; - ins.stype[0] = instructions[i]->ttype; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + ins.mSTemp[0] = mInstructions[i]->mTTemp; + ins.mSType[0] = mInstructions[i]->mTType; + assert(ins.mSTemp[0] >= 0); } else { @@ -824,20 +824,20 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr else { i = 0; - while (i < num && - (instructions[i]->code != IC_UNARY_OPERATOR || - instructions[i]->oper != ins.oper || - instructions[i]->stemp[0] != ins.stemp[0])) + while (i < mNum && + (mInstructions[i]->mCode != IC_UNARY_OPERATOR || + mInstructions[i]->mOperator != ins.mOperator || + mInstructions[i]->mSTemp[0] != ins.mSTemp[0])) { i++; } - if (i < num) + if (i < mNum) { - ins.code = IC_LOAD_TEMPORARY; - ins.stemp[0] = instructions[i]->ttemp; - ins.stype[0] = instructions[i]->ttype; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + ins.mSTemp[0] = mInstructions[i]->mTTemp; + ins.mSType[0] = mInstructions[i]->mTType; + assert(ins.mSTemp[0] >= 0); } else { @@ -849,16 +849,16 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr break; case IC_RELATIONAL_OPERATOR: - switch (ins.stype[1]) + switch (ins.mSType[1]) { case IT_FLOAT: - if (ins.stemp[1] >= 0 && tvalue[ins.stemp[1]] && tvalue[ins.stemp[1]]->code == IC_CONSTANT && - ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_CONSTANT) + if (ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_CONSTANT && + ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT) { - ins.code = IC_CONSTANT; - ins.ivalue = ConstantRelationalFolding(ins.oper, tvalue[ins.stemp[1]]->fvalue, tvalue[ins.stemp[0]]->fvalue); - ins.stemp[0] = -1; - ins.stemp[1] = -1; + ins.mCode = IC_CONSTANT; + ins.mIntValue = ConstantRelationalFolding(ins.mOperator, tvalue[ins.mSTemp[1]]->mFloatValue, tvalue[ins.mSTemp[0]]->mFloatValue); + ins.mSTemp[0] = -1; + ins.mSTemp[1] = -1; UpdateValue(ins, tvalue, aliasedLocals); } @@ -866,39 +866,39 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr case IT_POINTER: break; default: - if (ins.stemp[1] >= 0 && tvalue[ins.stemp[1]] && tvalue[ins.stemp[1]]->code == IC_CONSTANT && - ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_CONSTANT) + if (ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_CONSTANT && + ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT) { - ins.code = IC_CONSTANT; - ins.ivalue = ConstantFolding(ins.oper, tvalue[ins.stemp[1]]->ivalue, tvalue[ins.stemp[0]]->ivalue); - ins.stemp[0] = -1; - ins.stemp[1] = -1; + ins.mCode = IC_CONSTANT; + ins.mIntValue = ConstantFolding(ins.mOperator, tvalue[ins.mSTemp[1]]->mIntValue, tvalue[ins.mSTemp[0]]->mIntValue); + ins.mSTemp[0] = -1; + ins.mSTemp[1] = -1; UpdateValue(ins, tvalue, aliasedLocals); } - else if (ins.stemp[1] == ins.stemp[0]) + else if (ins.mSTemp[1] == ins.mSTemp[0]) { - ins.code = IC_CONSTANT; + ins.mCode = IC_CONSTANT; - switch (ins.oper) + switch (ins.mOperator) { case IA_CMPEQ: case IA_CMPGES: case IA_CMPLES: case IA_CMPGEU: case IA_CMPLEU: - ins.ivalue = 1; + ins.mIntValue = 1; break; case IA_CMPNE: case IA_CMPGS: case IA_CMPLS: case IA_CMPGU: case IA_CMPLU: - ins.ivalue = 0; + ins.mIntValue = 0; break; } - ins.stemp[0] = -1; - ins.stemp[1] = -1; + ins.mSTemp[0] = -1; + ins.mSTemp[1] = -1; UpdateValue(ins, tvalue, aliasedLocals); } @@ -915,25 +915,23 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr InterInstruction::InterInstruction(void) { - code = IC_NONE; + mCode = IC_NONE; - ttype = IT_NONE; - stype[0] = IT_NONE; - stype[1] = IT_NONE; - stype[2] = IT_NONE; + mTType = IT_NONE; + mSType[0] = IT_NONE; + mSType[1] = IT_NONE; + mSType[2] = IT_NONE; - ttemp = INVALID_TEMPORARY; - stemp[0] = INVALID_TEMPORARY; - stemp[1] = INVALID_TEMPORARY; - stemp[2] = INVALID_TEMPORARY; - - exceptionJump = NULL; + mTTemp = INVALID_TEMPORARY; + mSTemp[0] = INVALID_TEMPORARY; + mSTemp[1] = INVALID_TEMPORARY; + mSTemp[2] = INVALID_TEMPORARY; } void InterInstruction::SetCode(const Location& loc, InterCode code) { - this->code = code; - this->loc = loc; + this->mCode = code; + this->mLocation = loc; } static bool TypeInteger(InterType t) @@ -991,27 +989,27 @@ static void FilterTempDefineUsage(NumberSet& requiredTemps, NumberSet& providedT void InterInstruction::CollectLocalAddressTemps(GrowingIntArray& localTable) { - if (code == IC_CONSTANT) + if (mCode == IC_CONSTANT) { - if (ttype == IT_POINTER && mem == IM_LOCAL) - localTable[ttemp] = vindex; + if (mTType == IT_POINTER && mMemory == IM_LOCAL) + localTable[mTTemp] = mVarIndex; } - else if (code == IC_LEA) + else if (mCode == IC_LEA) { - if (mem == IM_LOCAL) - localTable[ttemp] = localTable[stemp[1]]; + if (mMemory == IM_LOCAL) + localTable[mTTemp] = localTable[mSTemp[1]]; } - else if (code == IC_LOAD_TEMPORARY) + else if (mCode == IC_LOAD_TEMPORARY) { - localTable[ttemp] = localTable[stemp[0]]; + localTable[mTTemp] = localTable[mSTemp[0]]; } } void InterInstruction::MarkAliasedLocalTemps(const GrowingIntArray& localTable, NumberSet& aliasedLocals) { - if (code == IC_STORE) + if (mCode == IC_STORE) { - int l = localTable[stemp[0]]; + int l = localTable[mSTemp[0]]; if (l >= 0) aliasedLocals += l; } @@ -1019,26 +1017,26 @@ void InterInstruction::MarkAliasedLocalTemps(const GrowingIntArray& localTable, void InterInstruction::FilterTempUsage(NumberSet& requiredTemps, NumberSet& providedTemps) { - FilterTempUseUsage(requiredTemps, providedTemps, stemp[0]); - FilterTempUseUsage(requiredTemps, providedTemps, stemp[1]); - FilterTempUseUsage(requiredTemps, providedTemps, stemp[2]); - FilterTempDefineUsage(requiredTemps, providedTemps, ttemp); + FilterTempUseUsage(requiredTemps, providedTemps, mSTemp[0]); + FilterTempUseUsage(requiredTemps, providedTemps, mSTemp[1]); + FilterTempUseUsage(requiredTemps, providedTemps, mSTemp[2]); + FilterTempDefineUsage(requiredTemps, providedTemps, mTTemp); } void InterInstruction::FilterVarsUsage(const GrowingVariableArray& localVars, NumberSet& requiredVars, NumberSet& providedVars) { - if (code == IC_LOAD && mem == IM_LOCAL) + if (mCode == IC_LOAD && mMemory == IM_LOCAL) { - assert(stemp[0] < 0); - if (!providedVars[vindex]) - requiredVars += vindex; + assert(mSTemp[0] < 0); + if (!providedVars[mVarIndex]) + requiredVars += mVarIndex; } - else if (code == IC_STORE && mem == IM_LOCAL) + else if (mCode == IC_STORE && mMemory == IM_LOCAL) { - assert(stemp[1] < 0); - if (!providedVars[vindex] && (siconst[1] != 0 || opsize != localVars[vindex].mSize)) - requiredVars += vindex; - providedVars += vindex; + assert(mSTemp[1] < 0); + if (!providedVars[mVarIndex] && (mSIntConst[1] != 0 || mOperandSize != localVars[mVarIndex].mSize)) + requiredVars += mVarIndex; + providedVars += mVarIndex; } } @@ -1058,13 +1056,13 @@ static void PerformTempDefineForwarding(int temp, TempForwardingTable& forwardin void InterInstruction::PerformTempForwarding(TempForwardingTable& forwardingTable) { - PerformTempUseForwarding(stemp[0], forwardingTable); - PerformTempUseForwarding(stemp[1], forwardingTable); - PerformTempUseForwarding(stemp[2], forwardingTable); - PerformTempDefineForwarding(ttemp, forwardingTable); - if (code == IC_LOAD_TEMPORARY && ttemp != stemp[0]) + PerformTempUseForwarding(mSTemp[0], forwardingTable); + PerformTempUseForwarding(mSTemp[1], forwardingTable); + PerformTempUseForwarding(mSTemp[2], forwardingTable); + PerformTempDefineForwarding(mTTemp, forwardingTable); + if (mCode == IC_LOAD_TEMPORARY && mTTemp != mSTemp[0]) { - forwardingTable.Build(ttemp, stemp[0]); + forwardingTable.Build(mTTemp, mSTemp[0]); } } @@ -1077,51 +1075,51 @@ bool InterInstruction::RemoveUnusedResultInstructions(InterInstruction* pre, Num { bool changed = false; - if (pre && code == IC_LOAD_TEMPORARY && pre->ttemp == stemp[0] && !requiredTemps[stemp[0]] && pre->ttemp >= numStaticTemps) + if (pre && mCode == IC_LOAD_TEMPORARY && pre->mTTemp == mSTemp[0] && !requiredTemps[mSTemp[0]] && pre->mTTemp >= numStaticTemps) { // previous instruction produced result, but it is not needed here - pre->ttemp = ttemp; + pre->mTTemp = mTTemp; - code = IC_NONE; - ttemp = -1; - stemp[0] = -1; - stemp[1] = -1; - stemp[2] = -1; + mCode = IC_NONE; + mTTemp = -1; + mSTemp[0] = -1; + mSTemp[1] = -1; + mSTemp[2] = -1; changed = true; } - else if (ttemp != -1) + else if (mTTemp != -1) { - if (!requiredTemps[ttemp] && ttemp >= numStaticTemps) + if (!requiredTemps[mTTemp] && mTTemp >= numStaticTemps) { - if (!HasSideEffect(code)) + if (!HasSideEffect(mCode)) { - code = IC_NONE; - ttemp = -1; - stemp[0] = -1; - stemp[1] = -1; - stemp[2] = -1; + mCode = IC_NONE; + mTTemp = -1; + mSTemp[0] = -1; + mSTemp[1] = -1; + mSTemp[2] = -1; changed = true; } else { - ttemp = -1; + mTTemp = -1; changed = true; } } else - requiredTemps -= ttemp; + requiredTemps -= mTTemp; } - if (stemp[0] >= 0) sfinal[0] = !requiredTemps[stemp[0]] && stemp[0] >= numStaticTemps; - if (stemp[1] >= 0) sfinal[1] = !requiredTemps[stemp[1]] && stemp[1] >= numStaticTemps; - if (stemp[2] >= 0) sfinal[2] = !requiredTemps[stemp[2]] && stemp[2] >= numStaticTemps; + if (mSTemp[0] >= 0) mSFinal[0] = !requiredTemps[mSTemp[0]] && mSTemp[0] >= numStaticTemps; + if (mSTemp[1] >= 0) mSFinal[1] = !requiredTemps[mSTemp[1]] && mSTemp[1] >= numStaticTemps; + if (mSTemp[2] >= 0) mSFinal[2] = !requiredTemps[mSTemp[2]] && mSTemp[2] >= numStaticTemps; - if (stemp[0] >= 0) requiredTemps += stemp[0]; - if (stemp[1] >= 0) requiredTemps += stemp[1]; - if (stemp[2] >= 0) requiredTemps += stemp[2]; + if (mSTemp[0] >= 0) requiredTemps += mSTemp[0]; + if (mSTemp[1] >= 0) requiredTemps += mSTemp[1]; + if (mSTemp[2] >= 0) requiredTemps += mSTemp[2]; return changed; } @@ -1130,27 +1128,27 @@ bool InterInstruction::RemoveUnusedStoreInstructions(const GrowingVariableArray& { bool changed = false; - if (code == IC_LOAD) + if (mCode == IC_LOAD) { - if (mem == IM_LOCAL) + if (mMemory == IM_LOCAL) { - requiredTemps += vindex; + requiredTemps += mVarIndex; } } - else if (code == IC_STORE) + else if (mCode == IC_STORE) { - if (mem == IM_LOCAL) + if (mMemory == IM_LOCAL) { - if (localVars[vindex].mAliased) + if (localVars[mVarIndex].mAliased) ; - else if (requiredTemps[vindex]) + else if (requiredTemps[mVarIndex]) { - if (siconst[1] == 0 && opsize == localVars[vindex].mSize) - requiredTemps -= vindex; + if (mSIntConst[1] == 0 && mOperandSize == localVars[mVarIndex].mSize) + requiredTemps -= mVarIndex; } else { - code = IC_NONE; + mCode = IC_NONE; changed = true; } } @@ -1173,7 +1171,7 @@ static void DestroySourceValues(int temp, GrowingInstructionPtrArray& tvalue, Fa ins = tvalue[j]; - if (ins->stemp[0] == temp || ins->stemp[1] == temp || ins->stemp[2] == temp) + if (ins->mSTemp[0] == temp || ins->mSTemp[1] == temp || ins->mSTemp[2] == temp) { tvalue[j] = NULL; tvalid -= j; @@ -1186,49 +1184,49 @@ static void DestroySourceValues(int temp, GrowingInstructionPtrArray& tvalue, Fa void InterInstruction::PerformValueForwarding(GrowingInstructionPtrArray& tvalue, FastNumberSet& tvalid) { - DestroySourceValues(ttemp, tvalue, tvalid); + DestroySourceValues(mTTemp, tvalue, tvalid); - if (code == IC_LOAD_TEMPORARY) + if (mCode == IC_LOAD_TEMPORARY) { - if (tvalue[stemp[0]]) + if (tvalue[mSTemp[0]]) { - tvalue[ttemp] = tvalue[stemp[0]]; - tvalid += ttemp; + tvalue[mTTemp] = tvalue[mSTemp[0]]; + tvalid += mTTemp; } } else { - if (ttemp >= 0) + if (mTTemp >= 0) { - tvalue[ttemp] = this; - tvalid += ttemp; + tvalue[mTTemp] = this; + tvalid += mTTemp; } } } void InterInstruction::LocalRenameRegister(GrowingIntArray& renameTable, int& num, int fixed) { - if (stemp[0] >= 0) stemp[0] = renameTable[stemp[0]]; - if (stemp[1] >= 0) stemp[1] = renameTable[stemp[1]]; - if (stemp[2] >= 0) stemp[2] = renameTable[stemp[2]]; + if (mSTemp[0] >= 0) mSTemp[0] = renameTable[mSTemp[0]]; + if (mSTemp[1] >= 0) mSTemp[1] = renameTable[mSTemp[1]]; + if (mSTemp[2] >= 0) mSTemp[2] = renameTable[mSTemp[2]]; - if (ttemp >= fixed) + if (mTTemp >= fixed) { - renameTable[ttemp] = num; - ttemp = num++; + renameTable[mTTemp] = num; + mTTemp = num++; } } void InterInstruction::GlobalRenameRegister(const GrowingIntArray& renameTable, GrowingTypeArray& temporaries) { - if (stemp[0] >= 0) stemp[0] = renameTable[stemp[0]]; - if (stemp[1] >= 0) stemp[1] = renameTable[stemp[1]]; - if (stemp[2] >= 0) stemp[2] = renameTable[stemp[2]]; + if (mSTemp[0] >= 0) mSTemp[0] = renameTable[mSTemp[0]]; + if (mSTemp[1] >= 0) mSTemp[1] = renameTable[mSTemp[1]]; + if (mSTemp[2] >= 0) mSTemp[2] = renameTable[mSTemp[2]]; - if (ttemp >= 0) + if (mTTemp >= 0) { - ttemp = renameTable[ttemp]; - temporaries[ttemp] = ttype; + mTTemp = renameTable[mTTemp]; + temporaries[mTTemp] = mTType; } } @@ -1253,128 +1251,117 @@ static void UpdateCollisionSet(NumberSet& liveTemps, NumberSet* collisionSets, i void InterInstruction::BuildCollisionTable(NumberSet& liveTemps, NumberSet* collisionSets) { - if (ttemp >= 0) + if (mTTemp >= 0) { // if (!liveTemps[ttemp]) __asm int 3 - liveTemps -= ttemp; + liveTemps -= mTTemp; } - UpdateCollisionSet(liveTemps, collisionSets, stemp[0]); - UpdateCollisionSet(liveTemps, collisionSets, stemp[1]); - UpdateCollisionSet(liveTemps, collisionSets, stemp[2]); - - if (exceptionJump) - { - int i; - - for (i = 0; i < exceptionJump->entryRequiredTemps.Size(); i++) - { - if (exceptionJump->entryRequiredTemps[i]) - UpdateCollisionSet(liveTemps, collisionSets, i); - } - } + UpdateCollisionSet(liveTemps, collisionSets, mSTemp[0]); + UpdateCollisionSet(liveTemps, collisionSets, mSTemp[1]); + UpdateCollisionSet(liveTemps, collisionSets, mSTemp[2]); } void InterInstruction::ReduceTemporaries(const GrowingIntArray& renameTable, GrowingTypeArray& temporaries) { - if (stemp[0] >= 0) stemp[0] = renameTable[stemp[0]]; - if (stemp[1] >= 0) stemp[1] = renameTable[stemp[1]]; - if (stemp[2] >= 0) stemp[2] = renameTable[stemp[2]]; + if (mSTemp[0] >= 0) mSTemp[0] = renameTable[mSTemp[0]]; + if (mSTemp[1] >= 0) mSTemp[1] = renameTable[mSTemp[1]]; + if (mSTemp[2] >= 0) mSTemp[2] = renameTable[mSTemp[2]]; - if (ttemp >= 0) + if (mTTemp >= 0) { - ttemp = renameTable[ttemp]; - temporaries[ttemp] = ttype; + mTTemp = renameTable[mTTemp]; + temporaries[mTTemp] = mTType; } } void InterInstruction::CollectActiveTemporaries(FastNumberSet& set) { - if (ttemp >= 0) set += ttemp; - if (stemp[0] >= 0) set += stemp[0]; - if (stemp[1] >= 0) set += stemp[1]; - if (stemp[2] >= 0) set += stemp[2]; + if (mTTemp >= 0) set += mTTemp; + if (mSTemp[0] >= 0) set += mSTemp[0]; + if (mSTemp[1] >= 0) set += mSTemp[1]; + if (mSTemp[2] >= 0) set += mSTemp[2]; } void InterInstruction::ShrinkActiveTemporaries(FastNumberSet& set, GrowingTypeArray& temporaries) { - if (ttemp >= 0) + if (mTTemp >= 0) { - ttemp = set.Index(ttemp); - temporaries[ttemp] = ttype; + mTTemp = set.Index(mTTemp); + temporaries[mTTemp] = mTType; } - if (stemp[0] >= 0) stemp[0] = set.Index(stemp[0]); - if (stemp[1] >= 0) stemp[1] = set.Index(stemp[1]); - if (stemp[2] >= 0) stemp[2] = set.Index(stemp[2]); + if (mSTemp[0] >= 0) mSTemp[0] = set.Index(mSTemp[0]); + if (mSTemp[1] >= 0) mSTemp[1] = set.Index(mSTemp[1]); + if (mSTemp[2] >= 0) mSTemp[2] = set.Index(mSTemp[2]); } void InterInstruction::CollectSimpleLocals(FastNumberSet& complexLocals, FastNumberSet& simpleLocals, GrowingTypeArray& localTypes) { - switch (code) + switch (mCode) { case IC_LOAD: - if (mem == IM_LOCAL && stemp[0] < 0) + if (mMemory == IM_LOCAL && mSTemp[0] < 0) { - localTypes[vindex] = ttype; - if (opsize == 2) - simpleLocals += vindex; + localTypes[mVarIndex] = mTType; + if (mOperandSize == 2) + simpleLocals += mVarIndex; else - complexLocals += vindex; + complexLocals += mVarIndex; } break; case IC_STORE: - if (mem == IM_LOCAL && stemp[1] < 0) + if (mMemory == IM_LOCAL && mSTemp[1] < 0) { - localTypes[vindex] = stype[0]; - if (opsize == 2) - simpleLocals += vindex; + localTypes[mVarIndex] = mSType[0]; + if (mOperandSize == 2) + simpleLocals += mVarIndex; else - complexLocals += vindex; + complexLocals += mVarIndex; } break; case IC_LEA: - if (mem == IM_LOCAL && stemp[1] < 0) - complexLocals += vindex; + if (mMemory == IM_LOCAL && mSTemp[1] < 0) + complexLocals += mVarIndex; break; case IC_CONSTANT: - if (ttype == IT_POINTER && mem == IM_LOCAL) - complexLocals += vindex; + if (mTType == IT_POINTER && mMemory == IM_LOCAL) + complexLocals += mVarIndex; break; } } void InterInstruction::SimpleLocalToTemp(int vindex, int temp) { - switch (code) + switch (mCode) { case IC_LOAD: - if (mem == IM_LOCAL && stemp[0] < 0 && vindex == this->vindex) + if (mMemory == IM_LOCAL && mSTemp[0] < 0 && vindex == this->mVarIndex) { - code = IC_LOAD_TEMPORARY; - stemp[0] = temp; - stype[0] = ttype; + mCode = IC_LOAD_TEMPORARY; + mSTemp[0] = temp; + mSType[0] = mTType; - assert(stemp[0] >= 0); + assert(mSTemp[0] >= 0); } break; case IC_STORE: - if (mem == IM_LOCAL && stemp[1] < 0 && vindex == this->vindex) + if (mMemory == IM_LOCAL && mSTemp[1] < 0 && vindex == this->mVarIndex) { - if (stemp[0] < 0) + if (mSTemp[0] < 0) { - code = IC_CONSTANT; - ivalue = siconst[0]; + mCode = IC_CONSTANT; + mIntValue = mSIntConst[0]; } else { - code = IC_LOAD_TEMPORARY; - assert(stemp[0] >= 0); + mCode = IC_LOAD_TEMPORARY; + assert(mSTemp[0] >= 0); } - ttemp = temp; - ttype = stype[0]; + mTTemp = temp; + mTType = mSType[0]; } break; } @@ -1382,12 +1369,12 @@ void InterInstruction::SimpleLocalToTemp(int vindex, int temp) void InterInstruction::Disassemble(FILE* file) { - if (this->code != IC_NONE) + if (this->mCode != IC_NONE) { static char memchars[] = "NPLGFPITA"; fprintf(file, "\t"); - switch (this->code) + switch (this->mCode) { case IC_LOAD_TEMPORARY: case IC_STORE_TEMPORARY: @@ -1406,16 +1393,16 @@ void InterInstruction::Disassemble(FILE* file) fprintf(file, "CONV"); break; case IC_STORE: - fprintf(file, "STORE%c%d", memchars[mem], opsize); + fprintf(file, "STORE%c%d", memchars[mMemory], mOperandSize); break; case IC_LOAD: - fprintf(file, "LOAD%c%d", memchars[mem], opsize); + fprintf(file, "LOAD%c%d", memchars[mMemory], mOperandSize); break; case IC_COPY: - fprintf(file, "COPY%c", memchars[mem]); + fprintf(file, "COPY%c", memchars[mMemory]); break; case IC_LEA: - fprintf(file, "LEA%c", memchars[mem]); + fprintf(file, "LEA%c", memchars[mMemory]); break; case IC_TYPECAST: fprintf(file, "CAST"); @@ -1430,10 +1417,10 @@ void InterInstruction::Disassemble(FILE* file) fprintf(file, "JUMP"); break; case IC_PUSH_FRAME: - fprintf(file, "PUSHF\t%d", int(ivalue)); + fprintf(file, "PUSHF\t%d", int(mIntValue)); break; case IC_POP_FRAME: - fprintf(file, "POPF\t%d", int(ivalue)); + fprintf(file, "POPF\t%d", int(mIntValue)); break; case IC_CALL: fprintf(file, "CALL"); @@ -1454,23 +1441,19 @@ void InterInstruction::Disassemble(FILE* file) static char typechars[] = "NUSFPB"; fprintf(file, "\t"); - if (ttemp >= 0) fprintf(file, "R%d(%c)", ttemp, typechars[ttype]); + if (mTTemp >= 0) fprintf(file, "R%d(%c)", mTTemp, typechars[mTType]); fprintf(file, "\t<-\t"); - if (stemp[2] >= 0) fprintf(file, "R%d(%c%c), ", stemp[2], typechars[stype[2]], sfinal[2] ? 'F' : '-'); - if (stemp[1] >= 0) fprintf(file, "R%d(%c%c), ", stemp[1], typechars[stype[1]], sfinal[1] ? 'F' : '-'); - if (stemp[0] >= 0) fprintf(file, "R%d(%c%c)", stemp[0], typechars[stype[0]], sfinal[0] ? 'F' : '-'); - if (this->code == IC_CONSTANT) + if (mSTemp[2] >= 0) fprintf(file, "R%d(%c%c), ", mSTemp[2], typechars[mSType[2]], mSFinal[2] ? 'F' : '-'); + if (mSTemp[1] >= 0) fprintf(file, "R%d(%c%c), ", mSTemp[1], typechars[mSType[1]], mSFinal[1] ? 'F' : '-'); + if (mSTemp[0] >= 0) fprintf(file, "R%d(%c%c)", mSTemp[0], typechars[mSType[0]], mSFinal[0] ? 'F' : '-'); + if (this->mCode == IC_CONSTANT) { - if (ttype == IT_POINTER) - fprintf(file, "C%d", opsize); - else if (ttype == IT_FLOAT) - fprintf(file, "C%f", fvalue); + if (mTType == IT_POINTER) + fprintf(file, "C%d", mOperandSize); + else if (mTType == IT_FLOAT) + fprintf(file, "C%f", mFloatValue); else - fprintf(file, "C%I64d", ivalue); - } - if (this->exceptionJump) - { - fprintf(file, " EX: %d", this->exceptionJump->num); + fprintf(file, "C%I64d", mIntValue); } fprintf(file, "\n"); @@ -1478,7 +1461,7 @@ void InterInstruction::Disassemble(FILE* file) } InterCodeBasicBlock::InterCodeBasicBlock(void) - : code(InterInstruction()), entryRenameTable(-1), exitRenameTable(-1) + : mInstructions(InterInstruction()), mEntryRenameTable(-1), mExitRenameTable(-1) { } @@ -1489,26 +1472,26 @@ InterCodeBasicBlock::~InterCodeBasicBlock(void) void InterCodeBasicBlock::Append(InterInstruction & code) { - this->code.Push(code); + this->mInstructions.Push(code); } void InterCodeBasicBlock::Close(InterCodeBasicBlock* trueJump, InterCodeBasicBlock* falseJump) { - this->trueJump = trueJump; - this->falseJump = falseJump; - this->numEntries = 0; + this->mTrueJump = trueJump; + this->mFalseJump = falseJump; + this->mNumEntries = 0; } void InterCodeBasicBlock::CollectEntries(void) { - numEntries++; - if (!visited) + mNumEntries++; + if (!mVisited) { - visited = true; + mVisited = true; - if (trueJump) trueJump->CollectEntries(); - if (falseJump) falseJump->CollectEntries(); + if (mTrueJump) mTrueJump->CollectEntries(); + if (mFalseJump) mFalseJump->CollectEntries(); } } @@ -1516,48 +1499,48 @@ void InterCodeBasicBlock::GenerateTraces(void) { int i; - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; for (;;) { - if (trueJump && trueJump->code.Size() == 1 && trueJump->code[0].code == IC_JUMP) + if (mTrueJump && mTrueJump->mInstructions.Size() == 1 && mTrueJump->mInstructions[0].mCode == IC_JUMP) { - trueJump->numEntries--; - trueJump = trueJump->trueJump; - if (trueJump) - trueJump->numEntries++; + mTrueJump->mNumEntries--; + mTrueJump = mTrueJump->mTrueJump; + if (mTrueJump) + mTrueJump->mNumEntries++; } - else if (falseJump && falseJump->code.Size() == 1 && falseJump->code[0].code == IC_JUMP) + else if (mFalseJump && mFalseJump->mInstructions.Size() == 1 && mFalseJump->mInstructions[0].mCode == IC_JUMP) { - falseJump->numEntries--; - falseJump = falseJump->trueJump; - if (falseJump) - falseJump->numEntries++; + mFalseJump->mNumEntries--; + mFalseJump = mFalseJump->mTrueJump; + if (mFalseJump) + mFalseJump->mNumEntries++; } - else if (trueJump && !falseJump && ((trueJump->code.Size() < 10 && trueJump->code.Size() > 1) || trueJump->numEntries == 1)) + else if (mTrueJump && !mFalseJump && ((mTrueJump->mInstructions.Size() < 10 && mTrueJump->mInstructions.Size() > 1) || mTrueJump->mNumEntries == 1)) { - trueJump->numEntries--; + mTrueJump->mNumEntries--; - code.Pop(); - for (i = 0; i < trueJump->code.Size(); i++) - code.Push(trueJump->code[i]); + mInstructions.Pop(); + for (i = 0; i < mTrueJump->mInstructions.Size(); i++) + mInstructions.Push(mTrueJump->mInstructions[i]); - falseJump = trueJump->falseJump; - trueJump = trueJump->trueJump; + mFalseJump = mTrueJump->mFalseJump; + mTrueJump = mTrueJump->mTrueJump; - if (trueJump) - trueJump->numEntries++; - if (falseJump) - falseJump->numEntries++; + if (mTrueJump) + mTrueJump->mNumEntries++; + if (mFalseJump) + mFalseJump->mNumEntries++; } else break; } - if (trueJump) trueJump->GenerateTraces(); - if (falseJump) falseJump->GenerateTraces(); + if (mTrueJump) mTrueJump->GenerateTraces(); + if (mFalseJump) mFalseJump->GenerateTraces(); } } @@ -1584,16 +1567,16 @@ static bool IsSimpleAddressMultiply(int val) static void OptimizeAddress(InterInstruction& ins, const GrowingInstructionPtrArray& tvalue, int offset) { - ins.siconst[offset] = 0; + ins.mSIntConst[offset] = 0; - if (ins.stemp[offset] >= 0 && tvalue[ins.stemp[offset]]) + if (ins.mSTemp[offset] >= 0 && tvalue[ins.mSTemp[offset]]) { - if (tvalue[ins.stemp[offset]]->code == IC_CONSTANT) + if (tvalue[ins.mSTemp[offset]]->mCode == IC_CONSTANT) { - ins.siconst[offset] = tvalue[ins.stemp[offset]]->ivalue; - ins.vindex = tvalue[ins.stemp[offset]]->vindex; - ins.mem = tvalue[ins.stemp[offset]]->mem; - ins.stemp[offset] = -1; + ins.mSIntConst[offset] = tvalue[ins.mSTemp[offset]]->mIntValue; + ins.mVarIndex = tvalue[ins.mSTemp[offset]]->mVarIndex; + ins.mMemory = tvalue[ins.mSTemp[offset]]->mMemory; + ins.mSTemp[offset] = -1; } } } @@ -1601,41 +1584,41 @@ static void OptimizeAddress(InterInstruction& ins, const GrowingInstructionPtrAr void InterCodeBasicBlock::CheckValueUsage(InterInstruction& ins, const GrowingInstructionPtrArray& tvalue) { - switch (ins.code) + switch (ins.mCode) { case IC_CALL: case IC_JSR: - if (ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_CONSTANT) + if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT) { - ins.mem = tvalue[ins.stemp[0]]->mem; - ins.vindex = tvalue[ins.stemp[0]]->vindex; - ins.opsize = tvalue[ins.stemp[0]]->opsize; - ins.stemp[0] = -1; + ins.mMemory = tvalue[ins.mSTemp[0]]->mMemory; + ins.mVarIndex = tvalue[ins.mSTemp[0]]->mVarIndex; + ins.mOperandSize = tvalue[ins.mSTemp[0]]->mOperandSize; + ins.mSTemp[0] = -1; } break; case IC_LOAD_TEMPORARY: - if (ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_CONSTANT) + if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT) { - switch (ins.stype[0]) + switch (ins.mSType[0]) { case IT_FLOAT: - ins.code = IC_CONSTANT; - ins.fvalue = tvalue[ins.stemp[0]]->fvalue; - ins.stemp[0] = -1; + ins.mCode = IC_CONSTANT; + ins.mFloatValue = tvalue[ins.mSTemp[0]]->mFloatValue; + ins.mSTemp[0] = -1; break; case IT_POINTER: - ins.code = IC_CONSTANT; - ins.mem = tvalue[ins.stemp[0]]->mem; - ins.vindex = tvalue[ins.stemp[0]]->vindex; - ins.ivalue = tvalue[ins.stemp[0]]->ivalue; - ins.opsize = tvalue[ins.stemp[0]]->opsize; - ins.stemp[0] = -1; + ins.mCode = IC_CONSTANT; + ins.mMemory = tvalue[ins.mSTemp[0]]->mMemory; + ins.mVarIndex = tvalue[ins.mSTemp[0]]->mVarIndex; + ins.mIntValue = tvalue[ins.mSTemp[0]]->mIntValue; + ins.mOperandSize = tvalue[ins.mSTemp[0]]->mOperandSize; + ins.mSTemp[0] = -1; break; default: - ins.code = IC_CONSTANT; - ins.ivalue = tvalue[ins.stemp[0]]->ivalue; - ins.stemp[0] = -1; + ins.mCode = IC_CONSTANT; + ins.mIntValue = tvalue[ins.mSTemp[0]]->mIntValue; + ins.mSTemp[0] = -1; break; } } @@ -1645,159 +1628,159 @@ void InterCodeBasicBlock::CheckValueUsage(InterInstruction& ins, const GrowingIn OptimizeAddress(ins, tvalue, 0); break; case IC_STORE: - if (ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_CONSTANT) + if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT) { - switch (ins.stype[0]) + switch (ins.mSType[0]) { case IT_FLOAT: break; case IT_POINTER: break; default: - if (ins.stype[0] == IT_UNSIGNED) - ins.siconst[0] = unsigned short (tvalue[ins.stemp[0]]->ivalue); + if (ins.mSType[0] == IT_UNSIGNED) + ins.mSIntConst[0] = unsigned short (tvalue[ins.mSTemp[0]]->mIntValue); else - ins.siconst[0] = tvalue[ins.stemp[0]]->ivalue; - ins.stemp[0] = -1; + ins.mSIntConst[0] = tvalue[ins.mSTemp[0]]->mIntValue; + ins.mSTemp[0] = -1; break; } } OptimizeAddress(ins, tvalue, 1); break; case IC_LEA: - if (ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_CONSTANT) + if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT) { - if (ins.stemp[1] >= 0 && tvalue[ins.stemp[1]] && tvalue[ins.stemp[1]]->code == IC_CONSTANT) + if (ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_CONSTANT) { - ins.code = IC_CONSTANT; - ins.ttype = IT_POINTER; - ins.mem = tvalue[ins.stemp[1]]->mem; - ins.vindex = tvalue[ins.stemp[1]]->vindex; - ins.ivalue = tvalue[ins.stemp[1]]->ivalue + tvalue[ins.stemp[0]]->ivalue; - ins.stemp[0] = -1; - ins.stemp[1] = -1; + ins.mCode = IC_CONSTANT; + ins.mTType = IT_POINTER; + ins.mMemory = tvalue[ins.mSTemp[1]]->mMemory; + ins.mVarIndex = tvalue[ins.mSTemp[1]]->mVarIndex; + ins.mIntValue = tvalue[ins.mSTemp[1]]->mIntValue + tvalue[ins.mSTemp[0]]->mIntValue; + ins.mSTemp[0] = -1; + ins.mSTemp[1] = -1; } - else if (tvalue[ins.stemp[0]]->ivalue == 0) + else if (tvalue[ins.mSTemp[0]]->mIntValue == 0) { - ins.code = IC_LOAD_TEMPORARY; - ins.stype[0] = ins.stype[1]; - ins.stemp[0] = ins.stemp[1]; - ins.stemp[1] = -1; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + ins.mSType[0] = ins.mSType[1]; + ins.mSTemp[0] = ins.mSTemp[1]; + ins.mSTemp[1] = -1; + assert(ins.mSTemp[0] >= 0); } } break; case IC_TYPECAST: - if (ins.stype[0] == ins.ttype) + if (ins.mSType[0] == ins.mTType) { - ins.code = IC_LOAD_TEMPORARY; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + assert(ins.mSTemp[0] >= 0); } - else if ((ins.stype[0] == IT_SIGNED || ins.stype[0] == IT_UNSIGNED) && ins.ttype == IT_POINTER) + else if ((ins.mSType[0] == IT_SIGNED || ins.mSType[0] == IT_UNSIGNED) && ins.mTType == IT_POINTER) { - if (ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_CONSTANT) + if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT) { - ins.code = IC_CONSTANT; - ins.ttype = IT_POINTER; - ins.mem = IM_ABSOLUTE; - ins.vindex = 0; - ins.ivalue = tvalue[ins.stemp[0]]->ivalue; - ins.stemp[0] = -1; + ins.mCode = IC_CONSTANT; + ins.mTType = IT_POINTER; + ins.mMemory = IM_ABSOLUTE; + ins.mVarIndex = 0; + ins.mIntValue = tvalue[ins.mSTemp[0]]->mIntValue; + ins.mSTemp[0] = -1; } } break; case IC_RETURN_VALUE: - if (ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_CONSTANT) + if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT) { - switch (ins.stype[0]) + switch (ins.mSType[0]) { case IT_FLOAT: break; case IT_POINTER: break; default: - if (ins.stype[0] == IT_UNSIGNED) - ins.siconst[0] = unsigned short(tvalue[ins.stemp[0]]->ivalue); + if (ins.mSType[0] == IT_UNSIGNED) + ins.mSIntConst[0] = unsigned short(tvalue[ins.mSTemp[0]]->mIntValue); else - ins.siconst[0] = tvalue[ins.stemp[0]]->ivalue; - ins.stemp[0] = -1; + ins.mSIntConst[0] = tvalue[ins.mSTemp[0]]->mIntValue; + ins.mSTemp[0] = -1; break; } } break; case IC_BINARY_OPERATOR: - switch (ins.stype[0]) + switch (ins.mSType[0]) { case IT_FLOAT: - if (ins.stemp[1] >= 0 && tvalue[ins.stemp[1]] && tvalue[ins.stemp[1]]->code == IC_CONSTANT) + if (ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_CONSTANT) { - if (ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_CONSTANT) + if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT) { - ins.code = IC_CONSTANT; - ins.ivalue = ConstantFolding(ins.oper, tvalue[ins.stemp[1]]->fvalue, tvalue[ins.stemp[0]]->fvalue); - ins.stemp[0] = -1; - ins.stemp[1] = -1; + ins.mCode = IC_CONSTANT; + ins.mIntValue = ConstantFolding(ins.mOperator, tvalue[ins.mSTemp[1]]->mFloatValue, tvalue[ins.mSTemp[0]]->mFloatValue); + ins.mSTemp[0] = -1; + ins.mSTemp[1] = -1; } else { - if (ins.oper == IA_ADD && tvalue[ins.stemp[1]]->fvalue == 0) + if (ins.mOperator == IA_ADD && tvalue[ins.mSTemp[1]]->mFloatValue == 0) { - ins.code = IC_LOAD_TEMPORARY; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + assert(ins.mSTemp[0] >= 0); } - else if (ins.oper == IA_MUL) + else if (ins.mOperator == IA_MUL) { - if (tvalue[ins.stemp[1]]->fvalue == 1.0) + if (tvalue[ins.mSTemp[1]]->mFloatValue == 1.0) { - ins.code = IC_LOAD_TEMPORARY; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + assert(ins.mSTemp[0] >= 0); } - else if (tvalue[ins.stemp[1]]->fvalue == 0.0) + else if (tvalue[ins.mSTemp[1]]->mFloatValue == 0.0) { - ins.code = IC_CONSTANT; - ins.fvalue = 0.0; - ins.stemp[0] = -1; - ins.stemp[1] = -1; + ins.mCode = IC_CONSTANT; + ins.mFloatValue = 0.0; + ins.mSTemp[0] = -1; + ins.mSTemp[1] = -1; } - else if (tvalue[ins.stemp[1]]->fvalue == 2.0) + else if (tvalue[ins.mSTemp[1]]->mFloatValue == 2.0) { - ins.oper = IA_ADD; - ins.stemp[1] = ins.stemp[0]; - assert(ins.stemp[0] >= 0); + ins.mOperator = IA_ADD; + ins.mSTemp[1] = ins.mSTemp[0]; + assert(ins.mSTemp[0] >= 0); } } } } - else if (ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_CONSTANT) + else if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT) { - if (ins.oper == IA_ADD && tvalue[ins.stemp[0]]->fvalue == 0) + if (ins.mOperator == IA_ADD && tvalue[ins.mSTemp[0]]->mFloatValue == 0) { - ins.code = IC_LOAD_TEMPORARY; - ins.stemp[0] = ins.stemp[1]; - ins.stemp[1] = -1; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + ins.mSTemp[0] = ins.mSTemp[1]; + ins.mSTemp[1] = -1; + assert(ins.mSTemp[0] >= 0); } - else if (ins.oper == IA_MUL) + else if (ins.mOperator == IA_MUL) { - if (tvalue[ins.stemp[0]]->fvalue == 1.0) + if (tvalue[ins.mSTemp[0]]->mFloatValue == 1.0) { - ins.code = IC_LOAD_TEMPORARY; - ins.stemp[0] = ins.stemp[1]; - ins.stemp[1] = -1; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + ins.mSTemp[0] = ins.mSTemp[1]; + ins.mSTemp[1] = -1; + assert(ins.mSTemp[0] >= 0); } - else if (tvalue[ins.stemp[0]]->fvalue == 0.0) + else if (tvalue[ins.mSTemp[0]]->mFloatValue == 0.0) { - ins.code = IC_CONSTANT; - ins.fvalue = 0.0; - ins.stemp[0] = -1; - ins.stemp[1] = -1; + ins.mCode = IC_CONSTANT; + ins.mFloatValue = 0.0; + ins.mSTemp[0] = -1; + ins.mSTemp[1] = -1; } - else if (tvalue[ins.stemp[0]]->fvalue == 2.0) + else if (tvalue[ins.mSTemp[0]]->mFloatValue == 2.0) { - ins.oper = IA_ADD; - ins.stemp[0] = ins.stemp[1]; - assert(ins.stemp[0] >= 0); + ins.mOperator = IA_ADD; + ins.mSTemp[0] = ins.mSTemp[1]; + assert(ins.mSTemp[0] >= 0); } } } @@ -1805,139 +1788,139 @@ void InterCodeBasicBlock::CheckValueUsage(InterInstruction& ins, const GrowingIn case IT_POINTER: break; default: - if (ins.stemp[1] >= 0 && tvalue[ins.stemp[1]] && tvalue[ins.stemp[1]]->code == IC_CONSTANT) + if (ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_CONSTANT) { - if (ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_CONSTANT) + if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT) { - ins.code = IC_CONSTANT; - ins.ivalue = ConstantFolding(ins.oper, tvalue[ins.stemp[1]]->ivalue, tvalue[ins.stemp[0]]->ivalue); - ins.stemp[0] = -1; - ins.stemp[1] = -1; + ins.mCode = IC_CONSTANT; + ins.mIntValue = ConstantFolding(ins.mOperator, tvalue[ins.mSTemp[1]]->mIntValue, tvalue[ins.mSTemp[0]]->mIntValue); + ins.mSTemp[0] = -1; + ins.mSTemp[1] = -1; } else { - ins.siconst[1] = tvalue[ins.stemp[1]]->ivalue; - ins.stemp[1] = -1; + ins.mSIntConst[1] = tvalue[ins.mSTemp[1]]->mIntValue; + ins.mSTemp[1] = -1; #if 1 - if (ins.oper == IA_ADD && ins.siconst[1] == 0) + if (ins.mOperator == IA_ADD && ins.mSIntConst[1] == 0) { - ins.code = IC_LOAD_TEMPORARY; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + assert(ins.mSTemp[0] >= 0); } - else if (ins.oper == IA_MUL) + else if (ins.mOperator == IA_MUL) { - if (ins.siconst[1] == 1) + if (ins.mSIntConst[1] == 1) { - ins.code = IC_LOAD_TEMPORARY; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + assert(ins.mSTemp[0] >= 0); } - else if (ins.siconst[1] == 2) + else if (ins.mSIntConst[1] == 2) { - ins.oper = IA_SHL; -ins.stemp[1] = ins.stemp[0]; -ins.stype[1] = ins.stype[0]; -ins.stemp[0] = -1; -ins.siconst[0] = 1; + ins.mOperator = IA_SHL; + ins.mSTemp[1] = ins.mSTemp[0]; + ins.mSType[1] = ins.mSType[0]; + ins.mSTemp[0] = -1; + ins.mSIntConst[0] = 1; } - else if (ins.siconst[1] == 4) + else if (ins.mSIntConst[1] == 4) { - ins.oper = IA_SHL; - ins.stemp[1] = ins.stemp[0]; - ins.stype[1] = ins.stype[0]; - ins.stemp[0] = -1; - ins.siconst[0] = 2; + ins.mOperator = IA_SHL; + ins.mSTemp[1] = ins.mSTemp[0]; + ins.mSType[1] = ins.mSType[0]; + ins.mSTemp[0] = -1; + ins.mSIntConst[0] = 2; } - else if (ins.siconst[1] == 8) + else if (ins.mSIntConst[1] == 8) { - ins.oper = IA_SHL; - ins.stemp[1] = ins.stemp[0]; - ins.stype[1] = ins.stype[0]; - ins.stemp[0] = -1; - ins.siconst[0] = 3; + ins.mOperator = IA_SHL; + ins.mSTemp[1] = ins.mSTemp[0]; + ins.mSType[1] = ins.mSType[0]; + ins.mSTemp[0] = -1; + ins.mSIntConst[0] = 3; } } #endif } } - else if (ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_CONSTANT) + else if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT) { - ins.siconst[0] = tvalue[ins.stemp[0]]->ivalue; - ins.stemp[0] = -1; + ins.mSIntConst[0] = tvalue[ins.mSTemp[0]]->mIntValue; + ins.mSTemp[0] = -1; #if 1 - if (ins.oper == IA_ADD && ins.siconst[0] == 0) + if (ins.mOperator == IA_ADD && ins.mSIntConst[0] == 0) { - ins.code = IC_LOAD_TEMPORARY; - ins.stemp[0] = ins.stemp[1]; - ins.stemp[1] = -1; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + ins.mSTemp[0] = ins.mSTemp[1]; + ins.mSTemp[1] = -1; + assert(ins.mSTemp[0] >= 0); } - else if (ins.oper == IA_MUL) + else if (ins.mOperator == IA_MUL) { - if (ins.siconst[0] == 1) + if (ins.mSIntConst[0] == 1) { - ins.code = IC_LOAD_TEMPORARY; - ins.stemp[0] = ins.stemp[1]; - ins.stemp[1] = -1; - assert(ins.stemp[0] >= 0); + ins.mCode = IC_LOAD_TEMPORARY; + ins.mSTemp[0] = ins.mSTemp[1]; + ins.mSTemp[1] = -1; + assert(ins.mSTemp[0] >= 0); } - else if (ins.siconst[0] == 2) + else if (ins.mSIntConst[0] == 2) { - ins.oper = IA_SHL; - ins.siconst[0] = 1; + ins.mOperator = IA_SHL; + ins.mSIntConst[0] = 1; } - else if (ins.siconst[0] == 4) + else if (ins.mSIntConst[0] == 4) { - ins.oper = IA_SHL; - ins.siconst[0] = 2; + ins.mOperator = IA_SHL; + ins.mSIntConst[0] = 2; } - else if (ins.siconst[0] == 8) + else if (ins.mSIntConst[0] == 8) { - ins.oper = IA_SHL; - ins.siconst[0] = 3; + ins.mOperator = IA_SHL; + ins.mSIntConst[0] = 3; } } #endif } - if (ins.stemp[1] < 0 && ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_BINARY_OPERATOR) + if (ins.mSTemp[1] < 0 && ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_BINARY_OPERATOR) { - InterInstruction* pins = tvalue[ins.stemp[0]]; - if (ins.oper == pins->oper && (ins.oper == IA_ADD || ins.oper == IA_MUL || ins.oper == IA_AND || ins.oper == IA_OR)) + InterInstruction* pins = tvalue[ins.mSTemp[0]]; + if (ins.mOperator == pins->mOperator && (ins.mOperator == IA_ADD || ins.mOperator == IA_MUL || ins.mOperator == IA_AND || ins.mOperator == IA_OR)) { - if (pins->stemp[1] < 0) + if (pins->mSTemp[1] < 0) { - ins.siconst[1] = ConstantFolding(ins.oper, ins.siconst[1], pins->siconst[1]); - ins.stemp[0] = pins->stemp[0]; + ins.mSIntConst[1] = ConstantFolding(ins.mOperator, ins.mSIntConst[1], pins->mSIntConst[1]); + ins.mSTemp[0] = pins->mSTemp[0]; } - else if (pins->stemp[0] < 0) + else if (pins->mSTemp[0] < 0) { - ins.siconst[1] = ConstantFolding(ins.oper, ins.siconst[1], pins->siconst[0]); - ins.stemp[0] = pins->stemp[1]; + ins.mSIntConst[1] = ConstantFolding(ins.mOperator, ins.mSIntConst[1], pins->mSIntConst[0]); + ins.mSTemp[0] = pins->mSTemp[1]; } } } - else if (ins.stemp[0] < 0 && ins.stemp[1] >= 0 && tvalue[ins.stemp[1]] && tvalue[ins.stemp[1]]->code == IC_BINARY_OPERATOR) + else if (ins.mSTemp[0] < 0 && ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_BINARY_OPERATOR) { - InterInstruction* pins = tvalue[ins.stemp[1]]; - if (ins.oper == pins->oper && (ins.oper == IA_ADD || ins.oper == IA_MUL || ins.oper == IA_AND || ins.oper == IA_OR)) + InterInstruction* pins = tvalue[ins.mSTemp[1]]; + if (ins.mOperator == pins->mOperator && (ins.mOperator == IA_ADD || ins.mOperator == IA_MUL || ins.mOperator == IA_AND || ins.mOperator == IA_OR)) { - if (pins->stemp[1] < 0) + if (pins->mSTemp[1] < 0) { - ins.siconst[0] = ConstantFolding(ins.oper, ins.siconst[0], pins->siconst[1]); - ins.stemp[1] = pins->stemp[0]; + ins.mSIntConst[0] = ConstantFolding(ins.mOperator, ins.mSIntConst[0], pins->mSIntConst[1]); + ins.mSTemp[1] = pins->mSTemp[0]; } - else if (pins->stemp[0] < 0) + else if (pins->mSTemp[0] < 0) { - ins.siconst[0] = ConstantFolding(ins.oper, ins.siconst[0], pins->siconst[0]); - ins.stemp[1] = pins->stemp[1]; + ins.mSIntConst[0] = ConstantFolding(ins.mOperator, ins.mSIntConst[0], pins->mSIntConst[0]); + ins.mSTemp[1] = pins->mSTemp[1]; } } - else if (ins.oper == IA_SHL && (pins->oper == IA_SHR || pins->oper == IA_SAR) && pins->stemp[0] < 0 && ins.siconst[0] == pins->siconst[0]) + else if (ins.mOperator == IA_SHL && (pins->mOperator == IA_SHR || pins->mOperator == IA_SAR) && pins->mSTemp[0] < 0 && ins.mSIntConst[0] == pins->mSIntConst[0]) { - ins.oper = IA_AND; - ins.siconst[0] = -1LL << ins.siconst[0]; - ins.stemp[1] = pins->stemp[1]; + ins.mOperator = IA_AND; + ins.mSIntConst[0] = -1LL << ins.mSIntConst[0]; + ins.mSTemp[1] = pins->mSTemp[1]; } } @@ -1945,14 +1928,14 @@ ins.siconst[0] = 1; } break; case IC_UNARY_OPERATOR: - switch (ins.stype[0]) + switch (ins.mSType[0]) { case IT_FLOAT: - if (ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_CONSTANT) + if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT) { - ins.code = IC_CONSTANT; - ins.fvalue = ConstantFolding(ins.oper, tvalue[ins.stemp[0]]->fvalue); - ins.stemp[0] = -1; + ins.mCode = IC_CONSTANT; + ins.mFloatValue = ConstantFolding(ins.mOperator, tvalue[ins.mSTemp[0]]->mFloatValue); + ins.mSTemp[0] = -1; } break; case IT_POINTER: @@ -1962,62 +1945,55 @@ ins.siconst[0] = 1; } break; case IC_RELATIONAL_OPERATOR: - switch (ins.stype[1]) + switch (ins.mSType[1]) { case IT_FLOAT: break; case IT_POINTER: - if (ins.oper == IA_CMPEQ || ins.oper == IA_CMPNE) + if (ins.mOperator == IA_CMPEQ || ins.mOperator == IA_CMPNE) { - if (ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_CONSTANT) + if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT) { - ins.opsize = tvalue[ins.stemp[0]]->opsize; - ins.stemp[0] = -1; + ins.mOperandSize = tvalue[ins.mSTemp[0]]->mOperandSize; + ins.mSTemp[0] = -1; } - else if (ins.stemp[1] >= 0 && tvalue[ins.stemp[1]] && tvalue[ins.stemp[1]]->code == IC_CONSTANT) + else if (ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_CONSTANT) { - ins.opsize = tvalue[ins.stemp[1]]->opsize; - ins.stemp[1] = -1; + ins.mOperandSize = tvalue[ins.mSTemp[1]]->mOperandSize; + ins.mSTemp[1] = -1; } } break; default: - if (ins.stemp[1] >= 0 && tvalue[ins.stemp[1]] && tvalue[ins.stemp[1]]->code == IC_CONSTANT && - ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_CONSTANT) + if (ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_CONSTANT && + ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT) { - ins.code = IC_CONSTANT; - ins.ivalue = ConstantFolding(ins.oper, tvalue[ins.stemp[1]]->ivalue, tvalue[ins.stemp[0]]->ivalue); - ins.stemp[0] = -1; - ins.stemp[1] = -1; + ins.mCode = IC_CONSTANT; + ins.mIntValue = ConstantFolding(ins.mOperator, tvalue[ins.mSTemp[1]]->mIntValue, tvalue[ins.mSTemp[0]]->mIntValue); + ins.mSTemp[0] = -1; + ins.mSTemp[1] = -1; } else { - if (ins.stemp[1] >= 0 && tvalue[ins.stemp[1]] && tvalue[ins.stemp[1]]->code == IC_CONSTANT) + if (ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_CONSTANT) { - ins.siconst[1] = tvalue[ins.stemp[1]]->ivalue; - ins.stemp[1] = -1; + ins.mSIntConst[1] = tvalue[ins.mSTemp[1]]->mIntValue; + ins.mSTemp[1] = -1; } - else if (ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_CONSTANT) + else if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT) { - ins.siconst[0] = tvalue[ins.stemp[0]]->ivalue; - ins.stemp[0] = -1; + ins.mSIntConst[0] = tvalue[ins.mSTemp[0]]->mIntValue; + ins.mSTemp[0] = -1; } } break; } break; case IC_BRANCH: - if (ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_CONSTANT) + if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT) { - ins.siconst[0] = tvalue[ins.stemp[0]]->ivalue; - ins.stemp[0] = -1; - } - break; - case IC_PUSH_FRAME: - if (ins.stemp[0] >= 0 && tvalue[ins.stemp[0]] && tvalue[ins.stemp[0]]->code == IC_CONSTANT) - { - ins.spconst[0] = tvalue[ins.stemp[0]]->opsize; - ins.stemp[0] = -1; + ins.mSIntConst[0] = tvalue[ins.mSTemp[0]]->mIntValue; + ins.mSTemp[0] = -1; } break; } @@ -2028,15 +2004,15 @@ void InterCodeBasicBlock::CollectLocalAddressTemps(GrowingIntArray& localTable) { int i; - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; - for (i = 0; i < code.Size(); i++) - code[i].CollectLocalAddressTemps(localTable); + for (i = 0; i < mInstructions.Size(); i++) + mInstructions[i].CollectLocalAddressTemps(localTable); - if (trueJump) trueJump->CollectLocalAddressTemps(localTable); - if (falseJump) falseJump->CollectLocalAddressTemps(localTable); + if (mTrueJump) mTrueJump->CollectLocalAddressTemps(localTable); + if (mFalseJump) mFalseJump->CollectLocalAddressTemps(localTable); } } @@ -2044,15 +2020,15 @@ void InterCodeBasicBlock::MarkAliasedLocalTemps(const GrowingIntArray& localTabl { int i; - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; - for (i = 0; i < code.Size(); i++) - code[i].MarkAliasedLocalTemps(localTable, aliasedLocals); + for (i = 0; i < mInstructions.Size(); i++) + mInstructions[i].MarkAliasedLocalTemps(localTable, aliasedLocals); - if (trueJump) trueJump->MarkAliasedLocalTemps(localTable, aliasedLocals); - if (falseJump) falseJump->MarkAliasedLocalTemps(localTable, aliasedLocals); + if (mTrueJump) mTrueJump->MarkAliasedLocalTemps(localTable, aliasedLocals); + if (mFalseJump) mFalseJump->MarkAliasedLocalTemps(localTable, aliasedLocals); } } @@ -2060,48 +2036,48 @@ void InterCodeBasicBlock::BuildLocalTempSets(int num, int numFixed) { int i; - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; - localRequiredTemps = NumberSet(num); - localProvidedTemps = NumberSet(num); + mLocalRequiredTemps = NumberSet(num); + mLocalProvidedTemps = NumberSet(num); - entryRequiredTemps = NumberSet(num); - entryProvidedTemps = NumberSet(num); - exitRequiredTemps = NumberSet(num); + mEntryRequiredTemps = NumberSet(num); + mEntryProvidedTemps = NumberSet(num); + mExitRequiredTemps = NumberSet(num); exitProvidedTemps = NumberSet(num); - for (i = 0; i < code.Size(); i++) + for (i = 0; i < mInstructions.Size(); i++) { - code[i].FilterTempUsage(localRequiredTemps, localProvidedTemps); + mInstructions[i].FilterTempUsage(mLocalRequiredTemps, mLocalProvidedTemps); } - entryRequiredTemps = localRequiredTemps; - exitProvidedTemps = localProvidedTemps; + mEntryRequiredTemps = mLocalRequiredTemps; + exitProvidedTemps = mLocalProvidedTemps; for (i = 0; i < numFixed; i++) { - entryRequiredTemps += i; + mEntryRequiredTemps += i; exitProvidedTemps += i; } - if (trueJump) trueJump->BuildLocalTempSets(num, numFixed); - if (falseJump) falseJump->BuildLocalTempSets(num, numFixed); + if (mTrueJump) mTrueJump->BuildLocalTempSets(num, numFixed); + if (mFalseJump) mFalseJump->BuildLocalTempSets(num, numFixed); } } void InterCodeBasicBlock::BuildGlobalProvidedTempSet(NumberSet fromProvidedTemps) { - if (!visited || !(fromProvidedTemps <= entryProvidedTemps)) + if (!mVisited || !(fromProvidedTemps <= mEntryProvidedTemps)) { - entryProvidedTemps |= fromProvidedTemps; + mEntryProvidedTemps |= fromProvidedTemps; fromProvidedTemps |= exitProvidedTemps; - visited = true; + mVisited = true; - if (trueJump) trueJump->BuildGlobalProvidedTempSet(fromProvidedTemps); - if (falseJump) falseJump->BuildGlobalProvidedTempSet(fromProvidedTemps); + if (mTrueJump) mTrueJump->BuildGlobalProvidedTempSet(fromProvidedTemps); + if (mFalseJump) mFalseJump->BuildGlobalProvidedTempSet(fromProvidedTemps); } } @@ -2109,22 +2085,22 @@ void InterCodeBasicBlock::PerformTempForwarding(TempForwardingTable& forwardingT { int i; - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; TempForwardingTable localForwardingTable(forwardingTable); - if (numEntries > 1) + if (mNumEntries > 1) localForwardingTable.Reset(); - for (i = 0; i < code.Size(); i++) + for (i = 0; i < mInstructions.Size(); i++) { - code[i].PerformTempForwarding(localForwardingTable); + mInstructions[i].PerformTempForwarding(localForwardingTable); } - if (trueJump) trueJump->PerformTempForwarding(localForwardingTable); - if (falseJump) falseJump->PerformTempForwarding(localForwardingTable); + if (mTrueJump) mTrueJump->PerformTempForwarding(localForwardingTable); + if (mFalseJump) mFalseJump->PerformTempForwarding(localForwardingTable); } } @@ -2133,27 +2109,27 @@ bool InterCodeBasicBlock::BuildGlobalRequiredTempSet(NumberSet& fromRequiredTemp bool revisit = false; int i; - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; - NumberSet newRequiredTemps(exitRequiredTemps); + NumberSet newRequiredTemps(mExitRequiredTemps); - if (trueJump && trueJump->BuildGlobalRequiredTempSet(newRequiredTemps)) revisit = true; - if (falseJump && falseJump->BuildGlobalRequiredTempSet(newRequiredTemps)) revisit = true; + if (mTrueJump && mTrueJump->BuildGlobalRequiredTempSet(newRequiredTemps)) revisit = true; + if (mFalseJump && mFalseJump->BuildGlobalRequiredTempSet(newRequiredTemps)) revisit = true; - if (!(newRequiredTemps <= exitRequiredTemps)) + if (!(newRequiredTemps <= mExitRequiredTemps)) { revisit = true; - exitRequiredTemps = newRequiredTemps; - newRequiredTemps -= localProvidedTemps; - entryRequiredTemps |= newRequiredTemps; + mExitRequiredTemps = newRequiredTemps; + newRequiredTemps -= mLocalProvidedTemps; + mEntryRequiredTemps |= newRequiredTemps; } } - fromRequiredTemps |= entryRequiredTemps; + fromRequiredTemps |= mEntryRequiredTemps; return revisit; } @@ -2162,32 +2138,32 @@ bool InterCodeBasicBlock::RemoveUnusedResultInstructions(int numStaticTemps) { bool changed = false; - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; - NumberSet requiredTemps(exitRequiredTemps); + NumberSet requiredTemps(mExitRequiredTemps); int i; for (i = 0; i < numStaticTemps; i++) requiredTemps += i; - for (i = code.Size() - 1; i > 0; i--) + for (i = mInstructions.Size() - 1; i > 0; i--) { - if (code[i].RemoveUnusedResultInstructions(&(code[i - 1]), requiredTemps, numStaticTemps)) + if (mInstructions[i].RemoveUnusedResultInstructions(&(mInstructions[i - 1]), requiredTemps, numStaticTemps)) changed = true; } - if (code[0].RemoveUnusedResultInstructions(NULL, requiredTemps, numStaticTemps)) + if (mInstructions[0].RemoveUnusedResultInstructions(NULL, requiredTemps, numStaticTemps)) changed = true; - if (trueJump) + if (mTrueJump) { - if (trueJump->RemoveUnusedResultInstructions(numStaticTemps)) + if (mTrueJump->RemoveUnusedResultInstructions(numStaticTemps)) changed = true; } - if (falseJump) + if (mFalseJump) { - if (falseJump->RemoveUnusedResultInstructions(numStaticTemps)) + if (mFalseJump->RemoveUnusedResultInstructions(numStaticTemps)) changed = true; } } @@ -2200,9 +2176,9 @@ void InterCodeBasicBlock::BuildLocalVariableSets(const GrowingVariableArray& loc { int i; - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; mLocalRequiredVars = NumberSet(localVars.Size()); mLocalProvidedVars = NumberSet(localVars.Size()); @@ -2212,30 +2188,30 @@ void InterCodeBasicBlock::BuildLocalVariableSets(const GrowingVariableArray& loc mExitRequiredVars = NumberSet(localVars.Size()); mExitProvidedVars = NumberSet(localVars.Size()); - for (i = 0; i < code.Size(); i++) + for (i = 0; i < mInstructions.Size(); i++) { - code[i].FilterVarsUsage(localVars, mLocalRequiredVars, mLocalProvidedVars); + mInstructions[i].FilterVarsUsage(localVars, mLocalRequiredVars, mLocalProvidedVars); } mEntryRequiredVars = mLocalRequiredVars; mExitProvidedVars = mLocalProvidedVars; - if (trueJump) trueJump->BuildLocalVariableSets(localVars); - if (falseJump) falseJump->BuildLocalVariableSets(localVars); + if (mTrueJump) mTrueJump->BuildLocalVariableSets(localVars); + if (mFalseJump) mFalseJump->BuildLocalVariableSets(localVars); } } void InterCodeBasicBlock::BuildGlobalProvidedVariableSet(const GrowingVariableArray& localVars, NumberSet fromProvidedVars) { - if (!visited || !(fromProvidedVars <= mEntryProvidedVars)) + if (!mVisited || !(fromProvidedVars <= mEntryProvidedVars)) { mEntryProvidedVars |= fromProvidedVars; fromProvidedVars |= mExitProvidedVars; - visited = true; + mVisited = true; - if (trueJump) trueJump->BuildGlobalProvidedVariableSet(localVars, fromProvidedVars); - if (falseJump) falseJump->BuildGlobalProvidedVariableSet(localVars, fromProvidedVars); + if (mTrueJump) mTrueJump->BuildGlobalProvidedVariableSet(localVars, fromProvidedVars); + if (mFalseJump) mFalseJump->BuildGlobalProvidedVariableSet(localVars, fromProvidedVars); } } @@ -2244,14 +2220,14 @@ bool InterCodeBasicBlock::BuildGlobalRequiredVariableSet(const GrowingVariableAr bool revisit = false; int i; - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; NumberSet newRequiredVars(mExitRequiredVars); - if (trueJump && trueJump->BuildGlobalRequiredVariableSet(localVars, newRequiredVars)) revisit = true; - if (falseJump && falseJump->BuildGlobalRequiredVariableSet(localVars, newRequiredVars)) revisit = true; + if (mTrueJump && mTrueJump->BuildGlobalRequiredVariableSet(localVars, newRequiredVars)) revisit = true; + if (mFalseJump && mFalseJump->BuildGlobalRequiredVariableSet(localVars, newRequiredVars)) revisit = true; if (!(newRequiredVars <= mExitRequiredVars)) { @@ -2273,29 +2249,29 @@ bool InterCodeBasicBlock::RemoveUnusedStoreInstructions(const GrowingVariableArr { bool changed = false; - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; NumberSet requiredVars(mExitRequiredVars); int i; - for (i = code.Size() - 1; i > 0; i--) + for (i = mInstructions.Size() - 1; i > 0; i--) { - if (code[i].RemoveUnusedStoreInstructions(localVars, &(code[i - 1]), requiredVars)) + if (mInstructions[i].RemoveUnusedStoreInstructions(localVars, &(mInstructions[i - 1]), requiredVars)) changed = true; } - if (code[0].RemoveUnusedStoreInstructions(localVars, nullptr, requiredVars)) + if (mInstructions[0].RemoveUnusedStoreInstructions(localVars, nullptr, requiredVars)) changed = true; - if (trueJump) + if (mTrueJump) { - if (trueJump->RemoveUnusedStoreInstructions(localVars)) + if (mTrueJump->RemoveUnusedStoreInstructions(localVars)) changed = true; } - if (falseJump) + if (mFalseJump) { - if (falseJump->RemoveUnusedStoreInstructions(localVars)) + if (mFalseJump->RemoveUnusedStoreInstructions(localVars)) changed = true; } } @@ -2308,16 +2284,16 @@ void InterCodeBasicBlock::PerformValueForwarding(const GrowingInstructionPtrArra { int i; - if (!visited) + if (!mVisited) { GrowingInstructionPtrArray ltvalue(tvalue); ValueSet lvalues(values); - visited = true; + mVisited = true; tvalid.Clear(); - if (numEntries != 1) + if (mNumEntries != 1) { lvalues.FlushAll(); ltvalue.Clear(); @@ -2331,14 +2307,14 @@ void InterCodeBasicBlock::PerformValueForwarding(const GrowingInstructionPtrArra } } - for (i = 0; i < code.Size(); i++) + for (i = 0; i < mInstructions.Size(); i++) { - lvalues.UpdateValue(code[i], ltvalue, aliasedLocals); - code[i].PerformValueForwarding(ltvalue, tvalid); + lvalues.UpdateValue(mInstructions[i], ltvalue, aliasedLocals); + mInstructions[i].PerformValueForwarding(ltvalue, tvalid); } - if (trueJump) trueJump->PerformValueForwarding(ltvalue, lvalues, tvalid, aliasedLocals); - if (falseJump) falseJump->PerformValueForwarding(ltvalue, lvalues, tvalid, aliasedLocals); + if (mTrueJump) mTrueJump->PerformValueForwarding(ltvalue, lvalues, tvalid, aliasedLocals); + if (mFalseJump) mFalseJump->PerformValueForwarding(ltvalue, lvalues, tvalid, aliasedLocals); } } @@ -2346,15 +2322,15 @@ void InterCodeBasicBlock::PerformMachineSpecificValueUsageCheck(const GrowingIns { int i; - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; GrowingInstructionPtrArray ltvalue(tvalue); tvalid.Clear(); - if (numEntries != 1) + if (mNumEntries != 1) ltvalue.Clear(); else { @@ -2365,14 +2341,14 @@ void InterCodeBasicBlock::PerformMachineSpecificValueUsageCheck(const GrowingIns } } - for (i = 0; i < code.Size(); i++) + for (i = 0; i < mInstructions.Size(); i++) { - CheckValueUsage(code[i], ltvalue); - code[i].PerformValueForwarding(ltvalue, tvalid); + CheckValueUsage(mInstructions[i], ltvalue); + mInstructions[i].PerformValueForwarding(ltvalue, tvalid); } - if (trueJump) trueJump->PerformMachineSpecificValueUsageCheck(ltvalue, tvalid); - if (falseJump) falseJump->PerformMachineSpecificValueUsageCheck(ltvalue, tvalid); + if (mTrueJump) mTrueJump->PerformMachineSpecificValueUsageCheck(ltvalue, tvalid); + if (mFalseJump) mFalseJump->PerformMachineSpecificValueUsageCheck(ltvalue, tvalid); } } @@ -2412,39 +2388,39 @@ void InterCodeBasicBlock::LocalRenameRegister(const GrowingIntArray& renameTable { int i; - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; - entryRenameTable.SetSize(renameTable.Size()); - exitRenameTable.SetSize(renameTable.Size()); + mEntryRenameTable.SetSize(renameTable.Size()); + mExitRenameTable.SetSize(renameTable.Size()); for (i = 0; i < renameTable.Size(); i++) { if (i < fixed) { - entryRenameTable[i] = i; - exitRenameTable[i] = i; + mEntryRenameTable[i] = i; + mExitRenameTable[i] = i; } - else if (entryRequiredTemps[i]) + else if (mEntryRequiredTemps[i]) { - entryRenameTable[i] = renameTable[i]; - exitRenameTable[i] = renameTable[i]; + mEntryRenameTable[i] = renameTable[i]; + mExitRenameTable[i] = renameTable[i]; } else { - entryRenameTable[i] = -1; - exitRenameTable[i] = -1; + mEntryRenameTable[i] = -1; + mExitRenameTable[i] = -1; } } - for (i = 0; i < code.Size(); i++) + for (i = 0; i < mInstructions.Size(); i++) { - code[i].LocalRenameRegister(exitRenameTable, num, fixed); + mInstructions[i].LocalRenameRegister(mExitRenameTable, num, fixed); } - if (trueJump) trueJump->LocalRenameRegister(exitRenameTable, num, fixed); - if (falseJump) falseJump->LocalRenameRegister(exitRenameTable, num, fixed); + if (mTrueJump) mTrueJump->LocalRenameRegister(mExitRenameTable, num, fixed); + if (mFalseJump) mFalseJump->LocalRenameRegister(mExitRenameTable, num, fixed); } } @@ -2454,18 +2430,18 @@ void InterCodeBasicBlock::BuildGlobalRenameRegisterTable(const GrowingIntArray& for (i = 0; i < renameTable.Size(); i++) { - if (renameTable[i] >= 0 && entryRenameTable[i] >= 0 && renameTable[i] != entryRenameTable[i]) + if (renameTable[i] >= 0 && mEntryRenameTable[i] >= 0 && renameTable[i] != mEntryRenameTable[i]) { - Union(globalRenameTable, renameTable[i], entryRenameTable[i]); + Union(globalRenameTable, renameTable[i], mEntryRenameTable[i]); } } - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; - if (trueJump) trueJump->BuildGlobalRenameRegisterTable(exitRenameTable, globalRenameTable); - if (falseJump) falseJump->BuildGlobalRenameRegisterTable(exitRenameTable, globalRenameTable); + if (mTrueJump) mTrueJump->BuildGlobalRenameRegisterTable(mExitRenameTable, globalRenameTable); + if (mFalseJump) mFalseJump->BuildGlobalRenameRegisterTable(mExitRenameTable, globalRenameTable); } } @@ -2473,36 +2449,36 @@ void InterCodeBasicBlock::GlobalRenameRegister(const GrowingIntArray& renameTabl { int i; - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; - for (i = 0; i < code.Size(); i++) + for (i = 0; i < mInstructions.Size(); i++) { - code[i].GlobalRenameRegister(renameTable, temporaries); + mInstructions[i].GlobalRenameRegister(renameTable, temporaries); } - if (trueJump) trueJump->GlobalRenameRegister(renameTable, temporaries); - if (falseJump) falseJump->GlobalRenameRegister(renameTable, temporaries); + if (mTrueJump) mTrueJump->GlobalRenameRegister(renameTable, temporaries); + if (mFalseJump) mFalseJump->GlobalRenameRegister(renameTable, temporaries); } } void InterCodeBasicBlock::BuildCollisionTable(NumberSet* collisionSets) { - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; - NumberSet requiredTemps(exitRequiredTemps); + NumberSet requiredTemps(mExitRequiredTemps); int i, j; - for (i = 0; i < exitRequiredTemps.Size(); i++) + for (i = 0; i < mExitRequiredTemps.Size(); i++) { - if (exitRequiredTemps[i]) + if (mExitRequiredTemps[i]) { - for (j = 0; j < exitRequiredTemps.Size(); j++) + for (j = 0; j < mExitRequiredTemps.Size(); j++) { - if (exitRequiredTemps[j]) + if (mExitRequiredTemps[j]) { collisionSets[i] += j; } @@ -2510,13 +2486,13 @@ void InterCodeBasicBlock::BuildCollisionTable(NumberSet* collisionSets) } } - for (i = code.Size() - 1; i >= 0; i--) + for (i = mInstructions.Size() - 1; i >= 0; i--) { - code[i].BuildCollisionTable(requiredTemps, collisionSets); + mInstructions[i].BuildCollisionTable(requiredTemps, collisionSets); } - if (trueJump) trueJump->BuildCollisionTable(collisionSets); - if (falseJump) falseJump->BuildCollisionTable(collisionSets); + if (mTrueJump) mTrueJump->BuildCollisionTable(collisionSets); + if (mFalseJump) mFalseJump->BuildCollisionTable(collisionSets); } } @@ -2524,17 +2500,17 @@ void InterCodeBasicBlock::ReduceTemporaries(const GrowingIntArray& renameTable, { int i; - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; - for (i = 0; i < code.Size(); i++) + for (i = 0; i < mInstructions.Size(); i++) { - code[i].ReduceTemporaries(renameTable, temporaries); + mInstructions[i].ReduceTemporaries(renameTable, temporaries); } - if (trueJump) trueJump->ReduceTemporaries(renameTable, temporaries); - if (falseJump) falseJump->ReduceTemporaries(renameTable, temporaries); + if (mTrueJump) mTrueJump->ReduceTemporaries(renameTable, temporaries); + if (mFalseJump) mFalseJump->ReduceTemporaries(renameTable, temporaries); } } @@ -2568,34 +2544,34 @@ void InterCodeBasicBlock::MapVariables(GrowingVariableArray& globalVars, Growing { int i; - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; - for (i = 0; i < code.Size(); i++) + for (i = 0; i < mInstructions.Size(); i++) { bool found = false; - switch (code[i].code) + switch (mInstructions[i].mCode) { case IC_STORE: case IC_LOAD: case IC_CONSTANT: case IC_JSR: - if (code[i].mem == IM_GLOBAL) + if (mInstructions[i].mMemory == IM_GLOBAL) { - UseGlobal(globalVars, code[i].vindex); + UseGlobal(globalVars, mInstructions[i].mVarIndex); } - else if (code[i].mem == IM_LOCAL) + else if (mInstructions[i].mMemory == IM_LOCAL) { - localVars[code[i].vindex].mUsed = true; + localVars[mInstructions[i].mVarIndex].mUsed = true; } break; } } - if (trueJump) trueJump->MapVariables(globalVars, localVars); - if (falseJump) falseJump->MapVariables(globalVars, localVars); + if (mTrueJump) mTrueJump->MapVariables(globalVars, localVars); + if (mFalseJump) mFalseJump->MapVariables(globalVars, localVars); } } @@ -2603,34 +2579,34 @@ void InterCodeBasicBlock::CollectOuterFrame(int level, int& size) { int i; - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; - for (i = 0; i < code.Size(); i++) + for (i = 0; i < mInstructions.Size(); i++) { - if (code[i].code == IC_PUSH_FRAME) + if (mInstructions[i].mCode == IC_PUSH_FRAME) { level++; if (level == 1) { - if (code[i].ivalue > size) - size = code[i].ivalue; - code[i].code = IC_NONE; + if (mInstructions[i].mIntValue > size) + size = mInstructions[i].mIntValue; + mInstructions[i].mCode = IC_NONE; } } - else if (code[i].code == IC_POP_FRAME) + else if (mInstructions[i].mCode == IC_POP_FRAME) { if (level == 1) { - code[i].code = IC_NONE; + mInstructions[i].mCode = IC_NONE; } level--; } } - if (trueJump) trueJump->CollectOuterFrame(level, size); - if (falseJump) falseJump->CollectOuterFrame(level, size); + if (mTrueJump) mTrueJump->CollectOuterFrame(level, size); + if (mFalseJump) mFalseJump->CollectOuterFrame(level, size); } } @@ -2638,17 +2614,17 @@ bool InterCodeBasicBlock::IsLeafProcedure(void) { int i; - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; - for (i = 0; i < code.Size(); i++) - if (code[i].code == IC_CALL) + for (i = 0; i < mInstructions.Size(); i++) + if (mInstructions[i].mCode == IC_CALL) return false; - if (trueJump && !trueJump->IsLeafProcedure()) + if (mTrueJump && !mTrueJump->IsLeafProcedure()) return false; - if (falseJump && !falseJump->IsLeafProcedure()) + if (mFalseJump && !mFalseJump->IsLeafProcedure()) return false; } @@ -2659,34 +2635,34 @@ void InterCodeBasicBlock::CollectVariables(GrowingVariableArray& globalVars, Gro { int i; - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; - for (i = 0; i < code.Size(); i++) + for (i = 0; i < mInstructions.Size(); i++) { bool found = false; - switch (code[i].code) + switch (mInstructions[i].mCode) { case IC_STORE: case IC_LOAD: case IC_CONSTANT: case IC_JSR: - if (code[i].mem == IM_LOCAL) + if (mInstructions[i].mMemory == IM_LOCAL) { - int size = code[i].opsize + code[i].ivalue; - if (size > localVars[code[i].vindex].mSize) - localVars[code[i].vindex].mSize = size; - if (code[i].code == IC_CONSTANT) - localVars[code[i].vindex].mAliased = true; + int size = mInstructions[i].mOperandSize + mInstructions[i].mIntValue; + if (size > localVars[mInstructions[i].mVarIndex].mSize) + localVars[mInstructions[i].mVarIndex].mSize = size; + if (mInstructions[i].mCode == IC_CONSTANT) + localVars[mInstructions[i].mVarIndex].mAliased = true; } break; } } - if (trueJump) trueJump->CollectVariables(globalVars, localVars); - if (falseJump) falseJump->CollectVariables(globalVars, localVars); + if (mTrueJump) mTrueJump->CollectVariables(globalVars, localVars); + if (mFalseJump) mFalseJump->CollectVariables(globalVars, localVars); } } @@ -2694,17 +2670,17 @@ void InterCodeBasicBlock::CollectSimpleLocals(FastNumberSet& complexLocals, Fast { int i; - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; - for (i = 0; i < code.Size(); i++) + for (i = 0; i < mInstructions.Size(); i++) { - code[i].CollectSimpleLocals(complexLocals, simpleLocals, localTypes); + mInstructions[i].CollectSimpleLocals(complexLocals, simpleLocals, localTypes); } - if (trueJump) trueJump->CollectSimpleLocals(complexLocals, simpleLocals, localTypes); - if (falseJump) falseJump->CollectSimpleLocals(complexLocals, simpleLocals, localTypes); + if (mTrueJump) mTrueJump->CollectSimpleLocals(complexLocals, simpleLocals, localTypes); + if (mFalseJump) mFalseJump->CollectSimpleLocals(complexLocals, simpleLocals, localTypes); } } @@ -2712,17 +2688,17 @@ void InterCodeBasicBlock::SimpleLocalToTemp(int vindex, int temp) { int i; - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; - for (i = 0; i < code.Size(); i++) + for (i = 0; i < mInstructions.Size(); i++) { - code[i].SimpleLocalToTemp(vindex, temp); + mInstructions[i].SimpleLocalToTemp(vindex, temp); } - if (trueJump) trueJump->SimpleLocalToTemp(vindex, temp); - if (falseJump) falseJump->SimpleLocalToTemp(vindex, temp); + if (mTrueJump) mTrueJump->SimpleLocalToTemp(vindex, temp); + if (mFalseJump) mFalseJump->SimpleLocalToTemp(vindex, temp); } } @@ -2731,17 +2707,17 @@ void InterCodeBasicBlock::CollectActiveTemporaries(FastNumberSet& set) { int i; - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; - for (i = 0; i < code.Size(); i++) + for (i = 0; i < mInstructions.Size(); i++) { - code[i].CollectActiveTemporaries(set); + mInstructions[i].CollectActiveTemporaries(set); } - if (trueJump) trueJump->CollectActiveTemporaries(set); - if (falseJump) falseJump->CollectActiveTemporaries(set); + if (mTrueJump) mTrueJump->CollectActiveTemporaries(set); + if (mFalseJump) mFalseJump->CollectActiveTemporaries(set); } } @@ -2749,17 +2725,17 @@ void InterCodeBasicBlock::ShrinkActiveTemporaries(FastNumberSet& set, GrowingTyp { int i; - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; - for (i = 0; i < code.Size(); i++) + for (i = 0; i < mInstructions.Size(); i++) { - code[i].ShrinkActiveTemporaries(set, temporaries); + mInstructions[i].ShrinkActiveTemporaries(set, temporaries); } - if (trueJump) trueJump->ShrinkActiveTemporaries(set, temporaries); - if (falseJump) falseJump->ShrinkActiveTemporaries(set, temporaries); + if (mTrueJump) mTrueJump->ShrinkActiveTemporaries(set, temporaries); + if (mFalseJump) mFalseJump->ShrinkActiveTemporaries(set, temporaries); } } @@ -2767,18 +2743,18 @@ void InterCodeBasicBlock::Disassemble(FILE* file, bool dumpSets) { int i; - if (!visited) + if (!mVisited) { - visited = true; + mVisited = true; - fprintf(file, "L%d: (%d)\n", num, numEntries); + fprintf(file, "L%d: (%d)\n", mIndex, mNumEntries); if (dumpSets) { fprintf(file, "Entry required temps : "); - for (i = 0; i < entryRequiredTemps.Size(); i++) + for (i = 0; i < mEntryRequiredTemps.Size(); i++) { - if (entryRequiredTemps[i]) + if (mEntryRequiredTemps[i]) fprintf(file, "#"); else fprintf(file, "-"); @@ -2786,27 +2762,27 @@ void InterCodeBasicBlock::Disassemble(FILE* file, bool dumpSets) fprintf(file, "\n\n"); } - for (i = 0; i < code.Size(); i++) + for (i = 0; i < mInstructions.Size(); i++) { - if (code[i].code != IT_NONE) + if (mInstructions[i].mCode != IT_NONE) { fprintf(file, "%04x\t", i); - code[i].Disassemble(file); + mInstructions[i].Disassemble(file); } } - if (trueJump) fprintf(file, "\t\t==> %d\n", trueJump->num); - if (falseJump) fprintf(file, "\t\t==> %d\n", falseJump->num); + if (mTrueJump) fprintf(file, "\t\t==> %d\n", mTrueJump->mIndex); + if (mFalseJump) fprintf(file, "\t\t==> %d\n", mFalseJump->mIndex); - if (trueJump) trueJump->Disassemble(file, dumpSets); - if (falseJump) falseJump->Disassemble(file, dumpSets); + if (mTrueJump) mTrueJump->Disassemble(file, dumpSets); + if (mFalseJump) mFalseJump->Disassemble(file, dumpSets); } } InterCodeProcedure::InterCodeProcedure(InterCodeModule * mod, const Location & location, const Ident* ident) - : temporaries(IT_NONE), blocks(nullptr), mLocation(location), mTempOffset(-1), - renameTable(-1), renameUnionTable(-1), globalRenameTable(-1), - valueForwardingTable(NULL), mLocalVars(InterVariable()), mModule(mod), + : mTemporaries(IT_NONE), mBlocks(nullptr), mLocation(location), mTempOffset(-1), + mRenameTable(-1), mRenameUnionTable(-1), mGlobalRenameTable(-1), + mValueForwardingTable(NULL), mLocalVars(InterVariable()), mModule(mod), mIdent(ident) { mID = mModule->mProcedures.Size(); @@ -2821,20 +2797,20 @@ void InterCodeProcedure::ResetVisited(void) { int i; - for (i = 0; i < blocks.Size(); i++) - blocks[i]->visited = false; + for (i = 0; i < mBlocks.Size(); i++) + mBlocks[i]->mVisited = false; } void InterCodeProcedure::Append(InterCodeBasicBlock* block) { - block->num = blocks.Size(); - blocks.Push(block); + block->mIndex = mBlocks.Size(); + mBlocks.Push(block); } int InterCodeProcedure::AddTemporary(InterType type) { - int temp = temporaries.Size(); - temporaries.Push(type); + int temp = mTemporaries.Size(); + mTemporaries.Push(type); return temp; } @@ -2848,39 +2824,39 @@ void InterCodeProcedure::BuildTraces(void) // Count number of entries // ResetVisited(); - for (int i = 0; i < blocks.Size(); i++) - blocks[i]->numEntries = 0; - blocks[0]->CollectEntries(); + for (int i = 0; i < mBlocks.Size(); i++) + mBlocks[i]->mNumEntries = 0; + mBlocks[0]->CollectEntries(); // // Build traces // ResetVisited(); - blocks[0]->GenerateTraces(); + mBlocks[0]->GenerateTraces(); ResetVisited(); - for (int i = 0; i < blocks.Size(); i++) - blocks[i]->numEntries = 0; - blocks[0]->CollectEntries(); + for (int i = 0; i < mBlocks.Size(); i++) + mBlocks[i]->mNumEntries = 0; + mBlocks[0]->CollectEntries(); DisassembleDebug("BuildTraces"); } void InterCodeProcedure::BuildDataFlowSets(void) { - int numTemps = temporaries.Size(); + int numTemps = mTemporaries.Size(); // // Build set with local provided/required temporaries // ResetVisited(); - blocks[0]->BuildLocalTempSets(numTemps, numFixedTemporaries); + mBlocks[0]->BuildLocalTempSets(numTemps, numFixedTemporaries); // // Build set of globaly provided temporaries // ResetVisited(); - blocks[0]->BuildGlobalProvidedTempSet(NumberSet(numTemps)); + mBlocks[0]->BuildGlobalProvidedTempSet(NumberSet(numTemps)); // // Build set of globaly required temporaries, might need @@ -2890,29 +2866,29 @@ void InterCodeProcedure::BuildDataFlowSets(void) do { ResetVisited(); - } while (blocks[0]->BuildGlobalRequiredTempSet(totalRequired)); + } while (mBlocks[0]->BuildGlobalRequiredTempSet(totalRequired)); } void InterCodeProcedure::RenameTemporaries(void) { - int numTemps = temporaries.Size(); + int numTemps = mTemporaries.Size(); // // Now we can rename temporaries to remove false dependencies // - renameTable.SetSize(numTemps, true); + mRenameTable.SetSize(numTemps, true); int i, j, numRename; numRename = numFixedTemporaries; for (i = 0; i < numRename; i++) - renameTable[i] = i; + mRenameTable[i] = i; // // First localy rename all temporaries // ResetVisited(); - blocks[0]->LocalRenameRegister(renameTable, numRename, numFixedTemporaries); + mBlocks[0]->LocalRenameRegister(mRenameTable, numRename, numFixedTemporaries); DisassembleDebug("local renamed temps"); @@ -2921,47 +2897,47 @@ void InterCodeProcedure::RenameTemporaries(void) // merges renames temporaries back, that have been renamed differently // on separate paths. // - renameUnionTable.SetSize(numRename); + mRenameUnionTable.SetSize(numRename); for (i = 0; i < numRename; i++) - renameUnionTable[i] = i; + mRenameUnionTable[i] = i; // // Build global rename table using a union/find algorithm // - renameTable.SetSize(numTemps, true); + mRenameTable.SetSize(numTemps, true); ResetVisited(); - blocks[0]->BuildGlobalRenameRegisterTable(renameTable, renameUnionTable); + mBlocks[0]->BuildGlobalRenameRegisterTable(mRenameTable, mRenameUnionTable); // // Now calculate the global temporary IDs for all local ids // int numRenamedTemps; - globalRenameTable.SetSize(numRename, true); + mGlobalRenameTable.SetSize(numRename, true); for (i = 0; i < numFixedTemporaries; i++) - globalRenameTable[i] = i; + mGlobalRenameTable[i] = i; numRenamedTemps = numFixedTemporaries; for (i = numFixedTemporaries; i < numRename; i++) { - j = Find(renameUnionTable, i); + j = Find(mRenameUnionTable, i); - if (globalRenameTable[j] < 0) - globalRenameTable[j] = numRenamedTemps++; + if (mGlobalRenameTable[j] < 0) + mGlobalRenameTable[j] = numRenamedTemps++; - globalRenameTable[i] = globalRenameTable[j]; + mGlobalRenameTable[i] = mGlobalRenameTable[j]; } - temporaries.SetSize(numRenamedTemps); + mTemporaries.SetSize(numRenamedTemps); // // Set global temporary IDs // ResetVisited(); - blocks[0]->GlobalRenameRegister(globalRenameTable, temporaries); + mBlocks[0]->GlobalRenameRegister(mGlobalRenameTable, mTemporaries); numTemps = numRenamedTemps; @@ -2970,7 +2946,7 @@ void InterCodeProcedure::RenameTemporaries(void) void InterCodeProcedure::TempForwarding(void) { - int numTemps = temporaries.Size(); + int numTemps = mTemporaries.Size(); ValueSet valueSet; FastNumberSet tvalidSet(numTemps); @@ -2979,11 +2955,11 @@ void InterCodeProcedure::TempForwarding(void) // Now remove needless temporary moves, that apear due to // stack evaluation // - tempForwardingTable.SetSize(numTemps); + mTempForwardingTable.SetSize(numTemps); - tempForwardingTable.Reset(); + mTempForwardingTable.Reset(); ResetVisited(); - blocks[0]->PerformTempForwarding(tempForwardingTable); + mBlocks[0]->PerformTempForwarding(mTempForwardingTable); DisassembleDebug("temp forwarding"); } @@ -3002,14 +2978,14 @@ void InterCodeProcedure::Close(void) BuildTraces(); ResetVisited(); - mLeafProcedure = blocks[0]->IsLeafProcedure(); + mLeafProcedure = mBlocks[0]->IsLeafProcedure(); if (!mLeafProcedure) { int size = 0; ResetVisited(); - blocks[0]->CollectOuterFrame(0, size); + mBlocks[0]->CollectOuterFrame(0, size); mCommonFrameSize = size; } else @@ -3021,23 +2997,23 @@ void InterCodeProcedure::Close(void) TempForwarding(); - int numTemps = temporaries.Size(); + int numTemps = mTemporaries.Size(); // // Find all local variables that are never aliased // GrowingIntArray localTable(-1); ResetVisited(); - blocks[0]->CollectLocalAddressTemps(localTable); + mBlocks[0]->CollectLocalAddressTemps(localTable); int nlocals = 0; for (int i = 0; i < localTable.Size(); i++) if (localTable[i] + 1 > nlocals) nlocals = localTable[i] + 1; - localAliasedSet.Reset(nlocals); + mLocalAliasedSet.Reset(nlocals); ResetVisited(); - blocks[0]->MarkAliasedLocalTemps(localTable, localAliasedSet); + mBlocks[0]->MarkAliasedLocalTemps(localTable, mLocalAliasedSet); // // Now forward constant values @@ -3045,17 +3021,17 @@ void InterCodeProcedure::Close(void) ValueSet valueSet; FastNumberSet tvalidSet(numTemps); - valueForwardingTable.SetSize(numTemps, true); + mValueForwardingTable.SetSize(numTemps, true); ResetVisited(); - blocks[0]->PerformValueForwarding(valueForwardingTable, valueSet, tvalidSet, localAliasedSet); + mBlocks[0]->PerformValueForwarding(mValueForwardingTable, valueSet, tvalidSet, mLocalAliasedSet); DisassembleDebug("value forwarding"); - valueForwardingTable.Clear(); + mValueForwardingTable.Clear(); ResetVisited(); - blocks[0]->PerformMachineSpecificValueUsageCheck(valueForwardingTable, tvalidSet); + mBlocks[0]->PerformMachineSpecificValueUsageCheck(mValueForwardingTable, tvalidSet); DisassembleDebug("machine value forwarding"); @@ -3063,11 +3039,11 @@ void InterCodeProcedure::Close(void) // Now remove needless temporary moves, that apear due to // stack evaluation // - tempForwardingTable.Reset(); - tempForwardingTable.SetSize(numTemps); + mTempForwardingTable.Reset(); + mTempForwardingTable.SetSize(numTemps); ResetVisited(); - blocks[0]->PerformTempForwarding(tempForwardingTable); + mBlocks[0]->PerformTempForwarding(mTempForwardingTable); DisassembleDebug("temp forwarding 2"); @@ -3078,31 +3054,31 @@ void InterCodeProcedure::Close(void) do { ResetVisited(); - blocks[0]->BuildLocalTempSets(numTemps, numFixedTemporaries); + mBlocks[0]->BuildLocalTempSets(numTemps, numFixedTemporaries); ResetVisited(); - blocks[0]->BuildGlobalProvidedTempSet(NumberSet(numTemps)); + mBlocks[0]->BuildGlobalProvidedTempSet(NumberSet(numTemps)); NumberSet totalRequired2(numTemps); do { ResetVisited(); - } while (blocks[0]->BuildGlobalRequiredTempSet(totalRequired2)); + } while (mBlocks[0]->BuildGlobalRequiredTempSet(totalRequired2)); ResetVisited(); - } while (blocks[0]->RemoveUnusedResultInstructions(numFixedTemporaries)); + } while (mBlocks[0]->RemoveUnusedResultInstructions(numFixedTemporaries)); DisassembleDebug("removed unused instructions"); ResetVisited(); - blocks[0]->CollectVariables(mModule->mGlobalVars, mLocalVars); + mBlocks[0]->CollectVariables(mModule->mGlobalVars, mLocalVars); if (mLocalVars.Size() > 0) { for (int i = 0; i < mLocalVars.Size(); i++) { - if (localAliasedSet[i]) + if (mLocalAliasedSet[i]) mLocalVars[i].mAliased = true; } @@ -3112,19 +3088,19 @@ void InterCodeProcedure::Close(void) do { ResetVisited(); - blocks[0]->BuildLocalVariableSets(mLocalVars); + mBlocks[0]->BuildLocalVariableSets(mLocalVars); ResetVisited(); - blocks[0]->BuildGlobalProvidedVariableSet(mLocalVars, NumberSet(mLocalVars.Size())); + mBlocks[0]->BuildGlobalProvidedVariableSet(mLocalVars, NumberSet(mLocalVars.Size())); NumberSet totalRequired2(mLocalVars.Size()); do { ResetVisited(); - } while (blocks[0]->BuildGlobalRequiredVariableSet(mLocalVars, totalRequired2)); + } while (mBlocks[0]->BuildGlobalRequiredVariableSet(mLocalVars, totalRequired2)); ResetVisited(); - } while (blocks[0]->RemoveUnusedStoreInstructions(mLocalVars)); + } while (mBlocks[0]->RemoveUnusedStoreInstructions(mLocalVars)); DisassembleDebug("removed unused local stores"); } @@ -3137,7 +3113,7 @@ void InterCodeProcedure::Close(void) GrowingTypeArray localTypes(IT_NONE); ResetVisited(); - blocks[0]->CollectSimpleLocals(complexLocals, simpleLocals, localTypes); + mBlocks[0]->CollectSimpleLocals(complexLocals, simpleLocals, localTypes); for (int i = 0; i < simpleLocals.Num(); i++) { @@ -3145,7 +3121,7 @@ void InterCodeProcedure::Close(void) if (!complexLocals[vi]) { ResetVisited(); - blocks[0]->SimpleLocalToTemp(vi, AddTemporary(localTypes[vi])); + mBlocks[0]->SimpleLocalToTemp(vi, AddTemporary(localTypes[vi])); } } @@ -3165,19 +3141,19 @@ void InterCodeProcedure::Close(void) do { ResetVisited(); - blocks[0]->BuildLocalTempSets(numTemps, numFixedTemporaries); + mBlocks[0]->BuildLocalTempSets(numTemps, numFixedTemporaries); ResetVisited(); - blocks[0]->BuildGlobalProvidedTempSet(NumberSet(numTemps)); + mBlocks[0]->BuildGlobalProvidedTempSet(NumberSet(numTemps)); NumberSet totalRequired2(numTemps); do { ResetVisited(); - } while (blocks[0]->BuildGlobalRequiredTempSet(totalRequired2)); + } while (mBlocks[0]->BuildGlobalRequiredTempSet(totalRequired2)); ResetVisited(); - } while (blocks[0]->RemoveUnusedResultInstructions(numFixedTemporaries)); + } while (mBlocks[0]->RemoveUnusedResultInstructions(numFixedTemporaries)); DisassembleDebug("removed unused instructions 2"); @@ -3192,13 +3168,13 @@ void InterCodeProcedure::Close(void) activeSet += i; ResetVisited(); - blocks[0]->CollectActiveTemporaries(activeSet); + mBlocks[0]->CollectActiveTemporaries(activeSet); - temporaries.SetSize(activeSet.Num()); + mTemporaries.SetSize(activeSet.Num()); ResetVisited(); - blocks[0]->ShrinkActiveTemporaries(activeSet, temporaries); + mBlocks[0]->ShrinkActiveTemporaries(activeSet, mTemporaries); MapVariables(); @@ -3210,7 +3186,7 @@ void InterCodeProcedure::Close(void) void InterCodeProcedure::MapVariables(void) { ResetVisited(); - blocks[0]->MapVariables(mModule->mGlobalVars, mLocalVars); + mBlocks[0]->MapVariables(mModule->mGlobalVars, mLocalVars); mLocalSize = 0; for (int i = 0; i < mLocalVars.Size(); i++) { @@ -3226,19 +3202,19 @@ void InterCodeProcedure::ReduceTemporaries(void) { NumberSet* collisionSet; int i, j, numRenamedTemps; - int numTemps = temporaries.Size(); + int numTemps = mTemporaries.Size(); ResetVisited(); - blocks[0]->BuildLocalTempSets(numTemps, numFixedTemporaries); + mBlocks[0]->BuildLocalTempSets(numTemps, numFixedTemporaries); ResetVisited(); - blocks[0]->BuildGlobalProvidedTempSet(NumberSet(numTemps)); + mBlocks[0]->BuildGlobalProvidedTempSet(NumberSet(numTemps)); NumberSet totalRequired2(numTemps); do { ResetVisited(); - } while (blocks[0]->BuildGlobalRequiredTempSet(totalRequired2)); + } while (mBlocks[0]->BuildGlobalRequiredTempSet(totalRequired2)); collisionSet = new NumberSet[numTemps]; @@ -3246,12 +3222,12 @@ void InterCodeProcedure::ReduceTemporaries(void) collisionSet[i].Reset(numTemps); ResetVisited(); - blocks[0]->BuildCollisionTable(collisionSet); + mBlocks[0]->BuildCollisionTable(collisionSet); - renameTable.SetSize(numTemps, true); + mRenameTable.SetSize(numTemps, true); for (i = 0; i < numFixedTemporaries; i++) - renameTable[i] = i; + mRenameTable[i] = i; numRenamedTemps = numFixedTemporaries; @@ -3263,9 +3239,9 @@ void InterCodeProcedure::ReduceTemporaries(void) for (j = numFixedTemporaries; j < numTemps; j++) { - if (renameTable[j] >= 0 && (collisionSet[i][j] || !TypeCompatible(temporaries[j], temporaries[i]))) + if (mRenameTable[j] >= 0 && (collisionSet[i][j] || !TypeCompatible(mTemporaries[j], mTemporaries[i]))) { - usedTemps += renameTable[j]; + usedTemps += mRenameTable[j]; } } @@ -3273,38 +3249,38 @@ void InterCodeProcedure::ReduceTemporaries(void) while (usedTemps[j]) j++; - renameTable[i] = j; + mRenameTable[i] = j; if (j >= numRenamedTemps) numRenamedTemps = j + 1; } - temporaries.SetSize(numRenamedTemps); + mTemporaries.SetSize(numRenamedTemps); ResetVisited(); - blocks[0]->GlobalRenameRegister(renameTable, temporaries); + mBlocks[0]->GlobalRenameRegister(mRenameTable, mTemporaries); delete[] collisionSet; ResetVisited(); - blocks[0]->BuildLocalTempSets(numRenamedTemps, numFixedTemporaries); + mBlocks[0]->BuildLocalTempSets(numRenamedTemps, numFixedTemporaries); ResetVisited(); - blocks[0]->BuildGlobalProvidedTempSet(NumberSet(numRenamedTemps)); + mBlocks[0]->BuildGlobalProvidedTempSet(NumberSet(numRenamedTemps)); NumberSet totalRequired3(numRenamedTemps); do { ResetVisited(); - } while (blocks[0]->BuildGlobalRequiredTempSet(totalRequired3)); + } while (mBlocks[0]->BuildGlobalRequiredTempSet(totalRequired3)); mTempOffset.SetSize(0); int offset = 0; if (!mLeafProcedure) offset += 16; - for (int i = 0; i < temporaries.Size(); i++) + for (int i = 0; i < mTemporaries.Size(); i++) { mTempOffset.Push(offset); - switch (temporaries[i]) + switch (mTemporaries[i]) { case IT_FLOAT: offset += 4; @@ -3338,7 +3314,7 @@ void InterCodeProcedure::Disassemble(const char* name, bool dumpSets) fprintf(file, "%s : %s:%d\n", name, mLocation.mFileName, mLocation.mLine); ResetVisited(); - blocks[0]->Disassemble(file, dumpSets); + mBlocks[0]->Disassemble(file, dumpSets); fclose(file); } diff --git a/oscar64/InterCode.h b/oscar64/InterCode.h index 21c7467..4a3fabf 100644 --- a/oscar64/InterCode.h +++ b/oscar64/InterCode.h @@ -116,8 +116,8 @@ typedef GrowingArray GrowingVariableArray; class ValueSet { protected: - InterInstructionPtr * instructions; - int num, size; + InterInstructionPtr * mInstructions; + int mNum, mSize; public: ValueSet(void); ValueSet(const ValueSet& values); @@ -137,96 +137,96 @@ class TempForwardingTable protected: struct Assoc { - int assoc, succ, pred; + int mAssoc, mSucc, mPred; Assoc(void) {} - Assoc(int assoc, int succ, int pred) { this->assoc = assoc; this->succ = succ; this->pred = pred; } - Assoc(const Assoc& assoc) { this->assoc = assoc.assoc; this->succ = assoc.succ; this->pred = assoc.pred; } + Assoc(int assoc, int succ, int pred) { this->mAssoc = assoc; this->mSucc = succ; this->mPred = pred; } + Assoc(const Assoc& assoc) { this->mAssoc = assoc.mAssoc; this->mSucc = assoc.mSucc; this->mPred = assoc.mPred; } }; - GrowingArray assoc; + GrowingArray mAssoc; public: - TempForwardingTable(void) : assoc(Assoc(-1, -1, -1)) + TempForwardingTable(void) : mAssoc(Assoc(-1, -1, -1)) { } - TempForwardingTable(const TempForwardingTable & table) : assoc(Assoc(-1, -1, -1)) + TempForwardingTable(const TempForwardingTable & table) : mAssoc(Assoc(-1, -1, -1)) { - for (int i = 0; i < table.assoc.Size(); i++) + for (int i = 0; i < table.mAssoc.Size(); i++) { - assoc[i].assoc = table.assoc[i].assoc; - assoc[i].succ = table.assoc[i].succ; - assoc[i].pred = table.assoc[i].pred; + mAssoc[i].mAssoc = table.mAssoc[i].mAssoc; + mAssoc[i].mSucc = table.mAssoc[i].mSucc; + mAssoc[i].mPred = table.mAssoc[i].mPred; } } void SetSize(int size) { int i; - assoc.SetSize(size); + mAssoc.SetSize(size); for (i = 0; i < size; i++) - assoc[i] = Assoc(i, i, i); + mAssoc[i] = Assoc(i, i, i); } void Reset(void) { int i; - for (i = 0; i < assoc.Size(); i++) - assoc[i] = Assoc(i, i, i); + for (i = 0; i < mAssoc.Size(); i++) + mAssoc[i] = Assoc(i, i, i); } int operator[](int n) { - return assoc[n].assoc; + return mAssoc[n].mAssoc; } void Destroy(int n) { int i, j; - if (assoc[n].assoc == n) + if (mAssoc[n].mAssoc == n) { - i = assoc[n].succ; + i = mAssoc[n].mSucc; while (i != n) { - j = assoc[i].succ; - assoc[i] = Assoc(i, i, i); + j = mAssoc[i].mSucc; + mAssoc[i] = Assoc(i, i, i); i = j; } } else { - assoc[assoc[n].pred].succ = assoc[n].succ; - assoc[assoc[n].succ].pred = assoc[n].pred; + mAssoc[mAssoc[n].mPred].mSucc = mAssoc[n].mSucc; + mAssoc[mAssoc[n].mSucc].mPred = mAssoc[n].mPred; } - assoc[n] = Assoc(n, n, n); + mAssoc[n] = Assoc(n, n, n); } void Build(int from, int to) { int i; - from = assoc[from].assoc; - to = assoc[to].assoc; + from = mAssoc[from].mAssoc; + to = mAssoc[to].mAssoc; if (from != to) { - i = assoc[from].succ; + i = mAssoc[from].mSucc; while (i != from) { - assoc[i].assoc = to; - i = assoc[i].succ; + mAssoc[i].mAssoc = to; + i = mAssoc[i].mSucc; } - assoc[from].assoc = to; + mAssoc[from].mAssoc = to; - assoc[assoc[to].succ].pred = assoc[from].pred; - assoc[assoc[from].pred].succ = assoc[to].succ; - assoc[to].succ = from; - assoc[from].pred = to; + mAssoc[mAssoc[to].mSucc].mPred = mAssoc[from].mPred; + mAssoc[mAssoc[from].mPred].mSucc = mAssoc[to].mSucc; + mAssoc[to].mSucc = from; + mAssoc[from].mPred = to; } } }; @@ -256,22 +256,18 @@ public: class InterInstruction { public: - InterCode code; - InterType ttype, stype[3]; - int ttemp, stemp[3]; - bool sfinal[3]; - __int64 siconst[3]; - double sfconst[3]; - int spconst[3]; - InterMemory mem; - InterOperator oper; - int opsize; - int vindex; - __int64 ivalue; - double fvalue; - bool zeroFrame; - Location loc; - InterCodeBasicBlock * exceptionJump; + InterCode mCode; + InterType mTType, mSType[3]; + int mTTemp, mSTemp[3]; + bool mSFinal[3]; + __int64 mSIntConst[3]; + InterMemory mMemory; + InterOperator mOperator; + int mOperandSize; + int mVarIndex; + __int64 mIntValue; + double mFloatValue; + Location mLocation; InterInstruction(void); void SetCode(const Location & loc, InterCode code); @@ -350,16 +346,15 @@ public: class InterCodeBasicBlock { public: - int num, numEntries; - InterCodeBasicBlock* trueJump, * falseJump; - GrowingInstructionArray code; + int mIndex, mNumEntries; + InterCodeBasicBlock* mTrueJump, * mFalseJump; + GrowingInstructionArray mInstructions; - bool visited; - int entryISP, entryPSP, entryFSP; + bool mVisited; - NumberSet localRequiredTemps, localProvidedTemps; - NumberSet entryRequiredTemps, entryProvidedTemps; - NumberSet exitRequiredTemps, exitProvidedTemps; + NumberSet mLocalRequiredTemps, mLocalProvidedTemps; + NumberSet mEntryRequiredTemps, mEntryProvidedTemps; + NumberSet mExitRequiredTemps, exitProvidedTemps; NumberSet mLocalRequiredVars, mLocalProvidedVars; NumberSet mEntryRequiredVars, mEntryProvidedVars; @@ -389,8 +384,8 @@ public: bool BuildGlobalRequiredVariableSet(const GrowingVariableArray& localVars, NumberSet& fromRequiredVars); bool RemoveUnusedStoreInstructions(const GrowingVariableArray& localVars); - GrowingIntArray entryRenameTable; - GrowingIntArray exitRenameTable; + GrowingIntArray mEntryRenameTable; + GrowingIntArray mExitRenameTable; void LocalRenameRegister(const GrowingIntArray& renameTable, int& num, int fixed); void BuildGlobalRenameRegisterTable(const GrowingIntArray& renameTable, GrowingIntArray& globalRenameTable); @@ -427,16 +422,16 @@ class InterCodeModule; class InterCodeProcedure { protected: - GrowingIntArray renameTable, renameUnionTable, globalRenameTable; - TempForwardingTable tempForwardingTable; - GrowingInstructionPtrArray valueForwardingTable; + GrowingIntArray mRenameTable, mRenameUnionTable, mGlobalRenameTable; + TempForwardingTable mTempForwardingTable; + GrowingInstructionPtrArray mValueForwardingTable; int numFixedTemporaries; - NumberSet localAliasedSet; + NumberSet mLocalAliasedSet; void ResetVisited(void); public: - GrowingInterCodeBasicBlockPtrArray blocks; - GrowingTypeArray temporaries; + GrowingInterCodeBasicBlockPtrArray mBlocks; + GrowingTypeArray mTemporaries; GrowingIntArray mTempOffset; int mTempSize, mCommonFrameSize; bool mLeafProcedure; diff --git a/oscar64/InterCodeGenerator.cpp b/oscar64/InterCodeGenerator.cpp index 9d01778..b8cb34b 100644 --- a/oscar64/InterCodeGenerator.cpp +++ b/oscar64/InterCodeGenerator.cpp @@ -38,16 +38,16 @@ InterCodeGenerator::ExValue InterCodeGenerator::Dereference(InterCodeProcedure* while (v.mReference > level) { InterInstruction ins; - ins.code = IC_LOAD; - ins.mem = IM_INDIRECT; - ins.stype[0] = IT_POINTER; - ins.stemp[0] = v.mTemp; - ins.ttype = v.mReference == 1 ? InterTypeOf(v.mType) : IT_POINTER; - ins.ttemp = proc->AddTemporary(ins.ttype); - ins.opsize = v.mReference == 1 ? v.mType->mSize : 2; + ins.mCode = IC_LOAD; + ins.mMemory = IM_INDIRECT; + ins.mSType[0] = IT_POINTER; + ins.mSTemp[0] = v.mTemp; + ins.mTType = v.mReference == 1 ? InterTypeOf(v.mType) : IT_POINTER; + ins.mTTemp = proc->AddTemporary(ins.mTType); + ins.mOperandSize = v.mReference == 1 ? v.mType->mSize : 2; block->Append(ins); - v = ExValue(v.mType, ins.ttemp, v.mReference - 1); + v = ExValue(v.mType, ins.mTTemp, v.mReference - 1); } return v; @@ -58,26 +58,26 @@ InterCodeGenerator::ExValue InterCodeGenerator::CoerceType(InterCodeProcedure* p if (v.mType->IsIntegerType() && type->mType == DT_TYPE_FLOAT) { InterInstruction cins; - cins.code = IC_CONVERSION_OPERATOR; - cins.oper = IA_INT2FLOAT; - cins.stype[0] = InterTypeOf(v.mType); - cins.stemp[0] = v.mTemp; - cins.ttype = IT_FLOAT; - cins.ttemp = proc->AddTemporary(cins.ttype); - v.mTemp = cins.ttemp; + cins.mCode = IC_CONVERSION_OPERATOR; + cins.mOperator = IA_INT2FLOAT; + cins.mSType[0] = InterTypeOf(v.mType); + cins.mSTemp[0] = v.mTemp; + cins.mTType = IT_FLOAT; + cins.mTTemp = proc->AddTemporary(cins.mTType); + v.mTemp = cins.mTTemp; v.mType = type; block->Append(cins); } else if (v.mType->mType == DT_TYPE_FLOAT && type->IsIntegerType()) { InterInstruction cins; - cins.code = IC_CONVERSION_OPERATOR; - cins.oper = IA_FLOAT2INT; - cins.stype[0] = InterTypeOf(v.mType); - cins.stemp[0] = v.mTemp; - cins.ttype = InterTypeOf(type); - cins.ttemp = proc->AddTemporary(cins.ttype); - v.mTemp = cins.ttemp; + cins.mCode = IC_CONVERSION_OPERATOR; + cins.mOperator = IA_FLOAT2INT; + cins.mSType[0] = InterTypeOf(v.mType); + cins.mSTemp[0] = v.mTemp; + cins.mTType = InterTypeOf(type); + cins.mTTemp = proc->AddTemporary(cins.mTType); + v.mTemp = cins.mTTemp; v.mType = type; block->Append(cins); } @@ -337,40 +337,40 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* case DT_CONST_INTEGER: { InterInstruction ins; - ins.code = IC_CONSTANT; - ins.ttype = InterTypeOf(dec->mBase); - ins.ttemp = proc->AddTemporary(ins.ttype); - if (ins.ttype == IT_SIGNED) - ins.ivalue = short(dec->mInteger); + ins.mCode = IC_CONSTANT; + ins.mTType = InterTypeOf(dec->mBase); + ins.mTTemp = proc->AddTemporary(ins.mTType); + if (ins.mTType == IT_SIGNED) + ins.mIntValue = short(dec->mInteger); else - ins.ivalue = unsigned short(dec->mInteger); + ins.mIntValue = unsigned short(dec->mInteger); block->Append(ins); - return ExValue(dec->mBase, ins.ttemp); + return ExValue(dec->mBase, ins.mTTemp); } break; case DT_CONST_FLOAT: { InterInstruction ins; - ins.code = IC_CONSTANT; - ins.ttype = InterTypeOf(dec->mBase); - ins.ttemp = proc->AddTemporary(ins.ttype); - ins.fvalue = dec->mNumber; + ins.mCode = IC_CONSTANT; + ins.mTType = InterTypeOf(dec->mBase); + ins.mTTemp = proc->AddTemporary(ins.mTType); + ins.mFloatValue = dec->mNumber; block->Append(ins); - return ExValue(dec->mBase, ins.ttemp); + return ExValue(dec->mBase, ins.mTTemp); } break; case DT_CONST_ADDRESS: { InterInstruction ins; - ins.code = IC_CONSTANT; - ins.ttype = IT_POINTER; - ins.ttemp = proc->AddTemporary(IT_POINTER); - ins.ivalue = dec->mInteger; - ins.mem = IM_ABSOLUTE; + ins.mCode = IC_CONSTANT; + ins.mTType = IT_POINTER; + ins.mTTemp = proc->AddTemporary(IT_POINTER); + ins.mIntValue = dec->mInteger; + ins.mMemory = IM_ABSOLUTE; block->Append(ins); - return ExValue(dec->mBase, ins.ttemp); + return ExValue(dec->mBase, ins.mTTemp); } break; @@ -383,14 +383,14 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* } InterInstruction ins; - ins.code = IC_CONSTANT; - ins.ttype = InterTypeOf(dec->mBase); - ins.ttemp = proc->AddTemporary(ins.ttype); - ins.vindex = dec->mVarIndex; - ins.mem = IM_PROCEDURE; - ins.ivalue = 0; + ins.mCode = IC_CONSTANT; + ins.mTType = InterTypeOf(dec->mBase); + ins.mTTemp = proc->AddTemporary(ins.mTType); + ins.mVarIndex = dec->mVarIndex; + ins.mMemory = IM_PROCEDURE; + ins.mIntValue = 0; block->Append(ins); - return ExValue(dec->mBase, ins.ttemp); + return ExValue(dec->mBase, ins.mTTemp); } break; @@ -414,14 +414,14 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* } InterInstruction ins; - ins.code = IC_CONSTANT; - ins.ttype = IT_POINTER; - ins.ttemp = proc->AddTemporary(IT_POINTER); - ins.ivalue = 0; - ins.vindex = dec->mVarIndex; - ins.mem = IM_GLOBAL; + ins.mCode = IC_CONSTANT; + ins.mTType = IT_POINTER; + ins.mTTemp = proc->AddTemporary(IT_POINTER); + ins.mIntValue = 0; + ins.mVarIndex = dec->mVarIndex; + ins.mMemory = IM_GLOBAL; block->Append(ins); - return ExValue(dec->mBase, ins.ttemp); + return ExValue(dec->mBase, ins.mTTemp); } default: @@ -435,28 +435,28 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* dec = exp->mDecValue; InterInstruction ins; - ins.code = IC_CONSTANT; - ins.ttype = IT_POINTER; - ins.ttemp = proc->AddTemporary(ins.ttype); - ins.opsize = dec->mSize; - ins.ivalue = dec->mOffset; + ins.mCode = IC_CONSTANT; + ins.mTType = IT_POINTER; + ins.mTTemp = proc->AddTemporary(ins.mTType); + ins.mOperandSize = dec->mSize; + ins.mIntValue = dec->mOffset; if (dec->mType == DT_ARGUMENT) - ins.mem = IM_PARAM; + ins.mMemory = IM_PARAM; else if (dec->mFlags & DTF_GLOBAL) { InitGlobalVariable(proc->mModule, dec); - ins.mem = IM_GLOBAL; + ins.mMemory = IM_GLOBAL; } else - ins.mem = IM_LOCAL; - ins.vindex = dec->mVarIndex; + ins.mMemory = IM_LOCAL; + ins.mVarIndex = dec->mVarIndex; block->Append(ins); if (!(dec->mBase->mFlags & DTF_DEFINED)) mErrors->Error(dec->mLocation, "Undefined variable type"); - return ExValue(dec->mBase, ins.ttemp, 1); + return ExValue(dec->mBase, ins.mTTemp, 1); } @@ -483,13 +483,13 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* InterInstruction ins; - ins.code = IC_COPY; - ins.mem = IM_INDIRECT; - ins.stype[0] = IT_POINTER; - ins.stemp[0] = vr.mTemp; - ins.stype[1] = IT_POINTER; - ins.stemp[1] = vl.mTemp; - ins.opsize = vl.mType->mSize; + ins.mCode = IC_COPY; + ins.mMemory = IM_INDIRECT; + ins.mSType[0] = IT_POINTER; + ins.mSTemp[0] = vr.mTemp; + ins.mSType[1] = IT_POINTER; + ins.mSTemp[1] = vl.mTemp; + ins.mOperandSize = vl.mType->mSize; block->Append(ins); } else @@ -513,15 +513,15 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* if (vl.mType->mType == DT_TYPE_POINTER) { InterInstruction cins; - cins.code = IC_CONSTANT; + cins.mCode = IC_CONSTANT; if (exp->mToken == TK_ASSIGN_ADD) { - cins.ivalue = vl.mType->mBase->mSize; + cins.mIntValue = vl.mType->mBase->mSize; } else if (exp->mToken == TK_ASSIGN_SUB) { - cins.ivalue = -vl.mType->mBase->mSize; + cins.mIntValue = -vl.mType->mBase->mSize; } else mErrors->Error(exp->mLocation, "Invalid pointer assignment"); @@ -529,30 +529,30 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* if (!vr.mType->IsIntegerType()) mErrors->Error(exp->mLocation, "Invalid argument for pointer inc/dec"); - cins.ttype = IT_SIGNED; - cins.ttemp = proc->AddTemporary(cins.ttype); + cins.mTType = IT_SIGNED; + cins.mTTemp = proc->AddTemporary(cins.mTType); block->Append(cins); InterInstruction mins; - mins.code = IC_BINARY_OPERATOR; - mins.oper = IA_MUL; - mins.stype[0] = IT_SIGNED; - mins.stemp[0] = vr.mTemp; - mins.stype[1] = IT_SIGNED; - mins.stemp[1] = cins.ttemp; - mins.ttype = IT_SIGNED; - mins.ttemp = proc->AddTemporary(mins.ttype); + mins.mCode = IC_BINARY_OPERATOR; + mins.mOperator = IA_MUL; + mins.mSType[0] = IT_SIGNED; + mins.mSTemp[0] = vr.mTemp; + mins.mSType[1] = IT_SIGNED; + mins.mSTemp[1] = cins.mTTemp; + mins.mTType = IT_SIGNED; + mins.mTTemp = proc->AddTemporary(mins.mTType); block->Append(mins); InterInstruction ains; - ains.code = IC_LEA; - ains.mem = IM_INDIRECT; - ains.stype[0] = IT_SIGNED; - ains.stemp[0] = mins.ttemp; - ains.stype[1] = IT_POINTER; - ains.stemp[1] = vl.mTemp; - ains.ttype = IT_POINTER; - ains.ttemp = proc->AddTemporary(ains.ttype); + ains.mCode = IC_LEA; + ains.mMemory = IM_INDIRECT; + ains.mSType[0] = IT_SIGNED; + ains.mSTemp[0] = mins.mTTemp; + ains.mSType[1] = IT_POINTER; + ains.mSTemp[1] = vl.mTemp; + ains.mTType = IT_POINTER; + ains.mTTemp = proc->AddTemporary(ains.mTType); block->Append(ains); } else @@ -560,38 +560,38 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* if (vll.mType->IsIntegerType() && vr.mType->mType == DT_TYPE_FLOAT) { InterInstruction cins; - cins.code = IC_CONVERSION_OPERATOR; - cins.oper = IA_FLOAT2INT; - cins.stype[0] = InterTypeOf(vr.mType); - cins.stemp[0] = vr.mTemp; - cins.ttype = InterTypeOf(vll.mType); - cins.ttemp = proc->AddTemporary(cins.ttype); - vr.mTemp = cins.ttemp; + cins.mCode = IC_CONVERSION_OPERATOR; + cins.mOperator = IA_FLOAT2INT; + cins.mSType[0] = InterTypeOf(vr.mType); + cins.mSTemp[0] = vr.mTemp; + cins.mTType = InterTypeOf(vll.mType); + cins.mTTemp = proc->AddTemporary(cins.mTType); + vr.mTemp = cins.mTTemp; vr.mType = TheSignedIntTypeDeclaration; block->Append(cins); } else if (vll.mType->mType == DT_TYPE_FLOAT && vr.mType->IsIntegerType()) { InterInstruction cins; - cins.code = IC_CONVERSION_OPERATOR; - cins.oper = IA_INT2FLOAT; - cins.stype[0] = InterTypeOf(vr.mType); - cins.stemp[0] = vr.mTemp; - cins.ttype = InterTypeOf(vll.mType);; - cins.ttemp = proc->AddTemporary(cins.ttype); - vr.mTemp = cins.ttemp; + cins.mCode = IC_CONVERSION_OPERATOR; + cins.mOperator = IA_INT2FLOAT; + cins.mSType[0] = InterTypeOf(vr.mType); + cins.mSTemp[0] = vr.mTemp; + cins.mTType = InterTypeOf(vll.mType);; + cins.mTTemp = proc->AddTemporary(cins.mTType); + vr.mTemp = cins.mTTemp; vr.mType = TheFloatTypeDeclaration; block->Append(cins); } InterInstruction oins; - oins.code = IC_BINARY_OPERATOR; - oins.stype[0] = InterTypeOf(vr.mType); - oins.stemp[0] = vr.mTemp; - oins.stype[1] = InterTypeOf(vll.mType); - oins.stemp[1] = vll.mTemp; - oins.ttype = InterTypeOf(vll.mType); - oins.ttemp = proc->AddTemporary(oins.ttype); + oins.mCode = IC_BINARY_OPERATOR; + oins.mSType[0] = InterTypeOf(vr.mType); + oins.mSTemp[0] = vr.mTemp; + oins.mSType[1] = InterTypeOf(vll.mType); + oins.mSTemp[1] = vll.mTemp; + oins.mTType = InterTypeOf(vll.mType); + oins.mTTemp = proc->AddTemporary(oins.mTType); if (!vll.mType->IsNumericType()) mErrors->Error(exp->mLocation, "Left hand element type is not numeric"); @@ -601,38 +601,38 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* switch (exp->mToken) { case TK_ASSIGN_ADD: - oins.oper = IA_ADD; + oins.mOperator = IA_ADD; break; case TK_ASSIGN_SUB: - oins.oper = IA_SUB; + oins.mOperator = IA_SUB; break; case TK_ASSIGN_MUL: - oins.oper = IA_MUL; + oins.mOperator = IA_MUL; break; case TK_ASSIGN_DIV: - oins.oper = IA_DIVS; + oins.mOperator = IA_DIVS; break; case TK_ASSIGN_MOD: - oins.oper = IA_MODS; + oins.mOperator = IA_MODS; break; case TK_ASSIGN_SHL: - oins.oper = IA_SHL; + oins.mOperator = IA_SHL; break; case TK_ASSIGN_SHR: - oins.oper = IA_SHR; + oins.mOperator = IA_SHR; break; case TK_ASSIGN_AND: - oins.oper = IA_AND; + oins.mOperator = IA_AND; break; case TK_ASSIGN_XOR: - oins.oper = IA_XOR; + oins.mOperator = IA_XOR; break; case TK_ASSIGN_OR: - oins.oper = IA_OR; + oins.mOperator = IA_OR; break; } - vr.mTemp = oins.ttemp; + vr.mTemp = oins.mTTemp; vr.mType = vll.mType; block->Append(oins); @@ -643,38 +643,38 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* if (vl.mType->IsIntegerType() && vr.mType->mType == DT_TYPE_FLOAT) { InterInstruction cins; - cins.code = IC_CONVERSION_OPERATOR; - cins.oper = IA_FLOAT2INT; - cins.stype[0] = InterTypeOf(vr.mType); - cins.stemp[0] = vr.mTemp; - cins.ttype = InterTypeOf(vl.mType); - cins.ttemp = proc->AddTemporary(cins.ttype); - vr.mTemp = cins.ttemp; + cins.mCode = IC_CONVERSION_OPERATOR; + cins.mOperator = IA_FLOAT2INT; + cins.mSType[0] = InterTypeOf(vr.mType); + cins.mSTemp[0] = vr.mTemp; + cins.mTType = InterTypeOf(vl.mType); + cins.mTTemp = proc->AddTemporary(cins.mTType); + vr.mTemp = cins.mTTemp; vr.mType = TheSignedIntTypeDeclaration; block->Append(cins); } else if (vl.mType->mType == DT_TYPE_FLOAT && vr.mType->IsIntegerType()) { InterInstruction cins; - cins.code = IC_CONVERSION_OPERATOR; - cins.oper = IA_INT2FLOAT; - cins.stype[0] = InterTypeOf(vr.mType); - cins.stemp[0] = vr.mTemp; - cins.ttype = InterTypeOf(vl.mType);; - cins.ttemp = proc->AddTemporary(cins.ttype); - vr.mTemp = cins.ttemp; + cins.mCode = IC_CONVERSION_OPERATOR; + cins.mOperator = IA_INT2FLOAT; + cins.mSType[0] = InterTypeOf(vr.mType); + cins.mSTemp[0] = vr.mTemp; + cins.mTType = InterTypeOf(vl.mType);; + cins.mTTemp = proc->AddTemporary(cins.mTType); + vr.mTemp = cins.mTTemp; vr.mType = TheFloatTypeDeclaration; block->Append(cins); } } - ins.code = IC_STORE; - ins.mem = IM_INDIRECT; - ins.stype[0] = InterTypeOf(vr.mType); - ins.stemp[0] = vr.mTemp; - ins.stype[1] = IT_POINTER; - ins.stemp[1] = vl.mTemp; - ins.opsize = vl.mType->mSize; + ins.mCode = IC_STORE; + ins.mMemory = IM_INDIRECT; + ins.mSType[0] = InterTypeOf(vr.mType); + ins.mSTemp[0] = vr.mTemp; + ins.mSType[1] = IT_POINTER; + ins.mSTemp[1] = vl.mTemp; + ins.mOperandSize = vl.mType->mSize; block->Append(ins); } } @@ -696,35 +696,35 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* mErrors->Error(exp->mLocation, "Index operand is not integral number"); InterInstruction cins; - cins.code = IC_CONSTANT; - cins.ivalue = vl.mType->mBase->mSize; - cins.ttype = IT_SIGNED; - cins.ttemp = proc->AddTemporary(cins.ttype); + cins.mCode = IC_CONSTANT; + cins.mIntValue = vl.mType->mBase->mSize; + cins.mTType = IT_SIGNED; + cins.mTTemp = proc->AddTemporary(cins.mTType); block->Append(cins); InterInstruction mins; - mins.code = IC_BINARY_OPERATOR; - mins.oper = IA_MUL; - mins.stype[0] = IT_SIGNED; - mins.stemp[0] = vr.mTemp; - mins.stype[1] = IT_SIGNED; - mins.stemp[1] = cins.ttemp; - mins.ttype = IT_SIGNED; - mins.ttemp = proc->AddTemporary(mins.ttype); + mins.mCode = IC_BINARY_OPERATOR; + mins.mOperator = IA_MUL; + mins.mSType[0] = IT_SIGNED; + mins.mSTemp[0] = vr.mTemp; + mins.mSType[1] = IT_SIGNED; + mins.mSTemp[1] = cins.mTTemp; + mins.mTType = IT_SIGNED; + mins.mTTemp = proc->AddTemporary(mins.mTType); block->Append(mins); InterInstruction ains; - ains.code = IC_LEA; - ains.mem = IM_INDIRECT; - ains.stype[0] = IT_SIGNED; - ains.stemp[0] = mins.ttemp; - ains.stype[1] = IT_POINTER; - ains.stemp[1] = vl.mTemp; - ains.ttype = IT_POINTER; - ains.ttemp = proc->AddTemporary(ains.ttype); + ains.mCode = IC_LEA; + ains.mMemory = IM_INDIRECT; + ains.mSType[0] = IT_SIGNED; + ains.mSTemp[0] = mins.mTTemp; + ains.mSType[1] = IT_POINTER; + ains.mSTemp[1] = vl.mTemp; + ains.mTType = IT_POINTER; + ains.mTTemp = proc->AddTemporary(ains.mTType); block->Append(ains); - return ExValue(vl.mType->mBase, ains.ttemp, 1); + return ExValue(vl.mType->mBase, ains.mTTemp, 1); } case EX_QUALIFY: @@ -736,24 +736,24 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* mErrors->Error(exp->mLocation, "Not an addressable expression"); InterInstruction cins; - cins.code = IC_CONSTANT; - cins.ivalue = exp->mDecValue->mOffset; - cins.ttype = IT_SIGNED; - cins.ttemp = proc->AddTemporary(cins.ttype); + cins.mCode = IC_CONSTANT; + cins.mIntValue = exp->mDecValue->mOffset; + cins.mTType = IT_SIGNED; + cins.mTTemp = proc->AddTemporary(cins.mTType); block->Append(cins); InterInstruction ains; - ains.code = IC_LEA; - ains.mem = IM_INDIRECT; - ains.stype[0] = IT_SIGNED; - ains.stemp[0] = cins.ttemp; - ains.stype[1] = IT_POINTER; - ains.stemp[1] = vl.mTemp; - ains.ttype = IT_POINTER; - ains.ttemp = proc->AddTemporary(ains.ttype); + ains.mCode = IC_LEA; + ains.mMemory = IM_INDIRECT; + ains.mSType[0] = IT_SIGNED; + ains.mSTemp[0] = cins.mTTemp; + ains.mSType[1] = IT_POINTER; + ains.mSTemp[1] = vl.mTemp; + ains.mTType = IT_POINTER; + ains.mTTemp = proc->AddTemporary(ains.mTType); block->Append(ains); - return ExValue(exp->mDecValue->mBase, ains.ttemp, 1); + return ExValue(exp->mDecValue->mBase, ains.mTTemp, 1); } case EX_BINARY: @@ -781,42 +781,42 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* if (vr.mType->IsIntegerType()) { InterInstruction cins; - cins.code = IC_CONSTANT; + cins.mCode = IC_CONSTANT; if (exp->mToken == TK_ADD) { - cins.ivalue = vl.mType->mBase->mSize; + cins.mIntValue = vl.mType->mBase->mSize; } else if (exp->mToken == TK_SUB) { - cins.ivalue = -vl.mType->mBase->mSize; + cins.mIntValue = -vl.mType->mBase->mSize; } else mErrors->Error(exp->mLocation, "Invalid pointer operation"); - cins.ttype = IT_SIGNED; - cins.ttemp = proc->AddTemporary(cins.ttype); + cins.mTType = IT_SIGNED; + cins.mTTemp = proc->AddTemporary(cins.mTType); block->Append(cins); InterInstruction mins; - mins.code = IC_BINARY_OPERATOR; - mins.oper = IA_MUL; - mins.stype[0] = IT_SIGNED; - mins.stemp[0] = vr.mTemp; - mins.stype[1] = IT_SIGNED; - mins.stemp[1] = cins.ttemp; - mins.ttype = IT_SIGNED; - mins.ttemp = proc->AddTemporary(mins.ttype); + mins.mCode = IC_BINARY_OPERATOR; + mins.mOperator = IA_MUL; + mins.mSType[0] = IT_SIGNED; + mins.mSTemp[0] = vr.mTemp; + mins.mSType[1] = IT_SIGNED; + mins.mSTemp[1] = cins.mTTemp; + mins.mTType = IT_SIGNED; + mins.mTTemp = proc->AddTemporary(mins.mTType); block->Append(mins); - ins.code = IC_LEA; - ins.mem = IM_INDIRECT; - ins.stype[0] = IT_SIGNED; - ins.stemp[0] = mins.ttemp; - ins.stype[1] = IT_POINTER; - ins.stemp[1] = vl.mTemp; - ins.ttype = IT_POINTER; - ins.ttemp = proc->AddTemporary(ins.ttype); + ins.mCode = IC_LEA; + ins.mMemory = IM_INDIRECT; + ins.mSType[0] = IT_SIGNED; + ins.mSTemp[0] = mins.mTTemp; + ins.mSType[1] = IT_POINTER; + ins.mSTemp[1] = vl.mTemp; + ins.mTType = IT_POINTER; + ins.mTTemp = proc->AddTemporary(ins.mTType); block->Append(ins); } else if (vr.mType->IsSame(vl.mType)) @@ -824,49 +824,49 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* if (exp->mToken == TK_SUB) { InterInstruction clins, crins; - clins.code = IC_TYPECAST; - clins.stemp[0] = vl.mTemp; - clins.stype[0] = IT_POINTER; - clins.ttype = IT_SIGNED; - clins.ttemp = proc->AddTemporary(clins.ttype); + clins.mCode = IC_TYPECAST; + clins.mSTemp[0] = vl.mTemp; + clins.mSType[0] = IT_POINTER; + clins.mTType = IT_SIGNED; + clins.mTTemp = proc->AddTemporary(clins.mTType); block->Append(clins); - crins.code = IC_TYPECAST; - crins.stemp[0] = vr.mTemp; - crins.stype[0] = IT_POINTER; - crins.ttype = IT_SIGNED; - crins.ttemp = proc->AddTemporary(crins.ttype); + crins.mCode = IC_TYPECAST; + crins.mSTemp[0] = vr.mTemp; + crins.mSType[0] = IT_POINTER; + crins.mTType = IT_SIGNED; + crins.mTTemp = proc->AddTemporary(crins.mTType); block->Append(crins); InterInstruction cins; - cins.code = IC_CONSTANT; - cins.ivalue = vl.mType->mBase->mSize; - cins.ttype = IT_SIGNED; - cins.ttemp = proc->AddTemporary(cins.ttype); + cins.mCode = IC_CONSTANT; + cins.mIntValue = vl.mType->mBase->mSize; + cins.mTType = IT_SIGNED; + cins.mTTemp = proc->AddTemporary(cins.mTType); block->Append(cins); InterInstruction sins, dins; - sins.code = IC_BINARY_OPERATOR; - sins.oper = IA_SUB; - sins.stype[0] = IT_SIGNED; - sins.stemp[0] = crins.ttemp; - sins.stype[1] = IT_SIGNED; - sins.stemp[1] = clins.ttemp; - sins.ttype = IT_SIGNED; - sins.ttemp = proc->AddTemporary(sins.ttype); + sins.mCode = IC_BINARY_OPERATOR; + sins.mOperator = IA_SUB; + sins.mSType[0] = IT_SIGNED; + sins.mSTemp[0] = crins.mTTemp; + sins.mSType[1] = IT_SIGNED; + sins.mSTemp[1] = clins.mTTemp; + sins.mTType = IT_SIGNED; + sins.mTTemp = proc->AddTemporary(sins.mTType); block->Append(sins); - dins.code = IC_BINARY_OPERATOR; - dins.oper = IA_DIVS; - dins.stype[0] = IT_SIGNED; - dins.stemp[0] = cins.ttemp; - dins.stype[1] = IT_SIGNED; - dins.stemp[1] = sins.ttemp; - dins.ttype = IT_SIGNED; - dins.ttemp = proc->AddTemporary(dins.ttype); + dins.mCode = IC_BINARY_OPERATOR; + dins.mOperator = IA_DIVS; + dins.mSType[0] = IT_SIGNED; + dins.mSTemp[0] = cins.mTTemp; + dins.mSType[1] = IT_SIGNED; + dins.mSTemp[1] = sins.mTTemp; + dins.mTType = IT_SIGNED; + dins.mTTemp = proc->AddTemporary(dins.mTType); block->Append(dins); - return ExValue(TheSignedIntTypeDeclaration, dins.ttemp); + return ExValue(TheSignedIntTypeDeclaration, dins.mTTemp); } else mErrors->Error(exp->mLocation, "Invalid pointer operation"); @@ -884,77 +884,77 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* if (vl.mType->IsIntegerType() && vr.mType->mType == DT_TYPE_FLOAT) { InterInstruction cins; - cins.code = IC_CONVERSION_OPERATOR; - cins.oper = IA_INT2FLOAT; - cins.stype[0] = InterTypeOf(vl.mType); - cins.stemp[0] = vl.mTemp; - cins.ttype = IT_FLOAT; - cins.ttemp = proc->AddTemporary(cins.ttype); - vl.mTemp = cins.ttemp; + cins.mCode = IC_CONVERSION_OPERATOR; + cins.mOperator = IA_INT2FLOAT; + cins.mSType[0] = InterTypeOf(vl.mType); + cins.mSTemp[0] = vl.mTemp; + cins.mTType = IT_FLOAT; + cins.mTTemp = proc->AddTemporary(cins.mTType); + vl.mTemp = cins.mTTemp; vl.mType = TheFloatTypeDeclaration; block->Append(cins); } else if (vl.mType->mType == DT_TYPE_FLOAT && vr.mType->IsIntegerType()) { InterInstruction cins; - cins.code = IC_CONVERSION_OPERATOR; - cins.oper = IA_INT2FLOAT; - cins.stype[0] = InterTypeOf(vr.mType); - cins.stemp[0] = vr.mTemp; - cins.ttype = IT_FLOAT; - cins.ttemp = proc->AddTemporary(cins.ttype); - vr.mTemp = cins.ttemp; + cins.mCode = IC_CONVERSION_OPERATOR; + cins.mOperator = IA_INT2FLOAT; + cins.mSType[0] = InterTypeOf(vr.mType); + cins.mSTemp[0] = vr.mTemp; + cins.mTType = IT_FLOAT; + cins.mTTemp = proc->AddTemporary(cins.mTType); + vr.mTemp = cins.mTTemp; vr.mType = TheFloatTypeDeclaration; block->Append(cins); } bool signedOP = (vl.mType->mFlags & DTF_SIGNED) && (vr.mType->mFlags & DTF_SIGNED); - ins.code = IC_BINARY_OPERATOR; + ins.mCode = IC_BINARY_OPERATOR; switch (exp->mToken) { case TK_ADD: - ins.oper = IA_ADD; + ins.mOperator = IA_ADD; break; case TK_SUB: - ins.oper = IA_SUB; + ins.mOperator = IA_SUB; break; case TK_MUL: - ins.oper = IA_MUL; + ins.mOperator = IA_MUL; break; case TK_DIV: - ins.oper = signedOP ? IA_DIVS : IA_DIVU; + ins.mOperator = signedOP ? IA_DIVS : IA_DIVU; break; case TK_MOD: - ins.oper = signedOP ? IA_MODS : IA_MODU; + ins.mOperator = signedOP ? IA_MODS : IA_MODU; break; case TK_LEFT_SHIFT: - ins.oper = IA_SHL; + ins.mOperator = IA_SHL; break; case TK_RIGHT_SHIFT: - ins.oper = (vl.mType->mFlags & DTF_SIGNED) ? IA_SAR : IA_SHR; + ins.mOperator = (vl.mType->mFlags & DTF_SIGNED) ? IA_SAR : IA_SHR; break; case TK_BINARY_AND: - ins.oper = IA_AND; + ins.mOperator = IA_AND; break; case TK_BINARY_OR: - ins.oper = IA_OR; + ins.mOperator = IA_OR; break; case TK_BINARY_XOR: - ins.oper = IA_XOR; + ins.mOperator = IA_XOR; break; } - ins.stype[0] = InterTypeOf(vr.mType);; - ins.stemp[0] = vr.mTemp; - ins.stype[1] = InterTypeOf(vl.mType);; - ins.stemp[1] = vl.mTemp; - ins.ttype = InterTypeOfArithmetic(ins.stype[0], ins.stype[1]); - ins.ttemp = proc->AddTemporary(ins.ttype); + ins.mSType[0] = InterTypeOf(vr.mType);; + ins.mSTemp[0] = vr.mTemp; + ins.mSType[1] = InterTypeOf(vl.mType);; + ins.mSTemp[1] = vl.mTemp; + ins.mTType = InterTypeOfArithmetic(ins.mSType[0], ins.mSType[1]); + ins.mTTemp = proc->AddTemporary(ins.mTType); block->Append(ins); } - return ExValue(vl.mType, ins.ttemp); + return ExValue(vl.mType, ins.mTTemp); } @@ -975,38 +975,38 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* bool ftype = vl.mType->mType == DT_TYPE_FLOAT; - cins.code = IC_CONSTANT; - cins.ttype = ftype ? IT_FLOAT : IT_SIGNED; - cins.ttemp = proc->AddTemporary(cins.ttype); + cins.mCode = IC_CONSTANT; + cins.mTType = ftype ? IT_FLOAT : IT_SIGNED; + cins.mTTemp = proc->AddTemporary(cins.mTType); if (vdl.mType->mType == DT_TYPE_POINTER) - cins.ivalue = exp->mToken == TK_INC ? vdl.mType->mBase->mSize : -(vdl.mType->mBase->mSize); + cins.mIntValue = exp->mToken == TK_INC ? vdl.mType->mBase->mSize : -(vdl.mType->mBase->mSize); else if (vdl.mType->IsNumericType()) - cins.ivalue = exp->mToken == TK_INC ? 1 : -1; + cins.mIntValue = exp->mToken == TK_INC ? 1 : -1; else mErrors->Error(exp->mLocation, "Not a numeric value or pointer"); block->Append(cins); - ains.code = IC_BINARY_OPERATOR; - ains.oper = IA_ADD; - ains.stype[0] = cins.ttype; - ains.stemp[0] = cins.ttemp; - ains.stype[1] = InterTypeOf(vdl.mType); - ains.stemp[1] = vdl.mTemp; - ains.ttype = ains.stype[1]; - ains.ttemp = proc->AddTemporary(ains.ttype); + ains.mCode = IC_BINARY_OPERATOR; + ains.mOperator = IA_ADD; + ains.mSType[0] = cins.mTType; + ains.mSTemp[0] = cins.mTTemp; + ains.mSType[1] = InterTypeOf(vdl.mType); + ains.mSTemp[1] = vdl.mTemp; + ains.mTType = ains.mSType[1]; + ains.mTTemp = proc->AddTemporary(ains.mTType); block->Append(ains); - sins.code = IC_STORE; - sins.mem = IM_INDIRECT; - sins.stype[0] = ains.ttype; - sins.stemp[0] = ains.ttemp; - sins.stype[1] = IT_POINTER; - sins.stemp[1] = vl.mTemp; - sins.opsize = vl.mType->mSize; + sins.mCode = IC_STORE; + sins.mMemory = IM_INDIRECT; + sins.mSType[0] = ains.mTType; + sins.mSTemp[0] = ains.mTTemp; + sins.mSType[1] = IT_POINTER; + sins.mSTemp[1] = vl.mTemp; + sins.mOperandSize = vl.mType->mSize; block->Append(sins); - return ExValue(vdl.mType, ains.ttemp); + return ExValue(vdl.mType, ains.mTTemp); } break; @@ -1027,34 +1027,34 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* bool ftype = vl.mType->mType == DT_TYPE_FLOAT; - cins.code = IC_CONSTANT; - cins.ttype = ftype ? IT_FLOAT : IT_SIGNED; - cins.ttemp = proc->AddTemporary(cins.ttype); + cins.mCode = IC_CONSTANT; + cins.mTType = ftype ? IT_FLOAT : IT_SIGNED; + cins.mTTemp = proc->AddTemporary(cins.mTType); if (vdl.mType->mType == DT_TYPE_POINTER) - cins.ivalue = exp->mToken == TK_INC ? vdl.mType->mBase->mSize : -(vdl.mType->mBase->mSize); + cins.mIntValue = exp->mToken == TK_INC ? vdl.mType->mBase->mSize : -(vdl.mType->mBase->mSize); else if (vdl.mType->IsNumericType()) - cins.ivalue = exp->mToken == TK_INC ? 1 : -1; + cins.mIntValue = exp->mToken == TK_INC ? 1 : -1; else mErrors->Error(exp->mLocation, "Not a numeric value or pointer"); block->Append(cins); - ains.code = IC_BINARY_OPERATOR; - ains.oper = IA_ADD; - ains.stype[0] = cins.ttype; - ains.stemp[0] = cins.ttemp; - ains.stype[1] = InterTypeOf(vdl.mType); - ains.stemp[1] = vdl.mTemp; - ains.ttype = ains.stype[1]; - ains.ttemp = proc->AddTemporary(ains.ttype); + ains.mCode = IC_BINARY_OPERATOR; + ains.mOperator = IA_ADD; + ains.mSType[0] = cins.mTType; + ains.mSTemp[0] = cins.mTTemp; + ains.mSType[1] = InterTypeOf(vdl.mType); + ains.mSTemp[1] = vdl.mTemp; + ains.mTType = ains.mSType[1]; + ains.mTTemp = proc->AddTemporary(ains.mTType); block->Append(ains); - sins.code = IC_STORE; - sins.mem = IM_INDIRECT; - sins.stype[0] = ains.ttype; - sins.stemp[0] = ains.ttemp; - sins.stype[1] = IT_POINTER; - sins.stemp[1] = vl.mTemp; - sins.opsize = vl.mType->mSize; + sins.mCode = IC_STORE; + sins.mMemory = IM_INDIRECT; + sins.mSType[0] = ains.mTType; + sins.mSTemp[0] = ains.mTTemp; + sins.mSType[1] = IT_POINTER; + sins.mSTemp[1] = vl.mTemp; + sins.mOperandSize = vl.mType->mSize; block->Append(sins); return ExValue(vdl.mType, vdl.mTemp); @@ -1067,25 +1067,25 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* InterInstruction ins; - ins.code = IC_UNARY_OPERATOR; + ins.mCode = IC_UNARY_OPERATOR; switch (exp->mToken) { case TK_ADD: vl = Dereference(proc, block, vl); - ins.oper = IA_NONE; + ins.mOperator = IA_NONE; break; case TK_SUB: vl = Dereference(proc, block, vl); if (!vl.mType->IsNumericType()) mErrors->Error(exp->mLocation, "Not a numeric type"); - ins.oper = IA_NEG; + ins.mOperator = IA_NEG; break; case TK_BINARY_NOT: vl = Dereference(proc, block, vl); if (!(vl.mType->mType == DT_TYPE_POINTER || vl.mType->IsNumericType())) mErrors->Error(exp->mLocation, "Not a numeric or pointer type"); - ins.oper = IA_NOT; + ins.mOperator = IA_NOT; break; case TK_MUL: if (vl.mType->mType != DT_TYPE_POINTER) @@ -1104,14 +1104,14 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* } } - ins.stype[0] = InterTypeOf(vl.mType); - ins.stemp[0] = vl.mTemp; - ins.ttype = ins.stype[0]; - ins.ttemp = proc->AddTemporary(ins.ttype); + ins.mSType[0] = InterTypeOf(vl.mType); + ins.mSTemp[0] = vl.mTemp; + ins.mTType = ins.mSType[0]; + ins.mTTemp = proc->AddTemporary(ins.mTType); block->Append(ins); - return ExValue(vl.mType, ins.ttemp); + return ExValue(vl.mType, ins.mTTemp); } case EX_RELATIONAL: @@ -1131,62 +1131,62 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* if (vl.mType->IsIntegerType() && vr.mType->mType == DT_TYPE_FLOAT) { InterInstruction cins; - cins.code = IC_CONVERSION_OPERATOR; - cins.oper = IA_INT2FLOAT; - cins.stype[0] = InterTypeOf(vl.mType); - cins.stemp[0] = vl.mTemp; - cins.ttype = IT_FLOAT; - cins.ttemp = proc->AddTemporary(cins.ttype); - vl.mTemp = cins.ttemp; + cins.mCode = IC_CONVERSION_OPERATOR; + cins.mOperator = IA_INT2FLOAT; + cins.mSType[0] = InterTypeOf(vl.mType); + cins.mSTemp[0] = vl.mTemp; + cins.mTType = IT_FLOAT; + cins.mTTemp = proc->AddTemporary(cins.mTType); + vl.mTemp = cins.mTTemp; vl.mType = TheFloatTypeDeclaration; block->Append(cins); } else if (vl.mType->mType == DT_TYPE_FLOAT && vr.mType->IsIntegerType()) { InterInstruction cins; - cins.code = IC_CONVERSION_OPERATOR; - cins.oper = IA_INT2FLOAT; - cins.stype[0] = InterTypeOf(vr.mType); - cins.stemp[0] = vr.mTemp; - cins.ttype = IT_FLOAT; - cins.ttemp = proc->AddTemporary(cins.ttype); - vr.mTemp = cins.ttemp; + cins.mCode = IC_CONVERSION_OPERATOR; + cins.mOperator = IA_INT2FLOAT; + cins.mSType[0] = InterTypeOf(vr.mType); + cins.mSTemp[0] = vr.mTemp; + cins.mTType = IT_FLOAT; + cins.mTTemp = proc->AddTemporary(cins.mTType); + vr.mTemp = cins.mTTemp; vr.mType = TheFloatTypeDeclaration; block->Append(cins); } - ins.code = IC_RELATIONAL_OPERATOR; + ins.mCode = IC_RELATIONAL_OPERATOR; switch (exp->mToken) { case TK_EQUAL: - ins.oper = IA_CMPEQ; + ins.mOperator = IA_CMPEQ; break; case TK_NOT_EQUAL: - ins.oper = IA_CMPNE; + ins.mOperator = IA_CMPNE; break; case TK_GREATER_THAN: - ins.oper = signedCompare ? IA_CMPGS : IA_CMPGU; + ins.mOperator = signedCompare ? IA_CMPGS : IA_CMPGU; break; case TK_GREATER_EQUAL: - ins.oper = signedCompare ? IA_CMPGES : IA_CMPGEU; + ins.mOperator = signedCompare ? IA_CMPGES : IA_CMPGEU; break; case TK_LESS_THAN: - ins.oper = signedCompare ? IA_CMPLS : IA_CMPLU; + ins.mOperator = signedCompare ? IA_CMPLS : IA_CMPLU; break; case TK_LESS_EQUAL: - ins.oper = signedCompare ? IA_CMPLES : IA_CMPLEU; + ins.mOperator = signedCompare ? IA_CMPLES : IA_CMPLEU; break; } - ins.stype[0] = InterTypeOf(vr.mType);; - ins.stemp[0] = vr.mTemp; - ins.stype[1] = InterTypeOf(vl.mType);; - ins.stemp[1] = vl.mTemp; - ins.ttype = IT_BOOL; - ins.ttemp = proc->AddTemporary(ins.ttype); + ins.mSType[0] = InterTypeOf(vr.mType);; + ins.mSTemp[0] = vr.mTemp; + ins.mSType[1] = InterTypeOf(vl.mType);; + ins.mSTemp[1] = vl.mTemp; + ins.mTType = IT_BOOL; + ins.mTTemp = proc->AddTemporary(ins.mTType); block->Append(ins); - return ExValue(TheBoolTypeDeclaration, ins.ttemp); + return ExValue(TheBoolTypeDeclaration, ins.mTTemp); } case EX_CALL: @@ -1206,15 +1206,15 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* vr = CoerceType(proc, block, vr, decf->mBase->mParams); InterInstruction ins; - ins.code = IC_UNARY_OPERATOR; - ins.oper = IA_ABS; - ins.stype[0] = IT_FLOAT; - ins.stemp[0] = vr.mTemp; - ins.ttype = IT_FLOAT; - ins.ttemp = proc->AddTemporary(ins.ttype); + ins.mCode = IC_UNARY_OPERATOR; + ins.mOperator = IA_ABS; + ins.mSType[0] = IT_FLOAT; + ins.mSTemp[0] = vr.mTemp; + ins.mTType = IT_FLOAT; + ins.mTTemp = proc->AddTemporary(ins.mTType); block->Append(ins); - return ExValue(TheFloatTypeDeclaration, ins.ttemp); + return ExValue(TheFloatTypeDeclaration, ins.mTTemp); } else if (!strcmp(iname->mString, "floor")) { @@ -1226,15 +1226,15 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* vr = CoerceType(proc, block, vr, decf->mBase->mParams); InterInstruction ins; - ins.code = IC_UNARY_OPERATOR; - ins.oper = IA_FLOOR; - ins.stype[0] = IT_FLOAT; - ins.stemp[0] = vr.mTemp; - ins.ttype = IT_FLOAT; - ins.ttemp = proc->AddTemporary(ins.ttype); + ins.mCode = IC_UNARY_OPERATOR; + ins.mOperator = IA_FLOOR; + ins.mSType[0] = IT_FLOAT; + ins.mSTemp[0] = vr.mTemp; + ins.mTType = IT_FLOAT; + ins.mTTemp = proc->AddTemporary(ins.mTType); block->Append(ins); - return ExValue(TheFloatTypeDeclaration, ins.ttemp); + return ExValue(TheFloatTypeDeclaration, ins.mTTemp); } else if (!strcmp(iname->mString, "ceil")) { @@ -1246,15 +1246,15 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* vr = CoerceType(proc, block, vr, decf->mBase->mParams); InterInstruction ins; - ins.code = IC_UNARY_OPERATOR; - ins.oper = IA_CEIL; - ins.stype[0] = IT_FLOAT; - ins.stemp[0] = vr.mTemp; - ins.ttype = IT_FLOAT; - ins.ttemp = proc->AddTemporary(ins.ttype); + ins.mCode = IC_UNARY_OPERATOR; + ins.mOperator = IA_CEIL; + ins.mSType[0] = IT_FLOAT; + ins.mSTemp[0] = vr.mTemp; + ins.mTType = IT_FLOAT; + ins.mTTemp = proc->AddTemporary(ins.mTType); block->Append(ins); - return ExValue(TheFloatTypeDeclaration, ins.ttemp); + return ExValue(TheFloatTypeDeclaration, ins.mTTemp); } else mErrors->Error(exp->mLeft->mDecValue->mLocation, "Unknown intrinsic function", iname->mString); @@ -1268,12 +1268,12 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* int atotal = 0; - int findex = block->code.Size(); + int findex = block->mInstructions.Size(); InterCodeBasicBlock* fblock = block; InterInstruction fins; - fins.code = IC_PUSH_FRAME; - fins.ivalue = atotal; + fins.mCode = IC_PUSH_FRAME; + fins.mIntValue = atotal; block->Append(fins); Declaration * ftype = vl.mType; @@ -1285,21 +1285,21 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* while (pex) { InterInstruction ains; - ains.code = IC_CONSTANT; - ains.ttype = IT_POINTER; - ains.ttemp = proc->AddTemporary(ains.ttype); - ains.mem = IM_FRAME; + ains.mCode = IC_CONSTANT; + ains.mTType = IT_POINTER; + ains.mTTemp = proc->AddTemporary(ains.mTType); + ains.mMemory = IM_FRAME; if (pdec) { - ains.vindex = pdec->mVarIndex; - ains.ivalue = pdec->mOffset; - ains.opsize = pdec->mSize; + ains.mVarIndex = pdec->mVarIndex; + ains.mIntValue = pdec->mOffset; + ains.mOperandSize = pdec->mSize; } else if (ftype->mFlags & DTF_VARIADIC) { - ains.vindex = atotal; - ains.ivalue = 0; - ains.opsize = 2; + ains.mVarIndex = atotal; + ains.mIntValue = 0; + ains.mOperandSize = 2; } else { @@ -1333,22 +1333,22 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* } InterInstruction wins; - wins.code = IC_STORE; - wins.mem = IM_INDIRECT; - wins.stype[0] = InterTypeOf(vr.mType);; - wins.stemp[0] = vr.mTemp; - wins.stype[1] = IT_POINTER; - wins.stemp[1] = ains.ttemp; + wins.mCode = IC_STORE; + wins.mMemory = IM_INDIRECT; + wins.mSType[0] = InterTypeOf(vr.mType);; + wins.mSTemp[0] = vr.mTemp; + wins.mSType[1] = IT_POINTER; + wins.mSTemp[1] = ains.mTTemp; if (pdec) - wins.opsize = pdec->mSize; + wins.mOperandSize = pdec->mSize; else if (vr.mType->mSize > 2 && vr.mType->mType != DT_TYPE_ARRAY) - wins.opsize = vr.mType->mSize; + wins.mOperandSize = vr.mType->mSize; else - wins.opsize = 2; + wins.mOperandSize = 2; block->Append(wins); - atotal += wins.opsize; + atotal += wins.mOperandSize; if (pdec) pdec = pdec->mNext; } @@ -1357,25 +1357,25 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* mErrors->Error(exp->mLocation, "Not enough arguments for function call"); InterInstruction cins; - cins.code = IC_CALL; - cins.stype[0] = IT_POINTER; - cins.stemp[0] = vl.mTemp; + cins.mCode = IC_CALL; + cins.mSType[0] = IT_POINTER; + cins.mSTemp[0] = vl.mTemp; if (ftype->mBase->mType != DT_TYPE_VOID) { - cins.ttype = InterTypeOf(ftype->mBase); - cins.ttemp = proc->AddTemporary(cins.ttype); + cins.mTType = InterTypeOf(ftype->mBase); + cins.mTTemp = proc->AddTemporary(cins.mTType); } block->Append(cins); - fblock->code[findex].ivalue = atotal; + fblock->mInstructions[findex].mIntValue = atotal; InterInstruction xins; - xins.code = IC_POP_FRAME; - xins.ivalue = atotal; + xins.mCode = IC_POP_FRAME; + xins.mIntValue = atotal; block->Append(xins); - return ExValue(vl.mType->mBase, cins.ttemp); + return ExValue(vl.mType->mBase, cins.mTTemp); } } @@ -1391,11 +1391,11 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* } InterInstruction ins; - ins.code = IC_CONSTANT; - ins.ttype = IT_POINTER; - ins.ttemp = proc->AddTemporary(ins.ttype); - ins.opsize = osize; - ins.ivalue = 0; + ins.mCode = IC_CONSTANT; + ins.mTType = IT_POINTER; + ins.mTTemp = proc->AddTemporary(ins.mTType); + ins.mOperandSize = osize; + ins.mIntValue = 0; InterVariable var; var.mOffset = 0; @@ -1551,14 +1551,14 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* if (block) { - ins.mem = IM_GLOBAL; - ins.vindex = var.mIndex; + ins.mMemory = IM_GLOBAL; + ins.mVarIndex = var.mIndex; block->Append(ins); InterInstruction jins; - jins.code = IC_JSR; - jins.stype[0] = IT_POINTER; - jins.stemp[0] = ins.ttemp; + jins.mCode = IC_JSR; + jins.mSType[0] = IT_POINTER; + jins.mSTemp[0] = ins.mTTemp; block->Append(jins); } @@ -1579,16 +1579,16 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* else if (!procType->mBase->CanAssign(vr.mType)) mErrors->Error(exp->mLocation, "Cannot return incompatible type"); - ins.stype[0] = InterTypeOf(vr.mType); - ins.stemp[0] = vr.mTemp; - ins.code = IC_RETURN_VALUE; + ins.mSType[0] = InterTypeOf(vr.mType); + ins.mSTemp[0] = vr.mTemp; + ins.mCode = IC_RETURN_VALUE; } else { if (procType->mBase && procType->mBase->mType != DT_TYPE_VOID) mErrors->Error(exp->mLocation, "Function has non void return type"); - ins.code = IC_RETURN; + ins.mCode = IC_RETURN; } block->Append(ins); @@ -1604,7 +1604,7 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* if (breakBlock) { InterInstruction jins; - jins.code = IC_JUMP; + jins.mCode = IC_JUMP; block->Append(jins); block->Close(breakBlock, nullptr); @@ -1622,7 +1622,7 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* if (continueBlock) { InterInstruction jins; - jins.code = IC_JUMP; + jins.mCode = IC_JUMP; block->Append(jins); block->Close(continueBlock, nullptr); @@ -1641,30 +1641,30 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* vl = Dereference(proc, block, vl); InterInstruction zins; - zins.code = IC_CONSTANT; - zins.ttype = InterTypeOf(vr.mType); - zins.ttemp = proc->AddTemporary(zins.ttype); - zins.ivalue = 0; + zins.mCode = IC_CONSTANT; + zins.mTType = InterTypeOf(vr.mType); + zins.mTTemp = proc->AddTemporary(zins.mTType); + zins.mIntValue = 0; block->Append(zins); InterInstruction ins; - ins.code = IC_RELATIONAL_OPERATOR; - ins.oper = IA_CMPNE; - ins.stype[0] = InterTypeOf(vr.mType); - ins.stemp[0] = zins.ttemp; - ins.stype[1] = InterTypeOf(vr.mType); - ins.stemp[1] = vl.mTemp; - ins.ttype = IT_BOOL; - ins.ttemp = proc->AddTemporary(ins.ttype); + ins.mCode = IC_RELATIONAL_OPERATOR; + ins.mOperator = IA_CMPNE; + ins.mSType[0] = InterTypeOf(vr.mType); + ins.mSTemp[0] = zins.mTTemp; + ins.mSType[1] = InterTypeOf(vr.mType); + ins.mSTemp[1] = vl.mTemp; + ins.mTType = IT_BOOL; + ins.mTTemp = proc->AddTemporary(ins.mTType); block->Append(ins); - return ExValue(TheBoolTypeDeclaration, ins.ttemp); + return ExValue(TheBoolTypeDeclaration, ins.mTTemp); } case EX_CONDITIONAL: { InterInstruction jins; - jins.code = IC_JUMP; + jins.mCode = IC_JUMP; InterCodeBasicBlock* tblock = new InterCodeBasicBlock(); proc->Append(tblock); @@ -1710,44 +1710,44 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* if (ttype == IT_FLOAT && vr.mType->IsIntegerType()) { InterInstruction ins; - ins.code = IC_CONVERSION_OPERATOR; - ins.oper = IA_INT2FLOAT; - ins.stype[0] = InterTypeOf(vr.mType); - ins.stemp[0] = vr.mTemp; - ins.ttype = ttype; - ins.ttemp = ttemp; + ins.mCode = IC_CONVERSION_OPERATOR; + ins.mOperator = IA_INT2FLOAT; + ins.mSType[0] = InterTypeOf(vr.mType); + ins.mSTemp[0] = vr.mTemp; + ins.mTType = ttype; + ins.mTTemp = ttemp; fblock->Append(ins); } else { InterInstruction ins; - ins.code = IC_LOAD_TEMPORARY; - ins.stype[0] = InterTypeOf(vr.mType); - ins.stemp[0] = vr.mTemp; - ins.ttype = ttype; - ins.ttemp = ttemp; + ins.mCode = IC_LOAD_TEMPORARY; + ins.mSType[0] = InterTypeOf(vr.mType); + ins.mSTemp[0] = vr.mTemp; + ins.mTType = ttype; + ins.mTTemp = ttemp; fblock->Append(ins); } if (ttype == IT_FLOAT && vl.mType->IsIntegerType()) { InterInstruction ins; - ins.code = IC_CONVERSION_OPERATOR; - ins.oper = IA_INT2FLOAT; - ins.stype[0] = InterTypeOf(vl.mType); - ins.stemp[0] = vl.mTemp; - ins.ttype = ttype; - ins.ttemp = ttemp; + ins.mCode = IC_CONVERSION_OPERATOR; + ins.mOperator = IA_INT2FLOAT; + ins.mSType[0] = InterTypeOf(vl.mType); + ins.mSTemp[0] = vl.mTemp; + ins.mTType = ttype; + ins.mTTemp = ttemp; tblock->Append(ins); } else { InterInstruction ins; - ins.code = IC_LOAD_TEMPORARY; - ins.stype[0] = InterTypeOf(vl.mType); - ins.stemp[0] = vl.mTemp; - ins.ttype = ttype; - ins.ttemp = ttemp; + ins.mCode = IC_LOAD_TEMPORARY; + ins.mSType[0] = InterTypeOf(vl.mType); + ins.mSTemp[0] = vl.mTemp; + ins.mTType = ttype; + ins.mTTemp = ttemp; tblock->Append(ins); } @@ -1773,23 +1773,23 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* if (exp->mLeft->mDecType->mType == DT_TYPE_FLOAT && vr.mType->IsIntegerType()) { vr = Dereference(proc, block, vr); - ins.code = IC_CONVERSION_OPERATOR; - ins.oper = IA_INT2FLOAT; - ins.stype[0] = InterTypeOf(vr.mType); - ins.stemp[0] = vr.mTemp; - ins.ttype = InterTypeOf(exp->mLeft->mDecType); - ins.ttemp = proc->AddTemporary(ins.ttype); + ins.mCode = IC_CONVERSION_OPERATOR; + ins.mOperator = IA_INT2FLOAT; + ins.mSType[0] = InterTypeOf(vr.mType); + ins.mSTemp[0] = vr.mTemp; + ins.mTType = InterTypeOf(exp->mLeft->mDecType); + ins.mTTemp = proc->AddTemporary(ins.mTType); block->Append(ins); } else if (exp->mLeft->mDecType->IsIntegerType() && vr.mType->mType == DT_TYPE_FLOAT) { vr = Dereference(proc, block, vr); - ins.code = IC_CONVERSION_OPERATOR; - ins.oper = IA_FLOAT2INT; - ins.stype[0] = InterTypeOf(vr.mType); - ins.stemp[0] = vr.mTemp; - ins.ttype = InterTypeOf(exp->mLeft->mDecType); - ins.ttemp = proc->AddTemporary(ins.ttype); + ins.mCode = IC_CONVERSION_OPERATOR; + ins.mOperator = IA_FLOAT2INT; + ins.mSType[0] = InterTypeOf(vr.mType); + ins.mSTemp[0] = vr.mTemp; + ins.mTType = InterTypeOf(exp->mLeft->mDecType); + ins.mTTemp = proc->AddTemporary(ins.mTType); block->Append(ins); } else if (exp->mLeft->mDecType->mType == DT_TYPE_POINTER && vr.mType->mType == DT_TYPE_POINTER) @@ -1800,15 +1800,15 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* else { vr = Dereference(proc, block, vr); - ins.code = IC_TYPECAST; - ins.stype[0] = InterTypeOf(vr.mType); - ins.stemp[0] = vr.mTemp; - ins.ttype = InterTypeOf(exp->mLeft->mDecType); - ins.ttemp = proc->AddTemporary(ins.ttype); + ins.mCode = IC_TYPECAST; + ins.mSType[0] = InterTypeOf(vr.mType); + ins.mSTemp[0] = vr.mTemp; + ins.mTType = InterTypeOf(exp->mLeft->mDecType); + ins.mTTemp = proc->AddTemporary(ins.mTType); block->Append(ins); } - return ExValue(exp->mLeft->mDecType, ins.ttemp); + return ExValue(exp->mLeft->mDecType, ins.mTTemp); } break; @@ -1819,7 +1819,7 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* case EX_WHILE: { InterInstruction jins; - jins.code = IC_JUMP; + jins.mCode = IC_JUMP; InterCodeBasicBlock* cblock = new InterCodeBasicBlock(); InterCodeBasicBlock* lblock = cblock; @@ -1846,7 +1846,7 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* case EX_IF: { InterInstruction jins; - jins.code = IC_JUMP; + jins.mCode = IC_JUMP; InterCodeBasicBlock* tblock = new InterCodeBasicBlock(); proc->Append(tblock); @@ -1878,7 +1878,7 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* TranslateExpression(procType, proc, block, exp->mLeft->mRight, breakBlock, continueBlock); InterInstruction jins; - jins.code = IC_JUMP; + jins.mCode = IC_JUMP; InterCodeBasicBlock* cblock = new InterCodeBasicBlock(); InterCodeBasicBlock* lblock = cblock; @@ -1922,7 +1922,7 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* case EX_DO: { InterInstruction jins; - jins.code = IC_JUMP; + jins.mCode = IC_JUMP; InterCodeBasicBlock* cblock = new InterCodeBasicBlock(); InterCodeBasicBlock* lblock = cblock; @@ -1945,7 +1945,7 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* case EX_SWITCH: { InterInstruction jins; - jins.code = IC_JUMP; + jins.mCode = IC_JUMP; vl = TranslateExpression(procType, proc, block, exp->mLeft, breakBlock, continueBlock); vl = Dereference(proc, block, vl); @@ -1974,21 +1974,21 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration* vr = Dereference(proc, sblock, vr); InterInstruction cins; - cins.code = IC_RELATIONAL_OPERATOR; - cins.oper = IA_CMPEQ; - cins.stype[0] = InterTypeOf(vr.mType);; - cins.stemp[0] = vr.mTemp; - cins.stype[1] = InterTypeOf(vl.mType);; - cins.stemp[1] = vl.mTemp; - cins.ttype = IT_BOOL; - cins.ttemp = proc->AddTemporary(cins.ttype); + cins.mCode = IC_RELATIONAL_OPERATOR; + cins.mOperator = IA_CMPEQ; + cins.mSType[0] = InterTypeOf(vr.mType);; + cins.mSTemp[0] = vr.mTemp; + cins.mSType[1] = InterTypeOf(vl.mType);; + cins.mSTemp[1] = vl.mTemp; + cins.mTType = IT_BOOL; + cins.mTTemp = proc->AddTemporary(cins.mTType); sblock->Append(cins); InterInstruction bins; - bins.code = IC_BRANCH; - bins.stype[0] = IT_BOOL; - bins.stemp[0] = cins.ttemp; + bins.mCode = IC_BRANCH; + bins.mSType[0] = IT_BOOL; + bins.mSTemp[0] = cins.mTTemp; sblock->Append(bins); sblock->Close(nblock, cblock); @@ -2154,9 +2154,9 @@ void InterCodeGenerator::TranslateLogic(Declaration* procType, InterCodeProcedur vr = Dereference(proc, block, vr); InterInstruction ins; - ins.code = IC_BRANCH; - ins.stype[0] = IT_BOOL; - ins.stemp[0] = vr.mTemp; + ins.mCode = IC_BRANCH; + ins.mSType[0] = IT_BOOL; + ins.mSTemp[0] = vr.mTemp; block->Append(ins); block->Close(tblock, fblock); @@ -2182,7 +2182,7 @@ InterCodeProcedure* InterCodeGenerator::TranslateProcedure(InterCodeModule * mod mErrors->Error(dec->mLocation, "Calling undefined function", dec->mIdent->mString); InterInstruction ins; - ins.code = IC_RETURN; + ins.mCode = IC_RETURN; exitBlock->Append(ins); exitBlock->Close(nullptr, nullptr);