| /* |
| * Android "Almost" C Compiler. |
| * This is a compiler for a small subset of the C language, intended for use |
| * in scripting environments where speed and memory footprint are important. |
| * |
| * This code is based upon the "unobfuscated" version of the |
| * Obfuscated Tiny C compiler, see the file LICENSE for details. |
| * |
| */ |
| |
| #define LOG_TAG "acc" |
| #include <cutils/log.h> |
| |
| #include <ctype.h> |
| #include <errno.h> |
| #include <limits.h> |
| #include <stdarg.h> |
| #include <stdint.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <unistd.h> |
| |
| #include <cutils/hashmap.h> |
| |
| #include <sys/mman.h> |
| |
| #if defined(MAP_ANON) && !defined(MAP_ANONYMOUS) |
| #define MAP_ANONYMOUS MAP_ANON |
| #endif |
| |
| #if defined(__arm__) |
| #define DEFAULT_ARM_CODEGEN |
| #define PROVIDE_ARM_CODEGEN |
| #elif defined(__i386__) |
| #define DEFAULT_X86_CODEGEN |
| #define PROVIDE_X86_CODEGEN |
| #elif defined(__x86_64__) |
| #define DEFAULT_X64_CODEGEN |
| #define PROVIDE_X64_CODEGEN |
| #endif |
| |
| #if (defined(__VFP_FP__) && !defined(__SOFTFP__)) |
| #define ARM_USE_VFP |
| #endif |
| |
| #include <acc/acc.h> |
| |
| #define LOG_API(...) do {} while(0) |
| // #define LOG_API(...) fprintf (stderr, __VA_ARGS__) |
| |
| #define LOG_STACK(...) do {} while(0) |
| // #define LOG_STACK(...) fprintf (stderr, __VA_ARGS__) |
| |
| // #define PROVIDE_TRACE_CODEGEN |
| |
| // Uncomment to disable ARM peephole optimizations |
| // #define DISABLE_ARM_PEEPHOLE |
| |
| // Uncomment to save input to a text file in DEBUG_DUMP_PATTERN |
| // #define DEBUG_SAVE_INPUT_TO_FILE |
| |
| #ifdef DEBUG_SAVE_INPUT_TO_FILE |
| #ifdef ARM_USE_VFP |
| #define DEBUG_DUMP_PATTERN "/data/misc/acc_dump/%d.c" |
| #else |
| #define DEBUG_DUMP_PATTERN "/tmp/acc_dump/%d.c" |
| #endif |
| #endif |
| |
| #define assert(b) assertImpl(b, __LINE__) |
| |
| namespace acc { |
| |
| // Subset of STL vector. |
| template<class E> class Vector { |
| public: |
| Vector() { |
| mpBase = 0; |
| mUsed = 0; |
| mSize = 0; |
| } |
| |
| ~Vector() { |
| if (mpBase) { |
| clear(); |
| free(mpBase); |
| } |
| } |
| |
| inline E& operator[](size_t i) { |
| return mpBase[i]; |
| } |
| |
| inline E& front() { |
| return mpBase[0]; |
| } |
| |
| inline E& back() { |
| return mpBase[mUsed - 1]; |
| } |
| |
| void pop_back() { |
| mUsed -= 1; |
| mpBase[mUsed].~E(); |
| } |
| |
| void push_back(const E& item) { |
| * ensure(1) = item; |
| } |
| |
| inline size_t size() { |
| return mUsed; |
| } |
| |
| void clear() { |
| if (mpBase) { |
| size_t used = mUsed; |
| for(size_t i = 0; i < used; i++) { |
| mpBase[i].~E(); |
| } |
| } |
| mUsed = 0; |
| } |
| |
| private: |
| E* ensure(int n) { |
| size_t newUsed = mUsed + n; |
| if (newUsed > mSize) { |
| size_t newSize = mSize * 2 + 10; |
| if (newSize < newUsed) { |
| newSize = newUsed; |
| } |
| mpBase = (E*) realloc(mpBase, sizeof(E) * newSize); |
| mSize = newSize; |
| } |
| E* result = mpBase + mUsed; |
| mUsed = newUsed; |
| return result; |
| } |
| |
| E* mpBase; |
| size_t mUsed; |
| size_t mSize; |
| }; |
| |
| class ErrorSink { |
| public: |
| void error(const char *fmt, ...) { |
| va_list ap; |
| va_start(ap, fmt); |
| verror(fmt, ap); |
| va_end(ap); |
| } |
| |
| virtual ~ErrorSink() {} |
| virtual void verror(const char* fmt, va_list ap) = 0; |
| }; |
| |
| class Compiler : public ErrorSink { |
| typedef int tokenid_t; |
| enum TypeTag { |
| TY_UNKNOWN = -1, |
| TY_INT, // 0 |
| TY_CHAR, // 1 |
| TY_SHORT, // 2 |
| TY_VOID, // 3 |
| TY_FLOAT, // 4 |
| TY_DOUBLE, // 5 |
| TY_POINTER, // 6 |
| TY_ARRAY, // 7 |
| TY_STRUCT, // 8 |
| TY_FUNC, // 9 |
| TY_PARAM // 10 |
| }; |
| |
| enum StorageClass { |
| SC_DEFAULT, // 0 |
| SC_AUTO, // 1 |
| SC_REGISTER, // 2 |
| SC_STATIC, // 3 |
| SC_EXTERN, // 4 |
| SC_TYPEDEF // 5 |
| }; |
| |
| struct Type { |
| TypeTag tag; |
| StorageClass storageClass; |
| tokenid_t id; // For function arguments, global vars, local vars, struct elements |
| tokenid_t structTag; // For structs the name of the struct |
| int length; // length of array, offset of struct element. -1 means struct is forward defined |
| int alignment; // for structs only |
| Type* pHead; // For a struct this is the prototype struct. |
| Type* pTail; |
| }; |
| |
| enum ExpressionType { |
| ET_RVALUE, |
| ET_LVALUE |
| }; |
| |
| struct ExpressionValue { |
| ExpressionValue() { |
| et = ET_RVALUE; |
| pType = NULL; |
| } |
| ExpressionType et; |
| Type* pType; |
| }; |
| |
| class ICodeBuf { |
| public: |
| virtual ~ICodeBuf() {} |
| virtual void init(int size) = 0; |
| virtual void setErrorSink(ErrorSink* pErrorSink) = 0; |
| virtual void o4(int n) = 0; |
| virtual void ob(int n) = 0; |
| virtual void* getBase() = 0; |
| virtual intptr_t getSize() = 0; |
| virtual intptr_t getPC() = 0; |
| // Call this before trying to modify code in the buffer. |
| virtual void flush() = 0; |
| }; |
| |
| class CodeBuf : public ICodeBuf { |
| char* ind; // Output code pointer |
| char* pProgramBase; |
| ErrorSink* mErrorSink; |
| int mSize; |
| bool mOverflowed; |
| |
| void release() { |
| if (pProgramBase != 0) { |
| munmap(pProgramBase, mSize); |
| pProgramBase = 0; |
| } |
| } |
| |
| bool check(int n) { |
| int newSize = ind - pProgramBase + n; |
| bool overflow = newSize > mSize; |
| if (overflow && !mOverflowed) { |
| mOverflowed = true; |
| if (mErrorSink) { |
| mErrorSink->error("Code too large: %d bytes", newSize); |
| } |
| } |
| return overflow; |
| } |
| |
| public: |
| CodeBuf() { |
| pProgramBase = 0; |
| ind = 0; |
| mErrorSink = 0; |
| mSize = 0; |
| mOverflowed = false; |
| } |
| |
| virtual ~CodeBuf() { |
| release(); |
| } |
| |
| virtual void init(int size) { |
| release(); |
| mSize = size; |
| pProgramBase = (char*) mmap(NULL, size, |
| PROT_EXEC | PROT_READ | PROT_WRITE, |
| MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); |
| ind = pProgramBase; |
| } |
| |
| virtual void setErrorSink(ErrorSink* pErrorSink) { |
| mErrorSink = pErrorSink; |
| } |
| |
| virtual void o4(int n) { |
| if(check(4)) { |
| return; |
| } |
| * (int*) ind = n; |
| ind += 4; |
| } |
| |
| /* |
| * Output a byte. Handles all values, 0..ff. |
| */ |
| virtual void ob(int n) { |
| if(check(1)) { |
| return; |
| } |
| *ind++ = n; |
| } |
| |
| virtual void* getBase() { |
| return (void*) pProgramBase; |
| } |
| |
| virtual intptr_t getSize() { |
| return ind - pProgramBase; |
| } |
| |
| virtual intptr_t getPC() { |
| return (intptr_t) ind; |
| } |
| |
| virtual void flush() {} |
| }; |
| |
| /** |
| * A code generator creates an in-memory program, generating the code on |
| * the fly. There is one code generator implementation for each supported |
| * architecture. |
| * |
| * The code generator implements the following abstract machine: |
| * R0 - the accumulator. |
| * FP - a frame pointer for accessing function arguments and local |
| * variables. |
| * SP - a stack pointer for storing intermediate results while evaluating |
| * expressions. The stack pointer grows downwards. |
| * |
| * The function calling convention is that all arguments are placed on the |
| * stack such that the first argument has the lowest address. |
| * After the call, the result is in R0. The caller is responsible for |
| * removing the arguments from the stack. |
| * The R0 register is not saved across function calls. The |
| * FP and SP registers are saved. |
| */ |
| |
| class CodeGenerator { |
| public: |
| CodeGenerator() { |
| mErrorSink = 0; |
| pCodeBuf = 0; |
| pushType(); |
| } |
| virtual ~CodeGenerator() {} |
| |
| virtual void init(ICodeBuf* pCodeBuf) { |
| this->pCodeBuf = pCodeBuf; |
| pCodeBuf->setErrorSink(mErrorSink); |
| } |
| |
| virtual void setErrorSink(ErrorSink* pErrorSink) { |
| mErrorSink = pErrorSink; |
| if (pCodeBuf) { |
| pCodeBuf->setErrorSink(mErrorSink); |
| } |
| } |
| |
| /* Give the code generator some utility types so it can |
| * use its own types as needed for the results of some |
| * operations like gcmp. |
| */ |
| |
| void setTypes(Type* pInt) { |
| mkpInt = pInt; |
| } |
| |
| /* Emit a function prolog. |
| * pDecl is the function declaration, which gives the arguments. |
| * Save the old value of the FP. |
| * Set the new value of the FP. |
| * Convert from the native platform calling convention to |
| * our stack-based calling convention. This may require |
| * pushing arguments from registers to the stack. |
| * Allocate "N" bytes of stack space. N isn't known yet, so |
| * just emit the instructions for adjusting the stack, and return |
| * the address to patch up. The patching will be done in |
| * functionExit(). |
| * returns address to patch with local variable size. |
| */ |
| virtual int functionEntry(Type* pDecl) = 0; |
| |
| /* Emit a function epilog. |
| * Restore the old SP and FP register values. |
| * Return to the calling function. |
| * argCount - the number of arguments to the function. |
| * localVariableAddress - returned from functionEntry() |
| * localVariableSize - the size in bytes of the local variables. |
| */ |
| virtual void functionExit(Type* pDecl, int localVariableAddress, |
| int localVariableSize) = 0; |
| |
| /* load immediate value to R0 */ |
| virtual void li(int i) = 0; |
| |
| /* Load floating point value from global address. */ |
| virtual void loadFloat(int address, Type* pType) = 0; |
| |
| /* Add the struct offset in bytes to R0, change the type to pType */ |
| virtual void addStructOffsetR0(int offset, Type* pType) = 0; |
| |
| /* Jump to a target, and return the address of the word that |
| * holds the target data, in case it needs to be fixed up later. |
| */ |
| virtual int gjmp(int t) = 0; |
| |
| /* Test R0 and jump to a target if the test succeeds. |
| * l = 0: je, l == 1: jne |
| * Return the address of the word that holds the targed data, in |
| * case it needs to be fixed up later. |
| */ |
| virtual int gtst(bool l, int t) = 0; |
| |
| /* Compare TOS against R0, and store the boolean result in R0. |
| * Pops TOS. |
| * op specifies the comparison. |
| */ |
| virtual void gcmp(int op) = 0; |
| |
| /* Perform the arithmetic op specified by op. TOS is the |
| * left argument, R0 is the right argument. |
| * Pops TOS. |
| */ |
| virtual void genOp(int op) = 0; |
| |
| /* Compare 0 against R0, and store the boolean result in R0. |
| * op specifies the comparison. |
| */ |
| virtual void gUnaryCmp(int op) = 0; |
| |
| /* Perform the arithmetic op specified by op. 0 is the |
| * left argument, R0 is the right argument. |
| */ |
| virtual void genUnaryOp(int op) = 0; |
| |
| /* Push R0 onto the stack. (Also known as "dup" for duplicate.) |
| */ |
| virtual void pushR0() = 0; |
| |
| /* Turn R0, TOS into R0 TOS R0 */ |
| |
| virtual void over() = 0; |
| |
| /* Pop R0 from the stack. (Also known as "drop") |
| */ |
| virtual void popR0() = 0; |
| |
| /* Store R0 to the address stored in TOS. |
| * The TOS is popped. |
| */ |
| virtual void storeR0ToTOS() = 0; |
| |
| /* Load R0 from the address stored in R0. |
| */ |
| virtual void loadR0FromR0() = 0; |
| |
| /* Load the absolute address of a variable to R0. |
| * If ea <= LOCAL, then this is a local variable, or an |
| * argument, addressed relative to FP. |
| * else it is an absolute global address. |
| * |
| * et is ET_RVALUE for things like string constants, ET_LVALUE for |
| * variables. |
| */ |
| virtual void leaR0(int ea, Type* pPointerType, ExpressionType et) = 0; |
| |
| /* Load the pc-relative address of a forward-referenced variable to R0. |
| * Return the address of the 4-byte constant so that it can be filled |
| * in later. |
| */ |
| virtual int leaForward(int ea, Type* pPointerType) = 0; |
| |
| /** |
| * Convert R0 to the given type. |
| */ |
| |
| void convertR0(Type* pType) { |
| convertR0Imp(pType, false); |
| } |
| |
| void castR0(Type* pType) { |
| convertR0Imp(pType, true); |
| } |
| |
| virtual void convertR0Imp(Type* pType, bool isCast) = 0; |
| |
| /* Emit code to adjust the stack for a function call. Return the |
| * label for the address of the instruction that adjusts the |
| * stack size. This will be passed as argument "a" to |
| * endFunctionCallArguments. |
| */ |
| virtual int beginFunctionCallArguments() = 0; |
| |
| /* Emit code to store R0 to the stack at byte offset l. |
| * Returns stack size of object (typically 4 or 8 bytes) |
| */ |
| virtual size_t storeR0ToArg(int l, Type* pArgType) = 0; |
| |
| /* Patch the function call preamble. |
| * a is the address returned from beginFunctionCallArguments |
| * l is the number of bytes the arguments took on the stack. |
| * Typically you would also emit code to convert the argument |
| * list into whatever the native function calling convention is. |
| * On ARM for example you would pop the first 5 arguments into |
| * R0..R4 |
| */ |
| virtual void endFunctionCallArguments(Type* pDecl, int a, int l) = 0; |
| |
| /* Emit a call to an unknown function. The argument "symbol" needs to |
| * be stored in the location where the address should go. It forms |
| * a chain. The address will be patched later. |
| * Return the address of the word that has to be patched. |
| */ |
| virtual int callForward(int symbol, Type* pFunc) = 0; |
| |
| /* Call a function pointer. L is the number of bytes the arguments |
| * take on the stack. The address of the function is stored at |
| * location SP + l. |
| */ |
| virtual void callIndirect(int l, Type* pFunc) = 0; |
| |
| /* Adjust SP after returning from a function call. l is the |
| * number of bytes of arguments stored on the stack. isIndirect |
| * is true if this was an indirect call. (In which case the |
| * address of the function is stored at location SP + l.) |
| */ |
| virtual void adjustStackAfterCall(Type* pDecl, int l, bool isIndirect) = 0; |
| |
| /* Generate a symbol at the current PC. t is the head of a |
| * linked list of addresses to patch. |
| */ |
| virtual void gsym(int t) = 0; |
| |
| /* Resolve a forward reference function at the current PC. |
| * t is the head of a |
| * linked list of addresses to patch. |
| * (Like gsym, but using absolute address, not PC relative address.) |
| */ |
| virtual void resolveForward(int t) = 0; |
| |
| /* |
| * Do any cleanup work required at the end of a compile. |
| * For example, an instruction cache might need to be |
| * invalidated. |
| * Return non-zero if there is an error. |
| */ |
| virtual int finishCompile() = 0; |
| |
| /** |
| * Adjust relative branches by this amount. |
| */ |
| virtual int jumpOffset() = 0; |
| |
| /** |
| * Memory alignment (in bytes) for this type of data |
| */ |
| virtual size_t alignmentOf(Type* type) = 0; |
| |
| /** |
| * Array element alignment (in bytes) for this type of data. |
| */ |
| virtual size_t sizeOf(Type* type) = 0; |
| |
| virtual Type* getR0Type() { |
| return mExpressionStack.back().pType; |
| } |
| |
| virtual ExpressionType getR0ExpressionType() { |
| return mExpressionStack.back().et; |
| } |
| |
| virtual void setR0ExpressionType(ExpressionType et) { |
| mExpressionStack.back().et = et; |
| } |
| |
| virtual size_t getExpressionStackDepth() { |
| return mExpressionStack.size(); |
| } |
| |
| virtual void forceR0RVal() { |
| if (getR0ExpressionType() == ET_LVALUE) { |
| loadR0FromR0(); |
| } |
| } |
| |
| protected: |
| /* |
| * Output a byte. Handles all values, 0..ff. |
| */ |
| void ob(int n) { |
| pCodeBuf->ob(n); |
| } |
| |
| void o4(int data) { |
| pCodeBuf->o4(data); |
| } |
| |
| intptr_t getBase() { |
| return (intptr_t) pCodeBuf->getBase(); |
| } |
| |
| intptr_t getPC() { |
| return pCodeBuf->getPC(); |
| } |
| |
| intptr_t getSize() { |
| return pCodeBuf->getSize(); |
| } |
| |
| void flush() { |
| pCodeBuf->flush(); |
| } |
| |
| void error(const char* fmt,...) { |
| va_list ap; |
| va_start(ap, fmt); |
| mErrorSink->verror(fmt, ap); |
| va_end(ap); |
| } |
| |
| void assertImpl(bool test, int line) { |
| if (!test) { |
| error("code generator assertion failed at line %s:%d.", __FILE__, line); |
| LOGD("code generator assertion failed at line %s:%d.", __FILE__, line); |
| * (char*) 0 = 0; |
| } |
| } |
| |
| void setR0Type(Type* pType) { |
| assert(pType != NULL); |
| mExpressionStack.back().pType = pType; |
| mExpressionStack.back().et = ET_RVALUE; |
| } |
| |
| void setR0Type(Type* pType, ExpressionType et) { |
| assert(pType != NULL); |
| mExpressionStack.back().pType = pType; |
| mExpressionStack.back().et = et; |
| } |
| |
| Type* getTOSType() { |
| return mExpressionStack[mExpressionStack.size()-2].pType; |
| } |
| |
| void pushType() { |
| if (mExpressionStack.size()) { |
| mExpressionStack.push_back(mExpressionStack.back()); |
| } else { |
| mExpressionStack.push_back(ExpressionValue()); |
| } |
| |
| } |
| |
| void overType() { |
| size_t size = mExpressionStack.size(); |
| if (size >= 2) { |
| mExpressionStack.push_back(mExpressionStack.back()); |
| mExpressionStack[size-1] = mExpressionStack[size-2]; |
| mExpressionStack[size-2] = mExpressionStack[size]; |
| } |
| } |
| |
| void popType() { |
| mExpressionStack.pop_back(); |
| } |
| |
| bool bitsSame(Type* pA, Type* pB) { |
| return collapseType(pA->tag) == collapseType(pB->tag); |
| } |
| |
| TypeTag collapseType(TypeTag tag) { |
| static const TypeTag collapsedTag[] = { |
| TY_INT, |
| TY_INT, |
| TY_INT, |
| TY_VOID, |
| TY_FLOAT, |
| TY_DOUBLE, |
| TY_INT, |
| TY_INT, |
| TY_VOID, |
| TY_VOID, |
| TY_VOID |
| }; |
| return collapsedTag[tag]; |
| } |
| |
| TypeTag collapseTypeR0() { |
| return collapseType(getR0Type()->tag); |
| } |
| |
| static bool isFloatType(Type* pType) { |
| return isFloatTag(pType->tag); |
| } |
| |
| static bool isFloatTag(TypeTag tag) { |
| return tag == TY_FLOAT || tag == TY_DOUBLE; |
| } |
| |
| static bool isPointerType(Type* pType) { |
| return isPointerTag(pType->tag); |
| } |
| |
| static bool isPointerTag(TypeTag tag) { |
| return tag == TY_POINTER || tag == TY_ARRAY; |
| } |
| |
| Type* getPointerArithmeticResultType(Type* a, Type* b) { |
| TypeTag aTag = a->tag; |
| TypeTag bTag = b->tag; |
| if (aTag == TY_POINTER) { |
| return a; |
| } |
| if (bTag == TY_POINTER) { |
| return b; |
| } |
| if (aTag == TY_ARRAY) { |
| return a->pTail; |
| } |
| if (bTag == TY_ARRAY) { |
| return b->pTail; |
| } |
| return NULL; |
| } |
| Type* mkpInt; |
| |
| private: |
| Vector<ExpressionValue> mExpressionStack; |
| ICodeBuf* pCodeBuf; |
| ErrorSink* mErrorSink; |
| }; |
| |
| #ifdef PROVIDE_ARM_CODEGEN |
| |
| static size_t rotateRight(size_t n, size_t rotate) { |
| return (n >> rotate) | (n << (32 - rotate)); |
| } |
| |
| static size_t rotateLeft(size_t n, size_t rotate) { |
| return (n << rotate) | (n >> (32 - rotate)); |
| } |
| |
| static bool encode12BitImmediate(size_t immediate, size_t* pResult) { |
| for(size_t i = 0; i < 16; i++) { |
| size_t rotate = i * 2; |
| size_t mask = rotateRight(0xff, rotate); |
| if ((immediate | mask) == mask) { |
| size_t bits8 = rotateLeft(immediate, rotate); |
| // assert(bits8 <= 0xff); |
| *pResult = (i << 8) | bits8; |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| static size_t decode12BitImmediate(size_t immediate) { |
| size_t data = immediate & 0xff; |
| size_t rotate = 2 * ((immediate >> 8) & 0xf); |
| return rotateRight(data, rotate); |
| } |
| |
| static bool isPowerOfTwo(size_t n) { |
| return (n != 0) & ((n & (n-1)) == 0); |
| } |
| |
| static size_t log2(size_t n) { |
| int result = 0; |
| while (n >>= 1) { |
| result++; |
| } |
| return result; |
| } |
| |
| class ARMCodeBuf : public ICodeBuf { |
| ICodeBuf* mpBase; |
| ErrorSink* mErrorSink; |
| |
| class CircularQueue { |
| static const int SIZE = 16; // Must be power of 2 |
| static const int MASK = SIZE-1; |
| unsigned int mBuf[SIZE]; |
| int mHead; |
| int mCount; |
| |
| public: |
| CircularQueue() { |
| mHead = 0; |
| mCount = 0; |
| } |
| |
| void pushBack(unsigned int data) { |
| mBuf[(mHead + mCount) & MASK] = data; |
| mCount += 1; |
| } |
| |
| unsigned int popFront() { |
| unsigned int result = mBuf[mHead]; |
| mHead = (mHead + 1) & MASK; |
| mCount -= 1; |
| return result; |
| } |
| |
| void popBack(int n) { |
| mCount -= n; |
| } |
| |
| inline int count() { |
| return mCount; |
| } |
| |
| bool empty() { |
| return mCount == 0; |
| } |
| |
| bool full() { |
| return mCount == SIZE; |
| } |
| |
| // The valid indexes are 1 - count() to 0 |
| unsigned int operator[](int i) { |
| return mBuf[(mHead + mCount + i) & MASK]; |
| } |
| }; |
| |
| CircularQueue mQ; |
| |
| void error(const char* fmt,...) { |
| va_list ap; |
| va_start(ap, fmt); |
| mErrorSink->verror(fmt, ap); |
| va_end(ap); |
| } |
| |
| void flush() { |
| while (!mQ.empty()) { |
| mpBase->o4(mQ.popFront()); |
| } |
| mpBase->flush(); |
| } |
| |
| public: |
| ARMCodeBuf(ICodeBuf* pBase) { |
| mpBase = pBase; |
| } |
| |
| virtual ~ARMCodeBuf() { |
| delete mpBase; |
| } |
| |
| void init(int size) { |
| mpBase->init(size); |
| } |
| |
| void setErrorSink(ErrorSink* pErrorSink) { |
| mErrorSink = pErrorSink; |
| mpBase->setErrorSink(pErrorSink); |
| } |
| |
| void o4(int n) { |
| if (mQ.full()) { |
| mpBase->o4(mQ.popFront()); |
| } |
| mQ.pushBack(n); |
| |
| #ifndef DISABLE_ARM_PEEPHOLE |
| // Peephole check |
| bool didPeep; |
| do { |
| static const unsigned int opMask = 0x01e00000; |
| static const unsigned int immediateMask = 0x00000fff; |
| static const unsigned int BMask = 0x00400000; |
| didPeep = false; |
| if (mQ.count() >= 4) { |
| |
| // Operand by a small constant |
| // push;mov #imm;pop;op ==> op #imm |
| |
| if (mQ[-4] == 0xe92d0001 && // stmfd r13!, {r0} |
| (mQ[-3] & ~immediateMask) == 0xe3a00000 && // mov r0, #X |
| mQ[-2] == 0xe8bd0002 && // ldmea r13!, {r1} |
| (mQ[-1] & ~opMask) == (0xe0810000 & ~opMask)) { // OP r0, r1, r0 |
| unsigned int movConst = mQ[-3]; |
| unsigned int op = mQ[-1]; |
| unsigned int combined = 0xe2000000 | (op & opMask) | (movConst & immediateMask); |
| // fprintf(stderr, "op %x movConst %x combined %x\n", op, movConst, combined); |
| if (! (combined == 0xe2800000 || combined == 0xe2400000)) { // add/sub #0 |
| mQ.popBack(4); |
| mQ.pushBack(combined); |
| didPeep = true; |
| } else { |
| mQ.popBack(4); |
| didPeep = true; |
| } |
| } |
| } |
| |
| // Load local variable |
| // sub r0,r11,#imm;ldr/ldrb r0,[r0] ==> ldr/ldrb r0, [r11,#-imm] |
| if (mQ.count() >= 2) { |
| if ((mQ[-2] & ~immediateMask) == 0xe24b0000) { // sub r0,r11,#imm |
| const unsigned int encodedImmediate = mQ[-2] & immediateMask; |
| const unsigned int ld = mQ[-1]; |
| if ((ld & ~BMask) == 0xe5900000) { // ldr{b} r0, [r0] |
| unsigned int combined = encodedImmediate | (0xE51B0000 | (ld & BMask)); // ldr r0, [r11, #-0] |
| mQ.popBack(2); |
| mQ.pushBack(combined); |
| didPeep = true; |
| } else if (ld == 0xedd07a00) { // ldcl p10, c7, [r0, #0x000] |
| unsigned int decodedImmediate = decode12BitImmediate(encodedImmediate); |
| if (decodedImmediate <= 1020 && ((decodedImmediate & 3) == 0)) { |
| unsigned int combined = (decodedImmediate >> 2) | 0xed5b7a00; // ldcl p10, c7, [r11, #-0] |
| mQ.popBack(2); |
| mQ.pushBack(combined); |
| didPeep = true; |
| } |
| } |
| } |
| } |
| |
| // Constant array lookup |
| |
| if (mQ.count() >= 6 && |
| mQ[-6] == 0xe92d0001 && // stmfd r13!, {r0} |
| (mQ[-5] & ~immediateMask)== 0xe3a00000 && // mov r0, #0x00000001 |
| mQ[-4] == 0xe8bd0002 && // ldmea r13!, {r1} |
| (mQ[-3] & ~immediateMask)== 0xe3a02000 && // mov r2, #0x00000004 |
| mQ[-2] == 0xe0000092 && // mul r0, r2, r0 |
| mQ[-1] == 0xe0810000) { // add r0, r1, r0 |
| unsigned int mov1 = mQ[-5]; |
| unsigned int mov2 = mQ[-3]; |
| unsigned int const1 = decode12BitImmediate(mov1); |
| unsigned int const2 = decode12BitImmediate(mov2); |
| unsigned int comboConst = const1 * const2; |
| size_t immediate = 0; |
| if (encode12BitImmediate(comboConst, &immediate)) { |
| mQ.popBack(6); |
| unsigned int add = immediate | 0xE2800000; // add r0, r0, #n |
| if (comboConst) { |
| mQ.pushBack(add); |
| } |
| didPeep = true; |
| } |
| } |
| |
| // Pointer arithmetic with a stride that is a power of two |
| |
| if (mQ.count() >= 3 && |
| (mQ[-3] & ~ immediateMask) == 0xe3a02000 && // mov r2, #stride |
| mQ[-2] == 0xe0000092 && // mul r0, r2, r0 |
| mQ[-1] == 0xe0810000) { // add r0, r1, r0 |
| int stride = decode12BitImmediate(mQ[-3]); |
| if (isPowerOfTwo(stride)) { |
| mQ.popBack(3); |
| unsigned int add = 0xe0810000 | (log2(stride) << 7); // add r0, r1, r0, LSL #log2(stride) |
| mQ.pushBack(add); |
| didPeep = true; |
| } |
| } |
| |
| } while (didPeep); |
| #endif |
| } |
| |
| void ob(int n) { |
| error("ob() not supported."); |
| } |
| |
| void* getBase() { |
| flush(); |
| return mpBase->getBase(); |
| } |
| |
| intptr_t getSize() { |
| flush(); |
| return mpBase->getSize(); |
| } |
| |
| intptr_t getPC() { |
| flush(); |
| return mpBase->getPC(); |
| } |
| }; |
| |
| class ARMCodeGenerator : public CodeGenerator { |
| public: |
| ARMCodeGenerator() { |
| #ifdef ARM_USE_VFP |
| // LOGD("Using ARM VFP hardware floating point."); |
| #else |
| // LOGD("Using ARM soft floating point."); |
| #endif |
| } |
| |
| virtual ~ARMCodeGenerator() {} |
| |
| /* returns address to patch with local variable size |
| */ |
| virtual int functionEntry(Type* pDecl) { |
| mStackUse = 0; |
| // sp -> arg4 arg5 ... |
| // Push our register-based arguments back on the stack |
| int regArgCount = calcRegArgCount(pDecl); |
| if (regArgCount > 0) { |
| mStackUse += regArgCount * 4; |
| o4(0xE92D0000 | ((1 << regArgCount) - 1)); // stmfd sp!, {} |
| } |
| // sp -> arg0 arg1 ... |
| o4(0xE92D4800); // stmfd sp!, {fp, lr} |
| mStackUse += 2 * 4; |
| // sp, fp -> oldfp, retadr, arg0 arg1 .... |
| o4(0xE1A0B00D); // mov fp, sp |
| LOG_STACK("functionEntry: %d\n", mStackUse); |
| int pc = getPC(); |
| o4(0xE24DD000); // sub sp, sp, # <local variables> |
| // We don't know how many local variables we are going to use, |
| // but we will round the allocation up to a multiple of |
| // STACK_ALIGNMENT, so it won't affect the stack alignment. |
| return pc; |
| } |
| |
| virtual void functionExit(Type* pDecl, int localVariableAddress, int localVariableSize) { |
| // Round local variable size up to a multiple of stack alignment |
| localVariableSize = ((localVariableSize + STACK_ALIGNMENT - 1) / |
| STACK_ALIGNMENT) * STACK_ALIGNMENT; |
| // Patch local variable allocation code: |
| if (localVariableSize < 0 || localVariableSize > 255) { |
| error("localVariables out of range: %d", localVariableSize); |
| } |
| *(char*) (localVariableAddress) = localVariableSize; |
| |
| #ifdef ARM_USE_VFP |
| { |
| Type* pReturnType = pDecl->pHead; |
| switch(pReturnType->tag) { |
| case TY_FLOAT: |
| o4(0xEE170A90); // fmrs r0, s15 |
| break; |
| case TY_DOUBLE: |
| o4(0xEC510B17); // fmrrd r0, r1, d7 |
| break; |
| default: |
| break; |
| } |
| } |
| #endif |
| |
| // sp -> locals .... fp -> oldfp, retadr, arg0, arg1, ... |
| o4(0xE1A0E00B); // mov lr, fp |
| o4(0xE59BB000); // ldr fp, [fp] |
| o4(0xE28ED004); // add sp, lr, #4 |
| // sp -> retadr, arg0, ... |
| o4(0xE8BD4000); // ldmfd sp!, {lr} |
| // sp -> arg0 .... |
| |
| // We store the PC into the lr so we can adjust the sp before |
| // returning. We need to pull off the registers we pushed |
| // earlier. We don't need to actually store them anywhere, |
| // just adjust the stack. |
| int regArgCount = calcRegArgCount(pDecl); |
| if (regArgCount) { |
| o4(0xE28DD000 | (regArgCount << 2)); // add sp, sp, #argCount << 2 |
| } |
| o4(0xE12FFF1E); // bx lr |
| } |
| |
| /* load immediate value */ |
| virtual void li(int t) { |
| liReg(t, 0); |
| setR0Type(mkpInt); |
| } |
| |
| virtual void loadFloat(int address, Type* pType) { |
| setR0Type(pType); |
| // Global, absolute address |
| o4(0xE59F0000); // ldr r0, .L1 |
| o4(0xEA000000); // b .L99 |
| o4(address); // .L1: .word ea |
| // .L99: |
| |
| switch (pType->tag) { |
| case TY_FLOAT: |
| #ifdef ARM_USE_VFP |
| o4(0xEDD07A00); // flds s15, [r0] |
| #else |
| o4(0xE5900000); // ldr r0, [r0] |
| #endif |
| break; |
| case TY_DOUBLE: |
| #ifdef ARM_USE_VFP |
| o4(0xED907B00); // fldd d7, [r0] |
| #else |
| o4(0xE1C000D0); // ldrd r0, [r0] |
| #endif |
| break; |
| default: |
| assert(false); |
| break; |
| } |
| } |
| |
| |
| virtual void addStructOffsetR0(int offset, Type* pType) { |
| if (offset) { |
| size_t immediate = 0; |
| if (encode12BitImmediate(offset, &immediate)) { |
| o4(0xE2800000 | immediate); // add r0, r0, #offset |
| } else { |
| error("structure offset out of range: %d", offset); |
| } |
| } |
| setR0Type(pType, ET_LVALUE); |
| } |
| |
| virtual int gjmp(int t) { |
| int pc = getPC(); |
| o4(0xEA000000 | encodeAddress(t)); // b .L33 |
| return pc; |
| } |
| |
| /* l = 0: je, l == 1: jne */ |
| virtual int gtst(bool l, int t) { |
| Type* pR0Type = getR0Type(); |
| TypeTag tagR0 = pR0Type->tag; |
| switch(tagR0) { |
| case TY_FLOAT: |
| #ifdef ARM_USE_VFP |
| o4(0xEEF57A40); // fcmpzs s15 |
| o4(0xEEF1FA10); // fmstat |
| #else |
| callRuntime((void*) runtime_is_non_zero_f); |
| o4(0xE3500000); // cmp r0,#0 |
| #endif |
| break; |
| case TY_DOUBLE: |
| #ifdef ARM_USE_VFP |
| o4(0xEEB57B40); // fcmpzd d7 |
| o4(0xEEF1FA10); // fmstat |
| #else |
| callRuntime((void*) runtime_is_non_zero_d); |
| o4(0xE3500000); // cmp r0,#0 |
| #endif |
| break; |
| default: |
| o4(0xE3500000); // cmp r0,#0 |
| break; |
| } |
| int branch = l ? 0x1A000000 : 0x0A000000; // bne : beq |
| int pc = getPC(); |
| o4(branch | encodeAddress(t)); |
| return pc; |
| } |
| |
| virtual void gcmp(int op) { |
| Type* pR0Type = getR0Type(); |
| Type* pTOSType = getTOSType(); |
| TypeTag tagR0 = collapseType(pR0Type->tag); |
| TypeTag tagTOS = collapseType(pTOSType->tag); |
| if (tagR0 == TY_INT && tagTOS == TY_INT) { |
| setupIntPtrArgs(); |
| o4(0xE1510000); // cmp r1, r1 |
| switch(op) { |
| case OP_EQUALS: |
| o4(0x03A00001); // moveq r0,#1 |
| o4(0x13A00000); // movne r0,#0 |
| break; |
| case OP_NOT_EQUALS: |
| o4(0x03A00000); // moveq r0,#0 |
| o4(0x13A00001); // movne r0,#1 |
| break; |
| case OP_LESS_EQUAL: |
| o4(0xD3A00001); // movle r0,#1 |
| o4(0xC3A00000); // movgt r0,#0 |
| break; |
| case OP_GREATER: |
| o4(0xD3A00000); // movle r0,#0 |
| o4(0xC3A00001); // movgt r0,#1 |
| break; |
| case OP_GREATER_EQUAL: |
| o4(0xA3A00001); // movge r0,#1 |
| o4(0xB3A00000); // movlt r0,#0 |
| break; |
| case OP_LESS: |
| o4(0xA3A00000); // movge r0,#0 |
| o4(0xB3A00001); // movlt r0,#1 |
| break; |
| default: |
| error("Unknown comparison op %d", op); |
| break; |
| } |
| } else if (tagR0 == TY_DOUBLE || tagTOS == TY_DOUBLE) { |
| setupDoubleArgs(); |
| #ifdef ARM_USE_VFP |
| o4(0xEEB46BC7); // fcmped d6, d7 |
| o4(0xEEF1FA10); // fmstat |
| switch(op) { |
| case OP_EQUALS: |
| o4(0x03A00001); // moveq r0,#1 |
| o4(0x13A00000); // movne r0,#0 |
| break; |
| case OP_NOT_EQUALS: |
| o4(0x03A00000); // moveq r0,#0 |
| o4(0x13A00001); // movne r0,#1 |
| break; |
| case OP_LESS_EQUAL: |
| o4(0xD3A00001); // movle r0,#1 |
| o4(0xC3A00000); // movgt r0,#0 |
| break; |
| case OP_GREATER: |
| o4(0xD3A00000); // movle r0,#0 |
| o4(0xC3A00001); // movgt r0,#1 |
| break; |
| case OP_GREATER_EQUAL: |
| o4(0xA3A00001); // movge r0,#1 |
| o4(0xB3A00000); // movlt r0,#0 |
| break; |
| case OP_LESS: |
| o4(0xA3A00000); // movge r0,#0 |
| o4(0xB3A00001); // movlt r0,#1 |
| break; |
| default: |
| error("Unknown comparison op %d", op); |
| break; |
| } |
| #else |
| switch(op) { |
| case OP_EQUALS: |
| callRuntime((void*) runtime_cmp_eq_dd); |
| break; |
| case OP_NOT_EQUALS: |
| callRuntime((void*) runtime_cmp_ne_dd); |
| break; |
| case OP_LESS_EQUAL: |
| callRuntime((void*) runtime_cmp_le_dd); |
| break; |
| case OP_GREATER: |
| callRuntime((void*) runtime_cmp_gt_dd); |
| break; |
| case OP_GREATER_EQUAL: |
| callRuntime((void*) runtime_cmp_ge_dd); |
| break; |
| case OP_LESS: |
| callRuntime((void*) runtime_cmp_lt_dd); |
| break; |
| default: |
| error("Unknown comparison op %d", op); |
| break; |
| } |
| #endif |
| } else { |
| setupFloatArgs(); |
| #ifdef ARM_USE_VFP |
| o4(0xEEB47AE7); // fcmpes s14, s15 |
| o4(0xEEF1FA10); // fmstat |
| switch(op) { |
| case OP_EQUALS: |
| o4(0x03A00001); // moveq r0,#1 |
| o4(0x13A00000); // movne r0,#0 |
| break; |
| case OP_NOT_EQUALS: |
| o4(0x03A00000); // moveq r0,#0 |
| o4(0x13A00001); // movne r0,#1 |
| break; |
| case OP_LESS_EQUAL: |
| o4(0xD3A00001); // movle r0,#1 |
| o4(0xC3A00000); // movgt r0,#0 |
| break; |
| case OP_GREATER: |
| o4(0xD3A00000); // movle r0,#0 |
| o4(0xC3A00001); // movgt r0,#1 |
| break; |
| case OP_GREATER_EQUAL: |
| o4(0xA3A00001); // movge r0,#1 |
| o4(0xB3A00000); // movlt r0,#0 |
| break; |
| case OP_LESS: |
| o4(0xA3A00000); // movge r0,#0 |
| o4(0xB3A00001); // movlt r0,#1 |
| break; |
| default: |
| error("Unknown comparison op %d", op); |
| break; |
| } |
| #else |
| switch(op) { |
| case OP_EQUALS: |
| callRuntime((void*) runtime_cmp_eq_ff); |
| break; |
| case OP_NOT_EQUALS: |
| callRuntime((void*) runtime_cmp_ne_ff); |
| break; |
| case OP_LESS_EQUAL: |
| callRuntime((void*) runtime_cmp_le_ff); |
| break; |
| case OP_GREATER: |
| callRuntime((void*) runtime_cmp_gt_ff); |
| break; |
| case OP_GREATER_EQUAL: |
| callRuntime((void*) runtime_cmp_ge_ff); |
| break; |
| case OP_LESS: |
| callRuntime((void*) runtime_cmp_lt_ff); |
| break; |
| default: |
| error("Unknown comparison op %d", op); |
| break; |
| } |
| #endif |
| } |
| setR0Type(mkpInt); |
| } |
| |
| virtual void genOp(int op) { |
| Type* pR0Type = getR0Type(); |
| Type* pTOSType = getTOSType(); |
| TypeTag tagR0 = pR0Type->tag; |
| TypeTag tagTOS = pTOSType->tag; |
| bool isFloatR0 = isFloatTag(tagR0); |
| bool isFloatTOS = isFloatTag(tagTOS); |
| if (!isFloatR0 && !isFloatTOS) { |
| setupIntPtrArgs(); |
| bool isPtrR0 = isPointerTag(tagR0); |
| bool isPtrTOS = isPointerTag(tagTOS); |
| if (isPtrR0 || isPtrTOS) { |
| if (isPtrR0 && isPtrTOS) { |
| if (op != OP_MINUS) { |
| error("Unsupported pointer-pointer operation %d.", op); |
| } |
| if (! typeEqual(pR0Type, pTOSType)) { |
| error("Incompatible pointer types for subtraction."); |
| } |
| o4(0xE0410000); // sub r0,r1,r0 |
| setR0Type(mkpInt); |
| int size = sizeOf(pR0Type->pHead); |
| if (size != 1) { |
| pushR0(); |
| li(size); |
| // TODO: Optimize for power-of-two. |
| genOp(OP_DIV); |
| } |
| } else { |
| if (! (op == OP_PLUS || (op == OP_MINUS && isPtrR0))) { |
| error("Unsupported pointer-scalar operation %d", op); |
| } |
| Type* pPtrType = getPointerArithmeticResultType( |
| pR0Type, pTOSType); |
| int size = sizeOf(pPtrType->pHead); |
| if (size != 1) { |
| // TODO: Optimize for power-of-two. |
| liReg(size, 2); |
| if (isPtrR0) { |
| o4(0x0E0010192); // mul r1,r2,r1 |
| } else { |
| o4(0x0E0000092); // mul r0,r2,r0 |
| } |
| } |
| switch(op) { |
| case OP_PLUS: |
| o4(0xE0810000); // add r0,r1,r0 |
| break; |
| case OP_MINUS: |
| o4(0xE0410000); // sub r0,r1,r0 |
| break; |
| } |
| setR0Type(pPtrType); |
| } |
| } else { |
| switch(op) { |
| case OP_MUL: |
| o4(0x0E0000091); // mul r0,r1,r0 |
| break; |
| case OP_DIV: |
| callRuntime((void*) runtime_DIV); |
| break; |
| case OP_MOD: |
| callRuntime((void*) runtime_MOD); |
| break; |
| case OP_PLUS: |
| o4(0xE0810000); // add r0,r1,r0 |
| break; |
| case OP_MINUS: |
| o4(0xE0410000); // sub r0,r1,r0 |
| break; |
| case OP_SHIFT_LEFT: |
| o4(0xE1A00011); // lsl r0,r1,r0 |
| break; |
| case OP_SHIFT_RIGHT: |
| o4(0xE1A00051); // asr r0,r1,r0 |
| break; |
| case OP_BIT_AND: |
| o4(0xE0010000); // and r0,r1,r0 |
| break; |
| case OP_BIT_XOR: |
| o4(0xE0210000); // eor r0,r1,r0 |
| break; |
| case OP_BIT_OR: |
| o4(0xE1810000); // orr r0,r1,r0 |
| break; |
| case OP_BIT_NOT: |
| o4(0xE1E00000); // mvn r0, r0 |
| break; |
| default: |
| error("Unimplemented op %d\n", op); |
| break; |
| } |
| } |
| } else { |
| Type* pResultType = tagR0 > tagTOS ? pR0Type : pTOSType; |
| if (pResultType->tag == TY_DOUBLE) { |
| setupDoubleArgs(); |
| |
| switch(op) { |
| case OP_MUL: |
| #ifdef ARM_USE_VFP |
| o4(0xEE267B07); // fmuld d7, d6, d7 |
| #else |
| callRuntime((void*) runtime_op_mul_dd); |
| #endif |
| break; |
| case OP_DIV: |
| #ifdef ARM_USE_VFP |
| o4(0xEE867B07); // fdivd d7, d6, d7 |
| #else |
| callRuntime((void*) runtime_op_div_dd); |
| #endif |
| break; |
| case OP_PLUS: |
| #ifdef ARM_USE_VFP |
| o4(0xEE367B07); // faddd d7, d6, d7 |
| #else |
| callRuntime((void*) runtime_op_add_dd); |
| #endif |
| break; |
| case OP_MINUS: |
| #ifdef ARM_USE_VFP |
| o4(0xEE367B47); // fsubd d7, d6, d7 |
| #else |
| callRuntime((void*) runtime_op_sub_dd); |
| #endif |
| break; |
| default: |
| error("Unsupported binary floating operation %d\n", op); |
| break; |
| } |
| } else { |
| setupFloatArgs(); |
| switch(op) { |
| case OP_MUL: |
| #ifdef ARM_USE_VFP |
| o4(0xEE677A27); // fmuls s15, s14, s15 |
| #else |
| callRuntime((void*) runtime_op_mul_ff); |
| #endif |
| break; |
| case OP_DIV: |
| #ifdef ARM_USE_VFP |
| o4(0xEEC77A27); // fdivs s15, s14, s15 |
| #else |
| callRuntime((void*) runtime_op_div_ff); |
| #endif |
| break; |
| case OP_PLUS: |
| #ifdef ARM_USE_VFP |
| o4(0xEE777A27); // fadds s15, s14, s15 |
| #else |
| callRuntime((void*) runtime_op_add_ff); |
| #endif |
| break; |
| case OP_MINUS: |
| #ifdef ARM_USE_VFP |
| o4(0xEE777A67); // fsubs s15, s14, s15 |
| #else |
| callRuntime((void*) runtime_op_sub_ff); |
| #endif |
| break; |
| default: |
| error("Unsupported binary floating operation %d\n", op); |
| break; |
| } |
| } |
| setR0Type(pResultType); |
| } |
| } |
| |
| virtual void gUnaryCmp(int op) { |
| if (op != OP_LOGICAL_NOT) { |
| error("Unknown unary cmp %d", op); |
| } else { |
| Type* pR0Type = getR0Type(); |
| TypeTag tag = collapseType(pR0Type->tag); |
| switch(tag) { |
| case TY_INT: |
| o4(0xE3A01000); // mov r1, #0 |
| o4(0xE1510000); // cmp r1, r0 |
| o4(0x03A00001); // moveq r0,#1 |
| o4(0x13A00000); // movne r0,#0 |
| break; |
| case TY_FLOAT: |
| #ifdef ARM_USE_VFP |
| o4(0xEEF57A40); // fcmpzs s15 |
| o4(0xEEF1FA10); // fmstat |
| o4(0x03A00001); // moveq r0,#1 |
| o4(0x13A00000); // movne r0,#0 |
| #else |
| callRuntime((void*) runtime_is_zero_f); |
| #endif |
| break; |
| case TY_DOUBLE: |
| #ifdef ARM_USE_VFP |
| o4(0xEEB57B40); // fcmpzd d7 |
| o4(0xEEF1FA10); // fmstat |
| o4(0x03A00001); // moveq r0,#1 |
| o4(0x13A00000); // movne r0,#0 |
| #else |
| callRuntime((void*) runtime_is_zero_d); |
| #endif |
| break; |
| default: |
| error("gUnaryCmp unsupported type"); |
| break; |
| } |
| } |
| setR0Type(mkpInt); |
| } |
| |
| virtual void genUnaryOp(int op) { |
| Type* pR0Type = getR0Type(); |
| TypeTag tag = collapseType(pR0Type->tag); |
| switch(tag) { |
| case TY_INT: |
| switch(op) { |
| case OP_MINUS: |
| o4(0xE3A01000); // mov r1, #0 |
| o4(0xE0410000); // sub r0,r1,r0 |
| break; |
| case OP_BIT_NOT: |
| o4(0xE1E00000); // mvn r0, r0 |
| break; |
| default: |
| error("Unknown unary op %d\n", op); |
| break; |
| } |
| break; |
| case TY_FLOAT: |
| case TY_DOUBLE: |
| switch (op) { |
| case OP_MINUS: |
| if (tag == TY_FLOAT) { |
| #ifdef ARM_USE_VFP |
| o4(0xEEF17A67); // fnegs s15, s15 |
| #else |
| callRuntime((void*) runtime_op_neg_f); |
| #endif |
| } else { |
| #ifdef ARM_USE_VFP |
| o4(0xEEB17B47); // fnegd d7, d7 |
| #else |
| callRuntime((void*) runtime_op_neg_d); |
| #endif |
| } |
| break; |
| case OP_BIT_NOT: |
| error("Can't apply '~' operator to a float or double."); |
| break; |
| default: |
| error("Unknown unary op %d\n", op); |
| break; |
| } |
| break; |
| default: |
| error("genUnaryOp unsupported type"); |
| break; |
| } |
| } |
| |
| virtual void pushR0() { |
| Type* pR0Type = getR0Type(); |
| TypeTag r0ct = collapseType(pR0Type->tag); |
| |
| #ifdef ARM_USE_VFP |
| switch (r0ct ) { |
| case TY_FLOAT: |
| o4(0xED6D7A01); // fstmfds sp!,{s15} |
| mStackUse += 4; |
| break; |
| case TY_DOUBLE: |
| o4(0xED2D7B02); // fstmfdd sp!,{d7} |
| mStackUse += 8; |
| break; |
| default: |
| o4(0xE92D0001); // stmfd sp!,{r0} |
| mStackUse += 4; |
| } |
| #else |
| |
| if (r0ct != TY_DOUBLE) { |
| o4(0xE92D0001); // stmfd sp!,{r0} |
| mStackUse += 4; |
| } else { |
| o4(0xE92D0003); // stmfd sp!,{r0,r1} |
| mStackUse += 8; |
| } |
| #endif |
| pushType(); |
| LOG_STACK("pushR0: %d\n", mStackUse); |
| } |
| |
| virtual void over() { |
| // We know it's only used for int-ptr ops (++/--) |
| |
| Type* pR0Type = getR0Type(); |
| TypeTag r0ct = collapseType(pR0Type->tag); |
| |
| Type* pTOSType = getTOSType(); |
| TypeTag tosct = collapseType(pTOSType->tag); |
| |
| assert (r0ct == TY_INT && tosct == TY_INT); |
| |
| o4(0xE8BD0002); // ldmfd sp!,{r1} |
| o4(0xE92D0001); // stmfd sp!,{r0} |
| o4(0xE92D0002); // stmfd sp!,{r1} |
| overType(); |
| mStackUse += 4; |
| } |
| |
| virtual void popR0() { |
| Type* pTOSType = getTOSType(); |
| TypeTag tosct = collapseType(pTOSType->tag); |
| #ifdef ARM_USE_VFP |
| if (tosct == TY_FLOAT || tosct == TY_DOUBLE) { |
| error("Unsupported popR0 float/double"); |
| } |
| #endif |
| switch (tosct){ |
| case TY_INT: |
| case TY_FLOAT: |
| o4(0xE8BD0001); // ldmfd sp!,{r0} |
| mStackUse -= 4; |
| break; |
| case TY_DOUBLE: |
| o4(0xE8BD0003); // ldmfd sp!,{r0, r1} // Restore R0 |
| mStackUse -= 8; |
| break; |
| default: |
| error("Can't pop this type."); |
| break; |
| } |
| popType(); |
| LOG_STACK("popR0: %d\n", mStackUse); |
| } |
| |
| virtual void storeR0ToTOS() { |
| Type* pPointerType = getTOSType(); |
| assert(pPointerType->tag == TY_POINTER); |
| Type* pDestType = pPointerType->pHead; |
| convertR0(pDestType); |
| o4(0xE8BD0004); // ldmfd sp!,{r2} |
| popType(); |
| mStackUse -= 4; |
| switch (pDestType->tag) { |
| case TY_POINTER: |
| case TY_INT: |
| o4(0xE5820000); // str r0, [r2] |
| break; |
| case TY_FLOAT: |
| #ifdef ARM_USE_VFP |
| o4(0xEDC27A00); // fsts s15, [r2, #0] |
| #else |
| o4(0xE5820000); // str r0, [r2] |
| #endif |
| break; |
| case TY_SHORT: |
| o4(0xE1C200B0); // strh r0, [r2] |
| break; |
| case TY_CHAR: |
| o4(0xE5C20000); // strb r0, [r2] |
| break; |
| case TY_DOUBLE: |
| #ifdef ARM_USE_VFP |
| o4(0xED827B00); // fstd d7, [r2, #0] |
| #else |
| o4(0xE1C200F0); // strd r0, [r2] |
| #endif |
| break; |
| case TY_STRUCT: |
| { |
| int size = sizeOf(pDestType); |
| if (size > 0) { |
| liReg(size, 1); |
| callRuntime((void*) runtime_structCopy); |
| } |
| } |
| break; |
| default: |
| error("storeR0ToTOS: unimplemented type %d", |
| pDestType->tag); |
| break; |
| } |
| setR0Type(pDestType); |
| } |
| |
| virtual void loadR0FromR0() { |
| Type* pPointerType = getR0Type(); |
| assert(pPointerType->tag == TY_POINTER); |
| Type* pNewType = pPointerType->pHead; |
| TypeTag tag = pNewType->tag; |
| switch (tag) { |
| case TY_POINTER: |
| case TY_INT: |
| o4(0xE5900000); // ldr r0, [r0] |
| break; |
| case TY_FLOAT: |
| #ifdef ARM_USE_VFP |
| o4(0xEDD07A00); // flds s15, [r0, #0] |
| #else |
| o4(0xE5900000); // ldr r0, [r0] |
| #endif |
| break; |
| case TY_SHORT: |
| o4(0xE1D000F0); // ldrsh r0, [r0] |
| break; |
| case TY_CHAR: |
| o4(0xE5D00000); // ldrb r0, [r0] |
| break; |
| case TY_DOUBLE: |
| #ifdef ARM_USE_VFP |
| o4(0xED907B00); // fldd d7, [r0, #0] |
| #else |
| o4(0xE1C000D0); // ldrd r0, [r0] |
| #endif |
| break; |
| case TY_ARRAY: |
| pNewType = pNewType->pTail; |
| break; |
| case TY_STRUCT: |
| break; |
| default: |
| error("loadR0FromR0: unimplemented type %d", tag); |
| break; |
| } |
| setR0Type(pNewType); |
| } |
| |
| virtual void leaR0(int ea, Type* pPointerType, ExpressionType et) { |
| if (ea > -LOCAL && ea < LOCAL) { |
| // Local, fp relative |
| |
| size_t immediate = 0; |
| bool inRange = false; |
| if (ea < 0) { |
| inRange = encode12BitImmediate(-ea, &immediate); |
| o4(0xE24B0000 | immediate); // sub r0, fp, #ea |
| } else { |
| inRange = encode12BitImmediate(ea, &immediate); |
| o4(0xE28B0000 | immediate); // add r0, fp, #ea |
| } |
| if (! inRange) { |
| error("Offset out of range: %08x", ea); |
| } |
| } else { |
| // Global, absolute. |
| o4(0xE59F0000); // ldr r0, .L1 |
| o4(0xEA000000); // b .L99 |
| o4(ea); // .L1: .word 0 |
| // .L99: |
| } |
| setR0Type(pPointerType, et); |
| } |
| |
| virtual int leaForward(int ea, Type* pPointerType) { |
| setR0Type(pPointerType); |
| int result = ea; |
| int pc = getPC(); |
| int offset = 0; |
| if (ea) { |
| offset = (pc - ea - 8) >> 2; |
| if ((offset & 0xffff) != offset) { |
| error("function forward reference out of bounds"); |
| } |
| } else { |
| offset = 0; |
| } |
| o4(0xE59F0000 | offset); // ldr r0, .L1 |
| |
| if (ea == 0) { |
| o4(0xEA000000); // b .L99 |
| result = getPC(); |
| o4(ea); // .L1: .word 0 |
| // .L99: |
| } |
| return result; |
| } |
| |
| virtual void convertR0Imp(Type* pType, bool isCast){ |
| Type* pR0Type = getR0Type(); |
| if (isPointerType(pType) && isPointerType(pR0Type)) { |
| Type* pA = pR0Type; |
| Type* pB = pType; |
| // Array decays to pointer |
| if (pA->tag == TY_ARRAY && pB->tag == TY_POINTER) { |
| pA = pA->pTail; |
| } |
| if (! (typeEqual(pA, pB) |
| || pB->pHead->tag == TY_VOID |
| || (pA->tag == TY_POINTER && pB->tag == TY_POINTER && isCast) |
| )) { |
| error("Incompatible pointer or array types"); |
| } |
| } else if (bitsSame(pType, pR0Type)) { |
| // do nothing special |
| } else { |
| TypeTag r0Tag = collapseType(pR0Type->tag); |
| TypeTag destTag = collapseType(pType->tag); |
| if (r0Tag == TY_INT) { |
| if (destTag == TY_FLOAT) { |
| #ifdef ARM_USE_VFP |
| o4(0xEE070A90); // fmsr s15, r0 |
| o4(0xEEF87AE7); // fsitos s15, s15 |
| |
| #else |
| callRuntime((void*) runtime_int_to_float); |
| #endif |
| } else { |
| assert(destTag == TY_DOUBLE); |
| #ifdef ARM_USE_VFP |
| o4(0xEE070A90); // fmsr s15, r0 |
| o4(0xEEB87BE7); // fsitod d7, s15 |
| |
| #else |
| callRuntime((void*) runtime_int_to_double); |
| #endif |
| } |
| } else if (r0Tag == TY_FLOAT) { |
| if (destTag == TY_INT) { |
| #ifdef ARM_USE_VFP |
| o4(0xEEFD7AE7); // ftosizs s15, s15 |
| o4(0xEE170A90); // fmrs r0, s15 |
| #else |
| callRuntime((void*) runtime_float_to_int); |
| #endif |
| } else { |
| assert(destTag == TY_DOUBLE); |
| #ifdef ARM_USE_VFP |
| o4(0xEEB77AE7); // fcvtds d7, s15 |
| #else |
| callRuntime((void*) runtime_float_to_double); |
| #endif |
| } |
| } else { |
| if (r0Tag == TY_DOUBLE) { |
| if (destTag == TY_INT) { |
| #ifdef ARM_USE_VFP |
| o4(0xEEFD7BC7); // ftosizd s15, d7 |
| o4(0xEE170A90); // fmrs r0, s15 |
| #else |
| callRuntime((void*) runtime_double_to_int); |
| #endif |
| } else { |
| if(destTag == TY_FLOAT) { |
| #ifdef ARM_USE_VFP |
| o4(0xEEF77BC7); // fcvtsd s15, d7 |
| #else |
| callRuntime((void*) runtime_double_to_float); |
| #endif |
| } else { |
| incompatibleTypes(pR0Type, pType); |
| } |
| } |
| } else { |
| incompatibleTypes(pR0Type, pType); |
| } |
| } |
| } |
| setR0Type(pType); |
| } |
| |
| virtual int beginFunctionCallArguments() { |
| int pc = getPC(); |
| o4(0xE24DDF00); // Placeholder sub sp, sp, #0 |
| return pc; |
| } |
| |
| virtual size_t storeR0ToArg(int l, Type* pArgType) { |
| convertR0(pArgType); |
| Type* pR0Type = getR0Type(); |
| TypeTag r0ct = collapseType(pR0Type->tag); |
| #ifdef ARM_USE_VFP |
| switch(r0ct) { |
| case TY_INT: |
| if (l < 0 || l > 4096-4) { |
| error("l out of range for stack offset: 0x%08x", l); |
| } |
| o4(0xE58D0000 | l); // str r0, [sp, #l] |
| return 4; |
| case TY_FLOAT: |
| if (l < 0 || l > 1020 || (l & 3)) { |
| error("l out of range for stack offset: 0x%08x", l); |
| } |
| o4(0xEDCD7A00 | (l >> 2)); // fsts s15, [sp, #l] |
| return 4; |
| case TY_DOUBLE: { |
| // Align to 8 byte boundary |
| int l2 = (l + 7) & ~7; |
| if (l2 < 0 || l2 > 1020 || (l2 & 3)) { |
| error("l out of range for stack offset: 0x%08x", l); |
| } |
| o4(0xED8D7B00 | (l2 >> 2)); // fstd d7, [sp, #l2] |
| return (l2 - l) + 8; |
| } |
| default: |
| assert(false); |
| return 0; |
| } |
| #else |
| switch(r0ct) { |
| case TY_INT: |
| case TY_FLOAT: |
| if (l < 0 || l > 4096-4) { |
| error("l out of range for stack offset: 0x%08x", l); |
| } |
| o4(0xE58D0000 + l); // str r0, [sp, #l] |
| return 4; |
| case TY_DOUBLE: { |
| // Align to 8 byte boundary |
| int l2 = (l + 7) & ~7; |
| if (l2 < 0 || l2 > 4096-8) { |
| error("l out of range for stack offset: 0x%08x", l); |
| } |
| o4(0xE58D0000 + l2); // str r0, [sp, #l] |
| o4(0xE58D1000 + l2 + 4); // str r1, [sp, #l+4] |
| return (l2 - l) + 8; |
| } |
| default: |
| assert(false); |
| return 0; |
| } |
| #endif |
| } |
| |
| virtual void endFunctionCallArguments(Type* pDecl, int a, int l) { |
| int argumentStackUse = l; |
| // Have to calculate register arg count from actual stack size, |
| // in order to properly handle ... functions. |
| int regArgCount = l >> 2; |
| if (regArgCount > 4) { |
| regArgCount = 4; |
| } |
| if (regArgCount > 0) { |
| argumentStackUse -= regArgCount * 4; |
| o4(0xE8BD0000 | ((1 << regArgCount) - 1)); // ldmfd sp!,{} |
| } |
| mStackUse += argumentStackUse; |
| |
| // Align stack. |
| int missalignment = mStackUse - ((mStackUse / STACK_ALIGNMENT) |
| * STACK_ALIGNMENT); |
| mStackAlignmentAdjustment = 0; |
| if (missalignment > 0) { |
| mStackAlignmentAdjustment = STACK_ALIGNMENT - missalignment; |
| } |
| l += mStackAlignmentAdjustment; |
| |
| if (l < 0 || l > 0x3FC) { |
| error("L out of range for stack adjustment: 0x%08x", l); |
| } |
| flush(); |
| * (int*) a = 0xE24DDF00 | (l >> 2); // sub sp, sp, #0 << 2 |
| mStackUse += mStackAlignmentAdjustment; |
| LOG_STACK("endFunctionCallArguments mStackUse: %d, mStackAlignmentAdjustment %d\n", |
| mStackUse, mStackAlignmentAdjustment); |
| } |
| |
| virtual int callForward(int symbol, Type* pFunc) { |
| setR0Type(pFunc->pHead); |
| // Forward calls are always short (local) |
| int pc = getPC(); |
| o4(0xEB000000 | encodeAddress(symbol)); |
| return pc; |
| } |
| |
| virtual void callIndirect(int l, Type* pFunc) { |
| assert(pFunc->tag == TY_FUNC); |
| popType(); // Get rid of indirect fn pointer type |
| int argCount = l >> 2; |
| int poppedArgs = argCount > 4 ? 4 : argCount; |
| int adjustedL = l - (poppedArgs << 2) + mStackAlignmentAdjustment; |
| if (adjustedL < 0 || adjustedL > 4096-4) { |
| error("l out of range for stack offset: 0x%08x", l); |
| } |
| o4(0xE59DC000 | (0xfff & adjustedL)); // ldr r12, [sp,#adjustedL] |
| o4(0xE12FFF3C); // blx r12 |
| Type* pReturnType = pFunc->pHead; |
| setR0Type(pReturnType); |
| #ifdef ARM_USE_VFP |
| switch(pReturnType->tag) { |
| case TY_FLOAT: |
| o4(0xEE070A90); // fmsr s15, r0 |
| break; |
| case TY_DOUBLE: |
| o4(0xEC410B17); // fmdrr d7, r0, r1 |
| break; |
| default: |
| break; |
| } |
| #endif |
| } |
| |
| virtual void adjustStackAfterCall(Type* pDecl, int l, bool isIndirect) { |
| int argCount = l >> 2; |
| // Have to calculate register arg count from actual stack size, |
| // in order to properly handle ... functions. |
| int regArgCount = l >> 2; |
| if (regArgCount > 4) { |
| regArgCount = 4; |
| } |
| int stackArgs = argCount - regArgCount; |
| int stackUse = stackArgs + (isIndirect ? 1 : 0) |
| + (mStackAlignmentAdjustment >> 2); |
| if (stackUse) { |
| if (stackUse < 0 || stackUse > 255) { |
| error("L out of range for stack adjustment: 0x%08x", l); |
| } |
| o4(0xE28DDF00 | stackUse); // add sp, sp, #stackUse << 2 |
| mStackUse -= stackUse * 4; |
| LOG_STACK("adjustStackAfterCall: %d\n", mStackUse); |
| } |
| } |
| |
| virtual int jumpOffset() { |
| return 8; |
| } |
| |
| /* output a symbol and patch all calls to it */ |
| virtual void gsym(int t) { |
| int n; |
| int base = getBase(); |
| int pc = getPC(); |
| while (t) { |
| int data = * (int*) t; |
| int decodedOffset = ((BRANCH_REL_ADDRESS_MASK & data) << 2); |
| if (decodedOffset == 0) { |
| n = 0; |
| } else { |
| n = base + decodedOffset; /* next value */ |
| } |
| *(int *) t = (data & ~BRANCH_REL_ADDRESS_MASK) |
| | encodeRelAddress(pc - t - 8); |
| t = n; |
| } |
| } |
| |
| /* output a symbol and patch all calls to it */ |
| virtual void resolveForward(int t) { |
| if (t) { |
| int pc = getPC(); |
| *(int *) t = pc; |
| } |
| } |
| |
| virtual int finishCompile() { |
| #if defined(__arm__) |
| const long base = long(getBase()); |
| const long curr = long(getPC()); |
| int err = cacheflush(base, curr, 0); |
| return err; |
| #else |
| return 0; |
| #endif |
| } |
| |
| /** |
| * alignment (in bytes) for this type of data |
| */ |
| virtual size_t alignmentOf(Type* pType){ |
| switch(pType->tag) { |
| case TY_CHAR: |
| return 1; |
| case TY_SHORT: |
| return 2; |
| case TY_DOUBLE: |
| return 8; |
| case TY_ARRAY: |
| return alignmentOf(pType->pHead); |
| case TY_STRUCT: |
| return pType->pHead->alignment & 0x7fffffff; |
| case TY_FUNC: |
| error("alignment of func not supported"); |
| return 1; |
| default: |
| return 4; |
| } |
| } |
| |
| /** |
| * Array element alignment (in bytes) for this type of data. |
| */ |
| virtual size_t sizeOf(Type* pType){ |
| switch(pType->tag) { |
| case TY_INT: |
| return 4; |
| case TY_SHORT: |
| return 2; |
| case TY_CHAR: |
| return 1; |
| case TY_FLOAT: |
| return 4; |
| case TY_DOUBLE: |
| return 8; |
| case TY_POINTER: |
| return 4; |
| case TY_ARRAY: |
| return pType->length * sizeOf(pType->pHead); |
| case TY_STRUCT: |
| return pType->pHead->length; |
| default: |
| error("Unsupported type %d", pType->tag); |
| return 0; |
| } |
| } |
| |
| private: |
| |
| static const int BRANCH_REL_ADDRESS_MASK = 0x00ffffff; |
| |
| /** Encode a relative address that might also be |
| * a label. |
| */ |
| int encodeAddress(int value) { |
| int base = getBase(); |
| if (value >= base && value <= getPC() ) { |
| // This is a label, encode it relative to the base. |
| value = value - base; |
| } |
| return encodeRelAddress(value); |
| } |
| |
| int encodeRelAddress(int value) { |
| return BRANCH_REL_ADDRESS_MASK & (value >> 2); |
| } |
| |
| int calcRegArgCount(Type* pDecl) { |
| int reg = 0; |
| Type* pArgs = pDecl->pTail; |
| while (pArgs && reg < 4) { |
| Type* pArg = pArgs->pHead; |
| if ( pArg->tag == TY_DOUBLE) { |
| int evenReg = (reg + 1) & ~1; |
| if (evenReg >= 4) { |
| break; |
| } |
| reg = evenReg + 2; |
| } else { |
| reg++; |
| } |
| pArgs = pArgs->pTail; |
| } |
| return reg; |
| } |
| |
| void setupIntPtrArgs() { |
| o4(0xE8BD0002); // ldmfd sp!,{r1} |
| mStackUse -= 4; |
| popType(); |
| } |
| |
| /* Pop TOS to R1 (use s14 if VFP) |
| * Make sure both R0 and TOS are floats. (Could be ints) |
| * We know that at least one of R0 and TOS is already a float |
| */ |
| void setupFloatArgs() { |
| Type* pR0Type = getR0Type(); |
| Type* pTOSType = getTOSType(); |
| TypeTag tagR0 = collapseType(pR0Type->tag); |
| TypeTag tagTOS = collapseType(pTOSType->tag); |
| if (tagR0 != TY_FLOAT) { |
| assert(tagR0 == TY_INT); |
| #ifdef ARM_USE_VFP |
| o4(0xEE070A90); // fmsr s15, r0 |
| o4(0xEEF87AE7); // fsitos s15, s15 |
| #else |
| callRuntime((void*) runtime_int_to_float); |
| #endif |
| } |
| if (tagTOS != TY_FLOAT) { |
| assert(tagTOS == TY_INT); |
| assert(tagR0 == TY_FLOAT); |
| #ifdef ARM_USE_VFP |
| o4(0xECBD7A01); // fldmfds sp!, {s14} |
| o4(0xEEB87AC7); // fsitos s14, s14 |
| #else |
| o4(0xE92D0001); // stmfd sp!,{r0} // push R0 |
| o4(0xE59D0004); // ldr r0, [sp, #4] |
| callRuntime((void*) runtime_int_to_float); |
| o4(0xE1A01000); // mov r1, r0 |
| o4(0xE8BD0001); // ldmfd sp!,{r0} // pop R0 |
| o4(0xE28DD004); // add sp, sp, #4 // Pop sp |
| #endif |
| } else { |
| // Pop TOS |
| #ifdef ARM_USE_VFP |
| o4(0xECBD7A01); // fldmfds sp!, {s14} |
| |
| #else |
| o4(0xE8BD0002); // ldmfd sp!,{r1} |
| #endif |
| } |
| mStackUse -= 4; |
| popType(); |
| } |
| |
| /* Pop TOS into R2..R3 (use D6 if VFP) |
| * Make sure both R0 and TOS are doubles. Could be floats or ints. |
| * We know that at least one of R0 and TOS are already a double. |
| */ |
| |
| void setupDoubleArgs() { |
| Type* pR0Type = getR0Type(); |
| Type* pTOSType = getTOSType(); |
| TypeTag tagR0 = collapseType(pR0Type->tag); |
| TypeTag tagTOS = collapseType(pTOSType->tag); |
| if (tagR0 != TY_DOUBLE) { |
| if (tagR0 == TY_INT) { |
| #ifdef ARM_USE_VFP |
| o4(0xEE070A90); // fmsr s15, r0 |
| o4(0xEEB87BE7); // fsitod d7, s15 |
| |
| #else |
| callRuntime((void*) runtime_int_to_double); |
| #endif |
| } else { |
| assert(tagR0 == TY_FLOAT); |
| #ifdef ARM_USE_VFP |
| o4(0xEEB77AE7); // fcvtds d7, s15 |
| #else |
| callRuntime((void*) runtime_float_to_double); |
| #endif |
| } |
| } |
| if (tagTOS != TY_DOUBLE) { |
| #ifdef ARM_USE_VFP |
| if (tagTOS == TY_INT) { |
| o4(0xECFD6A01); // fldmfds sp!,{s13} |
| o4(0xEEB86BE6); // fsitod d6, s13 |
| } else { |
| assert(tagTOS == TY_FLOAT); |
| o4(0xECFD6A01); // fldmfds sp!,{s13} |
| o4(0xEEB76AE6); // fcvtds d6, s13 |
| } |
| #else |
| o4(0xE92D0003); // stmfd sp!,{r0,r1} // push r0,r1 |
| o4(0xE59D0008); // ldr r0, [sp, #8] |
| if (tagTOS == TY_INT) { |
| callRuntime((void*) runtime_int_to_double); |
| } else { |
| assert(tagTOS == TY_FLOAT); |
| callRuntime((void*) runtime_float_to_double); |
| } |
| o4(0xE1A02000); // mov r2, r0 |
| o4(0xE1A03001); // mov r3, r1 |
| o4(0xE8BD0003); // ldmfd sp!,{r0, r1} // Restore R0 |
| o4(0xE28DD004); // add sp, sp, #4 // Pop sp |
| #endif |
| mStackUse -= 4; |
| } else { |
| #ifdef ARM_USE_VFP |
| o4(0xECBD6B02); // fldmfdd sp!, {d6} |
| #else |
| o4(0xE8BD000C); // ldmfd sp!,{r2,r3} |
| #endif |
| mStackUse -= 8; |
| } |
| popType(); |
| } |
| |
| void liReg(int t, int reg) { |
| assert(reg >= 0 && reg < 16); |
| int rN = (reg & 0xf) << 12; |
| size_t encodedImmediate; |
| if (encode12BitImmediate(t, &encodedImmediate)) { |
| o4(0xE3A00000 | encodedImmediate | rN); // mov rN, #0 |
| } else if (encode12BitImmediate(-(t+1), &encodedImmediate)) { |
| // mvn means move constant ^ ~0 |
| o4(0xE3E00000 | encodedImmediate | rN); // mvn rN, #0 |
| } else { |
| o4(0xE51F0000 | rN); // ldr rN, .L3 |
| o4(0xEA000000); // b .L99 |
| o4(t); // .L3: .word 0 |
| // .L99: |
| } |
| } |
| |
| void incompatibleTypes(Type* pR0Type, Type* pType) { |
| error("Incompatible types old: %d new: %d", pR0Type->tag, pType->tag); |
| } |
| |
| void callRuntime(void* fn) { |
| o4(0xE59FC000); // ldr r12, .L1 |
| o4(0xEA000000); // b .L99 |
| o4((int) fn); //.L1: .word fn |
| o4(0xE12FFF3C); //.L99: blx r12 |
| } |
| |
| // Integer math: |
| |
| static int runtime_DIV(int b, int a) { |
| return a / b; |
| } |
| |
| static int runtime_MOD(int b, int a) { |
| return a % b; |
| } |
| |
| static void runtime_structCopy(void* src, size_t size, void* dest) { |
| memcpy(dest, src, size); |
| } |
| |
| #ifndef ARM_USE_VFP |
| |
| // Comparison to zero |
| |
| static int runtime_is_non_zero_f(float a) { |
| return a != 0; |
| } |
| |
| static int runtime_is_non_zero_d(double a) { |
| return a != 0; |
| } |
| |
| // Comparison to zero |
| |
| static int runtime_is_zero_f(float a) { |
| return a == 0; |
| } |
| |
| static int runtime_is_zero_d(double a) { |
| return a == 0; |
| } |
| |
| // Type conversion |
| |
| static int runtime_float_to_int(float a) { |
| return (int) a; |
| } |
| |
| static double runtime_float_to_double(float a) { |
| return (double) a; |
| } |
| |
| static int runtime_double_to_int(double a) { |
| return (int) a; |
| } |
| |
| static float runtime_double_to_float(double a) { |
| return (float) a; |
| } |
| |
| static float runtime_int_to_float(int a) { |
| return (float) a; |
| } |
| |
| static double runtime_int_to_double(int a) { |
| return (double) a; |
| } |
| |
| // Comparisons float |
| |
| static int runtime_cmp_eq_ff(float b, float a) { |
| return a == b; |
| } |
| |
| static int runtime_cmp_ne_ff(float b, float a) { |
| return a != b; |
| } |
| |
| static int runtime_cmp_lt_ff(float b, float a) { |
| return a < b; |
| } |
| |
| static int runtime_cmp_le_ff(float b, float a) { |
| return a <= b; |
| } |
| |
| static int runtime_cmp_ge_ff(float b, float a) { |
| return a >= b; |
| } |
| |
| static int runtime_cmp_gt_ff(float b, float a) { |
| return a > b; |
| } |
| |
| // Comparisons double |
| |
| static int runtime_cmp_eq_dd(double b, double a) { |
| return a == b; |
| } |
| |
| static int runtime_cmp_ne_dd(double b, double a) { |
| return a != b; |
| } |
| |
| static int runtime_cmp_lt_dd(double b, double a) { |
| return a < b; |
| } |
| |
| static int runtime_cmp_le_dd(double b, double a) { |
| return a <= b; |
| } |
| |
| static int runtime_cmp_ge_dd(double b, double a) { |
| return a >= b; |
| } |
| |
| static int runtime_cmp_gt_dd(double b, double a) { |
| return a > b; |
| } |
| |
| // Math float |
| |
| static float runtime_op_add_ff(float b, float a) { |
| return a + b; |
| } |
| |
| static float runtime_op_sub_ff(float b, float a) { |
| return a - b; |
| } |
| |
| static float runtime_op_mul_ff(float b, float a) { |
| return a * b; |
| } |
| |
| static float runtime_op_div_ff(float b, float a) { |
| return a / b; |
| } |
| |
| static float runtime_op_neg_f(float a) { |
| return -a; |
| } |
| |
| // Math double |
| |
| static double runtime_op_add_dd(double b, double a) { |
| return a + b; |
| } |
| |
| static double runtime_op_sub_dd(double b, double a) { |
| return a - b; |
| } |
| |
| static double runtime_op_mul_dd(double b, double a) { |
| return a * b; |
| } |
| |
| static double runtime_op_div_dd(double b, double a) { |
| return a / b; |
| } |
| |
| static double runtime_op_neg_d(double a) { |
| return -a; |
| } |
| |
| #endif |
| |
| static const int STACK_ALIGNMENT = 8; |
| int mStackUse; |
| // This variable holds the amount we adjusted the stack in the most |
| // recent endFunctionCallArguments call. It's examined by the |
| // following adjustStackAfterCall call. |
| int mStackAlignmentAdjustment; |
| }; |
| |
| #endif // PROVIDE_ARM_CODEGEN |
| |
| #ifdef PROVIDE_X86_CODEGEN |
| |
| class X86CodeGenerator : public CodeGenerator { |
| public: |
| X86CodeGenerator() {} |
| virtual ~X86CodeGenerator() {} |
| |
| /* returns address to patch with local variable size |
| */ |
| virtual int functionEntry(Type* pDecl) { |
| o(0xe58955); /* push %ebp, mov %esp, %ebp */ |
| return oad(0xec81, 0); /* sub $xxx, %esp */ |
| } |
| |
| virtual void functionExit(Type* pDecl, int localVariableAddress, int localVariableSize) { |
| o(0xc3c9); /* leave, ret */ |
| *(int *) localVariableAddress = localVariableSize; /* save local variables */ |
| } |
| |
| /* load immediate value */ |
| virtual void li(int i) { |
| oad(0xb8, i); /* mov $xx, %eax */ |
| setR0Type(mkpInt); |
| } |
| |
| virtual void loadFloat(int address, Type* pType) { |
| setR0Type(pType); |
| switch (pType->tag) { |
| case TY_FLOAT: |
| oad(0x05D9, address); // flds |
| break; |
| case TY_DOUBLE: |
| oad(0x05DD, address); // fldl |
| break; |
| default: |
| assert(false); |
| break; |
| } |
| } |
| |
| virtual void addStructOffsetR0(int offset, Type* pType) { |
| if (offset) { |
| oad(0x05, offset); // addl offset, %eax |
| } |
| setR0Type(pType, ET_LVALUE); |
| } |
| |
| virtual int gjmp(int t) { |
| return psym(0xe9, t); |
| } |
| |
| /* l = 0: je, l == 1: jne */ |
| virtual int gtst(bool l, int t) { |
| Type* pR0Type = getR0Type(); |
| TypeTag tagR0 = pR0Type->tag; |
| bool isFloatR0 = isFloatTag(tagR0); |
| if (isFloatR0) { |
| o(0xeed9); // fldz |
| o(0xe9da); // fucompp |
| o(0xe0df); // fnstsw %ax |
| o(0x9e); // sahf |
| } else { |
| o(0xc085); // test %eax, %eax |
| } |
| // Use two output statements to generate one instruction. |
| o(0x0f); // je/jne xxx |
| return psym(0x84 + l, t); |
| } |
| |
| virtual void gcmp(int op) { |
| Type* pR0Type = getR0Type(); |
| Type* pTOSType = getTOSType(); |
| TypeTag tagR0 = pR0Type->tag; |
| TypeTag tagTOS = pTOSType->tag; |
| bool isFloatR0 = isFloatTag(tagR0); |
| bool isFloatTOS = isFloatTag(tagTOS); |
| if (!isFloatR0 && !isFloatTOS) { |
| int t = decodeOp(op); |
| o(0x59); /* pop %ecx */ |
| o(0xc139); /* cmp %eax,%ecx */ |
| li(0); |
| o(0x0f); /* setxx %al */ |
| o(t + 0x90); |
| o(0xc0); |
| popType(); |
| } else { |
| setupFloatOperands(); |
| switch (op) { |
| case OP_EQUALS: |
| o(0xe9da); // fucompp |
| o(0xe0df); // fnstsw %ax |
| o(0x9e); // sahf |
| o(0xc0940f); // sete %al |
| o(0xc29b0f); // setnp %dl |
| o(0xd021); // andl %edx, %eax |
| break; |
| case OP_NOT_EQUALS: |
| o(0xe9da); // fucompp |
| o(0xe0df); // fnstsw %ax |
| o(0x9e); // sahf |
| o(0xc0950f); // setne %al |
| o(0xc29a0f); // setp %dl |
| o(0xd009); // orl %edx, %eax |
| break; |
| case OP_GREATER_EQUAL: |
| o(0xe9da); // fucompp |
| o(0xe0df); // fnstsw %ax |
| o(0x05c4f6); // testb $5, %ah |
| o(0xc0940f); // sete %al |
| break; |
| case OP_LESS: |
| o(0xc9d9); // fxch %st(1) |
| o(0xe9da); // fucompp |
| o(0xe0df); // fnstsw %ax |
| o(0x9e); // sahf |
| o(0xc0970f); // seta %al |
| break; |
| case OP_LESS_EQUAL: |
| o(0xc9d9); // fxch %st(1) |
| o(0xe9da); // fucompp |
| o(0xe0df); // fnstsw %ax |
| o(0x9e); // sahf |
| o(0xc0930f); // setea %al |
| break; |
| case OP_GREATER: |
| o(0xe9da); // fucompp |
| o(0xe0df); // fnstsw %ax |
| o(0x45c4f6); // testb $69, %ah |
| o(0xc0940f); // sete %al |
| break; |
| default: |
| error("Unknown comparison op"); |
| } |
| o(0xc0b60f); // movzbl %al, %eax |
| } |
| setR0Type(mkpInt); |
| } |
| |
| virtual void genOp(int op) { |
| Type* pR0Type = getR0Type(); |
| Type* pTOSType = getTOSType(); |
| TypeTag tagR0 = pR0Type->tag; |
| TypeTag tagTOS = pTOSType->tag; |
| bool isFloatR0 = isFloatTag(tagR0); |
| bool isFloatTOS = isFloatTag(tagTOS); |
| if (!isFloatR0 && !isFloatTOS) { |
| bool isPtrR0 = isPointerTag(tagR0); |
| bool isPtrTOS = isPointerTag(tagTOS); |
| if (isPtrR0 || isPtrTOS) { |
| if (isPtrR0 && isPtrTOS) { |
| if (op != OP_MINUS) { |
| error("Unsupported pointer-pointer operation %d.", op); |
| } |
| if (! typeEqual(pR0Type, pTOSType)) { |
| error("Incompatible pointer types for subtraction."); |
| } |
| o(0x59); /* pop %ecx */ |
| o(decodeOp(op)); |
| popType(); |
| setR0Type(mkpInt); |
| int size = sizeOf(pR0Type->pHead); |
| if (size != 1) { |
| pushR0(); |
| li(size); |
| // TODO: Optimize for power-of-two. |
| genOp(OP_DIV); |
| } |
| } else { |
| if (! (op == OP_PLUS || (op == OP_MINUS && isPtrR0))) { |
| error("Unsupported pointer-scalar operation %d", op); |
| } |
| Type* pPtrType = getPointerArithmeticResultType( |
| pR0Type, pTOSType); |
| o(0x59); /* pop %ecx */ |
| int size = sizeOf(pPtrType->pHead); |
| if (size != 1) { |
| // TODO: Optimize for power-of-two. |
| if (isPtrR0) { |
| oad(0xC969, size); // imull $size, %ecx |
| } else { |
| oad(0xC069, size); // mul $size, %eax |
| } |
| } |
| o(decodeOp(op)); |
| popType(); |
| setR0Type(pPtrType); |
| } |
| } else { |
| o(0x59); /* pop %ecx */ |
| o(decodeOp(op)); |
| if (op == OP_MOD) |
| o(0x92); /* xchg %edx, %eax */ |
| popType(); |
| } |
| } else { |
| Type* pResultType = tagR0 > tagTOS ? pR0Type : pTOSType; |
| setupFloatOperands(); |
| // Both float. x87 R0 == left hand, x87 R1 == right hand |
| switch (op) { |
| case OP_MUL: |
| o(0xc9de); // fmulp |
| break; |
| case OP_DIV: |
| o(0xf1de); // fdivp |
| break; |
| case OP_PLUS: |
| o(0xc1de); // faddp |
| break; |
| case OP_MINUS: |
| o(0xe1de); // fsubp |
| break; |
| default: |
| error("Unsupported binary floating operation."); |
| break; |
| } |
| setR0Type(pResultType); |
| } |
| } |
| |
| virtual void gUnaryCmp(int op) { |
| if (op != OP_LOGICAL_NOT) { |
| error("Unknown unary cmp %d", op); |
| } else { |
| Type* pR0Type = getR0Type(); |
| TypeTag tag = collapseType(pR0Type->tag); |
| switch(tag) { |
| case TY_INT: { |
| oad(0xb9, 0); /* movl $0, %ecx */ |
| int t = decodeOp(op); |
| o(0xc139); /* cmp %eax,%ecx */ |
| li(0); |
| o(0x0f); /* setxx %al */ |
| o(t + 0x90); |
| o(0xc0); |
| } |
| break; |
| case TY_FLOAT: |
| case TY_DOUBLE: |
| o(0xeed9); // fldz |
| o(0xe9da); // fucompp |
| o(0xe0df); // fnstsw %ax |
| o(0x9e); // sahf |
| o(0xc0950f); // setne %al |
| o(0xc29a0f); // setp %dl |
| o(0xd009); // orl %edx, %eax |
| o(0xc0b60f); // movzbl %al, %eax |
| o(0x01f083); // xorl $1, %eax |
| break; |
| default: |
| error("gUnaryCmp unsupported type"); |
| break; |
| } |
| } |
| setR0Type(mkpInt); |
| } |
| |
| virtual void genUnaryOp(int op) { |
| Type* pR0Type = getR0Type(); |
| TypeTag tag = collapseType(pR0Type->tag); |
| switch(tag) { |
| case TY_INT: |
| oad(0xb9, 0); /* movl $0, %ecx */ |
| o(decodeOp(op)); |
| break; |
| case TY_FLOAT: |
| case TY_DOUBLE: |
| switch (op) { |
| case OP_MINUS: |
| o(0xe0d9); // fchs |
| break; |
| case OP_BIT_NOT: |
| error("Can't apply '~' operator to a float or double."); |
| break; |
| default: |
| error("Unknown unary op %d\n", op); |
| break; |
| } |
| break; |
| default: |
| error("genUnaryOp unsupported type"); |
| break; |
| } |
| } |
| |
| virtual void pushR0() { |
| Type* pR0Type = getR0Type(); |
| TypeTag r0ct = collapseType(pR0Type->tag); |
| switch(r0ct) { |
| case TY_INT: |
| o(0x50); /* push %eax */ |
| break; |
| case TY_FLOAT: |
| o(0x50); /* push %eax */ |
| o(0x241cd9); // fstps 0(%esp) |
| break; |
| case TY_DOUBLE: |
| o(0x50); /* push %eax */ |
| o(0x50); /* push %eax */ |
| o(0x241cdd); // fstpl 0(%esp) |
| break; |
| default: |
| error("pushR0 unsupported type %d", r0ct); |
| break; |
| } |
| pushType(); |
| } |
| |
| virtual void over() { |
| // We know it's only used for int-ptr ops (++/--) |
| |
| Type* pR0Type = getR0Type(); |
| TypeTag r0ct = collapseType(pR0Type->tag); |
| |
| Type* pTOSType = getTOSType(); |
| TypeTag tosct = collapseType(pTOSType->tag); |
| |
| assert (r0ct == TY_INT && tosct == TY_INT); |
| |
| o(0x59); /* pop %ecx */ |
| o(0x50); /* push %eax */ |
| o(0x51); /* push %ecx */ |
| |
| overType(); |
| } |
| |
| virtual void popR0() { |
| Type* pR0Type = getR0Type(); |
| TypeTag r0ct = collapseType(pR0Type->tag); |
| switch(r0ct) { |
| case TY_INT: |
| o(0x58); /* popl %eax */ |
| break; |
| case TY_FLOAT: |
| o(0x2404d9); // flds (%esp) |
| o(0x58); /* popl %eax */ |
| break; |
| case TY_DOUBLE: |
| o(0x2404dd); // fldl (%esp) |
| o(0x58); /* popl %eax */ |
| o(0x58); /* popl %eax */ |
| break; |
| default: |
| error("popR0 unsupported type %d", r0ct); |
| break; |
| } |
| popType(); |
| } |
| |
| virtual void storeR0ToTOS() { |
| Type* pPointerType = getTOSType(); |
| assert(pPointerType->tag == TY_POINTER); |
| Type* pTargetType = pPointerType->pHead; |
| convertR0(pTargetType); |
| o(0x59); /* pop %ecx */ |
| popType(); |
| switch (pTargetType->tag) { |
| case TY_POINTER: |
| case TY_INT: |
| o(0x0189); /* movl %eax/%al, (%ecx) */ |
| break; |
| case TY_SHORT: |
| o(0x018966); /* movw %ax, (%ecx) */ |
| break; |
| case TY_CHAR: |
| o(0x0188); /* movl %eax/%al, (%ecx) */ |
| break; |
| case TY_FLOAT: |
| o(0x19d9); /* fstps (%ecx) */ |
| break; |
| case TY_DOUBLE: |
| o(0x19dd); /* fstpl (%ecx) */ |
| break; |
| case TY_STRUCT: |
| { |
| // TODO: use alignment information to use movsw/movsl instead of movsb |
| int size = sizeOf(pTargetType); |
| if (size > 0) { |
| o(0x9c); // pushf |
| o(0x57); // pushl %edi |
| o(0x56); // pushl %esi |
| o(0xcf89); // movl %ecx, %edi |
| o(0xc689); // movl %eax, %esi |
| oad(0xb9, size); // mov #size, %ecx |
| o(0xfc); // cld |
| o(0xf3); // rep |
| o(0xa4); // movsb |
| o(0x5e); // popl %esi |
| o(0x5f); // popl %edi |
| o(0x9d); // popf |
| } |
| } |
| break; |
| default: |
| error("storeR0ToTOS: unsupported type %d", |
| pTargetType->tag); |
| break; |
| } |
| setR0Type(pTargetType); |
| } |
| |
| virtual void loadR0FromR0() { |
| Type* pPointerType = getR0Type(); |
| assert(pPointerType->tag == TY_POINTER); |
| Type* pNewType = pPointerType->pHead; |
| TypeTag tag = pNewType->tag; |
| switch (tag) { |
| case TY_POINTER: |
| case TY_INT: |
| o2(0x008b); /* mov (%eax), %eax */ |
| break; |
| case TY_SHORT: |
| o(0xbf0f); /* movswl (%eax), %eax */ |
| ob(0); |
| break; |
| case TY_CHAR: |
| o(0xbe0f); /* movsbl (%eax), %eax */ |
| ob(0); /* add zero in code */ |
| break; |
| case TY_FLOAT: |
| o2(0x00d9); // flds (%eax) |
| break; |
| case TY_DOUBLE: |
| o2(0x00dd); // fldl (%eax) |
| break; |
| case TY_ARRAY: |
| pNewType = pNewType->pTail; |
| break; |
| case TY_STRUCT: |
| break; |
| default: |
| error("loadR0FromR0: unsupported type %d", tag); |
| break; |
| } |
| setR0Type(pNewType); |
| } |
| |
| virtual void leaR0(int ea, Type* pPointerType, ExpressionType et) { |
| gmov(10, ea); /* leal EA, %eax */ |
| setR0Type(pPointerType, et); |
| } |
| |
| virtual int leaForward(int ea, Type* pPointerType) { |
| oad(0xb8, ea); /* mov $xx, %eax */ |
| setR0Type(pPointerType); |
| return getPC() - 4; |
| } |
| |
| virtual void convertR0Imp(Type* pType, bool isCast){ |
| Type* pR0Type = getR0Type(); |
| if (pR0Type == NULL) { |
| assert(false); |
| setR0Type(pType); |
| return; |
| } |
| if (isPointerType(pType) && isPointerType(pR0Type)) { |
| Type* pA = pR0Type; |
| Type* pB = pType; |
| // Array decays to pointer |
| if (pA->tag == TY_ARRAY && pB->tag == TY_POINTER) { |
| pA = pA->pTail; |
| } |
| if (! (typeEqual(pA, pB) |
| || pB->pHead->tag == TY_VOID |
| || (pA->tag == TY_POINTER && pB->tag == TY_POINTER && isCast) |
| )) { |
| error("Incompatible pointer or array types"); |
| } |
| } else if (bitsSame(pType, pR0Type)) { |
| // do nothing special |
| } else if (isFloatType(pType) && isFloatType(pR0Type)) { |
| // do nothing special, both held in same register on x87. |
| } else { |
| TypeTag r0Tag = collapseType(pR0Type->tag); |
| TypeTag destTag = collapseType(pType->tag); |
| if (r0Tag == TY_INT && isFloatTag(destTag)) { |
| // Convert R0 from int to float |
| o(0x50); // push %eax |
| o(0x2404DB); // fildl 0(%esp) |
| o(0x58); // pop %eax |
| } else if (isFloatTag(r0Tag) && destTag == TY_INT) { |
| // Convert R0 from float to int. Complicated because |
| // need to save and restore the rounding mode. |
| o(0x50); // push %eax |
| o(0x50); // push %eax |
| o(0x02247cD9); // fnstcw 2(%esp) |
| o(0x2444b70f); // movzwl 2(%esp), %eax |
| o(0x02); |
| o(0x0cb4); // movb $12, %ah |
| o(0x24048966); // movw %ax, 0(%esp) |
| o(0x242cd9); // fldcw 0(%esp) |
| o(0x04245cdb); // fistpl 4(%esp) |
| o(0x02246cd9); // fldcw 2(%esp) |
| o(0x58); // pop %eax |
| o(0x58); // pop %eax |
| } else { |
| error("Incompatible types old: %d new: %d", |
| pR0Type->tag, pType->tag); |
| } |
| } |
| setR0Type(pType); |
| } |
| |
| virtual int beginFunctionCallArguments() { |
| return oad(0xec81, 0); /* sub $xxx, %esp */ |
| } |
| |
| virtual size_t storeR0ToArg(int l, Type* pArgType) { |
| convertR0(pArgType); |
| Type* pR0Type = getR0Type(); |
| TypeTag r0ct = collapseType(pR0Type->tag); |
| switch(r0ct) { |
| case TY_INT: |
| oad(0x248489, l); /* movl %eax, xxx(%esp) */ |
| return 4; |
| case TY_FLOAT: |
| oad(0x249CD9, l); /* fstps xxx(%esp) */ |
| return 4; |
| case TY_DOUBLE: |
| oad(0x249CDD, l); /* fstpl xxx(%esp) */ |
| return 8; |
| default: |
| assert(false); |
| return 0; |
| } |
| } |
| |
| virtual void endFunctionCallArguments(Type* pDecl, int a, int l) { |
| * (int*) a = l; |
| } |
| |
| virtual int callForward(int symbol, Type* pFunc) { |
| assert(pFunc->tag == TY_FUNC); |
| setR0Type(pFunc->pHead); |
| return psym(0xe8, symbol); /* call xxx */ |
| } |
| |
| virtual void callIndirect(int l, Type* pFunc) { |
| assert(pFunc->tag == TY_FUNC); |
| popType(); // Get rid of indirect fn pointer type |
| setR0Type(pFunc->pHead); |
| oad(0x2494ff, l); /* call *xxx(%esp) */ |
| } |
| |
| virtual void adjustStackAfterCall(Type* pDecl, int l, bool isIndirect) { |
| assert(pDecl->tag == TY_FUNC); |
| if (isIndirect) { |
| l += 4; |
| } |
| if (l > 0) { |
| oad(0xc481, l); /* add $xxx, %esp */ |
| } |
| } |
| |
| virtual int jumpOffset() { |
| return 5; |
| } |
| |
| /* output a symbol and patch all calls to it */ |
| virtual void gsym(int t) { |
| int n; |
| int pc = getPC(); |
| while (t) { |
| n = *(int *) t; /* next value */ |
| *(int *) t = pc - t - 4; |
| t = n; |
| } |
| } |
| |
| /* output a symbol and patch all calls to it, using absolute address */ |
| virtual void resolveForward(int t) { |
| int n; |
| int pc = getPC(); |
| while (t) { |
| n = *(int *) t; /* next value */ |
| *(int *) t = pc; |
| t = n; |
| } |
| } |
| |
| virtual int finishCompile() { |
| size_t pagesize = 4096; |
| size_t base = (size_t) getBase() & ~ (pagesize - 1); |
| size_t top = ((size_t) getPC() + pagesize - 1) & ~ (pagesize - 1); |
| int err = mprotect((void*) base, top - base, PROT_READ | PROT_WRITE | PROT_EXEC); |
| if (err) { |
| error("mprotect() failed: %d", errno); |
| } |
| return err; |
| } |
| |
| /** |
| * Alignment (in bytes) for this type of data |
| */ |
| virtual size_t alignmentOf(Type* pType){ |
| switch (pType->tag) { |
| case TY_CHAR: |
| return 1; |
| case TY_SHORT: |
| return 2; |
| case TY_ARRAY: |
| return alignmentOf(pType->pHead); |
| case TY_STRUCT: |
| return pType->pHead->alignment & 0x7fffffff; |
| case TY_FUNC: |
| error("alignment of func not supported"); |
| return 1; |
| default: |
| return 4; |
| } |
| } |
| |
| /** |
| * Array element alignment (in bytes) for this type of data. |
| */ |
| virtual size_t sizeOf(Type* pType){ |
| switch(pType->tag) { |
| case TY_INT: |
| return 4; |
| case TY_SHORT: |
| return 2; |
| case TY_CHAR: |
| return 1; |
| case TY_FLOAT: |
| return 4; |
| case TY_DOUBLE: |
| return 8; |
| case TY_POINTER: |
| return 4; |
| case TY_ARRAY: |
| return pType->length * sizeOf(pType->pHead); |
| case TY_STRUCT: |
| return pType->pHead->length; |
| default: |
| error("Unsupported type %d", pType->tag); |
| return 0; |
| } |
| } |
| |
| private: |
| |
| /** Output 1 to 4 bytes. |
| * |
| */ |
| void o(int n) { |
| /* cannot use unsigned, so we must do a hack */ |
| while (n && n != -1) { |
| ob(n & 0xff); |
| n = n >> 8; |
| } |
| } |
| |
| /* Output exactly 2 bytes |
| */ |
| void o2(int n) { |
| ob(n & 0xff); |
| ob(0xff & (n >> 8)); |
| } |
| |
| /* psym is used to put an instruction with a data field which is a |
| reference to a symbol. It is in fact the same as oad ! */ |
| int psym(int n, int t) { |
| return oad(n, t); |
| } |
| |
| /* instruction + address */ |
| int oad(int n, int t) { |
| o(n); |
| int result = getPC(); |
| o4(t); |
| return result; |
| } |
| |
| static const int operatorHelper[]; |
| |
| int decodeOp(int op) { |
| if (op < 0 || op > OP_COUNT) { |
| error("Out-of-range operator: %d\n", op); |
| op = 0; |
| } |
| return operatorHelper[op]; |
| } |
| |
| void gmov(int l, int t) { |
| o(l + 0x83); |
| oad((t > -LOCAL && t < LOCAL) << 7 | 5, t); |
| } |
| |
| void setupFloatOperands() { |
| Type* pR0Type = getR0Type(); |
| Type* pTOSType = getTOSType(); |
| TypeTag tagR0 = pR0Type->tag; |
| TypeTag tagTOS = pTOSType->tag; |
| bool isFloatR0 = isFloatTag(tagR0); |
| bool isFloatTOS = isFloatTag(tagTOS); |
| if (! isFloatR0) { |
| // Convert R0 from int to float |
| o(0x50); // push %eax |
| o(0x2404DB); // fildl 0(%esp) |
| o(0x58); // pop %eax |
| } |
| if (! isFloatTOS){ |
| o(0x2404DB); // fildl 0(%esp); |
| o(0x58); // pop %eax |
| } else { |
| if (tagTOS == TY_FLOAT) { |
| o(0x2404d9); // flds (%esp) |
| o(0x58); // pop %eax |
| } else { |
| o(0x2404dd); // fldl (%esp) |
| o(0x58); // pop %eax |
| o(0x58); // pop %eax |
| } |
| } |
| popType(); |
| } |
| }; |
| |
| #endif // PROVIDE_X86_CODEGEN |
| |
| #ifdef PROVIDE_TRACE_CODEGEN |
| class TraceCodeGenerator : public CodeGenerator { |
| private: |
| CodeGenerator* mpBase; |
| |
| public: |
| TraceCodeGenerator(CodeGenerator* pBase) { |
| mpBase = pBase; |
| } |
| |
| virtual ~TraceCodeGenerator() { |
| delete mpBase; |
| } |
| |
| virtual void init(ICodeBuf* pCodeBuf) { |
| mpBase->init(pCodeBuf); |
| } |
| |
| void setErrorSink(ErrorSink* pErrorSink) { |
| mpBase->setErrorSink(pErrorSink); |
| } |
| |
| /* returns address to patch with local variable size |
| */ |
| virtual int functionEntry(Type* pDecl) { |
| int result = mpBase->functionEntry(pDecl); |
| fprintf(stderr, "functionEntry(pDecl) -> %d\n", result); |
| return result; |
| } |
| |
| virtual void functionExit(Type* pDecl, int localVariableAddress, int localVariableSize) { |
| fprintf(stderr, "functionExit(pDecl, %d, %d)\n", |
| localVariableAddress, localVariableSize); |
| mpBase->functionExit(pDecl, localVariableAddress, localVariableSize); |
| } |
| |
| /* load immediate value */ |
| virtual void li(int t) { |
| fprintf(stderr, "li(%d)\n", t); |
| mpBase->li(t); |
| } |
| |
| virtual void loadFloat(int address, Type* pType) { |
| fprintf(stderr, "loadFloat(%d, type=%d)\n", address, pType->tag); |
| mpBase->loadFloat(address, pType); |
| } |
| |
| virtual void addStructOffsetR0(int offset, Type* pType) { |
| fprintf(stderr, "addStructOffsetR0(%d, type=%d)\n", offset, pType->tag); |
| mpBase->addStructOffsetR0(offset, pType); |
| } |
| |
| virtual int gjmp(int t) { |
| int result = mpBase->gjmp(t); |
| fprintf(stderr, "gjmp(%d) = %d\n", t, result); |
| return result; |
| } |
| |
| /* l = 0: je, l == 1: jne */ |
| virtual int gtst(bool l, int t) { |
| int result = mpBase->gtst(l, t); |
| fprintf(stderr, "gtst(%d,%d) = %d\n", l, t, result); |
| return result; |
| } |
| |
| virtual void gcmp(int op) { |
| fprintf(stderr, "gcmp(%d)\n", op); |
| mpBase->gcmp(op); |
| } |
| |
| virtual void genOp(int op) { |
| fprintf(stderr, "genOp(%d)\n", op); |
| mpBase->genOp(op); |
| } |
| |
| |
| virtual void gUnaryCmp(int op) { |
| fprintf(stderr, "gUnaryCmp(%d)\n", op); |
| mpBase->gUnaryCmp(op); |
| } |
| |
| virtual void genUnaryOp(int op) { |
| fprintf(stderr, "genUnaryOp(%d)\n", op); |
| mpBase->genUnaryOp(op); |
| } |
| |
| virtual void pushR0() { |
| fprintf(stderr, "pushR0()\n"); |
| mpBase->pushR0(); |
| } |
| |
| virtual void over() { |
| fprintf(stderr, "over()\n"); |
| mpBase->over(); |
| } |
| |
| virtual void popR0() { |
| fprintf(stderr, "popR0()\n"); |
| mpBase->popR0(); |
| } |
| |
| virtual void storeR0ToTOS() { |
| fprintf(stderr, "storeR0ToTOS()\n"); |
| mpBase->storeR0ToTOS(); |
| } |
| |
| virtual void loadR0FromR0() { |
| fprintf(stderr, "loadR0FromR0()\n"); |
| mpBase->loadR0FromR0(); |
| } |
| |
| virtual void leaR0(int ea, Type* pPointerType, ExpressionType et) { |
| fprintf(stderr, "leaR0(%d, %d, %d)\n", ea, |
| pPointerType->pHead->tag, et); |
| mpBase->leaR0(ea, pPointerType, et); |
| } |
| |
| virtual int leaForward(int ea, Type* pPointerType) { |
| fprintf(stderr, "leaForward(%d)\n", ea); |
| return mpBase->leaForward(ea, pPointerType); |
| } |
| |
| virtual void convertR0Imp(Type* pType, bool isCast){ |
| fprintf(stderr, "convertR0(pType tag=%d, %d)\n", pType->tag, isCast); |
| mpBase->convertR0Imp(pType, isCast); |
| } |
| |
| virtual int beginFunctionCallArguments() { |
| int result = mpBase->beginFunctionCallArguments(); |
| fprintf(stderr, "beginFunctionCallArguments() = %d\n", result); |
| return result; |
| } |
| |
| virtual size_t storeR0ToArg(int l, Type* pArgType) { |
| fprintf(stderr, "storeR0ToArg(%d, pArgType=%d)\n", l, |
| pArgType->tag); |
| return mpBase->storeR0ToArg(l, pArgType); |
| } |
| |
| virtual void endFunctionCallArguments(Type* pDecl, int a, int l) { |
| fprintf(stderr, "endFunctionCallArguments(%d, %d)\n", a, l); |
| mpBase->endFunctionCallArguments(pDecl, a, l); |
| } |
| |
| virtual int callForward(int symbol, Type* pFunc) { |
| int result = mpBase->callForward(symbol, pFunc); |
| fprintf(stderr, "callForward(%d) = %d\n", symbol, result); |
| return result; |
| } |
| |
| virtual void callIndirect(int l, Type* pFunc) { |
| fprintf(stderr, "callIndirect(%d returntype = %d)\n", l, |
| pFunc->pHead->tag); |
| mpBase->callIndirect(l, pFunc); |
| } |
| |
| virtual void adjustStackAfterCall(Type* pDecl, int l, bool isIndirect) { |
| fprintf(stderr, "adjustStackAfterCall(pType, %d, %d)\n", l, isIndirect); |
| mpBase->adjustStackAfterCall(pDecl, l, isIndirect); |
| } |
| |
| virtual int jumpOffset() { |
| return mpBase->jumpOffset(); |
| } |
| |
| /* output a symbol and patch all calls to it */ |
| virtual void gsym(int t) { |
| fprintf(stderr, "gsym(%d)\n", t); |
| mpBase->gsym(t); |
| } |
| |
| virtual void resolveForward(int t) { |
| mpBase->resolveForward(t); |
| } |
| |
| virtual int finishCompile() { |
| int result = mpBase->finishCompile(); |
| fprintf(stderr, "finishCompile() = %d\n", result); |
| return result; |
| } |
| |
| /** |
| * Alignment (in bytes) for this type of data |
| */ |
| virtual size_t alignmentOf(Type* pType){ |
| return mpBase->alignmentOf(pType); |
| } |
| |
| /** |
| * Array element alignment (in bytes) for this type of data. |
| */ |
| virtual size_t sizeOf(Type* pType){ |
| return mpBase->sizeOf(pType); |
| } |
| |
| virtual Type* getR0Type() { |
| return mpBase->getR0Type(); |
| } |
| |
| virtual ExpressionType getR0ExpressionType() { |
| return mpBase->getR0ExpressionType(); |
| } |
| |
| virtual void setR0ExpressionType(ExpressionType et) { |
| mpBase->setR0ExpressionType(et); |
| } |
| |
| virtual size_t getExpressionStackDepth() { |
| return mpBase->getExpressionStackDepth(); |
| } |
| |
| virtual void forceR0RVal() { |
| return mpBase->forceR0RVal(); |
| } |
| }; |
| |
| #endif // PROVIDE_TRACE_CODEGEN |
| |
| class Arena { |
| public: |
| // Used to record a given allocation amount. |
| // Used: |
| // Mark mark = arena.mark(); |
| // ... lots of arena.allocate() |
| // arena.free(mark); |
| |
| struct Mark { |
| size_t chunk; |
| size_t offset; |
| }; |
| |
| Arena() { |
| mCurrentChunk = 0; |
| Chunk start(CHUNK_SIZE); |
| mData.push_back(start); |
| } |
| |
| ~Arena() { |
| for(size_t i = 0; i < mData.size(); i++) { |
| mData[i].free(); |
| } |
| } |
| |
| // Alloc using the standard alignment size safe for any variable |
| void* alloc(size_t size) { |
| return alloc(size, 8); |
| } |
| |
| Mark mark(){ |
| Mark result; |
| result.chunk = mCurrentChunk; |
| result.offset = mData[mCurrentChunk].mOffset; |
| return result; |
| } |
| |
| void freeToMark(const Mark& mark) { |
| mCurrentChunk = mark.chunk; |
| mData[mCurrentChunk].mOffset = mark.offset; |
| } |
| |
| private: |
| // Allocate memory aligned to a given size |
| // and a given power-of-two-sized alignment (e.g. 1,2,4,8,...) |
| // Memory is not zero filled. |
| |
| void* alloc(size_t size, size_t alignment) { |
| while (size > mData[mCurrentChunk].remainingCapacity(alignment)) { |
| if (mCurrentChunk + 1 < mData.size()) { |
| mCurrentChunk++; |
| } else { |
| size_t allocSize = CHUNK_SIZE; |
| if (allocSize < size + alignment - 1) { |
| allocSize = size + alignment - 1; |
| } |
| Chunk chunk(allocSize); |
| mData.push_back(chunk); |
| mCurrentChunk++; |
| } |
| } |
| return mData[mCurrentChunk].allocate(size, alignment); |
| } |
| |
| static const size_t CHUNK_SIZE = 128*1024; |
| // Note: this class does not deallocate its |
| // memory when it's destroyed. It depends upon |
| // its parent to deallocate the memory. |
| struct Chunk { |
| Chunk() { |
| mpData = 0; |
| mSize = 0; |
| mOffset = 0; |
| } |
| |
| Chunk(size_t size) { |
| mSize = size; |
| mpData = (char*) malloc(size); |
| mOffset = 0; |
| } |
| |
| ~Chunk() { |
| // Doesn't deallocate memory. |
| } |
| |
| void* allocate(size_t size, size_t alignment) { |
| size_t alignedOffset = aligned(mOffset, alignment); |
| void* result = mpData + alignedOffset; |
| mOffset = alignedOffset + size; |
| return result; |
| } |
| |
| void free() { |
| if (mpData) { |
| ::free(mpData); |
| mpData = 0; |
| } |
| } |
| |
| size_t remainingCapacity(size_t alignment) { |
| return aligned(mSize, alignment) - aligned(mOffset, alignment); |
| } |
| |
| // Assume alignment is a power of two |
| inline size_t aligned(size_t v, size_t alignment) { |
| size_t mask = alignment-1; |
| return (v + mask) & ~mask; |
| } |
| |
| char* mpData; |
| size_t mSize; |
| size_t mOffset; |
| }; |
| |
| size_t mCurrentChunk; |
| |
| Vector<Chunk> mData; |
| }; |
| |
| struct VariableInfo; |
| |
| struct Token { |
| int hash; |
| size_t length; |
| char* pText; |
| tokenid_t id; |
| |
| // Current values for the token |
| char* mpMacroDefinition; |
| VariableInfo* mpVariableInfo; |
| VariableInfo* mpStructInfo; |
| }; |
| |
| class TokenTable { |
| public: |
| // Don't use 0..0xff, allows characters and operators to be tokens too. |
| |
| static const int TOKEN_BASE = 0x100; |
| TokenTable() { |
| mpMap = hashmapCreate(128, hashFn, equalsFn); |
| } |
| |
| ~TokenTable() { |
| hashmapFree(mpMap); |
| } |
| |
| void setArena(Arena* pArena) { |
| mpArena = pArena; |
| } |
| |
| // Returns a token for a given string of characters. |
| tokenid_t intern(const char* pText, size_t length) { |
| Token probe; |
| int hash = hashmapHash((void*) pText, length); |
| { |
| Token probe; |
| probe.hash = hash; |
| probe.length = length; |
| probe.pText = (char*) pText; |
| Token* pValue = (Token*) hashmapGet(mpMap, &probe); |
| if (pValue) { |
| return pValue->id; |
| } |
| } |
| |
| Token* pToken = (Token*) mpArena->alloc(sizeof(Token)); |
| memset(pToken, 0, sizeof(*pToken)); |
| pToken->hash = hash; |
| pToken->length = length; |
| pToken->pText = (char*) mpArena->alloc(length + 1); |
| memcpy(pToken->pText, pText, length); |
| pToken->pText[length] = 0; |
| pToken->id = mTokens.size() + TOKEN_BASE; |
| mTokens.push_back(pToken); |
| hashmapPut(mpMap, pToken, pToken); |
| return pToken->id; |
| } |
| |
| // Return the Token for a given tokenid. |
| Token& operator[](tokenid_t id) { |
| return *mTokens[id - TOKEN_BASE]; |
| } |
| |
| inline size_t size() { |
| return mTokens.size(); |
| } |
| |
| private: |
| |
| static int hashFn(void* pKey) { |
| Token* pToken = (Token*) pKey; |
| return pToken->hash; |
| } |
| |
| static bool equalsFn(void* keyA, void* keyB) { |
| Token* pTokenA = (Token*) keyA; |
| Token* pTokenB = (Token*) keyB; |
| // Don't need to compare hash values, they should always be equal |
| return pTokenA->length == pTokenB->length |
| && strcmp(pTokenA->pText, pTokenB->pText) == 0; |
| } |
| |
| Hashmap* mpMap; |
| Vector<Token*> mTokens; |
| Arena* mpArena; |
| }; |
| |
| class InputStream { |
| public: |
| virtual ~InputStream() {} |
| virtual int getChar() = 0; |
| }; |
| |
| class TextInputStream : public InputStream { |
| public: |
| TextInputStream(const char* text, size_t textLength) |
| : pText(text), mTextLength(textLength), mPosition(0) { |
| } |
| |
| virtual int getChar() { |
| return mPosition < mTextLength ? pText[mPosition++] : EOF; |
| } |
| |
| private: |
| const char* pText; |
| size_t mTextLength; |
| size_t mPosition; |
| }; |
| |
| class String { |
| public: |
| String() { |
| mpBase = 0; |
| mUsed = 0; |
| mSize = 0; |
| } |
| |
| String(const char* item, int len, bool adopt) { |
| if (len < 0) { |
| len = strlen(item); |
| } |
| if (adopt) { |
| mpBase = (char*) item; |
| mUsed = len; |
| mSize = len + 1; |
| } else { |
| mpBase = 0; |
| mUsed = 0; |
| mSize = 0; |
| appendBytes(item, len); |
| } |
| } |
| |
| String(const String& other) { |
| mpBase = 0; |
| mUsed = 0; |
| mSize = 0; |
| appendBytes(other.getUnwrapped(), other.len()); |
| } |
| |
| ~String() { |
| if (mpBase) { |
| free(mpBase); |
| } |
| } |
| |
| String& operator=(const String& other) { |
| clear(); |
| appendBytes(other.getUnwrapped(), other.len()); |
| return *this; |
| } |
| |
| inline char* getUnwrapped() const { |
| return mpBase; |
| } |
| |
| void clear() { |
| mUsed = 0; |
| if (mSize > 0) { |
| mpBase[0] = 0; |
| } |
| } |
| |
| void appendCStr(const char* s) { |
| appendBytes(s, strlen(s)); |
| } |
| |
| void appendBytes(const char* s, int n) { |
| memcpy(ensure(n), s, n + 1); |
| } |
| |
| void append(char c) { |
| * ensure(1) = c; |
| } |
| |
| void append(String& other) { |
| appendBytes(other.getUnwrapped(), other.len()); |
| } |
| |
| char* orphan() { |
| char* result = mpBase; |
| mpBase = 0; |
| mUsed = 0; |
| mSize = 0; |
| return result; |
| } |
| |
| void printf(const char* fmt,...) { |
| va_list ap; |
| va_start(ap, fmt); |
| vprintf(fmt, ap); |
| va_end(ap); |
| } |
| |
| void vprintf(const char* fmt, va_list ap) { |
| char* temp; |
| int numChars = vasprintf(&temp, fmt, ap); |
| memcpy(ensure(numChars), temp, numChars+1); |
| free(temp); |
| } |
| |
| inline size_t len() const { |
| return mUsed; |
| } |
| |
| private: |
| char* ensure(int n) { |
| size_t newUsed = mUsed + n; |
| if (newUsed > mSize) { |
| size_t newSize = mSize * 2 + 10; |
| if (newSize < newUsed) { |
| newSize = newUsed; |
| } |
| mpBase = (char*) realloc(mpBase, newSize + 1); |
| mSize = newSize; |
| } |
| mpBase[newUsed] = '\0'; |
| char* result = mpBase + mUsed; |
| mUsed = newUsed; |
| return result; |
| } |
| |
| char* mpBase; |
| size_t mUsed; |
| size_t mSize; |
| }; |
| |
| void internKeywords() { |
| // Note: order has to match TOK_ constants |
| static const char* keywords[] = { |
| "int", |
| "char", |
| "void", |
| "if", |
| "else", |
| "while", |
| "break", |
| "return", |
| "for", |
| "auto", |
| "case", |
| "const", |
| "continue", |
| "default", |
| "do", |
| "double", |
| "enum", |
| "extern", |
| "float", |
| "goto", |
| "long", |
| "register", |
| "short", |
| "signed", |
| "sizeof", |
| "static", |
| "struct", |
| "switch", |
| "typedef", |
| "union", |
| "unsigned", |
| "volatile", |
| "_Bool", |
| "_Complex", |
| "_Imaginary", |
| "inline", |
| "restrict", |
| |
| // predefined tokens that can also be symbols start here: |
| "pragma", |
| "define", |
| "line", |
| 0}; |
| |
| for(int i = 0; keywords[i]; i++) { |
| mTokenTable.intern(keywords[i], strlen(keywords[i])); |
| } |
| } |
| |
| struct InputState { |
| InputStream* pStream; |
| int oldCh; |
| }; |
| |
| struct VariableInfo { |
| void* pAddress; |
| void* pForward; // For a forward direction, linked list of data to fix up |
| tokenid_t tok; |
| size_t level; |
| VariableInfo* pOldDefinition; |
| Type* pType; |
| bool isStructTag; |
| }; |
| |
| class SymbolStack { |
| public: |
| SymbolStack() { |
| mpArena = 0; |
| mpTokenTable = 0; |
| } |
| |
| void setArena(Arena* pArena) { |
| mpArena = pArena; |
| } |
| |
| void setTokenTable(TokenTable* pTokenTable) { |
| mpTokenTable = pTokenTable; |
| } |
| |
| void pushLevel() { |
| Mark mark; |
| mark.mArenaMark = mpArena->mark(); |
| mark.mSymbolHead = mStack.size(); |
| mLevelStack.push_back(mark); |
| } |
| |
| void popLevel() { |
| // Undo any shadowing that was done: |
| Mark mark = mLevelStack.back(); |
| mLevelStack.pop_back(); |
| while (mStack.size() > mark.mSymbolHead) { |
| VariableInfo* pV = mStack.back(); |
| mStack.pop_back(); |
| if (pV->isStructTag) { |
| (*mpTokenTable)[pV->tok].mpStructInfo = pV->pOldDefinition; |
| } else { |
| (*mpTokenTable)[pV->tok].mpVariableInfo = pV->pOldDefinition; |
| } |
| } |
| mpArena->freeToMark(mark.mArenaMark); |
| } |
| |
| bool isDefinedAtCurrentLevel(tokenid_t tok) { |
| VariableInfo* pV = (*mpTokenTable)[tok].mpVariableInfo; |
| return pV && pV->level == level(); |
| } |
| |
| bool isStructTagDefinedAtCurrentLevel(tokenid_t tok) { |
| VariableInfo* pV = (*mpTokenTable)[tok].mpStructInfo; |
| return pV && pV->level == level(); |
| } |
| |
| VariableInfo* add(tokenid_t tok) { |
| Token& token = (*mpTokenTable)[tok]; |
| VariableInfo* pOldV = token.mpVariableInfo; |
| VariableInfo* pNewV = |
| (VariableInfo*) mpArena->alloc(sizeof(VariableInfo)); |
| memset(pNewV, 0, sizeof(VariableInfo)); |
| pNewV->tok = tok; |
| pNewV->level = level(); |
| pNewV->pOldDefinition = pOldV; |
| token.mpVariableInfo = pNewV; |
| mStack.push_back(pNewV); |
| return pNewV; |
| } |
| |
| VariableInfo* addStructTag(tokenid_t tok) { |
| Token& token = (*mpTokenTable)[tok]; |
| VariableInfo* pOldS = token.mpStructInfo; |
| VariableInfo* pNewS = |
| (VariableInfo*) mpArena->alloc(sizeof(VariableInfo)); |
| memset(pNewS, 0, sizeof(VariableInfo)); |
| pNewS->tok = tok; |
| pNewS->level = level(); |
| pNewS->isStructTag = true; |
| pNewS->pOldDefinition = pOldS; |
| token.mpStructInfo = pNewS; |
| mStack.push_back(pNewS); |
| return pNewS; |
| } |
| |
| VariableInfo* add(Type* pType) { |
| VariableInfo* pVI = add(pType->id); |
| pVI->pType = pType; |
| return pVI; |
| } |
| |
| void forEach(bool (*fn)(VariableInfo*, void*), void* context) { |
| for (size_t i = 0; i < mStack.size(); i++) { |
| if (! fn(mStack[i], context)) { |
| break; |
| } |
| } |
| } |
| |
| private: |
| inline size_t level() { |
| return mLevelStack.size(); |
| } |
| |
| struct Mark { |
| Arena::Mark mArenaMark; |
| size_t mSymbolHead; |
| }; |
| |
| Arena* mpArena; |
| TokenTable* mpTokenTable; |
| Vector<VariableInfo*> mStack; |
| Vector<Mark> mLevelStack; |
| }; |
| |
| struct MacroState { |
| tokenid_t name; // Name of the current macro we are expanding |
| char* dptr; // point to macro text during macro playback |
| int dch; // Saves old value of ch during a macro playback |
| }; |
| |
| #define MACRO_NESTING_MAX 32 |
| MacroState macroState[MACRO_NESTING_MAX]; |
| int macroLevel; // -1 means not playing any macro. |
| |
| int ch; // Current input character, or EOF |
| tokenid_t tok; // token |
| intptr_t tokc; // token extra info |
| double tokd; // floating point constant value |
| int tokl; // token operator level |
| intptr_t rsym; // return symbol |
| Type* pReturnType; // type of the current function's return. |
| intptr_t loc; // local variable index |
| char* glo; // global variable index |
| String mTokenString; |
| bool mbSuppressMacroExpansion; |
| char* pGlobalBase; |
| ACCSymbolLookupFn mpSymbolLookupFn; |
| void* mpSymbolLookupContext; |
| |
| // Arena for the duration of the compile |
| Arena mGlobalArena; |
| // Arena for data that's only needed when compiling a single function |
| Arena mLocalArena; |
| |
| Arena* mpCurrentArena; |
| |
| TokenTable mTokenTable; |
| SymbolStack mGlobals; |
| SymbolStack mLocals; |
| |
| SymbolStack* mpCurrentSymbolStack; |
| |
| // Prebuilt types, makes things slightly faster. |
| Type* mkpInt; // int |
| Type* mkpShort; // short |
| Type* mkpChar; // char |
| Type* mkpVoid; // void |
| Type* mkpFloat; |
| Type* mkpDouble; |
| Type* mkpIntFn; |
| Type* mkpIntPtr; |
| Type* mkpCharPtr; |
| Type* mkpFloatPtr; |
| Type* mkpDoublePtr; |
| Type* mkpPtrIntFn; |
| |
| InputStream* file; |
| int mLineNumber; |
| bool mbBumpLine; |
| |
| ICodeBuf* pCodeBuf; |
| CodeGenerator* pGen; |
| |
| String mErrorBuf; |
| |
| String mPragmas; |
| int mPragmaStringCount; |
| int mCompileResult; |
| |
| static const int ALLOC_SIZE = 99999; |
| |
| static const int TOK_DUMMY = 1; |
| static const int TOK_NUM = 2; |
| static const int TOK_NUM_FLOAT = 3; |
| static const int TOK_NUM_DOUBLE = 4; |
| static const int TOK_OP_ASSIGNMENT = 5; |
| static const int TOK_OP_ARROW = 6; |
| |
| // 3..255 are character and/or operators |
| |
| // Keywords start at 0x100 and increase by 1 |
| // Order has to match string list in "internKeywords". |
| enum { |
| TOK_KEYWORD = TokenTable::TOKEN_BASE, |
| TOK_INT = TOK_KEYWORD, |
| TOK_CHAR, |
| TOK_VOID, |
| TOK_IF, |
| TOK_ELSE, |
| TOK_WHILE, |
| TOK_BREAK, |
| TOK_RETURN, |
| TOK_FOR, |
| TOK_AUTO, |
| TOK_CASE, |
| TOK_CONST, |
| TOK_CONTINUE, |
| TOK_DEFAULT, |
| TOK_DO, |
| TOK_DOUBLE, |
| TOK_ENUM, |
| TOK_EXTERN, |
| TOK_FLOAT, |
| TOK_GOTO, |
| TOK_LONG, |
| TOK_REGISTER, |
| TOK_SHORT, |
| TOK_SIGNED, |
| TOK_SIZEOF, |
| TOK_STATIC, |
| TOK_STRUCT, |
| TOK_SWITCH, |
| TOK_TYPEDEF, |
| TOK_UNION, |
| TOK_UNSIGNED, |
| TOK_VOLATILE, |
| TOK__BOOL, |
| TOK__COMPLEX, |
| TOK__IMAGINARY, |
| TOK_INLINE, |
| TOK_RESTRICT, |
| |
| // Symbols start after keywords |
| |
| TOK_SYMBOL, |
| TOK_PRAGMA = TOK_SYMBOL, |
| TOK_DEFINE, |
| TOK_LINE |
| }; |
| |
| static const int LOCAL = 0x200; |
| |
| /* tokens in string heap */ |
| static const int TAG_TOK = ' '; |
| |
| static const int OP_INCREMENT = 0; |
| static const int OP_DECREMENT = 1; |
| static const int OP_MUL = 2; |
| static const int OP_DIV = 3; |
| static const int OP_MOD = 4; |
| static const int OP_PLUS = 5; |
| static const int OP_MINUS = 6; |
| static const int OP_SHIFT_LEFT = 7; |
| static const int OP_SHIFT_RIGHT = 8; |
| static const int OP_LESS_EQUAL = 9; |
| static const int OP_GREATER_EQUAL = 10; |
| static const int OP_LESS = 11; |
| static const int OP_GREATER = 12; |
| static const int OP_EQUALS = 13; |
| static const int OP_NOT_EQUALS = 14; |
| static const int OP_LOGICAL_AND = 15; |
| static const int OP_LOGICAL_OR = 16; |
| static const int OP_BIT_AND = 17; |
| static const int OP_BIT_XOR = 18; |
| static const int OP_BIT_OR = 19; |
| static const int OP_BIT_NOT = 20; |
| static const int OP_LOGICAL_NOT = 21; |
| static const int OP_COUNT = 22; |
| |
| /* Operators are searched from front, the two-character operators appear |
| * before the single-character operators with the same first character. |
| * @ is used to pad out single-character operators. |
| */ |
| static const char* operatorChars; |
| static const char operatorLevel[]; |
| |
| /* Called when we detect an internal problem. Does nothing in production. |
| * |
| */ |
| void internalError() { |
| * (char*) 0 = 0; |
| } |
| |
| void assertImpl(bool isTrue, int line) { |
| if (!isTrue) { |
| LOGD("%d: assertion failed at line %s:%d.", mLineNumber, __FILE__, line); |
| internalError(); |
| } |
| } |
| |
| bool isSymbol(tokenid_t t) { |
| return t >= TOK_SYMBOL && |
| ((size_t) (t-TOK_SYMBOL)) < mTokenTable.size(); |
| } |
| |
| bool isSymbolOrKeyword(tokenid_t t) { |
| return t >= TOK_KEYWORD && |
| ((size_t) (t-TOK_KEYWORD)) < mTokenTable.size(); |
| } |
| |
| VariableInfo* VI(tokenid_t t) { |
| assert(isSymbol(t)); |
| VariableInfo* pV = mTokenTable[t].mpVariableInfo; |
| if (pV && pV->tok != t) { |
| internalError(); |
| } |
| return pV; |
| } |
| |
| inline bool isDefined(tokenid_t t) { |
| return t >= TOK_SYMBOL && VI(t) != 0; |
| } |
| |
| const char* nameof(tokenid_t t) { |
| assert(isSymbolOrKeyword(t)); |
| return mTokenTable[t].pText; |
| } |
| |
| void pdef(int t) { |
| mTokenString.append(t); |
| } |
| |
| void inp() { |
| // Close any totally empty macros. We leave them on the stack until now |
| // so that we know which macros are being expanded when checking if the |
| // last token in the macro is a macro that's already being expanded. |
| while (macroLevel >= 0 && macroState[macroLevel].dptr == NULL) { |
| macroLevel--; |
| } |
| if (macroLevel >= 0) { |
| ch = *macroState[macroLevel].dptr++; |
| if (ch == 0) { |
| ch = macroState[macroLevel].dch; |
| macroState[macroLevel].dptr = NULL; // This macro's done |
| } |
| } else { |
| if (mbBumpLine) { |
| mLineNumber++; |
| mbBumpLine = false; |
| } |
| ch = file->getChar(); |
| if (ch == '\n') { |
| mbBumpLine = true; |
| } |
| } |
| #if 0 |
| printf("ch='%c' 0x%x\n", ch, ch); |
| #endif |
| } |
| |
| int isid() { |
| return isalnum(ch) | (ch == '_'); |
| } |
| |
| int decodeHex(int c) { |
| if (isdigit(c)) { |
| c -= '0'; |
| } else if (c <= 'F') { |
| c = c - 'A' + 10; |
| } else { |
| c =c - 'a' + 10; |
| } |
| return c; |
| } |
| |
| /* read a character constant, advances ch to after end of constant */ |
| int getq() { |
| int val = ch; |
| if (ch == '\\') { |
| inp(); |
| if (isoctal(ch)) { |
| // 1 to 3 octal characters. |
| val = 0; |
| for(int i = 0; i < 3; i++) { |
| if (isoctal(ch)) { |
| val = (val << 3) + ch - '0'; |
| inp(); |
| } |
| } |
| return val; |
| } else if (ch == 'x' || ch == 'X') { |
| // N hex chars |
| inp(); |
| if (! isxdigit(ch)) { |
| error("'x' character escape requires at least one digit."); |
| } else { |
| val = 0; |
| while (isxdigit(ch)) { |
| val = (val << 4) + decodeHex(ch); |
| inp(); |
| } |
| } |
| } else { |
| int val = ch; |
| switch (ch) { |
| case 'a': |
| val = '\a'; |
| break; |
| case 'b': |
| val = '\b'; |
| break; |
| case 'f': |
| val = '\f'; |
| break; |
| case 'n': |
| val = '\n'; |
| break; |
| case 'r': |
| val = '\r'; |
| break; |
| case 't': |
| val = '\t'; |
| break; |
| case 'v': |
| val = '\v'; |
| break; |
| case '\\': |
| val = '\\'; |
| break; |
| case '\'': |
| val = '\''; |
| break; |
| case '"': |
| val = '"'; |
| break; |
| case '?': |
| val = '?'; |
| break; |
| default: |
| error("Undefined character escape %c", ch); |
| break; |
| } |
| inp(); |
| return val; |
| } |
| } else { |
| inp(); |
| } |
| return val; |
| } |
| |
| static bool isoctal(int ch) { |
| return ch >= '0' && ch <= '7'; |
| } |
| |
| bool acceptCh(int c) { |
| bool result = c == ch; |
| if (result) { |
| pdef(ch); |
| inp(); |
| } |
| return result; |
| } |
| |
| bool acceptDigitsCh() { |
| bool result = false; |
| while (isdigit(ch)) { |
| result = true; |
| pdef(ch); |
| inp(); |
| } |
| return result; |
| } |
| |
| void parseFloat() { |
| tok = TOK_NUM_DOUBLE; |
| // mTokenString already has the integral part of the number. |
| if(mTokenString.len() == 0) { |
| mTokenString.append('0'); |
| } |
| acceptCh('.'); |
| acceptDigitsCh(); |
| if (acceptCh('e') || acceptCh('E')) { |
| acceptCh('-') || acceptCh('+'); |
| acceptDigitsCh(); |
| } |
| if (ch == 'f' || ch == 'F') { |
| tok = TOK_NUM_FLOAT; |
| inp(); |
| } else if (ch == 'l' || ch == 'L') { |
| inp(); |
| error("Long floating point constants not supported."); |
| } |
| char* pText = mTokenString.getUnwrapped(); |
| char* pEnd = pText + strlen(pText); |
| char* pEndPtr = 0; |
| errno = 0; |
| if (tok == TOK_NUM_FLOAT) { |
| tokd = strtof(pText, &pEndPtr); |
| } else { |
| tokd = strtod(pText, &pEndPtr); |
| } |
| if (errno || pEndPtr != pEnd) { |
| error("Can't parse constant: %s", pText); |
| } |
| // fprintf(stderr, "float constant: %s (%d) %g\n", pText, tok, tokd); |
| } |
| |
| bool currentlyBeingExpanded(tokenid_t id) { |
| for (int i = 0; i <= macroLevel; i++) { |
| if (macroState[macroLevel].name == id) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| void next() { |
| int l, a; |
| |
| while (isspace(ch) | (ch == '#')) { |
| if (ch == '#') { |
| inp(); |
| next(); |
| if (tok == TOK_DEFINE) { |
| doDefine(); |
| } else if (tok == TOK_PRAGMA) { |
| doPragma(); |
| } else if (tok == TOK_LINE) { |
| doLine(); |
| } else { |
| error("Unsupported preprocessor directive \"%s\"", |
| mTokenString.getUnwrapped()); |
| } |
| } |
| inp(); |
| } |
| tokl = 0; |
| tok = ch; |
| /* encode identifiers & numbers */ |
| if (isdigit(ch) || ch == '.') { |
| // Start of a numeric constant. Could be integer, float, or |
| // double, won't know until we look further. |
| mTokenString.clear(); |
| pdef(ch); |
| inp(); |
| if (tok == '.' && !isdigit(ch)) { |
| goto done; |
| } |
| int base = 10; |
| if (tok == '0') { |
| if (ch == 'x' || ch == 'X') { |
| base = 16; |
| tok = TOK_NUM; |
| tokc = 0; |
| inp(); |
| while ( isxdigit(ch) ) { |
| tokc = (tokc << 4) + decodeHex(ch); |
| inp(); |
| } |
| } else if (isoctal(ch)){ |
| base = 8; |
| tok = TOK_NUM; |
| tokc = 0; |
| while ( isoctal(ch) ) { |
| tokc = (tokc << 3) + (ch - '0'); |
| inp(); |
| } |
| } |
| } else if (isdigit(tok)){ |
| acceptDigitsCh(); |
| } |
| if (base == 10) { |
| if (tok == '.' || ch == '.' || ch == 'e' || ch == 'E') { |
| parseFloat(); |
| } else { |
| // It's an integer constant |
| char* pText = mTokenString.getUnwrapped(); |
| char* pEnd = pText + strlen(pText); |
| char* pEndPtr = 0; |
| errno = 0; |
| tokc = strtol(pText, &pEndPtr, base); |
| if (errno || pEndPtr != pEnd) { |
| error("Can't parse constant: %s %d %d", pText, base, errno); |
| } |
| tok = TOK_NUM; |
| } |
| } |
| } else if (isid()) { |
| mTokenString.clear(); |
| while (isid()) { |
| pdef(ch); |
| inp(); |
| } |
| tok = mTokenTable.intern(mTokenString.getUnwrapped(), mTokenString.len()); |
| if (! mbSuppressMacroExpansion) { |
| // Is this a macro? |
| char* pMacroDefinition = mTokenTable[tok].mpMacroDefinition; |
| if (pMacroDefinition && !currentlyBeingExpanded(tok)) { |
| // Yes, it is a macro |
| #if 0 |
| printf("Expanding macro %s -> %s", |
| mTokenString.getUnwrapped(), pMacroDefinition); |
| #endif |
| if (macroLevel >= MACRO_NESTING_MAX-1) { |
| error("Too many levels of macro recursion."); |
| } else { |
| macroLevel++; |
| macroState[macroLevel].name = tok; |
| macroState[macroLevel].dptr = pMacroDefinition; |
| macroState[macroLevel].dch = ch; |
| inp(); |
| next(); |
| } |
| } |
| } |
| } else { |
| inp(); |
| if (tok == '\'') { |
| tok = TOK_NUM; |
| tokc = getq(); |
| if (ch != '\'') { |
| error("Expected a ' character, got %c", ch); |
| } else { |
| inp(); |
| } |
| } else if ((tok == '/') & (ch == '*')) { |
| inp(); |
| while (ch && ch != EOF) { |
| while (ch != '*' && ch != EOF) |
| inp(); |
| inp(); |
| if (ch == '/') |
| ch = 0; |
| } |
| if (ch == EOF) { |
| error("End of file inside comment."); |
| } |
| inp(); |
| next(); |
| } else if ((tok == '/') & (ch == '/')) { |
| inp(); |
| while (ch && (ch != '\n') && (ch != EOF)) { |
| inp(); |
| } |
| inp(); |
| next(); |
| } else if ((tok == '-') & (ch == '>')) { |
| inp(); |
| tok = TOK_OP_ARROW; |
| } else { |
| const char* t = operatorChars; |
| int opIndex = 0; |
| while ((l = *t++) != 0) { |
| a = *t++; |
| tokl = operatorLevel[opIndex]; |
| tokc = opIndex; |
| if ((l == tok) & ((a == ch) | (a == '@'))) { |
| #if 0 |
| printf("%c%c -> tokl=%d tokc=0x%x\n", |
| l, a, tokl, tokc); |
| #endif |
| if (a == ch) { |
| inp(); |
| tok = TOK_DUMMY; /* dummy token for double tokens */ |
| } |
| /* check for op=, valid for * / % + - << >> & ^ | */ |
| if (ch == '=' && |
| ((tokl >= 1 && tokl <= 3) |
| || (tokl >=6 && tokl <= 8)) ) { |
| inp(); |
| tok = TOK_OP_ASSIGNMENT; |
| } |
| break; |
| } |
| opIndex++; |
| } |
| if (l == 0) { |
| tokl = 0; |
| tokc = 0; |
| } |
| } |
| } |
| |
| done: ; |
| #if 0 |
| { |
| String buf; |
| decodeToken(buf, tok, true); |
| fprintf(stderr, "%s\n", buf.getUnwrapped()); |
| } |
| #endif |
| } |
| |
| void doDefine() { |
| mbSuppressMacroExpansion = true; |
| next(); |
| mbSuppressMacroExpansion = false; |
| tokenid_t name = tok; |
| if (ch == '(') { |
| error("Defines with arguments not supported"); |
| return; |
| } |
| while (isspace(ch)) { |
| inp(); |
| } |
| String value; |
| bool appendToValue = true; |
| while (ch != '\n' && ch != EOF) { |
| // Check for '//' comments. |
| if (appendToValue && ch == '/') { |
| inp(); |
| if (ch == '/') { |
| appendToValue = false; |
| } else { |
| value.append('/'); |
| } |
| } |
| if (appendToValue && ch != EOF) { |
| value.append(ch); |
| } |
| inp(); |
| } |
| char* pDefn = (char*)mGlobalArena.alloc(value.len() + 1); |
| memcpy(pDefn, value.getUnwrapped(), value.len()); |
| pDefn[value.len()] = 0; |
| mTokenTable[name].mpMacroDefinition = pDefn; |
| #if 0 |
| { |
| String buf; |
| decodeToken(buf, name, true); |
| fprintf(stderr, "define %s = \"%s\"\n", buf.getUnwrapped(), pDefn); |
| } |
| #endif |
| } |
| |
| void doPragma() { |
| // # pragma name(val) |
| int state = 0; |
| while(ch != EOF && ch != '\n' && state < 10) { |
| switch(state) { |
| case 0: |
| if (isspace(ch)) { |
| inp(); |
| } else { |
| state++; |
| } |
| break; |
| case 1: |
| if (isalnum(ch)) { |
| mPragmas.append(ch); |
| inp(); |
| } else if (ch == '(') { |
| mPragmas.append(0); |
| inp(); |
| state++; |
| } else { |
| state = 11; |
| } |
| break; |
| case 2: |
| if (isalnum(ch)) { |
| mPragmas.append(ch); |
| inp(); |
| } else if (ch == ')') { |
| mPragmas.append(0); |
| inp(); |
| state = 10; |
| } else { |
| state = 11; |
| } |
| break; |
| } |
| } |
| if(state != 10) { |
| error("Unexpected pragma syntax"); |
| } |
| mPragmaStringCount += 2; |
| } |
| |
| void doLine() { |
| // # line number { "filename "} |
| next(); |
| if (tok != TOK_NUM) { |
| error("Expected a line-number"); |
| } else { |
| mLineNumber = tokc-1; // The end-of-line will increment it. |
| } |
| while(ch != EOF && ch != '\n') { |
| inp(); |
| } |
| } |
| |
| virtual void verror(const char* fmt, va_list ap) { |
| mErrorBuf.printf("%ld: ", mLineNumber); |
| mErrorBuf.vprintf(fmt, ap); |
| mErrorBuf.printf("\n"); |
| } |
| |
| void skip(intptr_t c) { |
| if (!accept(c)) { |
| error("'%c' expected", c); |
| } |
| } |
| |
| bool accept(intptr_t c) { |
| if (tok == c) { |
| next(); |
| return true; |
| } |
| return false; |
| } |
| |
| bool acceptStringLiteral() { |
| if (tok == '"') { |
| pGen->leaR0((int) glo, mkpCharPtr, ET_RVALUE); |
| // This while loop merges multiple adjacent string constants. |
| while (tok == '"') { |
| while (ch != '"' && ch != EOF) { |
| *allocGlobalSpace(1,1) = getq(); |
| } |
| if (ch != '"') { |
| error("Unterminated string constant."); |
| } |
| inp(); |
| next(); |
| } |
| /* Null terminate */ |
| *glo = 0; |
| /* align heap */ |
| allocGlobalSpace(1,(char*) (((intptr_t) glo + 4) & -4) - glo); |
| |
| return true; |
| } |
| return false; |
| } |
| |
| void linkGlobal(tokenid_t t, bool isFunction) { |
| VariableInfo* pVI = VI(t); |
| void* n = NULL; |
| if (mpSymbolLookupFn) { |
| n = mpSymbolLookupFn(mpSymbolLookupContext, nameof(t)); |
| } |
| if (pVI->pType == NULL) { |
| if (isFunction) { |
| pVI->pType = mkpIntFn; |
| } else { |
| pVI->pType = mkpInt; |
| } |
| } |
| pVI->pAddress = n; |
| } |
| |
| void unaryOrAssignment() { |
| unary(); |
| if (accept('=')) { |
| checkLVal(); |
| pGen->pushR0(); |
| expr(); |
| pGen->forceR0RVal(); |
| pGen->storeR0ToTOS(); |
| } else if (tok == TOK_OP_ASSIGNMENT) { |
| int t = tokc; |
| next(); |
| checkLVal(); |
| pGen->pushR0(); |
| pGen->forceR0RVal(); |
| pGen->pushR0(); |
| expr(); |
| pGen->forceR0RVal(); |
| pGen->genOp(t); |
| pGen->storeR0ToTOS(); |
| } |
| } |
| |
| /* Parse and evaluate a unary expression. |
| */ |
| void unary() { |
| tokenid_t t; |
| intptr_t a; |
| t = 0; |
| if (acceptStringLiteral()) { |
| // Nothing else to do. |
| } else { |
| int c = tokl; |
| a = tokc; |
| double ad = tokd; |
| t = tok; |
| next(); |
| if (t == TOK_NUM) { |
| pGen->li(a); |
| } else if (t == TOK_NUM_FLOAT) { |
| // Align to 4-byte boundary |
| glo = (char*) (((intptr_t) glo + 3) & -4); |
| * (float*) glo = (float) ad; |
| pGen->loadFloat((int) glo, mkpFloat); |
| glo += 4; |
| } else if (t == TOK_NUM_DOUBLE) { |
| // Align to 8-byte boundary |
| glo = (char*) (((intptr_t) glo + 7) & -8); |
| * (double*) glo = ad; |
| pGen->loadFloat((int) glo, mkpDouble); |
| glo += 8; |
| } else if (c == 2) { |
| /* -, +, !, ~ */ |
| unary(); |
| pGen->forceR0RVal(); |
| if (t == '!') |
| pGen->gUnaryCmp(a); |
| else if (t == '+') { |
| // ignore unary plus. |
| } else { |
| pGen->genUnaryOp(a); |
| } |
| } else if (c == 11) { |
| // pre increment / pre decrement |
| unary(); |
| doIncDec(a == OP_INCREMENT, 0); |
| } |
| else if (t == '(') { |
| // It's either a cast or an expression |
| Type* pCast = acceptCastTypeDeclaration(); |
| if (pCast) { |
| skip(')'); |
| unary(); |
| pGen->forceR0RVal(); |
| pGen->castR0(pCast); |
| } else { |
| commaExpr(); |
| skip(')'); |
| } |
| } else if (t == '*') { |
| /* This is a pointer dereference. |
| */ |
| unary(); |
| doPointer(); |
| } else if (t == '&') { |
| unary(); |
| doAddressOf(); |
| } else if (t == EOF ) { |
| error("Unexpected EOF."); |
| } else if (t == ';') { |
| error("Unexpected ';'"); |
| } else if (!checkSymbol(t)) { |
| // Don't have to do anything special here, the error |
| // message was printed by checkSymbol() above. |
| } else { |
| if (!isDefined(t)) { |
| mGlobals.add(t); |
| // printf("Adding new global function %s\n", nameof(t)); |
| } |
| VariableInfo* pVI = VI(t); |
| int n = (intptr_t) pVI->pAddress; |
| /* forward reference: try our lookup function */ |
| if (!n) { |
| linkGlobal(t, tok == '('); |
| n = (intptr_t) pVI->pAddress; |
| if (!n && tok != '(') { |
| error("Undeclared variable %s", nameof(t)); |
| } |
| } |
| if (tok != '(') { |
| /* variable or function name */ |
| if (!n) { |
| linkGlobal(t, false); |
| n = (intptr_t) pVI->pAddress; |
| if (!n) { |
| error("Undeclared variable %s", nameof(t)); |
| } |
| } |
| } |
| // load a variable |
| Type* pVal; |
| ExpressionType et; |
| if (pVI->pType->tag == TY_ARRAY) { |
| pVal = pVI->pType; |
| et = ET_RVALUE; |
| } else { |
| pVal = createPtrType(pVI->pType); |
| et = ET_LVALUE; |
| } |
| if (n) { |
| int tag = pVal->pHead->tag; |
| if (tag == TY_FUNC) { |
| et = ET_RVALUE; |
| } |
| pGen->leaR0(n, pVal, et); |
| } else { |
| pVI->pForward = (void*) pGen->leaForward( |
| (int) pVI->pForward, pVal); |
| } |
| } |
| } |
| |
| /* Now handle postfix operators */ |
| for(;;) { |
| if (tokl == 11) { |
| // post inc / post dec |
| doIncDec(tokc == OP_INCREMENT, true); |
| next(); |
| } else if (accept('[')) { |
| // Array reference |
| pGen->forceR0RVal(); |
| pGen->pushR0(); |
| commaExpr(); |
| pGen->forceR0RVal(); |
| pGen->genOp(OP_PLUS); |
| doPointer(); |
| skip(']'); |
| } else if (accept('.')) { |
| // struct element |
| pGen->forceR0RVal(); |
| Type* pStruct = pGen->getR0Type(); |
| if (pStruct->tag == TY_STRUCT) { |
| doStructMember(pStruct, true); |
| } else { |
| error("expected a struct value to the left of '.'"); |
| } |
| } else if (accept(TOK_OP_ARROW)) { |
| pGen->forceR0RVal(); |
| Type* pPtr = pGen->getR0Type(); |
| if (pPtr->tag == TY_POINTER && pPtr->pHead->tag == TY_STRUCT) { |
| pGen->loadR0FromR0(); |
| doStructMember(pPtr->pHead, false); |
| } else { |
| error("Expected a pointer to a struct to the left of '->'"); |
| } |
| } else if (accept('(')) { |
| /* function call */ |
| Type* pDecl = NULL; |
| VariableInfo* pVI = NULL; |
| Type* pFn = pGen->getR0Type(); |
| if (pFn->tag == TY_POINTER && pFn->pHead->tag == TY_FUNC) { |
| pDecl = pFn->pHead; |
| pGen->pushR0(); |
| Type* pArgList = pDecl->pTail; |
| bool varArgs = pArgList == NULL; |
| /* push args and invert order */ |
| a = pGen->beginFunctionCallArguments(); |
| int l = 0; |
| int argCount = 0; |
| while (tok != ')' && tok != EOF) { |
| if (! varArgs && !pArgList) { |
| error("Unexpected argument."); |
| } |
| expr(); |
| pGen->forceR0RVal(); |
| Type* pTargetType; |
| if (pArgList) { |
| pTargetType = pArgList->pHead; |
| pArgList = pArgList->pTail; |
| } else { |
| // This is a ... function, just pass arguments in their |
| // natural type. |
| pTargetType = pGen->getR0Type(); |
| if (pTargetType->tag == TY_FLOAT) { |
| pTargetType = mkpDouble; |
| } else if (pTargetType->tag == TY_ARRAY) { |
| // Pass arrays by pointer. |
| pTargetType = pTargetType->pTail; |
| } |
| } |
| if (pTargetType->tag == TY_VOID) { |
| error("Can't pass void value for argument %d", |
| argCount + 1); |
| } else { |
| l += pGen->storeR0ToArg(l, pTargetType); |
| } |
| if (accept(',')) { |
| // fine |
| } else if ( tok != ')') { |
| error("Expected ',' or ')'"); |
| } |
| argCount += 1; |
| } |
| if (! varArgs && pArgList) { |
| error("Expected more argument(s). Saw %d", argCount); |
| } |
| pGen->endFunctionCallArguments(pDecl, a, l); |
| skip(')'); |
| pGen->callIndirect(l, pDecl); |
| pGen->adjustStackAfterCall(pDecl, l, true); |
| } else { |
| error("Expected a function value to left of '('."); |
| } |
| } else { |
| break; |
| } |
| } |
| } |
| |
| void doStructMember(Type* pStruct, bool isDot) { |
| Type* pStructElement = lookupStructMember(pStruct, tok); |
| if (pStructElement) { |
| next(); |
| pGen->addStructOffsetR0(pStructElement->length, createPtrType(pStructElement->pHead)); |
| } else { |
| String buf; |
| decodeToken(buf, tok, true); |
| error("Expected a struct member to the right of '%s', got %s", |
| isDot ? "." : "->", buf.getUnwrapped()); |
| } |
| } |
| |
| void doIncDec(int isInc, int isPost) { |
| // R0 already has the lval |
| checkLVal(); |
| int lit = isInc ? 1 : -1; |
| pGen->pushR0(); |
| pGen->loadR0FromR0(); |
| int tag = pGen->getR0Type()->tag; |
| if (!(tag == TY_INT || tag == TY_SHORT || tag == TY_CHAR || |
| tag == TY_POINTER)) { |
| error("++/-- illegal for this type. %d", tag); |
| } |
| if (isPost) { |
| pGen->over(); |
| pGen->pushR0(); |
| pGen->li(lit); |
| pGen->genOp(OP_PLUS); |
| pGen->storeR0ToTOS(); |
| pGen->popR0(); |
| } else { |
| pGen->pushR0(); |
| pGen->li(lit); |
| pGen->genOp(OP_PLUS); |
| pGen->over(); |
| pGen->storeR0ToTOS(); |
| pGen->popR0(); |
| } |
| } |
| |
| void doPointer() { |
| pGen->forceR0RVal(); |
| Type* pR0Type = pGen->getR0Type(); |
| if (pR0Type->tag != TY_POINTER) { |
| error("Expected a pointer type."); |
| } else { |
| if (pR0Type->pHead->tag != TY_FUNC) { |
| pGen->setR0ExpressionType(ET_LVALUE); |
| } |
| } |
| } |
| |
| void doAddressOf() { |
| Type* pR0 = pGen->getR0Type(); |
| bool isFuncPtr = pR0->tag == TY_POINTER && pR0->pHead->tag == TY_FUNC; |
| if ((! isFuncPtr) && pGen->getR0ExpressionType() != ET_LVALUE) { |
| error("Expected an lvalue"); |
| } |
| Type* pR0Type = pGen->getR0Type(); |
| pGen->setR0ExpressionType(ET_RVALUE); |
| } |
| |
| /* Recursive descent parser for binary operations. |
| */ |
| void binaryOp(int level) { |
| intptr_t t, a; |
| t = 0; |
| if (level-- == 1) |
| unaryOrAssignment(); |
| else { |
| binaryOp(level); |
| a = 0; |
| while (level == tokl) { |
| t = tokc; |
| next(); |
| pGen->forceR0RVal(); |
| if (level > 8) { |
| a = pGen->gtst(t == OP_LOGICAL_OR, a); /* && and || output code generation */ |
| binaryOp(level); |
| } else { |
| pGen->pushR0(); |
| binaryOp(level); |
| // Check for syntax error. |
| if (pGen->getR0Type() == NULL) { |
| // We failed to parse a right-hand argument. |
| // Push a dummy value so we don't fail |
| pGen->li(0); |
| } |
| pGen->forceR0RVal(); |
| if ((level == 4) | (level == 5)) { |
| pGen->gcmp(t); |
| } else { |
| pGen->genOp(t); |
| } |
| } |
| } |
| /* && and || output code generation */ |
| if (a && level > 8) { |
| pGen->forceR0RVal(); |
| a = pGen->gtst(t == OP_LOGICAL_OR, a); |
| pGen->li(t != OP_LOGICAL_OR); |
| int b = pGen->gjmp(0); |
| pGen->gsym(a); |
| pGen->li(t == OP_LOGICAL_OR); |
| pGen->gsym(b); |
| } |
| } |
| } |
| |
| void commaExpr() { |
| for(;;) { |
| expr(); |
| if (!accept(',')) { |
| break; |
| } |
| } |
| } |
| |
| void expr() { |
| binaryOp(11); |
| } |
| |
| int test_expr() { |
| commaExpr(); |
| pGen->forceR0RVal(); |
| return pGen->gtst(0, 0); |
| } |
| |
| void block(intptr_t* breakLabel, intptr_t continueAddress, bool outermostFunctionBlock) { |
| intptr_t a, n, t; |
| |
| Type* pBaseType; |
| if ((pBaseType = acceptPrimitiveType(true))) { |
| /* declarations */ |
| localDeclarations(pBaseType); |
| } else if (tok == TOK_IF) { |
| next(); |
| skip('('); |
| a = test_expr(); |
| skip(')'); |
| block(breakLabel, continueAddress, false); |
| if (tok == TOK_ELSE) { |
| next(); |
| n = pGen->gjmp(0); /* jmp */ |
| pGen->gsym(a); |
| block(breakLabel, continueAddress, false); |
| pGen->gsym(n); /* patch else jmp */ |
| } else { |
| pGen->gsym(a); /* patch if test */ |
| } |
| } else if ((tok == TOK_WHILE) | (tok == TOK_FOR)) { |
| t = tok; |
| next(); |
| skip('('); |
| if (t == TOK_WHILE) { |
| n = pCodeBuf->getPC(); // top of loop, target of "next" iteration |
| a = test_expr(); |
| } else { |
| if (tok != ';') |
| commaExpr(); |
| skip(';'); |
| n = pCodeBuf->getPC(); |
| a = 0; |
| if (tok != ';') |
| a = test_expr(); |
| skip(';'); |
| if (tok != ')') { |
| t = pGen->gjmp(0); |
| commaExpr(); |
| pGen->gjmp(n - pCodeBuf->getPC() - pGen->jumpOffset()); |
| pGen->gsym(t); |
| n = t + 4; |
| } |
| } |
| skip(')'); |
| block(&a, n, false); |
| pGen->gjmp(n - pCodeBuf->getPC() - pGen->jumpOffset()); /* jmp */ |
| pGen->gsym(a); |
| } else if (tok == '{') { |
| if (! outermostFunctionBlock) { |
| mLocals.pushLevel(); |
| } |
| next(); |
| while (tok != '}' && tok != EOF) |
| block(breakLabel, continueAddress, false); |
| skip('}'); |
| if (! outermostFunctionBlock) { |
| mLocals.popLevel(); |
| } |
| } else { |
| if (accept(TOK_RETURN)) { |
| if (tok != ';') { |
| commaExpr(); |
| pGen->forceR0RVal(); |
| if (pReturnType->tag == TY_VOID) { |
| error("Must not return a value from a void function"); |
| } else { |
| pGen->convertR0(pReturnType); |
| } |
| } else { |
| if (pReturnType->tag != TY_VOID) { |
| error("Must specify a value here"); |
| } |
| } |
| rsym = pGen->gjmp(rsym); /* jmp */ |
| } else if (accept(TOK_BREAK)) { |
| if (breakLabel) { |
| *breakLabel = pGen->gjmp(*breakLabel); |
| } else { |
| error("break statement must be within a for, do, while, or switch statement"); |
| } |
| } else if (accept(TOK_CONTINUE)) { |
| if (continueAddress) { |
| pGen->gjmp(continueAddress - pCodeBuf->getPC() - pGen->jumpOffset()); |
| } else { |
| error("continue statement must be within a for, do, or while statement"); |
| } |
| } else if (tok != ';') |
| commaExpr(); |
| skip(';'); |
| } |
| } |
| |
| static bool typeEqual(Type* a, Type* b) { |
| if (a == b) { |
| return true; |
| } |
| if (a == NULL || b == NULL) { |
| return false; |
| } |
| TypeTag at = a->tag; |
| if (at != b->tag) { |
| return false; |
| } |
| if (at == TY_POINTER) { |
| return typeEqual(a->pHead, b->pHead); |
| } else if (at == TY_ARRAY) { |
| return a->length == b->length && typeEqual(a->pHead, b->pHead); |
| } else if (at == TY_FUNC || at == TY_PARAM) { |
| return typeEqual(a->pHead, b->pHead) |
| && typeEqual(a->pTail, b->pTail); |
| } else if (at == TY_STRUCT) { |
| return a->pHead == b->pHead; |
| } |
| return true; |
| } |
| |
| Type* createType(TypeTag tag, Type* pHead, Type* pTail) { |
| assert(tag >= TY_UNKNOWN && tag <= TY_PARAM); |
| Type* pType = (Type*) mpCurrentArena->alloc(sizeof(Type)); |
| memset(pType, 0, sizeof(*pType)); |
| pType->storageClass = SC_DEFAULT; |
| pType->tag = tag; |
| pType->pHead = pHead; |
| pType->pTail = pTail; |
| return pType; |
| } |
| |
| Type* createPtrType(Type* pType) { |
| return createType(TY_POINTER, pType, NULL); |
| } |
| |
| /** |
| * Try to print a type in declaration order |
| */ |
| void decodeType(String& buffer, Type* pType) { |
| buffer.clear(); |
| if (pType == NULL) { |
| buffer.appendCStr("null"); |
| return; |
| } |
| decodeTypeImp(buffer, pType); |
| } |
| |
| void decodeTypeImp(String& buffer, Type* pType) { |
| decodeTypeImpPrefix(buffer, pType); |
| decodeId(buffer, pType->id); |
| decodeTypeImpPostfix(buffer, pType); |
| } |
| |
| void decodeId(String& buffer, tokenid_t id) { |
| if (id) { |
| String temp; |
| decodeToken(temp, id, false); |
| buffer.append(temp); |
| } |
| } |
| |
| void decodeTypeImpPrefix(String& buffer, Type* pType) { |
| TypeTag tag = pType->tag; |
| |
| if ((tag >= TY_INT && tag <= TY_DOUBLE) || tag == TY_STRUCT) { |
| switch (tag) { |
| case TY_INT: |
| buffer.appendCStr("int"); |
| break; |
| case TY_SHORT: |
| buffer.appendCStr("short"); |
| break; |
| case TY_CHAR: |
| buffer.appendCStr("char"); |
| break; |
| case TY_VOID: |
| buffer.appendCStr("void"); |
| break; |
| case TY_FLOAT: |
| buffer.appendCStr("float"); |
| break; |
| case TY_DOUBLE: |
| buffer.appendCStr("double"); |
| break; |
| case TY_STRUCT: |
| { |
| bool isStruct = (pType->pHead->alignment & 0x80000000) != 0; |
| buffer.appendCStr(isStruct ? "struct" : "union"); |
| if (pType->pHead && pType->pHead->structTag) { |
| buffer.append(' '); |
| decodeId(buffer, pType->pHead->structTag); |
| } |
| } |
| break; |
| default: |
| break; |
| } |
| buffer.append(' '); |
| } |
| |
| switch (tag) { |
| case TY_INT: |
| break; |
| case TY_SHORT: |
| break; |
| case TY_CHAR: |
| break; |
| case TY_VOID: |
| break; |
| case TY_FLOAT: |
| break; |
| case TY_DOUBLE: |
| break; |
| case TY_POINTER: |
| decodeTypeImpPrefix(buffer, pType->pHead); |
| if(pType->pHead && pType->pHead->tag == TY_FUNC) { |
| buffer.append('('); |
| } |
| buffer.append('*'); |
| break; |
| case TY_ARRAY: |
| decodeTypeImpPrefix(buffer, pType->pHead); |
| break; |
| case TY_STRUCT: |
| break; |
| case TY_FUNC: |
| decodeTypeImp(buffer, pType->pHead); |
| break; |
| case TY_PARAM: |
| decodeTypeImp(buffer, pType->pHead); |
| break; |
| default: |
| String temp; |
| temp.printf("Unknown tag %d", pType->tag); |
| buffer.append(temp); |
| break; |
| } |
| } |
| |
| void decodeTypeImpPostfix(String& buffer, Type* pType) { |
| TypeTag tag = pType->tag; |
| |
| switch(tag) { |
| case TY_POINTER: |
| if(pType->pHead && pType->pHead->tag == TY_FUNC) { |
| buffer.append(')'); |
| } |
| decodeTypeImpPostfix(buffer, pType->pHead); |
| break; |
| case TY_ARRAY: |
| { |
| String temp; |
| temp.printf("[%d]", pType->length); |
| buffer.append(temp); |
| } |
| break; |
| case TY_STRUCT: |
| if (pType->pHead->length >= 0) { |
| buffer.appendCStr(" {"); |
| for(Type* pArg = pType->pTail; pArg; pArg = pArg->pTail) { |
| decodeTypeImp(buffer, pArg->pHead); |
| buffer.appendCStr(";"); |
| } |
| buffer.append('}'); |
| } |
| break; |
| case TY_FUNC: |
| buffer.append('('); |
| for(Type* pArg = pType->pTail; pArg; pArg = pArg->pTail) { |
| decodeTypeImp(buffer, pArg); |
| if (pArg->pTail) { |
| buffer.appendCStr(", "); |
| } |
| } |
| buffer.append(')'); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| void printType(Type* pType) { |
| String buffer; |
| decodeType(buffer, pType); |
| fprintf(stderr, "%s\n", buffer.getUnwrapped()); |
| } |
| |
| void insertTypeSpecifier(Type** ppType, TypeTag tag) { |
| if (! *ppType) { |
| *ppType = createType(tag, NULL, NULL); |
| } else { |
| if ((*ppType)->tag != TY_UNKNOWN) { |
| error("Only one type specifier allowed."); |
| } else { |
| (*ppType)->tag = tag; |
| } |
| } |
| } |
| |
| void insertStorageClass(Type** ppType, StorageClass storageClass) { |
| if (! *ppType) { |
| *ppType = createType(TY_UNKNOWN, NULL, NULL); |
| } |
| if ((*ppType)->storageClass != SC_DEFAULT) { |
| error("Only one storage class allowed."); |
| } else { |
| (*ppType)->storageClass = storageClass; |
| } |
| } |
| |
| Type* acceptPrimitiveType(bool allowStorageClass) { |
| Type* pType = NULL; |
| for (bool keepGoing = true; keepGoing;) { |
| switch(tok) { |
| case TOK_AUTO: |
| insertStorageClass(&pType, SC_AUTO); |
| break; |
| case TOK_REGISTER: |
| insertStorageClass(&pType, SC_REGISTER); |
| break; |
| case TOK_STATIC: |
| insertStorageClass(&pType, SC_STATIC); |
| break; |
| case TOK_EXTERN: |
| insertStorageClass(&pType, SC_EXTERN); |
| break; |
| case TOK_TYPEDEF: |
| insertStorageClass(&pType, SC_TYPEDEF); |
| break; |
| case TOK_INT: |
| insertTypeSpecifier(&pType, TY_INT); |
| break; |
| case TOK_SHORT: |
| insertTypeSpecifier(&pType, TY_SHORT); |
| break; |
| case TOK_CHAR: |
| insertTypeSpecifier(&pType, TY_CHAR); |
| break; |
| case TOK_VOID: |
| insertTypeSpecifier(&pType, TY_VOID); |
| break; |
| case TOK_FLOAT: |
| insertTypeSpecifier(&pType, TY_FLOAT); |
| break; |
| case TOK_DOUBLE: |
| insertTypeSpecifier(&pType, TY_DOUBLE); |
| break; |
| case TOK_STRUCT: |
| case TOK_UNION: |
| { |
| insertTypeSpecifier(&pType, TY_STRUCT); |
| bool isStruct = (tok == TOK_STRUCT); |
| next(); |
| pType = acceptStruct(pType, isStruct); |
| keepGoing = false; |
| } |
| break; |
| default: |
| // Is it a typedef? |
| if (isSymbol(tok)) { |
| VariableInfo* pV = VI(tok); |
| if (pV && pV->pType->storageClass == SC_TYPEDEF) { |
| if (! pType) { |
| pType = createType(TY_UNKNOWN, NULL, NULL); |
| } |
| StorageClass storageClass = pType->storageClass; |
| *pType = *pV->pType; |
| pType->storageClass = storageClass; |
| } else { |
| keepGoing = false; |
| } |
| } else { |
| keepGoing = false; |
| } |
| } |
| if (keepGoing) { |
| next(); |
| } |
| } |
| if (pType) { |
| if (pType->tag == TY_UNKNOWN) { |
| pType->tag = TY_INT; |
| } |
| if (allowStorageClass) { |
| switch(pType->storageClass) { |
| case SC_AUTO: error("auto not supported."); break; |
| case SC_REGISTER: error("register not supported."); break; |
| case SC_STATIC: error("static not supported."); break; |
| case SC_EXTERN: error("extern not supported."); break; |
| default: break; |
| } |
| } else { |
| if (pType->storageClass != SC_DEFAULT) { |
| error("An explicit storage class is not allowed in this type declaration"); |
| } |
| } |
| } |
| return pType; |
| } |
| |
| Type* acceptStruct(Type* pStructType, bool isStruct) { |
| tokenid_t structTag = acceptSymbol(); |
| bool isDeclaration = accept('{'); |
| bool fail = false; |
| |
| if (structTag) { |
| Token* pToken = &mTokenTable[structTag]; |
| VariableInfo* pStructInfo = pToken->mpStructInfo; |
| bool needToDeclare = !pStructInfo; |
| if (pStructInfo) { |
| if (isDeclaration) { |
| if (mpCurrentSymbolStack->isStructTagDefinedAtCurrentLevel(structTag)) { |
| if (pStructInfo->pType->pHead->length == -1) { |
| // we're filling in a forward declaration. |
| needToDeclare = false; |
| } else { |
| error("A struct with the same name is already defined at this level."); |
| fail = true; |
| } |
| } else { |
| needToDeclare = true; |
| } |
| } |
| if (!fail) { |
| assert(pStructInfo->isStructTag); |
| pStructType->pHead = pStructInfo->pType; |
| pStructType->pTail = pStructType->pHead->pTail; |
| } |
| } |
| |
| if (needToDeclare) { |
| // This is a new struct name |
| pToken->mpStructInfo = mpCurrentSymbolStack->addStructTag(structTag); |
| StorageClass storageClass = pStructType->storageClass; |
| pStructType = createType(TY_STRUCT, NULL, NULL); |
| pStructType->structTag = structTag; |
| pStructType->pHead = pStructType; |
| pStructType->storageClass = storageClass; |
| if (! isDeclaration) { |
| // A forward declaration |
| pStructType->length = -1; |
| } |
| pToken->mpStructInfo->pType = pStructType; |
| } |
| } else { |
| // An anonymous struct |
| pStructType->pHead = pStructType; |
| } |
| |
| if (isDeclaration) { |
| size_t offset = 0; |
| size_t structSize = 0; |
| size_t structAlignment = 0; |
| Type** pParamHolder = & pStructType->pHead->pTail; |
| while (tok != '}' && tok != EOF) { |
| Type* pPrimitiveType = expectPrimitiveType(false); |
| if (pPrimitiveType) { |
| while (tok != ';' && tok != EOF) { |
| Type* pItem = acceptDeclaration(pPrimitiveType, true, false); |
| if (!pItem) { |
| break; |
| } |
| if (lookupStructMember(pStructType, pItem->id)) { |
| String buf; |
| decodeToken(buf, pItem->id, false); |
| error("Duplicate struct member %s", buf.getUnwrapped()); |
| } |
| Type* pStructElement = createType(TY_PARAM, pItem, NULL); |
| size_t alignment = pGen->alignmentOf(pItem); |
| if (alignment > structAlignment) { |
| structAlignment = alignment; |
| } |
| size_t alignmentMask = alignment - 1; |
| offset = (offset + alignmentMask) & ~alignmentMask; |
| pStructElement->length = offset; |
| size_t size = pGen->sizeOf(pItem); |
| if (isStruct) { |
| offset += size; |
| structSize = offset; |
| } else { |
| if (size >= structSize) { |
| structSize = size; |
| } |
| } |
| *pParamHolder = pStructElement; |
| pParamHolder = &pStructElement->pTail; |
| accept(','); |
| } |
| skip(';'); |
| } else { |
| // Some sort of syntax error, skip token and keep trying |
| next(); |
| } |
| } |
| if (!fail) { |
| pStructType->pHead->length = structSize; |
| pStructType->pHead->alignment = structAlignment | (isStruct << 31); |
| } |
| skip('}'); |
| } |
| if (fail) { |
| pStructType = NULL; |
| } |
| return pStructType; |
| } |
| |
| Type* lookupStructMember(Type* pStruct, tokenid_t memberId) { |
| for(Type* pStructElement = pStruct->pHead->pTail; pStructElement; pStructElement = pStructElement->pTail) { |
| if (pStructElement->pHead->id == memberId) { |
| return pStructElement; |
| } |
| } |
| return NULL; |
| } |
| |
| Type* acceptDeclaration(Type* pType, bool nameAllowed, bool nameRequired) { |
| tokenid_t declName = 0; |
| bool reportFailure = false; |
| StorageClass storageClass = pType->storageClass; |
| pType = acceptDecl2(pType, declName, nameAllowed, |
| nameRequired, reportFailure); |
| if (declName) { |
| // Clone the parent type so we can set a unique ID |
| Type* pOldType = pType; |
| pType = createType(pType->tag, pType->pHead, pType->pTail); |
| *pType = *pOldType; |
| pType->id = declName; |
| pType->storageClass = storageClass; |
| } else if (nameRequired) { |
| error("Expected a variable name"); |
| } |
| #if 0 |
| fprintf(stderr, "Parsed a declaration: "); |
| printType(pType); |
| #endif |
| if (reportFailure) { |
| return NULL; |
| } |
| return pType; |
| } |
| |
| Type* expectDeclaration(Type* pBaseType) { |
| bool nameRequired = pBaseType->tag != TY_STRUCT; |
| Type* pType = acceptDeclaration(pBaseType, true, nameRequired); |
| if (! pType) { |
| error("Expected a declaration"); |
| } |
| return pType; |
| } |
| |
| /* Used for accepting types that appear in casts */ |
| Type* acceptCastTypeDeclaration() { |
| Type* pType = acceptPrimitiveType(false); |
| if (pType) { |
| pType = acceptDeclaration(pType, false, false); |
| } |
| return pType; |
| } |
| |
| Type* expectCastTypeDeclaration() { |
| Type* pType = acceptCastTypeDeclaration(); |
| if (! pType) { |
| error("Expected a declaration"); |
| } |
| return pType; |
| } |
| |
| Type* acceptDecl2(Type* pType, tokenid_t& declName, |
| bool nameAllowed, bool nameRequired, |
| bool& reportFailure) { |
| while (accept('*')) { |
| pType = createType(TY_POINTER, pType, NULL); |
| } |
| pType = acceptDecl3(pType, declName, nameAllowed, nameRequired, |
| reportFailure); |
| return pType; |
| } |
| |
| Type* acceptDecl3(Type* pType, tokenid_t& declName, |
| bool nameAllowed, bool nameRequired, |
| bool& reportFailure) { |
| // direct-dcl : |
| // name |
| // (dcl) |
| // direct-dcl() |
| // direct-dcl[] |
| Type* pNewHead = NULL; |
| if (accept('(')) { |
| pNewHead = acceptDecl2(pNewHead, declName, nameAllowed, |
| nameRequired, reportFailure); |
| skip(')'); |
| } else if ((declName = acceptSymbol()) != 0) { |
| if (nameAllowed == false && declName) { |
| error("Symbol %s not allowed here", nameof(declName)); |
| reportFailure = true; |
| } |
| } else if (nameRequired && ! declName) { |
| String temp; |
| decodeToken(temp, tok, true); |
| error("Expected name. Got %s", temp.getUnwrapped()); |
| reportFailure = true; |
| } |
| for(;;) { |
| if (accept('(')) { |
| // Function declaration |
| Type* pTail = acceptArgs(nameAllowed); |
| pType = createType(TY_FUNC, pType, pTail); |
| skip(')'); |
| } if (accept('[')) { |
| if (tok != ']') { |
| if (tok != TOK_NUM || tokc <= 0) { |
| error("Expected positive integer constant"); |
| } else { |
| Type* pDecayType = createPtrType(pType); |
| pType = createType(TY_ARRAY, pType, pDecayType); |
| pType->length = tokc; |
| } |
| next(); |
| } |
| skip(']'); |
| } else { |
| break; |
| } |
| } |
| |
| if (pNewHead) { |
| Type* pA = pNewHead; |
| while (pA->pHead) { |
| pA = pA->pHead; |
| } |
| pA->pHead = pType; |
| pType = pNewHead; |
| } |
| return pType; |
| } |
| |
| Type* acceptArgs(bool nameAllowed) { |
| Type* pHead = NULL; |
| Type* pTail = NULL; |
| for(;;) { |
| Type* pBaseArg = acceptPrimitiveType(false); |
| if (pBaseArg) { |
| Type* pArg = acceptDeclaration(pBaseArg, nameAllowed, false); |
| if (pArg) { |
| Type* pParam = createType(TY_PARAM, pArg, NULL); |
| if (!pHead) { |
| pHead = pParam; |
| pTail = pParam; |
| } else { |
| pTail->pTail = pParam; |
| pTail = pParam; |
| } |
| } |
| } |
| if (! accept(',')) { |
| break; |
| } |
| } |
| return pHead; |
| } |
| |
| Type* expectPrimitiveType(bool allowStorageClass) { |
| Type* pType = acceptPrimitiveType(allowStorageClass); |
| if (!pType) { |
| String buf; |
| decodeToken(buf, tok, true); |
| error("Expected a type, got %s", buf.getUnwrapped()); |
| } |
| return pType; |
| } |
| |
| void checkLVal() { |
| if (pGen->getR0ExpressionType() != ET_LVALUE) { |
| error("Expected an lvalue"); |
| } |
| } |
| |
| void addGlobalSymbol(Type* pDecl) { |
| tokenid_t t = pDecl->id; |
| VariableInfo* pVI = VI(t); |
| if(pVI && pVI->pAddress) { |
| reportDuplicate(t); |
| } |
| mGlobals.add(pDecl); |
| } |
| |
| void reportDuplicate(tokenid_t t) { |
| error("Duplicate definition of %s", nameof(t)); |
| } |
| |
| void addLocalSymbol(Type* pDecl) { |
| tokenid_t t = pDecl->id; |
| if (mLocals.isDefinedAtCurrentLevel(t)) { |
| reportDuplicate(t); |
| } |
| mLocals.add(pDecl); |
| } |
| |
| bool checkUndeclaredStruct(Type* pBaseType) { |
| if (pBaseType->tag == TY_STRUCT && pBaseType->length < 0) { |
| String temp; |
| decodeToken(temp, pBaseType->structTag, false); |
| error("Undeclared struct %s", temp.getUnwrapped()); |
| return true; |
| } |
| return false; |
| } |
| |
| void localDeclarations(Type* pBaseType) { |
| intptr_t a; |
| |
| while (pBaseType) { |
| while (tok != ';' && tok != EOF) { |
| Type* pDecl = expectDeclaration(pBaseType); |
| if (!pDecl) { |
| break; |
| } |
| if (!pDecl->id) { |
| break; |
| } |
| if (checkUndeclaredStruct(pDecl)) { |
| break; |
| } |
| addLocalSymbol(pDecl); |
| if (pDecl->tag == TY_FUNC) { |
| if (tok == '{') { |
| error("Nested functions are not allowed. Did you forget a '}' ?"); |
| break; |
| } |
| // Else it's a forward declaration of a function. |
| } else if (pDecl->storageClass != SC_TYPEDEF) { |
| int variableAddress = 0; |
| size_t alignment = pGen->alignmentOf(pDecl); |
| assert(alignment > 0); |
| size_t alignmentMask = ~ (alignment - 1); |
| size_t sizeOf = pGen->sizeOf(pDecl); |
| assert(sizeOf > 0); |
| loc = (loc + alignment - 1) & alignmentMask; |
| size_t alignedSize = (sizeOf + alignment - 1) & alignmentMask; |
| loc = loc + alignedSize; |
| variableAddress = -loc; |
| VI(pDecl->id)->pAddress = (void*) variableAddress; |
| if (accept('=')) { |
| /* assignment */ |
| pGen->leaR0(variableAddress, createPtrType(pDecl), ET_LVALUE); |
| pGen->pushR0(); |
| expr(); |
| pGen->forceR0RVal(); |
| pGen->storeR0ToTOS(); |
| } |
| } |
| if (tok == ',') |
| next(); |
| } |
| skip(';'); |
| pBaseType = acceptPrimitiveType(true); |
| } |
| } |
| |
| bool checkSymbol() { |
| return checkSymbol(tok); |
| } |
| |
| void decodeToken(String& buffer, tokenid_t token, bool quote) { |
| if (token == EOF ) { |
| buffer.printf("EOF"); |
| } else if (token == TOK_NUM) { |
| buffer.printf("numeric constant %d(0x%x)", tokc, tokc); |
| } else if (token == TOK_NUM_FLOAT) { |
| buffer.printf("numeric constant float %g", tokd); |
| } else if (token == TOK_NUM_DOUBLE) { |
| buffer.printf("numeric constant double %g", tokd); |
| } else if (token >= 0 && token < 256) { |
| if (token < 32) { |
| buffer.printf("'\\x%02x'", token); |
| } else { |
| buffer.printf("'%c'", token); |
| } |
| } else { |
| if (quote) { |
| if (token >= TOK_KEYWORD && token < TOK_SYMBOL) { |
| buffer.printf("keyword \"%s\"", nameof(token)); |
| } else { |
| buffer.printf("symbol \"%s\"", nameof(token)); |
| } |
| } else { |
| buffer.printf("%s", nameof(token)); |
| } |
| } |
| } |
| |
| void printToken(tokenid_t token) { |
| String buffer; |
| decodeToken(buffer, token, true); |
| fprintf(stderr, "%s\n", buffer.getUnwrapped()); |
| } |
| |
| bool checkSymbol(tokenid_t token) { |
| bool result = token >= TOK_SYMBOL; |
| if (!result) { |
| String temp; |
| decodeToken(temp, token, true); |
| error("Expected symbol. Got %s", temp.getUnwrapped()); |
| } |
| return result; |
| } |
| |
| tokenid_t acceptSymbol() { |
| tokenid_t result = 0; |
| if (tok >= TOK_SYMBOL) { |
| result = tok; |
| next(); |
| } |
| return result; |
| } |
| |
| void globalDeclarations() { |
| mpCurrentSymbolStack = &mGlobals; |
| while (tok != EOF) { |
| Type* pBaseType = expectPrimitiveType(true); |
| if (!pBaseType) { |
| break; |
| } |
| Type* pDecl = expectDeclaration(pBaseType); |
| if (!pDecl) { |
| break; |
| } |
| if (!pDecl->id) { |
| skip(';'); |
| continue; |
| } |
| |
| if (checkUndeclaredStruct(pDecl)) { |
| skip(';'); |
| continue; |
| } |
| if (! isDefined(pDecl->id)) { |
| addGlobalSymbol(pDecl); |
| } |
| VariableInfo* name = VI(pDecl->id); |
| if (name && name->pAddress) { |
| error("Already defined global %s", nameof(pDecl->id)); |
| } |
| if (pDecl->tag < TY_FUNC) { |
| // it's a variable declaration |
| for(;;) { |
| if (pDecl->storageClass == SC_TYPEDEF) { |
| // Do not allocate storage. |
| } else { |
| if (name && !name->pAddress) { |
| name->pAddress = (int*) allocGlobalSpace( |
| pGen->alignmentOf(name->pType), |
| pGen->sizeOf(name->pType)); |
| } |
| if (accept('=')) { |
| if (tok == TOK_NUM) { |
| if (name) { |
| * (int*) name->pAddress = tokc; |
| } |
| next(); |
| } else { |
| error("Expected an integer constant"); |
| } |
| } |
| } |
| if (!accept(',')) { |
| break; |
| } |
| pDecl = expectDeclaration(pBaseType); |
| if (!pDecl) { |
| break; |
| } |
| if (! isDefined(pDecl->id)) { |
| addGlobalSymbol(pDecl); |
| } |
| name = VI(pDecl->id); |
| } |
| skip(';'); |
| } else { |
| // Function declaration |
| if (accept(';')) { |
| // forward declaration. |
| } else if (tok != '{') { |
| error("expected '{'"); |
| } else { |
| mpCurrentArena = &mLocalArena; |
| mpCurrentSymbolStack = &mLocals; |
| if (name) { |
| /* patch forward references */ |
| pGen->resolveForward((int) name->pForward); |
| /* put function address */ |
| name->pAddress = (void*) pCodeBuf->getPC(); |
| } |
| // Calculate stack offsets for parameters |
| mLocals.pushLevel(); |
| intptr_t a = 8; |
| int argCount = 0; |
| for (Type* pP = pDecl->pTail; pP; pP = pP->pTail) { |
| Type* pArg = pP->pHead; |
| if (pArg->id) { |
| addLocalSymbol(pArg); |
| } |
| /* read param name and compute offset */ |
| Type* pPassingType = passingType(pArg); |
| size_t alignment = pGen->alignmentOf(pPassingType); |
| a = (a + alignment - 1) & ~ (alignment-1); |
| if (pArg->id) { |
| VI(pArg->id)->pAddress = (void*) a; |
| } |
| a = a + pGen->sizeOf(pPassingType); |
| argCount++; |
| } |
| rsym = loc = 0; |
| pReturnType = pDecl->pHead; |
| a = pGen->functionEntry(pDecl); |
| block(0, 0, true); |
| pGen->gsym(rsym); |
| pGen->functionExit(pDecl, a, loc); |
| mLocals.popLevel(); |
| mpCurrentArena = &mGlobalArena; |
| mpCurrentSymbolStack = &mGlobals; |
| } |
| } |
| } |
| } |
| |
| Type* passingType(Type* pType) { |
| switch (pType->tag) { |
| case TY_CHAR: |
| case TY_SHORT: |
| return mkpInt; |
| default: |
| return pType; |
| } |
| } |
| |
| char* allocGlobalSpace(size_t alignment, size_t bytes) { |
| size_t base = (((size_t) glo) + alignment - 1) & ~(alignment-1); |
| size_t end = base + bytes; |
| if ((end - (size_t) pGlobalBase) > (size_t) ALLOC_SIZE) { |
| error("Global space exhausted"); |
| assert(false); |
| return NULL; |
| } |
| char* result = (char*) base; |
| glo = (char*) end; |
| return result; |
| } |
| |
| void cleanup() { |
| if (pGlobalBase != 0) { |
| free(pGlobalBase); |
| pGlobalBase = 0; |
| } |
| if (pGen) { |
| delete pGen; |
| pGen = 0; |
| } |
| if (pCodeBuf) { |
| delete pCodeBuf; |
| pCodeBuf = 0; |
| } |
| if (file) { |
| delete file; |
| file = 0; |
| } |
| } |
| |
| // One-time initialization, when class is constructed. |
| void init() { |
| mpSymbolLookupFn = 0; |
| mpSymbolLookupContext = 0; |
| } |
| |
| void clear() { |
| tok = 0; |
| tokc = 0; |
| tokl = 0; |
| ch = 0; |
| rsym = 0; |
| loc = 0; |
| glo = 0; |
| macroLevel = -1; |
| file = 0; |
| pGlobalBase = 0; |
| pCodeBuf = 0; |
| pGen = 0; |
| mPragmaStringCount = 0; |
| mCompileResult = 0; |
| mLineNumber = 1; |
| mbBumpLine = false; |
| mbSuppressMacroExpansion = false; |
| } |
| |
| void setArchitecture(const char* architecture) { |
| delete pGen; |
| pGen = 0; |
| |
| delete pCodeBuf; |
| pCodeBuf = new CodeBuf(); |
| |
| if (architecture != NULL) { |
| #ifdef PROVIDE_ARM_CODEGEN |
| if (! pGen && strcmp(architecture, "arm") == 0) { |
| pGen = new ARMCodeGenerator(); |
| pCodeBuf = new ARMCodeBuf(pCodeBuf); |
| } |
| #endif |
| #ifdef PROVIDE_X86_CODEGEN |
| if (! pGen && strcmp(architecture, "x86") == 0) { |
| pGen = new X86CodeGenerator(); |
| } |
| #endif |
| if (!pGen ) { |
| error("Unknown architecture %s\n", architecture); |
| } |
| } |
| |
| if (pGen == NULL) { |
| #if defined(DEFAULT_ARM_CODEGEN) |
| pGen = new ARMCodeGenerator(); |
| pCodeBuf = new ARMCodeBuf(pCodeBuf); |
| #elif defined(DEFAULT_X86_CODEGEN) |
| pGen = new X86CodeGenerator(); |
| #endif |
| } |
| if (pGen == NULL) { |
| error("No code generator defined."); |
| } else { |
| pGen->setErrorSink(this); |
| pGen->setTypes(mkpInt); |
| } |
| } |
| |
| public: |
| struct args { |
| args() { |
| architecture = 0; |
| } |
| const char* architecture; |
| }; |
| |
| Compiler() { |
| init(); |
| clear(); |
| } |
| |
| ~Compiler() { |
| cleanup(); |
| } |
| |
| void registerSymbolCallback(ACCSymbolLookupFn pFn, ACCvoid* pContext) { |
| mpSymbolLookupFn = pFn; |
| mpSymbolLookupContext = pContext; |
| } |
| |
| int compile(const char* text, size_t textLength) { |
| int result; |
| |
| mpCurrentArena = &mGlobalArena; |
| createPrimitiveTypes(); |
| cleanup(); |
| clear(); |
| mTokenTable.setArena(&mGlobalArena); |
| mGlobals.setArena(&mGlobalArena); |
| mGlobals.setTokenTable(&mTokenTable); |
| mLocals.setArena(&mLocalArena); |
| mLocals.setTokenTable(&mTokenTable); |
| |
| internKeywords(); |
| setArchitecture(NULL); |
| if (!pGen) { |
| return -1; |
| } |
| #ifdef PROVIDE_TRACE_CODEGEN |
| pGen = new TraceCodeGenerator(pGen); |
| #endif |
| pGen->setErrorSink(this); |
| |
| if (pCodeBuf) { |
| pCodeBuf->init(ALLOC_SIZE); |
| } |
| pGen->init(pCodeBuf); |
| file = new TextInputStream(text, textLength); |
| pGlobalBase = (char*) calloc(1, ALLOC_SIZE); |
| glo = pGlobalBase; |
| inp(); |
| next(); |
| globalDeclarations(); |
| checkForUndefinedForwardReferences(); |
| result = pGen->finishCompile(); |
| if (result == 0) { |
| if (mErrorBuf.len()) { |
| result = -2; |
| } |
| } |
| mCompileResult = result; |
| return result; |
| } |
| |
| void createPrimitiveTypes() { |
| mkpInt = createType(TY_INT, NULL, NULL); |
| mkpShort = createType(TY_SHORT, NULL, NULL); |
| mkpChar = createType(TY_CHAR, NULL, NULL); |
| mkpVoid = createType(TY_VOID, NULL, NULL); |
| mkpFloat = createType(TY_FLOAT, NULL, NULL); |
| mkpDouble = createType(TY_DOUBLE, NULL, NULL); |
| mkpIntFn = createType(TY_FUNC, mkpInt, NULL); |
| mkpIntPtr = createPtrType(mkpInt); |
| mkpCharPtr = createPtrType(mkpChar); |
| mkpFloatPtr = createPtrType(mkpFloat); |
| mkpDoublePtr = createPtrType(mkpDouble); |
| mkpPtrIntFn = createPtrType(mkpIntFn); |
| } |
| |
| void checkForUndefinedForwardReferences() { |
| mGlobals.forEach(static_ufrcFn, this); |
| } |
| |
| static bool static_ufrcFn(VariableInfo* value, void* context) { |
| Compiler* pCompiler = (Compiler*) context; |
| return pCompiler->undefinedForwardReferenceCheck(value); |
| } |
| |
| bool undefinedForwardReferenceCheck(VariableInfo* value) { |
| if (!value->pAddress && value->pForward) { |
| error("Undefined forward reference: %s", |
| mTokenTable[value->tok].pText); |
| } |
| return true; |
| } |
| |
| /* Look through the symbol table to find a symbol. |
| * If found, return its value. |
| */ |
| void* lookup(const char* name) { |
| if (mCompileResult == 0) { |
| tokenid_t tok = mTokenTable.intern(name, strlen(name)); |
| VariableInfo* pVariableInfo = VI(tok); |
| if (pVariableInfo) { |
| return pVariableInfo->pAddress; |
| } |
| } |
| return NULL; |
| } |
| |
| void getPragmas(ACCsizei* actualStringCount, |
| ACCsizei maxStringCount, ACCchar** strings) { |
| int stringCount = mPragmaStringCount; |
| if (actualStringCount) { |
| *actualStringCount = stringCount; |
| } |
| if (stringCount > maxStringCount) { |
| stringCount = maxStringCount; |
| } |
| if (strings) { |
| char* pPragmas = mPragmas.getUnwrapped(); |
| while (stringCount-- > 0) { |
| *strings++ = pPragmas; |
| pPragmas += strlen(pPragmas) + 1; |
| } |
| } |
| } |
| |
| void getProgramBinary(ACCvoid** base, ACCsizei* length) { |
| *base = pCodeBuf->getBase(); |
| *length = (ACCsizei) pCodeBuf->getSize(); |
| } |
| |
| char* getErrorMessage() { |
| return mErrorBuf.getUnwrapped(); |
| } |
| }; |
| |
| const char* Compiler::operatorChars = |
| "++--*@/@%@+@-@<<>><=>=<@>@==!=&&||&@^@|@~@!@"; |
| |
| const char Compiler::operatorLevel[] = |
| {11, 11, 1, 1, 1, 2, 2, 3, 3, 4, 4, 4, 4, |
| 5, 5, /* ==, != */ |
| 9, 10, /* &&, || */ |
| 6, 7, 8, /* & ^ | */ |
| 2, 2 /* ~ ! */ |
| }; |
| |
| #ifdef PROVIDE_X86_CODEGEN |
| const int Compiler::X86CodeGenerator::operatorHelper[] = { |
| 0x1, // ++ |
| 0xff, // -- |
| 0xc1af0f, // * |
| 0xf9f79991, // / |
| 0xf9f79991, // % (With manual assist to swap results) |
| 0xc801, // + |
| 0xd8f7c829, // - |
| 0xe0d391, // << |
| 0xf8d391, // >> |
| 0xe, // <= |
| 0xd, // >= |
| 0xc, // < |
| 0xf, // > |
| 0x4, // == |
| 0x5, // != |
| 0x0, // && |
| 0x1, // || |
| 0xc821, // & |
| 0xc831, // ^ |
| 0xc809, // | |
| 0xd0f7, // ~ |
| 0x4 // ! |
| }; |
| #endif |
| |
| struct ACCscript { |
| ACCscript() { |
| text = 0; |
| textLength = 0; |
| accError = ACC_NO_ERROR; |
| } |
| |
| ~ACCscript() { |
| delete text; |
| } |
| |
| void registerSymbolCallback(ACCSymbolLookupFn pFn, ACCvoid* pContext) { |
| compiler.registerSymbolCallback(pFn, pContext); |
| } |
| |
| void setError(ACCenum error) { |
| if (accError == ACC_NO_ERROR && error != ACC_NO_ERROR) { |
| accError = error; |
| } |
| } |
| |
| ACCenum getError() { |
| ACCenum result = accError; |
| accError = ACC_NO_ERROR; |
| return result; |
| } |
| |
| Compiler compiler; |
| char* text; |
| int textLength; |
| ACCenum accError; |
| }; |
| |
| |
| extern "C" |
| ACCscript* accCreateScript() { |
| return new ACCscript(); |
| } |
| |
| extern "C" |
| ACCenum accGetError( ACCscript* script ) { |
| return script->getError(); |
| } |
| |
| extern "C" |
| void accDeleteScript(ACCscript* script) { |
| delete script; |
| } |
| |
| extern "C" |
| void accRegisterSymbolCallback(ACCscript* script, ACCSymbolLookupFn pFn, |
| ACCvoid* pContext) { |
| script->registerSymbolCallback(pFn, pContext); |
| } |
| |
| extern "C" |
| void accScriptSource(ACCscript* script, |
| ACCsizei count, |
| const ACCchar ** string, |
| const ACCint * length) { |
| int totalLength = 0; |
| for(int i = 0; i < count; i++) { |
| int len = -1; |
| const ACCchar* s = string[i]; |
| if (length) { |
| len = length[i]; |
| } |
| if (len < 0) { |
| len = strlen(s); |
| } |
| totalLength += len; |
| } |
| delete script->text; |
| char* text = new char[totalLength + 1]; |
| script->text = text; |
| script->textLength = totalLength; |
| char* dest = text; |
| for(int i = 0; i < count; i++) { |
| int len = -1; |
| const ACCchar* s = string[i]; |
| if (length) { |
| len = length[i]; |
| } |
| if (len < 0) { |
| len = strlen(s); |
| } |
| memcpy(dest, s, len); |
| dest += len; |
| } |
| text[totalLength] = '\0'; |
| |
| #ifdef DEBUG_SAVE_INPUT_TO_FILE |
| LOGD("Saving input to file..."); |
| int counter; |
| char path[PATH_MAX]; |
| for (counter = 0; counter < 4096; counter++) { |
| sprintf(path, DEBUG_DUMP_PATTERN, counter); |
| if(access(path, F_OK) != 0) { |
| break; |
| } |
| } |
| if (counter < 4096) { |
| LOGD("Saving input to file %s", path); |
| FILE* fd = fopen(path, "w"); |
| if (fd) { |
| fwrite(text, totalLength, 1, fd); |
| fclose(fd); |
| LOGD("Saved input to file %s", path); |
| } else { |
| LOGD("Could not save. errno: %d", errno); |
| } |
| } |
| #endif |
| } |
| |
| extern "C" |
| void accCompileScript(ACCscript* script) { |
| int result = script->compiler.compile(script->text, script->textLength); |
| if (result) { |
| script->setError(ACC_INVALID_OPERATION); |
| } |
| } |
| |
| extern "C" |
| void accGetScriptiv(ACCscript* script, |
| ACCenum pname, |
| ACCint * params) { |
| switch (pname) { |
| case ACC_INFO_LOG_LENGTH: |
| *params = 0; |
| break; |
| } |
| } |
| |
| extern "C" |
| void accGetScriptInfoLog(ACCscript* script, |
| ACCsizei maxLength, |
| ACCsizei * length, |
| ACCchar * infoLog) { |
| char* message = script->compiler.getErrorMessage(); |
| int messageLength = strlen(message) + 1; |
| if (length) { |
| *length = messageLength; |
| } |
| if (infoLog && maxLength > 0) { |
| int trimmedLength = maxLength < messageLength ? |
| maxLength : messageLength; |
| memcpy(infoLog, message, trimmedLength); |
| infoLog[trimmedLength] = 0; |
| } |
| } |
| |
| extern "C" |
| void accGetScriptLabel(ACCscript* script, const ACCchar * name, |
| ACCvoid ** address) { |
| void* value = script->compiler.lookup(name); |
| if (value) { |
| *address = value; |
| } else { |
| script->setError(ACC_INVALID_VALUE); |
| } |
| } |
| |
| extern "C" |
| void accGetPragmas(ACCscript* script, ACCsizei* actualStringCount, |
| ACCsizei maxStringCount, ACCchar** strings){ |
| script->compiler.getPragmas(actualStringCount, maxStringCount, strings); |
| } |
| |
| extern "C" |
| void accGetProgramBinary(ACCscript* script, |
| ACCvoid** base, ACCsizei* length) { |
| script->compiler.getProgramBinary(base, length); |
| } |
| |
| |
| } // namespace acc |
| |