URL
https://opencores.org/ocsvn/forwardcom/forwardcom/trunk
Subversion Repositories forwardcom
[/] [forwardcom/] [bintools/] [assem2.cpp] - Rev 42
Compare with Previous | Blame | View Log
/**************************** assem2.cpp ******************************** * Author: Agner Fog * Date created: 2017-04-17 * Last modified: 2021-08-11 * Version: 1.11 * Project: Binary tools for ForwardCom instruction set * Module: assem.cpp * Description: * Module for assembling ForwardCom .as files. * This module contains: * - expression(): Interpretation of expressions containing operators and * any type of operands. * Copyright 2017-2021 GNU General Public License http://www.gnu.org/licenses ******************************************************************************/ #include "stdafx.h" // Interpret and evaluate expression SExpression CAssembler::expression(uint32_t tok1, uint32_t maxtok, uint32_t options) { // tok1: index to first token, // maxtok: maximum number of tokens to use, // options: 0: normal, // 1: unsigned // 2: inside []. interpret as memory operand // 4: interpret option = keyword // 8: inside {}. has no meaning yet // 0x10: check syntax and count tokens, but do not call functions or report numeric // overflow, wrong operand types, or unknown names // This function scans the tokens and finds the operator with lowest priority. // The function is called recursively for each operand to this operator. // The level of parantheses is saved in the brackets stack. // The scanning terminates at any of these conditions: // * a token that cannot be part of the expression is encountered // * all tokens are used // * a comma is encountered // * an unmatched end bracket is encountered uint32_t tok; // current token uint32_t toklow = tok1; // operator with lowest priority uint32_t tokcolon = 0; // matching triadic operator with lowest priority uint32_t ntok = 0; // number of tokens used uint32_t priority = 0; // priority of this operator uint32_t bracketlevel = 0; // number of brackets in stack uint32_t state = 0; // 0: expecting value, 1: after value, expecting operator or end uint32_t i; // loop counter uint32_t temp; // temporary result uint32_t tokid; // token.id int32_t symi; // symbol index bool is_local = false; // symbol is local constant uint8_t endbracket; // expected end bracket SExpression exp1, exp2; // expressions during evaluation zeroAllMembers(exp1); // reset exp1 exp1.tokens = 1; for (tok = tok1; tok < tok1 + maxtok; tok++) { if (lineError) {exp1.etype = 0; return exp1;} if (tokens[tok].type == TOK_OPR) { // operator found. search for brackets if (tokens[tok].priority == 1 || tokens[tok].priority == 14) { // bracket found. ?: operator treated as bracket here switch (tokens[tok].id) { case '?': if (tokens[tok].priority > priority && bracketlevel == 0) { // if multiple ?:, split by the last one priority = tokens[tok].priority; toklow = tok; } // continue in next case case '(': case '[': case '{': // opening bracket. push on bracket stack brackets.push(uint8_t(tokens[tok].id)); bracketlevel++; state = 0; break; case ')': case ']': case '}': case ':': // closing bracket if (bracketlevel == 0) { goto EXIT_LOOP; // this end bracket is not part of the expression. } // remove matching opening bracket from stack bracketlevel--; endbracket = brackets.pop(); switch (endbracket) { case '(': endbracket = ')'; break; case '[': endbracket = ']'; break; case '{': endbracket = '}'; break; case '?': endbracket = ':'; break; } if (endbracket != tokens[tok].id) { // end bracket does not match begin bracket errors.report(tokens[tok].pos, tokens[tok].stringLength, ERR_BRACKET_END); goto EXIT_LOOP; } if (tokens[tok].id == ':') { if (bracketlevel == 0 && priority == 14 && tokcolon == 0) { tokcolon = tok; // ':' matches current '?' with lowest priority } state = 0; continue; } state = 1; continue; // finished with this token } } if (bracketlevel) continue; // don't search for priority inside brackets if (state == 1) { // expecting operator if (tokens[tok].id == ';') break; // end at semicolon if (tokens[tok].id == ',' && !(options & 2)) break; // end at comma, except inside [] if (tokens[tok].id == '=' && !(options & 6)) break; // end at =, except inside [] or when interpreting option = value if (tokens[tok].priority >= priority) { // if multiple operators with same priority, split by the last one to get the first evaluated first // operator with lower priority found priority = tokens[tok].priority; toklow = tok; } if (tokens[tok].priority == 3) state = 1; else state = 0; // state 0 except after monadic operator } else if (state == 0 && (tokens[tok].id == '-' || tokens[tok].id == '+' || tokens[tok].priority == 3)) { // monadic operator if (priority < 3) { priority = 3; toklow = tok; } } else { errors.report(tokens[tok]); break; // unexpected operator } } else { // not an operator if (bracketlevel) continue; // inside brackets: search only for end bracket if (state == 0) { // expecting value switch (tokens[tok].type) { case TOK_NAM: case TOK_LAB: case TOK_VAR: case TOK_SEC: case TOK_NUM: case TOK_FLT: case TOK_CHA: case TOK_STR: case TOK_REG: case TOK_SYM: case TOK_XPR: case TOK_OPT: state = 1; // allowed value tokens break; case TOK_TYP: state = 1; // type expression break; case TOK_HLL: if (tokens[tok].id == HLL_FALSE || tokens[tok].id == HLL_TRUE) { state = 1; } else { errors.report(tokens[tok]); } break; default: errors.report(tokens[tok]); break; } } else { break; // no operator found after value. end here } } } EXIT_LOOP: if (lineError) {exp1.etype = 0; return exp1;} // number of tokens used ntok = tok - tok1; exp1.tokens = ntok; if (bracketlevel) { endbracket = brackets.pop(); errors.report(tokens[tok1].pos, tokens[tok].pos - tokens[tok1].pos, endbracket == '?' ? ERR_QUESTION_MARK : ERR_BRACKET_BEGIN); if (exp1.etype == 0) exp1.etype = XPR_INT; return exp1; } if (ntok == 0) { // no expression found if (maxtok == 0 && tok > 0) tok--; errors.report(tokens[tok].pos, tokens[tok].stringLength, ERR_MISSING_EXPR); return exp1; } switch (priority) { case 0: // no operator found. just an expression if (ntok > 2 && tokens[tok1].type == TOK_OPR && tokens[tok1].priority == 1) { // this is an expression in brackets uint32_t option1 = options; if (tokens[tok1].id == '[') { if (options & 2) errors.report(tokens[tok1]); // nested [[]] not allowed option1 |= 2; } if (tokens[tok1].id == '{') option1 |= 8; // evaluate expression inside bracket exp1 = expression(tok1 + 1, ntok - 2, option1); exp1.tokens += 2; goto RETURNEXP1; } else if (ntok == 1) { // this is a single token. get value switch (tokens[tok1].type) { case TOK_LAB: case TOK_VAR: case TOK_SEC: case TOK_SYM: exp1.etype = XPR_SYM1; // symbol address exp1.sym3 = tokens[tok1].id; symi = findSymbol(exp1.sym3); // is symbol local with known value? is_local = symi > 0 && symbols[symi].st_bind == STB_LOCAL && (symbols[symi].st_type == STT_CONSTANT || symbols[symi].st_type == STT_VARIABLE); if (options & 2) { // symbol inside [] exp1.etype |= XPR_MEM; exp1.sym3 = 0; if (is_local) { exp1.offset_mem = tokens[tok1].value.w;// don't take value from symbol, it may change exp1.etype &= ~XPR_SYM1; // symbol reference no longer needed exp1.etype |= XPR_OFFSET; // has offset } else { exp1.sym1 = tokens[tok1].id; } if (exp1.etype & (XPR_FLT | XPR_STRING)) { // float or string not allowed in memory operand errors.report(tokens[tok1].pos, tokens[tok1].stringLength, ERR_WRONG_TYPE); } } else { // symbol outside [] if (is_local) { if (symbols[symi].st_other & STV_FLOAT) exp1.etype |= XPR_FLT; else exp1.etype |= XPR_INT; exp1.value.i = tokens[tok1].value.u; // don't take value from symbol, it may change if (symbols[symi].st_other & STV_STRING) { exp1.etype = XPR_STRING; exp1.sym2 = (uint32_t)symbols[symi].st_unitnum; // sym2 used for string length } else { exp1.etype &= ~XPR_SYM1; // symbol reference no longer needed exp1.sym3 = 0; } } else { exp1.etype |= XPR_INT; // type not known yet? exp1.sym3 = tokens[tok1].id; } } break; case TOK_NUM: if (options & 2) { // number inside [] is offset exp1.etype = XPR_OFFSET; // integer value exp1.offset_mem = (int32_t)interpretNumber((char*)buf()+tokens[tok1].pos, tokens[tok1].stringLength, &temp); } else { // number outside [] is operand exp1.etype = XPR_INT; // integer value exp1.value.i = interpretNumber((char*)buf() + tokens[tok1].pos, tokens[tok1].stringLength, &temp); } if (temp) errors.report(tokens[tok1]); break; case TOK_FLT: exp1.etype = XPR_FLT; // floating point value exp1.value.d = interpretFloat((char*)buf()+tokens[tok1].pos, tokens[tok1].stringLength); if (options & 2) { // float not allowed in memory operand errors.report(tokens[tok1].pos, tokens[tok1].stringLength, ERR_WRONG_TYPE); } break; case TOK_CHA: { // character(s). convert to integer exp1.etype = XPR_INT; exp1.value.u = 0; bool escape = false; // check for \ escape characters int j = 0; // count characters for (i = 0; i < tokens[tok1].stringLength; i++) { uint8_t c = get<uint8_t>(tokens[tok1].pos + i); if (c == '\\' && !escape) { escape = true; continue; // escape next character } if (escape) { // special escape characters switch (c) { case '\\': break; case 'n': c = '\n'; break; case 'r': c = '\r'; break; case 't': c = '\t'; break; case '0': c = 0; break; } } escape = false; exp1.value.u += uint64_t(c) << j*8; j++; } if (options & 2) { // string not allowed in memory operand errors.report(tokens[tok1].pos, tokens[tok1].stringLength, ERR_WRONG_TYPE); } break;} case TOK_STR: { // string exp1.etype = XPR_STRING; exp1.value.u = stringBuffer.dataSize(); // save position of string exp1.sym2 = tokens[tok1].stringLength; // string length bool escape = false; // check for \ escape characters for (i = 0; i < tokens[tok1].stringLength; i++) { char c = get<char>(tokens[tok1].pos + i); if (c == '\\' && !escape) { escape = true; continue; // escape next character } if (escape) { // special escape characters switch (c) { case '\\': escape = false; break; case 'n': c = '\n'; break; case 'r': c = '\r'; break; case 't': c = '\t'; break; case '0': c = 0; break; } } if (escape && exp1.sym2) exp1.sym2--; // reduce length stringBuffer.put(c); escape = false; } stringBuffer.put(char(0)); // terminate string if (options & 2) { // string not allowed in memory operand errors.report(tokens[tok1].pos, tokens[tok1].stringLength, ERR_WRONG_TYPE); } break;} case TOK_REG: if (options & 2) { // register inside [] is base register exp1.etype = XPR_BASE | XPR_MEM; exp1.base = uint8_t(tokens[tok1].id); if ((tokens[tok1].id & 0xFE0) == REG_SPEC) { exp1.base = tokens[tok1].id >> 16; // special register. to do: check if register type is valid } } else { // normal register operand exp1.etype = XPR_REG | XPR_REG1; exp1.reg1 = tokens[tok1].id; } break; case TOK_NAM: if ((options & 0x10) == 0) errors.report(tokens[tok1]); exp1.etype |= XPR_UNRESOLV; // unresolved name break; case TOK_OPT: exp1.etype = XPR_OPTION; if ((tokens[tok1].id) == OPT_SCALAR) { exp1.etype |= XPR_SCALAR; } else { exp1.value.u = tokens[tok1].id; } break; case TOK_XPR: // expression if (tokens[tok1].value.u < expressions.numEntries()) { exp1 = expressions[tokens[tok1].value.w]; exp1.tokens = ntok; if ((exp1.etype & XPR_REG) && !(exp1.etype & XPR_MEM) && (options & 2)) { // register inside [] is base register exp1.etype = XPR_BASE | XPR_MEM; exp1.base = exp1.reg1; exp1.reg1 = 0; } } else errors.report(tokens[tok1]); break; case TOK_TYP: exp1.etype = XPR_TYPENAME; exp1.value.u = tokens[tok1].id; break; case TOK_HLL: if (tokens[tok1].id == HLL_FALSE || tokens[tok1].id == HLL_TRUE) { // translate to constant exp1.etype = XPR_INT; exp1.value.u = tokens[tok1].id & 1; } else { errors.report(tokens[tok1]); } break; default: errors.report(tokens[tok1]); } if (options & 2) exp1.etype |= XPR_MEM; // inside [], interpret as memory operand goto RETURNEXP1; } else { // unrecognized token errors.report(tokens[tok1]); } break; case 3: // monadic operator if (toklow == tok1) { // operator comes first exp1 = expression(toklow + 1, maxtok - 1, options); // evaluate the rest if (exp1.etype & XPR_UNRESOLV) { exp1.tokens++; // unresolved expression. return unresolved result goto RETURNEXP1; } zeroAllMembers(exp2); // zero exp2 switch (tokens[toklow].id) { case '+': // value is unchanged exp1.tokens++; goto RETURNEXP1;; // value is unchanged case '-': if (exp1.etype & (XPR_OP | XPR_REG | XPR_MEM)) { exp1 = op1minus(exp1); // convert -(A+B) etc. goto RETURNEXP1; } exp2 = exp1; // convert -A to 0-A exp1.tokens = 0; exp1.etype = XPR_INT; exp1.value.i = 0; tokid = '-'; break; // continue in dyadic operators with 0-exp2 case '!': exp1.tokens++; if (exp1.instruction == II_COMPARE && (exp1.etype & XPR_REG1) && (exp1.etype & (XPR_REG2 | XPR_INT | XPR_IMMEDIATE))) { // compare instruction. invert condition exp1.optionbits ^= 1; exp1.etype |= XPR_OPTIONS; if ((exp1.reg1 & REG_V) && (dataType & TYP_FLOAT)) exp1.optionbits ^= 8; // floating point compare. invert gives unordered goto RETURNEXP1; } if (exp1.instruction == II_AND && (exp1.etype & XPR_REG1) && (exp1.etype & XPR_INT)) { // test_bit/test_bits_or/jump instruction. invert condition exp1.optionbits ^= 4; exp1.etype |= XPR_OPTIONS; goto RETURNEXP1; } if (exp1.instruction == II_TEST_BITS_AND && (exp1.etype & XPR_REG1) && (exp1.etype & XPR_INT)) { // test_bits_and/jump instruction. invert condition exp1.optionbits ^= 1; exp1.etype |= XPR_OPTIONS; goto RETURNEXP1; } if (exp1.etype & (XPR_MEM | XPR_REG)) { // '!' ambiguous on register and memory operands errors.report(tokens[toklow].pos, tokens[toklow].stringLength, ERR_NOT_OP_AMBIGUOUS); } exp2.tokens = 0; exp2.etype = XPR_INT; exp2.value.i = 0; tokid = '='+D2; break; // continue in dyadic operators with exp1 == 0 case '~': exp2.tokens = 0; exp2.etype = XPR_INT; exp2.value.i = -1; tokid = '^'; break; // continue in dyadic operators with exp1 ^ -1 default: errors.report(tokens[tok1]); // ++ and -- not supported in expression return exp1; } goto DYADIC; // proceed to dyadic operator } else { // postfix ++ and -- errors.report(tokens[tok1+1]); // ++ and -- not supported in expression } goto RETURNEXP1; case 14: // triadic operator ?: // evaluate exp1 ? exp2 : exp3 for all expression types return op3(tok1, toklow, tokcolon, maxtok, options); default:; // continue below for dyadic operator } // dyadic operator. evaluate two subexpressions exp1 = expression(tok1, toklow - tok1, options); // evaluate fist expression if (exp1.tokens != toklow - tok1) errors.report(tokens[tok1 + exp1.tokens]); if (lineError) return exp1; exp2 = expression(toklow + 1, tok1 + maxtok - (toklow + 1), options); // evaluate second expression ntok = toklow - tok1 + 1 + exp2.tokens; tokid = tokens[toklow].id; // operator id if (lineError) return exp1; DYADIC: exp1 = op2(tokid, exp1, exp2); RETURNEXP1: if (lineError) return exp1; if (exp1.etype & XPR_ERROR) { errors.report(tokens[toklow].pos, tokens[toklow].stringLength, exp1.value.w); } return exp1; } // Interpret dyadic expression with any type of operands SExpression CAssembler::op2(uint32_t op, SExpression & exp1, SExpression & exp2) { if ((exp1.etype | exp2.etype) & XPR_UNRESOLV) { exp1.etype = XPR_UNRESOLV; // unresolved operand. make unresolved result exp1.tokens += exp2.tokens + 1; } else if ((exp1.etype & exp2.etype & XPR_MEM) //&& ((exp1.etype|exp2.etype) & (XPR_BASE|XPR_INDEX|XPR_OPTION|XPR_SYM1|XPR_SYM2|XPR_LIMIT|XPR_LENGTH|XPR_BROADC)) ) { exp1 = op2Memory(op, exp1, exp2); // generation of memory operand. both operands inside [] and contain not only constants } else if (exp1.etype == XPR_OPTION && op == '=') { // option = value is handled by op2Memory exp1 = op2Memory(op, exp1, exp2); } else if (exp1.etype & exp2.etype & XPR_SYM1) { // adding or subtracting symbols and integers exp1 = op2Memory(op, exp1, exp2); } else if ((exp1.etype & XPR_SYM2) && (exp2.etype & XPR_INT)) { // (sym1-sym2)/const exp1 = op2Memory(op, exp1, exp2); } // generation of instruction involving registers and/or memory operand: // (don't rely on XPR_MEM flag here because we would catch expressions involving constants only inside [] ) //!else if ((exp1.etype | exp2.etype) & (XPR_REG | XPR_BASE /*| XPR_SYM1*/)) { // else if ((exp1.etype | exp2.etype) & (XPR_REG | XPR_BASE | XPR_SYM1)) { //?? else if (((exp1.etype | exp2.etype) & (XPR_REG | XPR_BASE)) || (exp1.sym1 | exp2.sym1)) { //?? exp1 = op2Registers(op, exp1, exp2); } else if ((exp1.etype | exp2.etype) & XPR_STRING) { exp1 = op2String(op, exp1, exp2); // string operation } else if ((exp1.etype & 0xF) == XPR_FLT || (exp2.etype & 0xF) == XPR_FLT) { // dyadic operators for float // floating point operation exp1 = op2Float(op, exp1, exp2); } else if ((exp1.etype & 0xF) == XPR_INT && (exp2.etype & 0xF) == XPR_INT) { // dyadic operators for integers // integer operation exp1 = op2Int(op, exp1, exp2); } else { // other types exp1.etype = XPR_ERROR; exp1.value.u = ERR_WRONG_TYPE; } return exp1; } // Interpret dyadic expression with integer operands SExpression CAssembler::op2Int(uint32_t op, SExpression const & exp1, SExpression const & exp2) { SExpression expr = exp1; expr.tokens = exp1.tokens + exp2.tokens + 1; switch (op & ~OP_UNS) { case '+': expr.value.u = exp1.value.u + exp2.value.u; break; case '-': expr.value.u = exp1.value.u - exp2.value.u; break; case '*': expr.value.i = exp1.value.i * exp2.value.i; break; case '/': if (exp2.value.i == 0) { expr.etype |= XPR_ERROR; expr.value.u = ERR_OVERFLOW; break; } if (op & OP_UNS) expr.value.u = exp1.value.u / exp2.value.u; // unsigned division else expr.value.i = exp1.value.i / exp2.value.i; // signed division break; case '%': if (exp2.value.i == 0) { expr.etype |= XPR_ERROR; expr.value.u = ERR_OVERFLOW; break; } if (op & OP_UNS) expr.value.u = exp1.value.u % exp2.value.u; // unsigned modulo else expr.value.i = exp1.value.i % exp2.value.i; // signed modulo break; case '<' + D2: // << expr.value.u = exp1.value.u << exp2.value.u; break; case '>' + D2: // >> shift right signed if (op & OP_UNS) expr.value.u = exp1.value.u >> exp2.value.u; // unsigned shift right else expr.value.i = exp1.value.i >> exp2.value.i; // signed shift right break; case '>' + D3: // >>> unsigned shift right expr.value.u = exp1.value.u >> exp2.value.u; break; case '<': // < compare if (op & OP_UNS) expr.value.i = exp1.value.u < exp2.value.u; // unsigned compare else expr.value.i = exp1.value.i < exp2.value.i; // signed compare break; case '<' + EQ: // <= compare if (op & OP_UNS) expr.value.i = exp1.value.u <= exp2.value.u; // unsigned compare else expr.value.i = exp1.value.i <= exp2.value.i; // signed compare break; case '>': // > compare if (op & OP_UNS) expr.value.i = exp1.value.u > exp2.value.u; // unsigned compare else expr.value.i = exp1.value.i > exp2.value.i; // signed compare break; case '>' + EQ: // >= compare if (op & OP_UNS) expr.value.i = exp1.value.u >= exp2.value.u; // unsigned compare else expr.value.i = exp1.value.i >= exp2.value.i; // signed compare break; case '=' + D2: // == expr.value.u = exp1.value.u == exp2.value.u; break; case '!' + EQ: // != expr.value.u = exp1.value.u != exp2.value.u; break; case '&': // bitwise and expr.value.u = exp1.value.u & exp2.value.u; break; case '|': // bitwise or expr.value.u = exp1.value.u | exp2.value.u; break; case '^': // bitwise xor expr.value.u = exp1.value.u ^ exp2.value.u; break; case '&' + D2: // logical and expr.value.u = exp1.value.u && exp2.value.u; break; case '|' + D2: // logical or expr.value.u = exp1.value.u || exp2.value.u; break; case '^' + D2: // logical xor expr.value.u = (exp1.value.u != 0) ^ (exp2.value.u != 0); break; default: // unsupported operator expr.etype |= XPR_ERROR; expr.value.u = ERR_WRONG_TYPE; } return expr; } // Interpret dyadic expression with floating point operands SExpression CAssembler::op2Float(uint32_t op, SExpression & exp1, SExpression & exp2) { SExpression expr = exp1; expr.tokens = exp1.tokens + exp2.tokens + 1; if (exp1.etype == XPR_INT) { // convert exp1 to float exp1.value.d = (double)exp1.value.i; expr.etype = XPR_FLT; } if (exp2.etype == XPR_INT) { // convert exp2 to float exp2.value.d = (double)exp2.value.i; expr.etype = XPR_FLT; } // dyadic operator on float switch (op) { case '+': expr.value.d = exp1.value.d + exp2.value.d; break; case '-': expr.value.d = exp1.value.d - exp2.value.d; break; case '*': expr.value.d = exp1.value.d * exp2.value.d; break; case '/': if (exp2.value.d == 0.) { expr.etype |= XPR_ERROR; expr.value.u = ERR_OVERFLOW; break; } expr.value.d = exp1.value.d / exp2.value.d; break; case '<': // signed compare expr.value.i = exp1.value.d < exp2.value.d; expr.etype = XPR_INT; break; case '<' + EQ: // <= signed compare expr.value.i = exp1.value.d <= exp2.value.d; expr.etype = XPR_INT; break; case '>': // signed compare expr.value.i = exp1.value.d > exp2.value.d; expr.etype = XPR_INT; break; case '>' + EQ: // >= signed compare expr.value.i = exp1.value.d <= exp2.value.d; expr.etype = XPR_INT; break; case '=' + D2: // == expr.value.i = exp1.value.d == exp2.value.d; expr.etype = XPR_INT; break; case '!' + EQ: // != expr.value.i = exp1.value.d != exp2.value.d; expr.etype = XPR_INT; break; case '&' + D2: // logical and expr.value.i = exp1.value.d != 0. && exp2.value.d != 0.; expr.etype = XPR_INT; break; break; case '|' + D2: // logical or expr.value.i = exp1.value.d != 0. || exp2.value.d != 0.; expr.etype = XPR_INT; break; break; default: // unsupported operator expr.etype |= XPR_ERROR; expr.value.u = ERR_WRONG_TYPE; } return expr; } // Interpret dyadic expression with register or memory operands, generating instruction SExpression CAssembler::op2Registers(uint32_t op, SExpression const & ex1, SExpression const & ex2) { SExpression expr = {{0}}; // return expression uint8_t swapped = false; // operands are swapped uint8_t cannotSwap = false; // cannot swap operands because both contain vector registers uint32_t i; // loop counter // make array of the two expressions SExpression exp12[2]; // copy of expressions uint32_t numtokens = ex1.tokens + ex2.tokens + 1; // number of tokens expr.tokens = numtokens; // resolve nested expressions if ((ex1.etype | ex2.etype) & XPR_OP) { /* if (op == '&' && (ex1.etype & XPR_REG) && !(ex1.etype & XPR_OP) && ex2.instruction == II_XOR && ((ex2.etype & 0xF) == XPR_INT) && ex2.value.i == -1) { // A & (B ^ -1) = and_not(A,B). This instruction is removed expr = ex1; expr.tokens = numtokens; expr.etype |= XPR_OP; expr.instruction = II_AND_NOT; expr.reg2 = ex2.reg1; return expr; } */ // simplify both expressions if possible exp12[0] = ex1; exp12[1] = ex2; for (i = 0; i < 2; i++) { if ((exp12[i].etype & (XPR_REG | XPR_MEM)) && (exp12[i].etype & XPR_IMMEDIATE) && exp12[i].value.i == 0) { if (exp12[i].instruction == II_SUB_REV) { // expression is -A converted to (0-A). change to register and sign bit exp12[i].etype &= ~(XPR_OPTIONS | XPR_IMMEDIATE | XPR_OP); exp12[i].instruction = 0; exp12[i].optionbits = 1; } else if (exp12[i].instruction == II_MUL_ADD && exp12[i].value.i == 0) { // expression is -A*B converted to (-A*B+0). change to A*B and sign bit exp12[i].instruction = II_MUL; exp12[i].optionbits = exp12[i].optionbits & 1; exp12[i].etype &= ~(XPR_OPTIONS | XPR_IMMEDIATE); } else if (exp12[i].instruction == II_ADD_ADD && (exp12[i].etype & (XPR_INT | XPR_FLT)) && (exp12[i].optionbits & 3) == 3 && exp12[i].value.i == 0) { // expression is -(A+B) converted to (-A-B+0). change to A+B and sign bit exp12[i].etype &= ~(XPR_INT | XPR_FLT); exp12[i].instruction = II_ADD; exp12[i].optionbits ^= 3; exp12[i].etype &= ~(XPR_OPTIONS | XPR_IMMEDIATE); } } else if (exp12[i].instruction == II_SUB_REV) { // change -A+B to -(A-B) exp12[i].instruction = II_SUB; exp12[i].optionbits ^= 3; } } if ((exp12[0].etype & XPR_IMMEDIATE) && (exp12[1].etype & XPR_IMMEDIATE)) { // both operands contain an immediate. combine the immediates if possible bool isfloat[2]; // check if operands are float for (i = 0; i < 2; i++) isfloat[i] = (exp12[i].etype & XPR_IMMEDIATE) == XPR_FLT; // convert integer to float if the other operand is float for (i = 0; i < 2; i++) { if (isfloat[1-i] && !isfloat[i]) { exp12[i].value.d = (double)exp12[i].value.i; isfloat[i] = true; } } if (op == '+' || op == '-') { // add or subtract operands and store in exp12[1] uint8_t sign = 0; switch (exp12[0].instruction) { case II_ADD: case II_SUB_REV: sign = exp12[0].optionbits >> 1 & 1; if (op == '-') sign ^= 1; break; case II_SUB: sign = (exp12[0].optionbits >> 1 & 1) ^ 1; if (op == '-') sign ^= 1; break; case II_ADD_ADD: sign = exp12[0].optionbits >> 2 & 1; if (op == '-') sign ^= 1; break; default: // no other instructions can be combined with + or - expr.etype |= XPR_ERROR; expr.value.u = ERR_WRONG_OPERANDS; return expr; } if (exp12[1].instruction == II_SUB) sign ^= 1; // add immediates and store them in exp12[1] if (sign) { if (isfloat[1]) exp12[1].value.d -= exp12[0].value.d; else exp12[1].value.i -= exp12[0].value.i; } else { if (isfloat[1]) exp12[1].value.d += exp12[0].value.d; else exp12[1].value.i += exp12[0].value.i; } exp12[0].value.i = 0; exp12[0].etype &= ~ (XPR_INT | XPR_FLT); if (exp12[0].instruction == II_ADD_ADD) { exp12[0].instruction = II_ADD; exp12[0].optionbits &= ~ 4; } else { exp12[0].instruction = 0; } } else if (op == '*' && exp12[0].instruction == II_MUL) { if (isfloat[0]) { exp12[1].value.d *= exp12[0].value.d; } else { exp12[1].value.i *= exp12[0].value.i; } exp12[0].value.i = 0; exp12[0].etype &= ~ (XPR_INT | XPR_FLT | XPR_OP); exp12[0].instruction = 0; } /* else if (op == '&' && exp12[0].instruction == II_AND && !isfloat[0]) { exp12[1].value.i &= exp12[0].value.i; exp12[0].value.i = 0; exp12[0].etype &= ~ XPR_INT; exp12[0].instruction = 0; } else if (op == '|' && exp12[0].instruction == II_OR && !isfloat[0]) { exp12[1].value.i |= exp12[0].value.i; exp12[0].value.i = 0; exp12[0].etype &= ~ XPR_INT; exp12[0].instruction = 0; } else if (op == '^' && exp12[0].instruction == II_XOR && !isfloat[0]) { exp12[1].value.i ^= exp12[0].value.i; exp12[0].value.i = 0; exp12[0].etype &= ~ XPR_INT; exp12[0].instruction = 0; } */ else { expr.etype |= XPR_ERROR; expr.value.u = ERR_WRONG_OPERANDS; } } // error if two memory operands uint32_t etyp0 = exp12[0].etype, etyp1 = exp12[1].etype; //if ((etyp0 & etyp1 & XPR_MEM) || (exp12[0].value.i && exp12[1].value.i)) { if (etyp0 & etyp1 & XPR_MEM) { expr.etype |= XPR_ERROR; expr.value.u = ERR_WRONG_OPERANDS; return expr; } // error if too many operands if (((etyp0 & XPR_REG1) != 0) + ((etyp0 & XPR_REG2) != 0) + ((etyp0 & XPR_REG3) != 0) + ((etyp1 & XPR_REG1) != 0) + ((etyp1 & XPR_REG2) != 0) + ((etyp1 & XPR_REG3) != 0) + (((etyp0 | etyp1) & XPR_MEM) != 0) + (((etyp0 | etyp1) & XPR_IMMEDIATE) != 0) > 3) { expr.etype |= XPR_ERROR; expr.value.u = ERR_TOO_MANY_OPERANDS; return expr; } // check which operations can swap if (op != '+' && op != '*' && op != '&' && op != '|' && op != '^' && op != '-') { cannotSwap = true; // operation is not commutative ('-' is handled with sign bits) } // put operands in this order: register, memory, immediate if ((exp12[0].etype & (XPR_IMMEDIATE | XPR_MEM)) && !(exp12[1].etype & XPR_IMMEDIATE) && !cannotSwap) { // first operand is immediate or memory, and second operant is not immediate // swap operands if not two vector registers if (exp12[0].reg1 & exp12[1].reg1 & REG_V) { // both operands contain a vector register. cannot swap. make error message later if swapping required cannotSwap = true; } else if ((exp12[1].etype & XPR_MEM) && op == '*') { // second operand also contains memory cannotSwap = true; } else { // swap operands to get immediate or memory operand last expr = exp12[0]; exp12[0] = exp12[1]; exp12[1] = expr; if (op == '-') { op = '+'; // convert '-' to '+' and flip sign bit to make operation commutative exp12[0].optionbits ^= 1; } swapped = true; } } if (op == '+' || op == '-') { /* done above: if (exp12[0].etype & (XPR_IMMEDIATE | XPR_MEM) && exp12[1].instruction == II_MUL && !(exp12[1].etype & (XPR_INT | XPR_FLT))) { // (memory or constant) + reg*reg. swap operands expr = exp12[0]; exp12[0] = exp12[1]; exp12[1] = expr; if (op == '-') { exp12[0].optionbits ^= 1; // invert signs in both operands exp12[1].optionbits ^= 1; } } */ if (!((exp12[0].etype | exp12[1].etype) & XPR_OP)) { // +/-R1 +/-R2 if (op == '-') exp12[1].optionbits ^= 1; // sign of second operand // change sign of constant if this simplifies it if ((exp12[1].etype & XPR_INT) && (exp12[1].optionbits & 1)) { exp12[1].value.i = -exp12[1].value.i; exp12[1].optionbits = 0; } else if ((exp12[1].etype & XPR_FLT) && (exp12[1].optionbits & 1)) { exp12[1].value.d = -exp12[1].value.d; exp12[1].optionbits = 0; } uint8_t s = exp12[0].optionbits | exp12[1].optionbits << 1; // combine signs expr = exp12[1]; expr.tokens = numtokens; expr.reg1 = exp12[0].reg1; if (exp12[1].etype & XPR_REG1) { expr.reg2 = exp12[1].reg1; expr.etype |= XPR_REG2; } expr.etype |= XPR_OP | XPR_REG1; expr.optionbits = 0; switch (s) { case 0: // R1 + R2 expr.instruction = II_ADD; break; case 1: // -R1 + R2 expr.instruction = II_SUB_REV; break; case 2: // R1 - R2 expr.instruction = II_SUB; break; case 3: // -R1 -R2 expr.instruction = II_ADD_ADD; expr.value.i = 0; expr.optionbits = s; expr.etype |= XPR_INT | XPR_OPTIONS; break; } return expr; } else if (exp12[0].instruction == II_MUL || exp12[1].instruction == II_MUL) { // (A*B)+C if (op == '-') exp12[1].optionbits ^= 1; // change sign if '-' if (exp12[1].instruction == II_MUL) { // swap expressions if A+(B*C) if (exp12[0].reg1 & REG_V) { expr.etype |= XPR_ERROR; expr.value.w = ERR_CANNOT_SWAP_VECT; // cannot put vector addend as first operand return expr; } expr = exp12[0]; exp12[0] = exp12[1]; exp12[1] = expr; // swap expressions } expr = exp12[0] | exp12[1]; // combine expressions expr.tokens = numtokens; if ((exp12[0].etype & exp12[1].etype & (XPR_MEM|XPR_IMMEDIATE)) || // two memory or two immediate operands ((exp12[0].etype & (XPR_MEM|XPR_IMMEDIATE)) == (XPR_MEM|XPR_IMMEDIATE))) { // exp12[0] has both memory and immediate expr.etype |= XPR_ERROR; expr.value.w = ERR_TOO_COMPLEX; return expr; } expr.instruction = II_MUL_ADD; expr.etype |= XPR_OPTIONS; if (((exp12[0].etype & XPR_MEM) && !(exp12[1].etype & XPR_IMMEDIATE)) || (exp12[0].etype & XPR_IMMEDIATE)) { expr.instruction = II_MUL_ADD2; // get A*C+B // we don't need to do anything with signs here because the sign options apply to product and addend, not to specific operands } expr.etype |= XPR_OP; expr.reg1 = exp12[0].reg1; expr.reg2 = exp12[0].reg2; if (exp12[1].etype & XPR_REG) { // C has a register if (exp12[0].etype & XPR_REG2) { // 3 registers expr.reg3 = exp12[1].reg1; expr.etype |= XPR_REG3; } else { expr.reg2 = exp12[1].reg1; // 2 registers expr.etype |= XPR_REG2; } } // optionbits 0-1 = sign of product. optionbits 2-3 = sign of addend. expr.optionbits = 3 * (exp12[0].optionbits & 1) | 0xC * (exp12[1].optionbits & 1); expr.etype |= XPR_OPTIONS; return expr; } else if (exp12[0].instruction == II_ADD || exp12[0].instruction == II_SUB) { // (A+B)+C expr = exp12[0] | exp12[1]; // combine expressions expr.tokens = numtokens; expr.reg1 = exp12[0].reg1; expr.etype |= XPR_OP; expr.instruction = II_ADD_ADD; if ((exp12[0].etype & XPR_IMMEDIATE) || ((exp12[0].etype & XPR_MEM) && !(exp12[1].etype & XPR_IMMEDIATE))) { // does not fit expr.etype |= XPR_ERROR; expr.value.w = cannotSwap ? ERR_CANNOT_SWAP_VECT : ERR_TOO_COMPLEX; return expr; } if (exp12[1].etype & XPR_REG) { // C has a register if (exp12[0].etype & XPR_REG2) { // 3 registers expr.reg3 = exp12[1].reg1; expr.etype |= XPR_REG3; } else if (exp12[0].etype & XPR_REG1) { // 2 registers expr.reg2 = exp12[1].reg1; expr.etype |= XPR_REG2; } else { expr.reg1 = exp12[1].reg1; // 1 registers expr.etype |= XPR_REG1; } } expr.optionbits = (exp12[0].optionbits & 3) | ((exp12[1].optionbits & 1) ^ (op == '-')) << 2; if (exp12[0].instruction == II_SUB) expr.optionbits ^= 2; if (swapped && op == '-') expr.optionbits ^= 7; expr.etype |= XPR_OPTIONS; return expr; } else if (exp12[1].instruction == II_ADD || exp12[1].instruction == II_SUB) { // A+(B+C) expr = exp12[0] | exp12[1]; // combine expressions expr.tokens = numtokens; expr.reg1 = exp12[0].reg1; expr.etype |= XPR_OP; expr.instruction = II_ADD_ADD; if (exp12[0].etype & exp12[1].etype & (XPR_IMMEDIATE | XPR_MEM)) { // does not fit expr.etype |= XPR_ERROR; expr.value.w = ERR_TOO_COMPLEX; return expr; } if (exp12[0].etype & XPR_MEM) { // A = mem, B = register, C = immediate. Needs additional reordering expr.optionbits = ((exp12[1].optionbits & 1) ^ (op == '-')) // register into first place | (exp12[0].optionbits & 1) << 1 // memory in second place | ((exp12[1].optionbits >> 1 & 1) ^ (op == '-')) << 2; // immediate in third place if (exp12[1].instruction == II_SUB) expr.optionbits ^= 4; if (swapped && op == '-') expr.optionbits ^= 7; expr.reg1 = exp12[1].reg1; expr.etype |= XPR_OPTIONS; return expr; } if (exp12[1].etype & XPR_REG2) { // 3 registers expr.reg2 = exp12[1].reg1; expr.reg3 = exp12[1].reg2; expr.etype |= XPR_REG2 | XPR_REG3; } else if (exp12[1].etype & XPR_REG1) { // 2 registers expr.reg2 = exp12[1].reg1; expr.etype |= XPR_REG2; } expr.optionbits = (exp12[0].optionbits & 1) | 6 * ((exp12[1].optionbits & 1) ^ (op == '-')); if (exp12[1].instruction == II_SUB) expr.optionbits ^= 4; if (swapped && op == '-') expr.optionbits ^= 7; expr.etype |= XPR_OPTIONS; return expr; } } else if (!((exp12[0].etype | exp12[1].etype) & XPR_OP) && (op == '*' || (op == '/' && !swapped))) { // (+/- a) * (+/- b) expr = exp12[0] | exp12[1]; expr.etype |= XPR_OP; expr.tokens = numtokens; expr.optionbits = exp12[0].optionbits ^ exp12[1].optionbits; if (expr.optionbits & 1) { // change sign if ((exp12[1].etype & 0xF) == XPR_FLT) { expr.value.d = -exp12[1].value.d; expr.optionbits = 0; } else if ((exp12[1].etype & 0xF) == XPR_INT) { expr.value.i = -exp12[1].value.i; expr.optionbits = 0; } else if (/*(exp12[1].etype & XPR_REG) &&*/ op == '*' && expr.value.i == 0) { // change -a*b to -a*b + 0 expr.instruction = II_MUL_ADD; expr.optionbits = 0x3; expr.reg1 = exp12[0].reg1; if (exp12[1].etype & XPR_REG1) { expr.reg2 = exp12[1].reg1; expr.etype |= XPR_REG2; } expr.etype |= XPR_INT | XPR_OPTIONS; return expr; } else { expr.etype |= XPR_ERROR; expr.value.w = ERR_TOO_COMPLEX; return expr; } } expr.reg1 = exp12[0].reg1; if (exp12[1].etype & XPR_REG1) { expr.reg2 = exp12[1].reg1; expr.etype |= XPR_REG2; } expr.instruction = (op == '*') ? II_MUL : II_DIV; return expr; } else if (((exp12[0].etype & exp12[1].etype) & XPR_INT) && (op == '='+D2 || op == '!'+EQ) && exp12[0].value.i == exp12[1].value.i && ((exp12[0].etype | exp12[1].etype) & (XPR_REG1 | XPR_REG2)) == XPR_REG1 && (exp12[0].etype & exp12[1].etype & XPR_REG1) == 0) { // (r1 & const) == const gives test_bits_and expr = exp12[0] | exp12[1]; expr.etype |= XPR_OP | XPR_OPTIONS; expr.tokens = numtokens; expr.instruction = II_TEST_BITS_AND; if (op == '!'+EQ) expr.optionbits ^= 1; return expr; } else if (op == '&'+D2 || op == '|'+D2 || op == '^' || op == '^'+D2) { // possible combination of compare or test with extra boolean operand int swap = exp12[1].instruction != 0; expr = exp12[swap]; if (expr.instruction == II_COMPARE && exp12[1-swap].etype == (XPR_REG | XPR_REG1)) { // use fallback register as an extra boolean operand on compare instruction switch (op & 0xFF) { case '&': expr.optionbits |= 0x10; break; case '|': expr.optionbits |= 0x20; break; case '^': expr.optionbits |= 0x30; break; default: expr.etype |= XPR_ERROR; expr.value.u = ERR_TOO_COMPLEX; } expr.etype |= XPR_OP | XPR_OPTIONS | XPR_FALLBACK; expr.tokens = numtokens; expr.fallback = exp12[1-swap].reg1; return expr; } /*else if (expr.instruction >= II_TEST_BIT && expr.instruction <= II_TEST_BITS_OR && exp12[1-swap].etype == (XPR_REG | XPR_REG1)) { // Use fallback register as an extra boolean operand on bit test instructions // This does not work yet. test_bit cannot be expressed with high level operators switch (op & 0xFF) { case '&': expr.optionbits |= 0x01; break; case '|': expr.optionbits |= 0x02; break; case '^': expr.optionbits |= 0x03; break; default: expr.etype |= XPR_ERROR; expr.value.u = ERR_TOO_COMPLEX; } expr.etype |= XPR_OP | XPR_OPTIONS | XPR_FALLBACK; expr.tokens = numtokens; expr.fallback = exp12[1-swap].reg1; return expr; }*/ } } // not a complex expression if ((ex1.etype & (XPR_IMMEDIATE | XPR_MEM)) && !((ex1.reg1 & REG_V) || (ex2.etype & XPR_IMMEDIATE))){ // first operand is integer, float or memory. swap operands if not two vector registers or memory and immediate exp12[0] = ex2; exp12[1] = ex1; swapped = true; } else { exp12[0] = ex1; exp12[1] = ex2; } expr.etype |= (exp12[1].etype & XPR_REG1) << 1; // XPR_REG1 becomes XPR_REG2 // combine everything from the two operands expr = exp12[0] | exp12[1]; expr.etype |= XPR_OP; expr.tokens = numtokens; expr.reg1 = exp12[0].reg1; expr.reg2 = exp12[1].reg1; expr.etype |= (exp12[1].etype & XPR_REG1) << 1; if (expr.instruction) { expr.etype |= XPR_ERROR; expr.value.u = ERR_TOO_COMPLEX; return expr; } // 2-operand instruction switch (op) { case '+': expr.instruction = II_ADD; break; case '-': expr.instruction = swapped ? II_SUB_REV : II_SUB; break; case '*': expr.instruction = II_MUL; break; case '/': expr.instruction = swapped ? II_DIV_REV : II_DIV; break; case '%': if (swapped) {expr.etype |= XPR_ERROR; expr.value.u = ERR_WRONG_TYPE;} expr.instruction = II_REM; break; case '&': case '&'+D2: // boolean AND and bitwise AND have same implementation expr.instruction = II_AND; break; case '|': case '|'+D2: // boolean OR and bitwise OR have same implementation expr.instruction = II_OR; break; case '^': case '^'+D2: expr.instruction = II_XOR; break; case '<': expr.instruction = II_COMPARE; expr.optionbits = 2 ^ swapped; expr.etype |= XPR_OPTIONS; break; case '<' + EQ: // <= expr.instruction = II_COMPARE; expr.optionbits = 5 ^ swapped; expr.etype |= XPR_OPTIONS; break; case '>': expr.instruction = II_COMPARE; expr.optionbits = 4 ^ swapped; expr.etype |= XPR_OPTIONS; break; case '>' + EQ: // >= expr.instruction = II_COMPARE; expr.optionbits = 3 ^ swapped; expr.etype |= XPR_OPTIONS; break; case '='+D2: // == expr.instruction = II_COMPARE; expr.optionbits = 0; //expr.etype |= XPR_OPTIONS; break; case '!'+EQ: // != expr.instruction = II_COMPARE; expr.etype |= XPR_OPTIONS; expr.optionbits = 1; // compare for not equal if ((expr.reg1 & REG_V) && (dataType & TYP_FLOAT)) { expr.optionbits |= 8; // floating point not equal includes unordered } break; case '<' + D2: // << if (swapped) {expr.etype |= XPR_ERROR; expr.value.u = ERR_WRONG_TYPE;} expr.instruction = II_SHIFT_LEFT; break; case '>' + D2: // >> if (swapped) {expr.etype |= XPR_ERROR; expr.value.u = ERR_WRONG_TYPE;} expr.instruction = II_SHIFT_RIGHT_S; break; case '>' + D3: // >>> if (swapped) {expr.etype |= XPR_ERROR; expr.value.u = ERR_WRONG_TYPE;} expr.instruction = II_SHIFT_RIGHT_U; break; default: expr.etype |= XPR_ERROR; expr.value.u = ERR_WRONG_TYPE; } return expr; } // Interpret dyadic expression generating memory operand. // both expressions are inside [] or at least one contains components other than integer constants SExpression CAssembler::op2Memory(uint32_t op, SExpression & exp1, SExpression & exp2) { SExpression expr; // return value SExpression expt; // temporary value expr.tokens = exp1.tokens + exp2.tokens + 1; // total number of tokens uint64_t f; // temporary factor int32_t symi1 = 0, symi2 = 0; // symbol indexes if (!((exp1.etype|exp2.etype) & (XPR_IMMEDIATE|XPR_BASE|XPR_INDEX|XPR_OPTION|XPR_SYM1|XPR_SYM2|XPR_LIMIT|XPR_LENGTH|XPR_BROADC))) { // combination of only integer expressions inside [] // combine everything from the two operands expr = exp1 | exp2; expr.tokens = exp1.tokens + exp2.tokens + 1; expr.etype &= ~XPR_OP; expr.instruction = 0; // operator is resolved here switch (op) { case '+': // adding offsets expr.offset_mem = exp1.offset_mem + exp2.offset_mem; break; case '-': // expr.offset_mem = exp1.offset_mem - exp2.offset_mem; break; case '*': expr.offset_mem = exp1.offset_mem * exp2.offset_mem; break; case '/': if (exp2.offset_mem == 0) { expr.etype |= XPR_ERROR; expr.value.u = ERR_OVERFLOW; break; } expr.offset_mem = exp1.offset_mem / exp2.offset_mem; break; case '<' + D2: // << expr.offset_mem = exp1.offset_mem << exp2.offset_mem; break; case '>' + D2: // >> shift right signed expr.offset_mem = exp1.offset_mem >> exp2.offset_mem; // signed shift right break; case '>' + D3: // >>> unsigned shift right expr.offset_mem = uint32_t(exp1.offset_mem) >> uint32_t(exp2.offset_mem); // unsigned shift right break; default: // wrong operator expr.value.u = ERR_WRONG_TYPE; expr.etype |= XPR_ERROR; return expr; } return expr; } // not only integer expressions if ((exp2.etype & XPR_SYM1) && op == '-') { // subtracting two symbol addresses if (exp1.sym1) { exp2.sym2 = exp2.sym1; exp2.sym1 = 0; exp2.etype = (exp2.etype & ~XPR_SYM1) | XPR_SYM2; if (exp1.symscale1 == 0) exp1.symscale1 = 1; if (exp2.symscale1 == 0) exp2.symscale1 = 1; if (exp1.symscale1 != exp2.symscale1 || exp2.sym2 == 0) { exp1.value.u = ERR_CONFLICT_TYPE; // conflicting scale factors exp1.etype |= XPR_ERROR; return exp1; } } else if (exp1.sym3) { exp2.sym4 = exp2.sym3; exp2.sym3 = 0; exp2.etype = (exp2.etype & ~XPR_SYM1) | XPR_SYM2; if (exp1.symscale3 == 0) exp1.symscale3 = 1; if (exp2.symscale3 == 0) exp2.symscale3 = 1; if (exp1.symscale3 != exp2.symscale3 || exp2.sym4 == 0) { exp1.value.u = ERR_CONFLICT_TYPE; // conflicting scale factors exp1.etype |= XPR_ERROR; return exp1; } } else { exp1.value.u = ERR_CONFLICT_TYPE; // conflicting scale factors exp1.etype |= XPR_ERROR; return exp1; } } // error checks if (exp1.etype & exp2.etype & (XPR_SYM1 | XPR_SYM2 | XPR_SYMSCALE | XPR_INDEX | XPR_LIMIT | XPR_LENGTH | XPR_BROADC)) { exp1.value.u = ERR_MEM_COMPONENT_TWICE; // some component or option specified twice exp1.etype |= XPR_ERROR; return exp1; } if (((exp1.etype | exp2.etype) & (XPR_LIMIT | XPR_OFFSET)) == (XPR_LIMIT | XPR_OFFSET)) { exp1.value.u = ERR_LIMIT_AND_OFFSET; // cannot have both offset and limit exp1.etype |= XPR_ERROR; return exp1; } if ((exp2.etype & XPR_BASE) && ((exp1.etype & XPR_BASE) || op == '-')) { // adding two registers or subtracting a register. make the second an index register if (exp2.base == 31 && (exp1.etype & XPR_BASE) && !(exp2.etype & XPR_INDEX)) { // stack pointer cannot be index. make first register an index instead exp1.index = exp1.base; exp1.base = 0; exp1.etype = (exp1.etype & ~XPR_BASE) | XPR_INDEX; exp1.scale = 1; } else { exp2.index = exp2.base; exp2.base = 0; exp2.etype = (exp2.etype & ~XPR_BASE) | XPR_INDEX; exp2.scale = 1; } } // combine everything from the two operands expr = exp1 | exp2; expr.tokens = exp1.tokens + exp2.tokens + 1; expr.value.u = exp1.value.u + exp2.value.u; // add values, except for special cases below expr.offset_mem = exp1.offset_mem + exp2.offset_mem; // add offsets, except for special cases below expr.offset_jump = exp1.offset_jump + exp2.offset_jump; // add jump offsets expr.etype &= ~XPR_OP; expr.instruction = 0; // operator is resolved here switch (op) { case '+': // adding components. offsets have been added above /* Changed: immediate value outside [] cannot be converted to offset: if ((expr.etype & (XPR_REG | XPR_BASE | XPR_SYM1)) && (expr.etype & XPR_INT) && (expr.etype & XPR_MEM)) { // adding offset. convert value to offset expr.offset += expr.value.i; expr.value.i = 0; expr.etype = (expr.etype | XPR_OFFSET) & ~XPR_IMMEDIATE; } */ break; case ',': // combining components. components are combined below if (exp1.value.u && exp2.value.u) { expr.value.u = ERR_WRONG_TYPE; // cannot combine integer offsets with comma operator expr.etype |= XPR_ERROR; return expr; } if ((expr.etype & XPR_INDEX) && (expr.etype & (XPR_LENGTH | XPR_BROADC))) { // both index and broadcast if (expr.scale == -1) { if (expr.index != expr.length) { // scale = -1. index and length must be the same expr.value.u = ERR_NEG_INDEX_LENGTH; expr.etype |= XPR_ERROR; return expr; } } else { // cannot have index and length/broadcast expr.value.u = ERR_INDEX_AND_LENGTH; expr.etype |= XPR_ERROR; return expr; } } break; case '-': // subtract offsets or registers (symbol addresses subtracted above) /* Changed: immediate value outside [] cannot be converted to offset: if ((exp1.etype & (XPR_REG | XPR_BASE | XPR_SYM1)) && (exp2.etype & XPR_INT) && (expr.etype & XPR_MEM)) { // subtracting offset. convert value to offset expr.offset = exp1.offset - exp2.value.i; expr.value.i = 0; expr.etype = (expr.etype | XPR_OFFSET) & ~XPR_IMMEDIATE; } else */ { expr.offset_mem = exp1.offset_mem - exp2.offset_mem; expr.offset_jump = exp1.offset_jump - exp2.offset_jump; expr.value.u = exp1.value.u - exp2.value.u; } if (exp2.etype & XPR_INDEX) { // subtracting a register gives negative index expr.scale = - exp2.scale; } else if ((exp1.etype & XPR_SYM1) && (exp2.etype & XPR_SYM2)) { // subtracting two symbols. has been fixed above // check if symbols are in the same domain if (exp1.sym1) { symi1 = findSymbol(exp1.sym1); symi2 = findSymbol(exp2.sym2); } else if (exp1.sym3) { symi1 = findSymbol(exp1.sym3); symi2 = findSymbol(exp2.sym4); } if (symi1 > 0 && symi2 > 0 && (symbols[symi1].st_other & symbols[symi2].st_other & (SHF_IP | SHF_DATAP | SHF_THREADP)) == 0 && (symbols[symi1].st_type & symbols[symi2].st_type & STT_CONSTANT) == 0) { errors.reportLine(ERR_RELOCATION_DOMAIN); } } //else if ((expr.etype & XPR_IMMEDIATE) == XPR_INT) expr.etype |= XPR_OFFSET; // value is offset if (exp2.etype & (XPR_SYM1|XPR_SYMSCALE)) { expr.value.u = ERR_WRONG_TYPE; // cannot subtract these components expr.etype |= XPR_ERROR; return expr; } break; case '<'+D2: // index << s = index * (1 << s) //exp2.value.u = (uint64_t)1 << exp2.value.u; exp2.offset_mem = 1 << exp2.offset_mem; goto MULTIPLYINDEX; // continue in case '*' case '*': // indexregister * scale if ((exp1.etype & (XPR_INT|XPR_OFFSET)) && (exp2.etype & (XPR_BASE|XPR_INDEX))){ // first operand is integer, second operand is register. swap operands expt = exp2; exp2 = exp1; exp1 = expt; } MULTIPLYINDEX: if ((exp1.etype & XPR_BASE) && !(exp1.etype & XPR_INDEX)) { // convert base to index exp1.index = exp1.base; exp1.base = 0; exp1.scale = 1; exp1.etype = (exp1.etype & ~XPR_BASE) | XPR_INDEX; } if (exp2.etype & XPR_INT) { // convert integer to offset. should not occur exp2.offset_mem = exp2.value.w; exp2.value.i = 0; exp2.etype = (exp2.etype & ~XPR_INT) | XPR_OFFSET; } if (!(exp1.etype & XPR_INDEX) || !(exp2.etype & XPR_OFFSET) || ((exp1.etype | exp2.etype) & (XPR_OPTION|XPR_SYM1|XPR_SYM2|XPR_LIMIT|XPR_LENGTH|XPR_BROADC))) { expr.value.u = ERR_WRONG_TYPE; // cannot multiply anything else expr.etype |= XPR_ERROR; return expr; } f = int64_t(exp2.offset_mem) * exp1.scale; if ((f & (f - 1)) || f == 0 || f > 16) { // check that scale is a power of 2, not bigger than 16 expr.value.u = ERR_SCALE_FACTOR; // wrong scale factor expr.etype |= XPR_ERROR; return expr; } expr.base = exp1.base; expr.index = exp1.index; expr.scale = (int8_t)f; expr.etype = exp1.etype | (exp2.etype & ~(XPR_INT|XPR_OFFSET)); expr.value.u = 0; expr.offset_mem = exp1.offset_mem; break; case '>'+D2: // divide (sym1-sym2) >> s = (sym1-sym2) / (1 << s) exp2.value.u = (uint64_t)1 << exp2.value.u; exp2.offset_mem = (uint64_t)1 << exp2.offset_mem; // continue in case '/' case '/': // divide (sym1-sym2) / scale if ((exp2.etype & XPR_OFFSET) && !(exp2.etype & (XPR_REG | XPR_INT | XPR_BASE))) { // constant has been interpreted as offset because it is inside []. change it to XPR_INT exp2.value.i = exp2.offset_mem; exp2.offset_mem = 0; exp2.etype = (exp2.etype & ~(XPR_OFFSET)) | XPR_INT; expr.offset_mem = exp1.offset_mem; } if (!(exp1.etype & XPR_SYM1) || ((exp2.etype & 0xF) != XPR_INT) || ((exp1.etype | exp2.etype) & (XPR_REG|XPR_OPTION|XPR_LIMIT|XPR_LENGTH|XPR_BROADC))) { expr.value.u = ERR_WRONG_TYPE; // cannot divide anything else expr.etype |= XPR_ERROR; return expr; } f = exp2.value.u; if (exp1.symscale1) f *= exp1.symscale1; if ((f & (f - 1)) || f == 0 || f > 16) { // check that scale is a power of 2, not bigger than 16 expr.value.u = ERR_SCALE_FACTOR; // wrong scale factor expr.etype |= XPR_ERROR; return expr; } expr.symscale1 = (int8_t)f; expr.etype |= XPR_SYMSCALE; expr.etype = exp1.etype | (exp2.etype & ~XPR_INT); expr.value.u = exp1.value.u; break; case '=': // option = value // check if operands contain anything else if (!(exp1.etype & XPR_OPTION) || !(exp2.etype & (XPR_INT | XPR_BASE | XPR_REG)) || ((exp1.etype | exp2.etype) & (XPR_SYM1|XPR_SYM2|XPR_REG2|XPR_INDEX|XPR_LIMIT|XPR_LENGTH|XPR_BROADC))) { expr.value.u = ERR_WRONG_TYPE; // cannot uses '=' on anyting else inside [] expr.etype |= XPR_ERROR; return expr; } switch (exp1.value.w) { case OPT_LENGTH: // length = register if ((exp2.etype & XPR_REG1) && (exp2.reg1 & REG_R)) { // length = register, outside [] expr.etype = XPR_LENGTH | XPR_MEM; expr.length = exp2.reg1; expr.base = 0; expr.value.i = 0; break; } // length = register, inside [] if (!(exp2.etype & XPR_BASE) || (exp2.base & 0xE0) != REG_R) { expr.value.u = ERR_WRONG_TYPE; // cannot uses '=' on anyting else inside [] expr.etype |= XPR_ERROR; return expr; } expr.etype = XPR_LENGTH | XPR_MEM; expr.length = exp2.base; expr.base = 0; expr.value.i = 0; break; case OPT_BROADCAST: // broadcast = register if (!(exp2.etype & XPR_BASE) || (exp2.base & 0xE0) != REG_R) { expr.value.u = ERR_WRONG_TYPE; // cannot uses '=' on anyting else inside [] expr.etype |= XPR_ERROR; return expr; } expr.etype = XPR_BROADC | XPR_MEM; expr.length = exp2.base; expr.base = 0; expr.value.i = 0; break; case OPT_LIMIT: // limit = integer if (!(exp2.etype & XPR_INT)) { expr.value.u = ERR_WRONG_TYPE; // cannot uses '=' on anyting else inside [] expr.etype |= XPR_ERROR; return expr; } if (exp1.etype & XPR_OFFSET) { // cannot have both limit and offset expr.etype = ERR_LIMIT_AND_OFFSET; expr.etype |= XPR_ERROR; return expr; } expr.etype = XPR_LIMIT | XPR_MEM; expr.value.u = exp2.value.u; break; case OPT_SCALAR: // scalar expr.etype = XPR_SCALAR | XPR_MEM; expr.value.i = 0; break; case OPT_MASK: if (!(exp2.etype & (XPR_REG | XPR_REG1))) { expr.etype = ERR_MASK_NOT_REGISTER; expr.etype |= XPR_ERROR; return expr; } expr.etype = XPR_MASK; expr.mask = exp2.reg1; expr.reg1 = 0; break; case OPT_FALLBACK: if (exp2.etype == (XPR_REG | XPR_REG1) && (exp2.reg1 & 0x1F) != 0x1F) { expr.fallback = exp2.reg1; expr.etype = XPR_FALLBACK; expr.reg1 = 0; } else if ((exp2.etype & XPR_IMMEDIATE) && exp2.value.i == 0){ expr.fallback = (expr.mask & 0xF0) | 0x1F; expr.etype = XPR_FALLBACK; } else { expr.value.u = ERR_FALLBACK_WRONG; expr.etype |= XPR_ERROR; return expr; } break; case OPT_OPTIONS: if ((exp2.etype & 0xF) == XPR_INT) { expr.etype = (expr.etype & ~XPR_IMMEDIATE) | XPR_OPTIONS; expr.optionbits = (uint8_t)exp2.value.u; // move value to optionbits expr.value.i = 0; return expr; } else { expr.etype = ERR_WRONG_TYPE; expr.etype |= XPR_ERROR; return expr; } break; default: // mask and fallback options not allowed inside [] expr.value.u = ERR_NOT_INSIDE_MEM; // change error message expr.etype |= XPR_ERROR; return expr; } break; default: // wrong operator expr.value.u = ERR_WRONG_TYPE; expr.etype |= XPR_ERROR; return expr; } if ((expr.etype & XPR_INT) && !(expr.etype & (XPR_SYM1 | XPR_INDEX))) { // value not used otherwise is offset expr.etype = (expr.etype & ~(XPR_INT)) | XPR_OFFSET; } return expr; } // Interpreted triadic expression exp1 ? exp2 : exp3 at the indicated positions SExpression CAssembler::op3(uint32_t tok1, uint32_t toklow, uint32_t tokcolon, uint32_t maxtok, uint32_t options) { SExpression exp1, exp2; uint32_t cond; // evaluated condition exp1 = expression(tok1, toklow - tok1, options); // evaluate expression before '?' if (exp1.tokens != toklow - tok1) errors.report(tokens[tok1 + exp1.tokens]); if ((exp1.etype & XPR_REG) == 0 && (exp1.etype & (XPR_INT | XPR_FLT | XPR_STRING))) { // condition is a constant. just choose one of the two operands if ((exp1.etype & 0xF) == XPR_FLT) cond = exp1.value.d != 0.; // evaluate condition to true or false else if ((exp1.etype & 0xF) == XPR_STRING) { // string is false if empty or "0" cond = (exp1.sym2 != 0 && (exp1.sym2 > 1 || stringBuffer.get<uint16_t>((uint32_t)exp1.value.u) != '0')); } else cond = exp1.value.i != 0; // the expression that is not selected is evaluated with option = 0x10 to suppress errors but still count the tokens exp1 = expression(toklow + 1, tokcolon - (toklow + 1), options | (cond ^ 1) << 4); // evaluate first expression if (exp1.tokens != tokcolon - (toklow + 1)) errors.report(tokens[toklow + 1 + exp1.tokens]); exp2 = expression(tokcolon + 1, tok1 + maxtok - (tokcolon + 1), options | cond << 4); // evaluate second expression // number of tokens exp1.tokens = exp2.tokens = tokcolon - tok1 + 1 + exp2.tokens; // return the chosen expression if (cond) return exp1; else return exp2; } // condition is not a constant. It must be a mask register if ((exp1.etype & XPR_REG) == 0 || exp1.reg1 == 0 || exp1.etype & (XPR_OP|XPR_OPTION|XPR_MEM|XPR_SYM1|XPR_MASK|XPR_UNRESOLV)) { errors.report(tokens[tok1].pos, tokens[tok1].stringLength, ERR_MASK_NOT_REGISTER); } uint8_t maskreg = exp1.reg1; // save mask register // evaluate the middle expression exp1 = expression(toklow + 1, tokcolon - (toklow + 1), options); if (exp1.tokens != tokcolon - (toklow + 1)) errors.report(tokens[toklow + 1 + exp1.tokens]); // third expression must be fallback exp2 = expression(tokcolon + 1, tok1 + maxtok - (tokcolon + 1), options); uint8_t fallbackreg = 0; // fallback register if (exp2.etype & XPR_REG) { fallbackreg = exp2.reg1; exp1.etype |= XPR_FALLBACK; } else if ((exp2.etype & (XPR_INT | XPR_FLT)) && exp2.value.i == 0) { fallbackreg = maskreg | 0x1F; // register 31 with same type as mask register exp1.etype |= XPR_FALLBACK; } if (exp2.etype & (XPR_STRING | XPR_OP | XPR_OPTION | XPR_MEM | XPR_SYM1 | XPR_MASK) || exp2.value.i) { errors.report(tokens[tokcolon+1].pos, tokens[tokcolon+exp2.tokens+1].pos - tokens[tokcolon+1].pos, ERR_FALLBACK_WRONG); } // insert mask and fallback in exp1 exp1.etype |= XPR_MASK; exp1.mask = maskreg; exp1.fallback = fallbackreg; exp1.tokens = tokcolon - tok1 + 1 + exp2.tokens; return exp1; } // Convert -(expression), e.g. -(A-B) SExpression CAssembler::op1minus(SExpression & exp1) { exp1.tokens++; if ((exp1.etype & (XPR_REG | XPR_MEM)) && !(exp1.etype & XPR_OP) && exp1.value.i == 0) { // -reg or -mem exp1.etype |= XPR_OP | XPR_INT; exp1.instruction = II_SUB_REV; // 0 - expression } else if (exp1.instruction == II_SUB) exp1.instruction = II_SUB_REV; else if (exp1.instruction == II_SUB_REV) exp1.instruction = II_SUB; else if (exp1.instruction == II_ADD_ADD) exp1.optionbits ^= 3; else if (exp1.instruction == II_MUL_ADD || exp1.instruction == II_MUL_ADD2) exp1.optionbits ^= 0xF; else if (exp1.instruction == II_ADD && !(exp1.etype & (XPR_IMMEDIATE | XPR_MEM | XPR_SYM1))) { // -(R1+R2) = -R1 -R2 + 0 exp1.instruction = II_ADD_ADD; exp1.value.i = 0; exp1.optionbits = 3; exp1.etype |= XPR_INT; } else if (exp1.instruction == II_ADD && (exp1.etype & XPR_IMMEDIATE)) { // -(R1+I) = -R1 + (-I) exp1.instruction = II_SUB_REV; if ((exp1.etype & XPR_IMMEDIATE) == XPR_FLT) exp1.value.d = -exp1.value.d; else exp1.value.i = -exp1.value.i; } else if ((exp1.instruction == 0 || exp1.instruction == II_MUL || exp1.instruction == II_DIV || exp1.instruction == II_DIV_REV) && (exp1.etype & XPR_IMMEDIATE)) { // -I or -(A*I) if (exp1.etype & XPR_FLT) exp1.value.d = -exp1.value.d; else exp1.value.i = -exp1.value.i; } else if (exp1.instruction == II_MUL && !(exp1.etype & XPR_IMMEDIATE)) { exp1.instruction = II_MUL_ADD; exp1.optionbits ^= 3; exp1.etype |= XPR_INT; } else { exp1.etype = XPR_ERROR; exp1.value.u = ERR_TOO_COMPLEX; // cannot apply '-' to other expressions } return exp1; } // Interpret dyadic expression with string operands SExpression CAssembler::op2String(uint32_t op, SExpression const & exp1, SExpression const & exp2) { if (op != '+') { SExpression exp3; exp3.etype = XPR_ERROR; exp3.value.u = ERR_WRONG_TYPE; return exp3; } // operation is +. concatenate strings, convert numeric to string uint32_t stringpos1 = stringBuffer.dataSize(); // current position in string buffer uint32_t stringpos2; // position of second part of concatenated string const int maxIntLength = 32; // maximum length of integer as string const int maxFloatLength = 48; const char * wrongType = "-wrong type!-"; uint32_t len = 0; // length of string // first operand if (exp1.etype == XPR_STRING) { stringBuffer.push(stringBuffer.buf() + exp1.value.u, exp1.sym2); // copy to string buffer without terminating zero stringBuffer.put((char)0); //stringpos2 = stringBuffer.dataSize(); } else if (exp1.etype == XPR_INT) { // convert integer to string stringBuffer.push(&exp1, maxIntLength); // put in anyting here to make space for writing string if (sizeof(long int) >= 8) { #ifndef _WIN32 // suppress warning sprintf((char*)stringBuffer.buf()+stringpos1, "%li", exp1.value.i); #endif } else { sprintf((char*)stringBuffer.buf()+stringpos1, "%lli", (long long)exp1.value.i); } } else if (exp1.etype == XPR_FLT) { // convert float to string stringBuffer.push(&exp1, maxFloatLength); // put in anyting here to make space for writing string sprintf((char*)stringBuffer.buf()+stringpos1, "%g", exp1.value.d); } else { stringBuffer.put(wrongType); } len = (uint32_t)strlen((char*)stringBuffer.buf()+stringpos1); stringpos2 = stringpos1 + len; stringBuffer.setSize(stringpos2); // remove extra space // second operand if (exp2.etype == XPR_STRING) { stringBuffer.push(stringBuffer.buf() + exp2.value.u, exp2.sym2); // copy to string buffer without terminating zero stringBuffer.put((char)0); } else if (exp2.etype == XPR_INT) { // convert integer to string stringBuffer.push(&exp2, maxIntLength); // put in anyting here to make space for writing string if (sizeof(long int) >= 8) { #ifndef _WIN32 // suppress warning sprintf((char*)stringBuffer.buf()+stringpos2, "%li", exp2.value.i); #endif } else { sprintf((char*)stringBuffer.buf()+stringpos2, "%lli", (long long)exp2.value.i); } len = (uint32_t)strlen((char*)stringBuffer.buf()+stringpos2); stringBuffer.setSize(stringpos2 + len + 1); } else if (exp2.etype == XPR_FLT) { // convert float to string stringBuffer.push(&exp2, maxFloatLength); // put in anyting here to make space for writing string sprintf((char*)stringBuffer.buf()+stringpos2, "%g", exp2.value.d); len = (uint32_t)strlen((char*)stringBuffer.buf()+stringpos2); stringBuffer.setSize(stringpos2 + len + 1); } else { stringBuffer.put(wrongType); } SExpression exp3; exp3.etype = XPR_STRING; exp3.value.u = stringpos1; exp3.sym2 = (uint32_t)strlen((char*)stringBuffer.buf() + stringpos1); exp3.tokens = exp1.tokens + exp2.tokens + 1; return exp3; } double interpretFloat(const char * s, uint32_t length) { // interpret floating point number from string with indicated length char buffer[64]; if (length >= sizeof(buffer)) { union { uint64_t i; double d; } nan = {0xFFFFC00000000000}; return nan.d; // return NAN } memcpy(buffer, s, length); buffer[length] = 0; // terminate string double r; sscanf(buffer, "%lf", &r); // convert string to double return r; } // make expression out of symbol SExpression CAssembler::symbol2expression(uint32_t symi) { SExpression expr; zeroAllMembers(expr); switch (symbols[symi].st_type) { case STT_CONSTANT: case STT_VARIABLE: expr.etype = XPR_INT; // default type expr.sym1 = symi; if (symbols[symi].st_other & STV_FLOAT) expr.etype = XPR_FLT; if (symbols[symi].st_other & STV_STRING) { expr.etype = XPR_STRING; expr.sym2 = (uint32_t)symbols[symi].st_unitnum; } expr.value.u = symbols[symi].st_value; break; case STT_EXPRESSION: if (symbols[symi].st_value < expressions.numEntries()) { expr = expressions[uint32_t(symbols[symi].st_value)]; } else { expr.etype = XPR_ERROR; expr.value.u = TOK_XPR; } break; default: expr.etype = XPR_ERROR; expr.value.u = ERR_CONFLICT_TYPE; } expr.tokens = 0; return expr; }