Rijn/TempleOS-Rijn
1
1 Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity
Files
e57428affbeb3621f2c3f5d361e68a7823667729
TempleOS-Rijn/SparrowOS/Compiler/CmpInit.CPP
T
Terry A. Davis e57428affb SparrowOSTS_121127.ISO
2018-09-08 21:45:28 +02:00

741 lines
21 KiB
C++
Raw Blame History

#define NUM_INTERNAL_TYPES 16
class CInternalType
{
U8 type,size,name[8];
};
CInternalType internal_types_table[NUM_INTERNAL_TYPES]={
{IT_I0,0,"I0i"},
{IT_U0,0,"U0i"},
{IT_I0,0,"I0"},
{IT_U0,0,"U0"},
{IT_I8,1,"I8i"},
{IT_I8,1,"I8"},
{IT_U8,1,"U8i"},
{IT_U8,1,"U8"},
{IT_I16,2,"I16i"},
{IT_U16,2,"U16i"},
{IT_I32,4,"I32i"},
{IT_U32,4,"U32i"},
{IT_I64,8,"I64i"},
{IT_U64,8,"U64i"},
{IT_F64,8,"F64i"},
{IT_F64,8,"F64"},
};
U0 AsmPrsInsFlags(CLex *lx,CInstruction *tempi)
{
I64 i;
while (TRUE) {
switch (lx->token) {
case TK_IDENT:
if ((i=DefineMatch(lx->ident,"ST_OPCODE_MODIFIERS"))>=0) {
tempi->opcode_modifier=i;
break;
} else
return;
case TK_INTEGER:
if (lx->cur_i==16)
tempi->flags|=IEF_OP_SIZE16;
else if (lx->cur_i==32)
tempi->flags|=IEF_OP_SIZE32;
else
return;
break;
case '+':
tempi->flags|=IEF_PLUS_OPCODE;
case '/':
if (Lex(lx)==TK_INTEGER && lx->cur_i<8)
tempi->slash_val=lx->cur_i;
else if (lx->token==TK_IDENT) {
if (!StrCmp(lx->ident,"R"))
tempi->slash_val=SV_R_REGISTER;
else if (!StrCmp(lx->ident,"I"))
tempi->slash_val=SV_I_REGISTER;
else
return;
} else
return;
break;
case '!': tempi->flags|=IEF_DONT_SWITCH_MODES; break;
case '&': tempi->flags|=IEF_DFT; break;
case ':': tempi->flags|=IEF_STI; break;
case '-': tempi->flags|=IEF_NO_REX; break;
case '~': tempi->flags|=IEF_40_REX; break;
case '=': tempi->flags|=IEF_48_REX; break;
case '`': tempi->flags|=IEF_REX_ONLY_R8_R15; break;
case '^': tempi->flags|=IEF_REX_XOR_LIKE; break;
case '$$': tempi->flags|=IEF_ENDING_ZERO; break;
default:
return;
}
Lex(lx);
}
}
U0 AsmHashLoad(Bool first)
{
I64 i,j,size,size1;
CInternalType *tempit;
CLex *lx;
CHashGeneric *temph;
CHashReg *tempr;
CHashOpcode *tempo,*tempo1;
CInstruction *tempi;
CHashClass *tempc;
asm_hash=HashTableNew(2048);
size1=offset(CHashOpcode.ins)+sizeof(CInstruction)<<5;
tempo=MAlloc(size1);
lx=LexNew(TextFileRead("OpCodes.TXT.Z"),0,StrNew("OpCodes.TXT.Z"));
lx->hash_table_list=NULL;
Lex(lx);
while (lx->token) {
if (lx->token!=TK_IDENT)
LexExcept(lx,"ST_EXPECTING_IDENTIFIER");
i=ListEntryMatch(lx->ident,"R8\0R16\0R32\0R64\0SEG\0FSTK\0MM\0XMM\0OPCODE\0KEYWORD\0ASM_KEYWORD\0");
if (i<0)
LexExcept(lx,"Unknown Statement");
Lex(lx); //skip keyword
if (lx->token!=TK_IDENT)
LexExcept(lx,"ST_EXPECTING_IDENTIFIER");
switch (i) {
case 8: //OPCODE
MemSet(tempo,0,size1);
tempo->type=HTT_OPCODE;
tempo->instruction_entry_cnt=0;
tempo->str=lx->ident;
lx->ident=0;
Lex(lx); //Skip OPCODE
while (lx->token && lx->token!=';') {
tempi=&tempo->ins[tempo->instruction_entry_cnt];
tempi->ins_entry_num=tempo->instruction_entry_cnt++;
tempi->slash_val=SV_NONE; //Not zero!!
while (lx->token==TK_INTEGER) {
tempi->opcode[tempi->opcode_cnt++]=lx->cur_i;
Lex(lx);
}
if (lx->token==',')
Lex(lx);
else if (lx->token!=';')
LexExcept(lx,"ST_EXPECTING_COMMA");
AsmPrsInsFlags(lx,tempi);
tempi->arg1=0;
tempi->arg2=0;
if (lx->token==TK_IDENT) {
j=DefineMatch(lx->ident,"ST_ARG_TYPES");
tempi->arg1=j;
if (ARGT_REL8<=j<=ARGT_REL32 ||
ARGT_MOFFS8<=j<=ARGT_MOFFS64)
tempi|=IEF_NO_REX;
if (Lex(lx)==TK_IDENT) {
j=DefineMatch(lx->ident,"ST_ARG_TYPES");
Lex(lx);
tempi->arg2=j;
if (ARGT_REL8<=j<=ARGT_REL32 ||
ARGT_MOFFS8<=j<=ARGT_MOFFS64)
tempi|=IEF_NO_REX;
}
}
}
size=offset(CHashOpcode.ins)+
sizeof(CInstruction)*tempo->instruction_entry_cnt;
tempo1=MAlloc(size);
MemCpy(tempo1,tempo,size);
tempo1->use_cnt=0;
if (HashFind(tempo1->str,asm_hash,HTT_OPCODE))
LexExcept(lx,"ST_DUP_OPCODE_ENTRY");
HashAdd(tempo1,asm_hash);
break;
case 9: //KEYWORD
case 10: //ASM_KEYWORD
temph=CAlloc(sizeof(CHashGeneric));
temph->str=lx->ident;
lx->ident=NULL;
Lex(lx); //skip keyword name
if (lx->token!=TK_INTEGER)
LexExcept(lx,"ST_EXPECTING_INTEGER");
temph->user_data0=lx->cur_i;
if (i==9) {//KEYWORD
temph->type=HTT_KEYWORD;
HashAdd(temph,asm_hash);
if (first) {
temph=MAllocIdentical(temph);
HashAdd(temph,adam_task->hash_table);
}
} else {
temph->type=HTT_ASM_KEYWORD;
HashAdd(temph,asm_hash);
}
Lex(lx); //Skip INT
break;
case REGT_R8:
case REGT_R16:
case REGT_R32:
case REGT_R64:
case REGT_SEG:
case REGT_FSTK:
case REGT_MM:
case REGT_XMM:
tempr=CAlloc(sizeof(CHashReg));
tempr->str=lx->ident;
lx->ident=NULL;
Lex(lx); //skip keyword name
if (lx->token!=TK_INTEGER)
LexExcept(lx,"ST_EXPECTING_INTEGER");
tempr->type=HTT_REG;
tempr->reg_type=i;
tempr->reg_num=lx->cur_i;
HashAdd(tempr,asm_hash);
Lex(lx); //Skip INT
break;
}
if (lx->token!=';')
LexExcept(lx,"ST_MISSING_SEMICOLON");
Lex(lx); //Skip ';'
}
Free(tempo);
LexDel(lx);
for (i=0;i<NUM_INTERNAL_TYPES;i++) {
tempit=&internal_types_table[i];
tempc=PrsClassNew;
tempc->type=HTT_INTERNAL_TYPE;
tempc->sub_type=tempit->type;
Bts(&tempc->flags,Cf_INTERNAL_TYPE);
tempc->size=tempit->size;
tempc->str=AStrNew(tempit->name);
HashAdd(tempc,asm_hash);
sys_internal_types[tempc->sub_type]=tempc;
if (first) {
tempc=MAllocIdentical(tempc);
HashAdd(tempc,adam_task->hash_table);
}
}
}
U0 CmpLoadDefines()
{
DefineLoad("ST_ERR",ST_ERR_ST);
DefineLoad("ST_WARN",ST_WARN_ST);
DefineLoad("ST_MISSING_SEMICOLON","missing ';' at");
DefineLoad("ST_MISSING_EXPRESSION","missing Expression at ");
DefineLoad("ST_MISSING_RIGHT_PAREN","missing ')' at ");
DefineLoad("ST_MISSING_RIGHT_BRACKET","missing ']' at ");
DefineLoad("ST_MISSING_COLON","missing ':' at");
DefineLoad("ST_UNDEFINED_SYM","undefined sym at ");
DefineLoad("ST_UNDEFINED_SYM_LINE","undefined sym at line:");
DefineLoad("ST_UNDEFINED_IDENTIFIER","undefined identifier at ");
DefineLoad("ST_INVALID_CLASS","invalid class at ");
DefineLoad("ST_INVALID_MEMBER","invalid member at ");
DefineLoad("ST_EXPECTING_TYPE","expecting type at ");
DefineLoad("ST_EXPECTING_IDENTIFIER","expecting identifier at ");
DefineLoad("ST_EXPECTING_RIGHT_PAREN","expecting ')' at ");
DefineLoad("ST_EXPECTING_LEFT_BRACE","expecting '{' at ");
DefineLoad("ST_EXPECTING_EQUAL","expecting '=' at ");
DefineLoad("ST_MISSING_RIGHT_BRACE","missing '}' at ");
DefineLoad("ST_INVALID_LVAL","invalid lval at ");
DefineLoad("ST_EXPECTING_COMMA","expecting ',' at ");
DefineLoad("ST_EXPECTING_SYS_SYM","expecting System sym at ");
DefineLoad("ST_MISSING_WHILE","missing 'while' at");
DefineLoad("ST_ALREADY_ONE_IMMEDIATE","already one immediate at ");
DefineLoad("ST_SYNTAX_ERROR","syntax error at ");
DefineLoad("ST_EXPECTING_SCALE_FACTOR","expecting scale factor at ");
DefineLoad("ST_EXPECTING_LEFT_PAREN","expecting '(' at ");
DefineLoad("ST_UNDEFINED_DUP_CNT","undefined DUP cnt at ");
DefineLoad("ST_NO_LOCAL_GLBL_EXPORT","no local glbl exports at ");
DefineLoad("ST_EXPECTING_COLON","expecting ':' at ");
DefineLoad("ST_EXPECTING_DOT","expecting '.' at ");
DefineLoad("ST_EXPECTING_LOCAL_VAR","expecting local var at ");
DefineLoad("ST_REDEFINITION","redefinition at ");
DefineLoad("ST_INVALID_INSTRUCTION","invalid instruction at ");
DefineLoad("ST_BRANCH_OUT_OF_RANGE","branch out of range at ");
DefineLoad("ST_BRANCH_OUT_OF_RANGE_LINE","branch out of range at line:");
DefineLoad("ST_ATTEMPT_DEFINE_IMPORT","attempt to define import at ");
DefineLoad("ST_COULD_USE_I8_DISP","could use I8 displacement at ");
DefineLoad("ST_COULD_USE_I8_DISP_LINE","could use I8 displacement at line:");
DefineLoad("ST_PTR_TO_U0","use \"U8 *\" instead of \"U0 *\" at ");
DefineLoad("ST_NO_SIZE_SPECIFIED","no size specified at ");
DefineListLoad("ST_IT_TYPES","I0\0U0\0I8\0U8\0I16\0U16\0I32\0U32\0I64\0U64\0F64\0uF64\0");
DefineListLoad("ST_TY_TYPES","NULL\0IMM\0REG\0DISP\0SIB\0RIP\0STK\0");
DefineListLoad("ST_U8_REGS","AL\0CL\0DL\0BL\0AH\0CH\0DH\0BH\0"
"R8u8\0R9u8\0R10u8\0R11u8\0R12u8\0R13u8\0R14u8\0R15u8\0");
DefineListLoad("ST_U8_REX_REGS","AL\0CL\0DL\0BL\0RSPu8\0RBPu8\0RSIu8\0RDIu8\0"
"R8u8\0R9u8\0R10u8\0R11u8\0R12u8\0R13u8\0R14u8\0R15u8\0");
DefineListLoad("ST_U16_REGS","AX\0CX\0DX\0BX\0SP\0BP\0SI\0DI\0"
"R8u16\0R9u16\0R10u16\0R11u16\0R12u16\0R13u16\0R14u16\0R15u16\0");
DefineListLoad("ST_U32_REGS","EAX\0ECX\0EDX\0EBX\0ESP\0EBP\0ESI\0EDI\0"
"R8u32\0R9u32\0R10u32\0R11u32\0R12u32\0R13u32\0R14u32\0R15u32\0");
DefineListLoad("ST_U64_REGS","RAX\0RCX\0RDX\0RBX\0RSP\0RBP\0RSI\0RDI\0"
"R8\0R9\0R10\0R11\0R12\0R13\0R14\0R15\0");
DefineListLoad("ST_MM_REGS","MM0\0MM1\0MM2\0MM3\0MM4\0MM5\0MM6\0MM7\0");
DefineListLoad("ST_XMM_REGS","XMM0\0XMM1\0XMM2\0XMM3\0XMM4\0XMM5\0XMM6\0XMM7\0");
DefineListLoad("ST_OPCODE_MODIFIERS","NO\0CB\0CW\0CD\0CP\0IB\0IW\0ID\0");
DefineListLoad("ST_ARG_TYPES",
"NO\0REL8\0REL16\0REL32\0UIMM8\0UIMM16\0UIMM32\0UIMM64\0"
"R8\0R16\0R32\0R64\0"
"IMM8\0IMM16\0IMM32\0IMM64\0RM8\0RM16\0RM32\0RM64\0"
"M8\0M16\0M32\0M64\0"
"M1632\0M16N32\0M16N16\0M32N32\0"
"MOFFS8\0MOFFS16\0MOFFS32\0MOFFS64\0"
"AL\0AX\0EAX\0RAX\0CL\0DX\0 \0SREG\0"
"SS\0DS\0ES\0FS\0GS\0CS\0ST0\0STI\0"
"MM\0MM32\0MM64\0XMM\0XMM32\0XMM64\0XMM128\0XMM0\0");
DefineListLoad("ST_SEG_REGS","ES\0CS\0SS\0DS\0FS\0GS\0");
DefineListLoad("ST_FSTK_REGS","ST0\0ST1\0ST2\0ST3\0ST4\0ST5\0ST6\0ST7\0");
DefineLoad("ST_EXPECTING_INTEGER","expecting integer at ");
DefineLoad("ST_USE_POSTFIX_CAST","Use SparrowOS postfix typecasting at ");
DefineLoad("ST_PRS_INTERNAL_ERROR","Compiler Parse Error at ");
DefineLoad("ST_OPT_INTERNAL_ERROR","Compiler Optimization Error at ");
DefineLoad("ST_UNRESOLVED_REFERENCE","Unresolved Reference:");
DefineLoad("ST_SCANNING_DIR","Scanning Directory:");
DefineLoad("ST_UNUSED_VAR","Unused var ");
DefineLoad("ST_UNNEEDED_NOUNUSEDWARN","Unneeded nounusedwarn ");
DefineLoad("ST_UNUSED_EXTERN","Unused extern ");
DefineLoad("ST_UNUSED_LABEL","Unused label ");
DefineLoad("ST_UNUSED_LABEL_AT","Unused label at ");
DefineLoad("ST_NOT_ALLOWED_IN_FUN","Not allowed in fun");
DefineLoad("ST_MISSING_CATCH","missing 'catch' at");
DefineLoad("ST_UNDEFINED_GOTO_LABEL","Undefined goto label ");
DefineLoad("ST_UNDEFINED_GOTO_LABEL_AT","Undefined goto label at ");
DefineLoad("ST_DUP_GOTO_LABEL","Duplicate goto label at ");
DefineLoad("ST_BREAK_NOT_ALLOWED","'break' not allowed\n");
DefineLoad("ST_ERRORS_WARNINGS","Errs:%d Warns:%d Code:%X Size:%X\n");
DefineLoad("ST_IMPORT_NOT_NEEDED","import not needed at ");
DefineLoad("ST_CASE_RANGE_ERROR","switch range error at ");
DefineLoad("ST_LEX_STK_OVERFLOW","Lex Stk overflow");
DefineLoad("ST_ASSERT_FAILED","Assert Failed ");
DefineLoad("ST_ADDR_EXTERN","Can't take addr of extern fun");
DefineLoad("ST_EXTERNS_NOT_ALLOWED","Extern Not Allowed at ");
DefineLoad("ST_UNNECESSARY_PARENTHESIS","Unnecessary parenthesis");
DefineLoad("ST_STATIC_UNION","Static unions are not implemented");
DefineLoad("ST_IMPORT_HASH_TABLE_NOT_ALLOWED","import_hash_table only allowed in static compiled #exe{} mode.");
DefineLoad("ST_CANT_INIT_GLBL_ON_HEAP","Can't init glbl var on data heap in static module");
DefineLoad("ST_INVALID_ARRAY_SIZE","Invalid array size at ");
DefineLoad("ST_NO_FUN_ASM_ALIGN","ALIGN not allowed in fun asm blk ");
DefineLoad("ST_ALIGN_MUST_BE_POWER_OF_TWO","ALIGN must be power of two at ");
DefineLoad("ST_ALIGN_TOO_LARGE","In JIT mode, max ALIGN is 8 ");
DefineLoad("ST_FUN_SIZE_NOT_DEFINED","Function size not defined at ");
DefineLoad("ST_DUP_MEMBER","Duplicate member at ");
DefineLoad("ST_DUP_TYPE","Duplicate type at ");
DefineLoad("ST_FUN_PTR_FUN_PTR","Duplicate fun pointer at ");
DefineLoad("ST_EXPECTING_STAR","Expecting '*' at ");
DefineLoad("ST_EXPECTING_AMPERSAND","Expecting '&' at ");
DefineLoad("ST_NOT_IMPLEMENTED","Feat not implemented");
DefineLoad("ST_DUP_CASE","Duplicate case at ");
DefineLoad("ST_DEREF_U0","Dereference U0 ");
DefineLoad("ST_ASSIGN_U0","Assign U0 ");
DefineLoad("ST_NO_GLBL_LABELS","No global labels at ");
DefineLoad("ST_SHOULD_RETURN_VAL","Function should return val ");
DefineLoad("ST_CANT_RETURN_VAL","Not in fun. Can't return a val ");
DefineLoad("ST_SHOULD_NOT_RETURN_VAL","Function should NOT return val ");
DefineLoad("ST_DUP_OPCODE_ENTRY","Duplicate OPCODE entry ");
DefineLoad("ST_IN_FUN","in fun ");
DefineLoad("ST_NOT_ARRAY_OR_PTR","not array or ptr ");
DefineLoad("ST_16BIT_UNASM","16-bit unassembly is not well supported.\n");
DefineLoad("ST_CANT_REG_VAR","Can't reg var ");
DefineLoad("ST_ILLEGAL_FWD_REF","Illegal fwd ref at ");
DefineLoad("ST_REG_IN_USE","Register in use ");
DefineLoad("ST_ONE_BASE_CLASS","Only one base class allowed at this time at ");
DefineLoad("ST_ADD_NOT_VAL","Must be address, not value ");
DefineLoad("ST_HEADER_FOR_PRINTF","Missing header for PrintF(), PutS() and PutChar() at ");
DefineLoad("ST_HEADER_FOR_SYSTRY","Missing header for SysTry() and SysUntry() at ");
$AN,"Anchor for inserting Compiler Defines","COMPILE_DEFINE"$
DefineListLoad("ST_INTERMEDIATE_CODE",
// '*' means it is a dereference instruction
// '=' means it is an assignment instruction
// '^' means it is a compare instruction
// '9' arg cnt means var
// 'N' means not constant. Sets LF_NOT_CONSTANT
// which means an expression contains mem
// accesses or things which might change.
// arg cnt,result cnt,deref/assign/cmp,nonconst,might not fill result
"00..END\0"
"00..START\0"
"00..NOP\0"
"10..END_EXP\0"
"00..NOP1\0"
"00..LABEL\0"
"00..CALL_START\0"
"01..CALL_END\0"
"00..CALL_END2\0"
"10..RETURN_VAL\0"
"00..RETURN_VAL2\0"
"01..IMM\0"
"01..F64\0"
"01.NSTR_CONST\0"
"01.NABS_ADDR\0"
"01.NADDR_IMPORT\0"
"01.NHEAP_GLBL\0"
"01..SIZEOF\0"
"01..TYPE\0"
"01.NGET_LABEL\0"
"01.NRBP\0"
"01.NREG\0"
"00.NFS\0"
"01.NMOV_FS\0"
"00.NGS\0"
"01.NMOV_GS\0"
"01.NLEA\0"
"01.NMOV\0"
"10..TO_I64\0"
"10..TO_F64\0"
"10..TO_BOOL\0"
"10..TOUPPER\0"
"11..NATIVE_TYPECAST\0"
"11.NADDR\0"
"11..COM\0"
"11..NOT\0"
"11..UNARY_MINUS\0"
"11*NDEREF\0"
"11*NDEREF_PP\0"
"11*NDEREF_MM\0"
"11*N_PP\0"
"11*N_MM\0"
"11*NPP_\0"
"11*NMM_\0"
"21..SHL\0"
"21..SHR\0"
"11=.SHL_CONST\0"
"11=.SHR_CONST\0"
"21..POWER\0"
"21..MUL\0"
"21..DIV\0"
"21..MOD\0"
"21..AND\0"
"21..OR\0"
"21..XOR\0"
"21..ADD\0"
"21..SUB\0"
"11=.ADD_CONST\0"
"11=.SUB_CONST\0"
"21^.EQUAL_EQUAL\0"
"21^.NOT_EQUAL\0"
"21^.LESS\0"
"21^.GREATER\0"
"21^.LESS_EQUAL\0"
"21^.GREATER_EQUAL\0"
"01..PUSH_CMP\0"
"21..AND_AND\0"
"21..OR_OR\0"
"21..XOR_XOR\0"
"31..COLON\0"
"00..QUESTION\0"
"21=NASSIGN\0"
"21=NASSIGN_PP\0"
"21=NASSIGN_MM\0"
"21=NSHL_EQUAL\0"
"21=NSHR_EQUAL\0"
"21=NMUL_EQUAL\0"
"21=NDIV_EQUAL\0"
"21=NMOD_EQUAL\0"
"21=NAND_EQUAL\0"
"21=NOR_EQUAL\0"
"21=NXOR_EQUAL\0"
"21=NADD_EQUAL\0"
"21=NSUB_EQUAL\0"
"00..JMP\0"
"20..SWITCH\0"
"20..NOBOUND_SWITCH\0"
"90..ADD_RSP\0"
"90..ADD_RSP1\0"
"00..ENTER\0"
"00=.PUSH_REGS\0"
"00=.POP_REGS\0"
"00..LEAVE\0"
"00..RET\0"
"00.NCALL\0"
"00.NCALL_INDIRECT\0"
"00.NCALL_INDIRECT2\0"
"00.NCALL_IMPORT\0"
"00.NCALL_EXTERN\0"
"00.NIRQ\0"
"00.NASM\0"
"00.NCLI\0"
"00.NSTI\0"
"10.NPREEMPT\0"
"00.NCLD\0"
"00.NSTD\0"
"00.NHLT\0"
"10.NPUSH\0"
"00.NPOP\0"
"00.NPUSHFD\0"
"00.NPOPFD\0"
"00.NPAUSE\0"
"10.NCLFLUSH\0"
"10.NINVLPG\0"
"10.NINU8\0"
"10.NINU16\0"
"10.NINU32\0"
"20.NOUTU8\0"
"20.NOUTU16\0"
"20.NOUTU32\0"
"00.NGET_FLAGS\0"
"10.NSET_FLAGS\0"
"00.NGET_RAX\0"
"10.NSET_RAX\0"
"00.NGET_BASE_PTR\0"
"10.NSET_BASE_PTR\0"
"00.NGET_STK_PTR\0"
"10.NSET_STK_PTR\0"
"01.NRIP\0"
"00.NRDTSC\0"
"00.NHPET\0"
"20.NBT\0"
"20.NBTS\0"
"20.NBTR\0"
"20.NBTC\0"
"30.NBEQU\0"
"20.NLBTS\0"
"20.NLBTR\0"
"20.NLBTC\0"
"30.NLBEQU\0"
"10.NBSF\0"
"10.NBSR\0"
"10.NQUE_INIT\0"
"20.NQUE_INS\0"
"20.NQUE_INS_REV\0"
"10.NQUE_REM\0"
"10.NSTRLEN\0"
"30.NMEMCPY\0"
"30.NMEMSET\0"
"30.NMEMSET_U16\0"
"30.NMEMSET_U32\0"
"30.NMEMSET_U64\0"
"10..BR_ZERO\0"
"10..BR_NOT_ZERO\0"
"20..BR_NOT_EQUAL\0"
"20..BR_EQUAL_EQUAL\0"
"20..BR_GREATER_EQUAL\0"
"20..BR_LESS_EQUAL\0"
"20..BR_GREATER\0"
"20..BR_LESS\0"
"21..BR_2NOT_EQUAL\0"
"21..BR_2EQUAL_EQUAL\0"
"21..BR_2GREATER_EQUAL\0"
"21..BR_2LESS_EQUAL\0"
"21..BR_2GREATER\0"
"21..BR_2LESS\0"
"20..BR_AND_ZERO\0"
"20..BR_AND_NOT_ZERO\0"
"10.NBR_MM_ZERO\0"
"10.NBR_MM_NOT_ZERO\0"
"20..BR_AND_AND_ZERO\0"
"20..BR_AND_AND_NOT_ZERO\0"
"20..BR_OR_OR_ZERO\0"
"20..BR_OR_OR_NOT_ZERO\0"
"20.NBR_BT\0"
"20.NBR_BTS\0"
"20.NBR_BTR\0"
"20.NBR_BTC\0"
"20.NBR_LBTS\0"
"20.NBR_LBTR\0"
"20.NBR_LBTC\0"
"20.NBR_NOT_BT\0"
"20.NBR_NOT_BTS\0"
"20.NBR_NOT_BTR\0"
"20.NBR_NOT_BTC\0"
"20.NBR_NOT_LBTS\0"
"20.NBR_NOT_LBTR\0"
"20.NBR_NOT_LBTC\0"
"20.NSWAP_U8\0"
"20.NSWAP_U16\0"
"20.NSWAP_U32\0"
"20.NSWAP_U64\0"
"10..ABS_I64\0"
"10..SIGN_I64\0"
"20..MIN_I64\0"
"20..MIN_U64\0"
"20..MAX_I64\0"
"20..MAX_U64\0"
"30..LIMIT_I64\0"
"30..LIMIT_U64\0"
"20..MOD_U64\0"
"10..SQRI64\0"
"10..SQRU64\0"
"11..SQR\0"
"11..ABS\0"
"11..SQRT\0"
"11..SIN\0"
"11..COS\0"
"11..TAN\0"
"11..ATAN\0"
);$AN,"Anchor for adding intermediate codes","IC_INIT_TABLE"$
}
U0 CmpFillTables()
{
U8 *st;
I64 i,k;
U32 *u,*d4;
assign_bitmap=CAlloc((IC_NUM_ENTRIES+7)>>3);
deref_bitmap=CAlloc((IC_NUM_ENTRIES+7)>>3);
cmp_bitmap=CAlloc((IC_NUM_ENTRIES+7)>>3);
not_constant_bitmap=CAlloc((IC_NUM_ENTRIES+7)>>3);
fpop_bitmap=CAlloc((IC_NUM_ENTRIES+7)>>3);
cmp_arg_cnt=CAlloc(IC_NUM_ENTRIES);
cmp_result_cnt=CAlloc(IC_NUM_ENTRIES);
st=Define("ST_INTERMEDIATE_CODE");
for (i=0;i<IC_NUM_ENTRIES;i++) {
cmp_arg_cnt[i]=*st-'0';
cmp_result_cnt[i]=st[1]-'0';
if (st[2]=='*')
Bts(deref_bitmap,i);
else if (st[2]=='=')
Bts(assign_bitmap,i);
else if (st[2]=='^')
Bts(cmp_bitmap,i);
if (st[3]=='N')
Bts(not_constant_bitmap,i);
st+=StrLen(st)+1;
//See $LK,"ST_INTERMEDIATE_CODE","FF:::/SparrowOS/Compiler/CodeGen.CPP.Z,ST_INTERMEDIATE_CODE"$.
}
Bts(fpop_bitmap,IC_ADD);
Bts(fpop_bitmap,IC_SUB);
Bts(fpop_bitmap,IC_MUL);
Bts(fpop_bitmap,IC_DIV);
Bts(fpop_bitmap,IC__PP);
Bts(fpop_bitmap,IC__MM);
Bts(fpop_bitmap,IC_PP_);
Bts(fpop_bitmap,IC_MM_);
Bts(fpop_bitmap,IC_SQR);
Bts(fpop_bitmap,IC_ABS);
Bts(fpop_bitmap,IC_SQRT);
Bts(fpop_bitmap,IC_SIN);
Bts(fpop_bitmap,IC_COS);
Bts(fpop_bitmap,IC_TAN);
Bts(fpop_bitmap,IC_ATAN);
to_reg_vars_map=CAlloc(NUM_REGS*sizeof(U8));
num_reg_vars=0;
reg_vars_mask=CREG_VARS_MASK;
for (i=0;i<NUM_REGS;i++)
if (Bt(&reg_vars_mask,i))
to_reg_vars_map[num_reg_vars++]=i;
to_non_ptr_vars_map=CAlloc(NUM_REGS*sizeof(U8));
num_non_ptr_vars=0;
non_ptr_vars_mask=CREG_NON_PTR_MASK;
for (i=0;i<NUM_REGS;i++)
if (Bt(&non_ptr_vars_mask,i))
to_non_ptr_vars_map[num_non_ptr_vars++]=i;
to_stk_temps_map_odd=CAlloc(NUM_REGS*sizeof(U8));
to_stk_temps_map_even=CAlloc(NUM_REGS*sizeof(U8));
num_stk_temps=0;
stk_temps_mask=CSTK_TEMPS_MASK;
for (i=0;i<NUM_REGS;i++)
if (Bt(&stk_temps_mask,i))
to_stk_temps_map_even[num_stk_temps++]=i;
k=num_stk_temps;
for (i=0;i<NUM_REGS;i++)
if (Bt(&stk_temps_mask,i))
to_stk_temps_map_odd[--k]=i;
u=CAlloc(sizeof(U32)*TK_NUM_TK);
dual_U16_tokens1=u;
u['!']=TK_NOT_EQUAL<<16+'=';
u['&']=TK_AND_AND<<16+'&';
u['*']=TK_MUL_EQUAL<<16+'=';
u['+']=TK_PLUS_PLUS<<16+'+';
u['-']=TK_DEREFERENCE<<16+'>';
u['/']='*';
u[':']=TK_DBL_COLON<<16+':';
u['<']=TK_LESS_EQUAL<<16+'=';
u['=']=TK_EQUAL_EQUAL<<16+'=';
u['>']=TK_GREATER_EQUAL<<16+'=';
u['^']=TK_XOR_EQUAL<<16+'=';
u['|']=TK_OR_OR<<16+'|';
u['%']=TK_MOD_EQUAL<<16+'=';
u=CAlloc(sizeof(U32)*TK_NUM_TK);
dual_U16_tokens2=u;
u['&']=TK_AND_EQUAL<<16+'=';
u['+']=TK_ADD_EQUAL<<16+'=';
u['-']=TK_MINUS_MINUS<<16+'-';
u['/']='/';
u['<']=TK_SHL<<16+'<';
u['>']=TK_SHR<<16+'>';
u['^']=TK_XOR_XOR<<16+'^';
u['|']=TK_OR_EQUAL<<16+'=';
u=CAlloc(sizeof(U32)*TK_NUM_TK);
dual_U16_tokens3=u;
u['-']=TK_SUB_EQUAL<<16+'=';
u['/']=TK_DIV_EQUAL<<16+'=';
//$AN,"","OP_precedence"$Here the operator precedences are
//defined.
d4=CAlloc(sizeof(U32)*TK_NUM_TK);
unary_ops_table=d4;
d4['~']=PREC_UNARY_PRE<<16+IC_COM;
d4['!']=PREC_UNARY_PRE<<16+IC_NOT;
d4['-']=PREC_UNARY_PRE<<16+IC_UNARY_MINUS;
d4['&']=PREC_UNARY_PRE<<16+IC_ADDR;
d4['*']=PREC_UNARY_PRE<<16+IC_DEREF;
d4=CAlloc(sizeof(U32)*TK_NUM_TK);
binary_ops_table=d4;
d4['`'] =(PREC_EXP+ASSOCF_RIGHT)<<16+IC_POWER;
d4[TK_SHL] =(PREC_EXP+ASSOCF_LEFT)<<16+IC_SHL;
d4[TK_SHR] =(PREC_EXP+ASSOCF_LEFT)<<16+IC_SHR;
d4['*'] =PREC_MUL<<16+IC_MUL;
d4['/'] =(PREC_MUL+ASSOCF_LEFT)<<16+IC_DIV;
d4['%'] =(PREC_MUL+ASSOCF_LEFT)<<16+IC_MOD;
d4['&'] =PREC_AND<<16+IC_AND;
d4['^'] =PREC_XOR<<16+IC_XOR;
d4['|'] =PREC_OR<<16+IC_OR;
d4['+'] =PREC_ADD<<16+IC_ADD;
d4['-'] =(PREC_ADD+ASSOCF_LEFT)<<16+IC_SUB;
d4['<'] =PREC_CMP<<16+IC_LESS;
d4['>'] =PREC_CMP<<16+IC_GREATER;
d4[TK_LESS_EQUAL] =PREC_CMP<<16+IC_LESS_EQUAL;
d4[TK_GREATER_EQUAL] =PREC_CMP<<16+IC_GREATER_EQUAL;
d4[TK_EQUAL_EQUAL] =PREC_CMP2<<16+IC_EQUAL_EQUAL;
d4[TK_NOT_EQUAL] =PREC_CMP2<<16+IC_NOT_EQUAL;
d4[TK_AND_AND] =PREC_AND_AND<<16+IC_AND_AND;
d4[TK_XOR_XOR]=PREC_XOR_XOR<<16+IC_XOR_XOR;
d4[TK_OR_OR] =PREC_OR_OR<<16+IC_OR_OR;
d4[':'] =(PREC_QUEST+ASSOCF_LEFT)<<16+IC_COLON;
d4['?'] =(PREC_QUEST+ASSOCF_LEFT)<<16+IC_QUESTION;
d4['='] =(PREC_ASSIGN+ASSOCF_RIGHT)<<16+IC_ASSIGN;
d4[TK_SHL_EQUAL]=(PREC_ASSIGN+ASSOCF_RIGHT)<<16+IC_SHL_EQUAL;
d4[TK_SHR_EQUAL]=(PREC_ASSIGN+ASSOCF_RIGHT)<<16+IC_SHR_EQUAL;
d4[TK_MUL_EQUAL]=(PREC_ASSIGN+ASSOCF_RIGHT)<<16+IC_MUL_EQUAL;
d4[TK_DIV_EQUAL]=(PREC_ASSIGN+ASSOCF_RIGHT)<<16+IC_DIV_EQUAL;
d4[TK_MOD_EQUAL]=(PREC_ASSIGN+ASSOCF_RIGHT)<<16+IC_MOD_EQUAL;
d4[TK_AND_EQUAL]=(PREC_ASSIGN+ASSOCF_RIGHT)<<16+IC_AND_EQUAL;
d4[TK_OR_EQUAL] =(PREC_ASSIGN+ASSOCF_RIGHT)<<16+IC_OR_EQUAL;
d4[TK_XOR_EQUAL]=(PREC_ASSIGN+ASSOCF_RIGHT)<<16+IC_XOR_EQUAL;
d4[TK_ADD_EQUAL]=(PREC_ASSIGN+ASSOCF_RIGHT)<<16+IC_ADD_EQUAL;
d4[TK_SUB_EQUAL]=(PREC_ASSIGN+ASSOCF_RIGHT)<<16+IC_SUB_EQUAL;
}
Reference in new issue View Git Blame Copy Permalink