[ { "path": ".ci/check-format.sh", "content": "#!/usr/bin/env bash\n\nSOURCES=$(find $(git rev-parse --show-toplevel) | egrep \"\\.(c|cxx|cpp|h|hpp)\\$\")\n\nset -x\n\nfor file in ${SOURCES};\ndo\n clang-format-18 ${file} > expected-format\n diff -u -p --label=\"${file}\" --label=\"expected coding style\" ${file} expected-format\ndone\nexit $(clang-format-18 --output-replacements-xml ${SOURCES} | egrep -c \"\")\n" }, { "path": ".ci/check-newline.sh", "content": "#!/usr/bin/env bash\n\nret=0\nshow=0\n# Reference: https://medium.com/@alexey.inkin/how-to-force-newline-at-end-of-files-and-why-you-should-do-it-fdf76d1d090e\nwhile IFS= read -rd '' f; do\n if file --mime-encoding \"$f\" | grep -qv binary; then\n tail -c1 < \"$f\" | read -r _ || show=1\n if [ $show -eq 1 ]; then\n echo \"Warning: No newline at end of file $f\"\n ret=1\n show=0\n fi\n fi\ndone < <(git ls-files -z src tools tests)\n\nexit $ret\n" }, { "path": ".clang-format", "content": "BasedOnStyle: Chromium\nLanguage: Cpp\nMaxEmptyLinesToKeep: 3\nIndentCaseLabels: false\nAllowShortIfStatementsOnASingleLine: false\nAllowShortCaseLabelsOnASingleLine: false\nAllowShortLoopsOnASingleLine: false\nDerivePointerAlignment: false\nPointerAlignment: Right\nSpaceAfterCStyleCast: true\nTabWidth: 4\nUseTab: Never\nIndentWidth: 4\nBreakBeforeBraces: Linux\nAccessModifierOffset: -4\nForEachMacros:\n - foreach\n - list_for_each\n - list_for_each_safe\n - list_for_each_entry\n - list_for_each_entry_safe\n" }, { "path": ".github/workflows/main.yml", "content": "name: Github Actions\n\non: [push, pull_request]\n\njobs:\n host-x86:\n runs-on: ubuntu-24.04\n strategy:\n matrix:\n compiler: [gcc, clang]\n architecture: [arm, riscv]\n link_mode: [static]\n include:\n - compiler: gcc\n architecture: arm\n link_mode: dynamic\n - compiler: clang\n architecture: arm\n link_mode: dynamic\n steps:\n - name: Checkout code\n uses: actions/checkout@v4\n - name: Download dependencies\n run: |\n sudo apt-get update -q -y\n sudo apt-get install -q -y graphviz jq\n sudo apt-get install -q -y qemu-user\n sudo apt-get install -q -y build-essential\n sudo apt-get install -q -y gcc-arm-linux-gnueabihf\n - name: Determine static or dynamic linking mode\n id: determine-mode\n run: |\n if [ \"${{ matrix.link_mode }}\" = \"dynamic\" ]; then\n echo \"Use dynamic linking mode\"\n echo \"DYNLINK=1\" >> \"$GITHUB_OUTPUT\"\n else\n echo \"Use static linking mode\"\n echo \"DYNLINK=0\" >> \"$GITHUB_OUTPUT\"\n fi\n - name: Build artifacts\n env:\n CC: ${{ matrix.compiler }}\n run: |\n make ARCH=${{ matrix.architecture }} DYNLINK=${{ steps.determine-mode.outputs.DYNLINK }}\n - name: IR regression tests\n run: |\n make check-snapshot DYNLINK=${{ steps.determine-mode.outputs.DYNLINK }} || exit 1\n - name: Sanitizer-enabled stage 0 tests\n env:\n CC: ${{ matrix.compiler }}\n run: |\n make check-sanitizer DYNLINK=${{ steps.determine-mode.outputs.DYNLINK }} || exit 1\n - name: Unit tests\n run: |\n make check DYNLINK=${{ steps.determine-mode.outputs.DYNLINK }} || exit 1\n\n host-arm:\n runs-on: ubuntu-24.04-arm\n strategy:\n matrix:\n link_mode: [static, dynamic]\n steps:\n - name: Checkout code\n uses: actions/checkout@v4\n\n - name: Download dependencies\n run: |\n sudo dpkg --add-architecture armhf\n sudo apt-get update -q -y\n sudo apt-get install -q -y graphviz jq\n sudo apt-get install -q -y build-essential libc6:armhf\n sudo wget https://github.com/fastfetch-cli/fastfetch/releases/download/2.58.0/fastfetch-linux-aarch64.deb\n sudo dpkg -i fastfetch-linux-aarch64.deb\n\n - name: Determine static or dynamic linking mode\n id: determine-mode\n run: |\n if [ \"${{ matrix.link_mode }}\" = \"dynamic\" ]; then\n echo \"Use dynamic linking mode\"\n echo \"DYNLINK=1\" >> \"$GITHUB_OUTPUT\"\n else\n echo \"Use static linking mode\"\n echo \"DYNLINK=0\" >> \"$GITHUB_OUTPUT\"\n fi\n\n - name: Build artifacts\n run: |\n make ARCH=arm DYNLINK=${{ steps.determine-mode.outputs.DYNLINK }}\n\n - name: Sanitizer-enabled stage 0 tests\n run: |\n make check-sanitizer DYNLINK=${{ steps.determine-mode.outputs.DYNLINK }} || exit 1\n\n - name: Unit tests\n run: |\n make check DYNLINK=${{ steps.determine-mode.outputs.DYNLINK }} || exit 1\n\n preprocessor-host:\n runs-on: ubuntu-24.04\n strategy:\n matrix:\n compiler: [gcc, clang]\n architecture: [arm, riscv]\n steps:\n - name: Checkout code\n uses: actions/checkout@v4\n - name: Download dependencies\n run: |\n sudo apt-get update -q -y\n sudo apt-get install -q -y graphviz jq\n sudo apt-get install -q -y qemu-user\n sudo apt-get install -q -y build-essential\n - name: Configurate config\n run: |\n make distclean config ARCH=${{ matrix.architecture }}\n - name: Preprocess stage 1 source code\n env:\n CC: ${{ matrix.compiler }}\n run: |\n make out/shecc\n ./out/shecc -E src/main.c > ./out/out.c\n - name: Build stage 1 artifact\n run: |\n ./out/shecc --no-libc -o out/shecc-stage1.elf ./out/out.c\n\n coding-style:\n runs-on: ubuntu-24.04\n steps:\n - uses: actions/checkout@v4\n - name: Coding convention\n run: |\n sudo apt-get install -q -y clang-format-18\n .ci/check-newline.sh\n .ci/check-format.sh\n shell: bash\n" }, { "path": ".gitignore", "content": "out\na.out\n*.o\n*.elf\n*.log\n*.lst\n*.dot\nconfig\nsrc/codegen.c\n.session.mk\n\n# vscode C/C++ plugin generated files\n.vscode\n" }, { "path": "AUTHORS", "content": "shecc is written by:\n Jim Huang \n Yu-Cheng Cheng \n Lecopzer Chen \n Vacantron Chen \n Matt Jan \n Alex Lai \n Chin Yik Ming \n Hank Wang \n Kyle Lin \n Yu En Siao \n Meng-Zong Tsai \n Kuan-Wei Chiu \n Yu-Hui Wu \n" }, { "path": "COMPLIANCE.md", "content": "# C99 Compliance Status\n\nshecc implements a subset of C99 suitable for self-hosting and systems programming,\nprioritizing simplicity, educational value, and minimal dependencies over full standard compliance.\nThis document tracks compliance gaps and non-standard behaviors.\n\n## Implemented Features\n\n### Core Language\n- Basic types: `int`, `short`, `char`, `void`, `_Bool`\n- Structures and unions with nested definitions\n- Enumerations with automatic value assignment\n- Function definitions and declarations\n- Arrays (single and multi-dimensional)\n- Pointers and pointer arithmetic (fully C99-compliant)\n- Type definitions (`typedef`)\n\n### Control Flow\n- `if`/`else` statements\n- `goto` and label statements\n- `while`, `do-while`, `for` loops\n- `switch`/`case`/`default` statements\n- `break`, `continue`, `return` statements\n\n### Operators\n- Arithmetic: `+`, `-`, `*`, `/`, `%`\n- Bitwise: `&`, `|`, `^`, `~`, `<<`, `>>`\n- Logical: `&&`, `||`, `!`\n- Relational: `<`, `>`, `<=`, `>=`, `==`, `!=`\n- Assignment: `=`, `+=`, `-=`, `*=`, `/=`, `%=`, `<<=`, `>>=`, `&=`, `|=`, `^=`\n- Increment/decrement: `++`, `--` (prefix and postfix)\n- Conditional: `? :`\n- Member access: `.`, `->`\n- Address/dereference: `&`, `*`\n\n### Preprocessor (Partial)\n- `#define` for object-like and function-like macros\n- `#ifdef`, `#ifndef`, `#if`, `#elif`, `#else`, `#endif`\n- `#undef` for macro removal\n- `#pragma once`, other `#pragma` options will be ignored\n- `defined()` operator\n- `__VA_ARGS__` for variadic macros\n- `__FILE__`, `__LINE__` built-in macros\n\n## Missing Features\n\n### Storage Classes & Qualifiers\n\n| Feature | Status | Impact |\n|---------|--------|--------|\n| `static` | Not implemented | No internal linkage or persistent local variables |\n| `extern` | Not implemented | No external linkage declarations |\n| `register` | Not implemented | No register hint optimization |\n| `auto` | Not implemented | Default storage class (implicit) |\n| `const` | Parsed but ignored | No read-only enforcement |\n| `volatile` | Not implemented | No volatile semantics |\n| `restrict` | Not implemented | No pointer aliasing optimization |\n| `inline` | Not implemented | No function inlining |\n\n### Type System\n\n| Feature | Status | Notes |\n|---------|--------|-------|\n| `long` | Missing | Only 4-byte integers |\n| `long long` | Missing | No 64-bit integers |\n| `unsigned` | Missing | All integers are signed |\n| `signed` | Missing | Implicit for integers |\n| `float` | Missing | No floating-point support |\n| `double` | Missing | No floating-point support |\n| `long double` | Missing | No floating-point support |\n| Bit-fields | Missing | Cannot pack struct members |\n\n### Literals & Constants\n\n| Feature | Status | Current Behavior |\n|---------|--------|-----------------|\n| Integer suffixes (`u`, `l`, `ll`) | Not parsed | All literals are `int` |\n| Wide characters (`L'c'`) | Not supported | Single-byte only |\n| Wide strings (`L\"...\"`) | Not supported | Single-byte only |\n| Multi-character constants | Not supported | Single character only |\n| Universal characters (`\\u`, `\\U`) | Not supported | ASCII only |\n| Hex escapes (`\\x...`) | Limited | Max 2 hex digits |\n\n### Preprocessor Gaps\n\n| Feature | Status | Description |\n|---------|--------|-------------|\n| `#include` | Partial | Local file inclusion is supported, but lack of capability to include system files |\n| Token pasting (`##`) | Missing | Cannot concatenate tokens |\n| Stringizing (`#`) | Missing | Cannot convert to string |\n| `__DATE__` | Missing | No compile date |\n| `__TIME__` | Missing | No compile time |\n| `__STDC__` | Missing | No standard compliance indicator |\n\n### Advanced Features\n\n| Feature | Status | Description |\n|---------|--------|-------------|\n| Designated initializers | Missing | No `.field = value` syntax |\n| Compound literals | Partial | Limited support |\n| Flexible array members | Missing | No `[]` at struct end |\n| Variable-length arrays | Missing | No runtime-sized arrays |\n| `_Complex` | Missing | No complex numbers |\n| `_Imaginary` | Missing | No imaginary numbers |\n| `_Static_assert` | Missing | No compile-time assertions |\n| `_Alignof` | Missing | No alignment queries |\n| `_Alignas` | Missing | No alignment specification |\n| `_Generic` | Missing | No generic selection |\n\n## Non-Standard Behaviors\n\n### GNU Extensions\n- Binary literals: `0b101010`\n- Escape sequence: `\\e` for ESC character\n- `void*` arithmetic (treated as `char*`)\n- `sizeof(void)` returns 0 (should be error)\n- Computed goto\n\n### Implementation-Specific\n- Array compound literals in scalar context use first element\n- String literals are modifiable (stored in `.data`, not `.rodata`)\n- No strict aliasing rules\n- Left-to-right evaluation order (not always guaranteed in C99)\n" }, { "path": "CONTRIBUTING.md", "content": "# Contributing to `shecc`\n\n:+1::tada: First off, thanks for taking the time to contribute! :tada::+1:\n\nThe following is a set of guidelines for contributing to [shecc](https://github.com/sysprog21/shecc)\nhosted on GitHub. These are mostly guidelines, not rules.\nUse your best judgment, and feel free to propose changes to this document in a pull request.\n\n## Issues\n\nThis project uses GitHub Issues to track ongoing development, discuss project plans, and keep track of bugs.\nBe sure to search for existing issues before you create another one.\n\nInitially, it is advisable to create an issue on GitHub for bug reports, feature requests,\nor substantial pull requests, as this offers a platform for discussion with both the community and project maintainers.\n\nEngaging in a conversation through a GitHub issue before making a contribution is crucial to ensure the acceptance of your work.\nWe aim to prevent situations where significant effort is expended on a pull request that might not align with the project's design principles.\nFor example, it might turn out that the feature you propose is more suited as an independent module that complements this project,\nin which case we would recommend that direction.\n\nFor minor corrections, such as typo fixes, small refactoring, or updates to documentation/comments,\nfiling an issue is not typically necessary.\nWhat constitutes a \"minor\" fix involves discretion; however, examples include:\n- Correcting spelling mistakes\n- Minor code refactoring\n- Updating or editing documentation and comments\n\nNevertheless, there may be instances where, upon reviewing your pull requests,\nwe might request an issue to be filed to facilitate discussion on broader design considerations.\n\nVisit our [Issues page on GitHub](https://github.com/sysprog21/shecc/issues) to search and submit.\n\n## Language Compliance\n\nBefore contributing new language features or modifications to the compiler frontend,\nplease review [COMPLIANCE.md](COMPLIANCE.md) to understand shecc's current C99 compliance status,\nsupported features, and known limitations. This document helps ensure that contributions\nalign with the project's subset implementation philosophy.\n\n## Coding Convention\n\nContributions from developers across corporations, academia, and individuals are welcome.\nHowever, participation requires adherence to fundamental ground rules:\n* Code must strictly adhere to the established C coding style (refer to the guidelines below).\n While there is some flexibility in basic style, it is crucial to stick to the current coding standards.\n Complex algorithmic constructs without proper comments will not be accepted.\n* External pull requests should include thorough documentation in the pull request comments for consideration.\n* When composing documentation, code comments, and other materials in English,\n please adhere to the American English (`en_US`) dialect.\n This variant should be considered the standard for all documentation efforts.\n For instance, opt for \"initialize\" over \"initialise\" and \"color\" rather than \"colour\".\n\nSoftware requirement: [clang-format](https://clang.llvm.org/docs/ClangFormat.html) version 18 or later.\n\nThis repository consistently contains an up-to-date `.clang-format` file with rules that match the explained ones.\nFor maintaining a uniform coding style, execute the command `clang-format -i *.{c,h}`.\n\n## Coding Style for Modern C\n\nThis coding style is a variant of the [K&R style](https://en.wikipedia.org/wiki/Indentation_style#K&R).\nAdhere to established practices while being open to innovation.\nMaintain consistency, adopt the latest C standards,\nand embrace modern compilers along with their advanced static analysis capabilities and sanitizers.\n\n### Indentation\n\nIn this coding style guide, the use of 4 spaces for indentation instead of tabs is strongly enforced to ensure consistency.\nAlways apply a single space before and after comparison and assignment operators to maintain readable code.\nAdditionally, it is crucial to include a single space after every comma.\ne.g.,\n```c\nfor (int i = 0; i < 10; i++) {\n printf(\"%d\\n\", i);\n /* some operations */\n}\n```\n\nThe tab character (ASCII 0x9) should never appear within any source code file.\nWhen indentation is needed in the source code, align using spaces instead.\nThe width of the tab character varies by text editor and programmer preference,\nmaking consistent visual layout a continual challenge during code reviews and maintenance.\n\n### Line length\n\nAll lines should typically remain within 80 characters, with longer lines wrapped as needed.\nThis practice is supported by several valid rationales:\n* It encourages developers to write concise code.\n* Smaller portions of information are easier for humans to process.\n* It assists users of vi/vim (and potentially other editors) who use vertical splits.\n* It is especially helpful for those who may want to print code on paper.\n\n### Comments\n\nMulti-line comments should have the opening and closing characters on separate lines,\nwith the content lines prefixed by a space and an asterisk (`*`) for alignment, e.g.,\n```c\n/*\n * This is a multi-line comment.\n */\n\n/* One line comment. */\n```\n\nUse multi-line comments for more elaborate descriptions or before significant logical blocks of code.\n\nSingle-line comments should be written in C89 style:\n```c\n return (uintptr_t) val; /* return a bitfield */\n```\n\nLeave two spaces between the statement and the inline comment.\nAvoid commenting out code directly.\nInstead, use `#if 0` ... `#endif` when it is intentional.\n\nAll assumptions should be clearly explained in comments.\nUse the following markers to highlight issues and make them searchable:\n* `WARNING`: Alerts a maintainer to the risk of changing this code.\n e.g., a delay loop counter's terminal value was determined empirically and may need adjustment when the code is ported or the optimization level is tweaked.\n* `NOTE`: Provides descriptive comments about the \"why\" of a chunk of code,\n as opposed to the \"how\" usually included in comments.\n e.g., a chunk of driver code may deviate from the datasheet due to a known erratum in the chip,\n or an assumption made by the original programmer is explained.\n* `TODO`: Indicates an area of the code that is still under construction and explains what remains to be done.\n When appropriate, include an all-caps programmer name or set of initials before the word `TODO`.\n\nKeep the documentation as close to the code as possible.\n\n### Spacing and brackets\n\nEnsure that the keywords `if`, `while`, `for`, `switch`, and `return` are always followed by a single space when there is additional code on the same line.\nFollow these spacing guidelines:\n* Place one space after the keyword in a conditional or loop.\n* Do not use spaces around the parentheses in conditionals or loops.\n* Insert one space before the opening curly bracket.\n\nFor example:\n```c\ndo {\n /* some operations */\n} while (condition);\n```\n\nFunctions (their declarations or calls), `sizeof` operator or similar\nmacros shall not have a space after their name/keyword or around the\nbrackets, e.g.,\n```c\nunsigned total_len = offsetof(obj_t, items[n]);\nunsigned obj_len = sizeof(obj_t);\n```\n\nUse brackets to avoid ambiguity and with operators such as `sizeof`,\nbut otherwise avoid redundant or excessive brackets.\n\nAssignment operators (`=`, `+=`, `-=`, `*=`, `/=`, `%=`, `&=`, `|=`, `^=`, `~=`, and `!=`) should always have a space before and after them.\nFor example:\n```c\ncount += 1;\n```\n\nBinary operators (`+`, `-`, `*`, `/`, `%`, `<`, `<=`, `>`, `>=`, `==`, `!=`, `<<`, `>>`, `&`, `|`, `^`, `&&`, and `||`) should also be surrounded by spaces.\nFor example:\n```c\ncurrent_conf = prev_conf | (1 << START_BIT);\n```\n\nUnary operators (`++`, `--`, `!`, and `~`) should be written without spaces between the operator and the operand.\nFor example:\n```c\nbonus++;\nif (!play)\n return STATE_QUITE;\n```\n\nThe ternary operator (`?` and `:`) should have spaces on both sides.\nFor example:\n```c\nuint32_t max(uint32_t a, uint32_t b)\n{\n return (a > b) ? a : b;\n}\n```\n\nStructure pointer (`->`) and member (`.`) operators should not have surrounding spaces.\nSimilarly, array subscript operators (`[` and `]`) and function call parentheses should be written without spaces around them.\n\n### Parentheses\n\nAvoid relying on C’s operator precedence rules, as they may not be immediately clear to those maintaining the code.\nTo ensure clarity, always use parentheses to enforce the correct execution order within a sequence of operations,\nor break long statements into multiple lines if necessary.\n\nWhen using logical AND (`&&`) and logical OR (`||`) operators, each operand should be enclosed in parentheses,\nunless it is a single identifier or constant.\nFor example:\n```c\nif ((count > 100) && (detected == false)) {\n character = C_ASSASSIN;\n}\n```\n\n### Variable names and declarations\n\nEnsure that functions, variables, and comments are consistently named using English words.\nGlobal variables should have descriptive names, while local variables can have shorter names.\nIt is important to strike a balance between being descriptive and concise.\nEach variable's name should clearly reflect its purpose.\n\nUse [snake_case](https://en.wikipedia.org/wiki/Snake_case) for naming conventions,\nand avoid using \"camelCase.\"\nAdditionally, do not use Hungarian notation or any other unnecessary prefixes or suffixes.\n\nWhen declaring pointers, follow these spacing conventions:\n```c\nconst char *name; /* Const pointer; '*' with the name and a space before it */\nconf_t * const cfg; /* Pointer to const data; spaces around 'const' */\nconst uint8_t * const charmap; /* Const pointer and const data */\nconst void * restrict key; /* Const pointer that does not alias */\n```\n\nLocal variables of the same type should be declared on the same line.\nFor example:\n```c\nvoid func(void)\n{\n char a, b; /* OK */\n\n char a;\n char b; /* Incorrect: a variable with char type already exists. */\n}\n```\n\nAlways include a trailing comma in the last element of a structure initialization,\nincluding its nested elements, to help `clang-format` correctly format the structure.\nHowever, this comma can be omitted in very simple and short structures.\n```c\ntypedef struct {\n int width, height;\n} screen_t;\n\nscreen_t s = {\n .width = 640,\n .height = 480, /* comma here */\n}\n```\n\n### Type definitions\n\nDeclarations shall be on the same line, e.g.,\n```c\ntypedef void (*dir_iter_t)(void *, const char *, struct dirent *);\n```\n\n_Typedef_ structures rather than pointers. Note that structures can be kept\nopaque if they are not dereferenced outside the translation unit where they\nare defined. Pointers can be _typedefed_ only if there is a very compelling\nreason.\n\nNew types may be suffixed with `_t`. Structure name, when used within the\ntranslation unit, may be omitted, e.g.:\n\n```c\ntypedef struct {\n unsigned if_index;\n unsigned addr_len;\n addr_t next_hop;\n} route_info_t;\n```\n\n### Initialization\n\nDo not initialize static and global variables to `0`; the compiler will do this.\nWhen a variable is declared inside a function, it is not automatically initialized.\n\n```c\nstatic uint8_t a; /* Global variable 'a' is set to 0 by the compiler */\n\nvoid foo()\n{\n /* 'b' is uninitialized and set to whatever happens to be in memory */\n uint8_t b;\n ...\n}\n```\n\nEmbrace C99 structure initialization where reasonable, e.g.,\n```c\nstatic const crypto_ops_t openssl_ops = {\n .create = openssl_crypto_create,\n .destroy = openssl_crypto_destroy,\n .encrypt = openssl_crypto_encrypt,\n .decrypt = openssl_crypto_decrypt,\n .hmac = openssl_crypto_hmac,\n};\n```\n\nEmbrace C99 array initialization, especially for the state machines, e.g.,\n```c\nstatic const uint8_t tcp_fsm[TCP_NSTATES][2][TCPFC_COUNT] = {\n [TCPS_CLOSED] = {\n [FLOW_FORW] = {\n /* Handshake (1): initial SYN. */\n [TCPFC_SYN] = TCPS_SYN_SENT,\n },\n },\n ...\n}\n```\n\nAny pointer variable that does not have an initial address should be explicitly initialized to `NULL`.\nThis practice helps prevent undefined behavior caused by dereferencing uninitialized pointers.\n\nIn accordance with modern C standards (such as C99 and later), it is preferable to define local variables as needed,\nrather than declaring them all at the beginning of a function.\nDeclaring variables close to their first use enhances code readability and helps maintain a clear, logical flow within the function.\n\nAdditionally, static analysis tools can be employed to scan the entire source code before each build,\nproviding warnings about variables that are used before being properly initialized.\nThis helps catch potential bugs early and ensures code quality and safety.\n\n### Control structures\n\nTry to make the control flow easy to follow. Avoid long convoluted logic\nexpressions; try to split them where possible (into inline functions,\nseparate if-statements, etc).\n\nThe control structure keyword and the expression in the brackets should be\nseparated by a single space. The opening curly bracket shall be in the\nsame line, also separated by a single space. Example:\n\n```c\n for (;;) {\n obj = get_first();\n while ((obj = get_next(obj))) {\n ...\n }\n if (done)\n break;\n }\n```\n\nDo not add inner spaces around the brackets. There should be one space after\nthe semicolon when `for` has expressions:\n```c\n for (unsigned i = 0; i < __arraycount(items); i++) {\n ...\n }\n```\n\n#### Avoid unnecessary nesting levels\n\nIt is generally preferred to place the shorter clause (measured in lines of code) first in `if` and `else if` statements.\nLong clauses can distract the reader from the core decision-making logic, making the code harder to follow.\nBy placing the shorter clause first, the decision path becomes clearer and easier to understand, which can help reduce bugs.\n\nAvoid nesting `if`-`else` statements deeper than two levels.\nInstead, consider using function calls or `switch` statements to simplify the logic and enhance readability.\nDeeply nested `if`-`else` statements often indicate a complex and fragile state machine implementation,\nwhich can be refactored into a safer and more maintainable structure.\n\nFor example, avoid this:\n```c\nint inspect(obj_t *obj)\n{\n if (cond) {\n ...\n /* long code block */\n ...\n return 0;\n }\n return -1;\n}\n```\n\nInstead, consider this approach:\n```c\nint inspect(obj_t *obj)\n{\n if (!cond)\n return -1;\n ...\n return 0;\n}\n```\n\nHowever, be careful not to make the logic more convoluted in an attempt to simplify nesting.\n\n### `if` statements\n\nCurly brackets and spacing follow the K&R style:\n```c\n if (a == b) {\n ..\n } else if (a < b) {\n ...\n } else {\n ...\n }\n```\n\nSimple and succinct one-line if-statements may omit curly brackets:\n```c\n if (!valid)\n return -1;\n```\n\nHowever, do prefer curly brackets with multi-line or more complex statements.\nIf one branch uses curly brackets, then all other branches shall use the\ncurly brackets too.\n\nWrap long conditions to the if-statement indentation adding extra 4 spaces:\n```c\n if (some_long_expression &&\n another_expression) {\n ...\n }\n```\n\n#### Avoid redundant `else`\n\nAvoid:\n```c\n if (flag & F_FEATURE_X) {\n ...\n return 0;\n } else {\n return -1;\n }\n```\n\nConsider:\n```c\n if (flag & F_FEATURE_X) {\n ...\n return 0;\n }\n return -1;\n```\n\n### `switch` statements\n\nSwitch statements should have the `case` blocks at the same indentation\nlevel, e.g.:\n```c\n switch (expr) {\n case A:\n ...\n break;\n case B:\n /* fallthrough */\n case C:\n ...\n break;\n }\n```\n\nIf the case block does not break, then it is strongly recommended to add a\ncomment containing \"fallthrough\" to indicate it. Modern compilers can also\nbe configured to require such comment (see gcc `-Wimplicit-fallthrough`).\n\n### Function definitions\n\nThe opening and closing curly brackets shall also be in the separate lines (K&R style).\n\n```c\nssize_t hex_write(FILE *stream, const void *buf, size_t len)\n{\n ...\n}\n```\n\nDo not use old style K&R style C definitions.\n\nIntroduced in C99, `restrict` is a pointer qualifier that informs the compiler no other pointer will access the same object during its lifetime,\nenabling optimizations such as vectorization. Violating this assumption leads to undefined behavior.\nUse `restrict` judiciously.\n\nFor function parameters, place one space after each comma, except at the end of a line.\n\n### Function-like Macros\n\nWhen using function-like macros (parameterized macros), adhere to the following guidelines:\n- Enclose the entire macro body in parentheses.\n- Surround each parameter usage with parentheses.\n- Limit the use of each parameter to no more than once within the macro to avoid unintended side effects.\n- Never include control flow statements (e.g., `return`) within a macro.\n- If the macro involves multiple statements, encapsulate them within a `do`-`while (0)` construct.\n\nFor example:\n```c\n#define SET_POINT(p, x, y) \\\n do { \\\n (p)->px = (x); \\\n (p)->py = (y); \\\n } while (0)\n```\n\nWhile the extensive use of parentheses, as shown above, helps minimize some risks,\nit cannot prevent issues like unintended double increments from calls such as `MAX(i++, j++)`.\n\nOther risks associated with macros include comparing signed and unsigned data or testing floating-point values.\nAdditionally, macros are not visible at runtime, making them impossible to step into with a debugger.\nTherefore, use them with caution.\n\nIn general, macro names are typically written in all capitals, except in cases where readability is improved by using lowercase.\nFor example:\n```\n#define countof(a) (size)(sizeof(a) / sizeof(*(a)))\n#define lengthof(s) (countof(s) - 1)\n```\n\nAlthough all capitals are generally preferred for constants,\nlowercase can be used for function-like macros to improve readability.\nThese function-like macros do not share the same namespace concerns as other macros.\n\nFor example, consider the implementation of a simple memory allocator.\nAn arena can be represented by a memory buffer and an offset that begins at zero.\nTo allocate an object, record the pointer at the current offset,\nadvance the offset by the size of the object, and return the pointer.\nAdditional considerations, such as alignment and checking for available space, are also required.\n```c\n#define new(a, n, t) alloc(a, n, sizeof(t), _Alignof(t))\n\ntypedef struct {\n char *begin, *end;\n} arena_t;\n\nvoid *alloc(arena_t *a, ptrdiff_t count, ptrdiff_t size, ptrdiff_t align)\n{\n ptrdiff_t pad = -(uintptr_t)a->begin & (align - 1);\n assert(count < (a->end - a->begin - pad) / size);\n\n void *result = a->begin + pad;\n a->begin += pad + (count * size);\n return memset(result, 0, count * size);\n}\n```\n\nUsing the `new` macro helps prevent several common errors in C programs.\nIf types are mixed up, the compiler generates errors or warnings.\nMoreover, naming a macro `new()` does not conflict with variables or fields named `new`,\nbecause the macro form does not resemble a function call.\n\n### Use `const` and `static` effectively\n\nThe `static` keyword should be used for any variables that do not need to be accessible outside the module where they are declared.\nThis is particularly important for global variables defined in C files.\nDeclaring variables and functions as `static` at the module level protects them from external access, reducing coupling between modules and improving encapsulation.\n\nFor functions that do not need to be accessible outside the module, use the `static` keyword.\nThis is especially important for private functions, where `static` should always be applied.\n\nFor example:\n```c\nstatic bool verify_range(uint16_t x, uint16_t y);\n```\n\nThe `const` keyword is essential for several key purposes:\n- Declaring variables that should not change after initialization.\n- Defining fields within a `struct` that must remain immutable, such as those in memory-mapped I/O peripheral registers.\n- Serving as a strongly typed alternative to `#define` for numerical constants.\n\nFor example, instead of using:\n```c\n#define MAX_SKILL_LEVEL (100U)\n```\n\nUse:\n```c\nconst uint8_t max_skill_level = 100;\n```\n\nMaximizing the use of `const` provides the advantage of compiler-enforced protection against unintended modifications to data that should be read-only,\nthereby enhancing code reliability and safety.\n\nAdditionally, when one of your function arguments is a pointer to data that will not be modified within the function,\nyou should use the `const` keyword.\nThis is particularly useful when comparing a character array with predefined strings without altering the array’s contents.\n\nFor example:\n```c\nstatic bool is_valid_cmd(const char *cmd);\n```\n\n### Object abstraction\n\nObjects are often \"simulated\" by the C programmers with a `struct` and\nits \"public API\". To enforce the information hiding principle, it is a\ngood idea to define the structure in the source file (translation unit)\nand provide only the _declaration_ in the header. For example, `obj.c`:\n\n```c\n#include \"obj.h\"\n\nstruct obj {\n int value;\n}\n\nobj_t *obj_create(void)\n{\n return calloc(1, sizeof(obj_t));\n}\n\nvoid obj_destroy(obj_t *obj)\n{\n free(obj);\n}\n```\n\nWith an example `obj.h`:\n```c\n#ifndef _OBJ_H_\n#define _OBJ_H_\n\ntypedef struct obj;\n\nobj_t *obj_create(void);\nvoid obj_destroy(obj_t *);\n\n#endif\n```\n\nSuch structuring will prevent direct access of the `obj_t` members outside\nthe `obj.c` source file. The implementation (of such \"class\" or \"module\")\nmay be large and abstracted within separate source files. In such case,\nconsider separating structures and \"methods\" into separate headers (think of\ndifferent visibility), for example `obj_impl.h` (private) and `obj.h` (public).\n\nConsider `crypto_impl.h`:\n```c\n#ifndef _CRYPTO_IMPL_H_\n#define _CRYPTO_IMPL_H_\n\n#if !defined(__CRYPTO_PRIVATE)\n#error \"only to be used by the crypto modules\"\n#endif\n\n#include \"crypto.h\"\n\ntypedef struct crypto {\n crypto_cipher_t cipher;\n void *key;\n size_t key_len;\n ...\n}\n...\n\n#endif\n```\n\nAnd `crypto.h` (public API):\n\n```c\n#ifndef _CRYPTO_H_\n#define _CRYPTO_H_\n\ntypedef struct crypto crypto_t;\n\ncrypto_t *crypto_create(crypto_cipher_t);\nvoid crypto_destroy(crypto_t *);\n...\n\n#endif\n```\n\n### Use reasonable types\n\nUse `unsigned` for general iterators; use `size_t` for general sizes; use\n`ssize_t` to return a size which may include an error. Of course, consider\npossible overflows.\n\nAvoid using fixed-width types like `uint8_t`, `uint16_t`, or other smaller integer types for general iterators or similar cases unless there is a specific need for size-constrained operations,\nsuch as in fixed-width data processing or resource-limited environments.\n\nC has rather peculiar _type promotion rules_ and unnecessary use of sub-word\ntypes might contribute to a bug once in a while.\n\nBoolean variables should be declared using the `bool` type.\nNon-Boolean values should be converted to Boolean by using relational operators (e.g., `<` or `!=`) rather than by casting.\n\nFor example:\n```c\n#include \n...\nbool inside = (value < expected_range);\n```\n\n### Embrace portability\n\n#### Byte-order\n\nDo not assume x86 or little-endian architecture. Use endian conversion\nfunctions for operating the on-disk and on-the-wire structures or other\ncases where it is appropriate.\n\n#### Types\n\nDo not assume a particular 32-bit or 64-bit architecture; for example, do not assume the size of `long` or `unsigned long`.\nInstead, use `int64_t` or `uint64_t` for 8-byte integers.\n\nFixed-width types, such as `uint32_t`, are particularly useful when memory size is critical,\nas in embedded systems, communication protocols requiring specific data sizes,\nor when interacting with hardware registers that require precise bit-width operations.\nIn these scenarios, fixed-width types ensure consistent behavior across different platforms and compilers.\n\nDo not assume `char` is signed; for example, on Arm architectures, it is unsigned by default.\n\nAvoid defining bit-fields within signed integer types.\nAdditionally, do not use bitwise operators (such as `&`, `|`, `~`, `^`, `<<`, and `>>`) on signed integer data.\nRefrain from combining signed and unsigned integers in comparisons or expressions, as this can lead to unpredictable results.\n\nWhen using `#define` to declare decimal constants, append a `U` to ensure they are treated as unsigned.\nFor example:\n```c\n#define SOME_CONSTANT (6U)\n\nuint16_t unsigned_a = 6;\nint16_t signed_b = -9;\nif (unsigned_a + signed_b < 4) {\n /* This block might appear logically correct, as -9 + 6 is -3 */\n ...\n}\n/* but compilers with 16-bit int may legally interpret it as (0xFFFF – 9) + 6. */\n```\n\nIt is important to note that certain aspects of manipulating binary data within signed integer containers are implementation-defined behaviors according to ISO C standards.\nAdditionally, mixing signed and unsigned integers can lead to data-dependent results, as demonstrated in the example above.\n\nUse C99 macros for constant prefixes or formatting of the fixed-width types.\n\nUse:\n```c\n#define SOME_CONSTANT (UINT64_C(1) << 48)\nprintf(\"val %\" PRIu64 \"\\n\", SOME_CONSTANT);\n```\n\nDo not use:\n```c\n#define SOME_CONSTANT (1ULL << 48)\nprintf(\"val %lld\\n\", SOME_CONSTANT);\n```\n\n#### Avoid unaligned access\n\nAvoid assuming that unaligned access is safe.\nIt is not secure on architectures like Arm, POWER, and others.\nAdditionally, even on x86, unaligned access can be slower.\n\n#### Structures and Unions\n\nCare should be taken to prevent the compiler from inserting padding bytes within `struct` or `union` types,\nas this can affect memory layout and portability.\nTo control padding and alignment, consider using structure packing techniques specific to your compiler.\n\nAdditionally, take precautions to ensure that the compiler does not alter the intended order of bits within bit-fields.\nThis is particularly important when working with hardware registers or communication protocols where bit order is crucial.\n\nAccording to the C standard, the layout of structures, including padding and bit-field ordering,\nis implementation-defined, meaning it can vary between different compilers and platforms.\nTherefore, it is essential to verify that the structure's layout meets your expectations, especially when writing portable code.\n\nFor example:\n```c\ntypedef struct {\n uint16_t count; /* offset 0 */\n uint16_t max_count; /* offset 2 */\n uint16_t unused0; /* offset 4 */\n uint16_t enable : 2; /* offset 6 bits 15-14 */\n uint16_t interrupt : 1; /* offset 6 bit 13 */\n uint16_t unused1 : 7; /* offset 6 bits 12-6 */\n uint16_t complete : 1; /* offset 6 bit 5 */\n uint16_t unused2 : 4; /* offset 6 bits 4-1 */\n uint16_t periodic : 1; /* offset 6 bit 0 */\n} mytimer_t;\n\n_Static_assert(sizeof(mytimer_t) == 8,\n \"mytimer_t struct size incorrect (expected 8 bytes)\");\n```\n\nTo enhance portability, use standard-defined types (e.g., `uint16_t`, `uint32_t`) and avoid relying on compiler-specific behavior.\nWhere precise control over memory layout is required, such as in embedded systems or when interfacing with hardware,\nalways verify the structure size and layout using static assertions.\n\n#### Avoid extreme portability\n\nUnless programming for micro-controllers or exotic CPU architectures,\nfocus on the common denominator of the modern CPU architectures, avoiding\nthe very maximum portability which can make the code unnecessarily cumbersome.\n\nSome examples:\n- It is fair to assume `sizeof(int) == 4` since it is the case on all modern\nmainstream architectures. PDP-11 era is long gone.\n- Using `1U` instead of `UINT32_C(1)` or `(uint32_t) 1` is also fine.\n- It is fair to assume that `NULL` is matching `(uintptr_t) 0` and it is fair\nto `memset()` structures with zero. Non-zero `NULL` is for retro computing.\n\n## Git Commit Style\n\nEffective version control is critical to modern software development.\nGit's powerful features—such as granular commits, branching,\nand a versatile staging area—offer unparalleled flexibility.\nHowever, this flexibility can sometimes lead to disorganized commit histories and\nmerge conflicts if not managed with clear, consistent practices.\n\nBy committing often, writing clear messages, and adhering to a common workflow,\ndevelopers can not only reduce the potential for errors but also simplify collaboration and future maintenance.\nWe encourage every team to tailor these best practices to their specific needs while striving\nfor a shared standard that promotes efficiency and code quality.\n\nBelow are the detailed guidelines that build on these principles.\n* Group Related Changes Together:\n Each commit should encapsulate a single, coherent change.\n e.g., if you are addressing two separate bugs, create two distinct commits.\n This approach produces focused, small commits that simplify understanding, enable quick rollbacks,\n and foster efficient peer reviews.\n By taking advantage of Git’s staging area and selective file staging,\n you can craft granular commits that make collaboration smoother and more transparent.\n* Commit Frequently:\n Making commits often ensures that your changes remain concise and logically grouped.\n Frequent commits not only help maintain a clean history but also allow you to share your progress with your teammates regularly.\n This regular sharing keeps everyone in sync,\n minimizes merge conflicts, and promotes a collaborative environment where integration happens seamlessly.\n* Avoid Committing Work in Progress:\n Only commit code when a logical component is in a stable, ready-to-integrate state.\n Break your feature's development into manageable segments that reach a functional milestone quickly,\n so you can commit regularly without compromising quality.\n If you feel the urge to commit merely to clear your working directory for actions like switching branches or pulling changes,\n use Git's stash feature instead.\n This practice helps maintain a stable repository and ensures that your team reviews well-tested, coherent code.\n* Test Your Code Before Committing:\n Before committing, ensure that your code has been thoroughly tested.\n Rather than assuming your changes are ready, run comprehensive tests to confirm they work as intended without unintended side effects.\n Testing is especially critical when sharing your code with others,\n as it maintains the overall stability of the project and builds trust among collaborators.\n* Utilize Branches for Parallel Development:\n Branches are a powerful tool that enables developers to isolate different lines of work—whether you are developing new features,\n fixing bugs, or exploring innovative ideas.\n By using branches extensively, you can work on your tasks independently and merge only after careful review and testing.\n This not only keeps the main branch stable but also encourages collaborative code reviews and a more organized integration process.\n\nClear and descriptive commit messages are crucial for maintaining a transparent history of changes and for facilitating effective debugging and tracking.\nPlease adhere to the guidelines outlined in [How to Write a Git Commit Message](https://cbea.ms/git-commit/).\n1. Separate the subject from the body with a blank line.\n2. Limit the subject line to 50 characters.\n3. Capitalize the subject line.\n4. Do not end the subject line with a period.\n5. Use the imperative mood in the subject line.\n6. Wrap the body at 72 characters.\n7. Use the body to explain what and why, not how.\n\nAn example (derived from Chris' blog post) looks like the following:\n```text\nSummarize changes in around 50 characters or less\n\nMore detailed explanatory text, if necessary. Wrap it to about 72\ncharacters or so. In some contexts, the first line is treated as the\nsubject of the commit and the rest of the text as the body. The\nblank line separating the summary from the body is critical (unless\nyou omit the body entirely); various tools like `log`, `shortlog`\nand `rebase` can get confused if you run the two together.\n\nExplain the problem that this commit is solving. Focus on why you\nare making this change as opposed to how (the code explains that).\nAre there side effects or other unintuitive consequences of this\nchange? Here's the place to explain them.\n\nFurther paragraphs come after blank lines.\n\n- Bullet points are okay, too\n\n- Typically a hyphen or asterisk is used for the bullet, preceded\n by a single space, with blank lines in between, but conventions\n vary here\n\nIf you use an issue tracker, put references to them at the bottom,\nlike this:\nClose #123\n```\n\nAnother illustration of effective practice.\n```text\ncommit f1775422bb5a1aa6e79a685dfa7cb54a852b567b\nAuthor: Jim Huang \nDate: Mon Feb 24 13:08:32 2025 +0800\n\n Introduce CPU architecture filtering in scheduler\n \n In environments with mixed CPU architectures, it is crucial to ensure\n that an instance runs only on a host with a compatible CPU\n type—preventing, for example, a RISC-V instance from being scheduled on\n an Arm host.\n \n This new scheduler filter enforces that requirement by comparing an\n instance's architecture against the host's allowed architectures. For\n the libvirt driver, the host's guest capabilities are queried, and the\n permitted architectures are recorded in the permitted_instances_types\n list within the host's cpu_info dictionary.\n \n The filter systematically excludes hosts that do not support the\n instance's CPU architecture. Additionally, RISC-V has been added to the\n set of acceptable architectures for scheduling.\n \n Note that the CPU architecture filter is disabled by default.\n```\n\nThe above is a clear, unformatted description provided in plain text.\n\nIn addition, this project expects contributors to follow these additional rules:\n* If there is important, useful, or essential conversation or information,\n include a reference or copy it.\n* Do not write single-word commits. Provide a descriptive subject.\n* Avoid using abusive words.\n* Avoid using backticks in commit subjects.\n Backticks can be easily confused with single quotes on some terminals,\n reducing readability. Plain text or single quotes provide sufficient clarity and emphasis.\n* Avoid using parentheses in commit subjects.\n Excessive use of parentheses \"()\" can clutter the subject line,\n making it harder to quickly grasp the essential message.\n\nSome conventions are automatically enforced by the [githooks](https://git-scm.com/docs/githooks).\n\n## References\n- [Linux kernel coding style](https://www.kernel.org/doc/html/latest/process/coding-style.html)\n- 1999, Brian W. Kernighan and Rob Pike, The Practice of Programming, Addison–Wesley.\n- 1993, Bill Shannon, [C Style and Coding Standards for SunOS](https://devnull-cz.github.io/unix-linux-prog-in-c/cstyle.ms.pdf)\n" }, { "path": "LICENSE", "content": "Copyright (c) 2020-2021, 2023-2026 National Cheng Kung University, Taiwan.\n\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n* Redistributions of source code must retain the above copyright notice,\n this list of conditions and the following disclaimer.\n\n* Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR\nANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON\nANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n" }, { "path": "Makefile", "content": "CFLAGS := -O -g \\\n\t-std=c99 -pedantic\n\nCFLAGS_TO_CHECK := \\\n\t-fwrapv \\\n\t-Wall -Wextra \\\n\t-Wno-unused-but-set-variable \\\n\t-Wno-unused-parameter \\\n\t-Wno-unused-function \\\n\t-Wshadow \\\n\t-Wno-variadic-macros \\\n\t-Wno-uninitialized \\\n\t-Wno-strict-prototypes \\\n\t-Wno-declaration-after-statement \\\n\t-Wno-format \\\n\t-Wno-format-pedantic \\\n\t-Wno-overflow\n\nSUPPORTED_CFLAGS :=\n# Check if a specific compiler flag is supported, attempting a dummy compilation\n# with flags. If successful, it returns the flag string; otherwise, it returns\n# an empty string.\n# Usage: $(call check_flag, -some-flag)\ncheck_flag = $(shell $(CC) $(1) -S -o /dev/null -xc /dev/null 2>/dev/null; \\\n if test $$? -eq 0; then echo \"$(1)\"; fi)\n\n# Iterate through the list of all potential flags, effectively filtering out all\n# unsupported flags.\n$(foreach flag, $(CFLAGS_TO_CHECK), $(eval CFLAGS += $(call check_flag, $(flag))))\n\nBUILD_SESSION := .session.mk\n\n-include $(BUILD_SESSION)\n\nSTAGE0 := shecc\nSTAGE1 := shecc-stage1.elf\nSTAGE2 := shecc-stage2.elf\n\nUSE_QEMU ?= 1\nOUT ?= out\nARCHS = arm riscv\nARCH ?= $(firstword $(ARCHS))\nSRCDIR := $(shell find src -type d)\nLIBDIR := $(shell find lib -type d)\n\nBUILTIN_LIBC_SOURCE ?= c.c\nBUILTIN_LIBC_HEADER := c.h\nSTAGE0_FLAGS ?= --dump-ir\nSTAGE1_FLAGS ?=\nDYNLINK ?= 0\nifeq ($(DYNLINK),1)\n ifeq ($(ARCH),riscv)\n # TODO: implement dynamic linking for RISC-V.\n $(error \"Dynamic linking mode is not implemented for RISC-V\")\n endif\n STAGE0_FLAGS += --dynlink\n STAGE1_FLAGS += --dynlink\nendif\n\nSRCS := $(wildcard $(patsubst %,%/main.c, $(SRCDIR)))\nOBJS := $(SRCS:%.c=$(OUT)/%.o)\ndeps := $(OBJS:%.o=%.o.d)\nTESTS := $(wildcard tests/*.c)\nTESTBINS := $(TESTS:%.c=$(OUT)/%.elf)\nSNAPSHOTS = $(foreach SNAPSHOT_ARCH,$(ARCHS), $(patsubst tests/%.c, tests/snapshots/%-$(SNAPSHOT_ARCH)-static.json, $(TESTS)))\nSNAPSHOTS += $(patsubst tests/%.c, tests/snapshots/%-arm-dynamic.json, $(TESTS))\n\nall: config bootstrap\n\nsanitizer: CFLAGS += -fsanitize=address -fsanitize=undefined -fno-omit-frame-pointer -O0\nsanitizer: LDFLAGS += -fsanitize=address -fsanitize=undefined\nsanitizer: config $(OUT)/$(STAGE0)-sanitizer\n\t$(VECHO) \" Built stage 0 compiler with sanitizers\\n\"\n\nifeq (,$(filter $(ARCH),$(ARCHS)))\n$(error Support ARM and RISC-V only. Select the target with \"ARCH=arm\" or \"ARCH=riscv\")\nendif\ninclude mk/$(ARCH).mk\ninclude mk/common.mk\n\nconfig:\n\t$(Q)ln -s $(PWD)/$(SRCDIR)/$(ARCH)-codegen.c $(SRCDIR)/codegen.c\n\t$(Q)$(PRINTF) $(ARCH_DEFS) > $@\n\t$(VECHO) \"Target machine code switch to %s\\n\" $(ARCH)\n\t$(Q)$(MAKE) $(BUILD_SESSION) --silent\n\t$(Q)$(CONFIG_CHECK_CMD)\n\n$(OUT)/tests/%.elf: tests/%.c $(OUT)/$(STAGE0)\n\t$(VECHO) \" SHECC\\t$@\\n\"\n\t$(Q)$(OUT)/$(STAGE0) $(STAGE0_FLAGS) -o $@ $< > $(basename $@).log ; \\\n\tchmod +x $@ ; $(PRINTF) \"Running $@ ...\\n\"\n\t$(Q)$(TARGET_EXEC) $@ && $(call pass)\n\ncheck: check-stage0 check-stage2 check-abi-stage0 check-abi-stage2\n\ncheck-stage0: $(OUT)/$(STAGE0) $(TESTBINS) tests/driver.sh\n\t$(VECHO) \" TEST STAGE 0\\n\"\n\ttests/driver.sh 0 $(DYNLINK)\n\ncheck-stage2: $(OUT)/$(STAGE2) $(TESTBINS) tests/driver.sh\n\t$(VECHO) \" TEST STAGE 2\\n\"\n\ttests/driver.sh 2 $(DYNLINK)\n\ncheck-sanitizer: $(OUT)/$(STAGE0)-sanitizer tests/driver.sh\n\t$(VECHO) \" TEST STAGE 0 (with sanitizers)\\n\"\n\t$(Q)cp $(OUT)/$(STAGE0)-sanitizer $(OUT)/shecc\n\ttests/driver.sh 0 $(DYNLINK)\n\t$(Q)rm $(OUT)/shecc\n\ncheck-snapshots: $(OUT)/$(STAGE0) $(SNAPSHOTS) tests/check-snapshots.sh\n\t$(Q)$(foreach SNAPSHOT_ARCH, $(ARCHS), $(MAKE) distclean config check-snapshot ARCH=$(SNAPSHOT_ARCH) DYNLINK=0 --silent;)\n\t$(Q)$(MAKE) distclean config check-snapshot ARCH=arm DYNLINK=1 --silent\n\t$(VECHO) \"Switching backend back to %s (DYNLINK=0)\\n\" arm\n\t$(Q)$(MAKE) distclean config ARCH=arm DYNLINK=0 --silent\n\ncheck-snapshot: $(OUT)/$(STAGE0) tests/check-snapshots.sh\n\t$(VECHO) \"Checking snapshot for %s (DYNLINK=%s)\\n\" $(ARCH) $(DYNLINK)\n\ttests/check-snapshots.sh $(ARCH) $(DYNLINK)\n\t$(VECHO) \" OK\\n\"\n\n# TODO: Add an ABI conformance test suite for the RISC-V architecture\ncheck-abi-stage0: $(OUT)/$(STAGE0)\n\t$(Q)if [ \"$(ARCH)\" = \"arm\" ]; then \\\n\t\ttests/$(ARCH)-abi.sh 0 $(DYNLINK); \\\n\telse \\\n\t\techo \"Skip ABI compliance validation\"; \\\n\tfi\n\ncheck-abi-stage2: $(OUT)/$(STAGE2)\n\t$(Q)if [ \"$(ARCH)\" = \"arm\" ]; then \\\n\t\ttests/$(ARCH)-abi.sh 2 $(DYNLINK); \\\n\telse \\\n\t\techo \"Skip ABI compliance validation\"; \\\n\tfi\n\nupdate-snapshots: tests/update-snapshots.sh\n\t$(Q)$(foreach SNAPSHOT_ARCH, $(ARCHS), $(MAKE) distclean config update-snapshot ARCH=$(SNAPSHOT_ARCH) DYNLINK=0 --silent;)\n\t$(Q)$(MAKE) distclean config update-snapshot ARCH=arm DYNLINK=1 --silent\n\t$(VECHO) \"Switching backend back to %s (DYNLINK=0)\\n\" arm\n\t$(Q)$(MAKE) distclean config ARCH=arm DYNLINK=0 --silent\n\nupdate-snapshot: $(OUT)/$(STAGE0) tests/update-snapshots.sh\n\t$(VECHO) \"Updating snapshot for %s (DYNLINK=%s)\\n\" $(ARCH) $(DYNLINK)\n\ttests/update-snapshots.sh $(ARCH) $(DYNLINK)\n\t$(VECHO) \" OK\\n\"\n\n$(OUT)/%.o: %.c\n\t$(VECHO) \" CC\\t$@\\n\"\n\t$(Q)$(CC) -o $@ $(CFLAGS) -c -MMD -MF $@.d $<\n\nSHELL_HACK := $(shell mkdir -p $(OUT) $(OUT)/$(SRCDIR) $(OUT)/tests)\n\n$(OUT)/norm-lf: tools/norm-lf.c\n\t$(VECHO) \" CC+LD\\t$@\\n\"\n\t$(Q)$(CC) $(CFLAGS) -o $@ $^\n\n$(OUT)/libc.inc: $(OUT)/inliner $(OUT)/norm-lf $(LIBDIR)/$(BUILTIN_LIBC_SOURCE) $(LIBDIR)/$(BUILTIN_LIBC_HEADER)\n\t$(VECHO) \" GEN\\t$@\\n\"\n\t$(Q)$(OUT)/norm-lf $(LIBDIR)/$(BUILTIN_LIBC_SOURCE) $(OUT)/c.normalized.c\n\t$(Q)$(OUT)/norm-lf $(LIBDIR)/$(BUILTIN_LIBC_HEADER) $(OUT)/c.normalized.h\n\t$(Q)$(OUT)/inliner $(OUT)/c.normalized.c $(OUT)/c.normalized.h $@\n\t$(Q)$(RM) $(OUT)/c.normalized.c $(OUT)/c.normalized.h\n\n$(OUT)/inliner: tools/inliner.c\n\t$(VECHO) \" CC+LD\\t$@\\n\"\n\t$(Q)$(CC) $(CFLAGS) -o $@ $^\n\n$(OUT)/$(STAGE0): $(OUT)/libc.inc $(OBJS)\n\t$(VECHO) \" LD\\t$@\\n\"\n\t$(Q)$(CC) $(OBJS) $(LDFLAGS) -o $@\n\n$(OUT)/$(STAGE0)-sanitizer: $(OUT)/libc.inc $(OBJS)\n\t$(VECHO) \" LD\\t$@ (with sanitizers)\\n\"\n\t$(Q)$(CC) $(OBJS) $(LDFLAGS) -o $@\n\n$(OUT)/$(STAGE1): $(OUT)/$(STAGE0)\n\t$(Q)$(STAGE1_CHECK_CMD)\n\t$(VECHO) \" SHECC\\t$@\\n\"\n\t$(Q)$(OUT)/$(STAGE0) $(STAGE0_FLAGS) -o $@ $(SRCDIR)/main.c > $(OUT)/shecc-stage1.log\n\t$(Q)chmod a+x $@\n\n$(OUT)/$(STAGE2): $(OUT)/$(STAGE1)\n\t$(VECHO) \" SHECC\\t$@\\n\"\n\t$(Q)$(TARGET_EXEC) $(OUT)/$(STAGE1) $(STAGE1_FLAGS) -o $@ $(SRCDIR)/main.c\n\nbootstrap: $(OUT)/$(STAGE2)\n\t$(Q)chmod 775 $(OUT)/$(STAGE2)\n\t$(Q)if ! diff -q $(OUT)/$(STAGE1) $(OUT)/$(STAGE2); then \\\n\techo \"Unable to bootstrap. Aborting\"; false; \\\n\tfi\n\n$(BUILD_SESSION):\n\t$(PRINTF) \"ARCH=$(ARCH)\" > $@\n\n.PHONY: clean\nclean:\n\t-$(RM) $(OUT)/$(STAGE0) $(OUT)/$(STAGE1) $(OUT)/$(STAGE2)\n\t-$(RM) $(OBJS) $(deps)\n\t-$(RM) $(TESTBINS) $(OUT)/tests/*.log $(OUT)/tests/*.lst\n\t-$(RM) $(OUT)/shecc*.log\n\t-$(RM) $(OUT)/libc.inc\n\ndistclean: clean\n\t-$(RM) $(OUT)/inliner $(OUT)/norm-lf $(OUT)/target $(SRCDIR)/codegen.c config $(BUILD_SESSION)\n\t-$(RM) DOM.dot CFG.dot\n\n-include $(deps)\n" }, { "path": "README.md", "content": "# shecc : self-hosting and educational C optimizing compiler\n\n

\"logo

\n\n## Introduction\n\n`shecc` is built from scratch, targeting both 32-bit Arm and RISC-V architectures,\nas a self-compiling compiler for a subset of the C language.\nDespite its simplistic nature, it is capable of performing basic optimization strategies as a standalone optimizing compiler.\n\n### Features\n\n* Generate executable Linux ELF binaries for ARMv7-A and RV32IM.\n* Provide a minimal C standard library for basic I/O on GNU/Linux.\n* The cross-compiler is written in ANSI C, making it compatible with most platforms.\n* Include a self-contained C front-end with an integrated machine code generator; no external assembler or linker needed.\n* Utilize a two-pass compilation process: the first pass checks syntax and breaks down complex statements into basic operations,\n while the second pass translates these operations into Arm/RISC-V machine code.\n* Develop a register allocation system that is compatible with RISC-style architectures.\n* Implement an architecture-independent, [static single assignment](https://en.wikipedia.org/wiki/Static_single-assignment_form) (SSA)-based middle-end for enhanced optimizations.\n\n## Compatibility\n\n`shecc` is capable of compiling C source files written in the following\nsyntax:\n* data types: `char`, `int`, `struct`, `enum`, `typedef`, and pointer types\n* condition statements: `if`, `else`, `while`, `for`, `do-while`, `switch`, `case`, `default`, `break`, `continue`, `return`, and\n general expressions\n* operators: all arithmetic, logical, bitwise, and assignment operators including compound assignments\n (`+=`, `-=`, `*=`, `/=`, `%=`, `&=`, `|=`, `^=`, `<<=`, `>>=`)\n* arrays: global/local arrays with initializers, multi-dimensional arrays\n* functions: function declarations, definitions, and calls with fixed arguments\n* variadic functions: basic support via direct pointer arithmetic (no ``)\n* typedef: type aliasing including typedef pointers (`typedef int *ptr_t;`)\n* pointers: full pointer arithmetic, multi-level pointer dereference (`***ptr`)\n* global/local variable initializations for all supported data types\n - e.g. `int i = [expr];`, `int arr[] = {1, 2, 3};`\n* preprocessor directives: `#define`, `#ifdef`, `#ifndef`, `#elif`, `#else`, `#endif`, `#undef`, `#error`, and `#include`\n* function-like macros with parameters and `__VA_ARGS__` support\n\nThe backend targets armv7hf with Linux ABI, verified on Raspberry Pi 3,\nand also supports RISC-V 32-bit architecture, verified with QEMU.\n\n## Bootstrapping\n\nThe steps to validate `shecc` bootstrapping:\n1. `stage0`: `shecc` source code is initially compiled using an ordinary compiler\n which generates a native executable. The generated compiler can be used as a\n cross-compiler.\n2. `stage1`: The built binary reads its own source code as input and generates an\n ARMv7-A/RV32IM binary.\n3. `stage2`: The generated ARMv7-A/RV32IM binary is invoked (via QEMU or running on\n Arm and RISC-V devices) with its own source code as input and generates another\n ARMv7-A/RV32IM binary.\n4. `bootstrap`: Build the `stage1` and `stage2` compilers, and verify that they are\n byte-wise identical. If so, `shecc` can compile its own source code and produce\n new versions of that same program.\n\n## Prerequisites\n\nCode generator in `shecc` does not rely on external utilities. You only need\nordinary C compilers such as `gcc` and `clang`. However, `shecc` would bootstrap\nitself, and Arm/RISC-V ISA emulation is required. Install QEMU for Arm/RISC-V user\nemulation on GNU/Linux:\n```shell\n$ sudo apt-get install qemu-user\n```\n\nThe build system is able to verify whether the running machine can perform native\nexecution without QEMU. The host machine may install the prebuilt\n[fastfetch](https://github.com/fastfetch-cli/fastfetch/), which allows the build\nsystem to determine whether native execution can be enabled.\n\nIt is still possible to build `shecc` on macOS or Microsoft Windows. However,\nthe second stage bootstrapping would fail due to `qemu-arm` absence.\n\nTo execute the snapshot test, install the packages below:\n```shell\n$ sudo apt-get install graphviz jq\n```\n\nAdditionally, because `shecc` supports the dynamic linking mode for the Arm architecture,\nit needs to install the ARM GNU toolchain to obtain the ELF interpreter and other dependencies:\n```shell\n$ sudo apt-get install gcc-arm-linux-gnueabihf\n```\nAnother approach is to manually download and install the toolchain from [ARM Developer website](https://developer.arm.com/downloads/-/arm-gnu-toolchain-downloads).\n\nSelect \"x86_64 Linux hosted cross toolchains\" - \"AArch32 GNU/Linux target with hard float (arm-none-linux-gnueabihf)\" to download the toolchain.\n\n## Build and Verify\n\nConfigure which backend you want, `shecc` supports ARMv7-A and RV32IM backend:\n```shell\n$ make config ARCH=arm\n# Target machine code switch to Arm\n\n$ make config ARCH=riscv\n# Target machine code switch to RISC-V\n```\n\nRun `make` and you should see this:\n```shell\n$ make\n CC+LD\tout/inliner\n GEN\tout/libc.inc\n CC\tout/src/main.o\n LD\tout/shecc\n SHECC\tout/shecc-stage1.elf\n SHECC\tout/shecc-stage2.elf\n```\n\nRun `make DYNLINK=1` to use the dynamic linking mode and generate the dynamically linked compiler:\n```shell\n# If using the dynamic linking mode, you should add 'DYNLINK=1' for each 'make' command.\n$ make DYNLINK=1\n CC+LD\tout/inliner\n GEN\tout/libc.inc\n CC\tout/src/main.o\n LD\tout/shecc\n SHECC\tout/shecc-stage1.elf\n SHECC\tout/shecc-stage2.elf\n\n$ file out/shecc-stage2.elf\nout/shecc-stage2.elf: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux-armhf.so.3, not stripped\n```\n\nFor development builds with memory safety checks:\n```shell\n$ make sanitizer\n$ make check-sanitizer\n```\n\nFile `out/shecc` is the first stage compiler. Its usage:\n```shell\n$ shecc [-o output] [+m] [--no-libc] [--dump-ir] [--dynlink] \n```\n\nCompiler options:\n- `-o` : Specify output file name (default: `out.elf`)\n- `+m` : Use hardware multiplication/division instructions (default: disabled)\n- `--no-libc` : Exclude embedded C library (default: embedded)\n- `--dump-ir` : Dump intermediate representation (IR)\n- `--dynlink` : Use dynamic linking (default: disabled)\n\nExample 1: static linking mode\n```shell\n$ out/shecc -o fib tests/fib.c\n$ chmod +x fib\n$ qemu-arm fib\n```\n\nExample 2: dynamic linking mode\n\nNotice that `/usr/arm-linux-gnueabihf` is the ELF interpreter prefix. Since the path may be different if you manually install the ARM GNU toolchain instead of using `apt-get`, you should set the prefix to the actual path.\n```shell\n$ out/shecc --dynlink -o fib tests/fib.c\n$ chmod +x fib\n$ qemu-arm -L /usr/arm-linux-gnueabihf fib\n```\n\n### IR Regression Tests\n\nTo ensure the consistency of frontend (lexer, parser) behavior when working on it, the snapshot test is introduced.\nThe snapshot test dumps IRs from the executable and compares the structural identity with the provided snapshots.\n\nVerify the emitted IRs by specifying `check-snapshots` target when invoking `make`:\n```shell\n$ make check-snapshots\n```\n\nIf the compiler frontend is updated, the emitted IRs might be changed.\nThus, you can update snapshots by specifying `update-snapshots` target when invoking `make`:\n```shell\n$ make update-snapshots\n```\n\nNotice that the above 2 targets will update all backend snapshots at once, to update/check current backend's snapshot, \nuse `update-snapshot` / `check-snapshot` instead.\n\n### Unit Tests\n\n`shecc` comes with a comprehensive test suite (200+ test cases). To run the tests:\n```shell\n# Add 'DYNLINK=1' if using the dynamic linking mode.\n$ make check # Run all tests (stage 0 and stage 2)\n$ make check-stage0 # Test stage 0 compiler only\n$ make check-stage2 # Test stage 2 compiler only\n$ make check-sanitizer # Test with AddressSanitizer and UBSan\n```\n\nThe test suite covers:\n* Basic data types and operators\n* Control flow statements\n* Arrays and pointers (including multi-level dereference)\n* Structs, enums, and typedefs\n* Variadic functions\n* Preprocessor directives and macros\n* Self-hosting validation\n\nReference output:\n```\n TEST STAGE 0\n...\nint main(int argc, int argv) { exit(sizeof(char)); } => 1\nint main(int argc, int argv) { int a; a = 0; switch (3) { case 0: return 2; case 3: a = 10; break; case 1: return 0; } exit(a); } => 10\nint main(int argc, int argv) { int a; a = 0; switch (3) { case 0: return 2; default: a = 10; break; } exit(a); } => 10\nOK\n TEST STAGE 2\n...\nint main(int argc, int argv) { exit(sizeof(char*)); }\nexit code => 4\noutput => \nint main(int argc, int argv) { exit(sizeof(int*)); }\nexit code => 4\noutput => \nOK\n```\n\nTo clean up the generated compiler files, execute the command `make clean`.\nFor resetting architecture configurations, use the command `make distclean`.\n\n## Intermediate Representation\n\nOnce the option `--dump-ir` is passed to `shecc`, the intermediate representation (IR)\nwill be generated. Take the file `tests/fib.c` for example. It consists of a recursive\nFibonacci sequence function.\n```c\nint fib(int n)\n{\n if (n == 0)\n return 0;\n else if (n == 1)\n return 1;\n return fib(n - 1) + fib(n - 2);\n}\n```\n\nExecute the following to generate IR:\n```shell\n$ out/shecc --dump-ir -o fib tests/fib.c\n```\n\nLine-by-line explanation between C source and IR (variable and label numbering may differ):\n```c\nC Source IR Explanation\n-------------------+--------------------------------------+--------------------------------------------------------------------------------------\nint fib(int n) def int @fib(int %n)\n{ {\n if (n == 0) const %.t871, 0 Load constant 0 into a temporary variable \".t871\"\n %.t872 = eq %n, %.t871 Test if \"n\" is equal to \".t871\", store result in \".t872\"\n br %.t872, .label.1430, .label.1431 If \".t872\" is non-zero, branch to label \".label.1430\", otherwise to \".label.1431\"\n .label.1430:\n return 0; const %.t873, 0 Load constant 0 into a temporary variable \".t873\"\n ret %.t873 Return \".t873\"\n .label.1431:\n else if (n == 1) const %.t874, 1 Load constant 1 into a temporary variable \".t874\"\n %.t875 = eq %n, %.t874 Test if \"n\" is equal to \".t874\", store result in \".t875\"\n br %.t875, .label.1434, .label.1435 If \".t875\" is true, branch to \".label.1434\", otherwise to \".label.1435\"\n .label.1434:\n return 1; const %.t876, 1 Load constant 1 into a temporary variable \".t876\"\n ret %.t876 Return \".t876\"\n .label.1435:\n return fib(n - 1) const %.t877, 1 Load constant 1 into \".t877\"\n %.t878 = sub %n, %.t877 Subtract \".t877\" from \"n\", store in \".t878\"\n push %.t878 Prepare argument \".t878\" for function call\n call @fib, 1 Call function \"@fib\" with 1 argument\n + retval %.t879 Store the return value in \".t879\"\n fib(n - 2); const %.t880, 2 Load constant 2 into \".t880\"\n %.t881 = sub %n, %.t880 Subtract \".t880\" from \"n\", store in \".t881\"\n push %.t881 Prepare argument \".t881\" for function call\n call @fib, 1 Call function \"@fib\" with 1 argument\n retval %.t882 Store the return value in \".t882\"\n %.t883 = add %.t879, %.t882 Add \".t879\" and \".t882\", store in \".t883\"\n ret %.t883 Return \".t883\"\n} }\n```\n\n## C99 Compliance\n\nshecc implements a subset of C99 suitable for self-hosting and systems programming.\nFor detailed information about supported features, missing functionality, and non-standard behaviors,\nsee [COMPLIANCE.md](COMPLIANCE.md).\n\n## Known Issues\n\n2. Full `` support is not available. Variadic functions work via direct pointer arithmetic.\n See the `printf` implementation in `lib/c.c` for the supported approach.\n3. The C front-end operates directly on token streams without building a full AST.\n4. Complex pointer arithmetic expressions like `*(p + offset)` have limited support.\n\n## License\n\n`shecc` is freely redistributable under the BSD 2 clause license.\nUse of this source code is governed by a BSD-style license that can be found in the `LICENSE` file.\n" }, { "path": "docs/dynamic-linking.md", "content": "# Dynamic Linking\n\n## Build dynamically linked shecc and programs\n\nBuild the dynamically linked version of shecc, but notice that shecc currently doesn't support dynamic linking for the RISC-V architecture:\n\n```shell\n$ make ARCH=arm DYNLINK=1\n```\n\nNext, you can use shecc to build dynamically linked programs by adding the `--dynlink` flag:\n\n```shell\n# Use the stage 0 compiler\n$ out/shecc --dynlink -o \n# Use the stage 1 or stage 2 compiler\n$ qemu-arm -L out/shecc-stage2.elf --dynlink -o \n\n# Execute the compiled program\n$ qemu-arm -L \n```\n\nWhen executing a dynamically linked program, you should set the ELF interpreter prefix so that `ld.so` can be invoked. Generally, it should be `/usr/arm-linux-gnueabihf` if you have installed the ARM GNU toolchain by `apt`. Otherwise, you should find and specify the correct path if you manually installed the toolchain.\n\n## Stack frame layout\n\n### Arm32\n\nIn both static and dynamic linking modes, the stack frame layout for each function can be illustrated as follows:\n\n```\nHigh Address\n+------------------+\n| incoming args |\n+------------------+ <- sp + total_size\n| saved lr |\n+------------------+\n| saved r11 |\n+------------------+\n| saved r10 |\n+------------------+\n| saved r9 |\n+------------------+\n| saved r8 |\n+------------------+\n| saved r7 |\n+------------------+\n| saved r6 |\n+------------------+\n| saved r5 |\n+------------------+\n| saved r4 |\n+------------------+\n| (padding) |\n+------------------+\n| local variables |\n+------------------+ <- sp + (MAX_PARAMS - MAX_ARGS_IN_REG) * 4\n| outgoing args |\n+------------------+ <- sp (MUST be aligned to 8 bytes)\nLow Address\n```\n\n* `total_size`: includes the size of the following elements:\n * `outgoing args`: a fixed size - `(MAX_PARAMS - MAX_ARGS_IN_REG) * 4` bytes\n * `local variables`\n * `saved r4-r11 and lr`: a fixed size - 36 bytes\n\n* Note that the space for `incoming args` belongs to the caller's stack frame, while the remaining space belongs to the callee's stack frame.\n\n### RISC-V\n\n(Currently not supported)\n\n## Calling Convention\n\n### Arm32\n\nRegardless of which mode is used, the caller performs the following operations to comply with the Arm Architecture Procedure Call Standard (AAPCS) when calling a function.\n\n* The first four arguments are put into registers `r0` - `r3`\n* Any additional arguments are passed on the stack. Arguments are pushed onto the stack starting from the last argument, so the fifth argument resides at a lower address and the last argument at a higher address.\n* Align the stack pointer to 8 bytes, as external functions may access 8-byte objects that require such alignment.\n\nThen, the callee will perform these operations:\n\n- Preserve the contents of registers `r4` - `r11` on the stack upon function entry.\n - The callee also pushes the content of `lr` onto the stack to preserve the return address; however, this operation is not required by the AAPCS.\n\n- Restore these registers from the stack upon returning.\n\n### RISC-V\n\nIn the RISC-V architecture, registers `a0` - `a7` are used as argument registers; that is, the first eight arguments are passed into these registers.\n\nSince the current implementation of shecc supports up to 8 arguments, no argument needs to be passed onto the stack.\n\n## Runtime execution flow of a dynamically linked program\n\n```\n | +---------------------------+\n | | program |\n | +-------------+ +----------------+ | |\n | | shell | | Dynamic linker | | +--------+ +----------+ |\nuserspace | | | | +------+->| entry | | main | |\n | | $ ./program | | (ld.so) | | | point | | function | |\nprogram | +-----+-------+ +----------------+ | +-+------+ +-----+----+ |\n | | ^ | | ^ | |\n | | | +----+---------+----+-------+\n | | | | | |\n | | | | | |\n----------+-------+---------------------------------------------+--------------------+---------+----+----------------------\n | | | | | |\n | v | v | v\n | +-------+ (It may be another | +-------------+-----+ +------+\nglibc | | execl | | | __libc_start_main +--->| exit |\n | +---+---+ equivalent call) | +-------------------+ +---+--+\n | | | |\n----------+-------+---------------------------------------------+---------------------------------------------+------------\nsystem | | | |\n | v | v\ncall | +------+ (It may be another | +-------+\n | | exec | | | _exit |\ninterface | +---+--+ equivalent syscall) | +---+---+\n | | | |\n----------+-------+---------------------------------------------+---------------------------------------------+------------\n | | | |\n | v | v\n | +--------------+ +---------------+ +--------+-------------+ +---------------+\n | | Validate the | | Create a new | | Startup the kernel's | | Delete the |\nkernel | | +--->| +--->| | | |\n | | executable | | process image | | program loader | | process image |\n | +--------------+ +---------------+ +----------------------+ +---------------+\n```\n\n1. A running process (e.g.: a shell) executes the specified program (`program`), which is dynamically linked.\n2. Kernel validates the executable and creates a process image if the validation passes.\n3. Dynamic linker (`ld.so`) is invoked by the kernel's program loader.\n * For the Arm architecture, the dynamic linker is `/lib/ld-linux-armhf.so.3`.\n4. Linker loads shared libraries such as `libc.so`.\n5. Linker resolves symbols and fills global offset table (GOT).\n6. Control transfers to the program, which starts at the entry point.\n7. Program executes `__libc_start_main` at the beginning.\n8. `__libc_start_main` calls the *main wrapper*, which pushes registers r4-r11 and lr onto the stack, sets up a global stack for all global variables (excluding read-only variables), and initializes them.\n9. Execute the *main wrapper*, and then invoke the main function.\n10. After the `main` function returns, the *main wrapper* restores the necessary registers and passes control back to `__libc_start_main`, which implicitly calls `exit(3)` to terminate the program.\n * Or, the `main` function can also call `exit(3)` or `_exit(2)` to directly terminate itself.\n\n## Dynamic sections\n\nWhen using dynamic linking, the following sections are generated for compiled programs:\n\n1. `.interp` - Path to dynamic linker\n2. `.dynsym` - Dynamic symbol table\n3. `.dynstr` - Dynamic string table\n4. `.rel.plt` - PLT relocations\n5. `.plt` - Procedure Linkage Table\n6. `.got` - Global Offset Table\n7. `.dynamic` - Dynamic linking information\n\n### Initialization of all GOT entries\n\n* `GOT[0]` is set to the starting address of the `.dynamic` section.\n* `GOT[1]` and `GOT[2]` are initialized to zero and reserved for the `link_map` and the resolver (`__dl_runtimer_resolve`).\n * The dynamic linker modifies them to point to the actual addresses at runtime.\n* `GOT[3]` - `GOT[N]` are initially set to the address of `PLT[0]` at compile time, causing the first call to an external function to invoke the resolver at runtime.\n\n### Explanation for PLT stubs (Arm32)\n\nUnder the Arm architecture, the resolver assumes that the following three conditions are met:\n\n* `[sp]` contains the return address from the original function call.\n* `ip` stores the address of the callee's GOT entry.\n* `lr` stores the address of `GOT[2]`.\n\nTherefore, the first entry (`PLT[0]`) contains the following instructions to satisfy the first and third requirements, and then to invoke the resolver.\n\n```\npush\t{lr}\t\t@ (str lr, [sp, #-4]!)\nmovw\tsl, #:lower16:(&GOT[2])\nmovt\tsl, #:upper16:(&GOT[2])\nmov\tlr, sl\nldr\tpc, [lr]\n```\n\n1. Push register `lr` onto the stack.\n2. Set register `sl` to the address of `GOT[2]`.\n3. Move the value of `sl` to `lr`.\n4. Load the value located at `[lr]` into the program counter (`pc`)\n\nThe remaining PLT entries correspond to all external functions, and each entry includes the following instructions to fulfill the second requirement:\n\n```\nmovw ip, #:lower16:(&GOT[x])\nmovt ip, #:upper16:(&GOT[x])\nldr pc, [ip]\n```\n\n1. Set register `ip` to the address of `GOT[x]`. \n2. Assign register `pc` to the value of `GOT[x]`. That is, set `pc` to the address of the callee.\n\n## PLT execution path and performance overhead\n\nSince calling an external function needs a PLT stub for indirect invocation, the execution path of the first call is as follows:\n\n1. Call the corresponding PLT stub of the external function.\n2. The PLT stub reads the GOT entry.\n3. Since the GOT entry is initially set to point to the first PLT entry, the call jumps to `PLT[0]`, which in turn calls the resolver.\n4. The resolver handles the symbol and updates the GOT entry.\n5. Jump to the actual function to continue execution.\n\nFor subsequent calls, the execution path only performs steps 1, 2 and 5. Regardless of whether it is the first call or a subsequent call, calling an external function requires executing additional instructions. It is evident that the overhead accounts to 3-8 instructions compared to a direct call.\n\nFor a bootstrapping compiler, this overhead is acceptable.\n\n## Binding\n\nEach external function must perform relocation via the resolver; in other words, each \"symbol\" needs to **bind** to its actual address.\n\nThere are two types of binding:\n\n### Lazy binding\n\nThe dynamic linker defers function call resolution until the function is called at runtime.\n\n### Immediate handling\n\nThe dynamic linker resolves all symbols when the program is started, or when the shared library is loaded via `dlopen`.\n\n## Limitations\n\nFor the current implementation of dynamic linking, note the following:\n\n* GOT is located in a writable segment (`.data` segment).\n* The `PT_GNU_RELRO` program header has not yet been implemented.\n* `DT_BIND_NOW` (force immediate binding) is not set.\n\nThis implies that:\n\n* GOT entries can be modified at runtime, which may create a potential ROP (Return-Oriented Programming) attack vector.\n* Function pointers (GOT entries) might be hijacked due to the absence of full RELRO protection.\n\n## Reference\n\n* man page: `ld(1)`\n* man page: `ld.so(8)`\n* glibc - [`__dl_runtime_resolve`](https://elixir.bootlin.com/glibc/glibc-2.41.9000/source/sysdeps/arm/dl-trampoline.S#L30) implementation (for Arm32)\n* Application Binary Interface for the Arm Architecture - [`abi-aa`](https://github.com/ARM-software/abi-aa)\n * `aaelf32`\n * `aapcs32`\n" }, { "path": "lib/c.c", "content": "/*\n * shecc - Self-Hosting and Educational C Compiler.\n *\n * shecc is freely redistributable under the BSD 2 clause license. See the\n * file \"LICENSE\" for information on usage and redistribution of this file.\n */\n\n/* minimal libc implementation */\n#include \"c.h\"\n#define INT_BUF_LEN 16\n\n#define __is_alpha(c) ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))\n#define __is_digit(c) ((c >= '0' && c <= '9'))\n#define __is_hex(c) \\\n (__is_digit(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))\n\nint isdigit(int c)\n{\n return __is_digit(c);\n}\n\nint isalpha(int c)\n{\n return __is_alpha(c);\n}\n\nint isalnum(int c)\n{\n return __is_alpha(c) || __is_digit(c);\n}\n\nint isxdigit(int c)\n{\n return __is_hex(c);\n}\n\nint isblank(int c)\n{\n return c == ' ' || c == '\\t';\n}\n\nint strlen(char *str)\n{\n /* process the string by checking 4 characters (a 32-bit word) at a time */\n int i = 0;\n for (;; i += 4) {\n if (!str[i])\n return i;\n if (!str[i + 1])\n return i + 1;\n if (!str[i + 2])\n return i + 2;\n if (!str[i + 3])\n return i + 3;\n }\n}\n\nint strcmp(char *s1, char *s2)\n{\n int i = 0;\n while (s1[i] && s2[i]) {\n if (s1[i] < s2[i])\n return -1;\n if (s1[i] > s2[i])\n return 1;\n i++;\n }\n return s1[i] - s2[i];\n}\n\nint strncmp(char *s1, char *s2, int len)\n{\n int i = 0;\n while (i < len) {\n if (s1[i] < s2[i])\n return -1;\n if (s1[i] > s2[i])\n return 1;\n if (!s1[i])\n return 0;\n i++;\n }\n return 0;\n}\n\nchar *strcpy(char *dest, char *src)\n{\n int i = 0;\n while (src[i]) {\n dest[i] = src[i];\n i++;\n }\n dest[i] = 0;\n return dest;\n}\n\nchar *strncpy(char *dest, char *src, int len)\n{\n int i = 0;\n int beyond = 0;\n while (i < len) {\n if (beyond == 0) {\n dest[i] = src[i];\n if (src[i] == 0)\n beyond = 1;\n } else {\n dest[i] = 0;\n }\n i++;\n }\n return dest;\n}\n\nchar *memcpy(char *dest, char *src, int count)\n{\n int i = 0;\n\n /* Continues as long as there are at least 4 bytes remaining to copy. */\n for (; i + 4 <= count; i += 4) {\n dest[i] = src[i];\n dest[i + 1] = src[i + 1];\n dest[i + 2] = src[i + 2];\n dest[i + 3] = src[i + 3];\n }\n\n /* Ensure all @count bytes are copied, even if @count is not a multiple of\n * 4, or if @count was less than 4 initially.\n */\n for (; i < count; i++)\n dest[i] = src[i];\n\n return dest;\n}\n\nint memcmp(void *s1, void *s2, int n)\n{\n char *p1 = (char *) s1, *p2 = (char *) s2;\n\n for (int i = 0; i < n; i++) {\n if (p1[i] < p2[i])\n return -1;\n if (p1[i] > p2[i])\n return 1;\n }\n return 0;\n}\n\nvoid *memset(void *s, int c, int n)\n{\n int i = 0;\n char *ptr = (char *) s;\n char byte_val = (char) c;\n for (; i + 4 <= n; i += 4) {\n ptr[i] = byte_val;\n ptr[i + 1] = byte_val;\n ptr[i + 2] = byte_val;\n ptr[i + 3] = byte_val;\n }\n\n for (; i < n; i++)\n ptr[i] = byte_val;\n\n return s;\n}\n\n/* set 10 digits (32bit) without div\n *\n * This function converts a given integer value to its string representation\n * in base-10 without using division operations. The method involves calculating\n * the approximate quotient and remainder using bitwise operations, which are\n * then used to derive each digit of the result.\n *\n * The logic is based on an efficient method of dividing by constants, as\n * detailed in the reference link:\n * http://web.archive.org/web/20180517023231/http://www.hackersdelight.org/divcMore.pdf.\n * This approach avoids expensive division instructions by using a series of\n * bitwise shifts and additions to calculate the quotient and remainder.\n */\nvoid __str_base10(char *pb, int val)\n{\n int neg = 0;\n int q, r, t;\n int i = INT_BUF_LEN - 1;\n\n if (val == -2147483648) {\n strncpy(pb + INT_BUF_LEN - 11, \"-2147483648\", 11);\n return;\n }\n if (val < 0) {\n neg = 1;\n val = -val;\n }\n\n while (val) {\n q = (val >> 1) + (val >> 2);\n q += (q >> 4);\n q += (q >> 8);\n q += (q >> 16);\n q >>= 3;\n r = val - (((q << 2) + q) << 1);\n t = ((r + 6) >> 4);\n q += t;\n r -= (((t << 2) + t) << 1);\n\n pb[i] += r;\n val = q;\n i--;\n }\n\n if (neg)\n pb[i] = '-';\n}\n\nvoid __str_base8(char *pb, int val)\n{\n int c = INT_BUF_LEN - 1, v;\n\n /* Because every 3 binary digits can be converted to 1 octal digit, here\n * performs the conversion 10 times, derived from 32 divided by 3.\n *\n * Finally, the remaining 2 bits are processed after the loop.\n */\n int times = (sizeof(int) << 3) / 3;\n for (int i = 0; i < times; i++) {\n v = val & 0x7;\n pb[c] = '0' + v;\n val >>= 3;\n c--;\n }\n v = val & 0x3;\n pb[c] = '0' + v;\n}\n\nvoid __str_base16(char *pb, int val)\n{\n int c = INT_BUF_LEN - 1;\n int times = sizeof(int) << 1;\n for (int i = 0; i < times; i++) {\n int v = val & 0xf;\n if (v < 10)\n pb[c] = '0' + v;\n else if (v < 16)\n pb[c] = 'a' + v - 10;\n else {\n abort();\n break;\n }\n val >>= 4;\n c--;\n }\n}\n\n/* The specification of snprintf() is defined in C99 7.19.6.5, and its behavior\n * and return value should comply with the following description:\n * - If n is zero, nothing is written.\n * - Writes at most n bytes, including the null character.\n * - On success, the return value should be the length of the entire converted\n * string even if n is insufficient to store it.\n *\n * Thus, a structure fmtbuf_t is defined for formatted output conversion for\n * the functions in the printf() family.\n * @buf: the current position of the buffer.\n * @n : the remaining space of the buffer.\n * @len: the number of characters that would have been written (excluding the\n * null terminator) had n been sufficiently large.\n *\n * Once a write operation is performed, buf and n will be respectively\n * incremented and decremented by the actual written size if n is sufficient,\n * and len must be incremented to store the length of the entire converted\n * string.\n */\ntypedef struct {\n char *buf;\n int n;\n int len;\n} fmtbuf_t;\n\nvoid __fmtbuf_write_char(fmtbuf_t *fmtbuf, int val)\n{\n fmtbuf->len += 1;\n\n /* Write the given character when n is greater than 1.\n * This means preserving one position for the null character.\n */\n if (fmtbuf->n <= 1)\n return;\n\n char ch = (char) (val & 0xFF);\n fmtbuf->buf[0] = ch;\n fmtbuf->buf += 1;\n fmtbuf->n -= 1;\n}\n\nvoid __fmtbuf_write_str(fmtbuf_t *fmtbuf, char *str, int l)\n{\n fmtbuf->len += l;\n\n /* Write the given string when n is greater than 1.\n * This means preserving one position for the null character.\n */\n if (fmtbuf->n <= 1)\n return;\n\n /* If the remaining space is less than the length of the string, write only\n * n - 1 bytes.\n */\n int sz = fmtbuf->n - 1;\n l = l <= sz ? l : sz;\n strncpy(fmtbuf->buf, str, l);\n fmtbuf->buf += l;\n fmtbuf->n -= l;\n}\n\nvoid __format(fmtbuf_t *fmtbuf,\n int val,\n int width,\n int zeropad,\n int base,\n int alternate_form)\n{\n char pb[INT_BUF_LEN], ch;\n int pbi;\n\n /* set to zeroes */\n for (pbi = 0; pbi < INT_BUF_LEN; pbi++)\n pb[pbi] = '0';\n\n pbi = 0;\n\n switch (base) {\n case 8:\n __str_base8(pb, val);\n break;\n case 10:\n __str_base10(pb, val);\n break;\n case 16:\n __str_base16(pb, val);\n break;\n default:\n abort();\n break;\n }\n\n while (pb[pbi] == '0' && pbi < INT_BUF_LEN - 1)\n pbi++;\n\n switch (base) {\n case 8:\n if (alternate_form) {\n if (width && zeropad && pb[pbi] != '0') {\n __fmtbuf_write_char(fmtbuf, '0');\n width -= 1;\n } else if (pb[pbi] != '0')\n pb[--pbi] = '0';\n }\n break;\n case 10:\n if (width && zeropad && pb[pbi] == '-') {\n __fmtbuf_write_char(fmtbuf, '-');\n pbi++;\n width--;\n }\n break;\n case 16:\n if (alternate_form) {\n if (width && zeropad && pb[pbi] != '0') {\n __fmtbuf_write_char(fmtbuf, '0');\n __fmtbuf_write_char(fmtbuf, 'x');\n width -= 2;\n } else if (pb[pbi] != '0') {\n pb[--pbi] = 'x';\n pb[--pbi] = '0';\n }\n }\n break;\n }\n\n width -= (INT_BUF_LEN - pbi);\n if (width < 0)\n width = 0;\n\n ch = zeropad ? '0' : ' ';\n while (width) {\n __fmtbuf_write_char(fmtbuf, ch);\n width--;\n }\n\n __fmtbuf_write_str(fmtbuf, pb + pbi, INT_BUF_LEN - pbi);\n}\n\nvoid __format_to_buf(fmtbuf_t *fmtbuf, char *format, int *var_args)\n{\n int si = 0, pi = 0;\n\n while (format[si]) {\n if (format[si] != '%') {\n __fmtbuf_write_char(fmtbuf, format[si]);\n si++;\n } else {\n int w = 0, zp = 0, pp = 0, v = var_args[pi], l;\n\n si++;\n if (format[si] == '#') {\n pp = 1;\n si++;\n }\n if (format[si] == '0') {\n zp = 1;\n si++;\n }\n if (format[si] >= '1' && format[si] <= '9') {\n w = format[si] - '0';\n si++;\n while (format[si] >= '0' && format[si] <= '9') {\n w *= 10;\n w += format[si] - '0';\n si++;\n }\n }\n switch (format[si]) {\n case 's':\n /* append param pi as string */\n l = strlen((char *) v);\n __fmtbuf_write_str(fmtbuf, (char *) v, l);\n break;\n case 'c':\n /* append param pi as char */\n __fmtbuf_write_char(fmtbuf, (char) v);\n break;\n case 'o':\n /* append param as octal */\n __format(fmtbuf, v, w, zp, 8, pp);\n break;\n case 'd':\n /* append param as decimal */\n __format(fmtbuf, v, w, zp, 10, 0);\n break;\n case 'x':\n /* append param as hex */\n __format(fmtbuf, v, w, zp, 16, pp);\n break;\n case '%':\n /* append literal '%' character */\n __fmtbuf_write_char(fmtbuf, '%');\n si++;\n continue;\n }\n pi++;\n si++;\n }\n }\n\n /* If n is still greater than 0, set the null character. */\n if (fmtbuf->n)\n fmtbuf->buf[0] = 0;\n}\n\nint printf(char *str, ...)\n{\n char buffer[200];\n fmtbuf_t fmtbuf;\n\n fmtbuf.buf = buffer;\n fmtbuf.n = INT_MAX;\n fmtbuf.len = 0;\n __format_to_buf(&fmtbuf, str, &str + 4);\n return __syscall(__syscall_write, 1, buffer, fmtbuf.len);\n}\n\nint sprintf(char *buffer, char *str, ...)\n{\n fmtbuf_t fmtbuf;\n\n fmtbuf.buf = buffer;\n fmtbuf.n = INT_MAX;\n fmtbuf.len = 0;\n __format_to_buf(&fmtbuf, str, &str + 4);\n return fmtbuf.len;\n}\n\nint snprintf(char *buffer, int n, char *str, ...)\n{\n fmtbuf_t fmtbuf;\n\n fmtbuf.buf = buffer;\n fmtbuf.n = n;\n fmtbuf.len = 0;\n __format_to_buf(&fmtbuf, str, &str + 4);\n return fmtbuf.len;\n}\n\nint __free_all(void);\n\nvoid exit(int exit_code)\n{\n __free_all();\n __syscall(__syscall_exit, exit_code);\n}\n\nvoid abort(void)\n{\n printf(\"Abnormal program termination\\n\");\n exit(-1);\n}\n\nFILE *fopen(char *filename, char *mode)\n{\n if (!strcmp(mode, \"wb\")) {\n#if defined(__arm__)\n return __syscall(__syscall_open, filename, 65, 0x1fd);\n#elif defined(__riscv)\n /* FIXME: mode not work currently in RISC-V */\n return __syscall(__syscall_openat, -100, filename, 65, 0x1fd);\n#endif\n }\n if (!strcmp(mode, \"rb\")) {\n#if defined(__arm__)\n return __syscall(__syscall_open, filename, 0, 0);\n#elif defined(__riscv)\n return __syscall(__syscall_openat, -100, filename, 0, 0);\n#endif\n }\n return NULL;\n}\n\nint fclose(FILE *stream)\n{\n __syscall(__syscall_close, stream);\n return 0;\n}\n\n/* Read a byte from file descriptor. So the return value is either in the range\n * of 0 to 127 for the character, or -1 on the end of file.\n */\nint fgetc(FILE *stream)\n{\n int buf = 0, r = __syscall(__syscall_read, stream, &buf, 1);\n if (r < 1)\n return -1;\n return buf;\n}\n\nchar *fgets(char *str, int n, FILE *stream)\n{\n int i;\n for (i = 0; i < n - 1; i++) {\n int c = fgetc(stream);\n if (c == -1) {\n if (i == 0)\n /* EOF on first char */\n return NULL;\n /* EOF in the middle */\n str[i] = 0;\n return str;\n }\n /* Use explicit cast for clarity */\n str[i] = (char) c;\n\n if (c == '\\n') {\n str[i + 1] = 0;\n return str;\n }\n }\n str[i] = 0;\n return str;\n}\n\nint fputc(int c, FILE *stream)\n{\n if (__syscall(__syscall_write, stream, &c, 1) < 0)\n return -1;\n return c;\n}\n\nint fseek(FILE *stream, int offset, int whence)\n{\n int result;\n#if defined(__arm__)\n result = __syscall(__syscall_lseek, stream, offset, whence);\n#elif defined(__riscv)\n /* No need to offset */\n result = __syscall(__syscall_lseek, stream, 0, offset, NULL, whence);\n#else\n#error \"Unsupported fseek support for current platform\"\n#endif\n return result == -1;\n}\n\nint ftell(FILE *stream)\n{\n#if defined(__arm__)\n return __syscall(__syscall_lseek, stream, 0, SEEK_CUR);\n#elif defined(__riscv)\n int result;\n __syscall(__syscall_lseek, stream, 0, 0, &result, SEEK_CUR);\n return result;\n#else\n#error \"Unsupported ftell support for current platform\"\n#endif\n}\n\n#define CHUNK_SIZE_FREED_MASK 1\n#define CHUNK_SIZE_SZ_MASK 0xFFFFFFFE\n#define CHUNK_GET_SIZE(size) (size & CHUNK_SIZE_SZ_MASK)\n#define IS_CHUNK_GET_FREED(size) (size & CHUNK_SIZE_FREED_MASK)\n\ntypedef struct chunk {\n struct chunk *next, *prev;\n int size;\n} chunk_t;\n\nvoid chunk_set_freed(chunk_t *chunk)\n{\n chunk->size |= CHUNK_SIZE_FREED_MASK;\n}\n\nvoid chunk_clear_freed(chunk_t *chunk)\n{\n chunk->size &= CHUNK_SIZE_SZ_MASK;\n}\n\nint __align_up(int size)\n{\n return ALIGN_UP(size, PAGESIZE);\n}\n\nchunk_t *__alloc_head;\nchunk_t *__alloc_tail;\nchunk_t *__freelist_head;\n\nvoid *malloc(int size)\n{\n if (size <= 0)\n return NULL;\n\n int flags = 34; /* MAP_PRIVATE (0x02) | MAP_ANONYMOUS (0x20) */\n int prot = 3; /* PROT_READ (0x01) | PROT_WRITE (0x02) */\n\n /* Align size to MIN_ALIGNMENT */\n size = ALIGN_UP(size, MIN_ALIGNMENT);\n\n if (!__alloc_head) {\n chunk_t *tmp =\n __syscall(__syscall_mmap2, NULL, __align_up(sizeof(chunk_t)), prot,\n flags, -1, 0);\n __alloc_head = tmp;\n __alloc_tail = tmp;\n __alloc_head->next = NULL;\n __alloc_head->prev = NULL;\n __alloc_head->size = 0;\n }\n\n if (!__freelist_head) {\n chunk_t *tmp =\n __syscall(__syscall_mmap2, NULL, __align_up(sizeof(chunk_t)), prot,\n flags, -1, 0);\n __freelist_head = tmp;\n __freelist_head->next = NULL;\n __freelist_head->prev = NULL;\n __freelist_head->size = -1;\n }\n\n /* Search for the best fit chunk in the free list */\n chunk_t *best_fit_chunk = NULL;\n chunk_t *allocated;\n int best_size = 0;\n\n if (!__freelist_head->next) {\n allocated = NULL;\n } else {\n for (chunk_t *fh = __freelist_head; fh->next; fh = fh->next) {\n int fh_size = CHUNK_GET_SIZE(fh->size);\n if (fh_size >= size && (!best_fit_chunk || fh_size < best_size)) {\n best_fit_chunk = fh;\n best_size = fh_size;\n }\n }\n\n if (best_fit_chunk) {\n /* Remove from freelist */\n if (best_fit_chunk->prev) {\n best_fit_chunk->prev->next = best_fit_chunk->next;\n } else {\n __freelist_head = best_fit_chunk->next;\n }\n if (best_fit_chunk->next) {\n best_fit_chunk->next->prev = best_fit_chunk->prev;\n }\n }\n allocated = best_fit_chunk;\n }\n\n if (!allocated) {\n allocated =\n __syscall(__syscall_mmap2, NULL, __align_up(sizeof(chunk_t) + size),\n prot, flags, -1, 0);\n allocated->size = __align_up(sizeof(chunk_t) + size);\n }\n\n /* Add to allocation list */\n __alloc_tail->next = allocated;\n allocated->prev = __alloc_tail;\n __alloc_tail = allocated;\n __alloc_tail->next = NULL;\n __alloc_tail->size = allocated->size;\n chunk_clear_freed(__alloc_tail);\n\n void *ptr = (void *) (__alloc_tail + 1);\n return ptr;\n}\n\nvoid *calloc(int n, int size)\n{\n /* Check for overflow before multiplication */\n if (!n || !size)\n return NULL;\n if (n > INT_MAX / size)\n return NULL; /* Overflow protection */\n\n int total = n * size;\n char *p = malloc(total);\n\n if (!p)\n return NULL;\n\n return memset(p, 0, total);\n}\n\nvoid __rfree(void *ptr, int size)\n{\n if (!ptr)\n return;\n __syscall(__syscall_munmap, ptr, size);\n}\n\nint __free_all(void)\n{\n if (!__freelist_head && !__alloc_head)\n return 0;\n\n chunk_t *cur = __freelist_head;\n chunk_t *rel;\n int size;\n\n /* release freelist */\n while (cur && cur->next) {\n rel = cur;\n cur = cur->next;\n rel->next = NULL;\n rel->prev = NULL;\n size = CHUNK_GET_SIZE(rel->size);\n __rfree(rel, size);\n }\n\n if (__alloc_head && __alloc_head->next) {\n cur = __alloc_head->next;\n /* release chunks which not be free */\n while (cur) {\n rel = cur;\n cur = cur->next;\n rel->next = NULL;\n rel->prev = NULL;\n size = CHUNK_GET_SIZE(rel->size);\n __rfree(rel, size);\n }\n }\n return 0;\n}\n\nvoid free(void *ptr)\n{\n if (!ptr)\n return;\n\n char *__ptr = (char *) ptr;\n chunk_t *cur = (chunk_t *) (__ptr - sizeof(chunk_t));\n if (IS_CHUNK_GET_FREED(cur->size)) {\n printf(\"free(): double free detected\\n\");\n abort();\n }\n\n chunk_t *prev = NULL;\n if (cur->prev) {\n prev = cur->prev;\n prev->next = cur->next;\n } else {\n __alloc_head = cur->next;\n }\n\n if (cur->next) {\n chunk_t *next = cur->next;\n next->prev = cur->prev;\n } else if (prev) {\n prev->next = NULL;\n __alloc_tail = prev;\n }\n\n /* Insert head in __freelist_head */\n cur->next = __freelist_head;\n cur->prev = NULL;\n chunk_set_freed(cur);\n if (__freelist_head)\n __freelist_head->prev = cur;\n __freelist_head = cur;\n}\n" }, { "path": "lib/c.h", "content": "/*\n * shecc - Self-Hosting and Educational C Compiler.\n *\n * shecc is freely redistributable under the BSD 2 clause license. See the\n * file \"LICENSE\" for information on usage and redistribution of this file.\n */\n\n#pragma once\n/* Declarations of C standard library functions */\n\n#define NULL 0\n\n#define bool _Bool\n#define true 1\n#define false 0\n\n#define INT_MAX 0x7fffffff\n#define INT_MIN 0x80000000\n\n#define SEEK_SET 0\n#define SEEK_CUR 1\n#define SEEK_END 2\n\n#if defined(__arm__)\n#define __SIZEOF_POINTER__ 4\n#define __syscall_exit 1\n#define __syscall_read 3\n#define __syscall_write 4\n#define __syscall_close 6\n#define __syscall_open 5\n#define __syscall_lseek 19\n#define __syscall_mmap2 192\n#define __syscall_munmap 91\n\n#elif defined(__riscv)\n#define __SIZEOF_POINTER__ 4\n#define __syscall_exit 93\n#define __syscall_read 63\n#define __syscall_write 64\n#define __syscall_close 57\n#define __syscall_open 1024\n#define __syscall_openat 56\n#define __syscall_lseek 62\n#define __syscall_mmap2 222\n#define __syscall_munmap 215\n\n#else /* Only Arm32 and RV32 are supported */\n#error \"Unsupported architecture\"\n#endif\n\n/* Non-portable: Assume page size is 4KiB */\n#define PAGESIZE 4096\n\n/* Minimum alignment for all memory allocations. */\n#define MIN_ALIGNMENT 8\n#define ALIGN_UP(val, align) (((val) + (align) - 1) & ~((align) - 1))\n\n/* va_list support for variadic functions */\ntypedef int *va_list;\n\n/* Character predicate functions */\nint isdigit(int c);\nint isalpha(int c);\nint isalnum(int c);\nint isxdigit(int c);\nint isblank(int c);\n\n/* File I/O */\ntypedef int FILE;\nFILE *fopen(char *filename, char *mode);\nint fclose(FILE *stream);\nint fgetc(FILE *stream);\nchar *fgets(char *str, int n, FILE *stream);\nint fputc(int c, FILE *stream);\nint fseek(FILE *stream, int offset, int whence);\nint ftell(FILE *stream);\n\n/* string-related functions */\nint strlen(char *str);\nint strcmp(char *s1, char *s2);\nint strncmp(char *s1, char *s2, int len);\nchar *strcpy(char *dest, char *src);\nchar *strncpy(char *dest, char *src, int len);\nchar *memcpy(char *dest, char *src, int count);\nint memcmp(void *s1, void *s2, int n);\nvoid *memset(void *s, int c, int n);\n\n/* formatted output string */\nint printf(char *str, ...);\nint sprintf(char *buffer, char *str, ...);\nint snprintf(char *buffer, int n, char *str, ...);\n\n/* Terminating program */\nvoid exit(int exit_code);\nvoid abort(void);\n\n/* Dynamic memory allocation/deallocation functions */\nvoid *malloc(int size);\nvoid *calloc(int n, int size);\nvoid free(void *ptr);\n" }, { "path": "mk/arm.mk", "content": "# Allow the following machines to use native execution\n#\n# - Beaglebone Black (Cortex-A8)\n# - Raspberry Pi 3 (Cortex-A53)\n# - Raspberry Pi 4 (Cortex-A72)\n# - Raspberry Pi 5 (Cortex-A76)\nALLOW_MACHINES = BeagleBone-Black Raspberry-Pi-3 Raspberry-Pi-4 Raspberry-Pi-5\nARCH_RUNNER = qemu-arm\nARCH_DEFS = \\\n \"/* target: ARM */\\n$\\\n \\#pragma once\\n$\\\n \\#define ARCH_PREDEFINED \\\"__arm__\\\" /* defined by GNU C and RealView */\\n$\\\n \\#define ELF_MACHINE 0x28 /* up to ARMv7/Aarch32 */\\n$\\\n \\#define ELF_FLAGS 0x5000400\\n$\\\n \\#define DYN_LINKER \\\"/lib/ld-linux-armhf.so.3\\\"\\n$\\\n \\#define LIBC_SO \\\"libc.so.6\\\"\\n$\\\n \\#define PLT_FIXUP_SIZE 20\\n$\\\n \\#define PLT_ENT_SIZE 12\\n$\\\n \\#define R_ARCH_JUMP_SLOT 0x16\\n$\\\n \\#define MAX_ARGS_IN_REG 4\\n$\\\n \"\n\n# If the running machine has the \"fastfetch\" tool installed, the build\n# system will verify whether native execution can be performed.\nifneq ($(shell which fastfetch),)\n # 1. Replace whitespaces with hyphens after retrieving the host\n # machine name via the \"fastfetch\" tool.\n #\n # 2. If at least one machine name in the allowlist is found in\n # the host machine name, it can perform native execution.\n #\n # Therefore, set USE_QEMU to 0.\n HOST_MACHINE = $(shell fastfetch --logo none --structure Host | sed 's/ /-/g')\n USE_QEMU = $(if $(strip $(foreach MACHINE, $(ALLOW_MACHINES), $(findstring $(MACHINE),$(HOST_MACHINE)))),0,1)\n\n # Special case: GitHub workflows on Arm64 runners\n #\n # When an Arm-hosted runner executes \"fastfetch --logo none --structure Host\",\n # it produces the following output:\n # \n # Host: Virtual Machine (Hyper-V UEFI Release v4.1)\n #\n # Arm-hosted runners are also capable of performing native execution. However,\n # directly adding \"Virtual-Machine\" to the allowlist would be ambiguous.\n # Therefore, the build system instead checks the CPU name using the\n # \"fastfetch --logo none --structure CPU\" command.\n #\n # If the detected CPU is \"Neoverse-N2\", the build system treats the running\n # machine as an Arm-hosted runner and enable native execution.\n ifeq ($(USE_QEMU),1)\n HOST_CPU = $(shell fastfetch --logo none --structure CPU | sed 's/ /-/g')\n USE_QEMU = $(if $(strip $(findstring Neoverse-N2,$(HOST_CPU))),0,1)\n endif\nendif\n\n# Find the sysroot of the ARM GNU toolchain if using dynamic linking.\n#\n# Since developers may install the toolchain manually instead of\n# using a package manager such as apt, we cannot assume that the\n# path of ld-linux is always \"/usr/arm-linux-gnueabihf\".\n#\n# Therefore, the following process first locates find the correct\n# sysroot of the toolchain, and then generate the ELF interpreter\n# prefix for later use.\nifeq ($(USE_QEMU),1)\n ifeq ($(DYNLINK),1)\n CROSS_COMPILE = arm-none-linux-gnueabihf-\n ARM_CC = $(CROSS_COMPILE)gcc\n ARM_CC := $(shell which $(ARM_CC))\n ifndef ARM_CC\n CROSS_COMPILE = arm-linux-gnueabihf-\n ARM_CC = $(CROSS_COMPILE)gcc\n ARM_CC := $(shell which $(ARM_CC))\n ifndef ARM_CC\n $(error \"Unable to find ARM GNU toolchain.\")\n endif\n endif\n\n LD_LINUX_PATH := $(shell cd $(shell $(ARM_CC) --print-sysroot) 2>/dev/null && pwd)\n ifeq (\"$(LD_LINUX_PATH)\",\"/\")\n LD_LINUX_PATH := $(shell dirname \"$(shell which $(ARM_CC))\")/..\n LD_LINUX_PATH := $(shell cd $(LD_LINUX_PATH) 2>/dev/null && pwd)\n LD_LINUX_PATH := $(LD_LINUX_PATH)/$(shell echo $(CROSS_COMPILE) | sed s'/.$$//')/libc\n LD_LINUX_PATH := $(shell cd $(LD_LINUX_PATH) 2>/dev/null && pwd)\n ifndef LD_LINUX_PATH\n LD_LINUX_PATH = /usr/$(shell echo $(CROSS_COMPILE) | sed s'/.$$//')\n LD_LINUX_PATH := $(shell cd $(LD_LINUX_PATH) 2>/dev/null && pwd)\n endif\n endif\n\n ifndef LD_LINUX_PATH\n $(error \"Dynamic linking mode requires ld-linux.so\")\n endif\n\n RUNNER_LD_PREFIX = -L $(LD_LINUX_PATH)\n endif\nendif\n" }, { "path": "mk/common.mk", "content": "UNAME_S := $(shell uname -s)\nifeq ($(UNAME_S),Darwin)\n PRINTF = printf\nelse\n PRINTF = env printf\nendif\n\n# Control the build verbosity\nifeq (\"$(VERBOSE)\",\"1\")\n Q :=\n VECHO = @true\n REDIR =\nelse\n Q := @\n VECHO = @$(PRINTF)\n REDIR = >/dev/null\nendif\n\n# Test suite\nPASS_COLOR = \\e[32;01m\nNO_COLOR = \\e[0m\n\npass = $(PRINTF) \"$(PASS_COLOR)$1 Passed$(NO_COLOR)\\n\"\n\n# Check the prerequisites\nPREREQ_LIST := dot jq\nTARGET_EXEC ?=\nifeq ($(USE_QEMU),1)\n # Add qemu to the list if the host and target architectures differ\n PREREQ_LIST += $(ARCH_RUNNER)\n ifeq ($(filter $(ARCH_RUNNER),$(notdir $(shell which $(ARCH_RUNNER)))),)\n STAGE1_WARN_MSG := \"Warning: failed to build the stage 1 and $\\\n stage 2 compilers due to missing $(ARCH_RUNNER)\\n\"\n STAGE1_CHECK_CMD := $(VECHO) $(STAGE1_WARN_MSG) && exit 1\n endif\n\n # Generate the path to the architecture-specific qemu\n TARGET_EXEC = $(shell which $(ARCH_RUNNER))\n ifeq ($(DYNLINK),1)\n TARGET_EXEC += $(RUNNER_LD_PREFIX)\n endif\nendif\nexport TARGET_EXEC\n\nPREREQ_EXEC := $(shell which $(PREREQ_LIST))\nPREREQ_MISSING := $(filter-out $(notdir $(PREREQ_EXEC)),$(PREREQ_LIST))\n\nifdef PREREQ_MISSING\n CONFIG_WARN_MSG := \"Warning: missing packages: $(PREREQ_MISSING)\\n$\\\n Warning: Please check package installation\\n\"\n CONFIG_CHECK_CMD := $(VECHO) $(CONFIG_WARN_MSG)\nendif\n" }, { "path": "mk/riscv.mk", "content": "# Enforce the use qemu of by setting the ALLOW_MACHINES variable to empty\nALLOW_MACHINES =\nARCH_RUNNER = qemu-riscv32\nARCH_DEFS = \\\n \"/* target: RISCV */\\n$\\\n \\#pragma once\\n$\\\n \\#define ARCH_PREDEFINED \\\"__riscv\\\" /* Older versions of the GCC toolchain defined __riscv__ */\\n$\\\n \\#define ELF_MACHINE 0xf3\\n$\\\n \\#define ELF_FLAGS 0\\n$\\\n \\#define DYN_LINKER \\\"/lib/ld-linux.so.3\\\"\\n$\\\n \\#define LIBC_SO \\\"libc.so.6\\\"\\n$\\\n \\#define PLT_FIXUP_SIZE 20\\n$\\\n \\#define PLT_ENT_SIZE 12\\n$\\\n \\#define R_ARCH_JUMP_SLOT 0x5\\n$\\\n \\#define MAX_ARGS_IN_REG 8\\n$\\\n \"\n\n# TODO: Set this variable for RISC-V architecture\nRUNNER_LD_PREFIX=\n" }, { "path": "src/arch-lower.c", "content": "/*\n * shecc - Architecture-specific IR lowering stage\n *\n * Introduces a minimal arch-lowering boundary that applies target-specific\n * tweaks to phase-2 IR (ph2_ir) before final code generation. This keeps\n * backends simpler by moving decisions that depend on CFG shape or target\n * quirks out of emit-time where possible.\n */\n\n#include \"../config\"\n#include \"defs.h\"\n\n/* ARM-specific lowering:\n * - Mark detached conditional branches so codegen can decide between\n * short/long forms without re-deriving CFG shape.\n */\nvoid arm_lower(void)\n{\n for (func_t *func = FUNC_LIST.head; func; func = func->next) {\n /* Skip function declarations without bodies */\n if (!func->bbs)\n continue;\n\n for (basic_block_t *bb = func->bbs; bb; bb = bb->rpo_next) {\n for (ph2_ir_t *insn = bb->ph2_ir_list.head; insn;\n insn = insn->next) {\n /* Mark branches that don't fall through to next block */\n if (insn->op == OP_branch) {\n /* In SSA, we index 'else_bb' first, and then 'then_bb' */\n insn->is_branch_detached = (insn->else_bb != bb->rpo_next);\n }\n }\n }\n }\n}\n\n/* RISC-V-specific lowering:\n * - Mark detached conditional branches\n * - Future: prepare for RISC-V specific patterns\n */\nvoid riscv_lower(void)\n{\n for (func_t *func = FUNC_LIST.head; func; func = func->next) {\n /* Skip function declarations without bodies */\n if (!func->bbs)\n continue;\n\n for (basic_block_t *bb = func->bbs; bb; bb = bb->rpo_next) {\n for (ph2_ir_t *insn = bb->ph2_ir_list.head; insn;\n insn = insn->next) {\n /* Mark branches that don't fall through to next block */\n if (insn->op == OP_branch)\n insn->is_branch_detached = (insn->else_bb != bb->rpo_next);\n }\n }\n }\n}\n\n/* Entry point: dispatch to the active architecture. */\nvoid arch_lower(void)\n{\n#if ELF_MACHINE == 0x28 /* ARM */\n arm_lower();\n#elif ELF_MACHINE == 0xf3 /* RISC-V */\n riscv_lower();\n#else\n /* Unknown architecture: keep behavior as-is. */\n (void) 0;\n#endif\n}\n" }, { "path": "src/arm-codegen.c", "content": "/*\n * shecc - Self-Hosting and Educational C Compiler.\n *\n * shecc is freely redistributable under the BSD 2 clause license. See the\n * file \"LICENSE\" for information on usage and redistribution of this file.\n */\n\n/* Translate IR to target machine code */\n\n#include \"arm.c\"\n#include \"defs.h\"\n#include \"globals.c\"\n\nvoid update_elf_offset(ph2_ir_t *ph2_ir)\n{\n func_t *func;\n switch (ph2_ir->op) {\n case OP_load_constant:\n /* ARMv7 uses 12 bits to encode immediate value, but the higher 4 bits\n * are for rotation. See A5.2.4 \"Modified immediate constants in ARM\n * instructions\" in ARMv7-A manual.\n */\n if (ph2_ir->src0 < 0)\n elf_offset += 12;\n else if (ph2_ir->src0 > 255)\n elf_offset += 8;\n else\n elf_offset += 4;\n return;\n case OP_address_of:\n case OP_global_address_of:\n /* ARMv7 uses 12 bits to encode immediate value, but the higher 4 bits\n * are for rotation. See A5.2.4 \"Modified immediate constants in ARM\n * instructions\" in ARMv7-A manual.\n */\n if (ph2_ir->src0 > 255)\n elf_offset += 12;\n else if (ph2_ir->src0 >= 0)\n elf_offset += 4;\n else\n abort();\n return;\n case OP_assign:\n if (ph2_ir->dest != ph2_ir->src0)\n elf_offset += 4;\n return;\n case OP_load:\n case OP_global_load:\n /* ARMv7 straight uses 12 bits to encode the offset of load instruction\n * (no rotation).\n */\n if (ph2_ir->src0 > 4095)\n elf_offset += 16;\n else if (ph2_ir->src0 >= 0)\n elf_offset += 4;\n else\n abort();\n return;\n case OP_store:\n case OP_global_store:\n /* ARMv7 straight uses 12 bits to encode the offset of store instruction\n * (no rotation).\n */\n if (ph2_ir->src1 > 4095)\n elf_offset += 16;\n else if (ph2_ir->src1 >= 0)\n elf_offset += 4;\n else\n abort();\n return;\n case OP_read:\n case OP_write:\n case OP_jump:\n case OP_load_func:\n case OP_indirect:\n case OP_add:\n case OP_sub:\n case OP_mul:\n case OP_lshift:\n case OP_rshift:\n case OP_bit_and:\n case OP_bit_or:\n case OP_bit_xor:\n case OP_negate:\n case OP_bit_not:\n elf_offset += 4;\n return;\n case OP_call:\n func = find_func(ph2_ir->func_name);\n if (func->bbs)\n elf_offset += 4;\n else if (dynlink) {\n /* When calling external functions in dynamic linking mode,\n * the following instructions are required:\n * - movw + movt: set r8 to 'elf_data_start'\n * - ldr: load a word from the address 'elf_data_start' into r12.\n * (restore the global stack pointer.)\n *\n * Therefore, the total offset is 16 bytes (4 instructions).\n */\n elf_offset += 16;\n } else {\n printf(\"The '%s' function is not implemented\\n\", ph2_ir->func_name);\n abort();\n }\n return;\n case OP_div:\n case OP_mod:\n if (hard_mul_div) {\n if (ph2_ir->op == OP_div)\n elf_offset += 4;\n else\n elf_offset += 12;\n return;\n }\n /* div/mod emulation's offset */\n elf_offset += 116;\n return;\n case OP_load_data_address:\n case OP_load_rodata_address:\n elf_offset += 8;\n return;\n case OP_address_of_func:\n case OP_eq:\n case OP_neq:\n case OP_gt:\n case OP_lt:\n case OP_geq:\n case OP_leq:\n case OP_log_not:\n elf_offset += 12;\n return;\n case OP_branch:\n if (ph2_ir->is_branch_detached)\n elf_offset += 12;\n else\n elf_offset += 8;\n return;\n case OP_return:\n elf_offset += 24;\n return;\n case OP_trunc:\n if (ph2_ir->src1 == 2)\n elf_offset += 8;\n else\n elf_offset += 4;\n return;\n case OP_sign_ext:\n elf_offset += 4;\n return;\n case OP_cast:\n elf_offset += 4;\n return;\n default:\n fatal(\"Unknown opcode\");\n }\n}\n\nvoid cfg_flatten(void)\n{\n func_t *func;\n\n if (dynlink)\n elf_offset =\n 100; /* offset of __libc_start_main + main_wrapper in codegen */\n else {\n func = find_func(\"__syscall\");\n func->bbs->elf_offset = 32; /* offset of start + branch in codegen */\n elf_offset = 92; /* offset of start + branch + syscall in codegen */\n }\n\n GLOBAL_FUNC->bbs->elf_offset = elf_offset;\n\n for (ph2_ir_t *ph2_ir = GLOBAL_FUNC->bbs->ph2_ir_list.head; ph2_ir;\n ph2_ir = ph2_ir->next) {\n update_elf_offset(ph2_ir);\n }\n\n /* prepare 'argc' and 'argv', then proceed to 'main' function */\n if (dynlink)\n elf_offset += 28;\n else\n elf_offset += 32; /* 6 insns for main call + 2 for exit */\n\n for (func = FUNC_LIST.head; func; func = func->next) {\n /* Skip function declarations without bodies */\n if (!func->bbs)\n continue;\n\n /* reserve stack */\n ph2_ir_t *flatten_ir = add_ph2_ir(OP_define);\n flatten_ir->src0 = func->stack_size;\n strncpy(flatten_ir->func_name, func->return_def.var_name, MAX_VAR_LEN);\n\n /* The actual offset of the top of the local stack is the sum of:\n * - 36 bytes (pushing registers r4-r11 and lr onto the stack)\n * - 4 bytes\n * (to ensure 8-byte alignment after pushing the 9 registers)\n * - ALIGN_UP(func->stack_size, 8)\n *\n * Note that func->stack_size does not include the 36 + 4 bytes,\n * so an additional 40 bytes should be added to\n * ALIGN_UP(func->stack_size, 8).\n */\n int stack_top_ofs = ALIGN_UP(func->stack_size, MIN_ALIGNMENT) + 40;\n\n for (basic_block_t *bb = func->bbs; bb; bb = bb->rpo_next) {\n bb->elf_offset = elf_offset;\n\n if (bb == func->bbs) {\n /* retrieve the global stack pointer and save ra, sp */\n elf_offset += 28;\n }\n\n for (ph2_ir_t *insn = bb->ph2_ir_list.head; insn;\n insn = insn->next) {\n /* For the instructions whose ofs_based_on_stack_top is set,\n * recalculate the operand's offset by adding stack_top_ofs.\n */\n if (insn->ofs_based_on_stack_top) {\n switch (insn->op) {\n case OP_load:\n case OP_address_of:\n insn->src0 = insn->src0 + stack_top_ofs;\n break;\n case OP_store:\n insn->src1 = insn->src1 + stack_top_ofs;\n break;\n default:\n /* Ignore opcodes with the ofs_based_on_stack_top\n * flag set since only the three opcodes above needs\n * to access a variable's address.\n */\n break;\n }\n }\n flatten_ir = add_existed_ph2_ir(insn);\n\n if (insn->op == OP_return) {\n /* restore sp */\n flatten_ir->src1 = bb->belong_to->stack_size;\n }\n\n /* Branch detachment is determined in the arch-lowering stage */\n\n update_elf_offset(flatten_ir);\n }\n }\n }\n}\n\nvoid emit(int code)\n{\n elf_write_int(elf_code, code);\n}\n\nvoid emit_ph2_ir(ph2_ir_t *ph2_ir)\n{\n func_t *func;\n const int rd = ph2_ir->dest;\n const int rn = ph2_ir->src0;\n int rm = ph2_ir->src1; /* Not const because OP_trunc modifies it */\n int ofs;\n bool is_external_call = false;\n\n /* Prepare this variable to reuse code for:\n * 1. division and modulo operations\n * 2. load and store operations\n * 3. address-of operations\n */\n arm_reg interm;\n\n switch (ph2_ir->op) {\n case OP_define:\n /* We should handle the function entry point carefully due to the\n * following constraints:\n * - according to AAPCS, the callee must preserve r4-r11 for the caller,\n * and the stack must always be 8-byte aligned.\n * - lr must be pushed because it may be modified when the function\n * calls another function.\n * - since external functions may call internal functions, r12 may not\n * hold the global stack pointer.\n *\n * Therefore, we perform the following operations:\n * 1. use a __stmdb instruction to push r4-r11 and lr onto the stack\n * first.\n * 2. retrieve the global stack pointer from the 4-byte global object\n * located at 'elf_data_start' to ensure correct access to the global\n * stack.\n * 3. set ofs to align(ph2_ir->src0, 8) + 4, and prepare a local\n * stack for the callee by subtracting ofs from sp.\n */\n emit(__stmdb(__AL, 1, __sp, 0x4FF0));\n emit(__movw(__AL, __r8, elf_data_start));\n emit(__movt(__AL, __r8, elf_data_start));\n emit(__lw(__AL, __r12, __r8, 0));\n ofs = ALIGN_UP(ph2_ir->src0, MIN_ALIGNMENT) + 4;\n emit(__movw(__AL, __r8, ofs));\n emit(__movt(__AL, __r8, ofs));\n emit(__sub_r(__AL, __sp, __sp, __r8));\n return;\n case OP_load_constant:\n if (ph2_ir->src0 < 0) {\n emit(__movw(__AL, __r8, -ph2_ir->src0));\n emit(__movt(__AL, __r8, -ph2_ir->src0));\n emit(__rsb_i(__AL, rd, 0, __r8));\n } else if (ph2_ir->src0 > 255) {\n emit(__movw(__AL, rd, ph2_ir->src0));\n emit(__movt(__AL, rd, ph2_ir->src0));\n } else\n emit(__mov_i(__AL, rd, ph2_ir->src0));\n return;\n case OP_address_of:\n case OP_global_address_of:\n interm = ph2_ir->op == OP_address_of ? __sp : __r12;\n if (ph2_ir->src0 > 255) {\n emit(__movw(__AL, __r8, ph2_ir->src0));\n emit(__movt(__AL, __r8, ph2_ir->src0));\n emit(__add_r(__AL, rd, interm, __r8));\n } else\n emit(__add_i(__AL, rd, interm, ph2_ir->src0));\n return;\n case OP_assign:\n emit(__mov_r(__AL, rd, rn));\n return;\n case OP_load:\n case OP_global_load:\n interm = ph2_ir->op == OP_load ? __sp : __r12;\n if (ph2_ir->src0 > 4095) {\n emit(__movw(__AL, __r8, ph2_ir->src0));\n emit(__movt(__AL, __r8, ph2_ir->src0));\n emit(__add_r(__AL, __r8, interm, __r8));\n emit(__lw(__AL, rd, __r8, 0));\n } else\n emit(__lw(__AL, rd, interm, ph2_ir->src0));\n return;\n case OP_store:\n case OP_global_store:\n interm = ph2_ir->op == OP_store ? __sp : __r12;\n if (ph2_ir->src1 > 4095) {\n emit(__movw(__AL, __r8, ph2_ir->src1));\n emit(__movt(__AL, __r8, ph2_ir->src1));\n emit(__add_r(__AL, __r8, interm, __r8));\n emit(__sw(__AL, rn, __r8, 0));\n } else\n emit(__sw(__AL, rn, interm, ph2_ir->src1));\n return;\n case OP_read:\n if (ph2_ir->src1 == 1)\n emit(__lb(__AL, rd, rn, 0));\n else if (ph2_ir->src1 == 2)\n emit(__lh(__AL, rd, rn, 0));\n else if (ph2_ir->src1 == 4)\n emit(__lw(__AL, rd, rn, 0));\n else\n abort();\n return;\n case OP_write:\n if (ph2_ir->dest == 1)\n emit(__sb(__AL, rm, rn, 0));\n else if (ph2_ir->dest == 2)\n emit(__sh(__AL, rm, rn, 0));\n else if (ph2_ir->dest == 4)\n emit(__sw(__AL, rm, rn, 0));\n else\n abort();\n return;\n case OP_branch:\n emit(__teq(rn));\n if (ph2_ir->is_branch_detached) {\n emit(__b(__NE, 8));\n emit(__b(__AL, ph2_ir->else_bb->elf_offset - elf_code->size));\n } else\n emit(__b(__NE, ph2_ir->then_bb->elf_offset - elf_code->size));\n return;\n case OP_jump:\n emit(__b(__AL, ph2_ir->next_bb->elf_offset - elf_code->size));\n return;\n case OP_call:\n func = find_func(ph2_ir->func_name);\n if (func->bbs)\n ofs = func->bbs->elf_offset - elf_code->size;\n else if (dynlink) {\n ofs = (dynamic_sections.elf_plt_start + func->plt_offset) -\n (elf_code_start + elf_code->size);\n is_external_call = true;\n } else {\n printf(\"The '%s' function is not implemented\\n\", ph2_ir->func_name);\n abort();\n }\n\n /* When calling external functions in dynamic linking mode,\n * the following instructions are required:\n * - movw + movt: set r8 to 'elf_data_start'\n * - ldr: load a word from the address 'elf_data_start' to r12.\n * (restore the global stack pointer.)\n *\n * Since shecc uses r12 to store a global stack pointer and external\n * functions can freely modify r12, causing internal functions to\n * access global variables incorrectly, additional instructions are\n * needed to restore r12 from the global object after the external\n * function returns.\n *\n * Otherwise, only a 'bl' instruction is generated to call internal\n * functions because shecc guarantees they do not modify r12.\n */\n emit(__bl(__AL, ofs));\n if (is_external_call) {\n emit(__movw(__AL, __r8, elf_data_start));\n emit(__movt(__AL, __r8, elf_data_start));\n emit(__lw(__AL, __r12, __r8, 0));\n }\n return;\n case OP_load_data_address:\n emit(__movw(__AL, rd, ph2_ir->src0 + elf_data_start));\n emit(__movt(__AL, rd, ph2_ir->src0 + elf_data_start));\n return;\n case OP_load_rodata_address:\n emit(__movw(__AL, rd, ph2_ir->src0 + elf_rodata_start));\n emit(__movt(__AL, rd, ph2_ir->src0 + elf_rodata_start));\n return;\n case OP_address_of_func:\n func = find_func(ph2_ir->func_name);\n if (func->bbs)\n ofs = elf_code_start + func->bbs->elf_offset;\n else if (dynlink)\n ofs = dynamic_sections.elf_plt_start + func->plt_offset;\n else {\n printf(\"The '%s' function is not implemented\\n\", ph2_ir->func_name);\n abort();\n }\n emit(__movw(__AL, __r8, ofs));\n emit(__movt(__AL, __r8, ofs));\n emit(__sw(__AL, __r8, rn, 0));\n return;\n case OP_load_func:\n emit(__mov_r(__AL, __r8, rn));\n return;\n case OP_indirect:\n emit(__blx(__AL, __r8));\n return;\n case OP_return:\n if (ph2_ir->src0 == -1)\n emit(__mov_r(__AL, __r0, __r0));\n else\n emit(__mov_r(__AL, __r0, rn));\n\n /* When calling a function, the following operations are performed:\n * 1. push r4-r11 and lr onto the stack.\n * 2. retrieve the global stack pointer from the 4-byte global object.\n * 3. decrement the stack by ALIGN_UP(stack_size, 8) + 4.\n *\n * Except for step 2, the reversed operations should be performed to\n * upon returning to restore the stack and the contents of r4-r11 and\n * lr.\n */\n ofs = ALIGN_UP(ph2_ir->src1, MIN_ALIGNMENT) + 4;\n emit(__movw(__AL, __r8, ofs));\n emit(__movt(__AL, __r8, ofs));\n emit(__add_r(__AL, __sp, __sp, __r8));\n emit(__ldm(__AL, 1, __sp, 0x4FF0));\n emit(__bx(__AL, __lr));\n return;\n case OP_add:\n emit(__add_r(__AL, rd, rn, rm));\n return;\n case OP_sub:\n emit(__sub_r(__AL, rd, rn, rm));\n return;\n case OP_mul:\n emit(__mul(__AL, rd, rn, rm));\n return;\n case OP_div:\n case OP_mod:\n if (hard_mul_div) {\n if (ph2_ir->op == OP_div)\n emit(__div(__AL, rd, rm, rn));\n else {\n emit(__div(__AL, __r8, rm, rn));\n emit(__mul(__AL, __r8, rm, __r8));\n emit(__sub_r(__AL, rd, rn, __r8));\n }\n return;\n }\n interm = __r8;\n /* div/mod emulation */\n /* Preserve the values of the dividend and divisor */\n emit(__stmdb(__AL, 1, __sp, (1 << rn) | (1 << rm)));\n /* Obtain absolute values of the dividend and divisor */\n emit(__srl_amt(__AL, 0, arith_rs, __r8, rn, 31));\n emit(__add_r(__AL, rn, rn, __r8));\n emit(__eor_r(__AL, rn, rn, __r8));\n emit(__srl_amt(__AL, 0, arith_rs, __r9, rm, 31));\n emit(__add_r(__AL, rm, rm, __r9));\n emit(__eor_r(__AL, rm, rm, __r9));\n if (ph2_ir->op == OP_div)\n emit(__eor_r(__AL, __r10, __r8, __r9));\n else {\n /* If the requested operation is modulo, the result will be stored\n * in __r9. The sign of the divisor is irrelevant for determining\n * the result's sign.\n */\n interm = __r9;\n emit(__mov_r(__AL, __r10, __r8));\n }\n /* Unsigned integer division */\n emit(__zero(__r8));\n emit(__mov_i(__AL, __r9, 1));\n emit(__cmp_i(__AL, rm, 0));\n emit(__b(__EQ, 52));\n emit(__cmp_i(__AL, rn, 0));\n emit(__b(__EQ, 44));\n emit(__cmp_r(__AL, rm, rn));\n emit(__sll_amt(__CC, 0, logic_ls, rm, rm, 1));\n emit(__sll_amt(__CC, 0, logic_ls, __r9, __r9, 1));\n emit(__b(__CC, -12));\n emit(__cmp_r(__AL, rn, rm));\n emit(__sub_r(__CS, rn, rn, rm));\n emit(__add_r(__CS, __r8, __r8, __r9));\n emit(__srl_amt(__AL, 1, logic_rs, __r9, __r9, 1));\n emit(__srl_amt(__CC, 0, logic_rs, rm, rm, 1));\n emit(__b(__CC, -20));\n /* After completing the emulation, the quotient and remainder will be\n * stored in __r8 and __r9, respectively.\n *\n * The original values of the dividend and divisor will be restored in\n * rn and rm.\n *\n * Finally, the result (quotient or remainder) will be stored in rd.\n */\n emit(__mov_r(__AL, __r9, rn));\n emit(__ldm(__AL, 1, __sp, (1 << rn) | (1 << rm)));\n emit(__mov_r(__AL, rd, interm));\n /* Handle the correct sign for the quotient or remainder */\n emit(__cmp_i(__AL, __r10, 0));\n emit(__rsb_i(__NE, rd, 0, rd));\n return;\n case OP_lshift:\n emit(__sll(__AL, rd, rn, rm));\n return;\n case OP_rshift:\n emit(__sra(__AL, rd, rn, rm));\n return;\n case OP_eq:\n case OP_neq:\n case OP_gt:\n case OP_lt:\n case OP_geq:\n case OP_leq:\n emit(__cmp_r(__AL, rn, rm));\n emit(__zero(rd));\n emit(__mov_i(arm_get_cond(ph2_ir->op), rd, 1));\n return;\n case OP_negate:\n emit(__rsb_i(__AL, rd, 0, rn));\n return;\n case OP_bit_not:\n emit(__mvn_r(__AL, rd, rn));\n return;\n case OP_bit_and:\n emit(__and_r(__AL, rd, rn, rm));\n return;\n case OP_bit_or:\n emit(__or_r(__AL, rd, rn, rm));\n return;\n case OP_bit_xor:\n emit(__eor_r(__AL, rd, rn, rm));\n return;\n case OP_log_not:\n emit(__cmp_i(__AL, rn, 0));\n emit(__mov_i(__NE, rd, 0));\n emit(__mov_i(__EQ, rd, 1));\n return;\n case OP_trunc:\n if (rm == 1) {\n emit(__and_i(__AL, rd, rn, 0xFF));\n } else if (rm == 2) {\n emit(__sll_amt(__AL, 0, logic_ls, rd, rn, 16));\n emit(__sll_amt(__AL, 0, logic_rs, rd, rd, 16));\n } else if (rm == 4) {\n emit(__mov_r(__AL, rd, rn));\n } else {\n fatal(\"Unsupported truncation operation with invalid target size\");\n }\n return;\n case OP_sign_ext: {\n /* Decode source size from upper 16 bits */\n int source_size = (rm >> 16) & 0xFFFF;\n if (source_size == 2) {\n emit(__sxth(__AL, rd, rn, 0));\n } else {\n /* For other cases, use byte extension (original behavior) */\n emit(__sxtb(__AL, rd, rn, 0));\n }\n }\n return;\n case OP_cast:\n /* Generic cast operation - for now, just move the value */\n emit(__mov_r(__AL, rd, rn));\n return;\n default:\n fatal(\"Unknown opcode\");\n }\n}\n\nvoid plt_generate(void);\nvoid code_generate(void)\n{\n int ofs;\n\n if (dynlink) {\n plt_generate();\n /* Call __libc_start_main() */\n emit(__mov_i(__AL, __r11, 0));\n emit(__mov_i(__AL, __lr, 0));\n emit(__pop_word(__AL, __r1));\n emit(__mov_r(__AL, __r2, __sp));\n emit(__push_reg(__AL, __r2));\n emit(__push_reg(__AL, __r0));\n emit(__mov_i(__AL, __r12, 0));\n emit(__push_reg(__AL, __r12));\n\n int main_wrapper_offset = elf_code->size + 28;\n emit(__movw(__AL, __r0, elf_code_start + main_wrapper_offset));\n emit(__movt(__AL, __r0, elf_code_start + main_wrapper_offset));\n emit(__mov_i(__AL, __r3, 0));\n emit(__bl(__AL, (dynamic_sections.elf_plt_start + PLT_FIXUP_SIZE) -\n (elf_code_start + elf_code->size)));\n /* Call '_exit' (syscall) to terminate the program if __libc_start_main\n * returns. */\n emit(__mov_i(__AL, __r0, 127));\n emit(__mov_i(__AL, __r7, 1));\n emit(__svc());\n\n /* If the compiled program is dynamic linking, the starting\n * point of 'main_wrapper' is located here.\n *\n * Push the contents of r4-r11 and lr onto stack.\n * Preserve 'argc' and 'argv' for the 'main' function.\n */\n emit(__stmdb(__AL, 1, __sp, 0x4FF0));\n emit(__mov_r(__AL, __r9, __r0));\n emit(__mov_r(__AL, __r10, __r1));\n }\n /* For both static and dynamic linking, we need to set up the stack\n * and call the main function.\n *\n * To ensure that the stack remains 8-byte aligned after adjustment,\n * 'ofs' is to align(GLOBAL_FUNC->stack_size, 8) to allocate space\n * for the global stack.\n *\n * In dynamic linking mode, since the preceding __stmdb instruction\n * pushes 9 registers onto stack, 'ofs' must be increased by 4 to\n * prevent the stack from becoming misaligned.\n */\n ofs = ALIGN_UP(GLOBAL_FUNC->stack_size, MIN_ALIGNMENT);\n if (dynlink)\n ofs += 4;\n emit(__movw(__AL, __r8, ofs));\n emit(__movt(__AL, __r8, ofs));\n emit(__sub_r(__AL, __sp, __sp, __r8));\n emit(__mov_r(__AL, __r12, __sp));\n /* The first object in the .data section is used to store the global\n * stack pointer. Therefore, store r12 at the address 'elf_data_start'\n * after the global stack has been prepared.\n */\n emit(__movw(__AL, __r8, elf_data_start));\n emit(__movt(__AL, __r8, elf_data_start));\n emit(__sw(__AL, __r12, __r8, 0));\n\n if (!dynlink) {\n /* Jump directly to the main preparation and then execute the\n * main function.\n *\n * In static linking mode, when the main function completes its\n * execution, it will invoke the '_exit' syscall to terminate\n * the program.\n *\n * That is, the execution flow is:\n *\n * +------------------+\n * | movw r8 |\n * 'start' | ... |\n * | b | (1) jump to global init --+\n * +------------------+ |\n * | push {r4 ... r7} | |\n * '__syscall' | ... | |\n * | bx lr | |\n * +------------------+ |\n * | ... | (2) global init <------+\n * | (global init) |\n * | ... |\n * global init | movw r8 |\n * + | movt r8 |\n * call main() | ... |\n * | bl
| (3) call main()\n * | mov r7 #1 |\n * | svc 0x00000000 | (4) call '_exit' after main()\n * +------------------+ returns\n */\n emit(__b(__AL, GLOBAL_FUNC->bbs->elf_offset - elf_code->size));\n\n /* __syscall - only for static linking\n *\n * If the number of arguments is greater than 4, the additional\n * arguments need to be retrieved from the stack. However, this\n * process must modify the contents of registers r4-r7.\n *\n * Therefore, __syscall needs to preserve the contents of these\n * registers before invoking a syscall, and restore them after\n * the syscall has completed.\n */\n emit(__stmdb(__AL, 1, __sp, 0x00F0));\n emit(__lw(__AL, __r4, __sp, 16));\n emit(__lw(__AL, __r5, __sp, 20));\n emit(__lw(__AL, __r6, __sp, 24));\n emit(__lw(__AL, __r7, __sp, 28));\n emit(__mov_r(__AL, __r7, __r0));\n emit(__mov_r(__AL, __r0, __r1));\n emit(__mov_r(__AL, __r1, __r2));\n emit(__mov_r(__AL, __r2, __r3));\n emit(__mov_r(__AL, __r3, __r4));\n emit(__mov_r(__AL, __r4, __r5));\n emit(__mov_r(__AL, __r5, __r6));\n emit(__svc());\n emit(__ldm(__AL, 1, __sp, 0x00F0));\n emit(__bx(__AL, __lr));\n }\n\n ph2_ir_t *ph2_ir;\n for (ph2_ir = GLOBAL_FUNC->bbs->ph2_ir_list.head; ph2_ir;\n ph2_ir = ph2_ir->next)\n emit_ph2_ir(ph2_ir);\n\n /* prepare 'argc' and 'argv', then proceed to 'main' function */\n if (MAIN_BB) {\n if (dynlink) {\n emit(__mov_r(__AL, __r0, __r9));\n emit(__mov_r(__AL, __r1, __r10));\n /* Call the main function.\n *\n * After the main function returns, the following\n * instructions restore the registers r4-r11 and\n * return control to __libc_start_main via the\n * preserved lr.\n */\n emit(__bl(__AL, MAIN_BB->elf_offset - elf_code->size));\n emit(__movw(__AL, __r8, ofs));\n emit(__movt(__AL, __r8, ofs));\n emit(__add_r(__AL, __sp, __sp, __r8));\n emit(__ldm(__AL, 1, __sp, 0x8FF0));\n } else {\n emit(__movw(__AL, __r8, ofs));\n emit(__movt(__AL, __r8, ofs));\n emit(__add_r(__AL, __r8, __r12, __r8));\n emit(__lw(__AL, __r0, __r8, 0));\n emit(__add_i(__AL, __r1, __r8, 4));\n\n /* Call main function, and call '_exit' syscall to\n * terminate the program. */\n emit(__bl(__AL, MAIN_BB->elf_offset - elf_code->size));\n\n /* exit with main's return value - r0 already has the\n * return value */\n emit(__mov_i(__AL, __r7, 1));\n emit(__svc());\n }\n }\n\n for (int i = 0; i < ph2_ir_idx; i++) {\n ph2_ir = PH2_IR_FLATTEN[i];\n emit_ph2_ir(ph2_ir);\n }\n}\n\nvoid plt_generate(void)\n{\n /* - PLT code generation explanation -\n *\n * As described in ARM's Platform Standard, PLT code should make register\n * ip address the corresponding GOT entry on SVr4-like (Linux-like)\n * platforms.\n *\n * Therefore, PLT[1] ~ PLT[N] use r12 (ip) to load the address of the\n * GOT entry and jump to the function entry via the GOT value.\n *\n * PLT[0] is used to call the resolver, which requires:\n * - [sp] contains the return address from the original function call.\n * - ip contains the address of the GOT entry.\n * - lr points to the address of GOT[2].\n *\n * The second requirement is alreadly handled by PLT[1] - PLT[N], so\n * PLT[0] must take care of the other two. The first one can be achieved\n * by a 'push' instruction; for the third, we use r10 to store the address\n * of GOT[2] and then move the value to lr.\n *\n * - Reason for using r10 in PLT[0] -\n *\n * The register allocation assumes 8 available registers, so the ARM code\n * generator primarily uses r0-r7 for code generation. These registers\n * cannot be modified arbitrarily; otherwise, the program may fail if any\n * of them are changed by PLT[0].\n *\n * However, r8-r11 can be freely used as temporary registers during code\n * generation, so PLT[0] arbitrarily chooses r10 to perform the required\n * operation.\n */\n int addr_of_got = dynamic_sections.elf_got_start + PTR_SIZE * 2;\n int end = dynamic_sections.plt_size - PLT_FIXUP_SIZE;\n elf_write_int(dynamic_sections.elf_plt, __push_reg(__AL, __lr));\n elf_write_int(dynamic_sections.elf_plt, __movw(__AL, __r10, addr_of_got));\n elf_write_int(dynamic_sections.elf_plt, __movt(__AL, __r10, addr_of_got));\n elf_write_int(dynamic_sections.elf_plt, __mov_r(__AL, __lr, __r10));\n elf_write_int(dynamic_sections.elf_plt, __lw(__AL, __pc, __lr, 0));\n for (int i = 0; i * PLT_ENT_SIZE < end; i++) {\n addr_of_got = dynamic_sections.elf_got_start + PTR_SIZE * (i + 3);\n elf_write_int(dynamic_sections.elf_plt,\n __movw(__AL, __r12, addr_of_got));\n elf_write_int(dynamic_sections.elf_plt,\n __movt(__AL, __r12, addr_of_got));\n elf_write_int(dynamic_sections.elf_plt, __lw(__AL, __pc, __r12, 0));\n }\n}\n" }, { "path": "src/arm.c", "content": "/*\n * shecc - Self-Hosting and Educational C Compiler.\n *\n * shecc is freely redistributable under the BSD 2 clause license. See the\n * file \"LICENSE\" for information on usage and redistribution of this file.\n */\n\n/* ARMv7-A instruction encoding */\n\n/* Identifier naming conventions\n * - prefix arm_ : Arm instruction encoding.\n * - prefix __ : mnemonic symbols for Arm instruction, condition code,\n * registers, etc.\n *\n * An example of usage in src/codegen.c: (unconditional jump)\n *\n * +---------------- write specified instruction into ELF\n * |\n * emit(__b(__AL, ofs));\n * | | |\n * | | +--- to PC-relative expression\n * | +------- always\n * +------------ branch\n *\n * Machine-level \"b\" instructions have restricted ranges from the address of\n * the current instruction.\n */\n\n#include \"defs.h\"\n\n/* opcode */\ntypedef enum {\n arm_and = 0,\n arm_eor = 1,\n arm_sub = 2,\n arm_rsb = 3,\n arm_add = 4,\n arm_ldm = 9,\n arm_teq = 9,\n arm_cmp = 10,\n arm_orr = 12,\n arm_mov = 13,\n arm_mvn = 15,\n arm_stmdb = 16\n} arm_op_t;\n\n/* Condition code\n * Reference:\n * https://community.arm.com/developer/ip-products/processors/b/processors-ip-blog/posts/condition-codes-1-condition-flags-and-codes\n */\ntypedef enum {\n __EQ = 0, /* Equal */\n __NE = 1, /* Not equal */\n __CS = 2, /* Unsigned higher or same */\n __CC = 3, /* Unsigned lower */\n __LS = 9, /* Unsigned lower or same */\n __GE = 10, /* Signed greater than or equal */\n __LT = 11, /* Signed less than */\n __GT = 12, /* Signed greater than */\n __LE = 13, /* Signed less than or equal */\n __AL = 14 /* Always executed */\n} arm_cond_t;\n\n/* Registers */\ntypedef enum {\n __r0 = 0,\n __r1 = 1,\n __r2 = 2,\n __r3 = 3,\n __r4 = 4,\n __r5 = 5,\n __r6 = 6,\n __r7 = 7,\n __r8 = 8,\n __r9 = 9,\n __r10 = 10,\n __r11 = 11,\n __r12 = 12,\n __sp = 13, /* stack pointer, r13 */\n __lr = 14, /* link register, r14 */\n __pc = 15 /* program counter, r15 */\n} arm_reg;\n\ntypedef enum {\n logic_ls = 0, /* Logical left shift */\n logic_rs = 1, /* Logical right shift */\n arith_rs = 2, /* Arithmetic right shift */\n rotat_rs = 3 /* Rotate right shift */\n} shift_type;\n\narm_cond_t arm_get_cond(opcode_t op)\n{\n switch (op) {\n case OP_eq:\n return __EQ;\n case OP_neq:\n return __NE;\n case OP_lt:\n return __LT;\n case OP_geq:\n return __GE;\n case OP_gt:\n return __GT;\n case OP_leq:\n return __LE;\n default:\n fatal(\"Unsupported condition IR opcode\");\n }\n return __AL;\n}\n\nint arm_extract_bits(int imm, int i_start, int i_end, int d_start, int d_end)\n{\n if (((d_end - d_start) != (i_end - i_start)) || (i_start > i_end) ||\n (d_start > d_end))\n fatal(\"Invalid bit copy\");\n\n int v = imm >> i_start;\n v &= ((2 << (i_end - i_start)) - 1);\n v <<= d_start;\n return v;\n}\n\nint arm_encode(arm_cond_t cond, int opcode, int rn, int rd, int op2)\n{\n return (cond << 28) + (opcode << 20) + (rn << 16) + (rd << 12) + op2;\n}\n\nint __svc(void)\n{\n return arm_encode(__AL, 240, 0, 0, 0);\n}\n\nint __mov(arm_cond_t cond, int io, int opcode, int s, int rn, int rd, int op2)\n{\n int shift = 0;\n if (op2 > 255) {\n shift = 16; /* full rotation */\n while ((op2 & 3) == 0) {\n /* we can shift by two bits */\n op2 >>= 2;\n shift -= 1;\n }\n if (op2 > 255)\n /* value spans more than 8 bits */\n fatal(\"Unable to represent value\");\n }\n return arm_encode(cond, s + (opcode << 1) + (io << 5), rn, rd,\n (shift << 8) + (op2 & 255));\n}\n\nint __and_r(arm_cond_t cond, arm_reg rd, arm_reg rs, arm_reg rm)\n{\n return __mov(cond, 0, arm_and, 0, rs, rd, rm);\n}\n\nint __or_r(arm_cond_t cond, arm_reg rd, arm_reg rs, arm_reg rm)\n{\n return __mov(cond, 0, arm_orr, 0, rs, rd, rm);\n}\n\nint __eor_r(arm_cond_t cond, arm_reg rd, arm_reg rs, arm_reg rm)\n{\n return __mov(cond, 0, arm_eor, 0, rs, rd, rm);\n}\n\nint __mvn_r(arm_cond_t cond, arm_reg rd, arm_reg rm)\n{\n return __mov(cond, 0, arm_mvn, 0, 0, rd, rm);\n}\n\nint __movw(arm_cond_t cond, arm_reg rd, int imm)\n{\n return arm_encode(cond, 48, 0, rd, 0) +\n arm_extract_bits(imm, 0, 11, 0, 11) +\n arm_extract_bits(imm, 12, 15, 16, 19);\n}\n\nint __movt(arm_cond_t cond, arm_reg rd, int imm)\n{\n imm >>= 16;\n return arm_encode(cond, 52, 0, rd, 0) +\n arm_extract_bits(imm, 0, 11, 0, 11) +\n arm_extract_bits(imm, 12, 15, 16, 19);\n}\n\nint __mov_i(arm_cond_t cond, arm_reg rd, int imm)\n{\n return __mov(cond, 1, arm_mov, 0, 0, rd, imm);\n}\n\nint __mov_r(arm_cond_t cond, arm_reg rd, arm_reg rs)\n{\n return __mov(cond, 0, arm_mov, 0, 0, rd, rs);\n}\n\nint __srl(arm_cond_t cond, arm_reg rd, arm_reg rm, arm_reg rs)\n{\n return arm_encode(cond, 0 + (arm_mov << 1) + (0 << 5), 0, rd,\n rm + (1 << 4) + (1 << 5) + (rs << 8));\n}\n\nint __srl_amt(arm_cond_t cond,\n int s,\n shift_type shift,\n arm_reg rd,\n arm_reg rm,\n int amt)\n{\n return arm_encode(cond, s + (arm_mov << 1) + (0 << 5), 0, rd,\n rm + (0 << 4) + (shift << 5) + (amt << 7));\n}\n\nint __sll(arm_cond_t cond, arm_reg rd, arm_reg rm, arm_reg rs)\n{\n return arm_encode(cond, 0 + (arm_mov << 1) + (0 << 5), 0, rd,\n rm + (1 << 4) + (0 << 5) + (rs << 8));\n}\n\nint __sll_amt(arm_cond_t cond,\n int s,\n shift_type shift,\n arm_reg rd,\n arm_reg rm,\n int amt)\n{\n return arm_encode(cond, s + (arm_mov << 1) + (0 << 5), 0, rd,\n rm + (0 << 4) + (shift << 5) + (amt << 7));\n}\n\nint __sra(arm_cond_t cond, arm_reg rd, arm_reg rm, arm_reg rs)\n{\n /* Arithmetic right shift with register\n * Bit 4 = 1 (register-specified shift)\n * Bits 5-6 = arith_rs (2) for arithmetic right shift\n */\n return arm_encode(cond, 0 + (arm_mov << 1) + (0 << 5), 0, rd,\n rm + (1 << 4) + (arith_rs << 5) + (rs << 8));\n}\n\nint __add_i(arm_cond_t cond, arm_reg rd, arm_reg rs, int imm)\n{\n if (imm >= 0)\n return __mov(cond, 1, arm_add, 0, rs, rd, imm);\n return __mov(cond, 1, arm_sub, 0, rs, rd, -imm);\n}\n\nint __add_r(arm_cond_t cond, arm_reg rd, arm_reg rs, arm_reg ro)\n{\n return __mov(cond, 0, arm_add, 0, rs, rd, ro);\n}\n\nint __sub_r(arm_cond_t cond, arm_reg rd, arm_reg rs, arm_reg ro)\n{\n return __mov(cond, 0, arm_sub, 0, rs, rd, ro);\n}\n\nint __and_i(arm_cond_t cond, arm_reg rd, arm_reg rs, int imm)\n{\n return __mov(cond, 1, arm_and, 0, rs, rd, imm);\n}\n\nint __zero(int rd)\n{\n return __mov_i(__AL, rd, 0);\n}\n\n/* ARM halfword transfer (immediate offset) using special encoding\n * For halfword: bits[11:8] = imm4H, bits[7:4] = encoding, bits[3:0] = imm4L\n * imm4H: upper 4 bits of offset\n * imm4L: lower 4 bits of offset\n * encoding: 0b1011 for unsigned halfword, 0b1111 for signed halfword\n */\nint arm_halfword_transfer(arm_cond_t cond,\n int l,\n arm_reg rn,\n arm_reg rd,\n int ofs,\n int signed_op)\n{\n int opcode = 16 + 8 + 4 + l;\n\n if (ofs < 0) {\n opcode -= 8;\n ofs = -ofs;\n }\n\n if (ofs > 255)\n fatal(\"Halfword offset too large\");\n\n /* Halfword encoding: split offset into 4-bit high and low parts */\n int imm4H = ((ofs >> 4) & 0xF) << 8;\n int imm4L = ofs & 0xF;\n\n /* Encode lower 8 bits: 1011xxxx for unsigned, 1111xxxx for signed */\n int encoded_ofs = imm4H | 0xB0 | imm4L | (signed_op << 6);\n\n return arm_encode(cond, opcode, rn, rd, encoded_ofs);\n}\n\nint arm_transfer(arm_cond_t cond,\n int l,\n int size,\n arm_reg rn,\n arm_reg rd,\n int ofs)\n{\n int opcode = 64 + 16 + 8 + l;\n if (size == 1)\n opcode += 4;\n if (ofs < 0) {\n opcode -= 8;\n ofs = -ofs;\n }\n return arm_encode(cond, opcode, rn, rd, ofs & 4095);\n}\n\nint __lw(arm_cond_t cond, arm_reg rd, arm_reg rn, int ofs)\n{\n return arm_transfer(cond, 1, 4, rn, rd, ofs);\n}\n\nint __lb(arm_cond_t cond, arm_reg rd, arm_reg rn, int ofs)\n{\n return arm_transfer(cond, 1, 1, rn, rd, ofs);\n}\n\nint __sw(arm_cond_t cond, arm_reg rd, arm_reg rn, int ofs)\n{\n return arm_transfer(cond, 0, 4, rn, rd, ofs);\n}\n\nint __sb(arm_cond_t cond, arm_reg rd, arm_reg rn, int ofs)\n{\n return arm_transfer(cond, 0, 1, rn, rd, ofs);\n}\n\n/* ARM signed halfword load (LDRSH) */\nint __lh(arm_cond_t cond, arm_reg rd, arm_reg rn, int ofs)\n{\n return arm_halfword_transfer(cond, 1, rn, rd, ofs, 1);\n}\n\n/* ARM halfword store (STRH) */\nint __sh(arm_cond_t cond, arm_reg rd, arm_reg rn, int ofs)\n{\n return arm_halfword_transfer(cond, 0, rn, rd, ofs, 0);\n}\n\nint __stmdb(arm_cond_t cond, int w, arm_reg rn, int reg_list)\n{\n return arm_encode(cond, arm_stmdb + (0x2 << 6) + (w << 1), rn, 0, reg_list);\n}\n\nint __ldm(arm_cond_t cond, int w, arm_reg rn, int reg_list)\n{\n return arm_encode(cond, arm_ldm + (0x2 << 6) + (w << 1), rn, 0, reg_list);\n}\n\nint __push_reg(arm_cond_t cond, arm_reg rt)\n{\n return arm_encode(cond, (0x5 << 4) | 0x2, 0xd, rt, 0x4);\n}\n\nint __pop_word(arm_cond_t cond, arm_reg rt)\n{\n return arm_encode(cond, (0x4 << 4) | 0x9, 0xd, rt, 0x4);\n}\n\nint __b(arm_cond_t cond, int ofs)\n{\n int o = (ofs - 8) >> 2;\n return arm_encode(cond, 160, 0, 0, 0) + (o & 16777215);\n}\n\nint __bl(arm_cond_t cond, int ofs)\n{\n int o = (ofs - 8) >> 2;\n return arm_encode(cond, 176, 0, 0, 0) + (o & 16777215);\n}\n\nint __bx(arm_cond_t cond, arm_reg rm)\n{\n /* BX: Branch and Exchange */\n return (cond << 28) | 0x012FFF10 | rm;\n}\n\nint __blx(arm_cond_t cond, arm_reg rd)\n{\n return arm_encode(cond, 18, 15, 15, rd + 3888);\n}\n\nint __mul(arm_cond_t cond, arm_reg rd, arm_reg r1, arm_reg r2)\n{\n return arm_encode(cond, 0, rd, 0, (r1 << 8) + 144 + r2);\n}\n\nint __div(arm_cond_t cond, arm_reg rd, arm_reg r1, arm_reg r2)\n{\n return arm_encode(cond, 113, rd, 15, (r1 << 8) + 16 + r2);\n}\n\nint __rsb_i(arm_cond_t cond, arm_reg rd, int imm, arm_reg rn)\n{\n return __mov(cond, 1, arm_rsb, 0, rn, rd, imm);\n}\n\nint __cmp_r(arm_cond_t cond, arm_reg r1, arm_reg r2)\n{\n return __mov(cond, 0, arm_cmp, 1, r1, 0, r2);\n}\n\nint __cmp_i(arm_cond_t cond, arm_reg rn, int imm)\n{\n return __mov(cond, 1, arm_cmp, 1, rn, 0, imm);\n}\n\nint __teq(arm_reg rd)\n{\n return __mov(__AL, 1, arm_teq, 1, rd, 0, 0);\n}\n\nint __sxtb(arm_cond_t cond, arm_reg rd, arm_reg rm, int rotation)\n{\n if (rotation != 0 && rotation != 8 && rotation != 16 && rotation != 24)\n fatal(\"SXTB rotation must be 0, 8, 16, or 24\");\n\n return arm_encode(cond, 106, 0xF, rd,\n rm | ((rotation >> 3) << 10) | (0x7 << 4));\n}\n\nint __sxth(arm_cond_t cond, arm_reg rd, arm_reg rm, int rotation)\n{\n if (rotation != 0 && rotation != 8 && rotation != 16 && rotation != 24)\n fatal(\"SXTH rotation must be 0, 8, 16, or 24\");\n\n return arm_encode(cond, 107, 0xF, rd,\n rm | ((rotation >> 3) << 10) | (0x7 << 4));\n}\n" }, { "path": "src/defs.h", "content": "/*\n * shecc - Self-Hosting and Educational C Compiler.\n *\n * shecc is freely redistributable under the BSD 2 clause license. See the\n * file \"LICENSE\" for information on usage and redistribution of this file.\n */\n\n#pragma once\n#include \n\n/* definitions */\n\n/* Common macro functions */\n#define is_newline(c) (c == '\\r' || c == '\\n')\n\n/* Limitations */\n#define MAX_TOKEN_LEN 256\n#define MAX_ID_LEN 64\n#define MAX_LINE_LEN 256\n#define MAX_VAR_LEN 128\n#define MAX_TYPE_LEN 32\n#define MAX_PARAMS 8\n#define MAX_LOCALS 1600\n#define MAX_FIELDS 64\n#define MAX_TYPES 256\n#define MAX_LABELS 256\n#define MAX_IR_INSTR 80000\n#define MAX_BB_PRED 128\n#define MAX_BB_DOM_SUCC 64\n#define MAX_BB_RDOM_SUCC 256\n#define MAX_GLOBAL_IR 256\n#define MAX_CODE 262144\n#define MAX_DATA 262144\n#define MAX_SYMTAB 65536\n#define MAX_STRTAB 65536\n#define MAX_HEADER 1024\n#define MAX_PROGRAM_HEADER 1024\n#define MAX_SECTION 1024\n#define MAX_SECTION_HEADER 1024\n#define MAX_SHSTR 1024\n#define MAX_INTERP 1024\n#define MAX_DYNAMIC 1024\n#define MAX_DYNSYM 1024\n#define MAX_DYNSTR 1024\n#define MAX_RELPLT 1024\n#define MAX_PLT 1024\n#define MAX_GOTPLT 1024\n#define MAX_CONSTANTS 1024\n#define MAX_CASES 128\n#define MAX_NESTING 128\n#define MAX_OPERAND_STACK_SIZE 32\n#define MAX_ANALYSIS_STACK_SIZE 800\n\n/* Default capacities for common data structures */\n/* Arena sizes optimized based on typical usage patterns */\n#define DEFAULT_ARENA_SIZE 262144 /* 256 KiB - standard default */\n#define SMALL_ARENA_SIZE 65536 /* 64 KiB - for small allocations */\n#define LARGE_ARENA_SIZE 524288 /* 512 KiB - for instruction arena */\n#define DEFAULT_FUNCS_SIZE 64\n#define DEFAULT_SRC_FILE_COUNT 8\n\n/* Arena compaction bitmask flags for selective memory reclamation */\n#define COMPACT_ARENA_BLOCK 0x01 /* BLOCK_ARENA - variables/blocks */\n#define COMPACT_ARENA_INSN 0x02 /* INSN_ARENA - instructions */\n#define COMPACT_ARENA_BB 0x04 /* BB_ARENA - basic blocks */\n#define COMPACT_ARENA_HASHMAP 0x08 /* HASHMAP_ARENA - hash nodes */\n#define COMPACT_ARENA_GENERAL 0x10 /* GENERAL_ARENA - misc allocations */\n#define COMPACT_ARENA_ALL 0x1F /* All arenas */\n\n/* Common arena compaction combinations for different compilation phases */\n#define COMPACT_PHASE_PARSING (COMPACT_ARENA_BLOCK | COMPACT_ARENA_GENERAL)\n#define COMPACT_PHASE_SSA (COMPACT_ARENA_INSN | COMPACT_ARENA_BB)\n#define COMPACT_PHASE_BACKEND (COMPACT_ARENA_BB | COMPACT_ARENA_GENERAL)\n\n#define ELF_START 0x10000\n#define PTR_SIZE 4\n\n/* Number of the available registers. Either 7 or 8 is accepted now. */\n#define REG_CNT 8\n\n/* This macro will be automatically defined at shecc run-time. */\n#ifdef __SHECC__\n/* use do-while as a substitution for nop */\n#define UNUSED(x) \\\n do { \\\n ; \\\n } while (0)\n#define HOST_PTR_SIZE 4\n#else\n/* suppress GCC/Clang warnings */\n#define UNUSED(x) (void) (x)\n/* configure host data model when using 'memcpy'. */\n#define HOST_PTR_SIZE __SIZEOF_POINTER__\n#endif\n\n#ifndef MIN_ALIGNMENT\n#define MIN_ALIGNMENT 8\n#endif\n\n#ifndef ALIGN_UP\n#define ALIGN_UP(val, align) (((val) + (align) - 1) & ~((align) - 1))\n#endif\n\n/* Common data structures */\ntypedef struct arena_block {\n char *memory;\n int capacity;\n int offset;\n struct arena_block *next;\n} arena_block_t;\n\ntypedef struct {\n arena_block_t *head;\n int total_bytes; /* Track total allocation for profiling */\n int block_size; /* Default block size for new blocks */\n} arena_t;\n\n/* string-based hash map definitions */\n\ntypedef struct hashmap_node {\n char *key;\n void *val;\n bool occupied;\n} hashmap_node_t;\n\ntypedef struct {\n int size;\n int cap;\n hashmap_node_t *table;\n} hashmap_t;\n\n/* lexer tokens */\ntypedef enum {\n T_start, /* FIXME: Unused, intended for lexer state machine init */\n T_eof, /* end-of-file (EOF) */\n T_numeric,\n T_identifier,\n T_comma, /* , */\n T_string, /* null-terminated string */\n T_char,\n T_open_bracket, /* ( */\n T_close_bracket, /* ) */\n T_open_curly, /* { */\n T_close_curly, /* } */\n T_open_square, /* [ */\n T_close_square, /* ] */\n T_asterisk, /* '*' */\n T_divide, /* / */\n T_mod, /* % */\n T_bit_or, /* | */\n T_bit_xor, /* ^ */\n T_bit_not, /* ~ */\n T_log_and, /* && */\n T_log_or, /* || */\n T_log_not, /* ! */\n T_lt, /* < */\n T_gt, /* > */\n T_le, /* <= */\n T_ge, /* >= */\n T_lshift, /* << */\n T_rshift, /* >> */\n T_dot, /* . */\n T_arrow, /* -> */\n T_plus, /* + */\n T_minus, /* - */\n T_minuseq, /* -= */\n T_pluseq, /* += */\n T_asteriskeq, /* *= */\n T_divideeq, /* /= */\n T_modeq, /* %= */\n T_lshifteq, /* <<= */\n T_rshifteq, /* >>= */\n T_xoreq, /* ^= */\n T_oreq, /* |= */\n T_andeq, /* &= */\n T_eq, /* == */\n T_noteq, /* != */\n T_assign, /* = */\n T_increment, /* ++ */\n T_decrement, /* -- */\n T_question, /* ? */\n T_colon, /* : */\n T_semicolon, /* ; */\n T_ampersand, /* & */\n T_return,\n T_if,\n T_else,\n T_while,\n T_for,\n T_do,\n T_typedef,\n T_enum,\n T_struct,\n T_union,\n T_sizeof,\n T_elipsis, /* ... */\n T_switch,\n T_case,\n T_break,\n T_default,\n T_continue,\n T_goto,\n T_const, /* const qualifier */\n /* C pre-processor directives */\n T_cppd_include,\n T_cppd_define,\n T_cppd_undef,\n T_cppd_error,\n T_cppd_if,\n T_cppd_elif,\n T_cppd_else,\n T_cppd_endif,\n T_cppd_ifdef,\n T_cppd_ifndef,\n T_cppd_pragma,\n /* C pre-processor specific, these kinds\n * will be removed after pre-processing is done.\n */\n T_newline,\n T_backslash,\n T_whitespace,\n T_tab\n} token_kind_t;\n\n/* Source location tracking for better error reporting */\ntypedef struct {\n int pos; /* raw source file position */\n int len; /* length of token */\n int line;\n int column;\n char *filename;\n} source_location_t;\n\ntypedef struct token {\n token_kind_t kind;\n char *literal;\n source_location_t location;\n struct token *next;\n} token_t;\n\ntypedef struct token_stream {\n token_t *head;\n token_t *tail;\n} token_stream_t;\n\n/* String pool for identifier deduplication */\ntypedef struct {\n hashmap_t *strings; /* Map string -> interned string */\n} string_pool_t;\n\n/* String literal pool for deduplicating string constants */\ntypedef struct {\n hashmap_t *literals; /* Map string literal -> ELF data offset */\n} string_literal_pool_t;\n\n/* builtin types */\ntypedef enum {\n TYPE_void = 0,\n TYPE_int,\n TYPE_char,\n TYPE_short,\n TYPE_struct,\n TYPE_union,\n TYPE_typedef\n} base_type_t;\n\n/* IR opcode */\ntypedef enum {\n /* intermediate use in front-end. No code generation */\n OP_generic,\n\n OP_phi,\n OP_unwound_phi, /* work like address_of + store */\n\n /* calling convention */\n OP_define, /* function entry point */\n OP_push, /* prepare arguments */\n OP_call, /* function call */\n OP_indirect, /* indirect call with function pointer */\n OP_return, /* explicit return */\n\n OP_allocat, /* allocate space on stack */\n OP_assign,\n OP_load_constant, /* load constant */\n OP_load_data_address, /* lookup address of a constant in data section */\n OP_load_rodata_address, /* lookup address of a constant in rodata section */\n\n /* control flow */\n OP_branch, /* conditional jump */\n OP_jump, /* unconditional jump */\n OP_func_ret, /* returned value */\n OP_label, /* for goto label */\n\n /* function pointer */\n OP_address_of_func, /* resolve function entry */\n OP_load_func, /* prepare indirective call */\n OP_global_load_func,\n\n /* memory address operations */\n OP_address_of, /* lookup variable's address */\n OP_global_address_of,\n OP_load, /* load a word from stack */\n OP_global_load,\n OP_store, /* store a word to stack */\n OP_global_store,\n OP_read, /* read from memory address */\n OP_write, /* write to memory address */\n\n /* arithmetic operators */\n OP_add,\n OP_sub,\n OP_mul,\n OP_div, /* signed division */\n OP_mod, /* modulo */\n OP_ternary, /* ? : */\n OP_lshift,\n OP_rshift,\n OP_log_and,\n OP_log_or,\n OP_log_not,\n OP_eq, /* equal */\n OP_neq, /* not equal */\n OP_lt, /* less than */\n OP_leq, /* less than or equal */\n OP_gt, /* greater than */\n OP_geq, /* greater than or equal */\n OP_bit_or,\n OP_bit_and,\n OP_bit_xor,\n OP_bit_not,\n OP_negate,\n\n /* data type conversion */\n OP_trunc,\n OP_sign_ext,\n OP_cast,\n\n /* entry point of the state machine */\n OP_start\n} opcode_t;\n\n/* variable definition */\ntypedef struct {\n int counter;\n int stack[64];\n int stack_idx;\n} rename_t;\n\ntypedef struct ref_block ref_block_t;\n\nstruct ref_block_list {\n ref_block_t *head, *tail;\n};\n\ntypedef struct ref_block_list ref_block_list_t;\n\ntypedef struct insn insn_t;\n\ntypedef struct use_chain_node {\n insn_t *insn;\n struct use_chain_node *next, *prev;\n} use_chain_t;\n\ntypedef struct var var_t;\ntypedef struct type type_t;\n\ntypedef struct var_list {\n int capacity;\n int size;\n var_t **elements;\n} var_list_t;\n\nstruct var {\n type_t *type;\n char var_name[MAX_VAR_LEN];\n int ptr_level;\n bool is_func;\n bool is_global;\n bool is_const_qualified; /* true if variable has const qualifier */\n bool address_taken; /* true if variable address was taken (&var) */\n int array_size;\n int array_dim1, array_dim2; /* first/second dimension size for 2D arrays */\n int offset; /* offset from stack or frame, index 0 is reserved */\n int init_val; /* for global initialization */\n int liveness; /* live range */\n int in_loop;\n struct var *base;\n int subscript;\n struct var *subscripts[128];\n int subscripts_idx;\n rename_t rename;\n ref_block_list_t ref_block_list; /* blocks which kill variable */\n use_chain_t *users_head, *users_tail;\n struct insn *last_assign;\n int consumed;\n bool is_ternary_ret;\n bool is_logical_ret;\n bool is_const; /* whether a constant representaion or not */\n int vreg_id; /* Virtual register ID */\n int phys_reg; /* Physical register assignment (-1 if unassigned) */\n int vreg_flags; /* VReg flags */\n int first_use; /* First instruction index where variable is used */\n int last_use; /* Last instruction index where variable is used */\n int loop_depth; /* Nesting depth if variable is in a loop */\n int use_count; /* Number of times variable is used */\n bool space_is_allocated; /* whether space is allocated for this variable */\n\n /* This flag is used to indicate to the compiler that the offset of\n * the variable is based on the top of the local stack.\n */\n bool ofs_based_on_stack_top;\n\n /* True when this variable was synthesized to hold a compound literal\n * (e.g., array or struct literal temporaries).\n */\n bool is_compound_literal;\n};\n\ntypedef struct func func_t;\n\n/* block definition */\nstruct block {\n var_list_t locals;\n struct block *parent;\n func_t *func;\n struct block *next;\n};\n\ntypedef struct block block_t;\ntypedef struct basic_block basic_block_t;\n\n/* Definition of a growable buffer for a mutable null-terminated string\n * @size: Current number of elements in the array\n * @capacity: Number of elements that can be stored without resizing\n * @elements: Pointer to the array of characters\n */\ntypedef struct {\n int size;\n int capacity;\n char *elements;\n} strbuf_t;\n\n/* phase-2 IR definition */\nstruct ph2_ir {\n opcode_t op;\n int src0;\n int src1;\n int dest;\n char func_name[MAX_VAR_LEN];\n basic_block_t *next_bb;\n basic_block_t *then_bb;\n basic_block_t *else_bb;\n struct ph2_ir *next;\n bool is_branch_detached;\n\n /* When an instruction uses a variable that its offset is based on\n * the top of the stack, this instruction's flag is also set to\n * indicate the compiler to recalculate the offset after the function's\n * stack size has been determined.\n *\n * Currently, only OP_load, OP_store and OP_address_of need this flag\n * to recompute the offset.\n */\n bool ofs_based_on_stack_top;\n};\n\ntypedef struct ph2_ir ph2_ir_t;\n\n/* type definition */\nstruct type {\n char type_name[MAX_TYPE_LEN];\n base_type_t base_type;\n struct type *base_struct;\n int size;\n var_t fields[MAX_FIELDS];\n int num_fields;\n int ptr_level; /* pointer level for typedef pointer types */\n};\n\n/* lvalue details */\ntypedef struct {\n int size;\n int ptr_level;\n bool is_func;\n bool is_reference;\n type_t *type;\n} lvalue_t;\n\n/* constants for enums */\ntypedef struct {\n char alias[MAX_VAR_LEN];\n int value;\n} constant_t;\n\nstruct phi_operand {\n var_t *var;\n basic_block_t *from;\n struct phi_operand *next;\n};\n\ntypedef struct phi_operand phi_operand_t;\n\nstruct insn {\n struct insn *next, *prev;\n int idx;\n opcode_t opcode;\n var_t *rd;\n var_t *rs1;\n var_t *rs2;\n int sz;\n bool useful; /* Used in DCE process. Set true if instruction is useful. */\n basic_block_t *belong_to;\n phi_operand_t *phi_ops;\n char str[64];\n};\n\ntypedef struct {\n insn_t *head, *tail;\n} insn_list_t;\n\ntypedef struct {\n ph2_ir_t *head, *tail;\n} ph2_ir_list_t;\n\ntypedef enum { NEXT, ELSE, THEN } bb_connection_type_t;\n\ntypedef struct {\n basic_block_t *bb;\n bb_connection_type_t type;\n} bb_connection_t;\n\nstruct symbol {\n var_t *var;\n int index;\n struct symbol *next;\n};\n\ntypedef struct symbol symbol_t;\n\ntypedef struct {\n symbol_t *head, *tail;\n} symbol_list_t;\n\nstruct basic_block {\n insn_list_t insn_list;\n ph2_ir_list_t ph2_ir_list;\n bb_connection_t prev[MAX_BB_PRED];\n /* Used in instruction dumping when ir_dump is enabled. */\n char bb_label_name[MAX_VAR_LEN];\n struct basic_block *next; /* normal BB */\n struct basic_block *then_; /* conditional BB */\n struct basic_block *else_;\n struct basic_block *idom;\n struct basic_block *r_idom;\n struct basic_block *rpo_next;\n struct basic_block *rpo_r_next;\n var_list_t live_gen;\n var_list_t live_kill;\n var_list_t live_in;\n var_list_t live_out;\n int rpo;\n int rpo_r;\n struct basic_block *DF[64];\n struct basic_block *RDF[64];\n int df_idx;\n int rdf_idx;\n int visited;\n bool useful; /* indicate whether this BB contains useful instructions */\n struct basic_block *dom_next[64];\n struct basic_block *dom_prev;\n struct basic_block *rdom_next[256];\n struct basic_block *rdom_prev;\n func_t *belong_to;\n block_t *scope;\n symbol_list_t symbol_list; /* variable declaration */\n int elf_offset;\n};\n\nstruct ref_block {\n basic_block_t *bb;\n struct ref_block *next;\n};\n\n/* Syntactic representation of func, combines syntactic details (e.g., return\n * type, parameters) with SSA-related information (e.g., basic blocks, control\n * flow) to support parsing, analysis, optimization, and code generation.\n */\n\ntypedef struct {\n char label_name[MAX_ID_LEN];\n basic_block_t *bb;\n bool used;\n} label_t;\n\nstruct func {\n /* Syntatic info */\n var_t return_def;\n var_t param_defs[MAX_PARAMS];\n int num_params;\n int va_args;\n int stack_size;\n\n /* SSA info */\n basic_block_t *bbs;\n basic_block_t *exit;\n symbol_list_t global_sym_list;\n int bb_cnt;\n int visited;\n\n /* Information used for dynamic linking */\n bool is_used;\n int plt_offset, got_offset;\n\n struct func *next;\n};\n\ntypedef struct {\n func_t *head, *tail;\n} func_list_t;\n\ntypedef struct {\n func_t *func;\n basic_block_t *bb;\n void (*preorder_cb)(func_t *, basic_block_t *);\n void (*postorder_cb)(func_t *, basic_block_t *);\n} bb_traversal_args_t;\n\ntypedef struct {\n var_t *var;\n int polluted;\n} regfile_t;\n\n/* ELF header */\ntypedef struct {\n char e_ident[16];\n char e_type[2];\n char e_machine[2];\n int e_version;\n int e_entry;\n int e_phoff;\n int e_shoff;\n int e_flags;\n char e_ehsize[2];\n char e_phentsize[2];\n char e_phnum[2];\n char e_shentsize[2];\n char e_shnum[2];\n char e_shstrndx[2];\n} elf32_hdr_t;\n\n/* ELF program header */\ntypedef struct {\n int p_type;\n int p_offset;\n int p_vaddr;\n int p_paddr;\n int p_filesz;\n int p_memsz;\n int p_flags;\n int p_align;\n} elf32_phdr_t;\n\n/* ELF section header */\ntypedef struct {\n int sh_name;\n int sh_type;\n int sh_flags;\n int sh_addr;\n int sh_offset;\n int sh_size;\n int sh_link;\n int sh_info;\n int sh_addralign;\n int sh_entsize;\n} elf32_shdr_t;\n\n/* Structures for dynamic linked program */\n/* ELF buffers for dynamic sections */\ntypedef struct {\n strbuf_t *elf_interp;\n strbuf_t *elf_dynamic;\n strbuf_t *elf_dynsym;\n strbuf_t *elf_dynstr;\n strbuf_t *elf_relplt;\n strbuf_t *elf_plt;\n strbuf_t *elf_got;\n int elf_interp_start;\n int elf_relplt_start;\n int elf_plt_start;\n int elf_got_start;\n int relplt_size;\n int plt_size;\n int got_size;\n} dynamic_sections_t;\n\n/* For .dynsym section. */\ntypedef struct {\n int st_name;\n int st_value;\n int st_size;\n char st_info;\n char st_other;\n char st_shndx[2];\n} elf32_sym_t;\n\n/* For .rel.plt section */\ntypedef struct {\n int r_offset;\n int r_info;\n} elf32_rel_t;\n\n/* For .dynamic section */\ntypedef struct {\n int d_tag;\n int d_un;\n} elf32_dyn_t;\n\n#define ELF32_ST_INFO(b, t) (((b) << 4) + ((t) & 0xf))\n" }, { "path": "src/elf.c", "content": "/*\n * shecc - Self-Hosting and Educational C Compiler.\n *\n * shecc is freely redistributable under the BSD 2 clause license. See the\n * file \"LICENSE\" for information on usage and redistribution of this file.\n */\n\n/* ELF file manipulation */\n\n#include \"../config\"\n#include \"defs.h\"\n#include \"globals.c\"\n\n#ifndef PAGESIZE\n#define PAGESIZE 4096\n#endif\n\nint elf_symbol_index = 0;\n\nvoid elf_write_str(strbuf_t *elf_array, const char *vals)\n{\n /* Note that strbuf_puts() does not push the null character.\n *\n * If necessary, use elf_write_byte() to append the null character\n * after calling elf_write_str().\n */\n if (!elf_array || !vals)\n return;\n strbuf_puts(elf_array, vals);\n}\n\nvoid elf_write_byte(strbuf_t *elf_array, int val)\n{\n if (!elf_array)\n return;\n strbuf_putc(elf_array, val);\n}\n\nchar e_extract_byte(int v, int b)\n{\n return (char) ((v >> (b << 3)) & 0xFF);\n}\n\nvoid elf_write_int(strbuf_t *elf_array, int val)\n{\n if (!elf_array)\n return;\n for (int i = 0; i < 4; i++)\n strbuf_putc(elf_array, e_extract_byte(val, i));\n}\n\nvoid elf_write_blk(strbuf_t *elf_array, void *blk, int sz)\n{\n if (!elf_array || !blk || sz <= 0)\n return;\n char *ptr = blk;\n for (int i = 0; i < sz; i++)\n strbuf_putc(elf_array, ptr[i]);\n}\n\nvoid elf_generate_header(void)\n{\n /* Check for null pointers to prevent crashes */\n if (!elf_code || !elf_data || !elf_symtab || !elf_strtab || !elf_header) {\n fatal(\"ELF buffers not initialized\");\n return;\n }\n\n elf32_hdr_t hdr;\n int phnum, shnum, shstrndx, shoff;\n\n if (dynlink) {\n /* In dynamic linking mode:\n * - number of program headers = 4\n * - number of section headers = 15\n * - section header index of .shstrtab = 14\n */\n phnum = 4;\n shnum = 15;\n shstrndx = 14;\n shoff =\n elf_header_len + elf_code->size + elf_data->size +\n elf_rodata->size + elf_symtab->size + elf_strtab->size +\n elf_shstrtab->size + dynamic_sections.elf_interp->size +\n dynamic_sections.elf_relplt->size + dynamic_sections.elf_plt->size +\n dynamic_sections.elf_got->size + dynamic_sections.elf_dynstr->size +\n dynamic_sections.elf_dynsym->size +\n dynamic_sections.elf_dynamic->size;\n } else {\n /* In static linking mode:\n * - number of program headers = 2\n * - number of section headers = 8\n * - section header index of .shstrtab = 7\n */\n phnum = 2;\n shnum = 8;\n shstrndx = 7;\n shoff = elf_header_len + elf_code->size + elf_data->size +\n elf_rodata->size + elf_symtab->size + elf_strtab->size +\n elf_shstrtab->size;\n }\n /* The following table explains the meaning of each field in the\n * ELF32 file header.\n *\n * Notice that the following values are hexadecimal.\n *\n * | File | |\n * & | Header bytes | Explanation |\n * ---+----------------+-------------------------------------------------+\n * 00 | 7F 45 4C 46 | e_ident[0] - e_ident[3]: ELF magic number. |\n * | 01 | e_ident[4]: 1 -> 32-bit, 2 -> 64-bit. |\n * | 01 | e_ident[5]: 1 -> little-endian. 2 -> big-endian.|\n * | 01 | e_ident[6]: 1 -> ELF header version; must be 1. |\n * | 00 | e_ident[7]: Target OS ABI; be 1 for Linux. |\n * | 00 | e_ident[8]: ABI version; should be 1 for Linux. |\n * | 00 00 00 | e_ident[9] - e_ident[16]: Padding; Unused; |\n * | 00 00 00 00 | should be 0. |\n * ---+----------------+-------------------------------------------------+\n * | 02 00 | e_type: Object file type; 2 -> executable |\n * | 28 00 | e_machine: Instruction Set Architecture. |\n * | | 0x28 -> ARMv7 |\n * | | 0xF3 -> RISC-V |\n * | 01 00 00 00 | e_version: ELF identification version; |\n * | | must be 1. |\n * | 54 00 01 00 | e_entry: Memory address of entry point. |\n * | | (where process starts). |\n * | 34 00 00 00 | e_phoff: File offset of program headers. |\n * | | 0x34 -> 32-bit, 0x40 -> 64-bit. |\n * | d7 8a 03 00 | e_shoff: File offset of section headers. |\n * ---+----------------+-------------------------------------------------+\n * | 00 02 00 50 | e_flags: 0x50000200 -> ARM Version5 EABI, |\n * | | soft-float ABI |\n * | | 0x00000000 -> RISC-V |\n * | 34 00 | e_ehsize: Size of this header. |\n * | | 0x34 -> 32-bit, 0x40 -> 64-bit. |\n * | 20 00 | e_phentsize: Size of each program header. |\n * | | 0x20 -> 32-bit, 0x38 -> 64-bit. |\n * | 01 00 | e_phnum: Number of program headers. |\n * | 28 00 | e_shentsize: Size of each section header. |\n * | | 0x28 -> 32-bit, 0x40 -> 64-bit. |\n * | 06 00 | e_shnum: Number of section headers. |\n * | 05 00 | e_shstrndx: Index of section header containing |\n * | | section names. |\n * ---+----------------+-------------------------------------------------+\n * 34 | | |\n */\n /* ELF file header */\n hdr.e_ident[0] = (char) 0x7F; /* ELF magic number */\n hdr.e_ident[1] = 'E';\n hdr.e_ident[2] = 'L';\n hdr.e_ident[3] = 'F';\n hdr.e_ident[4] = 1; /* 32-bit */\n hdr.e_ident[5] = 1; /* little-endian */\n hdr.e_ident[6] = 1; /* ELF header version */\n hdr.e_ident[7] = 0; /* Target OS ABI */\n hdr.e_ident[8] = 0; /* ABI version */\n hdr.e_ident[9] = 0; /* Padding */\n hdr.e_ident[10] = 0;\n hdr.e_ident[11] = 0;\n hdr.e_ident[12] = 0;\n hdr.e_ident[13] = 0;\n hdr.e_ident[14] = 0;\n hdr.e_ident[15] = 0;\n hdr.e_type[0] = 2; /* Object file type */\n hdr.e_type[1] = 0;\n hdr.e_machine[0] = ELF_MACHINE; /* Instruction Set Architecture */\n hdr.e_machine[1] = 0;\n hdr.e_version = 1; /* ELF version */\n hdr.e_entry = elf_code_start; /* entry point */\n hdr.e_phoff = sizeof(elf32_hdr_t); /* program header offset */\n hdr.e_shoff = shoff; /* section header offset */\n hdr.e_flags = ELF_FLAGS; /* flags */\n hdr.e_ehsize[0] = sizeof(elf32_hdr_t); /* header size */\n hdr.e_ehsize[1] = 0;\n hdr.e_phentsize[0] = sizeof(elf32_phdr_t); /* program header size */\n hdr.e_phentsize[1] = 0;\n hdr.e_phnum[0] = phnum; /* number of program headers */\n hdr.e_phnum[1] = 0;\n hdr.e_shentsize[0] = sizeof(elf32_shdr_t); /* section header size */\n hdr.e_shentsize[1] = 0;\n hdr.e_shnum[0] = shnum; /* number of section headers */\n hdr.e_shnum[1] = 0;\n hdr.e_shstrndx[0] = shstrndx; /* section index with names */\n hdr.e_shstrndx[1] = 0;\n elf_write_blk(elf_header, &hdr, sizeof(elf32_hdr_t));\n}\n\nvoid elf_generate_program_headers(void)\n{\n if (!elf_program_header || !elf_code || !elf_data || !elf_rodata ||\n (dynlink &&\n (!dynamic_sections.elf_interp || !dynamic_sections.elf_relplt ||\n !dynamic_sections.elf_plt || !dynamic_sections.elf_got ||\n !dynamic_sections.elf_dynstr || !dynamic_sections.elf_dynsym ||\n !dynamic_sections.elf_dynamic))) {\n fatal(\"ELF section buffers not initialized\");\n return;\n }\n\n elf32_phdr_t phdr;\n\n /* Explain the meaning of each field in the ELF32 program header.\n *\n * | Program | |\n * & | Header bytes | Explanation |\n * ---+----------------+-------------------------------------------------+\n * 34 | 01 00 00 00 | p_type: Segment type; 1 -> loadable. |\n * | 54 00 00 00 | p_offset: Offset of segment in the file. |\n * | 54 00 01 00 | p_vaddr: Virtual address of loaded segment. |\n * | 54 00 01 00 | p_paddr: Only used on systems where physical |\n * | | address is relevant. |\n * | 48 8a 03 00 | p_filesz: Size of the segment in the file image.|\n * | 48 8a 03 00 | p_memsz: Size of the segment in memory. |\n * | | This value should be greater than or |\n * | | equal to p_filesz. |\n * | 07 00 00 00 | p_flags: Segment-wise permissions; |\n * | | 0x1 -> execute, 0x2 -> write, |\n * | | 0x4 -> read |\n * | 04 00 00 00 | p_align: Align segment to the specified value. |\n * ---+----------------+-------------------------------------------------+\n * 54 | | |\n */\n /* program header - read-only segment */\n phdr.p_type = 1; /* PT_LOAD */\n phdr.p_offset = 0; /* offset of segment */\n phdr.p_vaddr = ELF_START; /* virtual address */\n phdr.p_paddr = ELF_START; /* physical address */\n phdr.p_filesz =\n elf_header_len + elf_code->size + elf_rodata->size; /* size in file */\n phdr.p_memsz =\n elf_header_len + elf_code->size + elf_rodata->size; /* size in memory */\n phdr.p_flags = 5; /* flags */\n phdr.p_align = PAGESIZE; /* alignment */\n if (dynlink) {\n phdr.p_filesz +=\n dynamic_sections.elf_relplt->size + dynamic_sections.elf_plt->size;\n phdr.p_memsz +=\n dynamic_sections.elf_relplt->size + dynamic_sections.elf_plt->size;\n }\n elf_write_blk(elf_program_header, &phdr, sizeof(elf32_phdr_t));\n\n /* program header - readable and writable segment */\n phdr.p_type = 1; /* PT_LOAD */\n phdr.p_offset = elf_header_len + elf_code->size +\n elf_rodata->size; /* offset of segment */\n phdr.p_vaddr = elf_data_start; /* virtual address */\n phdr.p_paddr = elf_data_start; /* physical address */\n phdr.p_filesz = elf_data->size; /* size in file */\n phdr.p_memsz = elf_data->size + elf_bss_size; /* size in memory */\n phdr.p_flags = 6; /* flags */\n phdr.p_align = PAGESIZE; /* alignment */\n if (dynlink) {\n phdr.p_offset +=\n dynamic_sections.elf_relplt->size + dynamic_sections.elf_plt->size;\n phdr.p_vaddr = dynamic_sections.elf_interp_start;\n phdr.p_paddr = dynamic_sections.elf_interp_start;\n phdr.p_filesz += dynamic_sections.elf_interp->size +\n dynamic_sections.elf_got->size +\n dynamic_sections.elf_dynstr->size +\n dynamic_sections.elf_dynsym->size +\n dynamic_sections.elf_dynamic->size;\n phdr.p_memsz += dynamic_sections.elf_interp->size +\n dynamic_sections.elf_got->size +\n dynamic_sections.elf_dynstr->size +\n dynamic_sections.elf_dynsym->size +\n dynamic_sections.elf_dynamic->size;\n }\n elf_write_blk(elf_program_header, &phdr, sizeof(elf32_phdr_t));\n\n\n if (dynlink) {\n /* program header - program interpreter (.interp section) */\n phdr.p_type = 3; /* PT_INTERP */\n phdr.p_offset = elf_header_len + elf_code->size + elf_rodata->size +\n dynamic_sections.elf_relplt->size +\n dynamic_sections.elf_plt->size; /* offset of segment */\n phdr.p_vaddr = dynamic_sections.elf_interp_start; /* virtual address */\n phdr.p_paddr = dynamic_sections.elf_interp_start; /* physical address */\n phdr.p_filesz = strlen(DYN_LINKER) + 1; /* size in file */\n phdr.p_memsz = strlen(DYN_LINKER) + 1; /* size in memory */\n phdr.p_flags = 4; /* flags */\n phdr.p_align = 1; /* alignment */\n elf_write_blk(elf_program_header, &phdr, sizeof(elf32_phdr_t));\n\n /* program header - .dynamic section */\n phdr.p_type = 2; /* PT_DYNAMIC */\n phdr.p_offset =\n elf_header_len + elf_code->size + elf_rodata->size +\n dynamic_sections.elf_relplt->size + dynamic_sections.elf_plt->size +\n dynamic_sections.elf_interp->size + dynamic_sections.elf_got->size +\n dynamic_sections.elf_dynstr->size +\n dynamic_sections.elf_dynsym->size; /* offset of segment */\n phdr.p_vaddr = dynamic_sections.elf_got_start +\n dynamic_sections.elf_got->size +\n dynamic_sections.elf_dynstr->size +\n dynamic_sections.elf_dynsym->size; /* virtual address */\n phdr.p_paddr = dynamic_sections.elf_got_start +\n dynamic_sections.elf_got->size +\n dynamic_sections.elf_dynstr->size +\n dynamic_sections.elf_dynsym->size; /* physical address */\n phdr.p_filesz = dynamic_sections.elf_dynamic->size; /* size in file */\n phdr.p_memsz = dynamic_sections.elf_dynamic->size; /* size in memory */\n phdr.p_flags = 6; /* flags */\n phdr.p_align = 4; /* alignment */\n elf_write_blk(elf_program_header, &phdr, sizeof(elf32_phdr_t));\n }\n}\n\nvoid elf_generate_section_headers(void)\n{\n /* Check for null pointers to prevent crashes */\n if (!elf_section_header || !elf_code || !elf_data || !elf_rodata ||\n !elf_symtab || !elf_strtab || !elf_shstrtab ||\n (dynlink &&\n (!dynamic_sections.elf_interp || !dynamic_sections.elf_relplt ||\n !dynamic_sections.elf_plt || !dynamic_sections.elf_got ||\n !dynamic_sections.elf_dynstr || !dynamic_sections.elf_dynsym ||\n !dynamic_sections.elf_dynamic))) {\n fatal(\"ELF section buffers not initialized\");\n return;\n }\n\n /* section header table */\n elf32_shdr_t shdr;\n int ofs = elf_header_len, sh_name = 0;\n\n /*\n * The following table uses the text section header as an example\n * to explain the ELF32 section header.\n *\n * | Section | |\n * & | Header bytes | Explanation |\n * ---+----------------+-------------------------------------------------+\n * | 0b 00 00 00 | sh_name: Name of the section. Giving the |\n * | | location of a null-terminated string. |\n * | 01 00 00 00 | sh_type: Type of the section's contents |\n * | | and semantics. |\n * | | 1 -> holds the program-defined |\n * | | information |\n * | 07 00 00 00 | sh_flags: Miscellaneous attributes. |\n * | | 0x1 -> writable, 0x2 -> allocatable |\n * | | 0x4 -> executable. |\n * | 54 00 01 00 | sh_addr: Starting address of the section |\n * | | in the memory image of a process. |\n * | 54 00 00 00 | sh_offset: Offset of the section in the file. |\n * | 0b 30 03 00 | sh_size: Size of the section. |\n * | 00 00 00 00 | sh_link: Section header table index link. |\n * | 00 00 00 00 | sh_info: Extra information. |\n * | 04 00 00 00 | sh_addralign: Address alignment constraints. |\n * | 00 00 00 00 | sh_entsize: Size of each entry. |\n * ---+----------------+-------------------------------------------------+\n * | | |\n */\n /* NULL section */\n shdr.sh_name = sh_name;\n shdr.sh_type = 0;\n shdr.sh_flags = 0;\n shdr.sh_addr = 0;\n shdr.sh_offset = 0;\n shdr.sh_size = 0;\n shdr.sh_link = 0;\n shdr.sh_info = 0;\n shdr.sh_addralign = 0;\n shdr.sh_entsize = 0;\n elf_write_blk(elf_section_header, &shdr, sizeof(elf32_shdr_t));\n sh_name += 1;\n\n /* .text */\n shdr.sh_name = sh_name;\n shdr.sh_type = 1;\n shdr.sh_flags = 7;\n shdr.sh_addr = elf_code_start;\n shdr.sh_offset = ofs;\n shdr.sh_size = elf_code->size;\n shdr.sh_link = 0;\n shdr.sh_info = 0;\n shdr.sh_addralign = 4;\n shdr.sh_entsize = 0;\n elf_write_blk(elf_section_header, &shdr, sizeof(elf32_shdr_t));\n ofs += elf_code->size;\n sh_name += strlen(\".text\") + 1;\n\n /* .rodata */\n shdr.sh_name = sh_name; /* Offset in shstrtab for \".rodata\" */\n shdr.sh_type = 1; /* SHT_PROGBITS */\n shdr.sh_flags = 2; /* SHF_ALLOC only (read-only) */\n shdr.sh_addr = elf_rodata_start;\n shdr.sh_offset = ofs;\n shdr.sh_size = elf_rodata->size;\n shdr.sh_link = 0;\n shdr.sh_info = 0;\n shdr.sh_addralign = 4;\n shdr.sh_entsize = 0;\n elf_write_blk(elf_section_header, &shdr, sizeof(elf32_shdr_t));\n ofs += elf_rodata->size;\n sh_name += strlen(\".rodata\") + 1;\n\n if (dynlink) {\n /* .rel.plt */\n shdr.sh_name = sh_name;\n shdr.sh_type = 9; /* SHT_REL */\n shdr.sh_flags = 0x42; /* 0x40 | SHF_ALLOC */\n shdr.sh_addr = dynamic_sections.elf_relplt_start;\n shdr.sh_offset = ofs;\n shdr.sh_size = dynamic_sections.elf_relplt->size;\n shdr.sh_link = 8; /* The section header index of .dynsym. */\n shdr.sh_info = 6; /* The section header index of .got. */\n shdr.sh_addralign = 4;\n shdr.sh_entsize = sizeof(elf32_rel_t);\n elf_write_blk(elf_section_header, &shdr, sizeof(elf32_shdr_t));\n ofs += dynamic_sections.elf_relplt->size;\n sh_name += strlen(\".rel.plt\") + 1;\n\n /* .plt */\n shdr.sh_name = sh_name;\n shdr.sh_type = 1;\n shdr.sh_flags = 0x6;\n shdr.sh_addr = dynamic_sections.elf_plt_start;\n shdr.sh_offset = ofs;\n shdr.sh_size = dynamic_sections.elf_plt->size;\n shdr.sh_link = 0;\n shdr.sh_info = 0;\n shdr.sh_addralign = 4;\n shdr.sh_entsize = 4;\n elf_write_blk(elf_section_header, &shdr, sizeof(elf32_shdr_t));\n ofs += dynamic_sections.elf_plt->size;\n sh_name += strlen(\".plt\") + 1;\n\n /* .interp */\n shdr.sh_name = sh_name;\n shdr.sh_type = 1;\n shdr.sh_flags = 0x2;\n shdr.sh_addr = dynamic_sections.elf_interp_start;\n shdr.sh_offset = ofs;\n shdr.sh_size = strlen(DYN_LINKER) + 1;\n shdr.sh_link = 0;\n shdr.sh_info = 0;\n shdr.sh_addralign = 1;\n shdr.sh_entsize = 0;\n elf_write_blk(elf_section_header, &shdr, sizeof(elf32_shdr_t));\n ofs += dynamic_sections.elf_interp->size;\n sh_name += strlen(\".interp\") + 1;\n\n /* .got */\n shdr.sh_name = sh_name;\n shdr.sh_type = 1;\n shdr.sh_flags = 0x3;\n shdr.sh_addr = dynamic_sections.elf_got_start;\n shdr.sh_offset = ofs;\n shdr.sh_size = dynamic_sections.elf_got->size;\n shdr.sh_link = 0;\n shdr.sh_info = 0;\n shdr.sh_addralign = 4;\n shdr.sh_entsize = PTR_SIZE;\n elf_write_blk(elf_section_header, &shdr, sizeof(elf32_shdr_t));\n ofs += dynamic_sections.elf_got->size;\n sh_name += strlen(\".got\") + 1;\n\n /* .dynstr */\n shdr.sh_name = sh_name;\n shdr.sh_type = 3;\n shdr.sh_flags = 0x2;\n shdr.sh_addr =\n dynamic_sections.elf_got_start + dynamic_sections.elf_got->size;\n shdr.sh_offset = ofs;\n shdr.sh_size = dynamic_sections.elf_dynstr->size;\n shdr.sh_link = 0;\n shdr.sh_info = 0;\n shdr.sh_addralign = 1;\n shdr.sh_entsize = 0;\n elf_write_blk(elf_section_header, &shdr, sizeof(elf32_shdr_t));\n ofs += dynamic_sections.elf_dynstr->size;\n sh_name += strlen(\".dynstr\") + 1;\n\n /* .dynsym */\n shdr.sh_name = sh_name;\n shdr.sh_type = 11;\n shdr.sh_flags = 0x2;\n shdr.sh_addr = dynamic_sections.elf_got_start +\n dynamic_sections.elf_got->size +\n dynamic_sections.elf_dynstr->size;\n shdr.sh_offset = ofs;\n shdr.sh_size = dynamic_sections.elf_dynsym->size;\n shdr.sh_link = 7; /* The section header index of .dynstr. */\n shdr.sh_info = 1; /* The index of the first non-local symbol. */\n shdr.sh_addralign = 4;\n shdr.sh_entsize = sizeof(elf32_sym_t);\n elf_write_blk(elf_section_header, &shdr, sizeof(elf32_shdr_t));\n ofs += dynamic_sections.elf_dynsym->size;\n sh_name += strlen(\".dynsym\") + 1;\n\n /* .dynamic */\n shdr.sh_name = sh_name;\n shdr.sh_type = 6;\n shdr.sh_flags = 0x3;\n shdr.sh_addr = dynamic_sections.elf_got_start +\n dynamic_sections.elf_got->size +\n dynamic_sections.elf_dynstr->size +\n dynamic_sections.elf_dynsym->size;\n shdr.sh_offset = ofs;\n shdr.sh_size = dynamic_sections.elf_dynamic->size;\n shdr.sh_link = 7; /* The section header index of .dynstr. */\n shdr.sh_info = 0;\n shdr.sh_addralign = 4;\n shdr.sh_entsize = 0;\n elf_write_blk(elf_section_header, &shdr, sizeof(elf32_shdr_t));\n ofs += dynamic_sections.elf_dynamic->size;\n sh_name += strlen(\".dynamic\") + 1;\n }\n\n /* .data */\n shdr.sh_name = sh_name;\n shdr.sh_type = 1;\n shdr.sh_flags = 3;\n shdr.sh_addr = elf_data_start;\n shdr.sh_offset = ofs;\n shdr.sh_size = elf_data->size;\n shdr.sh_link = 0;\n shdr.sh_info = 0;\n shdr.sh_addralign = 4;\n shdr.sh_entsize = 0;\n elf_write_blk(elf_section_header, &shdr, sizeof(elf32_shdr_t));\n ofs += elf_data->size;\n sh_name += strlen(\".data\") + 1;\n\n /* .bss */\n shdr.sh_name = sh_name; /* Offset in shstrtab for \".bss\" */\n shdr.sh_type = 8; /* SHT_NOBITS */\n shdr.sh_flags = 3; /* SHF_ALLOC | SHF_WRITE */\n shdr.sh_addr = elf_bss_start;\n shdr.sh_offset = ofs; /* File offset (not actually used for NOBITS) */\n shdr.sh_size = elf_bss_size;\n shdr.sh_link = 0;\n shdr.sh_info = 0;\n shdr.sh_addralign = 4;\n shdr.sh_entsize = 0;\n elf_write_blk(elf_section_header, &shdr, sizeof(elf32_shdr_t));\n sh_name += strlen(\".bss\") + 1;\n /* Note: .bss is not written to file (SHT_NOBITS) */\n\n /* .symtab */\n shdr.sh_name = sh_name;\n shdr.sh_type = 2;\n shdr.sh_flags = 0;\n shdr.sh_addr = 0;\n shdr.sh_offset = ofs;\n shdr.sh_size = elf_symtab->size;\n shdr.sh_link = dynlink ? 13 : 6; /* Link to .strtab */\n shdr.sh_info = elf_symbol_index;\n shdr.sh_addralign = 4;\n shdr.sh_entsize = 16;\n elf_write_blk(elf_section_header, &shdr, sizeof(elf32_shdr_t));\n ofs += elf_symtab->size;\n sh_name += strlen(\".symtab\") + 1;\n\n /* .strtab */\n shdr.sh_name = sh_name;\n shdr.sh_type = 3;\n shdr.sh_flags = 0;\n shdr.sh_addr = 0;\n shdr.sh_offset = ofs;\n shdr.sh_size = elf_strtab->size;\n shdr.sh_link = 0;\n shdr.sh_info = 0;\n shdr.sh_addralign = 1;\n shdr.sh_entsize = 0;\n elf_write_blk(elf_section_header, &shdr, sizeof(elf32_shdr_t));\n ofs += elf_strtab->size;\n sh_name += strlen(\".strtab\") + 1;\n\n /* .shstr */\n shdr.sh_name = sh_name;\n shdr.sh_type = 3;\n shdr.sh_flags = 0;\n shdr.sh_addr = 0;\n shdr.sh_offset = ofs;\n shdr.sh_size = elf_shstrtab->size;\n shdr.sh_link = 0;\n shdr.sh_info = 0;\n shdr.sh_addralign = 1;\n shdr.sh_entsize = 0;\n elf_write_blk(elf_section_header, &shdr, sizeof(elf32_shdr_t));\n sh_name += strlen(\".shstrtab\") + 1;\n}\n\nvoid elf_align(strbuf_t *elf_array)\n{\n /* Check for null pointers to prevent crashes */\n if (!elf_array) {\n fatal(\"ELF buffers not initialized for alignment\");\n return;\n }\n\n while (elf_array->size & 3)\n elf_write_byte(elf_array, 0);\n}\n\nvoid elf_generate_sections(void)\n{\n if (!elf_shstrtab ||\n (dynlink &&\n (!dynamic_sections.elf_interp || !dynamic_sections.elf_relplt ||\n !dynamic_sections.elf_plt || !dynamic_sections.elf_got ||\n !dynamic_sections.elf_dynstr || !dynamic_sections.elf_dynsym ||\n !dynamic_sections.elf_dynamic))) {\n fatal(\"ELF section buffers not initialized\");\n return;\n }\n\n if (dynlink) {\n /* In dynamic linking mode, elf_generate_sections() also generates\n * .interp, .dynsym, .dynstr, .relplt, .got and dynamic sections.\n *\n * .plt section is generated at the code generation phase.\n *\n * TODO:\n * Define a new structure named 'elf32_rela_t' and use it to generate\n * relocation entries for RISC-V architecture.\n */\n elf32_sym_t sym;\n elf32_dyn_t dyn;\n elf32_rel_t rel;\n int dymsym_idx = 1, func_plt_ofs, func_got_ofs, st_name = 0;\n memset(&sym, 0, sizeof(elf32_sym_t));\n memset(&dyn, 0, sizeof(elf32_dyn_t));\n memset(&rel, 0, sizeof(elf32_rel_t));\n\n /* .interp section */\n elf_write_str(dynamic_sections.elf_interp, DYN_LINKER);\n elf_write_byte(dynamic_sections.elf_interp, 0);\n elf_align(dynamic_sections.elf_interp);\n\n /* Add first symbol table entry (STN_UNDEF) to .dynsym section. */\n elf_write_blk(dynamic_sections.elf_dynsym, &sym, sizeof(elf32_sym_t));\n\n /* Add first NULL byte to .dynstr section. */\n elf_write_byte(dynamic_sections.elf_dynstr, 0);\n st_name += 1;\n\n /* Add \"libc.so.6\" to .dynstr section. */\n elf_write_str(dynamic_sections.elf_dynstr, LIBC_SO);\n elf_write_byte(dynamic_sections.elf_dynstr, 0);\n st_name += strlen(LIBC_SO) + 1;\n\n /* Perform the following steps for each external function.\n * - Add a new PLT relocation entry to .relplt section.\n * - Add a new dynamic symbol entry to .dynsym section.\n * - Append the external function name to .dynstr section.\n * - Set plt_offset and got_offset for the external function.\n *\n * Since __libc_start_main is not added to the function list,\n * it must be handled additionally first.\n */\n rel.r_offset = dynamic_sections.elf_got_start + PTR_SIZE * 3;\n rel.r_info = (dymsym_idx << 8) | R_ARCH_JUMP_SLOT;\n elf_write_blk(dynamic_sections.elf_relplt, &rel, sizeof(elf32_rel_t));\n\n sym.st_name = st_name;\n sym.st_info = ELF32_ST_INFO(1, 2); /* STB_GLOBAL = 1, STT_FUNC = 2 */\n elf_write_blk(dynamic_sections.elf_dynsym, &sym, sizeof(elf32_sym_t));\n dymsym_idx += 1;\n\n elf_write_str(dynamic_sections.elf_dynstr, \"__libc_start_main\");\n elf_write_byte(dynamic_sections.elf_dynstr, 0);\n st_name += strlen(\"__libc_start_main\") + 1;\n\n /* Because PLT[1] and GOT[3] are reserved for __libc_start_main,\n * its plt_offset and got_offset must be PLT_FIXUP_SIZE and\n * PTR_SIZE * 3, respectively. Therefore, no offset assignment is\n * required for this function.\n */\n\n func_plt_ofs = PLT_FIXUP_SIZE + PLT_ENT_SIZE;\n func_got_ofs = PTR_SIZE << 2;\n for (func_t *func = FUNC_LIST.head; func; func = func->next) {\n if (func->is_used && !func->bbs) {\n rel.r_offset += PTR_SIZE;\n rel.r_info = (dymsym_idx << 8) | R_ARCH_JUMP_SLOT;\n elf_write_blk(dynamic_sections.elf_relplt, &rel,\n sizeof(elf32_rel_t));\n\n sym.st_name = st_name;\n sym.st_info =\n ELF32_ST_INFO(1, 2); /* STB_GLOBAL = 1, STT_FUNC = 2 */\n elf_write_blk(dynamic_sections.elf_dynsym, &sym,\n sizeof(elf32_sym_t));\n dymsym_idx += 1;\n\n elf_write_str(dynamic_sections.elf_dynstr,\n func->return_def.var_name);\n elf_write_byte(dynamic_sections.elf_dynstr, 0);\n st_name += strlen(func->return_def.var_name) + 1;\n\n func->plt_offset = func_plt_ofs;\n func->got_offset = func_got_ofs;\n\n func_plt_ofs += PLT_ENT_SIZE;\n func_got_ofs += PTR_SIZE;\n }\n }\n /* Ensure proper alignment for .dynstr section. */\n elf_align(dynamic_sections.elf_dynstr);\n\n /* .got section\n *\n * - GOT[0] holds the virtual address of .dynamic section.\n * - GOT[1] and GOT[2] are reserved for link_map and resolver,\n * and are initialized to 0.\n * - The remaining entries are initialized to &PLT[0].\n */\n elf_write_int(dynamic_sections.elf_got,\n dynamic_sections.elf_got_start +\n dynamic_sections.got_size +\n dynamic_sections.elf_dynstr->size +\n dynamic_sections.elf_dynsym->size);\n elf_write_int(dynamic_sections.elf_got, 0);\n elf_write_int(dynamic_sections.elf_got, 0);\n for (int i = PTR_SIZE * 3; i < dynamic_sections.got_size; i += PTR_SIZE)\n elf_write_int(dynamic_sections.elf_got,\n dynamic_sections.elf_plt_start);\n\n /* .dynamic section */\n dyn.d_tag = 0x5; /* STRTAB */\n dyn.d_un =\n dynamic_sections.elf_got_start +\n dynamic_sections.got_size; /* The virtual address of .dynstr. */\n elf_write_blk(dynamic_sections.elf_dynamic, &dyn, sizeof(elf32_dyn_t));\n\n dyn.d_tag = 0xa; /* STRSZ */\n dyn.d_un = dynamic_sections.elf_dynstr->size;\n elf_write_blk(dynamic_sections.elf_dynamic, &dyn, sizeof(elf32_dyn_t));\n\n dyn.d_tag = 0x6; /* SYMTAB */\n dyn.d_un = dynamic_sections.elf_got_start + dynamic_sections.got_size +\n dynamic_sections.elf_dynstr\n ->size; /* The virtual address of .dynsym. */\n elf_write_blk(dynamic_sections.elf_dynamic, &dyn, sizeof(elf32_dyn_t));\n\n dyn.d_tag = 0xb; /* SYMENT */\n dyn.d_un = sizeof(elf32_sym_t); /* Size of an entry. */\n elf_write_blk(dynamic_sections.elf_dynamic, &dyn, sizeof(elf32_dyn_t));\n\n dyn.d_tag = 0x11; /* REL */\n dyn.d_un = dynamic_sections\n .elf_relplt_start; /* The virtual address of .rel.plt. */\n elf_write_blk(dynamic_sections.elf_dynamic, &dyn, sizeof(elf32_dyn_t));\n\n dyn.d_tag = 0x12; /* RELSZ */\n dyn.d_un = dynamic_sections.relplt_size;\n elf_write_blk(dynamic_sections.elf_dynamic, &dyn, sizeof(elf32_dyn_t));\n\n dyn.d_tag = 0x13; /* RELENT */\n dyn.d_un = sizeof(elf32_rel_t);\n elf_write_blk(dynamic_sections.elf_dynamic, &dyn, sizeof(elf32_dyn_t));\n\n dyn.d_tag = 0x3; /* PLTGOT */\n dyn.d_un =\n dynamic_sections.elf_got_start; /* The virtual address of .got.*/\n elf_write_blk(dynamic_sections.elf_dynamic, &dyn, sizeof(elf32_dyn_t));\n\n dyn.d_tag = 0x2; /* PLTRELSZ */\n dyn.d_un = dynamic_sections.relplt_size;\n elf_write_blk(dynamic_sections.elf_dynamic, &dyn, sizeof(elf32_dyn_t));\n\n dyn.d_tag = 0x14; /* PLTREL */\n dyn.d_un = 0x11;\n elf_write_blk(dynamic_sections.elf_dynamic, &dyn, sizeof(elf32_dyn_t));\n\n dyn.d_tag = 0x17; /* JMPREL */\n dyn.d_un = dynamic_sections\n .elf_relplt_start; /* The virtual address of .rel.plt. */\n elf_write_blk(dynamic_sections.elf_dynamic, &dyn, sizeof(elf32_dyn_t));\n\n dyn.d_tag = 0x1; /* NEEDED */\n dyn.d_un = 0x1; /* The index of \"libc.so.6\" in .dynstr. */\n elf_write_blk(dynamic_sections.elf_dynamic, &dyn, sizeof(elf32_dyn_t));\n\n dyn.d_tag = 0x0; /* NULL */\n dyn.d_un = 0x0;\n elf_write_blk(dynamic_sections.elf_dynamic, &dyn, sizeof(elf32_dyn_t));\n }\n\n /* shstr section; len = 53\n * If using dynamic linking, len = 105.\n */\n elf_write_byte(elf_shstrtab, 0);\n elf_write_str(elf_shstrtab, \".text\");\n elf_write_byte(elf_shstrtab, 0);\n elf_write_str(elf_shstrtab, \".rodata\");\n elf_write_byte(elf_shstrtab, 0);\n if (dynlink) {\n elf_write_str(elf_shstrtab, \".rel.plt\");\n elf_write_byte(elf_shstrtab, 0);\n elf_write_str(elf_shstrtab, \".plt\");\n elf_write_byte(elf_shstrtab, 0);\n elf_write_str(elf_shstrtab, \".interp\");\n elf_write_byte(elf_shstrtab, 0);\n elf_write_str(elf_shstrtab, \".got\");\n elf_write_byte(elf_shstrtab, 0);\n elf_write_str(elf_shstrtab, \".dynstr\");\n elf_write_byte(elf_shstrtab, 0);\n elf_write_str(elf_shstrtab, \".dynsym\");\n elf_write_byte(elf_shstrtab, 0);\n elf_write_str(elf_shstrtab, \".dynamic\");\n elf_write_byte(elf_shstrtab, 0);\n }\n elf_write_str(elf_shstrtab, \".data\");\n elf_write_byte(elf_shstrtab, 0);\n elf_write_str(elf_shstrtab, \".bss\");\n elf_write_byte(elf_shstrtab, 0);\n elf_write_str(elf_shstrtab, \".symtab\");\n elf_write_byte(elf_shstrtab, 0);\n elf_write_str(elf_shstrtab, \".strtab\");\n elf_write_byte(elf_shstrtab, 0);\n elf_write_str(elf_shstrtab, \".shstrtab\");\n elf_write_byte(elf_shstrtab, 0);\n}\n\nvoid elf_add_symbol(const char *symbol, int pc)\n{\n /* Check for null pointers to prevent crashes */\n if (!symbol || !elf_symtab || !elf_strtab) {\n fatal(\"Invalid parameters for elf_add_symbol\");\n return;\n }\n\n elf_write_int(elf_symtab, elf_strtab->size);\n elf_write_int(elf_symtab, pc);\n elf_write_int(elf_symtab, 0);\n elf_write_int(elf_symtab, pc == 0 ? 0 : 1 << 16);\n\n elf_write_str(elf_strtab, symbol);\n elf_write_byte(elf_strtab, 0);\n elf_symbol_index++;\n}\n\nvoid elf_preprocess(void)\n{\n elf_header_len = sizeof(elf32_hdr_t) + (sizeof(elf32_phdr_t) << 1);\n if (dynlink)\n elf_header_len += (sizeof(elf32_phdr_t) << 1);\n elf_align(elf_data);\n elf_align(elf_rodata);\n elf_code_start = ELF_START + elf_header_len;\n elf_rodata_start = elf_code_start + elf_offset;\n if (dynlink) {\n /* Precalculate the sizes of .rel.plt, .plt and .got sections.\n *\n * Suppose the compiled program has n external functions:\n * - .rel.plt contains n entries.\n * - .plt has n entries plus one fixup entry.\n * - .got includes n + 3 entries\n * - GOT[0] holds the virtual address of .dynamic section.\n * - GOT[1] and GOT[2] are reserved for link_map and resolver\n * (both set to 0).\n * - The remaining entries correspond to all external functions.\n *\n * Next, consider the case of __libc_start_main before initializing\n * the sizes:\n * - .rel.plt has the one entry for __libc_start_main.\n * - .plt includes one fixup entry plus one entry for __libc_start_main.\n * - .got has 3 + 1 entries.\n * - 3 entries for GOT[0] - GOT[2].\n * - 1 entry (GOT[3]) reserved for __libc_start_main.\n *\n * Therefore, the following code initialize the section sizes based on\n * the layout described above, and then traverse the function list in a\n * for loop to increment the sizes for each newly found external\n * function.\n */\n dynamic_sections.relplt_size = sizeof(elf32_rel_t);\n dynamic_sections.plt_size = PLT_FIXUP_SIZE + PLT_ENT_SIZE;\n dynamic_sections.got_size = PTR_SIZE * 3 + PTR_SIZE;\n for (func_t *func = FUNC_LIST.head; func; func = func->next) {\n if (func->is_used && !func->bbs) {\n dynamic_sections.relplt_size += sizeof(elf32_rel_t);\n dynamic_sections.plt_size += PLT_ENT_SIZE;\n dynamic_sections.got_size += PTR_SIZE;\n }\n }\n\n /* Set the starting addresses of the three sections. */\n int elf_interp_size = strlen(DYN_LINKER) + 1;\n elf_interp_size = ALIGN_UP(elf_interp_size, 4);\n dynamic_sections.elf_relplt_start = elf_rodata_start + elf_rodata->size;\n dynamic_sections.elf_plt_start =\n dynamic_sections.elf_relplt_start + dynamic_sections.relplt_size;\n /* Since the first section of the second load segment is .interp\n * when using dynamic linking mode, adding PAGESIZE to elf_interp_start\n * is to ensure that two load segments don't share a common page.\n */\n dynamic_sections.elf_interp_start = dynamic_sections.elf_plt_start +\n dynamic_sections.plt_size +\n PAGESIZE;\n dynamic_sections.elf_got_start =\n dynamic_sections.elf_interp_start + elf_interp_size;\n }\n elf_generate_sections();\n if (dynlink) {\n elf_data_start = dynamic_sections.elf_got_start +\n dynamic_sections.elf_got->size +\n dynamic_sections.elf_dynstr->size +\n dynamic_sections.elf_dynsym->size +\n dynamic_sections.elf_dynamic->size;\n } else {\n /* To prevent two load segments from sharing a common page, add\n * PAGESIZE to elf_data_start, since the first section of the second\n * load segment is .data in static linking mode.\n */\n elf_data_start = elf_rodata_start + elf_rodata->size + PAGESIZE;\n }\n elf_bss_start = elf_data_start + elf_data->size;\n elf_align(elf_symtab);\n elf_align(elf_strtab);\n}\n\nvoid elf_postprocess(void)\n{\n elf_generate_header();\n elf_generate_program_headers();\n elf_generate_section_headers();\n}\n\nvoid elf_generate(const char *outfile)\n{\n if (!outfile)\n outfile = \"a.out\";\n\n FILE *fp = fopen(outfile, \"wb\");\n if (!fp) {\n fatal(\"Unable to open output file for writing\");\n return;\n }\n\n for (int i = 0; i < elf_header->size; i++)\n fputc(elf_header->elements[i], fp);\n for (int i = 0; i < elf_program_header->size; i++)\n fputc(elf_program_header->elements[i], fp);\n /* Read-only sections */\n for (int i = 0; i < elf_code->size; i++)\n fputc(elf_code->elements[i], fp);\n for (int i = 0; i < elf_rodata->size; i++)\n fputc(elf_rodata->elements[i], fp);\n\n if (dynlink) {\n /* Read-only sections */\n for (int i = 0; i < dynamic_sections.elf_relplt->size; i++)\n fputc(dynamic_sections.elf_relplt->elements[i], fp);\n for (int i = 0; i < dynamic_sections.elf_plt->size; i++)\n fputc(dynamic_sections.elf_plt->elements[i], fp);\n /* Readable and writable sections */\n for (int i = 0; i < dynamic_sections.elf_interp->size; i++)\n fputc(dynamic_sections.elf_interp->elements[i], fp);\n for (int i = 0; i < dynamic_sections.elf_got->size; i++)\n fputc(dynamic_sections.elf_got->elements[i], fp);\n for (int i = 0; i < dynamic_sections.elf_dynstr->size; i++)\n fputc(dynamic_sections.elf_dynstr->elements[i], fp);\n for (int i = 0; i < dynamic_sections.elf_dynsym->size; i++)\n fputc(dynamic_sections.elf_dynsym->elements[i], fp);\n for (int i = 0; i < dynamic_sections.elf_dynamic->size; i++)\n fputc(dynamic_sections.elf_dynamic->elements[i], fp);\n }\n /* Readable and writable sections */\n for (int i = 0; i < elf_data->size; i++)\n fputc(elf_data->elements[i], fp);\n /* Note: .bss is not written to file (SHT_NOBITS) */\n\n /* Other sections and section headers */\n for (int i = 0; i < elf_symtab->size; i++)\n fputc(elf_symtab->elements[i], fp);\n for (int i = 0; i < elf_strtab->size; i++)\n fputc(elf_strtab->elements[i], fp);\n for (int i = 0; i < elf_shstrtab->size; i++)\n fputc(elf_shstrtab->elements[i], fp);\n for (int i = 0; i < elf_section_header->size; i++)\n fputc(elf_section_header->elements[i], fp);\n fclose(fp);\n}\n" }, { "path": "src/globals.c", "content": "/*\n * shecc - Self-Hosting and Educational C Compiler.\n *\n * shecc is freely redistributable under the BSD 2 clause license. See the\n * file \"LICENSE\" for information on usage and redistribution of this file.\n */\n\n#pragma once\n#include \n#include \n#include \n#include \n#include \n\n#include \"defs.h\"\n\n/* Forward declaration for string interning */\nchar *intern_string(char *str);\n\n/* Lexer */\ntoken_t *cur_token;\n/* TOKEN_CACHE maps filename to the corresponding computed token stream */\nhashmap_t *TOKEN_CACHE;\nstrbuf_t *LIBC_SRC;\n\n/* Global objects */\n\nhashmap_t *SRC_FILE_MAP;\nhashmap_t *FUNC_MAP;\nhashmap_t *CONSTANTS_MAP;\n\n/* Types */\n\ntype_t *TYPES;\nint types_idx = 0;\n\ntype_t *TY_void;\ntype_t *TY_char;\ntype_t *TY_bool;\ntype_t *TY_int;\ntype_t *TY_short;\n\n/* Arenas */\n\narena_t *INSN_ARENA;\n\n/* HASHMAP_ARENA is responsible for hashmap_node_t allocation */\narena_t *HASHMAP_ARENA;\n\n/* BLOCK_ARENA is responsible for block_t / var_t allocation */\narena_t *BLOCK_ARENA;\n\n/* BB_ARENA is responsible for basic_block_t / ph2_ir_t allocation */\narena_t *BB_ARENA;\n\n/* TOKEN_ARENA is responsible for token_t (including literal) /\n * source_location_t allocation */\narena_t *TOKEN_ARENA;\n\n/* GENERAL_ARENA is responsible for functions, symbols, constants, aliases,\n * macros, and traversal args\n */\narena_t *GENERAL_ARENA;\n\nint bb_label_idx = 0;\n\nph2_ir_t **PH2_IR_FLATTEN;\nint ph2_ir_idx = 0;\n\nfunc_list_t FUNC_LIST;\nfunc_t *GLOBAL_FUNC;\nblock_t *GLOBAL_BLOCK;\nbasic_block_t *MAIN_BB;\nint elf_offset = 0;\n\nregfile_t REGS[REG_CNT];\n\nhashmap_t *INCLUSION_MAP;\n\n/* ELF sections */\nstrbuf_t *elf_code;\nstrbuf_t *elf_data;\nstrbuf_t *elf_rodata;\nstrbuf_t *elf_header;\nstrbuf_t *elf_program_header;\nstrbuf_t *elf_symtab;\nstrbuf_t *elf_strtab;\nstrbuf_t *elf_section_header;\nstrbuf_t *elf_shstrtab;\nint elf_header_len;\nint elf_code_start;\nint elf_data_start;\nint elf_rodata_start;\nint elf_bss_start;\nint elf_bss_size;\ndynamic_sections_t dynamic_sections;\n\n/* Command line compilation flags */\nbool dynlink = false;\nbool libc = true;\nbool expand_only = false;\nbool dump_ir = false;\nbool hard_mul_div = false;\n\n/* Create a new arena block with given capacity.\n * @capacity: The capacity of the arena block. Must be positive.\n *\n * Return: The pointer of created arena block. NULL if failed to allocate.\n */\narena_block_t *arena_block_create(int capacity)\n{\n arena_block_t *block = malloc(sizeof(arena_block_t));\n\n if (!block) {\n printf(\"Failed to allocate memory for arena block structure\\n\");\n abort();\n }\n\n block->memory = malloc(capacity * sizeof(char));\n\n if (!block->memory) {\n printf(\"Failed to allocate memory for arena block buffer\\n\");\n free(block);\n abort();\n }\n\n block->capacity = capacity;\n block->offset = 0;\n block->next = NULL;\n return block;\n}\n\n/* Free a single arena block and its memory buffer.\n * @block: Pointer to the arena_block_t to free. Must not be NULL.\n */\nvoid arena_block_free(arena_block_t *block)\n{\n free(block->memory);\n free(block);\n}\n\n/* Initialize the given arena with initial capacity.\n * @initial_capacity: The initial capacity of the arena. Must be positive.\n *\n * Return: The pointer of initialized arena.\n */\narena_t *arena_init(int initial_capacity)\n{\n arena_t *arena = malloc(sizeof(arena_t));\n if (!arena) {\n printf(\"Failed to allocate memory for arena structure\\n\");\n abort();\n }\n arena->head = arena_block_create(initial_capacity);\n arena->total_bytes = initial_capacity;\n /* Use the initial capacity as the default block size for future growth. */\n arena->block_size = initial_capacity;\n return arena;\n}\n\n/* Allocate memory from the given arena with given size.\n * The arena may create a new arena block if no space is available.\n * @arena: The arena to allocate memory from. Must not be NULL.\n * @size: The size of memory to allocate. Must be positive.\n *\n * Return: The pointer of allocated memory. NULL if new arena block is failed to\n * allocate.\n */\nvoid *arena_alloc(arena_t *arena, int size)\n{\n if (size <= 0) {\n printf(\"arena_alloc: size must be positive\\n\");\n abort();\n }\n\n /* Align to sizeof(void*) bytes for host compatibility */\n const int alignment = sizeof(void *);\n size = (size + alignment - 1) & ~(alignment - 1);\n\n if (!arena->head || arena->head->offset + size > arena->head->capacity) {\n /* Need a new block: choose capacity = max(DEFAULT_ARENA_SIZE,\n * arena->block_size, size) */\n const int base =\n (arena->block_size > DEFAULT_ARENA_SIZE ? arena->block_size\n : DEFAULT_ARENA_SIZE);\n const int new_capacity = (size > base ? size : base);\n arena_block_t *new_block = arena_block_create(new_capacity);\n new_block->next = arena->head;\n arena->head = new_block;\n arena->total_bytes += new_capacity;\n }\n\n void *ptr = arena->head->memory + arena->head->offset;\n arena->head->offset += size;\n return ptr;\n}\n\n/* arena_alloc() plus explicit zero‑initialization.\n * @arena: The arena to allocate memory from. Must not be NULL.\n * @n: Number of elements.\n * @size: Size of each element in bytes.\n *\n * Internally calls arena_alloc(n * size) and then fills the entire region with\n * zero bytes.\n *\n * Return: Pointer to zero-initialized memory.\n */\nvoid *arena_calloc(arena_t *arena, int n, int size)\n{\n if (n * size == 0) {\n printf(\"arena_calloc: cannot allocate 0 bytes\\n\");\n abort();\n }\n\n int total = n * size;\n void *ptr = arena_alloc(arena, total);\n\n /* Use memset for better performance */\n memset(ptr, 0, total);\n\n return ptr;\n}\n\n/* Reallocate a previously allocated region within the arena to a different\n * size.\n *\n * Behaviors:\n * 1. If oldptr == NULL and oldsz == 0, act like malloc.\n * 2. If newsz <= oldsz, return oldptr immediately.\n * 3. Grow in place if oldptr is the last allocation in the current block.\n * 4. Otherwise, allocate a new region and copy old data.\n *\n * @arena: Pointer to the arena. Must not be NULL.\n * @oldptr: Pointer to the previously allocated memory in the arena.\n * @oldsz: Original size (in bytes) of that allocation.\n * @newsz: New desired size (in bytes).\n *\n * Return: Pointer to the reallocated (resized) memory region.\n */\nvoid *arena_realloc(arena_t *arena, char *oldptr, int oldsz, int newsz)\n{\n /* act like malloc */\n if (oldptr == NULL) {\n if (oldsz != 0) {\n printf(\"arena_realloc: oldptr == NULL requires oldsz == 0\\n\");\n abort();\n }\n return arena_alloc(arena, newsz);\n }\n if (oldsz == 0) {\n printf(\"arena_realloc: oldptr != NULL requires oldsz > 0\\n\");\n abort();\n }\n\n /* return oldptr immediately */\n if (newsz <= oldsz) {\n return oldptr;\n }\n\n /* From here on, oldptr != NULL and newsz > oldsz and oldsz != 0 */\n int delta = newsz - oldsz;\n arena_block_t *blk = arena->head;\n char *block_end = blk->memory + blk->offset;\n\n /* grow in place if oldptr is the last allocation in the current block */\n if (oldptr + oldsz == block_end && blk->offset + delta <= blk->capacity) {\n blk->offset += delta;\n return oldptr;\n }\n\n /* allocate a new region and copy old data */\n void *newptr = arena_alloc(arena, newsz);\n memcpy(newptr, oldptr, oldsz);\n return newptr;\n}\n\n/* Duplicate a NULL-terminated string into the arena.\n *\n * @arena: a Pointer to the arena. Must not be NULL.\n * @str: NULL-terminated input string to duplicate. Must not be NULL.\n *\n * Return: Pointer to the duplicated string stored in the arena.\n */\nchar *arena_strdup(arena_t *arena, char *str)\n{\n const int n = strlen(str);\n char *dup = arena_alloc(arena, n + 1);\n memcpy(dup, str, n);\n dup[n] = '\\0';\n return dup;\n}\n\n/* Duplicate a block of memory into the arena.\n * Allocates size bytes within the arena and copies data from the input pointer.\n *\n * @arena: a Pointer to the arena. Must not be NULL.\n * @data: data Pointer to the source memory. Must not be NULL.\n * @size: size Number of bytes to copy. Must be non-negative.\n *\n * Return: The pointer to the duplicated memory stored in the arena.\n */\nvoid *arena_memdup(arena_t *arena, void *data, int size)\n{\n return memcpy(arena_alloc(arena, size), data, size);\n}\n\n/* Typed allocators for consistent memory management */\nfunc_t *arena_alloc_func(void)\n{\n return arena_calloc(GENERAL_ARENA, 1, sizeof(func_t));\n}\n\nsymbol_t *arena_alloc_symbol(void)\n{\n return arena_calloc(GENERAL_ARENA, 1, sizeof(symbol_t));\n}\n\nconstant_t *arena_alloc_constant(void)\n{\n /* constant_t is simple, can avoid zeroing */\n constant_t *c = arena_alloc(GENERAL_ARENA, sizeof(constant_t));\n c->alias[0] = '\\0';\n c->value = 0;\n return c;\n}\n\nbb_traversal_args_t *arena_alloc_traversal_args(void)\n{\n /* Keep using calloc for safety */\n return arena_calloc(GENERAL_ARENA, 1, sizeof(bb_traversal_args_t));\n}\n\nvoid arena_free(arena_t *arena)\n{\n arena_block_t *block = arena->head;\n arena_block_t *next;\n\n while (block) {\n next = block->next;\n arena_block_free(block);\n block = next;\n }\n\n free(arena);\n}\n\n/* Hash a string with FNV-1a hash function\n * and converts into usable hashmap index. The range of returned\n * hashmap index is ranged from \"(0 ~ 2,147,483,647) mod size\" due to\n * lack of unsigned integer implementation.\n * @size: The size of map. Must not be negative or 0.\n * @key: The key string. May be NULL.\n *\n * Return: The usable hashmap index.\n */\nint hashmap_hash_index(int size, char *key)\n{\n if (!key)\n return 0;\n\n int hash = 0x811c9dc5;\n\n for (; *key; key++) {\n hash ^= *key;\n hash *= 0x01000193;\n }\n\n const int mask = hash >> 31;\n return ((hash ^ mask) - mask) & (size - 1);\n}\n\nint round_up_pow2(int v)\n{\n v--;\n v |= v >> 1;\n v |= v >> 2;\n v |= v >> 4;\n v |= v >> 8;\n v |= v >> 16;\n v++;\n return v;\n}\n\n/* Create a hashmap on heap. Notice that provided size will always be rounded\n * up to nearest power of 2.\n * @size: The initial bucket size of hashmap. Must not be 0 or\n * negative.\n *\n * Return: The pointer of created hashmap.\n */\nhashmap_t *hashmap_create(int cap)\n{\n hashmap_t *map = malloc(sizeof(hashmap_t));\n\n if (!map) {\n printf(\"Failed to allocate hashmap_t with capacity %d\\n\", cap);\n return NULL;\n }\n\n map->size = 0;\n map->cap = round_up_pow2(cap);\n map->table = calloc(map->cap, sizeof(hashmap_node_t));\n\n if (!map->table) {\n printf(\"Failed to allocate table in hashmap_t\\n\");\n free(map);\n return NULL;\n }\n\n return map;\n}\n\n\nvoid hashmap_rehash(hashmap_t *map)\n{\n if (!map)\n return;\n\n int old_cap = map->cap;\n hashmap_node_t *old_table = map->table;\n\n map->cap <<= 1;\n map->table = calloc(map->cap, sizeof(hashmap_node_t));\n\n if (!map->table) {\n printf(\"Failed to allocate new table in hashmap_t\\n\");\n map->table = old_table;\n map->cap = old_cap;\n return;\n }\n\n map->size = 0;\n\n for (int i = 0; i < old_cap; i++) {\n if (old_table[i].occupied) {\n char *key = old_table[i].key;\n void *val = old_table[i].val;\n\n int index = hashmap_hash_index(map->cap, key);\n int start = index;\n\n while (map->table[index].occupied) {\n index = (index + 1) & (map->cap - 1);\n if (index == start) {\n printf(\"Error: New table is full during rehash\\n\");\n abort();\n }\n }\n\n map->table[index].key = key;\n map->table[index].val = val;\n map->table[index].occupied = true;\n map->size++;\n }\n }\n free(old_table);\n}\n\n/* Put a key-value pair into given hashmap.\n * If key already contains a value, then replace it with new value, the old\n * value will be freed.\n * @map: The hashmap to be put into. Must not be NULL.\n * @key: The key string. May be NULL.\n * @val: The value pointer. May be NULL. This value's lifetime is held by\n * hashmap.\n */\nvoid hashmap_put(hashmap_t *map, char *key, void *val)\n{\n if (!map)\n return;\n\n /* Check if size of map exceeds load factor 50% (or 1/2 of capacity) */\n if ((map->cap >> 1) <= map->size)\n hashmap_rehash(map);\n\n int index = hashmap_hash_index(map->cap, key);\n int start = index;\n\n while (map->table[index].occupied) {\n if (!strcmp(map->table[index].key, key)) {\n map->table[index].val = val;\n return;\n }\n\n index = (index + 1) & (map->cap - 1);\n if (index == start) {\n printf(\"Error: Hashmap is full\\n\");\n abort();\n }\n }\n\n map->table[index].key = arena_strdup(HASHMAP_ARENA, key);\n map->table[index].val = val;\n map->table[index].occupied = true;\n map->size++;\n}\n\n/* Get key-value pair node from hashmap from given key.\n * @map: The hashmap to be looked up. Must no be NULL.\n * @key: The key string. May be NULL.\n *\n * Return: The look up result, if the key-value pair entry exists, then returns\n * address of itself, NULL otherwise.\n */\nhashmap_node_t *hashmap_get_node(hashmap_t *map, char *key)\n{\n if (!map)\n return NULL;\n\n int index = hashmap_hash_index(map->cap, key);\n int start = index;\n\n while (map->table[index].occupied) {\n if (!strcmp(map->table[index].key, key))\n return &map->table[index];\n\n index = (index + 1) & (map->cap - 1);\n if (index == start)\n return NULL;\n }\n\n return NULL;\n}\n\n/* Get value from hashmap from given key.\n * @map: The hashmap to be looked up. Must no be NULL.\n * @key: The key string. May be NULL.\n *\n * Return: The look up result, if the key-value pair entry exists, then returns\n * its value's address, NULL otherwise.\n */\nvoid *hashmap_get(hashmap_t *map, char *key)\n{\n hashmap_node_t *node = hashmap_get_node(map, key);\n return node ? node->val : NULL;\n}\n\n/* Check if the key-value pair entry exists from given key.\n * @map: The hashmap to be looked up. Must no be NULL.\n * @key: The key string. May be NULL.\n *\n * Return: The look up result, if the key-value pair entry exists, then returns\n * true, false otherwise.\n */\nbool hashmap_contains(hashmap_t *map, char *key)\n{\n return hashmap_get_node(map, key);\n}\n\n/* Free the hashmap, this also frees key-value pair entry's value.\n * @map: The hashmap to be looked up. Must no be NULL.\n */\nvoid hashmap_free(hashmap_t *map)\n{\n if (!map)\n return;\n\n free(map->table);\n free(map);\n}\n\n/* Find the type by the given name.\n * @type_name: The name to be searched.\n * @flag:\n * 0 - Search in all type names.\n * 1 - Search in all names, excluding the tags of structure.\n * 2 - Only search in tags.\n *\n * Return: The pointer to the type, or NULL if not found.\n */\ntype_t *find_type(char *type_name, int flag)\n{\n for (int i = 0; i < types_idx; i++) {\n if (TYPES[i].base_type == TYPE_struct ||\n TYPES[i].base_type == TYPE_union) {\n if (flag == 1)\n continue;\n if (!strcmp(TYPES[i].type_name, type_name))\n return &TYPES[i];\n } else {\n if (flag == 2)\n continue;\n if (!strcmp(TYPES[i].type_name, type_name)) {\n /* If it is a forwardly declared alias of a structure, return\n * the base structure type.\n */\n if (TYPES[i].base_type == TYPE_typedef && TYPES[i].size == 0)\n return TYPES[i].base_struct;\n return &TYPES[i];\n }\n }\n }\n return NULL;\n}\n\nph2_ir_t *add_existed_ph2_ir(ph2_ir_t *ph2_ir)\n{\n PH2_IR_FLATTEN[ph2_ir_idx++] = ph2_ir;\n return ph2_ir;\n}\n\nph2_ir_t *add_ph2_ir(opcode_t op)\n{\n ph2_ir_t *ph2_ir = arena_alloc(BB_ARENA, sizeof(ph2_ir_t));\n ph2_ir->op = op;\n /* Initialize all fields explicitly */\n ph2_ir->next = NULL;\n ph2_ir->is_branch_detached = 0;\n ph2_ir->src0 = 0;\n ph2_ir->src1 = 0;\n ph2_ir->dest = 0;\n ph2_ir->func_name[0] = '\\0';\n ph2_ir->next_bb = NULL;\n ph2_ir->then_bb = NULL;\n ph2_ir->else_bb = NULL;\n ph2_ir->ofs_based_on_stack_top = false;\n return add_existed_ph2_ir(ph2_ir);\n}\n\nvoid set_var_liveout(var_t *var, int end)\n{\n if (var->liveness >= end)\n return;\n var->liveness = end;\n}\n\nblock_t *add_block(block_t *parent, func_t *func)\n{\n block_t *blk = arena_alloc(BLOCK_ARENA, sizeof(block_t));\n\n /* Initialize all fields explicitly */\n blk->locals.size = 0;\n blk->locals.capacity = 16;\n blk->locals.elements =\n arena_alloc(BLOCK_ARENA, blk->locals.capacity * sizeof(var_t *));\n blk->parent = parent;\n blk->func = func;\n blk->next = NULL;\n return blk;\n}\n\n/* String pool global */\nstring_pool_t *string_pool;\nstring_literal_pool_t *string_literal_pool;\n\n/* Safe string interning that works with self-hosting */\nchar *intern_string(char *str)\n{\n char *existing;\n char *interned;\n int len;\n\n /* Safety: return original if NULL */\n if (!str)\n return NULL;\n\n /* Safety: can't intern before initialization */\n if (!GENERAL_ARENA || !string_pool)\n return str;\n\n /* Check if already interned */\n existing = hashmap_get(string_pool->strings, str);\n if (existing)\n return existing;\n\n /* Allocate and store new string */\n len = strlen(str) + 1;\n interned = arena_alloc(GENERAL_ARENA, len);\n strcpy(interned, str);\n\n hashmap_put(string_pool->strings, interned, interned);\n\n return interned;\n}\n\nint hex_digit_value(char c)\n{\n if (c >= '0' && c <= '9')\n return c - '0';\n if (c >= 'a' && c <= 'f')\n return c - 'a' + 10;\n if (c >= 'A' && c <= 'F')\n return c - 'A' + 10;\n return -1;\n}\n\nint unescape_string(const char *input, char *output, int output_size)\n{\n if (!input || !output || output_size == 0)\n return -1;\n\n int i = 0, j = 0;\n\n while (input[i] != '\\0' && j < output_size - 1) {\n if (input[i] != '\\\\') {\n /* Regular characters */\n output[j++] = input[i++];\n continue;\n }\n\n i++;\n\n switch (input[i]) {\n case 'a':\n output[j++] = '\\a';\n i++;\n break;\n case 'b':\n output[j++] = '\\b';\n i++;\n break;\n case 'f':\n output[j++] = '\\f';\n i++;\n break;\n case 'e':\n output[j++] = 27;\n i++;\n break;\n case 'n':\n output[j++] = '\\n';\n i++;\n break;\n case 'r':\n output[j++] = '\\r';\n i++;\n break;\n case 't':\n output[j++] = '\\t';\n i++;\n break;\n case 'v':\n output[j++] = '\\v';\n i++;\n break;\n case '\\\\':\n output[j++] = '\\\\';\n i++;\n break;\n case '\\'':\n output[j++] = '\\'';\n i++;\n break;\n case '\"':\n output[j++] = '\"';\n i++;\n break;\n case '?':\n output[j++] = '\\?';\n i++;\n break;\n case 'x': {\n /* Hexadecimal escape sequence: \\xhh */\n i++; /* Skips 'x' */\n\n if (!isxdigit(input[i]))\n return -1;\n\n int value = 0;\n int count = 0;\n\n while (isxdigit(input[i]) && count < 2) {\n value = (value << 4) + hex_digit_value(input[i]);\n i++;\n count++;\n }\n\n output[j++] = (char) value;\n break;\n }\n case '0':\n case '1':\n case '2':\n case '3':\n case '4':\n case '5':\n case '6':\n case '7': {\n /* Octal escape sequence: \\ooo (up to 3 digits) */\n int value = 0;\n int digit_count = 0;\n\n while (input[i] >= '0' && input[i] <= '7' && digit_count < 3) {\n value = value * 8 + (input[i] - '0');\n i++;\n digit_count++;\n }\n\n output[j++] = (char) value;\n break;\n }\n default:\n /* Unknown escape sequence - treat as literal character */\n output[j++] = input[i++];\n break;\n }\n }\n\n output[j] = '\\0';\n\n /* Check if we ran out of output space */\n if (input[i] != '\\0')\n return -1;\n\n return j;\n}\n\nint parse_numeric_constant(char *buffer)\n{\n int i = 0;\n int value = 0;\n while (buffer[i]) {\n if (i == 1 && (buffer[i] | 32) == 'x') { /* hexadecimal */\n value = 0;\n i = 2;\n while (buffer[i]) {\n char c = buffer[i++];\n value <<= 4;\n if (isdigit(c))\n value += c - '0';\n c |= 32; /* convert to lower case */\n if (c >= 'a' && c <= 'f')\n value += (c - 'a') + 10;\n }\n return value;\n }\n if (i == 1 && (buffer[i] | 32) == 'b') { /* binary */\n value = 0;\n i = 2;\n while (buffer[i]) {\n char c = buffer[i++];\n value <<= 1;\n value += (c == '1');\n }\n return value;\n }\n if (buffer[0] == '0') /* octal */\n value = value * 8 + buffer[i++] - '0';\n else\n value = value * 10 + buffer[i++] - '0';\n }\n return value;\n}\n\ntype_t *add_type(void)\n{\n if (types_idx >= MAX_TYPES) {\n printf(\"Error: Maximum number of types (%d) exceeded\\n\", MAX_TYPES);\n abort();\n }\n return &TYPES[types_idx++];\n}\n\ntype_t *add_named_type(char *name)\n{\n type_t *type = add_type();\n /* Use interned string for type name */\n strcpy(type->type_name, intern_string(name));\n return type;\n}\n\nvoid add_constant(char alias[], int value)\n{\n constant_t *constant = arena_alloc_constant();\n if (!constant) {\n printf(\"Failed to allocate constant_t\\n\");\n return;\n }\n\n /* Use interned string for constant name */\n strcpy(constant->alias, intern_string(alias));\n constant->value = value;\n hashmap_put(CONSTANTS_MAP, alias, constant);\n}\n\nconstant_t *find_constant(char alias[])\n{\n return hashmap_get(CONSTANTS_MAP, alias);\n}\n\nvar_t *find_member(char token[], type_t *type)\n{\n /* If it is a forwardly declared alias of a structure, switch to the base\n * structure type.\n */\n if (type->size == 0)\n type = type->base_struct;\n\n for (int i = 0; i < type->num_fields; i++) {\n if (!strcmp(type->fields[i].var_name, token))\n return &type->fields[i];\n }\n return NULL;\n}\n\nvar_t *find_local_var(char *token, block_t *block)\n{\n func_t *func = block->func;\n\n for (; block; block = block->parent) {\n var_list_t *var_list = &block->locals;\n for (int i = 0; i < var_list->size; i++) {\n if (!strcmp(var_list->elements[i]->var_name, token))\n return var_list->elements[i];\n }\n }\n\n if (func) {\n for (int i = 0; i < func->num_params; i++) {\n if (!strcmp(func->param_defs[i].var_name, token))\n return &func->param_defs[i];\n }\n }\n return NULL;\n}\n\nvar_t *find_global_var(char *token)\n{\n var_list_t *var_list = &GLOBAL_BLOCK->locals;\n\n for (int i = 0; i < var_list->size; i++) {\n if (!strcmp(var_list->elements[i]->var_name, token))\n return var_list->elements[i];\n }\n return NULL;\n}\n\nvar_t *find_var(char *token, block_t *parent)\n{\n var_t *var = find_local_var(token, parent);\n if (!var)\n var = find_global_var(token);\n return var;\n}\n\nint size_var(var_t *var)\n{\n int size;\n if (var->ptr_level > 0 || var->is_func) {\n size = 4;\n } else {\n type_t *type = var->type;\n if (type->size == 0)\n size = type->base_struct->size;\n else\n size = type->size;\n }\n if (var->array_size > 0)\n size = size * var->array_size;\n return size;\n}\n\n/* Create a new function and adds it to the function lookup table and function\n * list if it does not already exist, or returns the existing instance if the\n * function already exists.\n *\n * Synthesized functions (e.g., compiler-generated functions like '__syscall')\n * are excluded from SSA analysis.\n *\n * @func_name: The name of the function. May be NULL.\n * @synthesize: Indicates whether the function is synthesized by the compiler.\n * Synthesized functions will not be analyzed by the SSA unit.\n *\n * Return: A pointer to the function.\n */\nfunc_t *add_func(char *func_name, bool synthesize)\n{\n func_t *func = hashmap_get(FUNC_MAP, func_name);\n\n if (func)\n return func;\n\n func = arena_alloc_func();\n hashmap_put(FUNC_MAP, func_name, func);\n /* Use interned string for function name */\n strcpy(func->return_def.var_name, intern_string(func_name));\n /* Prepare space for function arguments.\n *\n * For Arm architecture, the first four arguments (arg1 ~ arg4) are\n * passed to r0 ~ r3, and any additional arguments (arg5+) are passed\n * to the stack.\n *\n * +-------------+\n * | local vars |\n * +-------------+\n * | ... |\n * +-------------+ <-- sp + 16\n * | arg 8 |\n * +-------------+ <-- sp + 12\n * | arg 7 |\n * +-------------+ <-- sp + 8\n * | arg 6 |\n * +-------------+ <-- sp + 4\n * | arg 5 |\n * +-------------+ <-- sp\n *\n * If the target architecture is RISC-V, arg1 ~ arg8 are passed to\n * registers and arg9+ are passed to the stack.\n *\n * We allocate (MAX_PARAMS - MAX_ARGS_IN_REG) * 4 bytes for all functions\n * so that each of them can use the space to pass extra arguments.\n */\n func->stack_size = (MAX_PARAMS - MAX_ARGS_IN_REG) * 4;\n\n if (synthesize)\n return func;\n\n if (!FUNC_LIST.head) {\n FUNC_LIST.head = func;\n FUNC_LIST.tail = func;\n } else {\n FUNC_LIST.tail->next = func;\n FUNC_LIST.tail = func;\n }\n\n return func;\n}\n\n/* Find the function in function map.\n * @func_name: The name of the function. May be NULL.\n *\n * Return: A pointer to the function if exists, NULL otherwise.\n */\nfunc_t *find_func(char *func_name)\n{\n return hashmap_get(FUNC_MAP, func_name);\n}\n\n/* Create a basic block and set the scope of variables to 'parent' block */\nbasic_block_t *bb_create(block_t *parent)\n{\n /* Use arena_calloc for basic_block_t as it has many arrays that need\n * zeroing (live_gen, live_kill, live_in, live_out, DF, RDF, dom_next, etc.)\n * This is simpler and safer than manually initializing everything.\n */\n basic_block_t *bb = arena_calloc(BB_ARENA, 1, sizeof(basic_block_t));\n\n /* Initialize non-zero fields */\n bb->scope = parent;\n bb->belong_to = parent->func;\n\n /* Initialize prev array with NEXT type */\n for (int i = 0; i < MAX_BB_PRED; i++)\n bb->prev[i].type = NEXT;\n\n if (dump_ir)\n snprintf(bb->bb_label_name, MAX_VAR_LEN, \".label.%d\", bb_label_idx++);\n\n return bb;\n}\n\n/* The pred-succ pair must have only one connection */\nvoid bb_connect(basic_block_t *pred,\n basic_block_t *succ,\n bb_connection_type_t type)\n{\n if (!pred)\n abort();\n if (!succ)\n abort();\n\n int i = 0;\n while (succ->prev[i].bb)\n i++;\n\n if (i > MAX_BB_PRED - 1) {\n printf(\"Error: too many predecessors\\n\");\n abort();\n }\n\n succ->prev[i].bb = pred;\n succ->prev[i].type = type;\n\n switch (type) {\n case NEXT:\n pred->next = succ;\n break;\n case THEN:\n pred->then_ = succ;\n break;\n case ELSE:\n pred->else_ = succ;\n break;\n default:\n abort();\n }\n}\n\n/* The pred-succ pair must have only one connection */\nvoid bb_disconnect(basic_block_t *pred, basic_block_t *succ)\n{\n for (int i = 0; i < MAX_BB_PRED; i++) {\n if (succ->prev[i].bb == pred) {\n switch (succ->prev[i].type) {\n case NEXT:\n pred->next = NULL;\n break;\n case THEN:\n pred->then_ = NULL;\n break;\n case ELSE:\n pred->else_ = NULL;\n break;\n default:\n abort();\n }\n\n succ->prev[i].bb = NULL;\n break;\n }\n }\n}\n\n/* The symbol is an argument of function or the variable in declaration */\nvoid add_symbol(basic_block_t *bb, var_t *var)\n{\n if (!bb)\n return;\n symbol_t *sym;\n for (sym = bb->symbol_list.head; sym; sym = sym->next) {\n if (sym->var == var)\n return;\n }\n\n sym = arena_alloc_symbol();\n sym->var = var;\n\n if (!bb->symbol_list.head) {\n sym->index = 0;\n bb->symbol_list.head = sym;\n bb->symbol_list.tail = sym;\n } else {\n sym->index = bb->symbol_list.tail->index + 1;\n bb->symbol_list.tail->next = sym;\n bb->symbol_list.tail = sym;\n }\n}\n\nvoid add_insn(block_t *block,\n basic_block_t *bb,\n opcode_t op,\n var_t *rd,\n var_t *rs1,\n var_t *rs2,\n int sz,\n char *str)\n{\n if (!bb)\n return;\n\n bb->scope = block;\n\n insn_t *n = arena_alloc(INSN_ARENA, sizeof(insn_t));\n n->next = NULL;\n n->prev = NULL;\n n->opcode = op;\n n->rd = rd;\n n->rs1 = rs1;\n n->rs2 = rs2;\n n->sz = sz;\n n->useful = false;\n n->belong_to = bb;\n n->phi_ops = NULL;\n n->idx = 0;\n\n if (str)\n strcpy(n->str, intern_string(str));\n else\n n->str[0] = '\\0';\n\n /* Mark variables as address-taken to prevent incorrect constant\n * optimization\n */\n if ((op == OP_address_of || op == OP_global_address_of) && rs1) {\n rs1->address_taken = true;\n rs1->is_const = false; /* disable constant optimization */\n }\n\n if (!bb->insn_list.head)\n bb->insn_list.head = n;\n else\n bb->insn_list.tail->next = n;\n\n n->prev = bb->insn_list.tail;\n bb->insn_list.tail = n;\n}\n\nstrbuf_t *strbuf_create(int init_capacity)\n{\n strbuf_t *array = malloc(sizeof(strbuf_t));\n if (!array)\n return NULL;\n\n array->size = 0;\n array->capacity = init_capacity;\n array->elements = malloc(array->capacity * sizeof(char));\n if (!array->elements) {\n free(array);\n return NULL;\n }\n\n return array;\n}\n\nbool strbuf_extend(strbuf_t *src, int len)\n{\n int new_size = src->size + len;\n\n if (new_size < src->capacity)\n return true;\n\n if (new_size > (src->capacity << 1))\n src->capacity = new_size;\n else\n src->capacity <<= 1;\n\n char *new_arr = malloc(src->capacity * sizeof(char));\n\n if (!new_arr)\n return false;\n\n memcpy(new_arr, src->elements, src->size * sizeof(char));\n\n free(src->elements);\n src->elements = new_arr;\n\n return true;\n}\n\nbool strbuf_putc(strbuf_t *src, char value)\n{\n if (!strbuf_extend(src, 1))\n return false;\n\n src->elements[src->size] = value;\n src->size++;\n\n return true;\n}\n\nbool strbuf_puts(strbuf_t *src, const char *value)\n{\n int len = strlen(value);\n\n if (!strbuf_extend(src, len))\n return false;\n\n strncpy(src->elements + src->size, value, len);\n src->size += len;\n\n return true;\n}\n\nvoid strbuf_free(strbuf_t *src)\n{\n if (!src)\n return;\n\n free(src->elements);\n free(src);\n}\n\n/* This routine is required because the global variable initializations are\n * not supported now.\n */\nvoid global_init(void)\n{\n FUNC_LIST.head = NULL;\n FUNC_LIST.tail = NULL;\n memset(REGS, 0, sizeof(regfile_t) * REG_CNT);\n\n /* Initialize arenas first so we can use them for allocation */\n BLOCK_ARENA = arena_init(DEFAULT_ARENA_SIZE); /* Variables/blocks */\n INSN_ARENA = arena_init(LARGE_ARENA_SIZE); /* Instructions - high usage */\n BB_ARENA = arena_init(SMALL_ARENA_SIZE); /* Basic blocks - low usage */\n HASHMAP_ARENA = arena_init(DEFAULT_ARENA_SIZE); /* Hash nodes */\n TOKEN_ARENA = arena_init(LARGE_ARENA_SIZE);\n GENERAL_ARENA =\n arena_init(DEFAULT_ARENA_SIZE); /* For TYPES and PH2_IR_FLATTEN */\n\n /* Use arena allocation for better memory management */\n TYPES = arena_alloc(GENERAL_ARENA, MAX_TYPES * sizeof(type_t));\n PH2_IR_FLATTEN =\n arena_alloc(GENERAL_ARENA, MAX_IR_INSTR * sizeof(ph2_ir_t *));\n\n /* Initialize string pool for identifier deduplication */\n string_pool = arena_alloc(GENERAL_ARENA, sizeof(string_pool_t));\n string_pool->strings = hashmap_create(512);\n\n /* Initialize string literal pool for deduplicating string constants */\n string_literal_pool =\n arena_alloc(GENERAL_ARENA, sizeof(string_literal_pool_t));\n string_literal_pool->literals = hashmap_create(256);\n\n TOKEN_CACHE = hashmap_create(DEFAULT_SRC_FILE_COUNT);\n SRC_FILE_MAP = hashmap_create(DEFAULT_SRC_FILE_COUNT);\n FUNC_MAP = hashmap_create(DEFAULT_FUNCS_SIZE);\n CONSTANTS_MAP = hashmap_create(MAX_CONSTANTS);\n\n LIBC_SRC = strbuf_create(4096);\n elf_code = strbuf_create(MAX_CODE);\n elf_data = strbuf_create(MAX_DATA);\n elf_rodata = strbuf_create(MAX_DATA);\n elf_header = strbuf_create(MAX_HEADER);\n elf_program_header = strbuf_create(MAX_PROGRAM_HEADER);\n elf_symtab = strbuf_create(MAX_SYMTAB);\n elf_strtab = strbuf_create(MAX_STRTAB);\n elf_bss_size = 0;\n elf_shstrtab = strbuf_create(MAX_SHSTR);\n elf_section_header = strbuf_create(MAX_SECTION_HEADER);\n dynamic_sections.elf_interp = strbuf_create(MAX_INTERP);\n dynamic_sections.elf_dynamic = strbuf_create(MAX_DYNAMIC);\n dynamic_sections.elf_dynsym = strbuf_create(MAX_DYNSYM);\n dynamic_sections.elf_dynstr = strbuf_create(MAX_DYNSTR);\n dynamic_sections.elf_relplt = strbuf_create(MAX_RELPLT);\n dynamic_sections.elf_plt = strbuf_create(MAX_PLT);\n dynamic_sections.elf_got = strbuf_create(MAX_GOTPLT);\n}\n\n/* Forward declaration for lexer cleanup */\nvoid lexer_cleanup(void);\n\n/* Free empty trailing blocks from an arena safely.\n * This only frees blocks that come after the last used block,\n * ensuring no pointers are invalidated.\n *\n * @arena: The arena to compact.\n * Return: Bytes freed.\n */\nint arena_free_trailing_blocks(arena_t *arena)\n{\n if (!arena || !arena->head)\n return 0;\n\n /* Find the last block with actual allocations */\n arena_block_t *last_used = NULL;\n arena_block_t *block;\n\n for (block = arena->head; block; block = block->next) {\n if (block->offset > 0)\n last_used = block;\n }\n\n /* If no blocks are used, keep just the head */\n if (!last_used)\n last_used = arena->head;\n\n /* Free all blocks after last_used */\n int freed = 0;\n if (last_used->next) {\n block = last_used->next;\n last_used->next = NULL;\n\n while (block) {\n arena_block_t *next = block->next;\n freed += block->capacity;\n arena->total_bytes -= block->capacity;\n arena_block_free(block);\n block = next;\n }\n }\n\n return freed;\n}\n\n/* Compact all arenas to reduce memory usage after compilation phases.\n * This safely frees only trailing empty blocks without invalidating pointers.\n *\n * Return: Total bytes freed across all arenas.\n */\nint compact_all_arenas(void)\n{\n int total_saved = 0;\n\n /* Free trailing blocks from each arena */\n total_saved += arena_free_trailing_blocks(BLOCK_ARENA);\n total_saved += arena_free_trailing_blocks(INSN_ARENA);\n total_saved += arena_free_trailing_blocks(BB_ARENA);\n total_saved += arena_free_trailing_blocks(HASHMAP_ARENA);\n total_saved += arena_free_trailing_blocks(GENERAL_ARENA);\n\n return total_saved;\n}\n\n/* Compact specific arenas based on compilation phase.\n * Different phases have different memory usage patterns.\n *\n * @phase_mask: Bitmask using COMPACT_ARENA_* defines\n * to indicate which arenas to compact.\n *\n * Return: Total bytes freed.\n */\nint compact_arenas_selective(int phase_mask)\n{\n int total_saved = 0;\n\n if (phase_mask & COMPACT_ARENA_BLOCK)\n total_saved += arena_free_trailing_blocks(BLOCK_ARENA);\n\n if (phase_mask & COMPACT_ARENA_INSN)\n total_saved += arena_free_trailing_blocks(INSN_ARENA);\n\n if (phase_mask & COMPACT_ARENA_BB)\n total_saved += arena_free_trailing_blocks(BB_ARENA);\n\n if (phase_mask & COMPACT_ARENA_HASHMAP)\n total_saved += arena_free_trailing_blocks(HASHMAP_ARENA);\n\n if (phase_mask & COMPACT_ARENA_GENERAL)\n total_saved += arena_free_trailing_blocks(GENERAL_ARENA);\n\n return total_saved;\n}\n\nvoid global_release(void)\n{\n /* Cleanup lexer hashmaps */\n lexer_cleanup();\n\n /* Free string interning hashmaps */\n if (string_pool && string_pool->strings)\n hashmap_free(string_pool->strings);\n if (string_literal_pool && string_literal_pool->literals)\n hashmap_free(string_literal_pool->literals);\n\n arena_free(BLOCK_ARENA);\n arena_free(INSN_ARENA);\n arena_free(BB_ARENA);\n arena_free(HASHMAP_ARENA);\n arena_free(TOKEN_ARENA);\n arena_free(GENERAL_ARENA); /* free TYPES and PH2_IR_FLATTEN */\n hashmap_free(TOKEN_CACHE);\n hashmap_free(SRC_FILE_MAP);\n hashmap_free(FUNC_MAP);\n hashmap_free(INCLUSION_MAP);\n hashmap_free(CONSTANTS_MAP);\n\n strbuf_free(LIBC_SRC);\n strbuf_free(elf_code);\n strbuf_free(elf_data);\n strbuf_free(elf_rodata);\n strbuf_free(elf_header);\n strbuf_free(elf_program_header);\n strbuf_free(elf_symtab);\n strbuf_free(elf_strtab);\n strbuf_free(elf_shstrtab);\n strbuf_free(elf_section_header);\n strbuf_free(dynamic_sections.elf_interp);\n strbuf_free(dynamic_sections.elf_dynamic);\n strbuf_free(dynamic_sections.elf_dynsym);\n strbuf_free(dynamic_sections.elf_dynstr);\n strbuf_free(dynamic_sections.elf_relplt);\n strbuf_free(dynamic_sections.elf_plt);\n strbuf_free(dynamic_sections.elf_got);\n}\n\n/* Reports an error without specifying a position */\nvoid fatal(char *msg)\n{\n printf(\"[Error]: %s\\n\", msg);\n abort();\n}\n\n/* Reports error and prints occurred position context,\n * if the given location is NULL or source file is missing,\n * then fallbacks to fatal(char *).\n */\nvoid error_at(char *msg, source_location_t *loc)\n{\n int offset, start_idx, i = 0, len, pos;\n char diagnostic[MAX_LINE_LEN];\n\n if (!loc)\n fatal(msg);\n\n len = loc->len;\n pos = loc->pos;\n\n strbuf_t *src = hashmap_get(SRC_FILE_MAP, loc->filename);\n\n if (!src)\n fatal(msg);\n\n if (len < 1)\n len = 1;\n\n printf(\"%s:%d:%d: [Error]: %s\\n\", loc->filename, loc->line, loc->column,\n msg);\n printf(\"%6d | \", loc->line);\n\n /* Finds line's start position */\n for (offset = pos; offset >= 0 && src->elements[offset] != '\\n'; offset--)\n ;\n\n start_idx = offset + 1;\n\n /* Copies whole line to diagnostic buffer */\n for (offset = start_idx;\n offset < src->capacity && src->elements[offset] != '\\n' &&\n src->elements[offset] != '\\0';\n offset++) {\n diagnostic[i++] = src->elements[offset];\n }\n diagnostic[i] = '\\0';\n\n printf(\"%s\\n\", diagnostic);\n printf(\"%6c | \", ' ');\n\n i = 0;\n for (offset = start_idx; offset < pos; offset++)\n diagnostic[i++] = ' ';\n diagnostic[i++] = '^';\n for (; len > 1; len--)\n diagnostic[i++] = '~';\n\n strcpy(diagnostic + i, \" Error occurs here\");\n printf(\"%s\\n\", diagnostic);\n abort();\n}\n\nvoid print_indent(int indent)\n{\n for (int i = 0; i < indent; i++)\n printf(\"\\t\");\n}\n\nvoid dump_bb_insn(func_t *func, basic_block_t *bb, bool *at_func_start)\n{\n if (!bb)\n return;\n var_t *rd, *rs1, *rs2;\n\n if (bb != func->bbs && bb->insn_list.head) {\n if (!at_func_start[0])\n printf(\"%s:\\n\", bb->bb_label_name);\n else\n at_func_start[0] = false;\n }\n\n for (insn_t *insn = bb->insn_list.head; insn; insn = insn->next) {\n rd = insn->rd;\n rs1 = insn->rs1;\n rs2 = insn->rs2;\n\n switch (insn->opcode) {\n case OP_unwound_phi:\n /* Ignored */\n continue;\n case OP_allocat:\n print_indent(1);\n printf(\"allocat %s\", rd->type->type_name);\n\n for (int i = 0; i < rd->ptr_level; i++)\n printf(\"*\");\n\n printf(\" %%%s\", rd->var_name);\n\n if (rd->array_size > 0)\n printf(\"[%d]\", rd->array_size);\n\n break;\n case OP_load_constant:\n print_indent(1);\n printf(\"const %%%s, %d\", rd->var_name, rd->init_val);\n break;\n case OP_load_data_address:\n print_indent(1);\n /* offset from .data section */\n printf(\"%%%s = .data (%d)\", rd->var_name, rd->init_val);\n break;\n case OP_load_rodata_address:\n print_indent(1);\n /* offset from .rodata section */\n printf(\"%%%s = .rodata (%d)\", rd->var_name, rd->init_val);\n break;\n case OP_address_of:\n print_indent(1);\n printf(\"%%%s = &(%%%s)\", rd->var_name, rs1->var_name);\n break;\n case OP_assign:\n print_indent(1);\n printf(\"%%%s = %%%s\", rd->var_name, rs1->var_name);\n break;\n case OP_branch:\n print_indent(1);\n printf(\"br %%%s, %s, %s\", rs1->var_name, bb->then_->bb_label_name,\n bb->else_->bb_label_name);\n break;\n case OP_jump:\n print_indent(1);\n printf(\"jmp %s\", bb->next->bb_label_name);\n break;\n case OP_label:\n print_indent(0);\n printf(\"%s:\", insn->str);\n break;\n case OP_push:\n print_indent(1);\n printf(\"push %%%s\", rs1->var_name);\n break;\n case OP_call:\n print_indent(1);\n printf(\"call @%s\", insn->str);\n break;\n case OP_func_ret:\n print_indent(1);\n printf(\"retval %%%s\", rd->var_name);\n break;\n case OP_return:\n print_indent(1);\n if (rs1)\n printf(\"ret %%%s\", rs1->var_name);\n else\n printf(\"ret\");\n break;\n case OP_read:\n print_indent(1);\n printf(\"%%%s = (%%%s), %d\", rd->var_name, rs1->var_name, insn->sz);\n break;\n case OP_write:\n print_indent(1);\n if (rs1->is_func)\n printf(\"(%%%s) = @%s\", rs1->var_name, rs2->var_name);\n else\n printf(\"(%%%s) = %%%s, %d\", rs1->var_name, rs2->var_name,\n insn->sz);\n break;\n case OP_indirect:\n print_indent(1);\n printf(\"indirect call @(%%%s)\", rs1->var_name);\n break;\n case OP_negate:\n print_indent(1);\n printf(\"neg %%%s, %%%s\", rd->var_name, rs1->var_name);\n break;\n case OP_add:\n print_indent(1);\n printf(\"%%%s = add %%%s, %%%s\", rd->var_name, rs1->var_name,\n rs2->var_name);\n break;\n case OP_sub:\n print_indent(1);\n printf(\"%%%s = sub %%%s, %%%s\", rd->var_name, rs1->var_name,\n rs2->var_name);\n break;\n case OP_mul:\n print_indent(1);\n printf(\"%%%s = mul %%%s, %%%s\", rd->var_name, rs1->var_name,\n rs2->var_name);\n break;\n case OP_div:\n print_indent(1);\n printf(\"%%%s = div %%%s, %%%s\", rd->var_name, rs1->var_name,\n rs2->var_name);\n break;\n case OP_mod:\n print_indent(1);\n printf(\"%%%s = mod %%%s, %%%s\", rd->var_name, rs1->var_name,\n rs2->var_name);\n break;\n case OP_eq:\n print_indent(1);\n printf(\"%%%s = eq %%%s, %%%s\", rd->var_name, rs1->var_name,\n rs2->var_name);\n break;\n case OP_neq:\n print_indent(1);\n printf(\"%%%s = neq %%%s, %%%s\", rd->var_name, rs1->var_name,\n rs2->var_name);\n break;\n case OP_gt:\n print_indent(1);\n printf(\"%%%s = gt %%%s, %%%s\", rd->var_name, rs1->var_name,\n rs2->var_name);\n break;\n case OP_lt:\n print_indent(1);\n printf(\"%%%s = lt %%%s, %%%s\", rd->var_name, rs1->var_name,\n rs2->var_name);\n break;\n case OP_geq:\n print_indent(1);\n printf(\"%%%s = geq %%%s, %%%s\", rd->var_name, rs1->var_name,\n rs2->var_name);\n break;\n case OP_leq:\n print_indent(1);\n printf(\"%%%s = leq %%%s, %%%s\", rd->var_name, rs1->var_name,\n rs2->var_name);\n break;\n case OP_bit_and:\n print_indent(1);\n printf(\"%%%s = and %%%s, %%%s\", rd->var_name, rs1->var_name,\n rs2->var_name);\n break;\n case OP_bit_or:\n print_indent(1);\n printf(\"%%%s = or %%%s, %%%s\", rd->var_name, rs1->var_name,\n rs2->var_name);\n break;\n case OP_bit_not:\n print_indent(1);\n printf(\"%%%s = not %%%s\", rd->var_name, rs1->var_name);\n break;\n case OP_bit_xor:\n print_indent(1);\n printf(\"%%%s = xor %%%s, %%%s\", rd->var_name, rs1->var_name,\n rs2->var_name);\n break;\n case OP_log_and:\n print_indent(1);\n printf(\"%%%s = and %%%s, %%%s\", rd->var_name, rs1->var_name,\n rs2->var_name);\n break;\n case OP_log_or:\n print_indent(1);\n printf(\"%%%s = or %%%s, %%%s\", rd->var_name, rs1->var_name,\n rs2->var_name);\n break;\n case OP_log_not:\n print_indent(1);\n printf(\"%%%s = not %%%s\", rd->var_name, rs1->var_name);\n break;\n case OP_rshift:\n print_indent(1);\n printf(\"%%%s = rshift %%%s, %%%s\", rd->var_name, rs1->var_name,\n rs2->var_name);\n break;\n case OP_lshift:\n print_indent(1);\n printf(\"%%%s = lshift %%%s, %%%s\", rd->var_name, rs1->var_name,\n rs2->var_name);\n break;\n case OP_trunc:\n print_indent(1);\n printf(\"%%%s = trunc %%%s, %d\", rd->var_name, rs1->var_name,\n insn->sz);\n break;\n case OP_sign_ext:\n print_indent(1);\n printf(\"%%%s = sign_ext %%%s, %d\", rd->var_name, rs1->var_name,\n insn->sz);\n break;\n case OP_cast:\n print_indent(1);\n printf(\"%%%s = cast %%%s\", rd->var_name, rs1->var_name);\n break;\n default:\n printf(\"\", insn->opcode);\n break;\n }\n\n printf(\"\\n\");\n }\n}\n\nvoid dump_bb_insn_by_dom(func_t *func, basic_block_t *bb, bool *at_func_start)\n{\n dump_bb_insn(func, bb, at_func_start);\n for (int i = 0; i < MAX_BB_DOM_SUCC; i++) {\n if (!bb || !bb->dom_next[i])\n break;\n dump_bb_insn_by_dom(func, bb->dom_next[i], at_func_start);\n }\n}\n\nvoid dump_insn(void)\n{\n printf(\"====\\n\");\n\n for (func_t *func = FUNC_LIST.head; func; func = func->next) {\n /* Skip function declarations without bodies */\n if (!func->bbs)\n continue;\n\n bool at_func_start = true;\n\n printf(\"def %s\", func->return_def.type->type_name);\n\n for (int i = 0; i < func->return_def.ptr_level; i++)\n printf(\"*\");\n printf(\" @%s(\", func->return_def.var_name);\n\n for (int i = 0; i < func->num_params; i++) {\n if (i != 0)\n printf(\", \");\n printf(\"%s\", func->param_defs[i].type->type_name);\n\n for (int k = 0; k < func->param_defs[i].ptr_level; k++)\n printf(\"*\");\n printf(\" %%%s\", func->param_defs[i].var_name);\n }\n printf(\") {\\n\");\n\n dump_bb_insn_by_dom(func, func->bbs, &at_func_start);\n\n /* Handle implicit return */\n for (int i = 0; i < MAX_BB_PRED; i++) {\n if (!func->exit)\n break;\n basic_block_t *bb = func->exit->prev[i].bb;\n if (!bb)\n continue;\n\n if (func->return_def.type != TY_void)\n continue;\n\n if (bb->insn_list.tail)\n if (bb->insn_list.tail->opcode == OP_return)\n continue;\n\n print_indent(1);\n printf(\"ret\\n\");\n }\n\n printf(\"}\\n\");\n }\n\n printf(\"====\\n\");\n}\n" }, { "path": "src/lexer.c", "content": "/*\n * shecc - Self-Hosting and Educational C Compiler.\n *\n * shecc is freely redistributable under the BSD 2 clause license. See the\n * file \"LICENSE\" for information on usage and redistribution of this file.\n */\n#include \n#include \n\n#include \"defs.h\"\n#include \"globals.c\"\n\n/* Hash table constants */\n#define NUM_DIRECTIVES 11\n#define NUM_KEYWORDS 18\n\n/* Token mapping structure for elegant initialization */\ntypedef struct {\n char *name;\n token_kind_t token;\n} token_mapping_t;\n\n/* Preprocessor directive hash table using existing shecc hashmap */\nhashmap_t *DIRECTIVE_MAP = NULL;\n/* C keywords hash table */\nhashmap_t *KEYWORD_MAP = NULL;\n/* Token arrays for cleanup */\ntoken_kind_t *directive_tokens_storage = NULL;\ntoken_kind_t *keyword_tokens_storage = NULL;\n\nvoid lex_init_directives()\n{\n if (DIRECTIVE_MAP)\n return;\n\n DIRECTIVE_MAP = hashmap_create(16); /* Small capacity for directives */\n\n /* Initialization using struct compound literals for elegance */\n directive_tokens_storage =\n arena_alloc(GENERAL_ARENA, NUM_DIRECTIVES * sizeof(token_kind_t));\n\n /* Use array compound literal for directive mappings */\n token_mapping_t directives[] = {\n {\"#define\", T_cppd_define}, {\"#elif\", T_cppd_elif},\n {\"#else\", T_cppd_else}, {\"#endif\", T_cppd_endif},\n {\"#error\", T_cppd_error}, {\"#if\", T_cppd_if},\n {\"#ifdef\", T_cppd_ifdef}, {\"#ifndef\", T_cppd_ifndef},\n {\"#include\", T_cppd_include}, {\"#pragma\", T_cppd_pragma},\n {\"#undef\", T_cppd_undef},\n };\n\n /* hashmap insertion */\n for (int i = 0; i < NUM_DIRECTIVES; i++) {\n directive_tokens_storage[i] = directives[i].token;\n hashmap_put(DIRECTIVE_MAP, directives[i].name,\n &directive_tokens_storage[i]);\n }\n}\n\nvoid lex_init_keywords()\n{\n if (KEYWORD_MAP)\n return;\n\n KEYWORD_MAP = hashmap_create(32); /* Capacity for keywords */\n\n /* Initialization using struct compound literals for elegance */\n keyword_tokens_storage =\n arena_alloc(GENERAL_ARENA, NUM_KEYWORDS * sizeof(token_kind_t));\n\n /* Use array compound literal for keyword mappings */\n token_mapping_t keywords[] = {\n {\"if\", T_if},\n {\"while\", T_while},\n {\"for\", T_for},\n {\"do\", T_do},\n {\"else\", T_else},\n {\"return\", T_return},\n {\"typedef\", T_typedef},\n {\"enum\", T_enum},\n {\"struct\", T_struct},\n {\"sizeof\", T_sizeof},\n {\"switch\", T_switch},\n {\"case\", T_case},\n {\"break\", T_break},\n {\"default\", T_default},\n {\"continue\", T_continue},\n {\"goto\", T_goto},\n {\"union\", T_union},\n {\"const\", T_const},\n };\n\n /* hashmap insertion */\n for (int i = 0; i < NUM_KEYWORDS; i++) {\n keyword_tokens_storage[i] = keywords[i].token;\n hashmap_put(KEYWORD_MAP, keywords[i].name, &keyword_tokens_storage[i]);\n }\n}\n\n/* Hash table lookup for preprocessor directives */\ntoken_kind_t lookup_directive(char *token)\n{\n if (!DIRECTIVE_MAP)\n lex_init_directives();\n\n token_kind_t *result = hashmap_get(DIRECTIVE_MAP, token);\n if (result)\n return *result;\n\n return T_identifier;\n}\n\n/* Hash table lookup for C keywords */\ntoken_kind_t lookup_keyword(char *token)\n{\n if (!KEYWORD_MAP)\n lex_init_keywords();\n\n token_kind_t *result = hashmap_get(KEYWORD_MAP, token);\n if (result)\n return *result;\n\n return T_identifier;\n}\n\n\n/* Cleanup function for lexer hashmaps */\nvoid lexer_cleanup()\n{\n if (DIRECTIVE_MAP) {\n hashmap_free(DIRECTIVE_MAP);\n DIRECTIVE_MAP = NULL;\n }\n\n if (KEYWORD_MAP) {\n hashmap_free(KEYWORD_MAP);\n KEYWORD_MAP = NULL;\n }\n\n /* Token storage arrays are allocated from GENERAL_ARENA and will be\n * automatically freed when the arena is freed in global_release().\n * No need to explicitly free them here.\n */\n directive_tokens_storage = NULL;\n keyword_tokens_storage = NULL;\n}\n\nchar peek_char(strbuf_t *buf, int offset)\n{\n if (buf->size + offset >= buf->capacity)\n return '\\0';\n return buf->elements[buf->size + offset];\n}\n\nchar read_char(strbuf_t *buf)\n{\n if (buf->size + 1 >= buf->capacity)\n return buf->elements[buf->capacity - 1];\n buf->size++;\n return buf->elements[buf->size];\n}\n\nstrbuf_t *read_file(char *filename)\n{\n char buffer[MAX_LINE_LEN];\n FILE *f = fopen(filename, \"rb\");\n strbuf_t *src;\n\n if (!f) {\n printf(\"filename: %s\\n\", filename);\n fatal(\"source file cannot be found.\");\n }\n\n fseek(f, 0, SEEK_END);\n int len = ftell(f);\n src = strbuf_create(len + 1);\n fseek(f, 0, SEEK_SET);\n\n while (fgets(buffer, MAX_LINE_LEN, f))\n strbuf_puts(src, buffer);\n\n fclose(f);\n src->elements[len] = '\\0';\n return src;\n}\n\nstrbuf_t *get_file_buf(char *filename)\n{\n strbuf_t *buf;\n\n if (!hashmap_contains(SRC_FILE_MAP, filename)) {\n buf = read_file(filename);\n hashmap_put(SRC_FILE_MAP, filename, buf);\n } else {\n buf = hashmap_get(SRC_FILE_MAP, filename);\n }\n\n return buf;\n}\n\ntoken_t *new_token(token_kind_t kind, source_location_t *loc, int len)\n{\n token_t *token = arena_calloc(TOKEN_ARENA, 1, sizeof(token_t));\n token->kind = kind;\n memcpy(&token->location, loc, sizeof(source_location_t));\n token->location.len = len;\n return token;\n}\n\ntoken_t *lex_token(strbuf_t *buf, source_location_t *loc)\n{\n token_t *token;\n char token_buffer[MAX_TOKEN_LEN], ch = peek_char(buf, 0);\n\n loc->pos = buf->size;\n\n if (ch == '#') {\n if (loc->column != 1)\n error_at(\"Directive must be on the start of line\", loc);\n\n int sz = 0;\n\n do {\n if (sz >= MAX_TOKEN_LEN - 1) {\n loc->len = sz;\n error_at(\"Token too long\", loc);\n }\n token_buffer[sz++] = ch;\n ch = read_char(buf);\n } while (isalnum(ch) || ch == '_');\n token_buffer[sz] = '\\0';\n\n token_kind_t directive_kind = lookup_directive(token_buffer);\n if (directive_kind == T_identifier) {\n loc->len = sz;\n error_at(\"Unsupported directive\", loc);\n }\n\n token = new_token(directive_kind, loc, sz);\n loc->column += sz;\n return token;\n }\n\n if (ch == '\\\\') {\n read_char(buf);\n token = new_token(T_backslash, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == '\\n') {\n read_char(buf);\n token = new_token(T_newline, loc, 1);\n loc->line++;\n loc->column = 1;\n return token;\n }\n\n if (ch == '/') {\n ch = read_char(buf);\n\n if (ch == '*') {\n /* C-style comment */\n int pos = buf->size;\n do {\n /* advance one char */\n pos++;\n loc->column++;\n ch = buf->elements[pos];\n if (ch == '*') {\n /* look ahead */\n pos++;\n loc->column++;\n ch = buf->elements[pos];\n if (ch == '/') {\n /* consume closing '/', then commit and skip trailing\n * whitespaces\n */\n pos++;\n loc->column += 2;\n buf->size = pos;\n return lex_token(buf, loc);\n }\n }\n\n if (ch == '\\n') {\n loc->line++;\n loc->column = 1;\n }\n } while (ch);\n\n error_at(\"Unenclosed C-style comment\", loc);\n return NULL;\n }\n\n if (ch == '/') {\n /* C++-style comment */\n int pos = buf->size;\n do {\n pos++;\n ch = buf->elements[pos];\n } while (ch && !is_newline(ch));\n loc->column += pos - buf->size + 1;\n buf->size = pos;\n return lex_token(buf, loc);\n }\n\n if (ch == '=') {\n ch = read_char(buf);\n token = new_token(T_divideeq, loc, 2);\n loc->column += 2;\n return token;\n }\n\n token = new_token(T_divide, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == ' ') {\n /* Compacts sequence of whitespace together */\n int sz = 1;\n\n while (read_char(buf) == ' ')\n sz++;\n\n token = new_token(T_whitespace, loc, sz);\n loc->column += sz;\n return token;\n }\n\n if (ch == '\\t') {\n read_char(buf);\n token = new_token(T_tab, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == '\\0') {\n read_char(buf);\n token = new_token(T_eof, loc, 1);\n loc->column++;\n return token;\n }\n\n if (isdigit(ch)) {\n int sz = 0;\n token_buffer[sz++] = ch;\n ch = read_char(buf);\n\n if (token_buffer[0] == '0' && ((ch | 32) == 'x')) {\n /* Hexadecimal: starts with 0x or 0X */\n if (sz >= MAX_TOKEN_LEN - 1) {\n loc->len = sz;\n error_at(\"Token too long\", loc);\n }\n token_buffer[sz++] = ch;\n\n ch = read_char(buf);\n if (!isxdigit(ch)) {\n loc->len = 3;\n error_at(\"Invalid hex literal: expected hex digit after 0x\",\n loc);\n }\n\n do {\n if (sz >= MAX_TOKEN_LEN - 1) {\n loc->len = sz;\n error_at(\"Token too long\", loc);\n }\n token_buffer[sz++] = ch;\n ch = read_char(buf);\n } while (isxdigit(ch));\n\n } else if (token_buffer[0] == '0' && ((ch | 32) == 'b')) {\n /* Binary literal: 0b or 0B */\n if (sz >= MAX_TOKEN_LEN - 1) {\n loc->len = sz;\n error_at(\"Token too long\", loc);\n }\n token_buffer[sz++] = ch;\n\n ch = read_char(buf);\n if (ch != '0' && ch != '1') {\n loc->len = 3;\n error_at(\"Binary literal expects 0 or 1 after 0b\", loc);\n }\n\n do {\n if (sz >= MAX_TOKEN_LEN - 1) {\n loc->len = sz;\n error_at(\"Token too long\", loc);\n }\n token_buffer[sz++] = ch;\n ch = read_char(buf);\n } while (ch == '0' || ch == '1');\n\n } else if (token_buffer[0] == '0') {\n /* Octal: starts with 0 but not followed by 'x' or 'b' */\n while (isdigit(ch)) {\n if (ch >= '8') {\n loc->pos += sz;\n loc->column += sz;\n error_at(\"Invalid octal digit, must be in range 0-7\", loc);\n }\n if (sz >= MAX_TOKEN_LEN - 1) {\n loc->len = sz;\n error_at(\"Token too long\", loc);\n }\n token_buffer[sz++] = ch;\n ch = read_char(buf);\n }\n\n } else {\n /* Decimal */\n while (isdigit(ch)) {\n if (sz >= MAX_TOKEN_LEN - 1) {\n loc->len = sz;\n error_at(\"Token too long\", loc);\n }\n token_buffer[sz++] = ch;\n ch = read_char(buf);\n }\n }\n\n token_buffer[sz] = '\\0';\n token = new_token(T_numeric, loc, sz);\n token->literal = intern_string(token_buffer);\n loc->column += sz;\n return token;\n }\n\n if (ch == '(') {\n ch = read_char(buf);\n token = new_token(T_open_bracket, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == ')') {\n ch = read_char(buf);\n token = new_token(T_close_bracket, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == '{') {\n ch = read_char(buf);\n token = new_token(T_open_curly, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == '}') {\n ch = read_char(buf);\n token = new_token(T_close_curly, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == '[') {\n ch = read_char(buf);\n token = new_token(T_open_square, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == ']') {\n ch = read_char(buf);\n token = new_token(T_close_square, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == ',') {\n ch = read_char(buf);\n token = new_token(T_comma, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == '^') {\n ch = read_char(buf);\n\n if (ch == '=') {\n ch = read_char(buf);\n token = new_token(T_xoreq, loc, 2);\n loc->column += 2;\n return token;\n }\n\n token = new_token(T_bit_xor, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == '~') {\n ch = read_char(buf);\n token = new_token(T_bit_not, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == '\"') {\n int sz = 0;\n bool special = false;\n\n ch = read_char(buf);\n while (ch != '\"' || special) {\n if ((sz > 0) && (token_buffer[sz - 1] == '\\\\')) {\n token_buffer[sz++] = ch;\n } else {\n if (sz >= MAX_TOKEN_LEN - 1) {\n loc->len = sz + 1;\n error_at(\"String literal too long\", loc);\n }\n token_buffer[sz++] = ch;\n }\n\n if (ch == '\\\\')\n special = true;\n else\n special = false;\n\n ch = read_char(buf);\n }\n token_buffer[sz] = '\\0';\n\n read_char(buf);\n token = new_token(T_string, loc, sz + 2);\n token->literal = intern_string(token_buffer);\n loc->column += sz + 2;\n return token;\n }\n\n if (ch == '\\'') {\n int sz = 0;\n bool escaped = false;\n\n ch = read_char(buf);\n if (ch == '\\\\') {\n token_buffer[sz++] = ch;\n ch = read_char(buf);\n\n do {\n token_buffer[sz++] = ch;\n ch = read_char(buf);\n escaped = true;\n } while (ch && ch != '\\'');\n } else {\n token_buffer[sz++] = ch;\n }\n token_buffer[sz] = '\\0';\n\n if (!escaped)\n ch = read_char(buf);\n\n if (ch != '\\'') {\n loc->len = 2;\n error_at(\"Unenclosed character literal\", loc);\n }\n\n read_char(buf);\n token = new_token(T_char, loc, sz + 2);\n token->literal = intern_string(token_buffer);\n loc->column += sz + 2;\n return token;\n }\n\n if (ch == '*') {\n ch = read_char(buf);\n\n if (ch == '=') {\n read_char(buf);\n token = new_token(T_asteriskeq, loc, 2);\n loc->column += 2;\n return token;\n }\n\n token = new_token(T_asterisk, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == '&') {\n ch = read_char(buf);\n\n if (ch == '&') {\n read_char(buf);\n token = new_token(T_log_and, loc, 2);\n loc->column += 2;\n return token;\n }\n\n if (ch == '=') {\n read_char(buf);\n token = new_token(T_andeq, loc, 2);\n loc->column += 2;\n return token;\n }\n\n token = new_token(T_ampersand, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == '|') {\n ch = read_char(buf);\n\n if (ch == '|') {\n read_char(buf);\n token = new_token(T_log_or, loc, 2);\n loc->column += 2;\n return token;\n }\n\n if (ch == '=') {\n read_char(buf);\n token = new_token(T_oreq, loc, 2);\n loc->column += 2;\n return token;\n }\n\n token = new_token(T_bit_or, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == '<') {\n ch = read_char(buf);\n\n if (ch == '=') {\n read_char(buf);\n token = new_token(T_le, loc, 2);\n loc->column += 2;\n return token;\n }\n\n if (ch == '<') {\n ch = read_char(buf);\n\n if (ch == '=') {\n read_char(buf);\n token = new_token(T_lshifteq, loc, 3);\n loc->column += 3;\n return token;\n }\n\n token = new_token(T_lshift, loc, 2);\n loc->column += 2;\n return token;\n }\n\n token = new_token(T_lt, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == '%') {\n ch = read_char(buf);\n\n if (ch == '=') {\n read_char(buf);\n token = new_token(T_modeq, loc, 2);\n loc->column += 2;\n return token;\n }\n\n token = new_token(T_mod, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == '>') {\n ch = read_char(buf);\n\n if (ch == '=') {\n read_char(buf);\n token = new_token(T_ge, loc, 2);\n loc->column += 2;\n return token;\n }\n\n if (ch == '>') {\n ch = read_char(buf);\n\n if (ch == '=') {\n read_char(buf);\n token = new_token(T_rshifteq, loc, 3);\n loc->column += 3;\n return token;\n }\n\n token = new_token(T_rshift, loc, 2);\n loc->column += 2;\n return token;\n }\n\n token = new_token(T_gt, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == '!') {\n ch = read_char(buf);\n\n if (ch == '=') {\n read_char(buf);\n token = new_token(T_noteq, loc, 2);\n loc->column += 2;\n return token;\n }\n\n token = new_token(T_log_not, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == '.') {\n ch = read_char(buf);\n\n if (ch == '.' && peek_char(buf, 1) == '.') {\n buf->size += 2;\n token = new_token(T_elipsis, loc, 3);\n loc->column += 3;\n return token;\n }\n\n token = new_token(T_dot, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == '-') {\n ch = read_char(buf);\n\n if (ch == '>') {\n read_char(buf);\n token = new_token(T_arrow, loc, 2);\n loc->column += 2;\n return token;\n }\n\n if (ch == '-') {\n read_char(buf);\n token = new_token(T_decrement, loc, 2);\n loc->column += 2;\n return token;\n }\n\n if (ch == '=') {\n read_char(buf);\n token = new_token(T_minuseq, loc, 2);\n loc->column += 2;\n return token;\n }\n\n token = new_token(T_minus, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == '+') {\n ch = read_char(buf);\n\n if (ch == '+') {\n read_char(buf);\n token = new_token(T_increment, loc, 2);\n loc->column += 2;\n return token;\n }\n\n if (ch == '=') {\n read_char(buf);\n token = new_token(T_pluseq, loc, 2);\n loc->column += 2;\n return token;\n }\n\n token = new_token(T_plus, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == ';') {\n read_char(buf);\n token = new_token(T_semicolon, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == '?') {\n read_char(buf);\n token = new_token(T_question, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == ':') {\n read_char(buf);\n token = new_token(T_colon, loc, 1);\n loc->column++;\n return token;\n }\n\n if (ch == '=') {\n ch = read_char(buf);\n\n if (ch == '=') {\n read_char(buf);\n token = new_token(T_eq, loc, 2);\n loc->column += 2;\n return token;\n }\n\n token = new_token(T_assign, loc, 1);\n loc->column++;\n return token;\n }\n\n if (isalnum(ch) || ch == '_') {\n int sz = 0;\n do {\n if (sz >= MAX_TOKEN_LEN - 1) {\n loc->len = sz;\n error_at(\"Token too long\", loc);\n }\n token_buffer[sz++] = ch;\n ch = read_char(buf);\n } while (isalnum(ch) || ch == '_');\n token_buffer[sz] = 0;\n\n /* Fast path for common keywords - avoid hashmap lookup */\n token_kind_t kind = T_identifier;\n\n /* Check most common keywords inline based on token length and first\n * character.\n */\n switch (sz) {\n case 2: /* 2-letter keywords: if, do */\n if (token_buffer[0] == 'i' && token_buffer[1] == 'f')\n kind = T_if;\n else if (token_buffer[0] == 'd' && token_buffer[1] == 'o')\n kind = T_do;\n break;\n\n case 3: /* 3-letter keywords: for */\n if (token_buffer[0] == 'f' && token_buffer[1] == 'o' &&\n token_buffer[2] == 'r')\n kind = T_for;\n break;\n\n case 4: /* 4-letter keywords: else, enum, case */\n if (token_buffer[0] == 'e') {\n if (!memcmp(token_buffer, \"else\", 4))\n kind = T_else;\n else if (!memcmp(token_buffer, \"enum\", 4))\n kind = T_enum;\n } else if (!memcmp(token_buffer, \"case\", 4))\n kind = T_case;\n else if (!memcmp(token_buffer, \"goto\", 4))\n kind = T_goto;\n break;\n\n case 5: /* 5-letter keywords: while, break, union, const */\n if (token_buffer[0] == 'w' && !memcmp(token_buffer, \"while\", 5))\n kind = T_while;\n else if (token_buffer[0] == 'b' &&\n !memcmp(token_buffer, \"break\", 5))\n kind = T_break;\n else if (token_buffer[0] == 'u' &&\n !memcmp(token_buffer, \"union\", 5))\n kind = T_union;\n else if (token_buffer[0] == 'c' &&\n !memcmp(token_buffer, \"const\", 5))\n kind = T_const;\n break;\n\n case 6: /* 6-letter keywords: return, struct, switch, sizeof */\n if (token_buffer[0] == 'r' && !memcmp(token_buffer, \"return\", 6))\n kind = T_return;\n else if (token_buffer[0] == 's') {\n if (!memcmp(token_buffer, \"struct\", 6))\n kind = T_struct;\n else if (!memcmp(token_buffer, \"switch\", 6))\n kind = T_switch;\n else if (!memcmp(token_buffer, \"sizeof\", 6))\n kind = T_sizeof;\n }\n break;\n\n case 7: /* 7-letter keywords: typedef, default */\n if (!memcmp(token_buffer, \"typedef\", 7))\n kind = T_typedef;\n else if (!memcmp(token_buffer, \"default\", 7))\n kind = T_default;\n break;\n\n case 8: /* 8-letter keywords: continue */\n if (!memcmp(token_buffer, \"continue\", 8))\n kind = T_continue;\n break;\n\n default:\n /* Keywords longer than 8 chars or identifiers - use hashmap */\n break;\n }\n\n /* Fall back to hashmap for uncommon keywords */\n if (kind == T_identifier)\n kind = lookup_keyword(token_buffer);\n\n token = new_token(kind, loc, sz);\n token->literal = intern_string(token_buffer);\n loc->column += sz;\n return token;\n }\n\n error_at(\"Unexpected token\", loc);\n return NULL;\n}\n\ntoken_stream_t *gen_file_token_stream(char *filename)\n{\n /* FIXME: We should normalize filename first to make cache works as expected\n */\n\n token_t head;\n token_t *cur = &head;\n token_stream_t *tks;\n /* initialie source location with the following configuration:\n * pos is at 0,\n * len is 1 for reporting convenience,\n * and the column and line number are set to 1.\n */\n source_location_t loc = {0, 1, 1, 1, filename};\n strbuf_t *buf;\n\n tks = hashmap_get(TOKEN_CACHE, filename);\n\n /* Already cached, just return the computed token stream */\n if (tks)\n return tks;\n\n buf = get_file_buf(filename);\n\n /* Borrows strbuf_t#size to use as source index */\n buf->size = 0;\n\n while (buf->size < buf->capacity) {\n cur->next = lex_token(buf, &loc);\n cur = cur->next;\n\n if (cur->kind == T_eof)\n break;\n }\n\n if (!head.next) {\n head.next = arena_calloc(TOKEN_ARENA, 1, sizeof(token_t));\n head.next->kind = T_eof;\n memcpy(&head.next->location, &loc, sizeof(source_location_t));\n cur = head.next;\n }\n\n if (cur->kind != T_eof)\n error_at(\"Internal error, expected eof at the end of file\",\n &cur->location);\n\n tks = malloc(sizeof(token_stream_t));\n tks->head = head.next;\n tks->tail = cur;\n hashmap_put(TOKEN_CACHE, filename, tks);\n return tks;\n}\n\ntoken_stream_t *gen_libc_token_stream()\n{\n token_t head;\n token_t *cur = &head, *tk;\n token_stream_t *tks;\n char *filename = dynlink ? \"lib/c.h\" : \"lib/c.c\";\n strbuf_t *buf = LIBC_SRC;\n source_location_t loc = {0, 1, 1, 1, filename};\n\n tks = hashmap_get(TOKEN_CACHE, filename);\n\n if (tks)\n return tks;\n\n if (!hashmap_contains(SRC_FILE_MAP, filename))\n hashmap_put(SRC_FILE_MAP, filename, LIBC_SRC);\n\n /* Borrows strbuf_t#size to use as source index */\n buf->size = 0;\n\n while (buf->size < buf->capacity) {\n tk = lex_token(buf, &loc);\n\n /* Early break to discard eof token, so later\n * we can concat libc token stream with actual\n * input file's token stream.\n */\n if (tk->kind == T_eof)\n break;\n\n cur->next = tk;\n cur = cur->next;\n }\n\n if (!head.next)\n fatal(\"Unable to include libc\");\n\n if (tk->kind != T_eof)\n error_at(\"Internal error, expected eof at the end of file\",\n &cur->location);\n\n tks = malloc(sizeof(token_stream_t));\n tks->head = head.next;\n tks->tail = cur;\n hashmap_put(TOKEN_CACHE, filename, tks);\n return tks;\n}\n\nvoid skip_unused_token(void)\n{\n while (cur_token && cur_token->next) {\n if (cur_token->next->kind == T_whitespace ||\n cur_token->next->kind == T_newline ||\n cur_token->next->kind == T_tab)\n cur_token = cur_token->next;\n else\n break;\n }\n}\n\n/* Fetches current token's location. */\nsource_location_t *cur_token_loc()\n{\n return &cur_token->location;\n}\n\n/* Finds next token's location, whitespace, tab, and newline tokens are skipped,\n * if current token is eof, then returns eof token's location instead.\n */\nsource_location_t *next_token_loc()\n{\n skip_unused_token();\n\n if (cur_token->kind == T_eof)\n return &cur_token->location;\n\n return &cur_token->next->location;\n}\n\n/* Lex next token with aliasing enabled */\ntoken_kind_t lex_next(void)\n{\n skip_unused_token();\n /* if reached eof, we always return eof token to avoid any advancement */\n if (cur_token->kind == T_eof)\n return T_eof;\n\n cur_token = cur_token->next;\n return cur_token->kind;\n}\n\n/* Accepts next token if token types are matched. */\nbool lex_accept(token_kind_t kind)\n{\n skip_unused_token();\n if (cur_token->next && cur_token->next->kind == kind) {\n lex_next();\n return true;\n }\n return false;\n}\n\n/* Peeks next token and copy token's literal to value if token types are\n * matched.\n */\nbool lex_peek(token_kind_t kind, char *value)\n{\n skip_unused_token();\n if (cur_token->next && cur_token->next->kind == kind) {\n if (!value)\n return true;\n strcpy(value, cur_token->next->literal);\n return true;\n }\n return false;\n}\n\n/* Strictly match next token with given token type and copy token's literal to\n * value.\n */\nvoid lex_ident(token_kind_t token, char *value)\n{\n skip_unused_token();\n if (cur_token->next && cur_token->next->kind == token) {\n lex_next();\n if (value)\n strcpy(value, cur_token->literal);\n return;\n }\n token_t *tk = cur_token->next ? cur_token->next : cur_token;\n error_at(\"Unexpected token\", &tk->location);\n}\n\n/* Strictly match next token with given token type.\n */\nvoid lex_expect(token_kind_t token)\n{\n skip_unused_token();\n if (cur_token->next && cur_token->next->kind == token) {\n lex_next();\n return;\n }\n token_t *tk = cur_token->next ? cur_token->next : cur_token;\n error_at(\"Unexpected token\", &tk->location);\n}\n" }, { "path": "src/main.c", "content": "/*\n * shecc - Self-Hosting and Educational C Compiler.\n *\n * shecc is freely redistributable under the BSD 2 clause license. See the\n * file \"LICENSE\" for information on usage and redistribution of this file.\n */\n\n#include \n#include \n#include \n#include \n\n/* Define target machine */\n#include \"../config\"\n\n/* The inclusion must follow the fixed order, otherwise it fails to build. */\n#include \"defs.h\"\n\n/* Initialize global objects */\n#include \"globals.c\"\n\n/* ELF manipulation */\n#include \"elf.c\"\n\n/* C language lexical analyzer */\n#include \"lexer.c\"\n\n/* C language pre-processor */\n#include \"preprocessor.c\"\n\n/* C language syntactic analyzer */\n#include \"parser.c\"\n\n/* architecture-independent middle-end */\n#include \"ssa.c\"\n\n/* Register allocator */\n#include \"reg-alloc.c\"\n\n/* Peephole optimization */\n#include \"peephole.c\"\n\n/* Arch-specific IR lowering boundary */\n#include \"arch-lower.c\"\n\n/* Machine code generation. support ARMv7-A and RV32I */\n#include \"codegen.c\"\n\n/* inlined libc */\n#include \"../out/libc.inc\"\n\nint main(int argc, char *argv[])\n{\n char *out = NULL;\n char *in = NULL;\n token_stream_t *libc_token_stream, *token_stream;\n token_t *tk;\n\n for (int i = 1; i < argc; i++) {\n if (!strcmp(argv[i], \"--dump-ir\"))\n dump_ir = true;\n else if (!strcmp(argv[i], \"+m\"))\n hard_mul_div = true;\n else if (!strcmp(argv[i], \"--no-libc\"))\n libc = false;\n else if (!strcmp(argv[i], \"--dynlink\"))\n dynlink = true;\n else if (!strcmp(argv[i], \"-E\"))\n expand_only = true;\n else if (!strcmp(argv[i], \"-o\")) {\n if (i + 1 < argc) {\n out = argv[i + 1];\n i++;\n } else\n /* unsupported options */\n abort();\n } else if (argv[i][0] == '-') {\n fatal(\"Unidentified option\");\n } else\n in = argv[i];\n }\n\n if (!in) {\n printf(\"Missing source file!\\n\");\n printf(\n \"Usage: shecc [-o output] [+m] [--dump-ir] [--no-libc] [--dynlink] \"\n \"[-E]\"\n \"\\n\");\n exit(-1);\n }\n\n /* initialize global objects */\n global_init();\n\n /* include libc */\n if (libc) {\n libc_decl();\n if (!dynlink)\n libc_impl();\n libc_token_stream = gen_libc_token_stream();\n }\n\n token_stream = gen_file_token_stream(in);\n\n /* concat libc's and input file's token stream */\n if (libc) {\n libc_token_stream->tail->next = token_stream->head;\n token_stream = libc_token_stream;\n }\n\n tk = preprocess(token_stream->head);\n\n if (expand_only) {\n emit_preprocessed_token(tk);\n exit(0);\n }\n\n /* load and parse source code into IR */\n parse(tk);\n\n /* Compact arenas after parsing to free temporary parse structures */\n compact_all_arenas();\n\n ssa_build();\n\n /* dump first phase IR */\n if (dump_ir)\n dump_insn();\n\n /* SSA-based optimization */\n optimize();\n\n /* Compact arenas after SSA optimization to free temporary SSA structures */\n compact_all_arenas();\n\n /* SSA-based liveness analyses */\n liveness_analysis();\n\n /* Compact after liveness analysis - mainly traversal args in GENERAL_ARENA\n */\n compact_arenas_selective(COMPACT_ARENA_GENERAL);\n\n /* allocate register from IR */\n reg_alloc();\n\n /* Compact after register allocation - mainly INSN and BB arenas */\n compact_arenas_selective(COMPACT_ARENA_INSN | COMPACT_ARENA_BB);\n\n peephole();\n\n /* Apply arch-specific IR tweaks before final codegen */\n arch_lower();\n\n /* flatten CFG to linear instruction */\n cfg_flatten();\n\n /* Compact after CFG flattening - BB and GENERAL no longer needed */\n compact_arenas_selective(COMPACT_ARENA_BB | COMPACT_ARENA_GENERAL);\n\n /* dump second phase IR */\n if (dump_ir)\n dump_ph2_ir();\n\n /*\n * ELF preprocess:\n * 1. generate all sections except for .text section.\n * 2. calculate the starting addresses of certain sections.\n */\n elf_preprocess();\n\n /* generate code from IR */\n code_generate();\n\n /* ELF postprocess: generate all ELF headers */\n elf_postprocess();\n\n /* output code in ELF */\n elf_generate(out);\n\n /* release allocated objects */\n global_release();\n\n exit(0);\n}\n" }, { "path": "src/opt-sccp.c", "content": "/*\n * shecc - Self-Hosting and Educational C Compiler.\n *\n * shecc is freely redistributable under the BSD 2 clause license. See the\n * file \"LICENSE\" for information on usage and redistribution of this file.\n */\n\n/* SCCP (Sparse Conditional Constant Propagation) Optimization Pass\n *\n * This optimization pass performs:\n * - Constant propagation through assignments\n * - Constant folding for arithmetic and comparison operations\n * - Branch folding when conditions are compile-time constants\n * - Dead code elimination through unreachable branch removal\n */\n\n/* Simple constant propagation within basic blocks */\nbool simple_sccp(func_t *func)\n{\n if (!func || !func->bbs)\n return false;\n\n bool changed = false;\n\n /* Iterate through basic blocks */\n for (basic_block_t *bb = func->bbs; bb; bb = bb->rpo_next) {\n /* Process instructions in the block */\n for (insn_t *insn = bb->insn_list.head; insn; insn = insn->next) {\n /* Skip if no destination */\n if (!insn->rd)\n continue;\n\n /* Handle simple constant propagation */\n switch (insn->opcode) {\n case OP_assign:\n /* Propagate constants through assignments */\n if (insn->rs1 && insn->rs1->is_const && !insn->rd->is_const) {\n insn->rd->is_const = true;\n insn->rd->init_val = insn->rs1->init_val;\n insn->opcode = OP_load_constant;\n insn->rs1 = NULL;\n changed = true;\n }\n break;\n\n case OP_trunc:\n /* Constant truncation optimization integrated into SCCP */\n if (insn->rs1 && insn->rs1->is_const && !insn->rd->is_global &&\n insn->sz > 0) {\n int value = insn->rs1->init_val;\n int result = value;\n\n /* Perform truncation based on size */\n if (insn->sz == 1) {\n /* Truncate to 8 bits */\n result = value & 0xFF;\n } else if (insn->sz == 2) {\n /* Truncate to 16 bits */\n result = value & 0xFFFF;\n } else if (insn->sz == 4) {\n /* No truncation needed for 32-bit */\n result = value;\n } else {\n /* Invalid size, skip */\n break;\n }\n\n /* Convert to constant load */\n insn->opcode = OP_load_constant;\n insn->rd->is_const = true;\n insn->rd->init_val = result;\n insn->rs1 = NULL;\n insn->sz = 0;\n changed = true;\n }\n break;\n\n case OP_sign_ext:\n /* Constant sign extension optimization integrated into SCCP */\n if (insn->rs1 && insn->rs1->is_const && !insn->rd->is_global &&\n insn->sz > 0) {\n int value = insn->rs1->init_val;\n int result = value;\n\n /* Perform sign extension based on source size */\n if (insn->sz == 1) {\n /* Sign extend from 8 bits */\n result = (value & 0x80) ? (value | 0xFFFFFF00)\n : (value & 0xFF);\n } else if (insn->sz == 2) {\n /* Sign extend from 16 bits */\n result = (value & 0x8000) ? (value | 0xFFFF0000)\n : (value & 0xFFFF);\n } else if (insn->sz == 4) {\n /* No sign extension needed for 32-bit */\n result = value;\n } else {\n /* Invalid size, skip */\n break;\n }\n\n /* Convert to constant load */\n insn->opcode = OP_load_constant;\n insn->rd->is_const = true;\n insn->rd->init_val = result;\n insn->rs1 = NULL;\n insn->sz = 0;\n changed = true;\n }\n break;\n\n case OP_add:\n case OP_sub:\n case OP_mul:\n case OP_eq:\n case OP_neq:\n case OP_lt:\n case OP_leq:\n case OP_gt:\n case OP_geq:\n /* Unified constant folding for binary and comparison ops */\n if (insn->rs1 && insn->rs1->is_const && insn->rs2 &&\n insn->rs2->is_const && !insn->rd->is_global) {\n int result = 0;\n const int l = insn->rs1->init_val, r = insn->rs2->init_val;\n\n /* Compute result based on operation type */\n switch (insn->opcode) {\n case OP_add:\n result = l + r;\n break;\n case OP_sub:\n result = l - r;\n break;\n case OP_mul:\n result = l * r;\n break;\n case OP_eq:\n result = (l == r);\n break;\n case OP_neq:\n result = (l != r);\n break;\n case OP_lt:\n result = (l < r);\n break;\n case OP_leq:\n result = (l <= r);\n break;\n case OP_gt:\n result = (l > r);\n break;\n case OP_geq:\n result = (l >= r);\n break;\n default:\n continue;\n }\n\n /* Convert to constant load */\n insn->opcode = OP_load_constant;\n insn->rd->is_const = true;\n insn->rd->init_val = result;\n insn->rs1 = NULL;\n insn->rs2 = NULL;\n changed = true;\n }\n break;\n\n default:\n /* Other opcodes - no optimization */\n break;\n }\n }\n\n /* Simple constant branch folding */\n insn_t *last = bb->insn_list.tail;\n if (last && last->opcode == OP_branch) {\n if (last->rs1 && last->rs1->is_const) {\n /* Convert to unconditional jump */\n last->opcode = OP_jump;\n\n if (last->rs1->init_val != 0) {\n /* Take then branch */\n bb->else_ = NULL;\n } else {\n /* Take else branch */\n bb->then_ = bb->else_;\n bb->else_ = NULL;\n }\n\n last->rs1 = NULL;\n changed = true;\n }\n }\n }\n\n return changed;\n}\n\n/* Targeted constant truncation peephole optimization */\nbool optimize_constant_casts(func_t *func)\n{\n if (!func || !func->bbs)\n return false;\n\n bool changed = false;\n\n /* Simple peephole optimization: const + trunc pattern */\n for (basic_block_t *bb = func->bbs; bb; bb = bb->rpo_next) {\n if (!bb)\n continue;\n\n for (insn_t *insn = bb->insn_list.head; insn && insn->next;\n insn = insn->next) {\n insn_t *next_insn = insn->next;\n\n /* Look for pattern: const %.tX, VALUE followed by\n * %.tY = trunc %.tX, SIZE\n */\n if (insn->opcode == OP_load_constant &&\n next_insn->opcode == OP_trunc && insn->rd && next_insn->rs1 &&\n insn->rd == next_insn->rs1 && next_insn->sz > 0 &&\n !next_insn->rd->is_global) {\n int value = insn->rd->init_val;\n int result = value;\n\n /* Perform truncation based on size */\n if (next_insn->sz == 1) {\n /* Truncate to 8 bits */\n result = value & 0xFF;\n } else if (next_insn->sz == 2) {\n /* Truncate to 16 bits */\n result = value & 0xFFFF;\n } else if (next_insn->sz == 4) {\n /* No truncation needed for 32-bit */\n result = value;\n } else {\n /* Invalid size, skip */\n continue;\n }\n\n /* Optimize: Replace both instructions with single const */\n insn->rd = next_insn->rd; /* Update dest to final target */\n insn->rd->is_const = true;\n insn->rd->init_val = result;\n\n /* Remove the truncation instruction by converting it to\n * NOP-like\n */\n next_insn->opcode = OP_load_constant;\n next_insn->rd->is_const = true;\n next_insn->rd->init_val = result;\n next_insn->rs1 = NULL;\n next_insn->sz = 0;\n\n changed = true;\n }\n }\n }\n\n return changed;\n}\n" }, { "path": "src/parser.c", "content": "/*\n * shecc - Self-Hosting and Educational C Compiler.\n *\n * shecc is freely redistributable under the BSD 2 clause license. See the\n * file \"LICENSE\" for information on usage and redistribution of this file.\n */\n#include \n#include \n#include \n\n#include \"../config\"\n#include \"defs.h\"\n#include \"globals.c\"\n\n/* C language syntactic analyzer */\nint global_var_idx = 0;\n\n/* Side effect instructions cache */\ninsn_t side_effect[10];\nint se_idx = 0;\n\n/* Control flow utilities */\nbasic_block_t *break_bb[MAX_NESTING];\nint break_exit_idx = 0;\nbasic_block_t *continue_bb[MAX_NESTING];\nint continue_pos_idx = 0;\n\n/* Label utilities */\nlabel_t labels[MAX_LABELS];\nint label_idx = 0;\nbasic_block_t *backpatch_bb[MAX_LABELS];\nint backpatch_bb_idx = 0;\n\n/* stack of the operands of 3AC */\nvar_t *operand_stack[MAX_OPERAND_STACK_SIZE];\nint operand_stack_idx = 0;\n\n/* Forward declarations */\nsource_location_t *cur_token_loc();\nsource_location_t *next_token_loc();\n\nbasic_block_t *read_body_statement(block_t *parent, basic_block_t *bb);\nvoid perform_side_effect(block_t *parent, basic_block_t *bb);\nvoid read_inner_var_decl(var_t *vd, bool anon, bool is_param);\nvoid read_partial_var_decl(var_t *vd, var_t *template);\nvoid parse_array_init(var_t *var,\n block_t *parent,\n basic_block_t **bb,\n bool emit_code);\n\nlabel_t *find_label(char *name)\n{\n for (int i = 0; i < label_idx; i++) {\n if (!strcmp(name, labels[i].label_name))\n return &labels[i];\n }\n return NULL;\n}\n\nvoid add_label(char *name, basic_block_t *bb)\n{\n if (label_idx > MAX_LABELS - 1)\n error_at(\"Too many labels in function\", cur_token_loc());\n\n label_t *l = &labels[label_idx++];\n strncpy(l->label_name, name, MAX_ID_LEN);\n l->bb = bb;\n}\n\nchar *gen_name_to(char *buf)\n{\n sprintf(buf, \".t%d\", global_var_idx++);\n return buf;\n}\n\nvar_t *require_var(block_t *blk)\n{\n var_list_t *var_list = &blk->locals;\n\n if (var_list->size >= var_list->capacity) {\n var_list->capacity <<= 1;\n\n var_t **new_locals =\n arena_alloc(BLOCK_ARENA, var_list->capacity * sizeof(var_t *));\n memcpy(new_locals, var_list->elements,\n var_list->size * sizeof(var_t *));\n var_list->elements = new_locals;\n }\n\n var_t *var = arena_calloc(BLOCK_ARENA, 1, sizeof(var_t));\n var_list->elements[var_list->size++] = var;\n var->consumed = -1;\n var->phys_reg = -1;\n var->first_use = -1;\n var->last_use = -1;\n var->loop_depth = 0;\n var->use_count = 0;\n var->base = var;\n var->type = TY_int;\n var->space_is_allocated = false;\n var->ofs_based_on_stack_top = false;\n return var;\n}\n\nvar_t *require_typed_var(block_t *blk, type_t *type)\n{\n if (!type)\n error_at(\"Type must not be NULL\", cur_token_loc());\n\n var_t *var = require_var(blk);\n var->type = type;\n return var;\n}\n\nvar_t *require_typed_ptr_var(block_t *blk, type_t *type, int ptr)\n{\n var_t *var = require_typed_var(blk, type);\n var->ptr_level = ptr;\n return var;\n}\n\nvar_t *require_ref_var(block_t *blk, type_t *type, int ptr)\n{\n if (!type)\n error_at(\"Cannot reference variable from NULL type\", cur_token_loc());\n\n var_t *var = require_typed_var(blk, type);\n var->ptr_level = ptr + 1;\n return var;\n}\n\nvar_t *require_deref_var(block_t *blk, type_t *type, int ptr)\n{\n if (!type)\n error_at(\"Cannot dereference variable from NULL type\", cur_token_loc());\n\n /* Allowing integer dereferencing */\n if (!ptr && type->base_type != TYPE_struct &&\n type->base_type != TYPE_typedef)\n return require_var(blk);\n\n if (!ptr)\n error_at(\"Cannot dereference from non-pointer typed variable\",\n cur_token_loc());\n\n var_t *var = require_typed_var(blk, type);\n var->ptr_level = ptr - 1;\n return var;\n}\n\nvoid opstack_push(var_t *var)\n{\n operand_stack[operand_stack_idx++] = var;\n}\n\nvar_t *opstack_pop(void)\n{\n return operand_stack[--operand_stack_idx];\n}\n\nvoid read_expr(block_t *parent, basic_block_t **bb);\n\nint write_symbol(const char *data)\n{\n /* Write string literals to .rodata section */\n const int start_len = elf_rodata->size;\n elf_write_str(elf_rodata, data);\n elf_write_byte(elf_rodata, 0);\n return start_len;\n}\n\nint get_size(var_t *var)\n{\n if (var->ptr_level || var->is_func)\n return PTR_SIZE;\n return var->type->size;\n}\n\nint get_operator_prio(opcode_t op)\n{\n /* https://www.cs.uic.edu/~i109/Notes/COperatorPrecedenceTable.pdf */\n switch (op) {\n case OP_ternary:\n return 3;\n case OP_log_or:\n return 4;\n case OP_log_and:\n return 5;\n case OP_bit_or:\n return 6;\n case OP_bit_xor:\n return 7;\n case OP_bit_and:\n return 8;\n case OP_eq:\n case OP_neq:\n return 9;\n case OP_lt:\n case OP_leq:\n case OP_gt:\n case OP_geq:\n return 10;\n case OP_lshift:\n case OP_rshift:\n return 11;\n case OP_add:\n case OP_sub:\n return 12;\n case OP_mul:\n case OP_div:\n case OP_mod:\n return 13;\n default:\n return 0;\n }\n}\n\nint get_unary_operator_prio(opcode_t op)\n{\n switch (op) {\n case OP_add:\n case OP_sub:\n case OP_bit_not:\n case OP_log_not:\n return 14;\n default:\n return 0;\n }\n}\n\nopcode_t get_operator(void)\n{\n opcode_t op = OP_generic;\n if (lex_accept(T_plus))\n op = OP_add;\n else if (lex_accept(T_minus))\n op = OP_sub;\n else if (lex_accept(T_asterisk))\n op = OP_mul;\n else if (lex_accept(T_divide))\n op = OP_div;\n else if (lex_accept(T_mod))\n op = OP_mod;\n else if (lex_accept(T_lshift))\n op = OP_lshift;\n else if (lex_accept(T_rshift))\n op = OP_rshift;\n else if (lex_accept(T_log_and))\n op = OP_log_and;\n else if (lex_accept(T_log_or))\n op = OP_log_or;\n else if (lex_accept(T_eq))\n op = OP_eq;\n else if (lex_accept(T_noteq))\n op = OP_neq;\n else if (lex_accept(T_lt))\n op = OP_lt;\n else if (lex_accept(T_le))\n op = OP_leq;\n else if (lex_accept(T_gt))\n op = OP_gt;\n else if (lex_accept(T_ge))\n op = OP_geq;\n else if (lex_accept(T_ampersand))\n op = OP_bit_and;\n else if (lex_accept(T_bit_or))\n op = OP_bit_or;\n else if (lex_accept(T_bit_xor))\n op = OP_bit_xor;\n else if (lex_peek(T_question, NULL))\n op = OP_ternary;\n return op;\n}\n\nvar_t *promote_unchecked(block_t *block,\n basic_block_t **bb,\n var_t *var,\n type_t *target_type,\n int target_ptr)\n{\n var_t *rd = require_typed_ptr_var(block, target_type, target_ptr);\n gen_name_to(rd->var_name);\n /* Encode both source and target sizes in src1:\n * Lower 16 bits: target size\n * Upper 16 bits: source size\n * This allows codegen to distinguish between different promotion types\n * without changing IR semantics.\n */\n int encoded_size = ((var->type->size) << 16);\n if (target_ptr)\n encoded_size |= PTR_SIZE;\n else\n encoded_size |= target_type->size;\n add_insn(block, *bb, OP_sign_ext, rd, var, NULL, encoded_size, NULL);\n return rd;\n}\n\nvar_t *promote(block_t *block,\n basic_block_t **bb,\n var_t *var,\n type_t *target_type,\n int target_ptr)\n{\n /* Effectively checking whether var has size of int */\n if (var->type->size == target_type->size || var->ptr_level ||\n var->array_size)\n return var;\n\n if (var->type->size > TY_int->size && !var->ptr_level) {\n printf(\"Warning: Suspicious type promotion %s\\n\", var->type->type_name);\n return var;\n }\n\n return promote_unchecked(block, bb, var, target_type, target_ptr);\n}\n\nvar_t *truncate_unchecked(block_t *block,\n basic_block_t **bb,\n var_t *var,\n type_t *target_type,\n int target_ptr)\n{\n var_t *rd = require_typed_ptr_var(block, target_type, target_ptr);\n gen_name_to(rd->var_name);\n add_insn(block, *bb, OP_trunc, rd, var, NULL,\n target_ptr ? PTR_SIZE : target_type->size, NULL);\n return rd;\n}\n\nvar_t *resize_var(block_t *block, basic_block_t **bb, var_t *from, var_t *to)\n{\n bool is_from_ptr = from->ptr_level || from->array_size,\n is_to_ptr = to->ptr_level || to->array_size ||\n (to->type && to->type->ptr_level > 0);\n\n if (is_from_ptr && is_to_ptr)\n return from;\n\n int from_size = get_size(from), to_size = get_size(to);\n\n if (from_size > to_size) {\n /* Truncation */\n return truncate_unchecked(block, bb, from, to->type, to->ptr_level);\n }\n\n if (from_size < to_size) {\n /* Sign extend */\n return promote_unchecked(block, bb, from, to->type, to->ptr_level);\n }\n\n return from;\n}\n\nvoid read_parameter_list_decl(func_t *func, bool anon);\n\n/* Forward declaration for ternary handling used by initializers */\nvoid read_ternary_operation(block_t *parent, basic_block_t **bb);\n\n/* Parse array initializer to determine size for implicit arrays and\n * optionally emit initialization code.\n */\nvar_t *compute_element_address(block_t *parent,\n basic_block_t **bb,\n var_t *base_addr,\n int index,\n int elem_size)\n{\n if (index == 0)\n return base_addr;\n\n var_t *offset = require_var(parent);\n gen_name_to(offset->var_name);\n offset->init_val = index * elem_size;\n add_insn(parent, *bb, OP_load_constant, offset, NULL, NULL, 0, NULL);\n\n var_t *addr = require_var(parent);\n gen_name_to(addr->var_name);\n add_insn(parent, *bb, OP_add, addr, base_addr, offset, 0, NULL);\n return addr;\n}\n\nvar_t *compute_field_address(block_t *parent,\n basic_block_t **bb,\n var_t *struct_addr,\n var_t *field)\n{\n if (field->offset == 0)\n return struct_addr;\n\n var_t *offset = require_var(parent);\n gen_name_to(offset->var_name);\n offset->init_val = field->offset;\n add_insn(parent, *bb, OP_load_constant, offset, NULL, NULL, 0, NULL);\n\n var_t *addr = require_var(parent);\n gen_name_to(addr->var_name);\n add_insn(parent, *bb, OP_add, addr, struct_addr, offset, 0, NULL);\n return addr;\n}\n\nvar_t *parse_global_constant_value(block_t *parent, basic_block_t **bb)\n{\n var_t *val = NULL;\n\n if (lex_peek(T_numeric, NULL) || lex_peek(T_minus, NULL)) {\n bool is_neg = false;\n if (lex_accept(T_minus))\n is_neg = true;\n char numtok[MAX_ID_LEN];\n lex_ident(T_numeric, numtok);\n int num_val = parse_numeric_constant(numtok);\n if (is_neg)\n num_val = -num_val;\n\n val = require_var(parent);\n gen_name_to(val->var_name);\n val->init_val = num_val;\n add_insn(parent, *bb, OP_load_constant, val, NULL, NULL, 0, NULL);\n } else if (lex_peek(T_char, NULL)) {\n char chtok[MAX_TOKEN_LEN], unescaped[MAX_TOKEN_LEN];\n lex_ident(T_char, chtok);\n unescape_string(chtok, unescaped, MAX_TOKEN_LEN);\n\n val = require_typed_var(parent, TY_char);\n gen_name_to(val->var_name);\n val->init_val = unescaped[0];\n add_insn(parent, *bb, OP_load_constant, val, NULL, NULL, 0, NULL);\n } else if (lex_peek(T_string, NULL)) {\n lex_accept(T_string);\n /* TODO: String fields in structs not yet supported - requires proper\n * handling of string literals as initializers\n */\n } else {\n error_at(\"Global array initialization requires constant values\",\n next_token_loc());\n }\n\n return val;\n}\n\nvoid consume_global_constant_syntax(void)\n{\n if (lex_peek(T_numeric, NULL)) {\n lex_accept(T_numeric);\n } else if (lex_peek(T_minus, NULL)) {\n lex_accept(T_minus);\n lex_accept(T_numeric);\n } else if (lex_peek(T_string, NULL)) {\n lex_accept(T_string);\n } else if (lex_peek(T_char, NULL)) {\n lex_accept(T_char);\n } else {\n error_at(\"Global array initialization requires constant values\",\n next_token_loc());\n }\n}\n\nvoid parse_struct_field_init(block_t *parent,\n basic_block_t **bb,\n type_t *struct_type,\n var_t *target_addr,\n bool emit_code)\n{\n int field_idx = 0;\n\n if (!lex_peek(T_close_curly, NULL)) {\n for (;;) {\n var_t *field_val_raw = NULL;\n\n if (parent == GLOBAL_BLOCK) {\n if (emit_code) {\n field_val_raw = parse_global_constant_value(parent, bb);\n } else {\n consume_global_constant_syntax();\n }\n } else {\n read_expr(parent, bb);\n read_ternary_operation(parent, bb);\n field_val_raw = opstack_pop();\n }\n\n if (field_val_raw && field_idx < struct_type->num_fields) {\n var_t *field = &struct_type->fields[field_idx];\n\n var_t target = {0};\n target.type = field->type;\n target.ptr_level = field->ptr_level;\n var_t *field_val =\n resize_var(parent, bb, field_val_raw, &target);\n\n var_t *field_addr =\n compute_field_address(parent, bb, target_addr, field);\n\n int field_size = size_var(field);\n add_insn(parent, *bb, OP_write, NULL, field_addr, field_val,\n field_size, NULL);\n }\n\n field_idx++;\n if (!lex_accept(T_comma))\n break;\n if (lex_peek(T_close_curly, NULL))\n break;\n }\n }\n}\n\nvoid parse_array_literal_expr(block_t *parent, basic_block_t **bb)\n{\n var_t *array_var = require_var(parent);\n gen_name_to(array_var->var_name);\n array_var->is_compound_literal = true;\n\n int element_count = 0;\n var_t *first_element = NULL;\n\n if (!lex_peek(T_close_curly, NULL)) {\n read_expr(parent, bb);\n read_ternary_operation(parent, bb);\n first_element = opstack_pop();\n element_count = 1;\n\n while (lex_accept(T_comma)) {\n if (lex_peek(T_close_curly, NULL))\n break;\n\n read_expr(parent, bb);\n read_ternary_operation(parent, bb);\n opstack_pop();\n element_count++;\n }\n }\n\n lex_expect(T_close_curly);\n\n array_var->array_size = element_count;\n if (first_element) {\n array_var->type = first_element->type;\n array_var->init_val = first_element->init_val;\n } else {\n array_var->type = TY_int;\n array_var->init_val = 0;\n }\n\n opstack_push(array_var);\n add_insn(parent, *bb, OP_load_constant, array_var, NULL, NULL, 0, NULL);\n}\n\nbasic_block_t *handle_return_statement(block_t *parent, basic_block_t *bb)\n{\n if (lex_accept(T_semicolon)) {\n add_insn(parent, bb, OP_return, NULL, NULL, NULL, 0, NULL);\n bb_connect(bb, parent->func->exit, NEXT);\n return NULL;\n }\n\n read_expr(parent, &bb);\n read_ternary_operation(parent, &bb);\n perform_side_effect(parent, bb);\n lex_expect(T_semicolon);\n\n var_t *rs1 = opstack_pop();\n\n /* Handle array compound literals in return context.\n * Convert array compound literals to their first element value.\n */\n if (rs1 && rs1->array_size > 0 && rs1->var_name[0] == '.') {\n var_t *val = require_var(parent);\n val->type = rs1->type;\n val->init_val = rs1->init_val;\n gen_name_to(val->var_name);\n add_insn(parent, bb, OP_load_constant, val, NULL, NULL, 0, NULL);\n rs1 = val;\n }\n\n add_insn(parent, bb, OP_return, NULL, rs1, NULL, 0, NULL);\n bb_connect(bb, parent->func->exit, NEXT);\n return NULL;\n}\n\nbasic_block_t *handle_if_statement(block_t *parent, basic_block_t *bb)\n{\n basic_block_t *n = bb_create(parent);\n bb_connect(bb, n, NEXT);\n bb = n;\n\n lex_expect(T_open_bracket);\n read_expr(parent, &bb);\n lex_expect(T_close_bracket);\n\n var_t *vd = opstack_pop();\n add_insn(parent, bb, OP_branch, NULL, vd, NULL, 0, NULL);\n\n basic_block_t *then_ = bb_create(parent);\n basic_block_t *else_ = bb_create(parent);\n bb_connect(bb, then_, THEN);\n bb_connect(bb, else_, ELSE);\n\n basic_block_t *then_body = read_body_statement(parent, then_);\n basic_block_t *then_next_ = NULL;\n if (then_body) {\n then_next_ = bb_create(parent);\n bb_connect(then_body, then_next_, NEXT);\n }\n\n if (lex_accept(T_else)) {\n basic_block_t *else_body = read_body_statement(parent, else_);\n basic_block_t *else_next_ = NULL;\n if (else_body) {\n else_next_ = bb_create(parent);\n bb_connect(else_body, else_next_, NEXT);\n }\n\n if (then_next_ && else_next_) {\n basic_block_t *next_ = bb_create(parent);\n bb_connect(then_next_, next_, NEXT);\n bb_connect(else_next_, next_, NEXT);\n return next_;\n }\n\n return then_next_ ? then_next_ : else_next_;\n } else {\n if (then_next_) {\n bb_connect(else_, then_next_, NEXT);\n return then_next_;\n }\n return else_;\n }\n}\n\nbasic_block_t *handle_while_statement(block_t *parent, basic_block_t *bb)\n{\n basic_block_t *n = bb_create(parent);\n bb_connect(bb, n, NEXT);\n bb = n;\n\n continue_bb[continue_pos_idx++] = bb;\n\n basic_block_t *cond = bb;\n lex_expect(T_open_bracket);\n read_expr(parent, &bb);\n lex_expect(T_close_bracket);\n\n var_t *vd = opstack_pop();\n add_insn(parent, bb, OP_branch, NULL, vd, NULL, 0, NULL);\n\n basic_block_t *then_ = bb_create(parent);\n basic_block_t *else_ = bb_create(parent);\n bb_connect(bb, then_, THEN);\n bb_connect(bb, else_, ELSE);\n break_bb[break_exit_idx++] = else_;\n\n basic_block_t *body_ = read_body_statement(parent, then_);\n\n continue_pos_idx--;\n break_exit_idx--;\n\n if (body_)\n bb_connect(body_, cond, NEXT);\n\n return else_;\n}\n\nbasic_block_t *handle_goto_statement(block_t *parent, basic_block_t *bb)\n{\n /* Since a goto splits the current program into two basic blocks and makes\n * the subsequent basic block unreachable, this causes problems for later\n * CFG operations. Therefore, we create a fake if that always executes to\n * wrap the goto, and connect the unreachable basic block to the else\n * branch. Finally, return this else block.\n *\n * after:\n * a = b + c;\n * goto label;\n * c *= d;\n *\n * before:\n * a = b + c;\n * if (1)\n * goto label;\n * c *= d;\n */\n\n char token[MAX_ID_LEN];\n if (!lex_peek(T_identifier, token))\n error_at(\"Expected identifier after 'goto'\", next_token_loc());\n\n lex_expect(T_identifier);\n lex_expect(T_semicolon);\n\n basic_block_t *fake_if = bb_create(parent);\n bb_connect(bb, fake_if, NEXT);\n var_t *val = require_var(parent);\n gen_name_to(val->var_name);\n val->init_val = 1;\n add_insn(parent, fake_if, OP_load_constant, val, NULL, NULL, 0, NULL);\n add_insn(parent, fake_if, OP_branch, NULL, val, NULL, 0, NULL);\n\n basic_block_t *then_ = bb_create(parent);\n basic_block_t *else_ = bb_create(parent);\n bb_connect(fake_if, then_, THEN);\n bb_connect(fake_if, else_, ELSE);\n\n add_insn(parent, then_, OP_jump, NULL, NULL, NULL, 0, token);\n label_t *label = find_label(token);\n if (label) {\n label->used = true;\n bb_connect(then_, label->bb, NEXT);\n return else_;\n }\n\n if (backpatch_bb_idx > MAX_LABELS - 1)\n error_at(\"Too many forward-referenced labels\", cur_token_loc());\n\n backpatch_bb[backpatch_bb_idx++] = then_;\n return else_;\n}\n\nbasic_block_t *handle_struct_variable_decl(block_t *parent,\n basic_block_t *bb,\n char *token)\n{\n int find_type_flag = lex_accept(T_struct) ? 2 : 1;\n if (find_type_flag == 1 && lex_accept(T_union)) {\n find_type_flag = 2;\n }\n\n type_t *type = find_type(token, find_type_flag);\n if (!type)\n return bb;\n\n var_t *var = require_typed_var(parent, type);\n read_partial_var_decl(var, NULL);\n add_insn(parent, bb, OP_allocat, var, NULL, NULL, 0, NULL);\n add_symbol(bb, var);\n\n if (lex_accept(T_assign)) {\n if (lex_peek(T_open_curly, NULL) &&\n (var->array_size > 0 || var->ptr_level > 0)) {\n parse_array_init(var, parent, &bb, true);\n } else if (lex_peek(T_open_curly, NULL) &&\n (var->type->base_type == TYPE_struct ||\n var->type->base_type == TYPE_typedef)) {\n type_t *struct_type = var->type;\n if (struct_type->base_type == TYPE_typedef &&\n struct_type->base_struct)\n struct_type = struct_type->base_struct;\n\n var_t *struct_addr = require_var(parent);\n gen_name_to(struct_addr->var_name);\n add_insn(parent, bb, OP_address_of, struct_addr, var, NULL, 0,\n NULL);\n\n lex_expect(T_open_curly);\n parse_struct_field_init(parent, &bb, struct_type, struct_addr,\n true);\n lex_expect(T_close_curly);\n } else {\n read_expr(parent, &bb);\n read_ternary_operation(parent, &bb);\n var_t *rs1 = resize_var(parent, &bb, opstack_pop(), var);\n add_insn(parent, bb, OP_assign, var, rs1, NULL, 0, NULL);\n }\n }\n\n while (lex_accept(T_comma)) {\n var_t *nv = require_typed_var(parent, type);\n read_inner_var_decl(nv, false, false);\n add_insn(parent, bb, OP_allocat, nv, NULL, NULL, 0, NULL);\n add_symbol(bb, nv);\n if (lex_accept(T_assign)) {\n if (lex_peek(T_open_curly, NULL) &&\n (nv->array_size > 0 || nv->ptr_level > 0)) {\n parse_array_init(nv, parent, &bb, true);\n } else if (lex_peek(T_open_curly, NULL) &&\n (nv->type->base_type == TYPE_struct ||\n nv->type->base_type == TYPE_typedef)) {\n type_t *struct_type = nv->type;\n if (struct_type->base_type == TYPE_typedef &&\n struct_type->base_struct)\n struct_type = struct_type->base_struct;\n\n var_t *struct_addr = require_var(parent);\n gen_name_to(struct_addr->var_name);\n add_insn(parent, bb, OP_address_of, struct_addr, nv, NULL, 0,\n NULL);\n\n lex_expect(T_open_curly);\n parse_struct_field_init(parent, &bb, struct_type, struct_addr,\n 1);\n lex_expect(T_close_curly);\n } else {\n read_expr(parent, &bb);\n read_ternary_operation(parent, &bb);\n var_t *rs1 = resize_var(parent, &bb, opstack_pop(), nv);\n add_insn(parent, bb, OP_assign, nv, rs1, NULL, 0, NULL);\n }\n }\n }\n\n lex_expect(T_semicolon);\n return bb;\n}\n\nvoid parse_array_init(var_t *var,\n block_t *parent,\n basic_block_t **bb,\n bool emit_code)\n{\n int elem_size = var->type->size;\n int count = 0;\n var_t *base_addr = NULL;\n var_t *stored_vals[256];\n bool is_implicit = (var->array_size == 0);\n\n if (emit_code)\n base_addr = var;\n\n lex_expect(T_open_curly);\n if (!lex_peek(T_close_curly, NULL)) {\n for (;;) {\n var_t *val = NULL;\n\n if (lex_peek(T_open_curly, NULL) &&\n (var->type->base_type == TYPE_struct ||\n var->type->base_type == TYPE_typedef)) {\n type_t *struct_type = var->type;\n if (struct_type->base_type == TYPE_typedef &&\n struct_type->base_struct)\n struct_type = struct_type->base_struct;\n\n if (emit_code) {\n var_t *elem_addr = compute_element_address(\n parent, bb, base_addr, count, elem_size);\n lex_expect(T_open_curly);\n parse_struct_field_init(parent, bb, struct_type, elem_addr,\n emit_code);\n lex_expect(T_close_curly);\n val = NULL;\n } else {\n lex_expect(T_open_curly);\n while (!lex_peek(T_close_curly, NULL)) {\n if (parent == GLOBAL_BLOCK) {\n consume_global_constant_syntax();\n } else {\n read_expr(parent, bb);\n read_ternary_operation(parent, bb);\n opstack_pop();\n }\n if (!lex_accept(T_comma))\n break;\n if (lex_peek(T_close_curly, NULL))\n break;\n }\n lex_expect(T_close_curly);\n val = NULL;\n }\n } else {\n if (parent == GLOBAL_BLOCK) {\n consume_global_constant_syntax();\n val = NULL;\n } else {\n read_expr(parent, bb);\n read_ternary_operation(parent, bb);\n val = opstack_pop();\n }\n }\n\n if (is_implicit && emit_code && count < 256)\n stored_vals[count] = val;\n\n if (val && emit_code && !is_implicit && count < var->array_size) {\n var_t target = {0};\n target.type = var->type;\n target.ptr_level = 0;\n var_t *v = resize_var(parent, bb, val, &target);\n\n var_t *elem_addr = compute_element_address(\n parent, bb, base_addr, count, elem_size);\n\n if (elem_size <= 4) {\n add_insn(parent, *bb, OP_write, NULL, elem_addr, v,\n elem_size, NULL);\n } else {\n fatal(\"Unsupported: struct assignment > 4 bytes in array\");\n }\n }\n\n count++;\n if (!lex_accept(T_comma))\n break;\n if (lex_peek(T_close_curly, NULL))\n break;\n }\n }\n\n if (parent != GLOBAL_BLOCK && emit_code && !is_implicit) {\n /* e.g.:\n *\n * 1.\n * int main()\n * {\n * int a[5] = {};\n * return a[0] + a[1] + a[2] + a[3] + a[4];\n * }\n *\n * 2.\n * int main()\n * {\n * int a[5] = {5, 10}\n * return a[0] + a[1] + a[2] + a[3] + a[4];\n * }\n *\n * The initializer should set the value of the first elements, and\n * initialize other elements without explicit assignments to 0.\n *\n * Therefore, the first and second cases return 0 and 15, respectively.\n * */\n for (; count < var->array_size; count++) {\n var_t *val = require_var(parent);\n gen_name_to(val->var_name);\n val->init_val = 0;\n add_insn(parent, *bb, OP_load_constant, val, NULL, NULL, 0, NULL);\n\n var_t target = {0};\n target.type = var->type;\n target.ptr_level = 0;\n var_t *v = resize_var(parent, bb, val, &target);\n\n var_t *elem_addr = compute_element_address(parent, bb, base_addr,\n count, elem_size);\n\n if (elem_size <= 4) {\n add_insn(parent, *bb, OP_write, NULL, elem_addr, v, elem_size,\n NULL);\n } else {\n fatal(\"Unsupported: struct assignment > 4 bytes in array\");\n }\n }\n }\n lex_expect(T_close_curly);\n\n if (is_implicit) {\n if (var->ptr_level > 0)\n var->ptr_level = 0;\n var->array_size = count;\n\n if (emit_code && count > 0) {\n base_addr = var;\n\n for (int i = 0; i < count && i < 256; i++) {\n if (!stored_vals[i])\n continue;\n var_t target = {0};\n target.type = var->type;\n target.ptr_level = 0;\n var_t *v = resize_var(parent, bb, stored_vals[i], &target);\n\n var_t *elem_addr = compute_element_address(\n parent, bb, base_addr, i, elem_size);\n\n add_insn(parent, *bb, OP_write, NULL, elem_addr, v, elem_size,\n NULL);\n }\n }\n }\n}\n\nvoid parse_array_compound_literal(var_t *var,\n block_t *parent,\n basic_block_t **bb)\n{\n int elem_size = var->type->size;\n int count = 0;\n var->array_size = 0;\n var->init_val = 0;\n if (!lex_peek(T_close_curly, NULL)) {\n for (;;) {\n read_expr(parent, bb);\n read_ternary_operation(parent, bb);\n var_t *value = opstack_pop();\n if (count == 0)\n var->init_val = value->init_val;\n\n var_t target = {0};\n target.type = var->type;\n target.ptr_level = 0;\n var_t *store_val = resize_var(parent, bb, value, &target);\n var_t *elem_addr =\n compute_element_address(parent, bb, var, count, elem_size);\n add_insn(parent, *bb, OP_write, NULL, elem_addr, store_val,\n elem_size, NULL);\n\n count++;\n if (!lex_accept(T_comma))\n break;\n if (lex_peek(T_close_curly, NULL))\n break;\n }\n }\n\n lex_expect(T_close_curly);\n var->array_size = count;\n}\n/* Identify compiler-emitted temporaries that hold array compound literals.\n * They keep array metadata without pointer indirection and are marked via\n * is_compound_literal when synthesized.\n */\nbool is_array_literal_placeholder(var_t *var)\n{\n return var && var->array_size > 0 && !var->ptr_level &&\n var->is_compound_literal;\n}\n\nbool is_pointer_like_value(var_t *var)\n{\n return var && (var->ptr_level || var->array_size ||\n (var->type && var->type->ptr_level > 0));\n}\n\n/* Lower a compiler-emitted array literal placeholder (marked via\n * is_compound_literal) into a scalar temporary when later IR expects a plain\n * value instead of addressable storage. This keeps SSA joins uniform when only\n * one branch originates from an array literal.\n */\nvar_t *scalarize_array_literal(block_t *parent,\n basic_block_t **bb,\n var_t *array_var,\n type_t *hint_type)\n{\n if (!is_array_literal_placeholder(array_var))\n return array_var;\n\n /* Array literal placeholders carry the literal's natural type; default to\n * int when the parser left the type unset.\n */\n type_t *literal_type = array_var->type ? array_var->type : TY_int;\n int literal_size = literal_type->size;\n if (literal_size <= 0)\n literal_size = TY_int->size;\n\n /* A caller-provided hint (e.g., assignment target) dictates the result\n * type when available so we reuse wider/narrower scalar destinations.\n */\n type_t *result_type = hint_type ? hint_type : literal_type;\n if (!result_type)\n result_type = TY_int;\n\n /* Create a new scalar temporary, giving it a unique name and copying over\n * the literal data so downstream code can treat it like a normal value.\n */\n var_t *scalar = require_typed_var(parent, result_type);\n scalar->ptr_level = 0;\n gen_name_to(scalar->var_name);\n scalar->init_val = array_var->init_val;\n\n /* Materialize the literal data into the scalar temporary via an OP_read. */\n add_insn(parent, *bb, OP_read, scalar, array_var, NULL, literal_size, NULL);\n\n return scalar;\n}\n\n/* Centralized guard for lowering array literal placeholders when a scalar\n * value is expected, keeping the scattered special cases consistent.\n */\nvar_t *scalarize_array_literal_if_needed(block_t *parent,\n basic_block_t **bb,\n var_t *value,\n type_t *hint_type,\n bool needs_scalar)\n{\n if (!needs_scalar)\n return value;\n\n return scalarize_array_literal(parent, bb, value, hint_type);\n}\n\nvoid read_inner_var_decl(var_t *vd, bool anon, bool is_param)\n{\n /* Preserve typedef pointer level - don't reset if already inherited */\n vd->init_val = 0;\n if (is_param) {\n /* However, if the parsed variable is a function parameter,\n * reset its pointer level to zero.\n */\n vd->ptr_level = 0;\n }\n\n while (lex_accept(T_asterisk)) {\n vd->ptr_level++;\n /* Check for const after asterisk (e.g., int * const ptr).\n * For now, we just consume const qualifiers after pointer.\n * Full support would require tracking const-ness of the pointer\n * itself vs the pointed-to data separately.\n */\n while (lex_peek(T_const, NULL))\n lex_accept(T_const);\n }\n\n /* is it function pointer declaration? */\n if (lex_accept(T_open_bracket)) {\n func_t func;\n char temp_name[MAX_VAR_LEN];\n lex_expect(T_asterisk);\n lex_ident(T_identifier, temp_name);\n strcpy(vd->var_name, intern_string(temp_name));\n lex_expect(T_close_bracket);\n read_parameter_list_decl(&func, true);\n vd->is_func = true;\n } else {\n if (!anon) {\n char temp_name[MAX_VAR_LEN];\n lex_ident(T_identifier, temp_name);\n strcpy(vd->var_name, intern_string(temp_name));\n if (!lex_peek(T_open_bracket, NULL) && !is_param) {\n if (vd->is_global) {\n opstack_push(vd);\n }\n }\n }\n if (lex_accept(T_open_square)) {\n char buffer[10];\n\n /* array with size */\n if (lex_peek(T_numeric, buffer)) {\n vd->array_size = parse_numeric_constant(buffer);\n vd->array_dim1 = vd->array_size; /* Store first dimension */\n lex_expect(T_numeric);\n } else {\n /* array without size:\n * regarded as a pointer although could be nested\n */\n vd->ptr_level++;\n }\n lex_expect(T_close_square);\n\n /* Handle multi-dimensional arrays: int matrix[3][4] becomes array\n * of 3*4=12 elements\n */\n if (lex_accept(T_open_square)) {\n if (lex_peek(T_numeric, buffer)) {\n int next_dim = parse_numeric_constant(buffer);\n lex_expect(T_numeric);\n vd->array_dim2 = next_dim; /* Store second dimension */\n if (vd->array_size > 0) {\n vd->array_size *=\n next_dim; /* multiply dimensions together */\n } else {\n vd->array_size = next_dim;\n }\n } else {\n vd->ptr_level++;\n }\n lex_expect(T_close_square);\n\n /* For now, only support 2D arrays */\n while (lex_accept(T_open_square)) {\n if (lex_peek(T_numeric, buffer)) {\n int next_dim = parse_numeric_constant(buffer);\n lex_expect(T_numeric);\n if (vd->array_size > 0) {\n vd->array_size *= next_dim;\n } else {\n vd->array_size = next_dim;\n }\n } else {\n vd->ptr_level++;\n }\n lex_expect(T_close_square);\n }\n }\n } else {\n vd->array_size = 0;\n vd->array_dim1 = 0;\n vd->array_dim2 = 0;\n }\n vd->is_func = false;\n }\n}\n\n/* starting next_token, need to check the type */\nvoid read_full_var_decl(var_t *vd, bool anon, bool is_param)\n{\n char type_name[MAX_TYPE_LEN];\n int find_type_flag = lex_accept(T_struct) ? 2 : 1;\n if (find_type_flag == 1 && lex_accept(T_union)) {\n find_type_flag = 2;\n }\n lex_ident(T_identifier, type_name);\n type_t *type = find_type(type_name, find_type_flag);\n\n if (!type) {\n printf(\"Could not find type %s%s\\n\",\n find_type_flag == 2 ? \"struct/union \" : \"\", type_name);\n abort();\n }\n\n vd->type = type;\n\n read_inner_var_decl(vd, anon, is_param);\n}\n\n/* starting next_token, need to check the type */\nvoid read_partial_var_decl(var_t *vd, var_t *template)\n{\n read_inner_var_decl(vd, false, false);\n}\n\nvoid read_parameter_list_decl(func_t *func, bool anon)\n{\n int vn = 0;\n lex_expect(T_open_bracket);\n\n char token[MAX_TYPE_LEN];\n if (lex_peek(T_identifier, token) && !strncmp(token, \"void\", 4)) {\n lex_next();\n if (lex_accept(T_close_bracket))\n return;\n func->param_defs[vn].type = TY_void;\n read_inner_var_decl(&func->param_defs[vn], anon, true);\n if (!func->param_defs[vn].ptr_level && !func->param_defs[vn].is_func &&\n !func->param_defs[vn].array_size)\n error_at(\"'void' must be the only parameter and unnamed\",\n cur_token_loc());\n vn++;\n lex_accept(T_comma);\n }\n\n while (lex_peek(T_identifier, NULL) || lex_peek(T_const, NULL)) {\n /* Check for const qualifier */\n bool is_const = false;\n if (lex_accept(T_const))\n is_const = true;\n\n read_full_var_decl(&func->param_defs[vn], anon, true);\n func->param_defs[vn].is_const_qualified = is_const;\n vn++;\n lex_accept(T_comma);\n }\n func->num_params = vn;\n\n /* Up to 'MAX_PARAMS' parameters are accepted for the variadic function. */\n if (lex_accept(T_elipsis))\n func->va_args = 1;\n\n lex_expect(T_close_bracket);\n}\n\nvoid read_literal_param(block_t *parent, basic_block_t *bb)\n{\n char literal[MAX_TOKEN_LEN], unescaped[MAX_TOKEN_LEN],\n combined[MAX_LINE_LEN];\n int combined_len = 0;\n\n /* Read first string literal */\n lex_ident(T_string, literal);\n unescape_string(literal, combined, MAX_LINE_LEN);\n combined_len = strlen(combined);\n\n /* Check for adjacent string literals and concatenate them */\n while (lex_peek(T_string, NULL)) {\n lex_ident(T_string, literal);\n unescape_string(literal, unescaped, MAX_LINE_LEN - combined_len);\n int unescaped_len = strlen(unescaped);\n if (combined_len + unescaped_len >= MAX_LINE_LEN - 1)\n error_at(\"Concatenated string literal too long\", cur_token_loc());\n\n strcpy(combined + combined_len, unescaped);\n combined_len += unescaped_len;\n }\n\n const int index = write_symbol(combined);\n\n var_t *vd = require_typed_ptr_var(parent, TY_char, true);\n gen_name_to(vd->var_name);\n vd->init_val = index;\n opstack_push(vd);\n /* String literals are now in .rodata section */\n add_insn(parent, bb, OP_load_rodata_address, vd, NULL, NULL, 0, NULL);\n}\n\nvoid read_numeric_param(block_t *parent, basic_block_t *bb, bool is_neg)\n{\n char token[MAX_ID_LEN];\n int value = 0;\n int i = 0;\n char c;\n\n lex_ident(T_numeric, token);\n\n if (token[0] == '-') {\n is_neg = !is_neg;\n i++;\n }\n if (token[0] == '0') {\n if ((token[1] | 32) == 'x') { /* hexdecimal */\n i = 2;\n do {\n c = token[i++];\n if (isdigit(c))\n c -= '0';\n else {\n c |= 32; /* convert to lower case */\n if (c >= 'a' && c <= 'f')\n c = (c - 'a') + 10;\n else\n error_at(\"Invalid numeric constant\", cur_token_loc());\n }\n\n value = (value * 16) + c;\n } while (isxdigit(token[i]));\n } else if ((token[1] | 32) == 'b') { /* binary */\n i = 2;\n do {\n c = token[i++];\n if (c != '0' && c != '1')\n error_at(\"Invalid binary constant\", cur_token_loc());\n c -= '0';\n value = (value * 2) + c;\n } while (token[i] == '0' || token[i] == '1');\n } else { /* octal */\n do {\n c = token[i++];\n if (c > '7')\n error_at(\"Invalid numeric constant\", cur_token_loc());\n c -= '0';\n value = (value * 8) + c;\n } while (isdigit(token[i]));\n }\n } else {\n do {\n c = token[i++] - '0';\n value = (value * 10) + c;\n } while (isdigit(token[i]));\n }\n\n if (is_neg)\n value = -value;\n\n var_t *vd = require_var(parent);\n gen_name_to(vd->var_name);\n vd->init_val = value;\n opstack_push(vd);\n add_insn(parent, bb, OP_load_constant, vd, NULL, NULL, 0, NULL);\n}\n\nvoid read_char_param(block_t *parent, basic_block_t *bb)\n{\n char literal[MAX_TOKEN_LEN], unescaped[MAX_TOKEN_LEN];\n\n lex_ident(T_char, literal);\n unescape_string(literal, unescaped, MAX_TOKEN_LEN);\n\n var_t *vd = require_typed_var(parent, TY_char);\n gen_name_to(vd->var_name);\n vd->init_val = unescaped[0];\n opstack_push(vd);\n add_insn(parent, bb, OP_load_constant, vd, NULL, NULL, 0, NULL);\n}\n\nvoid read_logical(opcode_t op, block_t *parent, basic_block_t **bb);\nvoid read_func_parameters(func_t *func, block_t *parent, basic_block_t **bb)\n{\n int param_num = 0;\n var_t *params[MAX_PARAMS], *param;\n\n lex_expect(T_open_bracket);\n while (!lex_accept(T_close_bracket)) {\n read_expr(parent, bb);\n read_ternary_operation(parent, bb);\n\n param = opstack_pop();\n if (func && param_num < func->num_params) {\n var_t *target = &func->param_defs[param_num];\n if (!target->ptr_level && !target->array_size)\n param =\n scalarize_array_literal(parent, bb, param, target->type);\n }\n /* Handle parameter type conversion for direct calls.\n * Indirect calls currently don't provide function instance.\n */\n if (func && param_num >= func->num_params && func->va_args) {\n /* Default promotions apply to scalar varargs, but pointer-like\n * values (including array literals) must flow through unchanged so\n * \"%p\" and friends see an address rather than a scalarized value.\n */\n if (!is_pointer_like_value(param))\n param = promote(parent, bb, param, TY_int, 0);\n } else if (func) {\n param = resize_var(parent, bb, param, &func->param_defs[param_num]);\n }\n\n params[param_num++] = param;\n lex_accept(T_comma);\n }\n\n for (int i = 0; i < param_num; i++) {\n /* The operand should keep alive before calling function. Pass the\n * number of remained parameters to allocator to extend their liveness.\n */\n add_insn(parent, *bb, OP_push, NULL, params[i], NULL, param_num - i,\n NULL);\n }\n}\n\nvoid read_func_call(func_t *func, block_t *parent, basic_block_t **bb)\n{\n /* direct function call */\n read_func_parameters(func, parent, bb);\n\n add_insn(parent, *bb, OP_call, NULL, NULL, NULL, 0,\n func->return_def.var_name);\n}\n\nvoid read_indirect_call(block_t *parent, basic_block_t **bb)\n{\n /* Note: Indirect calls use generic parameter handling */\n read_func_parameters(NULL, parent, bb);\n\n add_insn(parent, *bb, OP_indirect, NULL, opstack_pop(), NULL, 0, NULL);\n}\n\nvoid read_lvalue(lvalue_t *lvalue,\n var_t *var,\n block_t *parent,\n basic_block_t **bb,\n bool eval,\n opcode_t op);\n\n/* Maintain a stack of expression values and operators, depending on next\n * operators' priority. Either apply it or operator on stack first.\n */\nvoid handle_address_of_operator(block_t *parent, basic_block_t **bb)\n{\n char token[MAX_VAR_LEN];\n lvalue_t lvalue;\n var_t *vd, *rs1;\n\n lex_peek(T_identifier, token);\n var_t *var = find_var(token, parent);\n read_lvalue(&lvalue, var, parent, bb, false, OP_generic);\n\n if (!lvalue.is_reference) {\n rs1 = opstack_pop();\n vd = require_ref_var(parent, lvalue.type, lvalue.ptr_level);\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_address_of, vd, rs1, NULL, 0, NULL);\n }\n}\n\nvoid handle_single_dereference(block_t *parent, basic_block_t **bb)\n{\n var_t *vd, *rs1;\n int sz;\n\n if (lex_peek(T_open_bracket, NULL)) {\n /* Handle general expression dereference: *(expr) */\n lex_expect(T_open_bracket);\n read_expr(parent, bb);\n lex_expect(T_close_bracket);\n\n rs1 = opstack_pop();\n /* For pointer dereference, we need to determine the target type and\n * size. Since we do not have full type tracking in expressions, use\n * defaults\n */\n type_t *deref_type = rs1->type ? rs1->type : TY_int;\n int deref_ptr = rs1->ptr_level > 0 ? rs1->ptr_level - 1 : 0;\n\n vd = require_deref_var(parent, deref_type, deref_ptr);\n if (deref_ptr > 0)\n sz = PTR_SIZE;\n else\n sz = deref_type->size;\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_read, vd, rs1, NULL, sz, NULL);\n } else {\n /* Handle simple identifier dereference: *var */\n char token[MAX_VAR_LEN];\n lvalue_t lvalue;\n\n lex_peek(T_identifier, token);\n var_t *var = find_var(token, parent);\n read_lvalue(&lvalue, var, parent, bb, true, OP_generic);\n\n rs1 = opstack_pop();\n vd = require_deref_var(parent, var->type, var->ptr_level);\n if (lvalue.ptr_level > 1)\n sz = PTR_SIZE;\n else {\n /* For typedef pointers, get the size of the pointed-to type */\n if (lvalue.type && lvalue.type->ptr_level > 0) {\n /* This is a typedef pointer */\n switch (lvalue.type->base_type) {\n case TYPE_char:\n sz = TY_char->size;\n break;\n case TYPE_short:\n sz = TY_short->size;\n break;\n case TYPE_int:\n sz = TY_int->size;\n break;\n case TYPE_void:\n sz = 1;\n break;\n default:\n sz = lvalue.type->size;\n break;\n }\n } else {\n sz = lvalue.type->size;\n }\n }\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_read, vd, rs1, NULL, sz, NULL);\n }\n}\n\nvoid handle_multiple_dereference(block_t *parent, basic_block_t **bb)\n{\n var_t *vd, *rs1;\n int sz;\n\n /* Handle consecutive asterisks for multiple dereference: **pp, ***ppp,\n * ***(expr) */\n int deref_count = 1; /* We already consumed one asterisk */\n while (lex_accept(T_asterisk))\n deref_count++;\n\n /* Check if we have a parenthesized expression or simple identifier */\n if (lex_peek(T_open_bracket, NULL)) {\n /* Handle ***(expr) case */\n lex_expect(T_open_bracket);\n read_expr(parent, bb);\n lex_expect(T_close_bracket);\n\n /* Apply dereferences one by one */\n for (int i = 0; i < deref_count; i++) {\n rs1 = opstack_pop();\n /* For expression dereference, use default type info */\n type_t *deref_type = rs1->type ? rs1->type : TY_int;\n int deref_ptr = rs1->ptr_level > 0 ? rs1->ptr_level - 1 : 0;\n\n vd = require_deref_var(parent, deref_type, deref_ptr);\n if (deref_ptr > 0)\n sz = PTR_SIZE;\n else\n sz = deref_type->size;\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_read, vd, rs1, NULL, sz, NULL);\n }\n } else {\n /* Handle **pp, ***ppp case with simple identifier */\n char token[MAX_VAR_LEN];\n lvalue_t lvalue;\n\n lex_peek(T_identifier, token);\n var_t *var = find_var(token, parent);\n read_lvalue(&lvalue, var, parent, bb, true, OP_generic);\n\n /* Apply dereferences one by one */\n for (int i = 0; i < deref_count; i++) {\n rs1 = opstack_pop();\n vd = require_deref_var(\n parent, var->type,\n lvalue.ptr_level > i ? lvalue.ptr_level - i - 1 : 0);\n if (lvalue.ptr_level > i + 1)\n sz = PTR_SIZE;\n else {\n /* For typedef pointers, get the size of the pointed-to type */\n if (lvalue.type && lvalue.type->ptr_level > 0 &&\n i == deref_count - 1) {\n /* This is a typedef pointer on the final dereference */\n switch (lvalue.type->base_type) {\n case TYPE_char:\n sz = TY_char->size;\n break;\n case TYPE_short:\n sz = TY_short->size;\n break;\n case TYPE_int:\n sz = TY_int->size;\n break;\n case TYPE_void:\n sz = 1;\n break;\n default:\n sz = lvalue.type->size;\n break;\n }\n } else {\n sz = lvalue.type->size;\n }\n }\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_read, vd, rs1, NULL, sz, NULL);\n }\n }\n}\n\nvoid handle_sizeof_operator(block_t *parent, basic_block_t **bb)\n{\n char token[MAX_TYPE_LEN];\n int ptr_cnt = 0;\n token_t *sizeof_tk = cur_token;\n type_t *type = NULL;\n var_t *vd;\n\n lex_expect(T_open_bracket);\n\n /* Check if this is sizeof(type) or sizeof(expression) */\n int find_type_flag = lex_accept(T_struct) ? 2 : 1;\n if (find_type_flag == 1 && lex_accept(T_union))\n find_type_flag = 2;\n\n if (lex_peek(T_identifier, token)) {\n /* Try to parse as a type first */\n type = find_type(token, find_type_flag);\n if (type) {\n /* sizeof(type) */\n lex_expect(T_identifier);\n while (lex_accept(T_asterisk))\n ptr_cnt++;\n }\n }\n\n if (!type) {\n /* sizeof(expression) - parse the expression and get its type */\n read_expr(parent, bb);\n read_ternary_operation(parent, bb);\n var_t *expr_var = opstack_pop();\n type = expr_var->type;\n ptr_cnt = expr_var->ptr_level;\n }\n\n if (!type)\n error_at(\"Unable to determine type in sizeof\", &sizeof_tk->location);\n\n vd = require_var(parent);\n vd->init_val = ptr_cnt ? PTR_SIZE : type->size;\n gen_name_to(vd->var_name);\n opstack_push(vd);\n lex_expect(T_close_bracket);\n add_insn(parent, *bb, OP_load_constant, vd, NULL, NULL, 0, NULL);\n}\n\nvoid read_expr_operand(block_t *parent, basic_block_t **bb)\n{\n var_t *vd, *rs1;\n bool is_neg = false;\n\n if (lex_accept(T_minus)) {\n is_neg = true;\n if (!lex_peek(T_numeric, NULL) && !lex_peek(T_identifier, NULL) &&\n !lex_peek(T_open_bracket, NULL)) {\n error_at(\"Unexpected token after unary minus\", next_token_loc());\n }\n }\n\n if (lex_peek(T_string, NULL))\n read_literal_param(parent, *bb);\n else if (lex_peek(T_char, NULL))\n read_char_param(parent, *bb);\n\n else if (lex_peek(T_numeric, NULL))\n read_numeric_param(parent, *bb, is_neg);\n else if (lex_accept(T_log_not)) {\n read_expr_operand(parent, bb);\n\n rs1 = opstack_pop();\n\n /* Constant folding for logical NOT */\n if (rs1 && rs1->is_const && !rs1->ptr_level && !rs1->is_global) {\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n vd->is_const = true;\n vd->init_val = !rs1->init_val;\n opstack_push(vd);\n add_insn(parent, *bb, OP_load_constant, vd, NULL, NULL, 0, NULL);\n } else {\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_log_not, vd, rs1, NULL, 0, NULL);\n }\n } else if (lex_accept(T_bit_not)) {\n read_expr_operand(parent, bb);\n\n rs1 = opstack_pop();\n\n /* Constant folding for bitwise NOT */\n if (rs1 && rs1->is_const && !rs1->ptr_level && !rs1->is_global) {\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n vd->is_const = true;\n vd->init_val = ~rs1->init_val;\n opstack_push(vd);\n add_insn(parent, *bb, OP_load_constant, vd, NULL, NULL, 0, NULL);\n } else {\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_bit_not, vd, rs1, NULL, 0, NULL);\n }\n } else if (lex_accept(T_ampersand)) {\n handle_address_of_operator(parent, bb);\n } else if (lex_accept(T_asterisk)) {\n /* dereference */\n if (lex_peek(T_asterisk, NULL)) {\n handle_multiple_dereference(parent, bb);\n } else {\n handle_single_dereference(parent, bb);\n }\n } else if (lex_accept(T_open_bracket)) {\n /* Check if this is a cast, compound literal, or parenthesized\n * expression */\n char lookahead_token[MAX_TYPE_LEN];\n bool is_compound_literal = false;\n bool is_cast = false;\n type_t *cast_or_literal_type = NULL;\n int cast_ptr_level = 0;\n\n /* Look ahead to see if we have a typename followed by ) */\n if (lex_peek(T_identifier, lookahead_token)) {\n /* Check if it's a basic type or typedef */\n type_t *type = find_type(lookahead_token, true);\n\n if (type) {\n /* Save current position to backtrack if needed */\n token_t *saved_token = cur_token;\n\n /* Try to parse as typename */\n lex_expect(T_identifier);\n\n /* Check for pointer types: int*, char*, etc. */\n int ptr_level = 0;\n while (lex_accept(T_asterisk)) {\n ptr_level++;\n }\n\n /* Check for array brackets: [size] or [] */\n bool is_array = false;\n if (lex_accept(T_open_square)) {\n is_array = true;\n /* Skip array size if present */\n if (lex_peek(T_numeric, NULL)) {\n char size_buffer[10];\n lex_ident(T_numeric, size_buffer);\n }\n lex_expect(T_close_square);\n }\n\n /* Check what follows the closing ) */\n if (lex_accept(T_close_bracket)) {\n if (lex_peek(T_open_curly, NULL)) {\n /* (type){...} - compound literal */\n is_compound_literal = true;\n cast_or_literal_type = type;\n cast_ptr_level = ptr_level;\n /* Store is_array flag in cast_ptr_level if it's an\n * array\n */\n if (is_array) {\n /* Special marker for array compound literal */\n cast_ptr_level = -1;\n }\n } else {\n /* (type)expr - cast expression */\n is_cast = true;\n cast_or_literal_type = type;\n cast_ptr_level = ptr_level;\n }\n } else {\n /* Not a cast or compound literal - backtrack */\n cur_token = saved_token;\n }\n }\n }\n\n if (is_cast) {\n /* Process cast: (type)expr */\n /* Parse the expression to be cast */\n read_expr_operand(parent, bb);\n\n /* Get the expression result */\n var_t *expr_var = opstack_pop();\n\n /* Create variable for cast result */\n var_t *cast_var = require_typed_ptr_var(\n parent, cast_or_literal_type, cast_ptr_level);\n gen_name_to(cast_var->var_name);\n\n /* Generate cast IR */\n add_insn(parent, *bb, OP_cast, cast_var, expr_var, NULL,\n cast_or_literal_type->size, NULL);\n\n /* Push the cast result */\n opstack_push(cast_var);\n\n } else if (is_compound_literal) {\n /* Process compound literal */\n lex_expect(T_open_curly);\n\n /* Create variable for compound literal result */\n var_t *compound_var =\n require_typed_var(parent, cast_or_literal_type);\n gen_name_to(compound_var->var_name);\n compound_var->is_compound_literal = true;\n\n /* Check if this is an array compound literal (int[]){...} */\n bool is_array_literal = (cast_ptr_level == -1);\n if (is_array_literal)\n cast_ptr_level = 0; /* Reset for normal processing */\n bool consumed_close_brace = false;\n /* Check if this is a pointer compound literal */\n if (is_array_literal) {\n compound_var->array_size = 0;\n add_insn(parent, *bb, OP_allocat, compound_var, NULL, NULL, 0,\n NULL);\n parse_array_compound_literal(compound_var, parent, bb);\n\n if (compound_var->array_size == 0) {\n compound_var->init_val = 0;\n add_insn(parent, *bb, OP_load_constant, compound_var, NULL,\n NULL, 0, NULL);\n }\n opstack_push(compound_var);\n consumed_close_brace = true;\n } else if (cast_ptr_level > 0) {\n /* Pointer compound literal: (int*){&x} */\n compound_var->ptr_level = cast_ptr_level;\n\n /* Parse the pointer value (should be an address) */\n if (!lex_peek(T_close_curly, NULL)) {\n read_expr(parent, bb);\n read_ternary_operation(parent, bb);\n var_t *ptr_val = opstack_pop();\n\n /* For pointer compound literals, store the address */\n compound_var->init_val = ptr_val->init_val;\n\n /* Consume additional values if present (for pointer arrays)\n */\n while (lex_accept(T_comma)) {\n if (lex_peek(T_close_curly, NULL))\n break;\n read_expr(parent, bb);\n read_ternary_operation(parent, bb);\n opstack_pop();\n }\n } else {\n /* Empty pointer compound literal: (int*){} */\n compound_var->init_val = 0; /* NULL pointer */\n }\n\n /* Generate code for pointer compound literal */\n opstack_push(compound_var);\n add_insn(parent, *bb, OP_load_constant, compound_var, NULL,\n NULL, 0, NULL);\n } else if (cast_or_literal_type->base_type == TYPE_struct ||\n cast_or_literal_type->base_type == TYPE_typedef) {\n /* Struct compound literal support (including typedef structs)\n */\n /* For typedef structs, the actual struct info is in the type */\n\n /* Initialize struct compound literal */\n compound_var->init_val = 0;\n compound_var->ptr_level = 0;\n\n /* Parse first field value */\n if (!lex_peek(T_close_curly, NULL)) {\n read_expr(parent, bb);\n read_ternary_operation(parent, bb);\n var_t *first_field = opstack_pop();\n compound_var->init_val = first_field->init_val;\n\n /* Consume additional fields if present */\n while (lex_accept(T_comma)) {\n if (lex_peek(T_close_curly, NULL)) {\n break;\n }\n read_expr(parent, bb);\n read_ternary_operation(parent, bb);\n opstack_pop(); /* Consume additional field values */\n }\n }\n\n /* Generate code for struct compound literal */\n opstack_push(compound_var);\n add_insn(parent, *bb, OP_load_constant, compound_var, NULL,\n NULL, 0, NULL);\n } else if (cast_or_literal_type->base_type == TYPE_int ||\n cast_or_literal_type->base_type == TYPE_short ||\n cast_or_literal_type->base_type == TYPE_char) {\n /* Handle empty compound literals */\n if (lex_peek(T_close_curly, NULL)) {\n /* Empty compound literal: (int){} */\n compound_var->init_val = 0;\n compound_var->array_size = 0;\n opstack_push(compound_var);\n add_insn(parent, *bb, OP_load_constant, compound_var, NULL,\n NULL, 0, NULL);\n } else if (lex_peek(T_numeric, NULL) ||\n lex_peek(T_identifier, NULL) ||\n lex_peek(T_char, NULL)) {\n /* Parse first element */\n read_expr(parent, bb);\n read_ternary_operation(parent, bb);\n\n /* Check if there are more elements (comma-separated) or if\n * it's an explicit array\n */\n if (lex_peek(T_comma, NULL) || is_array_literal) {\n /* Array compound literal: (int[]){1, 2, 3} */\n var_t *first_element = opstack_pop();\n\n /* Store elements temporarily */\n var_t *elements[256];\n elements[0] = first_element;\n int element_count = 1;\n\n /* Parse remaining elements */\n while (lex_accept(T_comma)) {\n if (lex_peek(T_close_curly, NULL))\n break; /* Trailing comma */\n\n read_expr(parent, bb);\n read_ternary_operation(parent, bb);\n if (element_count < 256) {\n elements[element_count] = opstack_pop();\n } else {\n opstack_pop(); /* Discard if too many */\n }\n element_count++;\n }\n\n /* Set array metadata */\n compound_var->array_size = element_count;\n compound_var->init_val = first_element->init_val;\n\n /* Allocate space for the array on stack */\n add_insn(parent, *bb, OP_allocat, compound_var, NULL,\n NULL, 0, NULL);\n\n /* Initialize each element */\n for (int i = 0; i < element_count && i < 256; i++) {\n if (!elements[i])\n continue;\n\n /* Store element at offset i * sizeof(element) */\n var_t *elem_offset = require_var(parent);\n elem_offset->init_val =\n i * cast_or_literal_type->size;\n gen_name_to(elem_offset->var_name);\n add_insn(parent, *bb, OP_load_constant, elem_offset,\n NULL, NULL, 0, NULL);\n\n /* Calculate address of element */\n var_t *elem_addr = require_var(parent);\n elem_addr->ptr_level = 1;\n gen_name_to(elem_addr->var_name);\n add_insn(parent, *bb, OP_add, elem_addr,\n compound_var, elem_offset, 0, NULL);\n\n /* Store the element value */\n add_insn(parent, *bb, OP_write, NULL, elem_addr,\n elements[i], cast_or_literal_type->size,\n NULL);\n }\n\n /* Store first element value for array-to-scalar */\n compound_var->init_val = first_element->init_val;\n\n /* Create result that provides first element access.\n * This enables array compound literals in scalar\n * contexts: int x = (int[]){1,2,3}; // x gets 1 int y\n * = 5 + (int[]){10}; // adds 5 + 10\n */\n var_t *result_var = require_var(parent);\n gen_name_to(result_var->var_name);\n result_var->type = compound_var->type;\n result_var->ptr_level = 0;\n result_var->array_size = 0;\n\n /* Read first element from the array */\n add_insn(parent, *bb, OP_read, result_var, compound_var,\n NULL, compound_var->type->size, NULL);\n opstack_push(result_var);\n } else {\n /* Single value: (int){42} - scalar compound literal */\n compound_var = opstack_pop();\n opstack_push(compound_var);\n }\n }\n }\n\n if (!consumed_close_brace)\n lex_expect(T_close_curly);\n } else {\n /* Regular parenthesized expression */\n read_expr(parent, bb);\n read_ternary_operation(parent, bb);\n lex_expect(T_close_bracket);\n }\n } else if (lex_accept(T_sizeof)) {\n handle_sizeof_operator(parent, bb);\n } else {\n /* function call, constant or variable - read token and determine */\n opcode_t prefix_op = OP_generic;\n char token[MAX_ID_LEN];\n\n if (lex_accept(T_increment))\n prefix_op = OP_add;\n else if (lex_accept(T_decrement))\n prefix_op = OP_sub;\n\n lex_peek(T_identifier, token);\n\n /* is a constant or variable? */\n constant_t *con = find_constant(token);\n var_t *var = find_var(token, parent);\n func_t *func = find_func(token);\n\n if (con) {\n vd = require_var(parent);\n vd->init_val = con->value;\n gen_name_to(vd->var_name);\n opstack_push(vd);\n lex_expect(T_identifier);\n add_insn(parent, *bb, OP_load_constant, vd, NULL, NULL, 0, NULL);\n } else if (var) {\n /* evalue lvalue expression */\n lvalue_t lvalue;\n read_lvalue(&lvalue, var, parent, bb, true, prefix_op);\n\n /* is it an indirect call with function pointer? */\n if (lex_peek(T_open_bracket, NULL)) {\n read_indirect_call(parent, bb);\n\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_func_ret, vd, NULL, NULL, 0, NULL);\n }\n } else if (func) {\n lex_expect(T_identifier);\n\n if (lex_peek(T_open_bracket, NULL)) {\n read_func_call(func, parent, bb);\n\n vd = require_typed_ptr_var(parent, func->return_def.type,\n func->return_def.ptr_level);\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_func_ret, vd, NULL, NULL, 0, NULL);\n } else {\n /* indirective function pointer assignment */\n vd = require_var(parent);\n vd->is_func = true;\n strcpy(vd->var_name, intern_string(token));\n opstack_push(vd);\n }\n } else if (lex_accept(T_open_curly)) {\n parse_array_literal_expr(parent, bb);\n } else {\n /* unknown expression */\n error_at(\"Unrecognized expression token\", next_token_loc());\n }\n\n if (is_neg) {\n rs1 = opstack_pop();\n\n /* Constant folding for negation */\n if (rs1 && rs1->is_const && !rs1->ptr_level && !rs1->is_global) {\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n vd->is_const = true;\n vd->init_val = -rs1->init_val;\n opstack_push(vd);\n add_insn(parent, *bb, OP_load_constant, vd, NULL, NULL, 0,\n NULL);\n } else {\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_negate, vd, rs1, NULL, 0, NULL);\n }\n }\n }\n}\n\nvoid finalize_logical(opcode_t op,\n block_t *parent,\n basic_block_t **bb,\n basic_block_t *shared_bb);\n\nbool is_logical(opcode_t op)\n{\n return op == OP_log_and || op == OP_log_or;\n}\n\n/* Helper function to calculate element size for pointer operations */\nint get_pointer_element_size(var_t *ptr_var)\n{\n int element_size = PTR_SIZE; /* Default to pointer size */\n\n if (!ptr_var || !ptr_var->type)\n return element_size;\n\n /* Direct pointer with type info */\n if (ptr_var->ptr_level && ptr_var->type)\n return ptr_var->type->size;\n\n /* Typedef pointer or array-derived pointer */\n if (ptr_var->type && ptr_var->type->ptr_level > 0) {\n switch (ptr_var->type->base_type) {\n case TYPE_char:\n return TY_char->size;\n case TYPE_short:\n return TY_short->size;\n case TYPE_int:\n return TY_int->size;\n case TYPE_void:\n return 1;\n default:\n return ptr_var->type->size ? ptr_var->type->size : PTR_SIZE;\n }\n }\n\n /* Array-derived pointer without ptr_level set */\n if (ptr_var->type) {\n switch (ptr_var->type->base_type) {\n case TYPE_char:\n return TY_char->size;\n case TYPE_short:\n return TY_short->size;\n case TYPE_int:\n return TY_int->size;\n case TYPE_void:\n return 1;\n default:\n return ptr_var->type->size ? ptr_var->type->size : PTR_SIZE;\n }\n }\n\n return element_size;\n}\n\n/* Helper function to handle pointer difference calculation */\nvoid handle_pointer_difference(block_t *parent,\n basic_block_t **bb,\n var_t *rs1,\n var_t *rs2)\n{\n /* First perform the subtraction to get byte difference */\n var_t *vd = require_var(parent);\n gen_name_to(vd->var_name);\n add_insn(parent, *bb, OP_sub, vd, rs1, rs2, 0, NULL);\n\n /* Determine element size for division */\n int element_size = get_pointer_element_size(rs1);\n\n /* Divide by element size to get element count */\n if (element_size > 1) {\n var_t *size_const = require_var(parent);\n gen_name_to(size_const->var_name);\n size_const->init_val = element_size;\n add_insn(parent, *bb, OP_load_constant, size_const, NULL, NULL, 0,\n NULL);\n\n var_t *result = require_var(parent);\n gen_name_to(result->var_name);\n add_insn(parent, *bb, OP_div, result, vd, size_const, 0, NULL);\n /* Push the result */\n opstack_push(result);\n } else {\n /* Element size is 1 (e.g., char), no division needed */\n opstack_push(vd);\n }\n}\n\n/* Helper function to handle pointer arithmetic (add/sub with scaling) */\nvoid handle_pointer_arithmetic(block_t *parent,\n basic_block_t **bb,\n opcode_t op,\n var_t *rs1,\n var_t *rs2)\n{\n var_t *ptr_var = NULL;\n var_t *int_var = NULL;\n int element_size = 0;\n\n /* Pointer arithmetic: differences (char*, int*, struct*, etc.),\n * addition/increment with scaling, and array indexing.\n */\n\n /* Check if both operands are pointers (pointer difference) */\n if (op == OP_sub) {\n /* If both are variables (not temporaries), look them up */\n var_t *orig_rs1 = rs1, *orig_rs2 = rs2;\n\n /* If they have names, they might be variable references - look them up\n */\n if (rs1->var_name[0] && !rs1->init_val) {\n var_t *found = find_var(rs1->var_name, parent);\n if (found)\n orig_rs1 = found;\n }\n if (rs2->var_name[0] && !rs2->init_val) {\n var_t *found = find_var(rs2->var_name, parent);\n if (found)\n orig_rs2 = found;\n }\n\n /* Check if both have ptr_level or typedef pointer type */\n bool rs1_is_ptr = is_pointer_like_value(orig_rs1);\n bool rs2_is_ptr = is_pointer_like_value(orig_rs2);\n\n /* If variable lookup failed, check the passed variables directly */\n if (!rs1_is_ptr)\n rs1_is_ptr = is_pointer_like_value(rs1);\n if (!rs2_is_ptr)\n rs2_is_ptr = is_pointer_like_value(rs2);\n\n if (rs1_is_ptr && rs2_is_ptr) {\n /* Both are pointers - this is pointer difference */\n /* Determine element size */\n element_size = PTR_SIZE; /* Default */\n\n /* Get element size from the first pointer */\n if (orig_rs1->type) {\n /* Check if this is a typedef pointer or regular pointer */\n if (orig_rs1->type->ptr_level > 0) {\n /* Typedef pointer - element size from base type */\n switch (orig_rs1->type->base_type) {\n case TYPE_char:\n element_size = 1;\n break;\n case TYPE_short:\n element_size = 2;\n break;\n case TYPE_int:\n element_size = 4;\n break;\n default:\n /* For struct/union typedef pointers, use the actual\n * type size\n */\n if (orig_rs1->type->size > 0)\n element_size = orig_rs1->type->size;\n break;\n }\n } else if (orig_rs1->ptr_level > 0) {\n /* Regular pointer (e.g., int *p) - type gives the base type\n */\n switch (orig_rs1->type->base_type) {\n case TYPE_char:\n element_size = 1;\n break;\n case TYPE_short:\n element_size = 2;\n break;\n case TYPE_int:\n element_size = 4;\n break;\n case TYPE_void:\n element_size = 1; /* void* arithmetic uses byte size */\n break;\n default:\n /* For struct pointers, use the struct size */\n element_size = orig_rs1->type->size;\n break;\n }\n }\n }\n\n /* Perform subtraction first */\n var_t *diff = require_var(parent);\n gen_name_to(diff->var_name);\n add_insn(parent, *bb, OP_sub, diff, rs1, rs2, 0, NULL);\n\n /* Then divide by element size if needed */\n if (element_size > 1) {\n var_t *size_const = require_var(parent);\n gen_name_to(size_const->var_name);\n size_const->init_val = element_size;\n add_insn(parent, *bb, OP_load_constant, size_const, NULL, NULL,\n 0, NULL);\n\n var_t *result = require_var(parent);\n gen_name_to(result->var_name);\n add_insn(parent, *bb, OP_div, result, diff, size_const, 0,\n NULL);\n opstack_push(result);\n } else {\n opstack_push(diff);\n }\n return;\n }\n }\n /* Determine which operand is the pointer for regular pointer arithmetic */\n if (is_pointer_like_value(rs1)) {\n ptr_var = rs1;\n int_var = rs2;\n element_size = get_pointer_element_size(rs1);\n } else if (is_pointer_like_value(rs2)) {\n /* Only for addition (p + n == n + p) */\n if (op == OP_add) {\n ptr_var = rs2;\n int_var = rs1;\n element_size = get_pointer_element_size(rs2);\n /* Swap operands so pointer is rs1 */\n rs1 = ptr_var;\n rs2 = int_var;\n }\n }\n\n /* If we need to scale the integer operand */\n if (ptr_var && element_size > 1) {\n /* Create multiplication by element size */\n var_t *size_const = require_var(parent);\n gen_name_to(size_const->var_name);\n size_const->init_val = element_size;\n add_insn(parent, *bb, OP_load_constant, size_const, NULL, NULL, 0,\n NULL);\n\n var_t *scaled = require_var(parent);\n gen_name_to(scaled->var_name);\n add_insn(parent, *bb, OP_mul, scaled, int_var, size_const, 0, NULL);\n\n /* Use scaled value as rs2 */\n rs2 = scaled;\n }\n\n /* Perform the operation */\n var_t *vd = require_var(parent);\n /* Preserve pointer type metadata on results of pointer arithmetic */\n if (ptr_var) {\n vd->type = ptr_var->type;\n vd->ptr_level = ptr_var->ptr_level;\n }\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, op, vd, rs1, rs2, 0, NULL);\n}\n\n/* Helper function to check if pointer arithmetic is needed */\nbool is_pointer_operation(opcode_t op, var_t *rs1, var_t *rs2)\n{\n if (op != OP_add && op != OP_sub)\n return false;\n\n return is_pointer_like_value(rs1) || is_pointer_like_value(rs2);\n}\n\n/* Helper function to check if a variable is a pointer based on its declaration\n */\nbool is_pointer_var(var_t *v, block_t *parent)\n{\n if (!v || !v->var_name[0])\n return false;\n\n /* Check if it has explicit ptr_level or type with ptr_level */\n if (v->ptr_level > 0 || (v->type && v->type->ptr_level > 0))\n return true;\n\n /* For variables that lost their type info during loading,\n * try to find the original declaration */\n var_t *orig = find_var(v->var_name, parent);\n if (orig &&\n (orig->ptr_level > 0 || (orig->type && orig->type->ptr_level > 0)))\n return true;\n\n return false;\n}\n\nvoid read_expr(block_t *parent, basic_block_t **bb)\n{\n var_t *vd, *rs1, *rs2;\n opcode_t oper_stack[10];\n int oper_stack_idx = 0;\n\n /* These variables used for parsing logical-and/or operation.\n *\n * For the logical-and operation, the false condition code path for testing\n * each operand uses the same code snippet (basic block).\n *\n * Likewise, when testing each operand for the logical-or operation, all of\n * them share a unified code path for the true condition.\n */\n bool has_prev_log_op = false;\n opcode_t prev_log_op = 0, pprev_log_op = 0;\n basic_block_t *log_and_shared_bb = bb_create(parent),\n *log_or_shared_bb = bb_create(parent);\n\n read_expr_operand(parent, bb);\n\n opcode_t op = get_operator();\n if (op == OP_generic || op == OP_ternary)\n return;\n if (is_logical(op)) {\n bb_connect(*bb, op == OP_log_and ? log_and_shared_bb : log_or_shared_bb,\n op == OP_log_and ? ELSE : THEN);\n read_logical(op, parent, bb);\n has_prev_log_op = true;\n prev_log_op = op;\n } else\n oper_stack[oper_stack_idx++] = op;\n read_expr_operand(parent, bb);\n op = get_operator();\n\n while (op != OP_generic && op != OP_ternary) {\n if (oper_stack_idx > 0) {\n int same = 0;\n do {\n opcode_t top_op = oper_stack[oper_stack_idx - 1];\n if (get_operator_prio(top_op) >= get_operator_prio(op)) {\n rs2 = opstack_pop();\n rs1 = opstack_pop();\n\n /* Handle pointer arithmetic for addition and subtraction */\n if (is_pointer_operation(top_op, rs1, rs2)) {\n /* handle_pointer_arithmetic handles both pointer\n * differences and regular pointer arithmetic internally\n */\n handle_pointer_arithmetic(parent, bb, top_op, rs1, rs2);\n oper_stack_idx--;\n continue;\n }\n\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, top_op, vd, rs1, rs2, 0, NULL);\n\n oper_stack_idx--;\n } else\n same = 1;\n } while (oper_stack_idx > 0 && same == 0);\n }\n if (is_logical(op)) {\n if (prev_log_op == 0 || prev_log_op == op) {\n bb_connect(\n *bb,\n op == OP_log_and ? log_and_shared_bb : log_or_shared_bb,\n op == OP_log_and ? ELSE : THEN);\n read_logical(op, parent, bb);\n prev_log_op = op;\n has_prev_log_op = true;\n } else if (prev_log_op == OP_log_and) {\n /* For example: a && b || c\n * previous opcode: prev_log_op == OP_log_and\n * current opcode: op == OP_log_or\n * current operand: b\n *\n * Finalize the logical-and operation and test the operand for\n * the following logical-or operation.\n */\n finalize_logical(prev_log_op, parent, bb, log_and_shared_bb);\n log_and_shared_bb = bb_create(parent);\n bb_connect(*bb, log_or_shared_bb, THEN);\n read_logical(op, parent, bb);\n\n /* Here are two cases to illustrate the following assignments\n * after finalizing the logical-and operation and testing the\n * operand for the following logical-or operation.\n *\n * 1. a && b || c\n * pprev opcode: pprev_log_op == 0 (no opcode)\n * previous opcode: prev_log_op == OP_log_and\n * current opcode: op == OP_log_or\n * current operand: b\n *\n * The current opcode should become the previous opcode,\n * and the pprev opcode remains 0.\n *\n * 2. a || b && c || d\n * pprev opcode: pprev_log_op == OP_log_or\n * previous opcode: prev_log_op == OP_log_and\n * current opcode: op == OP_log_or\n * current operand: b\n *\n * The previous opcode should inherit the pprev opcode, which\n * is equivalent to inheriting the current opcode because both\n * of pprev opcode and current opcode are logical-or operator.\n *\n * Thus, pprev opcode is considered used and is cleared to 0.\n *\n * Eventually, the current opcode becomes the previous opcode\n * and pprev opcode is set to 0.\n * */\n prev_log_op = op;\n pprev_log_op = 0;\n } else {\n /* For example: a || b && c\n * previous opcode: prev_log_op == OP_log_or\n * current opcode: op == OP_log_and\n * current operand: b\n *\n * Using the logical-and operation to test the current operand\n * instead of using the logical-or operation.\n *\n * Then, the previous opcode becomes pprev opcode and the\n * current opcode becomes the previous opcode.\n */\n bb_connect(*bb, log_and_shared_bb, ELSE);\n read_logical(op, parent, bb);\n pprev_log_op = prev_log_op;\n prev_log_op = op;\n }\n } else {\n while (has_prev_log_op &&\n (get_operator_prio(op) < get_operator_prio(prev_log_op))) {\n /* When encountering an operator with lower priority, conclude\n * the current logical-and/or and create a new basic block for\n * next logical-and/or operator.\n */\n finalize_logical(prev_log_op, parent, bb,\n prev_log_op == OP_log_and ? log_and_shared_bb\n : log_or_shared_bb);\n if (prev_log_op == OP_log_and)\n log_and_shared_bb = bb_create(parent);\n else\n log_or_shared_bb = bb_create(parent);\n\n /* After finalizing the previous logical-and/or operation, the\n * prev_log_op should inherit pprev_log_op and continue to check\n * whether to finalize a logical-and/or operation.\n */\n prev_log_op = pprev_log_op;\n has_prev_log_op = prev_log_op != 0;\n pprev_log_op = 0;\n }\n }\n read_expr_operand(parent, bb);\n if (!is_logical(op))\n oper_stack[oper_stack_idx++] = op;\n op = get_operator();\n }\n\n while (oper_stack_idx > 0) {\n opcode_t top_op = oper_stack[--oper_stack_idx];\n rs2 = opstack_pop();\n rs1 = opstack_pop();\n\n bool rs1_is_placeholder = is_array_literal_placeholder(rs1);\n bool rs2_is_placeholder = is_array_literal_placeholder(rs2);\n bool rs1_is_ptr_like = is_pointer_like_value(rs1);\n bool rs2_is_ptr_like = is_pointer_like_value(rs2);\n bool pointer_context = (rs1_is_ptr_like && !rs1_is_placeholder) ||\n (rs2_is_ptr_like && !rs2_is_placeholder);\n\n /* Pointer arithmetic handling */\n if (pointer_context && is_pointer_operation(top_op, rs1, rs2)) {\n handle_pointer_arithmetic(parent, bb, top_op, rs1, rs2);\n continue; /* skip normal processing */\n }\n\n if (rs1_is_placeholder && rs2_is_placeholder) {\n rs1 = scalarize_array_literal(parent, bb, rs1, NULL);\n rs2 = scalarize_array_literal(parent, bb, rs2, NULL);\n } else {\n if (rs1_is_placeholder && !rs2_is_ptr_like)\n rs1 = scalarize_array_literal(\n parent, bb, rs1, rs2 && rs2->type ? rs2->type : NULL);\n\n if (rs2_is_placeholder && !rs1_is_ptr_like)\n rs2 = scalarize_array_literal(\n parent, bb, rs2, rs1 && rs1->type ? rs1->type : NULL);\n }\n /* Constant folding for binary operations */\n if (rs1 && rs2 && rs1->init_val && !rs1->ptr_level && !rs1->is_global &&\n rs2->init_val && !rs2->ptr_level && !rs2->is_global) {\n /* Both operands are compile-time constants */\n int result = 0;\n bool folded = true;\n\n switch (top_op) {\n case OP_add:\n result = rs1->init_val + rs2->init_val;\n break;\n case OP_sub:\n result = rs1->init_val - rs2->init_val;\n break;\n case OP_mul:\n result = rs1->init_val * rs2->init_val;\n break;\n case OP_div:\n if (rs2->init_val != 0)\n result = rs1->init_val / rs2->init_val;\n else\n folded = false; /* Division by zero */\n break;\n case OP_mod:\n if (rs2->init_val != 0)\n result = rs1->init_val % rs2->init_val;\n else\n folded = false; /* Modulo by zero */\n break;\n case OP_bit_and:\n result = rs1->init_val & rs2->init_val;\n break;\n case OP_bit_or:\n result = rs1->init_val | rs2->init_val;\n break;\n case OP_bit_xor:\n result = rs1->init_val ^ rs2->init_val;\n break;\n case OP_lshift:\n result = rs1->init_val << rs2->init_val;\n break;\n case OP_rshift:\n result = rs1->init_val >> rs2->init_val;\n break;\n case OP_eq:\n result = rs1->init_val == rs2->init_val;\n break;\n case OP_neq:\n result = rs1->init_val != rs2->init_val;\n break;\n case OP_lt:\n result = rs1->init_val < rs2->init_val;\n break;\n case OP_leq:\n result = rs1->init_val <= rs2->init_val;\n break;\n case OP_gt:\n result = rs1->init_val > rs2->init_val;\n break;\n case OP_geq:\n result = rs1->init_val >= rs2->init_val;\n break;\n default:\n folded = false;\n break;\n }\n\n if (folded) {\n /* Create constant result */\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n vd->init_val = result;\n opstack_push(vd);\n add_insn(parent, *bb, OP_load_constant, vd, NULL, NULL, 0,\n NULL);\n } else {\n /* Normal operation - folding failed or not supported */\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, top_op, vd, rs1, rs2, 0, NULL);\n }\n } else {\n /* Normal operation */\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, top_op, vd, rs1, rs2, 0, NULL);\n }\n }\n while (has_prev_log_op) {\n finalize_logical(\n prev_log_op, parent, bb,\n prev_log_op == OP_log_and ? log_and_shared_bb : log_or_shared_bb);\n\n prev_log_op = pprev_log_op;\n has_prev_log_op = prev_log_op != 0;\n pprev_log_op = 0;\n }\n}\n\n/* Return the address that an expression points to, or evaluate its value.\n * x =;\n * x[] =;\n * x[expr].field =;\n * x[expr]->field =;\n */\nvoid read_lvalue(lvalue_t *lvalue,\n var_t *var,\n block_t *parent,\n basic_block_t **bb,\n bool eval,\n opcode_t prefix_op)\n{\n var_t *vd, *rs1, *rs2;\n bool is_address_got = false;\n bool is_member = false;\n\n /* already peeked and have the variable */\n lex_expect(T_identifier);\n\n lvalue->type = var->type;\n lvalue->size = get_size(var);\n lvalue->ptr_level = var->ptr_level;\n lvalue->is_func = var->is_func;\n lvalue->is_reference = false;\n\n opstack_push(var);\n\n if (lex_peek(T_open_square, NULL) || lex_peek(T_arrow, NULL) ||\n lex_peek(T_dot, NULL))\n lvalue->is_reference = true;\n\n while (lex_peek(T_open_square, NULL) || lex_peek(T_arrow, NULL) ||\n lex_peek(T_dot, NULL)) {\n if (lex_accept(T_open_square)) {\n /* if subscripted member's is not yet resolved, dereference to\n * resolve base address.\n * e.g., dereference of \"->\" in \"data->raw[0]\" would be performed\n * here.\n */\n if (lvalue->is_reference && lvalue->ptr_level && is_member) {\n rs1 = opstack_pop();\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_read, vd, rs1, NULL, 4, NULL);\n }\n\n /* var must be either a pointer or an array of some type */\n /* For typedef pointers, check the type's ptr_level */\n bool is_typedef_pointer = (var->type && var->type->ptr_level > 0);\n if (var->ptr_level == 0 && var->array_size == 0 &&\n !is_typedef_pointer)\n error_at(\"Cannot apply square operator to non-pointer\",\n cur_token_loc());\n\n /* if nested pointer, still pointer */\n /* Also handle typedef pointers which have ptr_level == 0 */\n if ((var->ptr_level <= 1 || is_typedef_pointer) &&\n var->array_size == 0) {\n /* For typedef pointers, get the size of the base type that the\n * pointer points to\n */\n if (lvalue->type->ptr_level > 0) {\n /* This is a typedef pointer, get base type size */\n switch (lvalue->type->base_type) {\n case TYPE_char:\n lvalue->size = TY_char->size;\n break;\n case TYPE_short:\n lvalue->size = TY_short->size;\n break;\n case TYPE_int:\n lvalue->size = TY_int->size;\n break;\n case TYPE_void:\n /* void pointers treated as byte pointers */\n lvalue->size = 1;\n break;\n default:\n lvalue->size = lvalue->type->size;\n break;\n }\n } else {\n lvalue->size = lvalue->type->size;\n }\n }\n\n read_expr(parent, bb);\n\n /* multiply by element size */\n /* For 2D arrays, check if this is the first or second dimension */\n int multiplier = lvalue->size;\n\n /* If this is the first index of a 2D array, multiply by dim2 *\n * element_size\n */\n if (!is_address_got && var->array_dim2 > 0)\n multiplier = var->array_dim2 * lvalue->size;\n\n if (multiplier != 1) {\n vd = require_var(parent);\n vd->init_val = multiplier;\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_load_constant, vd, NULL, NULL, 0,\n NULL);\n\n rs2 = opstack_pop();\n rs1 = opstack_pop();\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_mul, vd, rs1, rs2, 0, NULL);\n }\n\n rs2 = opstack_pop();\n rs1 = opstack_pop();\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_add, vd, rs1, rs2, 0, NULL);\n\n lex_expect(T_close_square);\n is_address_got = true;\n is_member = true;\n lvalue->is_reference = true;\n } else {\n char token[MAX_ID_LEN];\n\n if (lex_accept(T_arrow)) {\n /* resolve where the pointer points at from the calculated\n * address in a structure.\n */\n if (is_member) {\n rs1 = opstack_pop();\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_read, vd, rs1, NULL, 4, NULL);\n }\n } else {\n lex_expect(T_dot);\n\n if (!is_address_got) {\n rs1 = opstack_pop();\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_address_of, vd, rs1, NULL, 0,\n NULL);\n\n is_address_got = true;\n }\n }\n\n lex_ident(T_identifier, token);\n\n /* change type currently pointed to */\n var = find_member(token, lvalue->type);\n lvalue->type = var->type;\n lvalue->ptr_level = var->ptr_level;\n lvalue->is_func = var->is_func;\n lvalue->size = get_size(var);\n\n /* if it is an array, get the address of first element instead of\n * its value.\n */\n if (var->array_size > 0)\n lvalue->is_reference = false;\n\n /* move pointer to offset of structure */\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n vd->init_val = var->offset;\n opstack_push(vd);\n add_insn(parent, *bb, OP_load_constant, vd, NULL, NULL, 0, NULL);\n\n rs2 = opstack_pop();\n rs1 = opstack_pop();\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_add, vd, rs1, rs2, 0, NULL);\n\n is_address_got = true;\n is_member = true;\n }\n }\n\n if (!eval)\n return;\n\n /* Only handle pointer arithmetic if we have a pointer/array that hasn't\n * been dereferenced. After array indexing like arr[0], we have a value, not\n * a pointer.\n */\n if (lex_peek(T_plus, NULL) && (var->ptr_level || var->array_size) &&\n !lvalue->is_reference) {\n while (lex_peek(T_plus, NULL) && (var->ptr_level || var->array_size)) {\n lex_expect(T_plus);\n if (lvalue->is_reference) {\n rs1 = opstack_pop();\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_read, vd, rs1, NULL, lvalue->size,\n NULL);\n }\n\n read_expr_operand(parent, bb);\n\n lvalue->size = lvalue->type->size;\n\n if (lvalue->size > 1) {\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n vd->init_val = lvalue->size;\n opstack_push(vd);\n add_insn(parent, *bb, OP_load_constant, vd, NULL, NULL, 0,\n NULL);\n\n rs2 = opstack_pop();\n rs1 = opstack_pop();\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_mul, vd, rs1, rs2, 0, NULL);\n }\n\n rs2 = opstack_pop();\n rs1 = opstack_pop();\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_add, vd, rs1, rs2, 0, NULL);\n }\n } else {\n var_t *t;\n\n /* If operand is a reference, read the value and push to stack for the\n * incoming addition/subtraction. Otherwise, use the top element of\n * stack as the one of operands and the destination.\n */\n if (lvalue->is_reference) {\n rs1 = operand_stack[operand_stack_idx - 1];\n t = require_var(parent);\n gen_name_to(t->var_name);\n opstack_push(t);\n add_insn(parent, *bb, OP_read, t, rs1, NULL, lvalue->size, NULL);\n }\n if (prefix_op != OP_generic) {\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n /* For pointer arithmetic, increment by the size of pointed-to type\n */\n if (lvalue->ptr_level)\n vd->init_val = lvalue->type->size;\n else\n vd->init_val = 1;\n opstack_push(vd);\n add_insn(parent, *bb, OP_load_constant, vd, NULL, NULL, 0, NULL);\n\n rs2 = opstack_pop();\n if (lvalue->is_reference)\n rs1 = opstack_pop();\n else\n rs1 = operand_stack[operand_stack_idx - 1];\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n add_insn(parent, *bb, prefix_op, vd, rs1, rs2, 0, NULL);\n\n if (lvalue->is_reference) {\n rs1 = vd;\n vd = opstack_pop();\n /* The column of arguments of the new insn of 'OP_write' is\n * different from 'ph1_ir'\n */\n add_insn(parent, *bb, OP_write, NULL, vd, rs1, lvalue->size,\n NULL);\n /* Push the new value onto the operand stack */\n opstack_push(rs1);\n } else {\n rs1 = vd;\n vd = operand_stack[operand_stack_idx - 1];\n add_insn(parent, *bb, OP_assign, vd, rs1, NULL, 0, NULL);\n }\n } else if (lex_peek(T_increment, NULL) || lex_peek(T_decrement, NULL)) {\n side_effect[se_idx].opcode = OP_load_constant;\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n\n /* Calculate increment size based on pointer type */\n int increment_size = 1;\n if (lvalue->ptr_level && !lvalue->is_reference) {\n increment_size = lvalue->type->size;\n } else if (!lvalue->is_reference && lvalue->type &&\n lvalue->type->ptr_level > 0) {\n /* This is a typedef pointer */\n switch (lvalue->type->base_type) {\n case TYPE_char:\n increment_size = TY_char->size;\n break;\n case TYPE_short:\n increment_size = TY_short->size;\n break;\n case TYPE_int:\n increment_size = TY_int->size;\n break;\n case TYPE_void:\n increment_size = 1;\n break;\n default:\n increment_size = lvalue->type->size;\n break;\n }\n }\n vd->init_val = increment_size;\n\n side_effect[se_idx].rd = vd;\n side_effect[se_idx].rs1 = NULL;\n side_effect[se_idx].rs2 = NULL;\n se_idx++;\n\n side_effect[se_idx].opcode =\n lex_accept(T_increment) ? OP_add : OP_sub;\n side_effect[se_idx].rs2 = vd;\n if (lvalue->is_reference)\n side_effect[se_idx].rs1 = opstack_pop();\n else\n side_effect[se_idx].rs1 = operand_stack[operand_stack_idx - 1];\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n side_effect[se_idx].rd = vd;\n se_idx++;\n\n if (lvalue->is_reference) {\n side_effect[se_idx].opcode = OP_write;\n side_effect[se_idx].rs2 = vd;\n side_effect[se_idx].rs1 = opstack_pop();\n side_effect[se_idx].sz = lvalue->size;\n side_effect[se_idx].rd = NULL;\n opstack_push(t);\n se_idx++;\n } else {\n side_effect[se_idx].opcode = OP_assign;\n side_effect[se_idx].rs1 = vd;\n side_effect[se_idx].rd = operand_stack[operand_stack_idx - 1];\n side_effect[se_idx].rs2 = NULL;\n se_idx++;\n }\n } else {\n if (lvalue->is_reference) {\n /* pop the address and keep the read value */\n t = opstack_pop();\n opstack_pop();\n opstack_push(t);\n }\n }\n }\n}\n\nvoid read_logical(opcode_t op, block_t *parent, basic_block_t **bb)\n{\n var_t *vd;\n\n if (op != OP_log_and && op != OP_log_or)\n error_at(\"encounter an invalid logical opcode in read_logical()\",\n cur_token_loc());\n\n /* Test the operand before the logical-and/or operator */\n vd = opstack_pop();\n add_insn(parent, *bb, OP_branch, NULL, vd, NULL, 0, NULL);\n\n /* Create a proper branch label for the operand of the logical-and/or\n * operation.\n */\n basic_block_t *new_bb = bb_create(parent);\n bb_connect(*bb, new_bb, op == OP_log_and ? THEN : ELSE);\n\n bb[0] = new_bb;\n}\n\nvoid finalize_logical(opcode_t op,\n block_t *parent,\n basic_block_t **bb,\n basic_block_t *shared_bb)\n{\n basic_block_t *then, *then_next, *else_if, *else_bb;\n basic_block_t *end = bb_create(parent);\n var_t *vd, *log_op_res;\n\n if (op == OP_log_and) {\n /* For example: a && b\n *\n * If handling the expression, the basic blocks will\n * connect to each other as the following illustration:\n *\n * bb1 bb2 bb3\n * +-----------+ +-----------+ +---------+\n * | teq a, #0 | True | teq b, #0 | True | ldr 1 |\n * | bne bb2 | ----> | bne bb3 | ----> | b bb5 |\n * | b bb4 | | b bb4 | +---------+\n * +-----------+ +-----------+ |\n * | | |\n * | False | False |\n * | | |\n * | +---------+ +--------+\n * -------------> | ldr 0 | ------> | |\n * | b bb5 | | |\n * +---------+ +--------+\n * bb4 bb5\n *\n * In this case, finalize_logical() should add some\n * instructions to bb2 ~ bb5 and properly connect them\n * to each other.\n *\n * Notice that\n * - bb1 has been handled by read_logical().\n * - bb2 is equivalent to '*bb'.\n * - bb3 needs to be created.\n * - bb4 is 'shared_bb'.\n * - bb5 needs to be created.\n *\n * Thus, here uses 'then', 'then_next', 'else_bb' and\n * 'end' to respectively point to bb2 ~ bb5. Subsequently,\n * perform the mentioned operations for finalizing.\n * */\n then = *bb;\n then_next = bb_create(parent);\n else_bb = shared_bb;\n bb_connect(then, then_next, THEN);\n bb_connect(then, else_bb, ELSE);\n bb_connect(then_next, end, NEXT);\n } else if (op == OP_log_or) {\n /* For example: a || b\n *\n * Similar to handling logical-and operations, it should\n * add some instructions to the basic blocks and connect\n * them to each other for logical-or operations as in\n * the figure:\n *\n * bb1 bb2 bb3\n * +-----------+ +-----------+ +---------+\n * | teq a, #0 | False | teq b, #0 | False | ldr 0 |\n * | bne bb4 | ----> | bne bb4 | ----> | b bb5 |\n * | b bb2 | | b bb3 | +---------+\n * +-----------+ +-----------+ |\n * | | |\n * | True | True |\n * | | |\n * | +---------+ +--------+\n * -------------> | ldr 1 | ------> | |\n * | b bb5 | | |\n * +---------+ +--------+\n * bb4 bb5\n *\n * Similarly, here uses 'else_if', 'else_bb', 'then' and\n * 'end' to respectively point to bb2 ~ bb5, and then\n * finishes the finalization.\n * */\n then = shared_bb;\n else_if = *bb;\n else_bb = bb_create(parent);\n bb_connect(else_if, then, THEN);\n bb_connect(else_if, else_bb, ELSE);\n bb_connect(then, end, NEXT);\n } else\n error_at(\"encounter an invalid logical opcode in finalize_logical()\",\n cur_token_loc());\n bb_connect(else_bb, end, NEXT);\n\n /* Create the branch instruction for final logical-and/or operand */\n vd = opstack_pop();\n add_insn(parent, op == OP_log_and ? then : else_if, OP_branch, NULL, vd,\n NULL, 0, NULL);\n\n /*\n * If handling logical-and operation, here creates a true branch for the\n * logical-and operation and assigns a true value.\n *\n * Otherwise, create a false branch and assign a false value for logical-or\n * operation.\n * */\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n vd->init_val = op == OP_log_and;\n add_insn(parent, op == OP_log_and ? then_next : else_bb, OP_load_constant,\n vd, NULL, NULL, 0, NULL);\n\n log_op_res = require_var(parent);\n gen_name_to(log_op_res->var_name);\n add_insn(parent, op == OP_log_and ? then_next : else_bb, OP_assign,\n log_op_res, vd, NULL, 0, NULL);\n\n /* After assigning a value, go to the final basic block, this is done by BB\n * fallthrough.\n */\n\n /* Create the shared branch and assign the other value for the other\n * condition of a logical-and/or operation.\n *\n * If handing a logical-and operation, assign a false value. else, assign\n * a true value for a logical-or operation.\n */\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n vd->init_val = op != OP_log_and;\n add_insn(parent, op == OP_log_and ? else_bb : then, OP_load_constant, vd,\n NULL, NULL, 0, NULL);\n\n add_insn(parent, op == OP_log_and ? else_bb : then, OP_assign, log_op_res,\n vd, NULL, 0, NULL);\n\n log_op_res->is_logical_ret = true;\n opstack_push(log_op_res);\n\n bb[0] = end;\n}\n\nvoid read_ternary_operation(block_t *parent, basic_block_t **bb)\n{\n var_t *vd;\n\n if (!lex_accept(T_question))\n return;\n\n /* ternary-operator */\n vd = opstack_pop();\n add_insn(parent, *bb, OP_branch, NULL, vd, NULL, 0, NULL);\n\n basic_block_t *then_ = bb_create(parent);\n basic_block_t *else_ = bb_create(parent);\n basic_block_t *end_ternary = bb_create(parent);\n bb_connect(then_, end_ternary, NEXT);\n bb_connect(else_, end_ternary, NEXT);\n\n /* true branch */\n read_expr(parent, &then_);\n bb_connect(*bb, then_, THEN);\n\n if (!lex_accept(T_colon)) {\n /* ternary operator in standard C needs three operands */\n /* Note: Dangling basic block cleanup handled by arena allocator */\n abort();\n }\n\n var_t *true_val = opstack_pop();\n\n /* false branch */\n read_expr(parent, &else_);\n bb_connect(*bb, else_, ELSE);\n var_t *false_val = opstack_pop();\n bool true_array = is_array_literal_placeholder(true_val);\n bool false_array = is_array_literal_placeholder(false_val);\n bool true_ptr_like = is_pointer_like_value(true_val);\n bool false_ptr_like = is_pointer_like_value(false_val);\n\n /* The ternary result must look like whichever side is pointer-like. If the\n * \"true\" expression is still a raw array literal but the \"false\" side is a\n * plain scalar, materialize the literal now so both branches produce\n * comparable scalar SSA values.\n */\n true_val = scalarize_array_literal_if_needed(\n parent, &then_, true_val, false_val ? false_val->type : NULL,\n true_array && !false_ptr_like);\n\n /* Apply the same conversion symmetrically when only the false branch is a\n * literal array. This prevents OP_assign from trying to move array storage\n * into a scalar destination later in code generation.\n */\n false_val = scalarize_array_literal_if_needed(\n parent, &else_, false_val, true_val ? true_val->type : NULL,\n false_array && !true_ptr_like);\n\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n add_insn(parent, then_, OP_assign, vd, true_val, NULL, 0, NULL);\n add_insn(parent, else_, OP_assign, vd, false_val, NULL, 0, NULL);\n\n var_t *array_ref = NULL;\n if (is_array_literal_placeholder(true_val))\n array_ref = true_val;\n else if (is_array_literal_placeholder(false_val))\n array_ref = false_val;\n\n if (array_ref) {\n vd->array_size = array_ref->array_size;\n vd->init_val = array_ref->init_val;\n vd->type = array_ref->type;\n }\n\n vd->is_ternary_ret = true;\n opstack_push(vd);\n bb[0] = end_ternary;\n}\n\nbool read_body_assignment(char *token,\n block_t *parent,\n opcode_t prefix_op,\n basic_block_t **bb)\n{\n var_t *var = find_local_var(token, parent), *vd, *rs1, *rs2, *t;\n if (!var)\n var = find_global_var(token);\n\n if (var) {\n int one = 0;\n opcode_t op = OP_generic;\n lvalue_t lvalue;\n int size = 0;\n\n /* has memory address that we want to set */\n read_lvalue(&lvalue, var, parent, bb, false, OP_generic);\n size = lvalue.size;\n\n if (lex_accept(T_increment)) {\n op = OP_add;\n one = 1;\n } else if (lex_accept(T_decrement)) {\n op = OP_sub;\n one = 1;\n } else if (lex_accept(T_pluseq)) {\n op = OP_add;\n } else if (lex_accept(T_minuseq)) {\n op = OP_sub;\n } else if (lex_accept(T_asteriskeq)) {\n op = OP_mul;\n } else if (lex_accept(T_divideeq)) {\n op = OP_div;\n } else if (lex_accept(T_modeq)) {\n op = OP_mod;\n } else if (lex_accept(T_lshifteq)) {\n op = OP_lshift;\n } else if (lex_accept(T_rshifteq)) {\n op = OP_rshift;\n } else if (lex_accept(T_xoreq)) {\n op = OP_bit_xor;\n } else if (lex_accept(T_oreq)) {\n op = OP_bit_or;\n } else if (lex_accept(T_andeq)) {\n op = OP_bit_and;\n } else if (lex_peek(T_open_bracket, NULL)) {\n /* dereference lvalue into function address */\n rs1 = opstack_pop();\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_read, vd, rs1, NULL, PTR_SIZE, NULL);\n\n read_indirect_call(parent, bb);\n return true;\n } else if (prefix_op == OP_generic) {\n lex_expect(T_assign);\n } else {\n op = prefix_op;\n one = 1;\n }\n\n if (op != OP_generic) {\n int increment_size = 1;\n\n /* if we have a pointer, shift it by element size */\n /* But not if we are operating on a dereferenced value (array\n * indexing)\n */\n if (lvalue.ptr_level && !lvalue.is_reference)\n increment_size = lvalue.type->size;\n /* Also check for typedef pointers which have is_ptr == 0 */\n else if (!lvalue.is_reference && lvalue.type &&\n lvalue.type->ptr_level > 0) {\n /* This is a typedef pointer, get the base type size */\n switch (lvalue.type->base_type) {\n case TYPE_char:\n increment_size = TY_char->size;\n break;\n case TYPE_short:\n increment_size = TY_short->size;\n break;\n case TYPE_int:\n increment_size = TY_int->size;\n break;\n case TYPE_void:\n /* void pointers treated as byte pointers */\n increment_size = 1;\n break;\n default:\n /* For struct pointers and other types */\n increment_size = lvalue.type->size;\n break;\n }\n }\n\n /* If operand is a reference, read the value and push to stack for\n * the incoming addition/subtraction. Otherwise, use the top element\n * of stack as the one of operands and the destination.\n */\n if (one == 1) {\n if (lvalue.is_reference) {\n t = opstack_pop();\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_read, vd, t, NULL, lvalue.size,\n NULL);\n } else\n t = operand_stack[operand_stack_idx - 1];\n\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n vd->init_val = increment_size;\n add_insn(parent, *bb, OP_load_constant, vd, NULL, NULL, 0,\n NULL);\n\n rs2 = vd;\n rs1 = opstack_pop();\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n add_insn(parent, *bb, op, vd, rs1, rs2, 0, NULL);\n\n if (lvalue.is_reference) {\n add_insn(parent, *bb, OP_write, NULL, t, vd, size, NULL);\n } else {\n vd = resize_var(parent, bb, vd, t);\n add_insn(parent, *bb, OP_assign, t, vd, NULL, 0, NULL);\n }\n } else {\n if (lvalue.is_reference) {\n t = opstack_pop();\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_read, vd, t, NULL, lvalue.size,\n NULL);\n } else\n t = operand_stack[operand_stack_idx - 1];\n\n read_expr(parent, bb);\n\n var_t *rhs_val = opstack_pop();\n rhs_val = scalarize_array_literal_if_needed(\n parent, bb, rhs_val, lvalue.type,\n !lvalue.ptr_level && !lvalue.is_reference);\n opstack_push(rhs_val);\n vd = require_var(parent);\n vd->init_val = increment_size;\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_load_constant, vd, NULL, NULL, 0,\n NULL);\n\n rs2 = opstack_pop();\n rs1 = opstack_pop();\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(parent, *bb, OP_mul, vd, rs1, rs2, 0, NULL);\n\n rs2 = opstack_pop();\n rs1 = opstack_pop();\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n add_insn(parent, *bb, op, vd, rs1, rs2, 0, NULL);\n\n if (lvalue.is_reference) {\n add_insn(parent, *bb, OP_write, NULL, t, vd, lvalue.size,\n NULL);\n } else {\n vd = resize_var(parent, bb, vd, t);\n add_insn(parent, *bb, OP_assign, t, vd, NULL, 0, NULL);\n }\n }\n } else {\n read_expr(parent, bb);\n read_ternary_operation(parent, bb);\n\n if (lvalue.is_func) {\n rs2 = opstack_pop();\n rs1 = opstack_pop();\n add_insn(parent, *bb, OP_write, NULL, rs1, rs2, PTR_SIZE, NULL);\n } else if (lvalue.is_reference) {\n rs2 = opstack_pop();\n rs1 = opstack_pop();\n add_insn(parent, *bb, OP_write, NULL, rs1, rs2, size, NULL);\n } else {\n rs1 = opstack_pop();\n vd = opstack_pop();\n rs1 = resize_var(parent, bb, rs1, vd);\n add_insn(parent, *bb, OP_assign, vd, rs1, NULL, 0, NULL);\n }\n }\n return true;\n }\n return false;\n}\n\nint read_primary_constant(void)\n{\n /* return signed constant */\n int isneg = 0, res;\n char buffer[MAX_TOKEN_LEN];\n if (lex_accept(T_minus))\n isneg = 1;\n if (lex_accept(T_open_bracket)) {\n res = read_primary_constant();\n lex_expect(T_close_bracket);\n } else if (lex_peek(T_numeric, buffer)) {\n res = parse_numeric_constant(buffer);\n lex_expect(T_numeric);\n } else if (lex_peek(T_char, buffer)) {\n char unescaped[MAX_TOKEN_LEN];\n unescape_string(buffer, unescaped, MAX_TOKEN_LEN);\n res = unescaped[0];\n lex_expect(T_char);\n } else\n error_at(\"Invalid value after assignment\", next_token_loc());\n if (isneg)\n return (-1) * res;\n return res;\n}\n\nint eval_expression_imm(opcode_t op, int op1, int op2)\n{\n /* return immediate result */\n int tmp = op2;\n int res = 0;\n switch (op) {\n case OP_add:\n res = op1 + op2;\n break;\n case OP_sub:\n res = op1 - op2;\n break;\n case OP_mul:\n res = op1 * op2;\n break;\n case OP_div:\n res = op1 / op2;\n break;\n case OP_mod:\n /* Use bitwise AND for modulo optimization when divisor is power of 2 */\n tmp &= (tmp - 1);\n if ((op2 != 0) && (tmp == 0)) {\n res = op1;\n res &= (op2 - 1);\n } else\n res = op1 % op2;\n break;\n case OP_lshift:\n res = op1 << op2;\n break;\n case OP_rshift:\n res = op1 >> op2;\n break;\n case OP_log_and:\n res = op1 && op2;\n break;\n case OP_log_or:\n res = op1 || op2;\n break;\n case OP_eq:\n res = op1 == op2;\n break;\n case OP_neq:\n res = op1 != op2;\n break;\n case OP_lt:\n res = op1 < op2;\n break;\n case OP_gt:\n res = op1 > op2;\n break;\n case OP_leq:\n res = op1 <= op2;\n break;\n case OP_geq:\n res = op1 >= op2;\n break;\n default:\n error_at(\"The requested operation is not supported.\", cur_token_loc());\n }\n return res;\n}\n\nbool read_global_assignment(char *token);\nvoid eval_ternary_imm(int cond, char *token)\n{\n if (cond == 0) {\n while (!lex_peek(T_colon, NULL)) {\n lex_next();\n }\n lex_accept(T_colon);\n read_global_assignment(token);\n } else {\n read_global_assignment(token);\n lex_expect(T_colon);\n while (!lex_peek(T_semicolon, NULL)) {\n lex_next();\n }\n }\n}\n\nbool read_global_assignment(char *token)\n{\n var_t *vd, *rs1, *var;\n block_t *parent = GLOBAL_BLOCK;\n basic_block_t *bb = GLOBAL_FUNC->bbs;\n\n /* global initialization must be constant */\n var = find_global_var(token);\n if (var) {\n if (lex_peek(T_string, NULL)) {\n /* String literal global initialization:\n * String literals are now stored in .rodata section.\n * TODO: Implement compile-time address resolution for global\n * pointer initialization with rodata addresses\n * (e.g., char *p = \"str\";)\n */\n read_literal_param(parent, bb);\n rs1 = opstack_pop();\n vd = var;\n add_insn(parent, bb, OP_assign, vd, rs1, NULL, 0, NULL);\n return true;\n }\n\n opcode_t op_stack[10];\n opcode_t op, next_op;\n int val_stack[10];\n int op_stack_index = 0, val_stack_index = 0;\n int operand1, operand2;\n operand1 = read_primary_constant();\n op = get_operator();\n /* only one value after assignment */\n if (op == OP_generic) {\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n vd->init_val = operand1;\n add_insn(parent, bb, OP_load_constant, vd, NULL, NULL, 0, NULL);\n\n rs1 = vd;\n vd = opstack_pop();\n add_insn(parent, bb, OP_assign, vd, rs1, NULL, 0, NULL);\n return true;\n }\n if (op == OP_ternary) {\n lex_expect(T_question);\n eval_ternary_imm(operand1, token);\n return true;\n }\n operand2 = read_primary_constant();\n next_op = get_operator();\n if (next_op == OP_generic) {\n /* only two operands, apply and return */\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n vd->init_val = eval_expression_imm(op, operand1, operand2);\n add_insn(parent, bb, OP_load_constant, vd, NULL, NULL, 0, NULL);\n\n rs1 = vd;\n vd = opstack_pop();\n add_insn(parent, bb, OP_assign, vd, rs1, NULL, 0, NULL);\n return true;\n }\n if (op == OP_ternary) {\n lex_expect(T_question);\n int cond = eval_expression_imm(op, operand1, operand2);\n eval_ternary_imm(cond, token);\n return true;\n }\n\n /* using stack if operands more than two */\n op_stack[op_stack_index++] = op;\n op = next_op;\n val_stack[val_stack_index++] = operand1;\n val_stack[val_stack_index++] = operand2;\n\n while (op != OP_generic && op != OP_ternary) {\n if (op_stack_index > 0) {\n /* we have a continuation, use stack */\n int same_op = 0;\n do {\n opcode_t stack_op = op_stack[op_stack_index - 1];\n if (get_operator_prio(stack_op) >= get_operator_prio(op)) {\n operand1 = val_stack[val_stack_index - 2];\n operand2 = val_stack[val_stack_index - 1];\n val_stack_index -= 2;\n\n /* apply stack operator and push result back */\n val_stack[val_stack_index++] =\n eval_expression_imm(stack_op, operand1, operand2);\n\n /* pop op stack */\n op_stack_index--;\n } else {\n same_op = 1;\n }\n /* continue util next operation is higher prio */\n } while (op_stack_index > 0 && same_op == 0);\n }\n /* push next operand on stack */\n val_stack[val_stack_index++] = read_primary_constant();\n /* push operator on stack */\n op_stack[op_stack_index++] = op;\n op = get_operator();\n }\n /* unwind stack and apply operations */\n while (op_stack_index > 0) {\n opcode_t stack_op = op_stack[op_stack_index - 1];\n\n /* pop stack and apply operators */\n operand1 = val_stack[val_stack_index - 2];\n operand2 = val_stack[val_stack_index - 1];\n val_stack_index -= 2;\n\n /* apply stack operator and push value back on stack */\n val_stack[val_stack_index++] =\n eval_expression_imm(stack_op, operand1, operand2);\n\n if (op_stack_index == 1) {\n if (op == OP_ternary) {\n lex_expect(T_question);\n eval_ternary_imm(val_stack[0], token);\n } else {\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n vd->init_val = val_stack[0];\n add_insn(parent, bb, OP_load_constant, vd, NULL, NULL, 0,\n NULL);\n\n rs1 = vd;\n vd = opstack_pop();\n add_insn(parent, bb, OP_assign, vd, rs1, NULL, 0, NULL);\n }\n return true;\n }\n\n /* pop op stack */\n op_stack_index--;\n }\n if (op == OP_ternary) {\n lex_expect(T_question);\n eval_ternary_imm(val_stack[0], token);\n } else {\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n vd->init_val = val_stack[0];\n add_insn(parent, GLOBAL_FUNC->bbs, OP_load_constant, vd, NULL, NULL,\n 0, NULL);\n\n rs1 = vd;\n vd = opstack_pop();\n add_insn(parent, GLOBAL_FUNC->bbs, OP_assign, vd, rs1, NULL, 0,\n NULL);\n }\n return true;\n }\n return false;\n}\n\nvoid perform_side_effect(block_t *parent, basic_block_t *bb)\n{\n for (int i = 0; i < se_idx; i++) {\n insn_t *insn = &side_effect[i];\n add_insn(parent, bb, insn->opcode, insn->rd, insn->rs1, insn->rs2,\n insn->sz, insn->str);\n }\n se_idx = 0;\n}\n\nbasic_block_t *read_code_block(func_t *func,\n block_t *parent,\n basic_block_t *bb);\n\nbasic_block_t *read_body_statement(block_t *parent, basic_block_t *bb)\n{\n char token[MAX_ID_LEN];\n func_t *func;\n type_t *type;\n var_t *vd, *rs1, *rs2, *var;\n opcode_t prefix_op = OP_generic;\n bool is_const = false;\n\n if (!bb)\n printf(\"Warning: unreachable code detected\\n\");\n\n /* statement can be:\n * function call, variable declaration, assignment operation,\n * keyword, block\n */\n\n if (lex_peek(T_open_curly, NULL))\n return read_code_block(parent->func, parent, bb);\n\n if (lex_accept(T_return)) {\n return handle_return_statement(parent, bb);\n }\n\n if (lex_accept(T_if)) {\n return handle_if_statement(parent, bb);\n }\n\n if (lex_accept(T_while)) {\n return handle_while_statement(parent, bb);\n }\n\n if (lex_accept(T_switch)) {\n bool is_default = false;\n\n basic_block_t *n = bb_create(parent);\n bb_connect(bb, n, NEXT);\n bb = n;\n\n lex_expect(T_open_bracket);\n read_expr(parent, &bb);\n lex_expect(T_close_bracket);\n\n /* create exit jump for breaks */\n basic_block_t *switch_end = bb_create(parent);\n break_bb[break_exit_idx++] = switch_end;\n basic_block_t *true_body_ = bb_create(parent);\n\n lex_expect(T_open_curly);\n while (lex_peek(T_default, NULL) || lex_peek(T_case, NULL)) {\n if (lex_accept(T_default))\n is_default = true;\n else {\n int case_val;\n\n lex_accept(T_case);\n if (lex_peek(T_numeric, token)) {\n case_val = parse_numeric_constant(token);\n lex_expect(T_numeric);\n } else if (lex_peek(T_char, token)) {\n char unescaped[MAX_TOKEN_LEN];\n unescape_string(token, unescaped, MAX_TOKEN_LEN);\n case_val = unescaped[0];\n lex_expect(T_char);\n } else if (lex_peek(T_identifier, token)) {\n constant_t *cd = find_constant(token);\n case_val = cd->value;\n lex_expect(T_identifier);\n } else {\n fatal(\"Not a valid case value\");\n }\n\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n vd->init_val = case_val;\n opstack_push(vd);\n add_insn(parent, bb, OP_load_constant, vd, NULL, NULL, 0, NULL);\n\n vd = require_var(parent);\n gen_name_to(vd->var_name);\n rs1 = opstack_pop();\n rs2 = operand_stack[operand_stack_idx - 1];\n add_insn(parent, bb, OP_eq, vd, rs1, rs2, 0, NULL);\n\n add_insn(parent, bb, OP_branch, NULL, vd, NULL, 0, NULL);\n }\n lex_expect(T_colon);\n\n if (is_default)\n /* there's no condition if it is a default label */\n bb_connect(bb, true_body_, NEXT);\n else\n bb_connect(bb, true_body_, THEN);\n\n int control = 0;\n\n while (!lex_peek(T_case, NULL) && !lex_peek(T_close_curly, NULL) &&\n !lex_peek(T_default, NULL)) {\n true_body_ = read_body_statement(parent, true_body_);\n control = 1;\n }\n\n if (control && true_body_) {\n /* Create a new body block for next case, and connect the last\n * body block which lacks 'break' to it to make that one ignore\n * the upcoming cases.\n */\n n = bb_create(parent);\n bb_connect(true_body_, n, NEXT);\n true_body_ = n;\n }\n\n if (!lex_peek(T_close_curly, NULL)) {\n if (is_default)\n error_at(\"Label default should be the last one\",\n next_token_loc());\n\n /* create a new conditional block for next case */\n n = bb_create(parent);\n bb_connect(bb, n, ELSE);\n bb = n;\n\n /* create a new body block for next case if the last body block\n * exits 'switch'.\n */\n if (!true_body_)\n true_body_ = bb_create(parent);\n } else if (!is_default) {\n /* handle missing default label */\n bb_connect(bb, switch_end, ELSE);\n }\n }\n\n /* remove the expression in switch() */\n opstack_pop();\n lex_expect(T_close_curly);\n\n if (true_body_)\n /* if the last label has no explicit break, connect it to the end */\n bb_connect(true_body_, switch_end, NEXT);\n\n break_exit_idx--;\n\n int dangling = 1;\n for (int i = 0; i < MAX_BB_PRED; i++)\n if (switch_end->prev[i].bb)\n dangling = 0;\n\n if (dangling)\n return NULL;\n\n return switch_end;\n }\n\n if (lex_accept(T_break)) {\n bb_connect(bb, break_bb[break_exit_idx - 1], NEXT);\n lex_expect(T_semicolon);\n return NULL;\n }\n\n if (lex_accept(T_continue)) {\n bb_connect(bb, continue_bb[continue_pos_idx - 1], NEXT);\n lex_expect(T_semicolon);\n return NULL;\n }\n\n if (lex_accept(T_for)) {\n lex_expect(T_open_bracket);\n\n /* synthesize for loop block */\n block_t *blk = add_block(parent, parent->func);\n\n /* setup - execute once */\n basic_block_t *setup = bb_create(blk);\n bb_connect(bb, setup, NEXT);\n\n if (!lex_accept(T_semicolon)) {\n if (!lex_peek(T_identifier, token))\n error_at(\"Unexpected token when parsing for loop\",\n next_token_loc());\n\n int find_type_flag = lex_accept(T_struct) ? 2 : 1;\n if (find_type_flag == 1 && lex_accept(T_union)) {\n find_type_flag = 2;\n }\n type = find_type(token, find_type_flag);\n if (type) {\n var = require_typed_var(blk, type);\n read_full_var_decl(var, false, false);\n add_insn(blk, setup, OP_allocat, var, NULL, NULL, 0, NULL);\n add_symbol(setup, var);\n if (lex_accept(T_assign)) {\n read_expr(blk, &setup);\n read_ternary_operation(blk, &setup);\n\n rs1 = resize_var(parent, &bb, opstack_pop(), var);\n add_insn(blk, setup, OP_assign, var, rs1, NULL, 0, NULL);\n }\n while (lex_accept(T_comma)) {\n var_t *nv;\n\n /* add sequence point at T_comma */\n perform_side_effect(blk, setup);\n\n /* multiple (partial) declarations */\n nv = require_typed_var(blk, type);\n read_partial_var_decl(nv, var); /* partial */\n add_insn(blk, setup, OP_allocat, nv, NULL, NULL, 0, NULL);\n add_symbol(setup, nv);\n if (lex_accept(T_assign)) {\n read_expr(blk, &setup);\n\n rs1 = resize_var(parent, &bb, opstack_pop(), nv);\n add_insn(blk, setup, OP_assign, nv, rs1, NULL, 0, NULL);\n }\n }\n } else {\n read_body_assignment(token, blk, OP_generic, &setup);\n }\n\n lex_expect(T_semicolon);\n }\n\n basic_block_t *cond_ = bb_create(blk);\n basic_block_t *for_end = bb_create(parent);\n basic_block_t *cond_start = cond_;\n break_bb[break_exit_idx++] = for_end;\n bb_connect(setup, cond_, NEXT);\n\n /* condition - check before the loop */\n if (!lex_accept(T_semicolon)) {\n read_expr(blk, &cond_);\n lex_expect(T_semicolon);\n } else {\n /* always true */\n vd = require_var(blk);\n vd->init_val = 1;\n gen_name_to(vd->var_name);\n opstack_push(vd);\n add_insn(blk, cond_, OP_load_constant, vd, NULL, NULL, 0, NULL);\n }\n bb_connect(cond_, for_end, ELSE);\n\n vd = opstack_pop();\n add_insn(blk, cond_, OP_branch, NULL, vd, NULL, 0, NULL);\n\n basic_block_t *inc_ = bb_create(blk);\n continue_bb[continue_pos_idx++] = inc_;\n\n /* increment after each loop */\n if (!lex_accept(T_close_bracket)) {\n if (lex_accept(T_increment))\n prefix_op = OP_add;\n else if (lex_accept(T_decrement))\n prefix_op = OP_sub;\n lex_peek(T_identifier, token);\n read_body_assignment(token, blk, prefix_op, &inc_);\n lex_expect(T_close_bracket);\n }\n\n /* loop body */\n basic_block_t *body_ = bb_create(blk);\n bb_connect(cond_, body_, THEN);\n body_ = read_body_statement(blk, body_);\n\n if (body_) {\n bb_connect(body_, inc_, NEXT);\n bb_connect(inc_, cond_start, NEXT);\n } else if (inc_->insn_list.head) {\n bb_connect(inc_, cond_start, NEXT);\n } else {\n /* Empty increment block - cleanup handled by arena allocator */\n }\n\n /* jump to increment */\n continue_pos_idx--;\n break_exit_idx--;\n return for_end;\n }\n\n if (lex_accept(T_do)) {\n basic_block_t *n = bb_create(parent);\n bb_connect(bb, n, NEXT);\n bb = n;\n\n basic_block_t *cond_ = bb_create(parent);\n basic_block_t *do_while_end = bb_create(parent);\n\n continue_bb[continue_pos_idx++] = cond_;\n break_bb[break_exit_idx++] = do_while_end;\n\n basic_block_t *do_body = read_body_statement(parent, bb);\n if (do_body)\n bb_connect(do_body, cond_, NEXT);\n\n lex_expect(T_while);\n lex_expect(T_open_bracket);\n read_expr(parent, &cond_);\n lex_expect(T_close_bracket);\n\n vd = opstack_pop();\n add_insn(parent, cond_, OP_branch, NULL, vd, NULL, 0, NULL);\n\n lex_expect(T_semicolon);\n\n for (int i = 0; i < MAX_BB_PRED; i++) {\n if (cond_->prev[i].bb) {\n bb_connect(cond_, bb, THEN);\n bb_connect(cond_, do_while_end, ELSE);\n break;\n }\n /* if breaking out of loop, skip condition block */\n }\n\n continue_pos_idx--;\n break_exit_idx--;\n return do_while_end;\n }\n\n if (lex_accept(T_goto))\n return handle_goto_statement(parent, bb);\n\n /* empty statement */\n if (lex_accept(T_semicolon))\n return bb;\n\n /* struct/union variable declaration */\n if (lex_peek(T_struct, NULL) || lex_peek(T_union, NULL)) {\n int find_type_flag = lex_accept(T_struct) ? 2 : 1;\n if (find_type_flag == 1 && lex_accept(T_union)) {\n find_type_flag = 2;\n }\n lex_ident(T_identifier, token);\n type = find_type(token, find_type_flag);\n if (type) {\n var = require_typed_var(parent, type);\n var->is_const_qualified = is_const;\n read_partial_var_decl(var, NULL);\n add_insn(parent, bb, OP_allocat, var, NULL, NULL, 0, NULL);\n add_symbol(bb, var);\n if (lex_accept(T_assign)) {\n if (lex_peek(T_open_curly, NULL) &&\n (var->array_size > 0 || var->ptr_level > 0)) {\n parse_array_init(var, parent, &bb,\n 1); /* Always emit code */\n } else if (lex_peek(T_open_curly, NULL) &&\n (var->type->base_type == TYPE_struct ||\n var->type->base_type == TYPE_typedef)) {\n /* C90-compliant struct compound literal support */\n type_t *struct_type = var->type;\n\n /* Handle typedef by getting actual struct type */\n if (struct_type->base_type == TYPE_typedef &&\n struct_type->base_struct)\n struct_type = struct_type->base_struct;\n\n lex_expect(T_open_curly);\n int field_idx = 0;\n\n if (!lex_peek(T_close_curly, NULL)) {\n for (;;) {\n /* Parse field value expression */\n read_expr(parent, &bb);\n read_ternary_operation(parent, &bb);\n var_t *val = opstack_pop();\n\n /* Initialize field if within bounds */\n if (field_idx < struct_type->num_fields) {\n var_t *field = &struct_type->fields[field_idx];\n\n /* Create target variable for field */\n var_t target = {0};\n target.type = field->type;\n target.ptr_level = field->ptr_level;\n var_t *field_val =\n resize_var(parent, &bb, val, &target);\n\n /* Compute field address: &struct + field_offset\n */\n var_t *struct_addr = require_var(parent);\n gen_name_to(struct_addr->var_name);\n add_insn(parent, bb, OP_address_of, struct_addr,\n var, NULL, 0, NULL);\n\n var_t *field_addr = struct_addr;\n if (field->offset > 0) {\n var_t *offset = require_var(parent);\n gen_name_to(offset->var_name);\n offset->init_val = field->offset;\n add_insn(parent, bb, OP_load_constant,\n offset, NULL, NULL, 0, NULL);\n\n var_t *addr = require_var(parent);\n gen_name_to(addr->var_name);\n add_insn(parent, bb, OP_add, addr,\n struct_addr, offset, 0, NULL);\n field_addr = addr;\n }\n\n /* Write field value */\n int field_size = size_var(field);\n add_insn(parent, bb, OP_write, NULL, field_addr,\n field_val, field_size, NULL);\n }\n\n field_idx++;\n if (!lex_accept(T_comma))\n break;\n if (lex_peek(T_close_curly, NULL))\n break;\n }\n }\n lex_expect(T_close_curly);\n } else {\n read_expr(parent, &bb);\n read_ternary_operation(parent, &bb);\n\n var_t *rhs = opstack_pop();\n rhs = scalarize_array_literal_if_needed(\n parent, &bb, rhs, var->type,\n !var->ptr_level && var->array_size == 0);\n\n rs1 = resize_var(parent, &bb, rhs, var);\n add_insn(parent, bb, OP_assign, var, rs1, NULL, 0, NULL);\n }\n }\n while (lex_accept(T_comma)) {\n var_t *nv;\n\n /* add sequence point at T_comma */\n perform_side_effect(parent, bb);\n\n /* multiple (partial) declarations */\n nv = require_typed_var(parent, type);\n read_inner_var_decl(nv, false, false);\n add_insn(parent, bb, OP_allocat, nv, NULL, NULL, 0, NULL);\n add_symbol(bb, nv);\n if (lex_accept(T_assign)) {\n if (lex_peek(T_open_curly, NULL) &&\n (nv->array_size > 0 || nv->ptr_level > 0)) {\n parse_array_init(nv, parent, &bb, true);\n } else if (lex_peek(T_open_curly, NULL) &&\n (nv->type->base_type == TYPE_struct ||\n nv->type->base_type == TYPE_typedef)) {\n /* C90-compliant struct compound literal support */\n type_t *struct_type = nv->type;\n\n /* Handle typedef by getting actual struct type */\n if (struct_type->base_type == TYPE_typedef &&\n struct_type->base_struct)\n struct_type = struct_type->base_struct;\n\n lex_expect(T_open_curly);\n int field_idx = 0;\n\n if (!lex_peek(T_close_curly, NULL)) {\n for (;;) {\n /* Parse field value expression */\n read_expr(parent, &bb);\n read_ternary_operation(parent, &bb);\n var_t *val = opstack_pop();\n\n /* Initialize field if within bounds */\n if (field_idx < struct_type->num_fields) {\n var_t *field =\n &struct_type->fields[field_idx];\n\n /* Create target variable for field */\n var_t target = {0};\n target.type = field->type;\n target.ptr_level = field->ptr_level;\n var_t *field_val =\n resize_var(parent, &bb, val, &target);\n\n /* Compute field address: &struct +\n * field_offset */\n var_t *struct_addr = require_var(parent);\n gen_name_to(struct_addr->var_name);\n add_insn(parent, bb, OP_address_of,\n struct_addr, nv, NULL, 0, NULL);\n\n var_t *field_addr = struct_addr;\n if (field->offset > 0) {\n var_t *offset = require_var(parent);\n gen_name_to(offset->var_name);\n offset->init_val = field->offset;\n add_insn(parent, bb, OP_load_constant,\n offset, NULL, NULL, 0, NULL);\n\n var_t *addr = require_var(parent);\n gen_name_to(addr->var_name);\n add_insn(parent, bb, OP_add, addr,\n struct_addr, offset, 0, NULL);\n field_addr = addr;\n }\n\n /* Write field value */\n int field_size = size_var(field);\n add_insn(parent, bb, OP_write, NULL,\n field_addr, field_val, field_size,\n NULL);\n }\n\n field_idx++;\n if (!lex_accept(T_comma))\n break;\n if (lex_peek(T_close_curly, NULL))\n break;\n }\n }\n lex_expect(T_close_curly);\n } else {\n read_expr(parent, &bb);\n read_ternary_operation(parent, &bb);\n var_t *rhs = opstack_pop();\n rhs = scalarize_array_literal_if_needed(\n parent, &bb, rhs, nv->type,\n !nv->ptr_level && nv->array_size == 0);\n\n rs1 = resize_var(parent, &bb, rhs, nv);\n add_insn(parent, bb, OP_assign, nv, rs1, NULL, 0, NULL);\n }\n }\n }\n lex_expect(T_semicolon);\n return bb;\n }\n error_at(\"Unknown struct/union type\", next_token_loc());\n }\n\n /* Handle const qualifier for local variable declarations */\n if (lex_accept(T_const)) {\n is_const = true;\n /* After const, we expect a type */\n if (!lex_peek(T_identifier, token))\n error_at(\"Expected type after const\", next_token_loc());\n }\n\n /* statement with prefix */\n if (!is_const && lex_accept(T_increment))\n prefix_op = OP_add;\n else if (!is_const && lex_accept(T_decrement))\n prefix_op = OP_sub;\n /* must be an identifier or asterisk (for pointer dereference) */\n bool has_asterisk = lex_peek(T_asterisk, NULL);\n if (!is_const && !lex_peek(T_identifier, token) && !has_asterisk)\n error_at(\"Unexpected token\", next_token_loc());\n\n /* is it a variable declaration? */\n /* Special handling when statement starts with asterisk */\n if (has_asterisk) {\n /* For \"*identifier\", check if identifier is a type.\n * If not, it's a dereference, not a declaration. */\n token_t *saved_token = cur_token;\n\n /* Skip the asterisk to peek at the identifier */\n lex_accept(T_asterisk);\n char next_ident[MAX_TOKEN_LEN];\n bool could_be_type = false;\n\n if (lex_peek(T_identifier, next_ident)) {\n /* Check if it's a type name */\n type = find_type(next_ident, 0);\n if (type)\n could_be_type = true;\n }\n\n /* Restore position */\n cur_token = saved_token;\n\n /* If it's not a type, skip the declaration block */\n if (!could_be_type)\n type = NULL;\n } else {\n /* Normal type checking without asterisk */\n int find_type_flag = lex_accept(T_struct) ? 2 : 1;\n if (find_type_flag == 1 && lex_accept(T_union))\n find_type_flag = 2;\n type = find_type(token, find_type_flag);\n }\n\n if (type) {\n var = require_typed_var(parent, type);\n var->is_const_qualified = is_const;\n read_full_var_decl(var, false, false);\n add_insn(parent, bb, OP_allocat, var, NULL, NULL, 0, NULL);\n add_symbol(bb, var);\n if (lex_accept(T_assign)) {\n if (lex_peek(T_open_curly, NULL) &&\n (var->array_size > 0 || var->ptr_level > 0)) {\n /* Emit code for locals in functions */\n parse_array_init(var, parent, &bb, 1);\n } else if (lex_peek(T_open_curly, NULL) &&\n (var->type->base_type == TYPE_struct ||\n var->type->base_type == TYPE_typedef)) {\n /* C90-compliant struct compound literal support */\n type_t *struct_type = var->type;\n\n /* Handle typedef by getting actual struct type */\n if (struct_type->base_type == TYPE_typedef &&\n struct_type->base_struct)\n struct_type = struct_type->base_struct;\n\n lex_expect(T_open_curly);\n int field_idx = 0;\n\n if (!lex_peek(T_close_curly, NULL)) {\n for (;;) {\n /* Parse field value expression */\n read_expr(parent, &bb);\n read_ternary_operation(parent, &bb);\n var_t *val = opstack_pop();\n\n /* Initialize field if within bounds */\n if (field_idx < struct_type->num_fields) {\n var_t *field = &struct_type->fields[field_idx];\n\n /* Create target variable for field */\n var_t target = {0};\n target.type = field->type;\n target.ptr_level = field->ptr_level;\n var_t *field_val =\n resize_var(parent, &bb, val, &target);\n\n /* Compute field address: &struct + field_offset */\n var_t *struct_addr = require_var(parent);\n gen_name_to(struct_addr->var_name);\n add_insn(parent, bb, OP_address_of, struct_addr,\n var, NULL, 0, NULL);\n\n var_t *field_addr = struct_addr;\n if (field->offset > 0) {\n var_t *offset = require_var(parent);\n gen_name_to(offset->var_name);\n offset->init_val = field->offset;\n add_insn(parent, bb, OP_load_constant, offset,\n NULL, NULL, 0, NULL);\n\n var_t *addr = require_var(parent);\n gen_name_to(addr->var_name);\n add_insn(parent, bb, OP_add, addr, struct_addr,\n offset, 0, NULL);\n field_addr = addr;\n }\n\n /* Write field value */\n int field_size = size_var(field);\n add_insn(parent, bb, OP_write, NULL, field_addr,\n field_val, field_size, NULL);\n }\n\n field_idx++;\n if (!lex_accept(T_comma))\n break;\n if (lex_peek(T_close_curly, NULL))\n break;\n }\n }\n lex_expect(T_close_curly);\n } else {\n read_expr(parent, &bb);\n read_ternary_operation(parent, &bb);\n\n var_t *expr_result = opstack_pop();\n\n /* Handle array compound literal to scalar assignment */\n if (expr_result && expr_result->array_size > 0 &&\n !var->ptr_level && var->array_size == 0 && var->type &&\n (var->type->base_type == TYPE_int ||\n var->type->base_type == TYPE_short) &&\n expr_result->var_name[0] == '.') {\n /* Extract first element from compound literal array */\n var_t *first_elem = require_var(parent);\n first_elem->type = var->type;\n gen_name_to(first_elem->var_name);\n\n /* Read first element from array at offset 0\n * expr_result is the array itself, so we can read\n * directly from it\n */\n add_insn(parent, bb, OP_read, first_elem, expr_result, NULL,\n var->type->size, NULL);\n expr_result = first_elem;\n }\n\n rs1 = resize_var(parent, &bb, expr_result, var);\n add_insn(parent, bb, OP_assign, var, rs1, NULL, 0, NULL);\n }\n }\n while (lex_accept(T_comma)) {\n var_t *nv;\n\n /* add sequence point at T_comma */\n perform_side_effect(parent, bb);\n\n /* multiple (partial) declarations */\n nv = require_typed_var(parent, type);\n read_partial_var_decl(nv, var); /* partial */\n add_insn(parent, bb, OP_allocat, nv, NULL, NULL, 0, NULL);\n add_symbol(bb, nv);\n if (lex_accept(T_assign)) {\n if (lex_peek(T_open_curly, NULL) &&\n (nv->array_size > 0 || nv->ptr_level > 0)) {\n /* Emit code for locals */\n parse_array_init(nv, parent, &bb, 1);\n } else if (lex_peek(T_open_curly, NULL) &&\n (nv->type->base_type == TYPE_struct ||\n nv->type->base_type == TYPE_typedef)) {\n /* C90-compliant struct compound literal support */\n type_t *struct_type = nv->type;\n\n /* Handle typedef by getting actual struct type */\n if (struct_type->base_type == TYPE_typedef &&\n struct_type->base_struct)\n struct_type = struct_type->base_struct;\n\n lex_expect(T_open_curly);\n int field_idx = 0;\n\n if (!lex_peek(T_close_curly, NULL)) {\n for (;;) {\n /* Parse field value expression */\n read_expr(parent, &bb);\n read_ternary_operation(parent, &bb);\n var_t *val = opstack_pop();\n\n /* Initialize field if within bounds */\n if (field_idx < struct_type->num_fields) {\n var_t *field = &struct_type->fields[field_idx];\n\n /* Create target variable for field */\n var_t target = {0};\n target.type = field->type;\n target.ptr_level = field->ptr_level;\n var_t *field_val =\n resize_var(parent, &bb, val, &target);\n\n /* Compute field address: &struct + field_offset\n */\n var_t *struct_addr = require_var(parent);\n gen_name_to(struct_addr->var_name);\n add_insn(parent, bb, OP_address_of, struct_addr,\n nv, NULL, 0, NULL);\n\n var_t *field_addr = struct_addr;\n if (field->offset > 0) {\n var_t *offset = require_var(parent);\n gen_name_to(offset->var_name);\n offset->init_val = field->offset;\n add_insn(parent, bb, OP_load_constant,\n offset, NULL, NULL, 0, NULL);\n\n var_t *addr = require_var(parent);\n gen_name_to(addr->var_name);\n add_insn(parent, bb, OP_add, addr,\n struct_addr, offset, 0, NULL);\n field_addr = addr;\n }\n\n /* Write field value */\n int field_size = size_var(field);\n add_insn(parent, bb, OP_write, NULL, field_addr,\n field_val, field_size, NULL);\n }\n\n field_idx++;\n if (!lex_accept(T_comma))\n break;\n if (lex_peek(T_close_curly, NULL))\n break;\n }\n }\n lex_expect(T_close_curly);\n } else {\n read_expr(parent, &bb);\n\n rs1 = resize_var(parent, &bb, opstack_pop(), nv);\n add_insn(parent, bb, OP_assign, nv, rs1, NULL, 0, NULL);\n }\n }\n }\n lex_expect(T_semicolon);\n return bb;\n }\n\n /* is a function call? Skip function call check when has_asterisk is true */\n if (!has_asterisk) {\n func = find_func(token);\n if (func) {\n lex_expect(T_identifier);\n read_func_call(func, parent, &bb);\n perform_side_effect(parent, bb);\n lex_expect(T_semicolon);\n return bb;\n }\n }\n\n /* handle pointer dereference expressions like *ptr = value */\n if (lex_peek(T_asterisk, NULL)) {\n read_expr(parent, &bb);\n read_ternary_operation(parent, &bb);\n\n /* Check if it's an assignment */\n if (lex_accept(T_assign)) {\n var_t *lvalue = opstack_pop();\n read_expr(parent, &bb);\n read_ternary_operation(parent, &bb);\n var_t *rvalue = opstack_pop();\n\n /* Generate OP_write for pointer dereference assignment */\n add_insn(parent, bb, OP_write, NULL, lvalue, rvalue,\n get_size(rvalue), NULL);\n } else {\n /* Expression statement without assignment */\n perform_side_effect(parent, bb);\n }\n lex_expect(T_semicolon);\n return bb;\n }\n\n /* is an assignment? */\n if (read_body_assignment(token, parent, prefix_op, &bb)) {\n perform_side_effect(parent, bb);\n lex_expect(T_semicolon);\n return bb;\n }\n\n if (lex_peek(T_identifier, token)) {\n lex_accept(T_identifier);\n token_t *id_tk = cur_token;\n if (lex_accept(T_colon)) {\n label_t *l = find_label(token);\n if (l)\n error_at(\"label redefinition\", &id_tk->location);\n\n basic_block_t *n = bb_create(parent);\n bb_connect(bb, n, NEXT);\n add_label(token, n);\n add_insn(parent, n, OP_label, NULL, NULL, NULL, 0, token);\n return n;\n }\n }\n\n error_at(\"Unrecognized statement token\", next_token_loc());\n return NULL;\n}\n\nbasic_block_t *read_code_block(func_t *func, block_t *parent, basic_block_t *bb)\n{\n block_t *blk = add_block(parent, func);\n bb->scope = blk;\n\n lex_expect(T_open_curly);\n\n while (!lex_accept(T_close_curly)) {\n bb = read_body_statement(blk, bb);\n perform_side_effect(blk, bb);\n }\n\n return bb;\n}\n\nvoid var_add_killed_bb(var_t *var, basic_block_t *bb);\n\nvoid read_func_body(func_t *func)\n{\n block_t *blk = add_block(NULL, func);\n func->bbs = bb_create(blk);\n func->exit = bb_create(blk);\n\n for (int i = 0; i < func->num_params; i++) {\n /* arguments */\n add_symbol(func->bbs, &func->param_defs[i]);\n func->param_defs[i].base = &func->param_defs[i];\n var_add_killed_bb(&func->param_defs[i], func->bbs);\n }\n basic_block_t *body = read_code_block(func, NULL, func->bbs);\n if (body)\n bb_connect(body, func->exit, NEXT);\n\n for (int i = 0; i < backpatch_bb_idx; i++) {\n basic_block_t *bb = backpatch_bb[i];\n insn_t *g = bb->insn_list.tail;\n label_t *label = find_label(g->str);\n if (!label)\n error_at(\"goto label undefined\", cur_token_loc());\n\n label->used = true;\n bb_connect(bb, label->bb, NEXT);\n }\n\n for (int i = 0; i < label_idx; i++) {\n label_t *label = &labels[i];\n if (label->used)\n continue;\n\n printf(\"Warning: unused label %s\\n\", label->label_name);\n }\n\n backpatch_bb_idx = 0;\n label_idx = 0;\n}\n\nvoid print_ptr_level(int level)\n{\n while (level > 0) {\n printf(\"*\");\n level--;\n }\n}\n\nvoid print_func_decl(func_t *func, const char *prefix, bool newline)\n{\n if (prefix)\n printf(\"%s\", prefix);\n\n if (func->return_def.is_const_qualified)\n printf(\"const \");\n printf(\"%s \", func->return_def.type->type_name);\n print_ptr_level(func->return_def.ptr_level -\n func->return_def.type->ptr_level);\n printf(\"%s(\", func->return_def.var_name);\n\n for (int i = 0; i < func->num_params; i++) {\n var_t *var = &func->param_defs[i];\n\n if (var->is_const_qualified)\n printf(\"const \");\n printf(\"%s \", var->type->type_name);\n\n print_ptr_level(var->ptr_level - var->type->ptr_level);\n\n printf(\"%s\", var->var_name);\n\n if (i != func->num_params - 1)\n printf(\", \");\n }\n\n if (func->va_args)\n printf(\", ...\");\n printf(\")\");\n\n if (newline)\n printf(\"\\n\");\n}\n\n/* if first token is type */\nvoid read_global_decl(block_t *block, bool is_const)\n{\n var_t *var = require_var(block);\n var->is_global = true;\n var->is_const_qualified = is_const;\n\n /* new function, or variables under parent */\n read_full_var_decl(var, false, false);\n\n if (lex_peek(T_open_bracket, NULL)) {\n /* function */\n func_t *func = find_func(var->var_name);\n func_t func_tmp;\n bool check_decl = false;\n\n if (func) {\n memcpy(&func_tmp, func, sizeof(func_t));\n check_decl = true;\n } else\n func = add_func(var->var_name, false);\n\n memcpy(&func->return_def, var, sizeof(var_t));\n block->locals.size--;\n read_parameter_list_decl(func, 0);\n\n if (check_decl) {\n /* Validate whether the previous declaration and the current\n * one differ.\n */\n if ((func->return_def.type != func_tmp.return_def.type) ||\n (func->return_def.ptr_level != func_tmp.return_def.ptr_level) ||\n (func->return_def.is_const_qualified !=\n func_tmp.return_def.is_const_qualified)) {\n printf(\"Error: conflicting types for the function %s.\\n\",\n func->return_def.var_name);\n print_func_decl(&func_tmp, \"before: \", true);\n print_func_decl(func, \"after: \", true);\n abort();\n }\n\n if (func->num_params != func_tmp.num_params) {\n printf(\n \"Error: confilcting number of arguments for the function \"\n \"%s.\\n\",\n func->return_def.var_name);\n print_func_decl(&func_tmp, \"before: \", true);\n print_func_decl(func, \"after: \", true);\n abort();\n }\n\n for (int i = 0; i < func->num_params; i++) {\n var_t *func_var = &func->param_defs[i];\n var_t *func_tmp_var = &func_tmp.param_defs[i];\n if ((func_var->type != func_tmp_var->type) ||\n (func_var->ptr_level != func_tmp_var->ptr_level) ||\n (func_var->is_const_qualified !=\n func_tmp_var->is_const_qualified)) {\n printf(\"Error: confilcting types for the function %s.\\n\",\n func->return_def.var_name);\n print_func_decl(&func_tmp, \"before: \", true);\n print_func_decl(func, \"after: \", true);\n abort();\n }\n }\n\n if (func->va_args != func_tmp.va_args) {\n printf(\"Error: conflicting types for the function %s.\\n\",\n func->return_def.var_name);\n print_func_decl(&func_tmp, \"before: \", true);\n print_func_decl(func, \"after: \", true);\n abort();\n }\n }\n\n if (lex_peek(T_open_curly, NULL)) {\n read_func_body(func);\n return;\n }\n if (lex_accept(T_semicolon)) /* forward definition */\n return;\n error_at(\"Syntax error in global declaration\", next_token_loc());\n } else\n add_insn(block, GLOBAL_FUNC->bbs, OP_allocat, var, NULL, NULL, 0, NULL);\n\n /* is a variable */\n if (lex_accept(T_assign)) {\n /* If '{' follows and this is an array (explicit or implicit-size via\n * pointer syntax), reuse the array initializer to emit per-element\n * stores for globals as well.\n */\n if (lex_peek(T_open_curly, NULL) &&\n (var->array_size > 0 || var->ptr_level > 0)) {\n parse_array_init(var, block, &GLOBAL_FUNC->bbs, true);\n lex_expect(T_semicolon);\n return;\n }\n\n /* Otherwise fall back to scalar/constant global assignment */\n read_global_assignment(var->var_name);\n lex_expect(T_semicolon);\n return;\n } else if (lex_accept(T_comma)) {\n /* TODO: Implement global variable continuation syntax for multiple\n * declarations in single statement (e.g., int a = 1, b = 2;)\n */\n error_at(\"Global continuation not supported\", cur_token_loc());\n } else if (lex_accept(T_semicolon)) {\n opstack_pop();\n return;\n }\n error_at(\"Syntax error in global declaration\", next_token_loc());\n}\n\nvoid consume_global_compound_literal(void)\n{\n lex_expect(T_open_curly);\n\n if (!lex_peek(T_close_curly, NULL)) {\n for (;;) {\n /* Just consume constant values for now */\n if (lex_peek(T_numeric, NULL)) {\n lex_accept(T_numeric);\n } else if (lex_peek(T_minus, NULL)) {\n lex_accept(T_minus);\n lex_accept(T_numeric);\n } else if (lex_peek(T_string, NULL)) {\n lex_accept(T_string);\n } else if (lex_peek(T_char, NULL)) {\n lex_accept(T_char);\n } else {\n error_at(\n \"Global struct initialization requires constant values\",\n next_token_loc());\n }\n\n if (!lex_accept(T_comma))\n break;\n if (lex_peek(T_close_curly, NULL))\n break;\n }\n }\n lex_expect(T_close_curly);\n}\n\nvoid initialize_struct_field(var_t *nv, var_t *v, int offset)\n{\n nv->type = v->type;\n nv->var_name[0] = '\\0';\n nv->ptr_level = 0;\n nv->is_func = false;\n nv->is_global = false;\n nv->is_const_qualified = false;\n nv->array_size = 0;\n nv->offset = offset;\n nv->init_val = 0;\n nv->liveness = 0;\n nv->in_loop = 0;\n nv->base = NULL;\n nv->subscript = 0;\n nv->subscripts_idx = 0;\n nv->is_compound_literal = false;\n}\n\nvoid read_global_statement(void)\n{\n char token[MAX_ID_LEN];\n block_t *block = GLOBAL_BLOCK; /* global block */\n bool is_const = false;\n\n /* Handle const qualifier */\n if (lex_accept(T_const))\n is_const = true;\n\n if (lex_accept(T_struct)) {\n int i = 0, size = 0;\n\n lex_ident(T_identifier, token);\n token_t *id_tk = cur_token;\n\n /* variable declaration using existing struct tag? */\n if (!lex_peek(T_open_curly, NULL)) {\n type_t *decl_type = find_type(token, 2);\n if (!decl_type)\n error_at(\"Unknown struct type\", &id_tk->location);\n\n /* one or more declarators */\n var_t *var = require_typed_var(block, decl_type);\n var->is_global = true; /* Global struct variable */\n var->is_const_qualified = is_const;\n read_partial_var_decl(var, NULL);\n add_insn(block, GLOBAL_FUNC->bbs, OP_allocat, var, NULL, NULL, 0,\n NULL);\n if (lex_accept(T_assign)) {\n if (lex_peek(T_open_curly, NULL) &&\n (var->array_size > 0 || var->ptr_level > 0)) {\n parse_array_init(var, block, &GLOBAL_FUNC->bbs, true);\n } else if (lex_peek(T_open_curly, NULL) &&\n var->array_size == 0 && var->ptr_level == 0 &&\n (decl_type->base_type == TYPE_struct ||\n decl_type->base_type == TYPE_typedef)) {\n /* Global struct compound literal support\n * Currently we just consume the syntax - actual\n * initialization would require runtime code which globals\n * don't support\n */\n consume_global_compound_literal();\n } else {\n read_global_assignment(var->var_name);\n }\n }\n while (lex_accept(T_comma)) {\n var_t *nv = require_typed_var(block, decl_type);\n read_inner_var_decl(nv, false, false);\n add_insn(block, GLOBAL_FUNC->bbs, OP_allocat, nv, NULL, NULL, 0,\n NULL);\n if (lex_accept(T_assign)) {\n if (lex_peek(T_open_curly, NULL) &&\n (nv->array_size > 0 || nv->ptr_level > 0)) {\n parse_array_init(nv, block, &GLOBAL_FUNC->bbs, true);\n } else if (lex_peek(T_open_curly, NULL) &&\n nv->array_size == 0 && nv->ptr_level == 0 &&\n (decl_type->base_type == TYPE_struct ||\n decl_type->base_type == TYPE_typedef)) {\n /* Global struct compound literal support for\n * continuation Currently we just consume the syntax\n */\n consume_global_compound_literal();\n } else {\n read_global_assignment(nv->var_name);\n }\n }\n }\n lex_expect(T_semicolon);\n return;\n }\n\n /* struct definition */\n /* has forward declaration? */\n type_t *type = find_type(token, 2);\n if (!type)\n type = add_type();\n\n strcpy(type->type_name, intern_string(token));\n type->base_type = TYPE_struct;\n\n lex_expect(T_open_curly);\n do {\n var_t *v = &type->fields[i++];\n read_full_var_decl(v, false, true);\n v->offset = size;\n size += size_var(v);\n\n /* Handle multiple variable declarations with same base type */\n while (lex_accept(T_comma)) {\n if (i >= MAX_FIELDS)\n error_at(\"Too many struct fields\", cur_token_loc());\n\n var_t *nv = &type->fields[i++];\n initialize_struct_field(nv, v, 0);\n read_inner_var_decl(nv, false, true);\n nv->offset = size;\n size += size_var(nv);\n }\n\n lex_expect(T_semicolon);\n } while (!lex_accept(T_close_curly));\n\n type->size = size;\n type->num_fields = i;\n lex_expect(T_semicolon);\n } else if (lex_accept(T_union)) {\n int i = 0, max_size = 0;\n\n lex_ident(T_identifier, token);\n\n /* has forward declaration? */\n type_t *type = find_type(token, 2);\n if (!type)\n type = add_type();\n\n strcpy(type->type_name, intern_string(token));\n type->base_type = TYPE_union;\n\n lex_expect(T_open_curly);\n do {\n var_t *v = &type->fields[i++];\n read_full_var_decl(v, false, true);\n v->offset = 0; /* All union fields start at offset 0 */\n int field_size = size_var(v);\n if (field_size > max_size)\n max_size = field_size;\n\n /* Handle multiple variable declarations with same base type */\n while (lex_accept(T_comma)) {\n if (i >= MAX_FIELDS)\n error_at(\"Too many union fields\", cur_token_loc());\n\n var_t *nv = &type->fields[i++];\n /* All union fields start at offset 0 */\n initialize_struct_field(nv, v, 0);\n read_inner_var_decl(nv, false, true);\n field_size = size_var(nv);\n if (field_size > max_size)\n max_size = field_size;\n }\n\n lex_expect(T_semicolon);\n } while (!lex_accept(T_close_curly));\n\n type->size = max_size;\n type->num_fields = i;\n lex_expect(T_semicolon);\n } else if (lex_accept(T_typedef)) {\n if (lex_accept(T_enum)) {\n int val = 0;\n type_t *type = add_type();\n\n type->base_type = TYPE_int;\n type->size = 4;\n lex_expect(T_open_curly);\n do {\n lex_ident(T_identifier, token);\n if (lex_accept(T_assign)) {\n char value[MAX_ID_LEN];\n lex_ident(T_numeric, value);\n val = parse_numeric_constant(value);\n }\n add_constant(token, val++);\n } while (lex_accept(T_comma));\n lex_expect(T_close_curly);\n lex_ident(T_identifier, token);\n strcpy(type->type_name, intern_string(token));\n lex_expect(T_semicolon);\n } else if (lex_accept(T_struct)) {\n int i = 0, size = 0;\n bool has_struct_def = false;\n type_t *tag = NULL, *type = add_type();\n\n /* is struct definition? */\n if (lex_peek(T_identifier, token)) {\n lex_expect(T_identifier);\n\n /* is existent? */\n tag = find_type(token, 2);\n if (!tag) {\n tag = add_type();\n tag->base_type = TYPE_struct;\n strcpy(tag->type_name, intern_string(token));\n }\n }\n\n /* typedef with struct definition */\n if (lex_accept(T_open_curly)) {\n has_struct_def = true;\n do {\n var_t *v = &type->fields[i++];\n read_full_var_decl(v, false, true);\n v->offset = size;\n size += size_var(v);\n\n /* Handle multiple variable declarations with same base type\n */\n while (lex_accept(T_comma)) {\n if (i >= MAX_FIELDS)\n error_at(\"Too many struct fields\", cur_token_loc());\n\n var_t *nv = &type->fields[i++];\n initialize_struct_field(nv, v, 0);\n read_inner_var_decl(nv, false, true);\n nv->offset = size;\n size += size_var(nv);\n }\n\n lex_expect(T_semicolon);\n } while (!lex_accept(T_close_curly));\n }\n\n lex_ident(T_identifier, type->type_name);\n type->size = size;\n type->num_fields = i;\n type->base_type = TYPE_typedef;\n\n if (tag && has_struct_def == 1) {\n strcpy(token, tag->type_name);\n memcpy(tag, type, sizeof(type_t));\n tag->base_type = TYPE_struct;\n strcpy(tag->type_name, intern_string(token));\n } else {\n /* If it is a forward declaration, build a connection between\n * structure tag and alias. In 'find_type', it will retrieve\n * infomation from base structure for alias.\n */\n type->base_struct = tag;\n }\n\n lex_expect(T_semicolon);\n } else if (lex_accept(T_union)) {\n int i = 0, max_size = 0;\n bool has_union_def = false;\n type_t *tag = NULL, *type = add_type();\n\n /* is union definition? */\n if (lex_peek(T_identifier, token)) {\n lex_expect(T_identifier);\n\n /* is existent? */\n tag = find_type(token, 2);\n if (!tag) {\n tag = add_type();\n tag->base_type = TYPE_union;\n strcpy(tag->type_name, intern_string(token));\n }\n }\n\n /* typedef with union definition */\n if (lex_accept(T_open_curly)) {\n has_union_def = true;\n do {\n var_t *v = &type->fields[i++];\n read_full_var_decl(v, false, true);\n v->offset = 0; /* All union fields start at offset 0 */\n int field_size = size_var(v);\n if (field_size > max_size)\n max_size = field_size;\n\n /* Handle multiple variable declarations with same base type\n */\n while (lex_accept(T_comma)) {\n if (i >= MAX_FIELDS)\n error_at(\"Too many union fields\", cur_token_loc());\n\n var_t *nv = &type->fields[i++];\n /* All union fields start at offset 0 */\n initialize_struct_field(nv, v, 0);\n read_inner_var_decl(nv, false, true);\n field_size = size_var(nv);\n if (field_size > max_size)\n max_size = field_size;\n }\n\n lex_expect(T_semicolon);\n } while (!lex_accept(T_close_curly));\n }\n\n lex_ident(T_identifier, type->type_name);\n type->size = max_size;\n type->num_fields = i;\n type->base_type = TYPE_typedef;\n\n if (tag && has_union_def == 1) {\n strcpy(token, tag->type_name);\n memcpy(tag, type, sizeof(type_t));\n tag->base_type = TYPE_union;\n strcpy(tag->type_name, intern_string(token));\n } else {\n /* If it is a forward declaration, build a connection between\n * union tag and alias. In 'find_type', it will retrieve\n * information from base union for alias.\n */\n type->base_struct = tag;\n }\n\n lex_expect(T_semicolon);\n } else {\n char base_type[MAX_TYPE_LEN];\n type_t *base;\n type_t *type = add_type();\n lex_ident(T_identifier, base_type);\n base = find_type(base_type, true);\n if (!base)\n error_at(\"Unable to find base type\", cur_token_loc());\n type->base_type = base->base_type;\n type->size = base->size;\n type->num_fields = 0;\n type->ptr_level = 0;\n\n /* Handle pointer types in typedef: typedef char *string; */\n while (lex_accept(T_asterisk)) {\n type->ptr_level++;\n type->size = PTR_SIZE;\n }\n\n lex_ident(T_identifier, type->type_name);\n lex_expect(T_semicolon);\n }\n } else if (lex_peek(T_identifier, NULL)) {\n read_global_decl(block, is_const);\n } else\n error_at(\"Syntax error in global statement\", next_token_loc());\n}\n\nvoid parse_internal(void)\n{\n /* set starting point of global stack manually */\n GLOBAL_FUNC = add_func(\"\", true);\n GLOBAL_FUNC->stack_size = 4;\n GLOBAL_FUNC->bbs = arena_calloc(BB_ARENA, 1, sizeof(basic_block_t));\n GLOBAL_FUNC->bbs->belong_to = GLOBAL_FUNC; /* Prevent nullptr deref in RA */\n\n /* built-in types */\n TY_void = add_named_type(\"void\");\n TY_void->base_type = TYPE_void;\n TY_void->size = 0;\n\n TY_char = add_named_type(\"char\");\n TY_char->base_type = TYPE_char;\n TY_char->size = 1;\n\n TY_int = add_named_type(\"int\");\n TY_int->base_type = TYPE_int;\n TY_int->size = 4;\n\n TY_short = add_named_type(\"short\");\n TY_short->base_type = TYPE_short;\n TY_short->size = 2;\n\n /* builtin type _Bool was introduced in C99 specification, it is more\n * well-known as macro type bool, which is defined in (in\n * shecc, it is defined in 'lib/c.c').\n */\n TY_bool = add_named_type(\"_Bool\");\n TY_bool->base_type = TYPE_char;\n TY_bool->size = 1;\n\n GLOBAL_BLOCK = add_block(NULL, NULL); /* global block */\n elf_add_symbol(\"\", 0); /* undef symbol */\n\n if (dynlink) {\n /* In dynamic mode, __syscall won't be implemented.\n *\n * Simply declare a 'syscall' function as follows if the program\n * needs to use 'syscall':\n *\n * int syscall(int number, ...);\n *\n * shecc will treat it as an external function, and the compiled\n * program will eventually use the implementation provided by\n * the external C library.\n *\n * If shecc supports the 'long' data type in the future, it would be\n * better to declare syscall using its original prototype:\n *\n * long syscall(long number, ...);\n * */\n } else {\n /* Linux syscall */\n func_t *func = add_func(\"__syscall\", true);\n func->return_def.type = TY_int;\n func->num_params = 0;\n func->va_args = 1;\n func->bbs = NULL;\n /* Otherwise, allocate a basic block to implement in static mode. */\n func->bbs = arena_calloc(BB_ARENA, 1, sizeof(basic_block_t));\n }\n\n /* Add a global object to the .data section.\n *\n * This object is used to save the global stack pointer.\n */\n elf_write_int(elf_data, 0);\n\n /* lexer initialization */\n do {\n read_global_statement();\n } while (!lex_accept(T_eof));\n}\n\nvoid parse(token_t *tk)\n{\n token_t head;\n head.kind = T_start;\n head.next = tk;\n cur_token = &head;\n\n parse_internal();\n}\n" }, { "path": "src/peephole.c", "content": "/*\n * shecc - Self-Hosting and Educational C Compiler.\n *\n * shecc is freely redistributable under the BSD 2 clause license. See the\n * file \"LICENSE\" for information on usage and redistribution of this file.\n */\n#include \n\n#include \"defs.h\"\n#include \"globals.c\"\n\n/* Determines if an instruction can be fused with a following OP_assign.\n * Fusible instructions are those whose results can be directly written\n * to the final destination register, eliminating intermediate moves.\n */\nbool is_fusible_insn(ph2_ir_t *ph2_ir)\n{\n switch (ph2_ir->op) {\n case OP_add: /* Arithmetic operations */\n case OP_sub:\n case OP_mul:\n case OP_div:\n case OP_mod:\n case OP_lshift: /* Shift operations */\n case OP_rshift:\n case OP_bit_and: /* Bitwise operations */\n case OP_bit_or:\n case OP_bit_xor:\n case OP_log_and: /* Logical operations */\n case OP_log_or:\n case OP_log_not:\n case OP_negate: /* Unary operations */\n case OP_load: /* Memory operations */\n case OP_global_load:\n case OP_load_data_address:\n case OP_load_rodata_address:\n return true;\n default:\n return false;\n }\n}\n\n/* Main peephole optimization function that applies pattern matching\n * and transformation rules to consecutive IR instructions.\n * Returns true if any optimization was applied, false otherwise.\n */\nbool insn_fusion(ph2_ir_t *ph2_ir)\n{\n ph2_ir_t *next = ph2_ir->next;\n if (!next)\n return false;\n\n /* ALU instruction fusion.\n * Eliminates redundant move operations following arithmetic/logical\n * operations. This is the most fundamental optimization that removes\n * temporary register usage.\n */\n if (next->op == OP_assign) {\n if (is_fusible_insn(ph2_ir) && ph2_ir->dest == next->src0) {\n /* Pattern: {ALU rn, rs1, rs2; mv rd, rn} → {ALU rd, rs1, rs2}\n * Example: {add t1, a, b; mv result, t1} → {add result, a, b}\n */\n ph2_ir->dest = next->dest;\n ph2_ir->next = next->next;\n return true;\n }\n }\n\n /* Arithmetic identity with zero constant */\n if (ph2_ir->op == OP_load_constant && ph2_ir->src0 == 0) {\n if (next->op == OP_add &&\n (ph2_ir->dest == next->src0 || ph2_ir->dest == next->src1)) {\n /* Pattern: {li 0; add x, 0} → {mov x} (additive identity: x+0 = x)\n * Handles both operand positions due to addition commutativity\n * Example: {li t1, 0; add result, var, t1} → {mov result, var}\n */\n int non_zero_src =\n (ph2_ir->dest == next->src0) ? next->src1 : next->src0;\n\n ph2_ir->op = OP_assign;\n ph2_ir->src0 = non_zero_src;\n ph2_ir->dest = next->dest;\n ph2_ir->next = next->next;\n return true;\n }\n\n if (next->op == OP_sub) {\n if (ph2_ir->dest == next->src1) {\n /* Pattern: {li 0; sub x, 0} → {mov x} (x - 0 = x)\n * Example: {li t1, 0; sub result, var, t1} → {mov result, var}\n */\n ph2_ir->op = OP_assign;\n ph2_ir->src0 = next->src0;\n ph2_ir->dest = next->dest;\n ph2_ir->next = next->next;\n return true;\n }\n\n if (ph2_ir->dest == next->src0) {\n /* Pattern: {li 0; sub 0, x} → {neg x} (0 - x = -x)\n * Example: {li t1, 0; sub result, t1, var} → {neg result, var}\n */\n ph2_ir->op = OP_negate;\n ph2_ir->src0 = next->src1;\n ph2_ir->dest = next->dest;\n ph2_ir->next = next->next;\n return true;\n }\n }\n\n if (next->op == OP_mul &&\n (ph2_ir->dest == next->src0 || ph2_ir->dest == next->src1)) {\n /* Pattern: {li 0; mul x, 0} → {li 0} (absorbing element: x * 0 = 0)\n * Example: {li t1, 0; mul result, var, t1} → {li result, 0}\n * Eliminates multiplication entirely\n */\n ph2_ir->op = OP_load_constant;\n ph2_ir->src0 = 0;\n ph2_ir->dest = next->dest;\n ph2_ir->next = next->next;\n return true;\n }\n }\n\n /* Multiplicative identity with one constant */\n if (ph2_ir->op == OP_load_constant && ph2_ir->src0 == 1) {\n if (next->op == OP_mul &&\n (ph2_ir->dest == next->src0 || ph2_ir->dest == next->src1)) {\n /* Pattern: {li 1; mul x, 1} → {mov x} (multiplicative identity:\n * x * 1 = x)\n * Example: {li t1, 1; mul result, var, t1} → {mov result, var}\n * Handles both operand positions due to multiplication\n * commutativity\n */\n ph2_ir->op = OP_assign;\n ph2_ir->src0 = ph2_ir->dest == next->src0 ? next->src1 : next->src0;\n ph2_ir->dest = next->dest;\n ph2_ir->next = next->next;\n return true;\n }\n }\n\n /* Bitwise identity operations */\n if (ph2_ir->op == OP_load_constant && ph2_ir->src0 == -1 &&\n next->op == OP_bit_and && ph2_ir->dest == next->src1) {\n /* Pattern: {li -1; and x, -1} → {mov x} (x & 0xFFFFFFFF = x)\n * Example: {li t1, -1; and result, var, t1} → {mov result, var}\n * Eliminates bitwise AND with all-ones mask\n */\n ph2_ir->op = OP_assign;\n ph2_ir->src0 = next->src0;\n ph2_ir->dest = next->dest;\n ph2_ir->next = next->next;\n return true;\n }\n\n if (ph2_ir->op == OP_load_constant && ph2_ir->src0 == 0 &&\n (next->op == OP_lshift || next->op == OP_rshift) &&\n ph2_ir->dest == next->src1) {\n /* Pattern: {li 0; shl/shr x, 0} → {mov x} (x << 0 = x >> 0 = x)\n * Example: {li t1, 0; shl result, var, t1} → {mov result, var}\n * Eliminates no-op shift operations\n */\n ph2_ir->op = OP_assign;\n ph2_ir->src0 = next->src0;\n ph2_ir->dest = next->dest;\n ph2_ir->next = next->next;\n return true;\n }\n\n if (ph2_ir->op == OP_load_constant && ph2_ir->src0 == 0 &&\n next->op == OP_bit_or && ph2_ir->dest == next->src1) {\n /* Pattern: {li 0; or x, 0} → {mov x} (x | 0 = x)\n * Example: {li t1, 0; or result, var, t1} → {mov result, var}\n * Eliminates bitwise OR with zero (identity element)\n */\n ph2_ir->op = OP_assign;\n ph2_ir->src0 = next->src0;\n ph2_ir->dest = next->dest;\n ph2_ir->next = next->next;\n return true;\n }\n\n /* Power-of-2 multiplication to shift conversion.\n * Shift operations are significantly faster than multiplication\n */\n if (ph2_ir->op == OP_load_constant && ph2_ir->src0 > 0 &&\n next->op == OP_mul && ph2_ir->dest == next->src1) {\n int power = ph2_ir->src0;\n /* Detect power-of-2 using bit manipulation: (n & (n-1)) == 0 for powers\n * of 2\n */\n if (power && (power & (power - 1)) == 0) {\n /* Calculate log2(power) to determine shift amount */\n int shift_amount = 0;\n int tmp = power;\n while (tmp > 1) {\n tmp >>= 1;\n shift_amount++;\n }\n /* Pattern: {li 2^n; mul x, 2^n} → {li n; shl x, n}\n * Example: {li t1, 4; mul result, var, t1} →\n * {li t1, 2; shl result, var, t1}\n */\n ph2_ir->op = OP_load_constant;\n ph2_ir->src0 = shift_amount;\n next->op = OP_lshift;\n return true;\n }\n }\n\n /* XOR identity operation */\n if (ph2_ir->op == OP_load_constant && ph2_ir->src0 == 0 &&\n next->op == OP_bit_xor && ph2_ir->dest == next->src1) {\n /* Pattern: {li 0; xor x, 0} → {mov x} (x ^ 0 = x)\n * Example: {li t1, 0; xor result, var, t1} → {mov result, var}\n * Completes bitwise identity optimization coverage\n */\n ph2_ir->op = OP_assign;\n ph2_ir->src0 = next->src0;\n ph2_ir->dest = next->dest;\n ph2_ir->next = next->next;\n return true;\n }\n\n /* Extended multiplicative identity (operand position variant)\n * Handles the case where constant 1 is in src0 position of multiplication\n */\n if (ph2_ir->op == OP_load_constant && ph2_ir->src0 == 1 &&\n next->op == OP_mul && ph2_ir->dest == next->src0) {\n /* Pattern: {li 1; mul 1, x} → {mov x} (1 * x = x)\n * Example: {li t1, 1; mul result, t1, var} → {mov result, var}\n * Covers multiplication commutativity edge case\n */\n ph2_ir->op = OP_assign;\n ph2_ir->src0 = next->src1;\n ph2_ir->dest = next->dest;\n ph2_ir->next = next->next;\n return true;\n }\n\n return false;\n}\n\n/* Redundant move elimination\n * Eliminates unnecessary move operations that are overwritten or redundant\n */\nbool redundant_move_elim(ph2_ir_t *ph2_ir)\n{\n ph2_ir_t *next = ph2_ir->next;\n if (!next)\n return false;\n\n /* Pattern 1: Consecutive assignments to same destination\n * {mov rd, rs1; mov rd, rs2} → {mov rd, rs2}\n * The first move is completely overwritten by the second\n */\n if (ph2_ir->op == OP_assign && next->op == OP_assign &&\n ph2_ir->dest == next->dest) {\n /* Replace first move with second, skip second */\n ph2_ir->src0 = next->src0;\n ph2_ir->next = next->next;\n return true;\n }\n\n /* Pattern 2: Redundant load immediately overwritten\n * {load rd, offset; mov rd, rs} → {mov rd, rs}\n * Loading a value that's immediately replaced is wasteful\n */\n if ((ph2_ir->op == OP_load || ph2_ir->op == OP_global_load) &&\n next->op == OP_assign && ph2_ir->dest == next->dest) {\n /* Replace load with move */\n ph2_ir->op = OP_assign;\n ph2_ir->src0 = next->src0;\n ph2_ir->src1 = 0; /* Clear unused field */\n ph2_ir->next = next->next;\n return true;\n }\n\n /* Pattern 3: Load constant immediately overwritten\n * {li rd, imm; mov rd, rs} → {mov rd, rs}\n * Loading a constant that's immediately replaced\n */\n if (ph2_ir->op == OP_load_constant && next->op == OP_assign &&\n ph2_ir->dest == next->dest) {\n /* Replace constant load with move */\n ph2_ir->op = OP_assign;\n ph2_ir->src0 = next->src0;\n ph2_ir->next = next->next;\n return true;\n }\n\n /* Pattern 4: Consecutive loads to same register\n * {load rd, offset1; load rd, offset2} → {load rd, offset2}\n * First load is pointless if immediately overwritten\n */\n if ((ph2_ir->op == OP_load || ph2_ir->op == OP_global_load) &&\n (next->op == OP_load || next->op == OP_global_load) &&\n ph2_ir->dest == next->dest) {\n /* Keep only the second load */\n ph2_ir->op = next->op;\n ph2_ir->src0 = next->src0;\n ph2_ir->src1 = next->src1;\n ph2_ir->next = next->next;\n return true;\n }\n\n /* Pattern 5: Consecutive constant loads (already handled in main loop\n * but included here for completeness)\n * {li rd, imm1; li rd, imm2} → {li rd, imm2}\n */\n if (ph2_ir->op == OP_load_constant && next->op == OP_load_constant &&\n ph2_ir->dest == next->dest) {\n /* Keep only the second constant */\n ph2_ir->src0 = next->src0;\n ph2_ir->next = next->next;\n return true;\n }\n\n /* Pattern 6: Move followed by load\n * {mov rd, rs; load rd, offset} → {load rd, offset}\n * The move is pointless if immediately overwritten by load\n */\n if (ph2_ir->op == OP_assign &&\n (next->op == OP_load || next->op == OP_global_load) &&\n ph2_ir->dest == next->dest) {\n /* Replace move+load with just the load */\n ph2_ir->op = next->op;\n ph2_ir->src0 = next->src0;\n ph2_ir->src1 = next->src1;\n ph2_ir->next = next->next;\n return true;\n }\n\n /* Pattern 7: Move followed by constant load\n * {mov rd, rs; li rd, imm} → {li rd, imm}\n * The move is pointless if immediately overwritten by constant\n */\n if (ph2_ir->op == OP_assign && next->op == OP_load_constant &&\n ph2_ir->dest == next->dest) {\n /* Replace move+li with just the li */\n ph2_ir->op = OP_load_constant;\n ph2_ir->src0 = next->src0;\n ph2_ir->src1 = 0; /* Clear unused field */\n ph2_ir->next = next->next;\n return true;\n }\n\n return false;\n}\n\n/* Load/store elimination for consecutive memory operations.\n * Removes redundant loads and dead stores that access the same memory location.\n * Conservative implementation to maintain bootstrap stability.\n */\nbool eliminate_load_store_pairs(ph2_ir_t *ph2_ir)\n{\n ph2_ir_t *next = ph2_ir->next;\n if (!next)\n return false;\n\n /* Only handle local loads/stores for now (not globals) to be safe */\n\n /* Pattern 1: Consecutive stores to same local location\n * {store [addr], val1; store [addr], val2} → {store [addr], val2}\n * First store is dead if immediately overwritten\n */\n if (ph2_ir->op == OP_store && next->op == OP_store) {\n /* Check if storing to same memory location */\n if (ph2_ir->src0 == next->src0 && ph2_ir->src1 == next->src1 &&\n ph2_ir->src0 >= 0 && ph2_ir->src1 >= 0) {\n /* Remove first store - it's dead */\n ph2_ir->dest = next->dest;\n ph2_ir->next = next->next;\n return true;\n }\n }\n\n /* Pattern 2: Redundant consecutive loads from same local location\n * {load rd1, [addr]; load rd2, [addr]} → {load rd1, [addr]; mov rd2, rd1}\n * Second load can reuse the first load's result\n * Only apply if addresses are simple (not complex expressions)\n */\n if (ph2_ir->op == OP_load && next->op == OP_load) {\n /* Check if loading from same memory location */\n if (ph2_ir->src0 == next->src0 && ph2_ir->src1 == next->src1 &&\n ph2_ir->src0 >= 0 && ph2_ir->src1 >= 0) {\n /* Replace second load with move */\n next->op = OP_assign;\n next->src0 = ph2_ir->dest; /* Result of first load */\n next->src1 = 0;\n return true;\n }\n }\n\n /* Pattern 3: Store followed by load from same location (store-to-load\n * forwarding) {store [addr], val; load rd, [addr]} → {store [addr], val;\n * mov rd, val} The load can use the stored value directly\n */\n if (ph2_ir->op == OP_store && next->op == OP_load) {\n /* Check if accessing same memory location */\n if (ph2_ir->src0 == next->src0 && ph2_ir->src1 == next->src1 &&\n ph2_ir->src0 >= 0 && ph2_ir->dest >= 0) {\n /* Replace load with move of stored value */\n next->op = OP_assign;\n next->src0 = ph2_ir->dest; /* Value that was stored */\n next->src1 = 0;\n return true;\n }\n }\n\n /* Pattern 4: Load followed by redundant store of same value\n * {load rd, [addr]; store [addr], rd} → {load rd, [addr]}\n * The store is redundant if storing back the just-loaded value\n */\n if (ph2_ir->op == OP_load && next->op == OP_store) {\n /* Check if storing the value we just loaded from same location */\n if (ph2_ir->dest == next->dest && ph2_ir->src0 == next->src0 &&\n ph2_ir->src1 == next->src1 && ph2_ir->src0 >= 0) {\n /* Remove redundant store */\n ph2_ir->next = next->next;\n return true;\n }\n }\n\n /* Pattern 5: Global store/load optimizations (carefully enabled) */\n if (ph2_ir->op == OP_global_store && next->op == OP_global_store) {\n /* Consecutive global stores to same location */\n if (ph2_ir->src0 == next->src0 && ph2_ir->src1 == next->src1) {\n /* Remove first store - it's dead */\n ph2_ir->dest = next->dest;\n ph2_ir->next = next->next;\n return true;\n }\n }\n\n if (ph2_ir->op == OP_global_load && next->op == OP_global_load) {\n /* Consecutive global loads from same location */\n if (ph2_ir->src0 == next->src0 && ph2_ir->src1 == next->src1) {\n /* Replace second load with move */\n next->op = OP_assign;\n next->src0 = ph2_ir->dest;\n next->src1 = 0;\n return true;\n }\n }\n\n return false;\n}\n\n/* Algebraic simplification: Apply mathematical identities to simplify\n * expressions\n *\n * This function handles patterns that SSA cannot see:\n * - Self-operations on registers (x-x, x^x, x|x, x&x)\n * - These patterns emerge after register allocation when different\n * variables are assigned to the same register\n *\n * SSA handles: Constant folding with known values (5+3 → 8)\n * Peephole handles: Register-based patterns (r1-r1 → 0)\n *\n * Returns true if optimization was applied\n */\nbool algebraic_simplification(ph2_ir_t *ph2_ir)\n{\n if (!ph2_ir)\n return false;\n\n /* NOTE: SSA's const_folding handles constant operations with known values.\n * We focus on register-based patterns that appear after register\n * allocation.\n */\n\n /* Pattern 1: Self-subtraction → 0\n * x - x = 0 (for register operands)\n */\n if (ph2_ir->op == OP_sub && ph2_ir->src0 == ph2_ir->src1) {\n ph2_ir->op = OP_load_constant;\n ph2_ir->src0 = 0; /* result is 0 */\n ph2_ir->src1 = 0; /* clear unused field */\n return true;\n }\n\n /* Pattern 2: Self-XOR → 0\n * x ^ x = 0 (for register operands)\n */\n if (ph2_ir->op == OP_bit_xor && ph2_ir->src0 == ph2_ir->src1) {\n ph2_ir->op = OP_load_constant;\n ph2_ir->src0 = 0; /* result is 0 */\n ph2_ir->src1 = 0; /* clear unused field */\n return true;\n }\n\n /* Pattern 3: Self-OR → x\n * x | x = x (identity operation for register operands)\n */\n if (ph2_ir->op == OP_bit_or && ph2_ir->src0 == ph2_ir->src1) {\n ph2_ir->op = OP_assign;\n /* src0 already contains x, just need to move it */\n ph2_ir->src1 = 0; /* clear unused field */\n return true;\n }\n\n /* Pattern 4: Self-AND → x\n * x & x = x (identity operation for register operands)\n */\n if (ph2_ir->op == OP_bit_and && ph2_ir->src0 == ph2_ir->src1) {\n ph2_ir->op = OP_assign;\n /* src0 already contains x, just need to move it */\n ph2_ir->src1 = 0; /* clear unused field */\n return true;\n }\n\n /* NOTE: Arithmetic identity patterns (x+0, x*1, x*0, x-0) are already\n * handled by SSA's const_folding() function and insn_fusion().\n * We focus on register-level patterns that SSA cannot see.\n */\n\n return false;\n}\n\n/* Division/modulo strength reduction: Optimize division and modulo by\n * power-of-2\n *\n * This pattern is unique to peephole optimizer.\n * SSA cannot perform this optimization because it works on virtual registers\n * before actual constant values are loaded.\n *\n * Returns true if optimization was applied\n */\nbool strength_reduction(ph2_ir_t *ph2_ir)\n{\n if (!ph2_ir || !ph2_ir->next)\n return false;\n\n ph2_ir_t *next = ph2_ir->next;\n\n /* Check for constant load followed by division or modulo */\n if (ph2_ir->op != OP_load_constant)\n return false;\n\n int value = ph2_ir->src0;\n\n /* Check if value is a power of 2 */\n if (value <= 0 || (value & (value - 1)) != 0)\n return false;\n\n /* Calculate shift amount for power of 2 */\n int shift = 0;\n int tmp = value;\n while (tmp > 1) {\n shift++;\n tmp >>= 1;\n }\n\n /* Pattern 1: Division by power of 2 → right shift\n * x / 2^n = x >> n (for unsigned)\n */\n if (next->op == OP_div && next->src1 == ph2_ir->dest) {\n /* Convert division to right shift */\n ph2_ir->src0 = shift; /* Load shift amount instead */\n next->op = OP_rshift;\n return true;\n }\n\n /* Pattern 2: Modulo by power of 2 → bitwise AND\n * x % 2^n = x & (2^n - 1)\n */\n if (next->op == OP_mod && next->src1 == ph2_ir->dest) {\n /* Convert modulo to bitwise AND */\n ph2_ir->src0 = value - 1; /* Load mask (2^n - 1) */\n next->op = OP_bit_and;\n return true;\n }\n\n /* Pattern 3: Multiplication by power of 2 → left shift\n * x * 2^n = x << n\n */\n if (next->op == OP_mul) {\n if (next->src0 == ph2_ir->dest) {\n /* 2^n * x = x << n */\n ph2_ir->src0 = shift; /* Load shift amount */\n next->op = OP_lshift;\n next->src0 = next->src1; /* Move x to src0 */\n next->src1 = ph2_ir->dest; /* Shift amount in src1 */\n return true;\n } else if (next->src1 == ph2_ir->dest) {\n /* x * 2^n = x << n */\n ph2_ir->src0 = shift; /* Load shift amount */\n next->op = OP_lshift;\n return true;\n }\n }\n\n return false;\n}\n\n/* Comparison optimization: Simplify comparison patterns\n * Focus on register-based patterns that SSA's SCCP misses\n * Returns true if optimization was applied\n */\nbool comparison_optimization(ph2_ir_t *ph2_ir)\n{\n if (!ph2_ir)\n return false;\n\n /* NOTE: SSA's SCCP handles constant comparisons, so we focus on\n * register-based self-comparisons after register allocation\n */\n\n /* Pattern 1: Self-comparison always false for !=\n * x != x → 0 (for register operands)\n */\n if (ph2_ir->op == OP_neq && ph2_ir->src0 == ph2_ir->src1) {\n ph2_ir->op = OP_load_constant;\n ph2_ir->src0 = 0; /* always false */\n ph2_ir->src1 = 0;\n return true;\n }\n\n /* Pattern 2: Self-comparison always true for ==\n * x == x → 1 (for register operands)\n */\n if (ph2_ir->op == OP_eq && ph2_ir->src0 == ph2_ir->src1) {\n ph2_ir->op = OP_load_constant;\n ph2_ir->src0 = 1; /* always true */\n ph2_ir->src1 = 0;\n return true;\n }\n\n /* Pattern 3: Self-comparison for less-than\n * x < x → 0 (always false)\n */\n if (ph2_ir->op == OP_lt && ph2_ir->src0 == ph2_ir->src1) {\n ph2_ir->op = OP_load_constant;\n ph2_ir->src0 = 0; /* always false */\n ph2_ir->src1 = 0;\n return true;\n }\n\n /* Pattern 4: Self-comparison for greater-than\n * x > x → 0 (always false)\n */\n if (ph2_ir->op == OP_gt && ph2_ir->src0 == ph2_ir->src1) {\n ph2_ir->op = OP_load_constant;\n ph2_ir->src0 = 0; /* always false */\n ph2_ir->src1 = 0;\n return true;\n }\n\n /* Pattern 5: Self-comparison for less-equal\n * x <= x → 1 (always true)\n */\n if (ph2_ir->op == OP_leq && ph2_ir->src0 == ph2_ir->src1) {\n ph2_ir->op = OP_load_constant;\n ph2_ir->src0 = 1; /* always true */\n ph2_ir->src1 = 0;\n return true;\n }\n\n /* Pattern 6: Self-comparison for greater-equal\n * x >= x → 1 (always true)\n */\n if (ph2_ir->op == OP_geq && ph2_ir->src0 == ph2_ir->src1) {\n ph2_ir->op = OP_load_constant;\n ph2_ir->src0 = 1; /* always true */\n ph2_ir->src1 = 0;\n return true;\n }\n\n return false;\n}\n\n/* Bitwise operation optimization: Simplify bitwise patterns\n * Returns true if optimization was applied\n */\nbool bitwise_optimization(ph2_ir_t *ph2_ir)\n{\n if (!ph2_ir || !ph2_ir->next)\n return false;\n\n ph2_ir_t *next = ph2_ir->next;\n\n /* Pattern 1: Double complement → identity\n * ~(~x) = x\n */\n if (ph2_ir->op == OP_negate && next->op == OP_negate &&\n next->src0 == ph2_ir->dest) {\n /* Replace with simple assignment */\n ph2_ir->op = OP_assign;\n ph2_ir->dest = next->dest;\n ph2_ir->next = next->next;\n return true;\n }\n\n /* Pattern 2: AND with all-ones mask → identity\n * x & 0xFFFFFFFF = x (for 32-bit)\n */\n if (ph2_ir->op == OP_load_constant && ph2_ir->src0 == -1 &&\n next->op == OP_bit_and && next->src1 == ph2_ir->dest) {\n /* Replace AND with assignment */\n next->op = OP_assign;\n next->src1 = 0;\n ph2_ir->next = next->next;\n return true;\n }\n\n /* Pattern 3: OR with zero → identity\n * x | 0 = x\n */\n if (ph2_ir->op == OP_load_constant && ph2_ir->src0 == 0 &&\n next->op == OP_bit_or && next->src1 == ph2_ir->dest) {\n /* Replace OR with assignment */\n next->op = OP_assign;\n next->src1 = 0;\n ph2_ir->next = next->next;\n return true;\n }\n\n /* Pattern 4: XOR with zero → identity\n * x ^ 0 = x\n */\n if (ph2_ir->op == OP_load_constant && ph2_ir->src0 == 0 &&\n next->op == OP_bit_xor && next->src1 == ph2_ir->dest) {\n /* Replace XOR with assignment */\n next->op = OP_assign;\n next->src1 = 0;\n ph2_ir->next = next->next;\n return true;\n }\n\n /* Pattern 5: AND with zero → zero\n * x & 0 = 0\n */\n if (ph2_ir->op == OP_load_constant && ph2_ir->src0 == 0 &&\n next->op == OP_bit_and &&\n (next->src0 == ph2_ir->dest || next->src1 == ph2_ir->dest)) {\n /* Replace with constant load of 0 */\n next->op = OP_load_constant;\n next->src0 = 0;\n next->src1 = 0;\n ph2_ir->next = next->next;\n return true;\n }\n\n /* Pattern 6: OR with all-ones → all-ones\n * x | 0xFFFFFFFF = 0xFFFFFFFF\n */\n if (ph2_ir->op == OP_load_constant && ph2_ir->src0 == -1 &&\n next->op == OP_bit_or &&\n (next->src0 == ph2_ir->dest || next->src1 == ph2_ir->dest)) {\n /* Replace with constant load of -1 */\n next->op = OP_load_constant;\n next->src0 = -1;\n next->src1 = 0;\n ph2_ir->next = next->next;\n return true;\n }\n\n /* Pattern 7: Shift by zero → identity\n * x << 0 = x, x >> 0 = x\n */\n if (ph2_ir->op == OP_load_constant && ph2_ir->src0 == 0 &&\n (next->op == OP_lshift || next->op == OP_rshift) &&\n next->src1 == ph2_ir->dest) {\n /* Replace shift with assignment */\n next->op = OP_assign;\n next->src1 = 0;\n ph2_ir->next = next->next;\n return true;\n }\n\n return false;\n}\n\n/* Triple pattern optimization: Handle 3-instruction sequences\n * These patterns are more complex but offer significant optimization\n * opportunities Returns true if optimization was applied\n */\nbool triple_pattern_optimization(ph2_ir_t *ph2_ir)\n{\n if (!ph2_ir || !ph2_ir->next || !ph2_ir->next->next)\n return false;\n\n ph2_ir_t *second = ph2_ir->next;\n ph2_ir_t *third = second->next;\n\n /* Pattern 1: Store-load-store elimination\n * {store val1, addr; load r, addr; store val2, addr}\n * The middle load is pointless if not used elsewhere\n */\n if (ph2_ir->op == OP_store && second->op == OP_load &&\n third->op == OP_store &&\n ph2_ir->src1 == second->src0 && /* same address */\n ph2_ir->dest == second->src1 && /* same offset */\n second->src0 == third->src1 && /* same address */\n second->src1 == third->dest) { /* same offset */\n /* Check if the loaded value is used by the third store */\n if (third->src0 != second->dest) {\n /* The load result is not used, can eliminate it */\n ph2_ir->next = third;\n return true;\n }\n }\n\n /* Pattern 2: Consecutive stores to same location\n * {store v1, addr; store v2, addr; store v3, addr}\n * Only the last store matters\n */\n if (ph2_ir->op == OP_store && second->op == OP_store &&\n third->op == OP_store && ph2_ir->src1 == second->src1 &&\n ph2_ir->dest == second->dest && second->src1 == third->src1 &&\n second->dest == third->dest) {\n /* All three stores go to the same location */\n /* Only the last one matters, eliminate first two */\n ph2_ir->src0 = third->src0; /* Use last value */\n ph2_ir->next = third->next; /* Skip middle stores */\n return true;\n }\n\n /* FIXME: Additional optimization patterns to implement:\n *\n * Pattern 3: Load-op-store with same location\n * {load r1, [addr]; op r2, r1, ...; store r2, [addr]}\n * Can optimize to in-place operation if possible\n * Requires architecture-specific support in codegen.\n *\n * Pattern 4: Redundant comparison after boolean operation\n * {cmp a, b; load 1; load 0} → simplified when used in branch\n * The comparison already produces 0 or 1, constants may be redundant\n *\n * Pattern 5: Consecutive loads that can be combined\n * {load r1, [base+off1]; load r2, [base+off2]; op r3, r1, r2}\n * Useful for struct member access patterns\n * Needs alignment checking and architecture support.\n *\n * Pattern 6: Load-Load-Select pattern\n * {load r1, c1; load r2, c2; select/cmov based on condition}\n * Can optimize by loading only the needed value\n * Requires control flow analysis.\n *\n * Pattern 7: Add-Add-Add chain simplification\n * {add r1, r0, c1; add r2, r1, c2; add r3, r2, c3}\n * Can be simplified if all are constants\n * Requires tracking constant values through the chain.\n *\n * Pattern 8: Global load followed by immediate use\n * {global_load r1; op r2, r1, ...; store r2}\n * Track global access patterns\n * Could optimize to atomic operations or direct memory ops.\n * Needs careful synchronization analysis.\n */\n\n return false;\n}\n\n/* Main peephole optimization driver.\n *\n * SSA Optimizer (insn_t, before register allocation):\n * - Constant folding with known values (5+3 → 8, x+0 → x)\n * - Common subexpression elimination\n * - Self-assignment elimination (x = x)\n * - Dead code elimination\n * - Constant comparison folding (5 < 3 → 0)\n *\n * Peephole Optimizer (ph2_ir_t, after register allocation):\n * - Register-based self-operations (r1-r1 → 0, r1^r1 → 0)\n * - Bitwise operation optimization (SSA doesn't handle these)\n * - Strength reduction for power-of-2 (needs actual constants loaded)\n * - Load/store pattern elimination\n * - Triple instruction sequence optimization\n * - Architecture-specific instruction fusion\n *\n * This refined separation eliminates redundant optimizations while\n * maintaining comprehensive coverage of optimization opportunities.\n */\nvoid peephole(void)\n{\n for (func_t *func = FUNC_LIST.head; func; func = func->next) {\n /* Skip function declarations without bodies */\n if (!func->bbs)\n continue;\n\n /* Local peephole optimizations on post-register-allocation IR */\n for (basic_block_t *bb = func->bbs; bb; bb = bb->rpo_next) {\n for (ph2_ir_t *ir = bb->ph2_ir_list.head; ir; ir = ir->next) {\n ph2_ir_t *next = ir->next;\n if (!next)\n continue;\n\n /* Self-assignment elimination\n * Keep this as a safety net: SSA handles most cases, but\n * register allocation might create new self-assignments\n */\n if (next->op == OP_assign && next->dest == next->src0) {\n ir->next = next->next;\n continue;\n }\n\n /* Try triple pattern optimization first (3-instruction\n * sequences)\n */\n if (triple_pattern_optimization(ir))\n continue;\n\n /* Try instruction fusion (2-instruction sequences) */\n if (insn_fusion(ir))\n continue;\n\n /* Apply comparison optimization */\n if (comparison_optimization(ir))\n continue;\n\n /* Apply strength reduction for power-of-2 operations */\n if (strength_reduction(ir))\n continue;\n\n /* Apply algebraic simplification */\n if (algebraic_simplification(ir))\n continue;\n\n /* Apply bitwise operation optimizations */\n if (bitwise_optimization(ir))\n continue;\n\n /* Apply redundant move elimination */\n if (redundant_move_elim(ir))\n continue;\n\n /* Apply load/store elimination */\n if (eliminate_load_store_pairs(ir))\n continue;\n }\n }\n }\n}\n" }, { "path": "src/preprocessor.c", "content": "/*\n * shecc - Self-Hosting and Educational C Compiler.\n *\n * shecc is freely redistributable under the BSD 2 clause license. See the\n * file \"LICENSE\" for information on usage and redistribution of this file.\n */\n#include \"../config\"\n#include \"defs.h\"\n#include \"globals.c\"\n\nsource_location_t synth_built_in_loc;\nhashmap_t *PRAGMA_ONCE;\nhashmap_t *MACROS;\n\ntoken_t *pp_lex_skip_space(token_t *tk)\n{\n while (tk->next &&\n (tk->next->kind == T_whitespace || tk->next->kind == T_tab))\n tk = tk->next;\n return tk;\n}\n\ntoken_t *pp_lex_next_token(token_t *tk, bool skip_space)\n{\n if (skip_space)\n tk = pp_lex_skip_space(tk);\n return tk->next;\n}\n\nbool pp_lex_peek_token(token_t *tk, token_kind_t kind, bool skip_space)\n{\n if (skip_space)\n tk = pp_lex_skip_space(tk);\n return tk->next && tk->next->kind == kind;\n}\n\ntoken_t *pp_lex_expect_token(token_t *tk, token_kind_t kind, bool skip_space)\n{\n if (skip_space)\n tk = pp_lex_skip_space(tk);\n if (tk->next) {\n if (tk->next->kind == kind)\n return pp_lex_next_token(tk, false);\n\n error_at(\"Unexpected token kind\", &tk->next->location);\n }\n\n error_at(\"Expect token after this token\", &tk->location);\n return tk;\n}\n\ntoken_t *lex_ident_token(token_t *tk,\n token_kind_t kind,\n char *dest,\n bool skip_space)\n{\n tk = pp_lex_expect_token(tk, kind, skip_space);\n strcpy(dest, tk->literal);\n return tk;\n}\n\n/* Copies and isolate the given copied token */\ntoken_t *copy_token(token_t *tk)\n{\n token_t *new_tk = arena_calloc(TOKEN_ARENA, 1, sizeof(token_t));\n memcpy(new_tk, tk, sizeof(token_t));\n new_tk->next = NULL;\n return new_tk;\n}\n\ntypedef struct macro {\n char *name;\n int param_num;\n token_t *param_names[MAX_PARAMS];\n token_t *replacement;\n bool is_variadic;\n token_t *variadic_tk;\n bool is_disabled;\n /* build-in function-like macro handler */\n token_t *(*handler)(token_t *);\n} macro_t;\n\nbool is_macro_defined(char *name)\n{\n macro_t *macro = hashmap_get(MACROS, name);\n\n return macro && !macro->is_disabled;\n}\n\n/* file_macro_handler is responsible for expanding built-in macro \"__FILE__\"\n * inplace with a string token with file's relative path's name literally\n */\ntoken_t *file_macro_handler(token_t *tk)\n{\n token_t *new_tk = copy_token(tk);\n new_tk->kind = T_string;\n new_tk->literal = tk->location.filename;\n memcpy(&new_tk->location, &tk->location, sizeof(source_location_t));\n return new_tk;\n}\n\n/* line_macro_handler is responsible for expanding built-in macro \"__LINE__\"\n * inplace with a string token with line number literally\n */\ntoken_t *line_macro_handler(token_t *tk)\n{\n char line[MAX_TOKEN_LEN];\n snprintf(line, MAX_TOKEN_LEN, \"%d\", tk->location.line);\n\n token_t *new_tk = copy_token(tk);\n new_tk->kind = T_numeric;\n new_tk->literal = intern_string(line);\n memcpy(&new_tk->location, &tk->location, sizeof(source_location_t));\n return new_tk;\n}\n\n/* hide_set_t is used to track which macros have been expanded in the previous\n * expanding context, if so, it'll get added into hide set of context to prevent\n * endless recursion macro expansion.\n */\ntypedef struct hide_set {\n char *name;\n struct hide_set *next;\n} hide_set_t;\n\nhide_set_t *new_hide_set(char *name)\n{\n hide_set_t *hs = arena_alloc(TOKEN_ARENA, sizeof(hide_set_t));\n hs->name = name;\n hs->next = NULL;\n return hs;\n}\n\nhide_set_t *hide_set_union(hide_set_t *hs1, hide_set_t *hs2)\n{\n hide_set_t head;\n hide_set_t *cur = &head;\n\n for (; hs1; hs1 = hs1->next) {\n cur->next = new_hide_set(hs1->name);\n cur = cur->next;\n }\n cur->next = hs2;\n\n return head.next;\n}\n\nbool hide_set_contains(hide_set_t *hs, char *name)\n{\n for (; hs; hs = hs->next)\n if (!strcmp(hs->name, name))\n return true;\n return false;\n}\n\nvoid hide_set_free(hide_set_t *hs)\n{\n for (hide_set_t *tmp; hs;) {\n tmp = hs;\n hs = hs->next;\n free(tmp);\n }\n}\n\ntypedef enum { CK_if_then, CK_elif_then, CK_else_then } cond_kind_t;\n\n/* cond_incl_t is used as a stack-like context to track conditional macro\n * directives' expansion, and gives information to the expansion context\n * to process the token stream with correct behavior.\n */\ntypedef struct cond_incl {\n struct cond_incl *prev;\n cond_kind_t ctx;\n token_t *tk;\n bool included;\n} cond_incl_t;\n\ncond_incl_t *push_cond(cond_incl_t *ci, token_t *tk, bool included)\n{\n cond_incl_t *cond = arena_alloc(TOKEN_ARENA, sizeof(cond_incl_t));\n cond->prev = ci;\n cond->ctx = CK_if_then;\n cond->tk = tk;\n cond->included = included;\n return cond;\n}\n\n/* preprocess_ctx_t is used to track various inforamtion when expanding token\n * stream, the context state may vary due to the current expanding object,\n * but in general case, it will tries to inherit parent context state if\n * possible.\n *\n * Due to the standard that token stream are always ends with EOF token,\n * the default behavior is not to trim EOF token, but if the result requires\n * EOF token to be present, set trim_eof to true would suffice.\n */\ntypedef struct preprocess_ctx {\n hide_set_t *hide_set;\n hashmap_t *macro_args;\n token_t *expanded_from;\n token_t *end_of_token; /* end of token stream of current context */\n bool trim_eof;\n} preprocess_ctx_t;\n\ntoken_t *pp_preprocess_internal(token_t *tk, preprocess_ctx_t *ctx);\nchar *token_to_string(token_t *tk, char *dest);\n\nint pp_get_operator_prio(opcode_t op)\n{\n /* https://www.cs.uic.edu/~i109/Notes/COperatorPrecedenceTable.pdf */\n switch (op) {\n case OP_ternary:\n return 3;\n case OP_log_or:\n return 4;\n case OP_log_and:\n return 5;\n case OP_bit_or:\n return 6;\n case OP_bit_xor:\n return 7;\n case OP_bit_and:\n return 8;\n case OP_eq:\n case OP_neq:\n return 9;\n case OP_lt:\n case OP_leq:\n case OP_gt:\n case OP_geq:\n return 10;\n case OP_add:\n case OP_sub:\n return 12;\n case OP_mul:\n case OP_div:\n case OP_mod:\n return 13;\n default:\n return 0;\n }\n}\n\nint pp_get_unary_operator_prio(opcode_t op)\n{\n switch (op) {\n case OP_add:\n case OP_sub:\n case OP_bit_not:\n case OP_log_not:\n return 14;\n default:\n return 0;\n }\n}\n\ntoken_t *pp_get_operator(token_t *tk, opcode_t *op)\n{\n tk = pp_lex_skip_space(tk);\n\n if (!tk->next)\n error_at(\"Unexpected error when trying to evaulate constant operator\",\n &tk->location);\n\n switch (tk->next->kind) {\n case T_plus:\n op[0] = OP_add;\n break;\n case T_minus:\n op[0] = OP_sub;\n break;\n case T_asterisk:\n op[0] = OP_mul;\n break;\n case T_divide:\n op[0] = OP_div;\n break;\n case T_mod:\n op[0] = OP_mod;\n break;\n case T_lshift:\n op[0] = OP_lshift;\n break;\n case T_rshift:\n op[0] = OP_rshift;\n break;\n case T_log_and:\n op[0] = OP_log_and;\n break;\n case T_log_or:\n op[0] = OP_log_or;\n break;\n case T_eq:\n op[0] = OP_eq;\n break;\n case T_noteq:\n op[0] = OP_neq;\n break;\n case T_lt:\n op[0] = OP_lt;\n break;\n case T_le:\n op[0] = OP_leq;\n break;\n case T_gt:\n op[0] = OP_gt;\n break;\n case T_ge:\n op[0] = OP_geq;\n break;\n case T_ampersand:\n op[0] = OP_bit_and;\n break;\n case T_bit_or:\n op[0] = OP_bit_or;\n break;\n case T_bit_xor:\n op[0] = OP_bit_xor;\n break;\n case T_question:\n op[0] = OP_ternary;\n break;\n default:\n /* Maybe it's an operand, we immediately return here. */\n op[0] = OP_generic;\n return tk;\n }\n tk = pp_lex_next_token(tk, true);\n return tk;\n}\n\ntoken_t *pp_read_constant_expr_operand(token_t *tk, int *val)\n{\n if (pp_lex_peek_token(tk, T_numeric, true)) {\n tk = pp_lex_next_token(tk, true);\n val[0] = parse_numeric_constant(tk->literal);\n return tk;\n }\n\n if (pp_lex_peek_token(tk, T_open_bracket, true)) {\n tk = pp_lex_next_token(tk, true);\n tk = pp_read_constant_expr_operand(tk, val);\n tk = pp_lex_expect_token(tk, T_close_bracket, true);\n return tk;\n }\n\n if (pp_lex_peek_token(tk, T_identifier, true)) {\n tk = pp_lex_next_token(tk, true);\n\n if (!strcmp(\"defined\", tk->literal)) {\n tk = pp_lex_expect_token(tk, T_open_bracket, true);\n tk = pp_lex_expect_token(tk, T_identifier, true);\n val[0] = is_macro_defined(tk->literal);\n tk = pp_lex_expect_token(tk, T_close_bracket, true);\n } else {\n /* Any identifier will fallback and evaluate as 0 */\n macro_t *macro = hashmap_get(MACROS, tk->literal);\n\n /* Disallow function-like macro to be expanded */\n if (macro && !(macro->param_num > 0 || macro->is_variadic)) {\n token_t *expanded_tk, *tmp;\n preprocess_ctx_t ctx;\n ctx.expanded_from = tk;\n ctx.hide_set = NULL;\n ctx.macro_args = NULL;\n ctx.trim_eof = false;\n expanded_tk = pp_preprocess_internal(macro->replacement, &ctx);\n tmp = tk->next;\n tk->next = expanded_tk;\n ctx.end_of_token->next = tmp;\n return pp_read_constant_expr_operand(tk, val);\n }\n\n val[0] = 0;\n }\n\n return tk;\n }\n\n /* Unable to identify next token, so we advance to next non-whitespace token\n * and report its location with error message.\n */\n tk = pp_lex_next_token(tk, true);\n error_at(\"Unexpected token while evaluating constant\", &tk->location);\n return tk;\n}\n\ntoken_t *pp_read_constant_infix_expr(int precedence, token_t *tk, int *val)\n{\n int lhs, rhs;\n\n /* Evaluate unary expression first */\n opcode_t op;\n tk = pp_get_operator(tk, &op);\n int current_precedence = pp_get_unary_operator_prio(op);\n if (current_precedence != 0 && current_precedence >= precedence) {\n tk = pp_read_constant_infix_expr(current_precedence, tk, &lhs);\n\n switch (op) {\n case OP_add:\n break;\n case OP_sub:\n lhs = -lhs;\n break;\n case OP_bit_not:\n lhs = ~lhs;\n break;\n case OP_log_not:\n lhs = !lhs;\n break;\n default: {\n source_location_t *loc =\n tk->next ? &tk->next->location : &tk->location;\n\n error_at(\"Unexpected unary token while evaluating constant\", loc);\n }\n }\n } else {\n tk = pp_read_constant_expr_operand(tk, &lhs);\n }\n\n while (true) {\n tk = pp_get_operator(tk, &op);\n current_precedence = pp_get_operator_prio(op);\n\n if (current_precedence == 0 || current_precedence <= precedence)\n break;\n\n tk = pp_read_constant_infix_expr(current_precedence, tk, &rhs);\n\n switch (op) {\n case OP_add:\n lhs += rhs;\n break;\n case OP_sub:\n lhs -= rhs;\n break;\n case OP_mul:\n lhs *= rhs;\n break;\n case OP_div:\n lhs /= rhs;\n break;\n case OP_bit_and:\n lhs &= rhs;\n break;\n case OP_bit_or:\n lhs |= rhs;\n break;\n case OP_bit_xor:\n lhs ^= rhs;\n break;\n case OP_lshift:\n lhs <<= rhs;\n break;\n case OP_rshift:\n lhs >>= rhs;\n break;\n case OP_gt:\n lhs = lhs > rhs;\n break;\n case OP_geq:\n lhs = lhs >= rhs;\n break;\n case OP_lt:\n lhs = lhs < rhs;\n break;\n case OP_leq:\n lhs = lhs <= rhs;\n break;\n case OP_eq:\n lhs = lhs == rhs;\n break;\n case OP_neq:\n lhs = lhs != rhs;\n break;\n case OP_log_and:\n lhs = lhs && rhs;\n break;\n case OP_log_or:\n lhs = lhs || rhs;\n break;\n default:\n error_at(\"Unexpected infix token while evaluating constant\",\n &tk->location);\n }\n tk = pp_get_operator(tk, &op);\n }\n\n val[0] = lhs;\n return tk;\n}\n\ntoken_t *pp_read_constant_expr(token_t *tk, int *val)\n{\n tk = pp_read_constant_infix_expr(0, tk, val);\n /* advance to fully consume constant expression */\n tk = pp_lex_next_token(tk, true);\n return tk;\n}\n\ntoken_t *pp_skip_inner_cond_incl(token_t *tk)\n{\n token_kind_t kind;\n\n while (tk->kind != T_eof) {\n kind = tk->kind;\n\n if (kind == T_cppd_if || kind == T_cppd_ifdef ||\n kind == T_cppd_ifndef) {\n if (!tk->next || !tk->next->next)\n error_at(\"Unexpected error when skipping conditional inclusion\",\n &tk->location);\n\n tk = pp_skip_inner_cond_incl(tk->next->next);\n continue;\n }\n\n if (kind == T_cppd_endif) {\n if (!tk->next || !tk->next->next)\n error_at(\"Unexpected error when skipping conditional inclusion\",\n &tk->location);\n return tk->next->next;\n }\n\n tk = tk->next;\n }\n return tk;\n}\n\ntoken_t *pp_skip_cond_incl(token_t *tk)\n{\n token_kind_t kind;\n\n while (tk->kind != T_eof) {\n kind = tk->kind;\n\n if (kind == T_cppd_if || kind == T_cppd_ifdef ||\n kind == T_cppd_ifndef) {\n tk = pp_skip_inner_cond_incl(tk);\n continue;\n }\n\n if (kind == T_cppd_elif || kind == T_cppd_else || kind == T_cppd_endif)\n break;\n\n tk = tk->next;\n }\n return tk;\n}\n\ntoken_t *pp_preprocess_internal(token_t *tk, preprocess_ctx_t *ctx)\n{\n token_t head;\n token_t *cur = &head;\n cond_incl_t *ci = NULL;\n\n while (tk) {\n macro_t *macro = NULL;\n\n switch (tk->kind) {\n case T_identifier: {\n token_t *macro_tk = tk;\n preprocess_ctx_t expansion_ctx;\n\n /* Initialize expansion context: inherit parent context and enable\n * EOF trimming for macro body expansion */\n expansion_ctx.expanded_from =\n ctx->expanded_from ? ctx->expanded_from : tk;\n expansion_ctx.macro_args = ctx->macro_args;\n expansion_ctx.trim_eof = true;\n\n token_t *macro_arg_replcaement = NULL;\n\n /* Check if this identifier is a macro parameter (argument)\n * If we're currently expanding a macro body, parameters should be\n * replaced with their supplied arguments */\n if (ctx->macro_args)\n macro_arg_replcaement =\n hashmap_get(ctx->macro_args, tk->literal);\n\n if (macro_arg_replcaement) {\n /* Recursively expand the argument to handle nested macros\n * TODO: We should consider ## (token concatenation) here */\n expansion_ctx.hide_set = ctx->hide_set;\n expansion_ctx.macro_args =\n NULL; /* Don't take account of macro arguments, this might\n run into infinite loop */\n macro_arg_replcaement = pp_preprocess_internal(\n macro_arg_replcaement, &expansion_ctx);\n cur->next = macro_arg_replcaement;\n cur = expansion_ctx.end_of_token;\n tk = pp_lex_next_token(tk, false);\n continue;\n }\n\n /* Prevent infinite recursion by checking hide set */\n if (hide_set_contains(ctx->hide_set, tk->literal))\n break;\n\n macro = hashmap_get(MACROS, tk->literal);\n\n /* Skips expansion if either macro doesn't exist or macro is diabled\n */\n if (!macro || macro->is_disabled)\n break;\n\n /* Handle built-in function-like macros (__FILE__, __LINE__)\n * These have special handlers that generate tokens directly */\n if (macro->handler) {\n cur->next = macro->handler(expansion_ctx.expanded_from);\n cur = cur->next;\n tk = pp_lex_next_token(tk, false);\n continue;\n }\n\n /* Check if this is a function-like macro invocation */\n if (pp_lex_peek_token(tk, T_open_bracket, true)) {\n token_t arg_head;\n token_t *arg_cur = &arg_head;\n int arg_idx = 0;\n int bracket_depth = 0;\n\n /* Add macro name to hide set to prevent re-expansion of itself\n * during its own body expansion */\n expansion_ctx.hide_set =\n hide_set_union(ctx->hide_set, new_hide_set(tk->literal));\n /* Create parameter mapping table for this macro invocation */\n expansion_ctx.macro_args = hashmap_create(8);\n\n tk = pp_lex_next_token(tk, true);\n\n /* Parse macro arguments until closing parenthesis\n *\n * Handles nested parentheses and comma-separated argument list\n * by tracking the nested depth */\n while (true) {\n if (pp_lex_peek_token(tk, T_open_bracket, false))\n bracket_depth++;\n else if (pp_lex_peek_token(tk, T_close_bracket, false))\n bracket_depth--;\n\n /* Expand identifiers within macro arguments\n *\n * This handles cases like: MACRO(OTHER_MACRO) where\n * OTHER_MACRO is itself expanded before being used as arg\n */\n if (expansion_ctx.macro_args &&\n pp_lex_peek_token(tk, T_identifier, false)) {\n token_t *arg_tk =\n hashmap_get(ctx->macro_args, tk->next->literal);\n\n if (arg_tk) {\n preprocess_ctx_t arg_expansion_ctx;\n arg_expansion_ctx.expanded_from = tk->next;\n arg_expansion_ctx.hide_set = expansion_ctx.hide_set;\n arg_expansion_ctx.macro_args = NULL;\n arg_tk = pp_preprocess_internal(arg_tk,\n &arg_expansion_ctx);\n tk = pp_lex_next_token(tk, false);\n arg_cur->next = arg_tk;\n arg_cur = arg_expansion_ctx.end_of_token;\n continue;\n }\n }\n\n /* Accumulate argument tokens until delimiter\n *\n * Collect all tokens between commas or parentheses as part\n * of the current argument */\n if (bracket_depth >= 0 &&\n !pp_lex_peek_token(tk, T_comma, false) &&\n !pp_lex_peek_token(tk, T_close_bracket, false)) {\n tk = pp_lex_next_token(tk, false);\n arg_cur->next = copy_token(tk);\n arg_cur = arg_cur->next;\n continue;\n }\n\n token_t *param_tk;\n\n /* Bind argument to corresponding parameter */\n if (arg_idx < macro->param_num) {\n param_tk = macro->param_names[arg_idx++];\n hashmap_put(expansion_ctx.macro_args, param_tk->literal,\n arg_head.next);\n } else {\n /* Handle variadic macro overflow\n *\n * If macro takes __VA_ARGS__, excess arguments go there\n */\n if (macro->is_variadic) {\n param_tk = macro->variadic_tk;\n\n if (hashmap_contains(expansion_ctx.macro_args,\n param_tk->literal)) {\n /* Append to existing variadic args with comma\n * separator to preserve argument boundaries */\n token_t *prev =\n hashmap_get(expansion_ctx.macro_args,\n param_tk->literal);\n\n while (prev->next)\n prev = prev->next;\n\n /* Borrows parameter's token location */\n prev->next =\n new_token(T_comma, ¶m_tk->location, 1);\n prev->next->next = arg_head.next;\n prev = arg_cur;\n } else {\n hashmap_put(expansion_ctx.macro_args,\n param_tk->literal, arg_head.next);\n }\n } else {\n error_at(\n \"Too many arguments supplied to macro \"\n \"invocation\",\n ¯o_tk->location);\n }\n }\n\n /* Reset for next argument collection */\n arg_cur = &arg_head;\n\n if (pp_lex_peek_token(tk, T_comma, false)) {\n tk = pp_lex_next_token(tk, false);\n continue;\n }\n\n if (pp_lex_peek_token(tk, T_close_bracket, false)) {\n tk = pp_lex_next_token(tk, false);\n break;\n }\n }\n\n if (arg_idx < macro->param_num)\n error_at(\"Too few arguments supplied to macro invocation\",\n ¯o_tk->location);\n\n /* Expand macro body with collected arguments\n * Replace parameter references with supplied argument tokens */\n cur->next =\n pp_preprocess_internal(macro->replacement, &expansion_ctx);\n cur = expansion_ctx.end_of_token;\n\n hashmap_free(expansion_ctx.macro_args);\n } else {\n /* Handle object-like macro expansion (no parameters)\n * Simply expand the replacement with current hide set plus\n * this macro name added to prevent re-expansion */\n expansion_ctx.hide_set =\n hide_set_union(ctx->hide_set, new_hide_set(tk->literal));\n cur->next =\n pp_preprocess_internal(macro->replacement, &expansion_ctx);\n cur = expansion_ctx.end_of_token;\n }\n\n tk = pp_lex_next_token(tk, false);\n continue;\n }\n case T_cppd_include: {\n char inclusion_path[MAX_LINE_LEN];\n token_stream_t *file_tks = NULL;\n preprocess_ctx_t inclusion_ctx;\n inclusion_ctx.hide_set = ctx->hide_set;\n inclusion_ctx.expanded_from = NULL;\n inclusion_ctx.macro_args = NULL;\n inclusion_ctx.trim_eof = true;\n\n if (pp_lex_peek_token(tk, T_string, true)) {\n tk = pp_lex_next_token(tk, true);\n strcpy(inclusion_path, tk->literal);\n\n /* normalize path */\n char path[MAX_LINE_LEN];\n const char *file = tk->location.filename;\n int c = strlen(file) - 1;\n\n while (c > 0 && file[c] != '/')\n c--;\n\n if (c) {\n if (c >= MAX_LINE_LEN - 1)\n c = MAX_LINE_LEN - 2;\n\n memcpy(path, file, c);\n path[c] = '\\0';\n } else {\n path[0] = '.';\n path[1] = '\\0';\n c = 1;\n }\n\n snprintf(path + c, MAX_LINE_LEN - c, \"/%s\", inclusion_path);\n strncpy(inclusion_path, path, MAX_LINE_LEN - 1);\n inclusion_path[MAX_LINE_LEN - 1] = '\\0';\n } else {\n int sz = 0;\n char token_buffer[MAX_TOKEN_LEN], *literal;\n tk = pp_lex_expect_token(tk, T_lt, true);\n\n while (!pp_lex_peek_token(tk, T_gt, false)) {\n tk = pp_lex_next_token(tk, false);\n literal = token_to_string(tk, token_buffer);\n\n strcpy(inclusion_path + sz, literal);\n sz += strlen(literal);\n }\n\n tk = pp_lex_next_token(tk, false);\n /* FIXME: We ignore #include <...> at this moment, since\n * all libc functions are included done by inlining.\n */\n tk = pp_lex_expect_token(tk, T_newline, true);\n tk = pp_lex_next_token(tk, false);\n continue;\n }\n\n tk = pp_lex_expect_token(tk, T_newline, true);\n tk = pp_lex_next_token(tk, false);\n\n if (hashmap_contains(PRAGMA_ONCE, inclusion_path))\n continue;\n\n file_tks = gen_file_token_stream(intern_string(inclusion_path));\n cur->next = pp_preprocess_internal(file_tks->head, &inclusion_ctx);\n cur = inclusion_ctx.end_of_token;\n continue;\n }\n case T_cppd_define: {\n token_t *r_head = NULL, *r_tail = NULL, *r_cur;\n\n tk = pp_lex_expect_token(tk, T_identifier, true);\n macro = hashmap_get(MACROS, tk->literal);\n\n if (!macro) {\n macro = arena_calloc(TOKEN_ARENA, 1, sizeof(macro_t));\n macro->name = tk->literal;\n } else {\n /* Ensures that #undef effect is overwritten */\n macro->is_disabled = false;\n }\n\n if (pp_lex_peek_token(tk, T_open_bracket, false)) {\n /* function-like macro */\n tk = pp_lex_next_token(tk, false);\n while (pp_lex_peek_token(tk, T_identifier, true)) {\n tk = pp_lex_next_token(tk, true);\n macro->param_names[macro->param_num++] = copy_token(tk);\n\n if (pp_lex_peek_token(tk, T_comma, true)) {\n tk = pp_lex_next_token(tk, true);\n }\n }\n\n if (pp_lex_peek_token(tk, T_elipsis, true)) {\n tk = pp_lex_next_token(tk, true);\n macro->is_variadic = true;\n macro->variadic_tk = copy_token(tk);\n macro->variadic_tk->literal = intern_string(\"__VA_ARGS__\");\n }\n\n tk = pp_lex_expect_token(tk, T_close_bracket, true);\n }\n\n tk = pp_lex_skip_space(tk);\n while (!pp_lex_peek_token(tk, T_newline, false)) {\n if (pp_lex_peek_token(tk, T_backslash, false)) {\n tk = pp_lex_expect_token(tk, T_backslash, false);\n\n if (!pp_lex_peek_token(tk, T_newline, false))\n error_at(\"Backslash and newline must not be separated\",\n &tk->location);\n else\n tk = pp_lex_expect_token(tk, T_newline, false);\n\n tk = pp_lex_next_token(tk, false);\n continue;\n }\n\n tk = pp_lex_next_token(tk, false);\n r_cur = copy_token(tk);\n r_cur->next = NULL;\n\n if (!r_head) {\n r_head = r_cur;\n r_tail = r_head;\n } else {\n r_tail->next = r_cur;\n r_tail = r_cur;\n }\n }\n\n tk = pp_lex_expect_token(tk, T_newline, false);\n tk = pp_lex_next_token(tk, false);\n macro->replacement = r_head;\n hashmap_put(MACROS, macro->name, macro);\n continue;\n }\n case T_cppd_undef: {\n tk = pp_lex_expect_token(tk, T_identifier, true);\n macro = hashmap_get(MACROS, tk->literal);\n\n if (macro) {\n macro->is_disabled = true;\n }\n\n tk = pp_lex_expect_token(tk, T_newline, true);\n continue;\n }\n case T_cppd_if: {\n token_t *cond_tk = tk;\n int defined;\n tk = pp_read_constant_expr(tk, &defined);\n ci = push_cond(ci, cond_tk, defined);\n\n if (!defined)\n tk = pp_skip_cond_incl(tk);\n continue;\n }\n case T_cppd_ifdef: {\n token_t *kw_tk = tk;\n tk = pp_lex_expect_token(tk, T_identifier, true);\n bool defined = is_macro_defined(tk->literal);\n\n ci = push_cond(ci, kw_tk, defined);\n if (!defined)\n tk = pp_skip_cond_incl(tk);\n else\n tk = pp_lex_expect_token(tk, T_newline, true);\n continue;\n }\n case T_cppd_ifndef: {\n token_t *kw_tk = tk;\n tk = pp_lex_expect_token(tk, T_identifier, true);\n bool defined = is_macro_defined(tk->literal);\n\n ci = push_cond(ci, kw_tk, !defined);\n if (defined)\n tk = pp_skip_cond_incl(tk);\n else\n tk = pp_lex_expect_token(tk, T_newline, true);\n continue;\n }\n case T_cppd_elif: {\n if (!ci || ci->ctx == CK_else_then)\n error_at(\"Stray #elif\", &tk->location);\n int included;\n ci->ctx = CK_elif_then;\n tk = pp_read_constant_expr(tk, &included);\n\n if (!ci->included && included)\n ci->included = true;\n else\n tk = pp_skip_cond_incl(tk);\n continue;\n }\n case T_cppd_else: {\n if (!ci || ci->ctx == CK_else_then)\n error_at(\"Stray #else\", &tk->location);\n ci->ctx = CK_else_then;\n tk = pp_lex_expect_token(tk, T_newline, true);\n\n if (ci->included)\n tk = pp_skip_cond_incl(tk);\n continue;\n }\n case T_cppd_endif: {\n if (!ci)\n error_at(\"Stray #endif\", &tk->location);\n ci = ci->prev;\n tk = pp_lex_expect_token(tk, T_newline, true);\n continue;\n }\n case T_cppd_pragma: {\n if (pp_lex_peek_token(tk, T_identifier, true)) {\n tk = pp_lex_next_token(tk, true);\n\n if (!strcmp(\"once\", tk->literal))\n hashmap_put(PRAGMA_ONCE, tk->location.filename, NULL);\n }\n\n while (!pp_lex_peek_token(tk, T_newline, true))\n tk = pp_lex_next_token(tk, true);\n\n tk = pp_lex_expect_token(tk, T_newline, true);\n continue;\n }\n case T_cppd_error: {\n if (pp_lex_peek_token(tk, T_string, true)) {\n tk = pp_lex_next_token(tk, true);\n\n error_at(tk->literal, &tk->location);\n } else {\n error_at(\n \"Internal error, #error does not support non-string error \"\n \"message\",\n &tk->location);\n }\n break;\n }\n case T_backslash: {\n /* This branch is designed to be failed since backslash should be\n * consumed by #define, and upon later expansion, it should not be\n * included previously while created by #define.\n */\n error_at(\"Backslash is not allowed here\", &cur->location);\n break;\n }\n case T_eof: {\n if (ctx->trim_eof) {\n tk = pp_lex_next_token(tk, false);\n continue;\n }\n break;\n }\n default:\n break;\n }\n\n cur->next = copy_token(tk);\n cur = cur->next;\n tk = pp_lex_next_token(tk, false);\n }\n\n if (ci)\n error_at(\"Unterminated conditional directive\", &ci->tk->location);\n\n ctx->end_of_token = cur;\n return head.next;\n}\n\ntoken_t *preprocess(token_t *tk)\n{\n preprocess_ctx_t ctx;\n ctx.hide_set = NULL;\n ctx.expanded_from = NULL;\n ctx.macro_args = NULL;\n ctx.trim_eof = false;\n\n /* Initialize built-in macros */\n PRAGMA_ONCE = hashmap_create(16);\n MACROS = hashmap_create(16);\n\n synth_built_in_loc.pos = 0;\n synth_built_in_loc.len = 1;\n synth_built_in_loc.column = 1;\n synth_built_in_loc.line = 1;\n synth_built_in_loc.filename = \"\";\n\n macro_t *macro = calloc(1, sizeof(macro_t));\n macro->name = \"__FILE__\";\n macro->handler = file_macro_handler;\n hashmap_put(MACROS, \"__FILE__\", macro);\n\n macro = calloc(1, sizeof(macro_t));\n macro->name = \"__LINE__\";\n macro->handler = line_macro_handler;\n hashmap_put(MACROS, \"__LINE__\", macro);\n\n /* architecture defines */\n macro = calloc(1, sizeof(macro_t));\n macro->name = ARCH_PREDEFINED;\n macro->replacement = new_token(T_numeric, &synth_built_in_loc, 1);\n macro->replacement->literal = \"1\";\n hashmap_put(MACROS, ARCH_PREDEFINED, macro);\n\n /* shecc run-time defines */\n macro = calloc(1, sizeof(macro_t));\n macro->name = \"__SHECC__\";\n macro->replacement = new_token(T_numeric, &synth_built_in_loc, 1);\n macro->replacement->literal = \"1\";\n hashmap_put(MACROS, \"__SHECC__\", macro);\n\n tk = pp_preprocess_internal(tk, &ctx);\n\n hashmap_free(MACROS);\n hashmap_free(PRAGMA_ONCE);\n return tk;\n}\n\nchar *token_to_string(token_t *tk, char *dest)\n{\n switch (tk->kind) {\n case T_eof:\n if (tk->next)\n error_at(\n \"Internal error, token_to_string does not expect eof token in \"\n \"the middle of token stream\",\n &tk->location);\n return NULL;\n case T_numeric:\n return tk->literal;\n case T_identifier:\n return tk->literal;\n case T_string:\n snprintf(dest, MAX_TOKEN_LEN, \"\\\"%s\\\"\", tk->literal);\n return dest;\n case T_char:\n snprintf(dest, MAX_TOKEN_LEN, \"'%s'\", tk->literal);\n return dest;\n case T_comma:\n return \",\";\n case T_open_bracket:\n return \"(\";\n case T_close_bracket:\n return \")\";\n case T_open_curly:\n return \"{\";\n case T_close_curly:\n return \"}\";\n case T_open_square:\n return \"[\";\n case T_close_square:\n return \"]\";\n case T_asterisk:\n return \"*\";\n case T_divide:\n return \"/\";\n case T_mod:\n return \"%\";\n case T_bit_or:\n return \"|\";\n case T_bit_xor:\n return \"^\";\n case T_bit_not:\n return \"~\";\n case T_log_and:\n return \"&&\";\n case T_log_or:\n return \"||\";\n case T_log_not:\n return \"!\";\n case T_lt:\n return \"<\";\n case T_gt:\n return \">\";\n case T_le:\n return \"<=\";\n case T_ge:\n return \">=\";\n case T_lshift:\n return \"<<\";\n case T_rshift:\n return \">>\";\n case T_dot:\n return \".\";\n case T_arrow:\n return \"->\";\n case T_plus:\n return \"+\";\n case T_minus:\n return \"-\";\n case T_minuseq:\n return \"-=\";\n case T_pluseq:\n return \"+=\";\n case T_asteriskeq:\n return \"*=\";\n case T_divideeq:\n return \"/=\";\n case T_modeq:\n return \"%=\";\n case T_lshifteq:\n return \"<<=\";\n case T_rshifteq:\n return \">>=\";\n case T_xoreq:\n return \"^=\";\n case T_oreq:\n return \"|=\";\n case T_andeq:\n return \"&=\";\n case T_eq:\n return \"==\";\n case T_noteq:\n return \"!=\";\n case T_assign:\n return \"=\";\n case T_increment:\n return \"++\";\n case T_decrement:\n return \"--\";\n case T_question:\n return \"?\";\n case T_colon:\n return \":\";\n case T_semicolon:\n return \";\";\n case T_ampersand:\n return \"&\";\n case T_return:\n return \"return\";\n case T_if:\n return \"if\";\n case T_else:\n return \"else\";\n case T_while:\n return \"while\";\n case T_for:\n return \"for\";\n case T_do:\n return \"do\";\n case T_typedef:\n return \"typedef\";\n case T_enum:\n return \"enum\";\n case T_struct:\n return \"struct\";\n case T_union:\n return \"union\";\n case T_sizeof:\n return \"sizeof\";\n case T_elipsis:\n return \"...\";\n case T_switch:\n return \"switch\";\n case T_case:\n return \"case\";\n case T_break:\n return \"break\";\n case T_default:\n return \"default\";\n case T_continue:\n return \"continue\";\n case T_goto:\n return \"goto\";\n case T_const:\n return \"const\";\n case T_newline:\n return \"\\n\";\n case T_backslash:\n error_at(\n \"Internal error, backslash should be ommited after \"\n \"preprocessing\",\n &tk->location);\n break;\n case T_whitespace: {\n int i = 0;\n for (; i < tk->location.len; i++)\n dest[i] = ' ';\n dest[i] = '\\0';\n return dest;\n }\n case T_tab:\n return \"\\t\";\n case T_start:\n /* FIXME: Unused token kind */\n break;\n case T_cppd_include:\n case T_cppd_define:\n case T_cppd_undef:\n case T_cppd_error:\n case T_cppd_if:\n case T_cppd_elif:\n case T_cppd_else:\n case T_cppd_endif:\n case T_cppd_ifdef:\n case T_cppd_ifndef:\n case T_cppd_pragma:\n error_at(\n \"Internal error, preprocessor directives should be ommited \"\n \"after preprocessing\",\n &tk->location);\n break;\n default:\n error_at(\"Unknown token kind\", &tk->location);\n printf(\"UNKNOWN_TOKEN\");\n break;\n }\n\n return NULL;\n}\n\nvoid emit_preprocessed_token(token_t *tk)\n{\n char token_buffer[MAX_TOKEN_LEN], *literal;\n\n while (tk) {\n literal = token_to_string(tk, token_buffer);\n\n if (literal)\n printf(\"%s\", literal);\n\n tk = tk->next;\n }\n}\n" }, { "path": "src/reg-alloc.c", "content": "/*\n * shecc - Self-Hosting and Educational C Compiler.\n *\n * shecc is freely redistributable under the BSD 2 clause license. See the\n * file \"LICENSE\" for information on usage and redistribution of this file.\n */\n\n/* Allocate registers from IR. The linear-scan algorithm now expects a minimum\n * of 7 available registers (typical for RISC-style architectures).\n *\n * TODO: Implement \"-O level\" optimization control. Currently the allocator\n * always performs dead variable elimination without writing back to stack.\n */\n#include \"defs.h\"\n#include \"globals.c\"\n\nvoid vreg_map_to_phys(var_t *var, int phys_reg)\n{\n if (var)\n var->phys_reg = phys_reg;\n}\n\nint vreg_get_phys(var_t *var)\n{\n if (var)\n return var->phys_reg;\n return -1;\n}\n\nvoid vreg_clear_phys(var_t *var)\n{\n if (var)\n var->phys_reg = -1;\n}\n\n/* Aligns size to nearest multiple of 4, this meets ARMv7's alignment\n * requirement.\n *\n * This function should be called whenever handling with user-defined type's\n * size.\n */\nint align_size(int i)\n{\n return i <= 4 ? 4 : (i + 3) & ~3;\n}\n\nbool check_live_out(basic_block_t *bb, var_t *var)\n{\n for (int i = 0; i < bb->live_out.size; i++) {\n if (bb->live_out.elements[i] == var)\n return true;\n }\n return false;\n}\n\nvoid track_var_use(var_t *var, int insn_idx)\n{\n if (!var)\n return;\n\n var->use_count++;\n\n if (var->first_use < 0)\n var->first_use = insn_idx;\n\n var->last_use = insn_idx;\n}\n\nvoid refresh(basic_block_t *bb, insn_t *insn)\n{\n for (int i = 0; i < REG_CNT; i++) {\n if (!REGS[i].var)\n continue;\n if (check_live_out(bb, REGS[i].var))\n continue;\n if (REGS[i].var->consumed < insn->idx) {\n vreg_clear_phys(REGS[i].var);\n REGS[i].var = NULL;\n REGS[i].polluted = 0;\n }\n }\n}\n\nph2_ir_t *bb_add_ph2_ir(basic_block_t *bb, opcode_t op)\n{\n ph2_ir_t *n = arena_alloc(BB_ARENA, sizeof(ph2_ir_t));\n n->op = op;\n /* Initialize all fields explicitly */\n n->next = NULL; /* well-formed singly linked list */\n n->is_branch_detached = 0; /* arch-lowering will set for branches */\n n->src0 = 0;\n n->src1 = 0;\n n->dest = 0;\n n->func_name[0] = '\\0';\n n->next_bb = NULL;\n n->then_bb = NULL;\n n->else_bb = NULL;\n n->ofs_based_on_stack_top = false;\n\n if (!bb->ph2_ir_list.head)\n bb->ph2_ir_list.head = n;\n else\n bb->ph2_ir_list.tail->next = n;\n\n bb->ph2_ir_list.tail = n;\n return n;\n}\n\n/* Calculate the cost of spilling a variable from a register.\n * Higher cost means the variable is more valuable to keep in a register.\n * The cost is computed based on multiple factors that affect performance.\n */\nint calculate_spill_cost(var_t *var, basic_block_t *bb, int current_idx)\n{\n int cost = 0;\n\n /* Variables that are live-out of the basic block must be spilled anyway,\n * so give them a high cost to prefer spilling them over others\n */\n if (check_live_out(bb, var))\n cost += 1000;\n\n /* Variables that will be used soon should have higher cost.\n * The closer the next use, the higher the penalty for spilling\n */\n if (var->consumed > current_idx) {\n int distance = var->consumed - current_idx;\n if (distance < 10)\n cost += 100 - distance * 10; /* Max 100 points for immediate use */\n }\n\n /* Frequently used variables should stay in registers.\n * Each use adds 5 points to the cost\n */\n if (var->use_count > 0)\n cost += var->use_count * 5;\n\n /* Variables inside loops are accessed repeatedly, so they should have much\n * higher priority to stay in registers (200 points per level)\n */\n if (var->loop_depth > 0)\n cost += var->loop_depth * 200;\n\n /* Constants can be easily reloaded, so prefer spilling them by reducing\n * their cost\n */\n if (var->is_const)\n cost -= 50;\n\n /* Variables with long live ranges may benefit from spilling to free up\n * registers for other variables\n */\n if (var->first_use >= 0 && var->last_use >= 0) {\n int range_length = var->last_use - var->first_use;\n if (range_length > 100)\n cost += 20; /* Small penalty for very long live ranges */\n }\n\n return cost;\n}\n\nint find_best_spill(basic_block_t *bb,\n int current_idx,\n int avoid_reg1,\n int avoid_reg2)\n{\n int best_reg = -1;\n int min_cost = 99999;\n\n for (int i = 0; i < REG_CNT; i++) {\n if (i == avoid_reg1 || i == avoid_reg2)\n continue;\n\n if (!REGS[i].var)\n continue;\n\n int cost = calculate_spill_cost(REGS[i].var, bb, current_idx);\n\n if (cost < min_cost) {\n min_cost = cost;\n best_reg = i;\n }\n }\n\n return best_reg;\n}\n\n/* Priority of spilling:\n * - live_out variable\n * - farthest local variable\n */\nvoid spill_var(basic_block_t *bb, var_t *var, int idx)\n{\n if (!REGS[idx].polluted) {\n REGS[idx].var = NULL;\n vreg_clear_phys(var);\n return;\n }\n\n if (!var->space_is_allocated) {\n var->offset = bb->belong_to->stack_size;\n var->space_is_allocated = true;\n bb->belong_to->stack_size += 4;\n }\n ph2_ir_t *ir = var->is_global ? bb_add_ph2_ir(bb, OP_global_store)\n : bb_add_ph2_ir(bb, OP_store);\n ir->src0 = idx;\n ir->src1 = var->offset;\n ir->ofs_based_on_stack_top = var->ofs_based_on_stack_top;\n REGS[idx].var = NULL;\n REGS[idx].polluted = 0;\n vreg_clear_phys(var);\n}\n\n/* Return the index of register for given variable. Otherwise, return -1. */\nint find_in_regs(var_t *var)\n{\n for (int i = 0; i < REG_CNT; i++) {\n if (REGS[i].var == var)\n return i;\n }\n return -1;\n}\n\nvoid load_var(basic_block_t *bb, var_t *var, int idx)\n{\n ph2_ir_t *ir;\n\n /* Load constants directly, others from memory */\n if (var->is_const) {\n ir = bb_add_ph2_ir(bb, OP_load_constant);\n ir->src0 = var->init_val;\n } else {\n ir = var->is_global ? bb_add_ph2_ir(bb, OP_global_load)\n : bb_add_ph2_ir(bb, OP_load);\n ir->src0 = var->offset;\n ir->ofs_based_on_stack_top = var->ofs_based_on_stack_top;\n }\n\n ir->dest = idx;\n REGS[idx].var = var;\n REGS[idx].polluted = 0;\n vreg_map_to_phys(var, idx);\n}\n\nint prepare_operand(basic_block_t *bb, var_t *var, int operand_0)\n{\n /* Check VReg mapping first for O(1) lookup */\n int phys_reg = vreg_get_phys(var);\n if (phys_reg >= 0 && phys_reg < REG_CNT && REGS[phys_reg].var == var)\n return phys_reg;\n\n /* Force reload for address-taken variables (may be modified via pointer) */\n int i = find_in_regs(var);\n if (i > -1 && !var->address_taken) {\n vreg_map_to_phys(var, i);\n return i;\n }\n\n for (i = 0; i < REG_CNT; i++) {\n if (!REGS[i].var) {\n load_var(bb, var, i);\n vreg_map_to_phys(var, i);\n return i;\n }\n }\n\n int spilled = find_best_spill(\n bb, bb->insn_list.tail ? bb->insn_list.tail->idx : 0, operand_0, -1);\n\n if (spilled < 0) {\n for (i = 0; i < REG_CNT; i++) {\n if (i != operand_0 && REGS[i].var) {\n spilled = i;\n break;\n }\n }\n }\n\n if (REGS[spilled].var)\n vreg_clear_phys(REGS[spilled].var);\n\n spill_var(bb, REGS[spilled].var, spilled);\n load_var(bb, var, spilled);\n vreg_map_to_phys(var, spilled);\n\n return spilled;\n}\n\nint prepare_dest(basic_block_t *bb, var_t *var, int operand_0, int operand_1)\n{\n int phys_reg = vreg_get_phys(var);\n if (phys_reg >= 0 && phys_reg < REG_CNT && REGS[phys_reg].var == var) {\n REGS[phys_reg].polluted = 1;\n return phys_reg;\n }\n\n int i = find_in_regs(var);\n if (i > -1) {\n REGS[i].polluted = 1;\n vreg_map_to_phys(var, i);\n return i;\n }\n\n for (i = 0; i < REG_CNT; i++) {\n if (!REGS[i].var) {\n REGS[i].var = var;\n REGS[i].polluted = 1;\n vreg_map_to_phys(var, i);\n return i;\n }\n }\n\n int spilled =\n find_best_spill(bb, bb->insn_list.tail ? bb->insn_list.tail->idx : 0,\n operand_0, operand_1);\n\n if (spilled < 0) {\n for (i = 0; i < REG_CNT; i++) {\n if (i != operand_0 && i != operand_1 && REGS[i].var) {\n spilled = i;\n break;\n }\n }\n }\n\n if (REGS[spilled].var)\n vreg_clear_phys(REGS[spilled].var);\n\n spill_var(bb, REGS[spilled].var, spilled);\n REGS[spilled].var = var;\n REGS[spilled].polluted = 1;\n vreg_map_to_phys(var, spilled);\n\n return spilled;\n}\n\nvoid spill_alive(basic_block_t *bb, insn_t *insn)\n{\n /* Spill all locals on pointer writes (conservative aliasing handling) */\n if (insn && insn->opcode == OP_write) {\n for (int i = 0; i < REG_CNT; i++) {\n if (REGS[i].var && !REGS[i].var->is_global)\n spill_var(bb, REGS[i].var, i);\n }\n return;\n }\n\n /* Standard spilling for non-pointer operations */\n for (int i = 0; i < REG_CNT; i++) {\n if (!REGS[i].var)\n continue;\n if (check_live_out(bb, REGS[i].var)) {\n spill_var(bb, REGS[i].var, i);\n continue;\n }\n if (REGS[i].var->consumed > insn->idx) {\n spill_var(bb, REGS[i].var, i);\n continue;\n }\n }\n}\n\nvoid spill_live_out(basic_block_t *bb)\n{\n for (int i = 0; i < REG_CNT; i++) {\n if (!REGS[i].var)\n continue;\n if (!check_live_out(bb, REGS[i].var)) {\n vreg_clear_phys(REGS[i].var);\n REGS[i].var = NULL;\n REGS[i].polluted = 0;\n continue;\n }\n if (!var_check_killed(REGS[i].var, bb)) {\n vreg_clear_phys(REGS[i].var);\n REGS[i].var = NULL;\n REGS[i].polluted = 0;\n continue;\n }\n spill_var(bb, REGS[i].var, i);\n }\n}\n\n/* The operand of 'OP_push' should not been killed until function called. */\nvoid extend_liveness(basic_block_t *bb, insn_t *insn, var_t *var, int offset)\n{\n if (check_live_out(bb, var))\n return;\n if (insn->idx + offset > var->consumed)\n var->consumed = insn->idx + offset;\n}\n\n/* Return whether extra arguments are pushed onto stack. */\nbool abi_lower_call_args(basic_block_t *bb, insn_t *insn)\n{\n int num_of_args = 0;\n int stack_args = 0;\n while (insn && insn->opcode == OP_push) {\n num_of_args += 1;\n insn = insn->next;\n }\n\n if (num_of_args <= MAX_ARGS_IN_REG)\n return false;\n\n insn = insn->prev;\n stack_args = num_of_args - MAX_ARGS_IN_REG;\n while (stack_args) {\n load_var(bb, insn->rs1, MAX_ARGS_IN_REG - 1);\n ph2_ir_t *ir = bb_add_ph2_ir(bb, OP_store);\n ir->src0 = MAX_ARGS_IN_REG - 1;\n ir->src1 = (stack_args - 1) * 4;\n stack_args -= 1;\n insn = insn->prev;\n }\n REGS[MAX_ARGS_IN_REG - 1].var = NULL;\n return true;\n}\n\nvoid reg_alloc(void)\n{\n /* TODO: Add proper .bss and .data section support for uninitialized /\n * initialized globals\n */\n for (insn_t *global_insn = GLOBAL_FUNC->bbs->insn_list.head; global_insn;\n global_insn = global_insn->next) {\n ph2_ir_t *ir;\n int dest, src0;\n\n switch (global_insn->opcode) {\n case OP_allocat:\n if (global_insn->rd->array_size) {\n /* Original scheme: pointer slot + backing region. Cache the\n * base offset of the backing region into init_val so later\n * global initializers can address elements without loading\n * the pointer.\n */\n global_insn->rd->offset = GLOBAL_FUNC->stack_size;\n global_insn->rd->space_is_allocated = true;\n GLOBAL_FUNC->stack_size += PTR_SIZE;\n src0 = GLOBAL_FUNC->stack_size; /* base of backing region */\n\n /* Stash base offset for this array variable */\n global_insn->rd->init_val = src0;\n\n if (global_insn->rd->ptr_level)\n GLOBAL_FUNC->stack_size +=\n align_size(PTR_SIZE * global_insn->rd->array_size);\n else {\n GLOBAL_FUNC->stack_size +=\n align_size(global_insn->rd->array_size *\n global_insn->rd->type->size);\n }\n\n dest = prepare_dest(GLOBAL_FUNC->bbs, global_insn->rd, -1, -1);\n ir = bb_add_ph2_ir(GLOBAL_FUNC->bbs, OP_global_address_of);\n ir->src0 = src0;\n ir->dest = dest;\n spill_var(GLOBAL_FUNC->bbs, global_insn->rd, dest);\n } else {\n global_insn->rd->offset = GLOBAL_FUNC->stack_size;\n global_insn->rd->space_is_allocated = true;\n if (global_insn->rd->ptr_level)\n GLOBAL_FUNC->stack_size += PTR_SIZE;\n else if (global_insn->rd->type != TY_int &&\n global_insn->rd->type != TY_short &&\n global_insn->rd->type != TY_char &&\n global_insn->rd->type != TY_bool) {\n GLOBAL_FUNC->stack_size +=\n align_size(global_insn->rd->type->size);\n } else\n /* 'char' is aligned to one byte for the convenience */\n GLOBAL_FUNC->stack_size += 4;\n }\n break;\n case OP_load_constant:\n case OP_load_data_address:\n case OP_load_rodata_address:\n dest = prepare_dest(GLOBAL_FUNC->bbs, global_insn->rd, -1, -1);\n ir = bb_add_ph2_ir(GLOBAL_FUNC->bbs, global_insn->opcode);\n ir->src0 = global_insn->rd->init_val;\n ir->dest = dest;\n break;\n case OP_assign:\n src0 = prepare_operand(GLOBAL_FUNC->bbs, global_insn->rs1, -1);\n dest = prepare_dest(GLOBAL_FUNC->bbs, global_insn->rd, src0, -1);\n ir = bb_add_ph2_ir(GLOBAL_FUNC->bbs, OP_assign);\n ir->src0 = src0;\n ir->dest = dest;\n spill_var(GLOBAL_FUNC->bbs, global_insn->rd, dest);\n /* release the unused constant number in register manually */\n REGS[src0].polluted = 0;\n vreg_clear_phys(REGS[src0].var);\n REGS[src0].var = NULL;\n break;\n case OP_add: {\n /* Special-case address computation for globals: if rs1 is a global\n * base and rs2 is a constant, propagate absolute offset to rd so\n * OP_write can fold into OP_global_store.\n */\n if (global_insn->rs1 && global_insn->rs1->is_global &&\n global_insn->rs2) {\n int base_off = global_insn->rs1->offset;\n /* For global arrays, use backing-region base cached in init_val\n */\n if (global_insn->rs1->array_size > 0)\n base_off = global_insn->rs1->init_val;\n global_insn->rd->offset = base_off + global_insn->rs2->init_val;\n global_insn->rd->space_is_allocated = true;\n global_insn->rd->is_global = true;\n break;\n }\n /* Fallback: generate an add */\n int src1;\n src0 = prepare_operand(GLOBAL_FUNC->bbs, global_insn->rs1, -1);\n src1 = prepare_operand(GLOBAL_FUNC->bbs, global_insn->rs2, src0);\n dest = prepare_dest(GLOBAL_FUNC->bbs, global_insn->rd, src0, src1);\n ir = bb_add_ph2_ir(GLOBAL_FUNC->bbs, OP_add);\n ir->src0 = src0;\n ir->src1 = src1;\n ir->dest = dest;\n break;\n }\n case OP_write: {\n /* Fold (addr, val) where addr carries GP-relative offset */\n if (global_insn->rs1 && (global_insn->rs1->is_global)) {\n int vreg =\n prepare_operand(GLOBAL_FUNC->bbs, global_insn->rs2, -1);\n ir = bb_add_ph2_ir(GLOBAL_FUNC->bbs, OP_global_store);\n ir->src0 = vreg;\n /* For array variables used as base, store to the backing\n * region's base offset (cached in init_val).\n */\n int base_off = global_insn->rs1->offset;\n if (global_insn->rs1->array_size > 0)\n base_off = global_insn->rs1->init_val;\n ir->src1 = base_off;\n break;\n }\n /* Fallback generic write */\n int src1;\n src0 = prepare_operand(GLOBAL_FUNC->bbs, global_insn->rs1, -1);\n src1 = prepare_operand(GLOBAL_FUNC->bbs, global_insn->rs2, src0);\n ir = bb_add_ph2_ir(GLOBAL_FUNC->bbs, OP_write);\n ir->src0 = src0;\n ir->src1 = src1;\n ir->dest = global_insn->sz;\n break;\n }\n default:\n printf(\"Unsupported global operation: %d\\n\", global_insn->opcode);\n abort();\n }\n }\n\n for (func_t *func = FUNC_LIST.head; func; func = func->next) {\n /* Skip function declarations without bodies */\n if (!func->bbs)\n continue;\n\n func->visited++;\n\n if (!strcmp(func->return_def.var_name, \"main\"))\n MAIN_BB = func->bbs;\n\n for (int i = 0; i < REG_CNT; i++)\n REGS[i].var = NULL;\n\n /* set arguments available */\n int args_in_reg = func->num_params < MAX_ARGS_IN_REG ? func->num_params\n : MAX_ARGS_IN_REG;\n for (int i = 0; i < args_in_reg; i++) {\n REGS[i].var = func->param_defs[i].subscripts[0];\n REGS[i].polluted = 1;\n }\n\n /* variadic function implementation */\n if (func->va_args) {\n /* When encountering a variadic function, allocate space for all\n * arguments on the local stack to ensure their addresses are\n * contiguous.\n */\n for (int i = 0; i < MAX_PARAMS; i++) {\n ph2_ir_t *ir;\n int src0 = i;\n\n if (i >= MAX_ARGS_IN_REG) {\n /* Callee should access caller's stack to obtain the\n * extra arguments.\n */\n ir = bb_add_ph2_ir(func->bbs, OP_load);\n ir->dest = MAX_ARGS_IN_REG;\n ir->src0 = (i - MAX_ARGS_IN_REG) * 4;\n ir->ofs_based_on_stack_top = true;\n src0 = MAX_ARGS_IN_REG;\n }\n\n if (i < args_in_reg) {\n func->param_defs[i].subscripts[0]->offset =\n func->stack_size;\n func->param_defs[i].subscripts[0]->space_is_allocated =\n true;\n }\n\n ir = bb_add_ph2_ir(func->bbs, OP_store);\n ir->src0 = src0;\n ir->src1 = func->stack_size;\n func->stack_size += 4;\n }\n } else {\n /* If the number of function arguments is fixed, the extra arguments\n * are directly placed in the caller's stack space instead of the\n * callee's.\n *\n * +----------> +---------------+\n * | | local vars |\n * | +---------------+\n * | | extra arg 4 |\n * | +---------------+ <-- sp + stack_size + 12\n * caller's space | extra arg 3 |\n * | +---------------+ <-- sp + stack_size + 8\n * | | extra arg 2 |\n * | +---------------+ <-- sp + stack_size + 4\n * | | extra arg 1 |\n * +----------> +---------------+ <-- sp + stack_size\n * | | local vars |\n * | +---------------+ <-- sp + 16\n * callee's space | Next callee's |\n * | | additional |\n * | | arguments |\n * +----------> +---------------+ <-- sp\n *\n * Note that:\n * - For the Arm architecture, extra arg1 ~ argX correspond to\n * arg5 ~ arg(X + 4).\n * - For the RISC-V architecture, extra arg1 ~ argX correspond to\n * arg9 ~ arg(X + 8).\n *\n * If any instruction use one of these additional arguments, it\n * inherits 'offset' and 'ofs_based_on_stack_top'. When calling\n * cfg_flatten(), the operand's offset will be recalculated by\n * adding the function's stack size.\n */\n for (int i = MAX_ARGS_IN_REG; i < func->num_params; i++) {\n func->param_defs[i].subscripts[0]->offset =\n (i - MAX_ARGS_IN_REG) * 4;\n func->param_defs[i].subscripts[0]->space_is_allocated = true;\n func->param_defs[i].subscripts[0]->ofs_based_on_stack_top =\n true;\n }\n }\n\n for (basic_block_t *bb = func->bbs; bb; bb = bb->rpo_next) {\n bool is_pushing_args = false, handle_abi = false,\n args_on_stack = false;\n int args = 0;\n\n bb->visited++;\n\n for (insn_t *insn = bb->insn_list.head; insn; insn = insn->next) {\n func_t *callee_func;\n ph2_ir_t *ir;\n int dest, src0, src1;\n int sz, clear_reg;\n\n refresh(bb, insn);\n\n switch (insn->opcode) {\n case OP_unwound_phi:\n track_var_use(insn->rs1, insn->idx);\n src0 = prepare_operand(bb, insn->rs1, -1);\n\n if (!insn->rd->space_is_allocated) {\n insn->rd->offset = bb->belong_to->stack_size;\n insn->rd->space_is_allocated = true;\n bb->belong_to->stack_size += 4;\n }\n\n ir = bb_add_ph2_ir(bb, OP_store);\n ir->src0 = src0;\n ir->src1 = insn->rd->offset;\n ir->ofs_based_on_stack_top =\n insn->rd->ofs_based_on_stack_top;\n break;\n case OP_allocat:\n if ((insn->rd->type == TY_void ||\n insn->rd->type == TY_int ||\n insn->rd->type == TY_short ||\n insn->rd->type == TY_char ||\n insn->rd->type == TY_bool) &&\n insn->rd->array_size == 0)\n break;\n\n insn->rd->offset = func->stack_size;\n insn->rd->space_is_allocated = true;\n func->stack_size += PTR_SIZE;\n src0 = func->stack_size;\n\n if (insn->rd->ptr_level)\n sz = PTR_SIZE;\n else {\n sz = insn->rd->type->size;\n }\n\n if (insn->rd->array_size)\n func->stack_size +=\n align_size(insn->rd->array_size * sz);\n else\n func->stack_size += align_size(sz);\n\n dest = prepare_dest(bb, insn->rd, -1, -1);\n ir = bb_add_ph2_ir(bb, OP_address_of);\n ir->src0 = src0;\n ir->dest = dest;\n ir->ofs_based_on_stack_top =\n insn->rd->ofs_based_on_stack_top;\n\n /* For arrays, store the base address just like global\n * arrays do\n */\n if (insn->rd->array_size)\n spill_var(bb, insn->rd, dest);\n break;\n case OP_load_constant:\n case OP_load_data_address:\n case OP_load_rodata_address:\n dest = prepare_dest(bb, insn->rd, -1, -1);\n ir = bb_add_ph2_ir(bb, insn->opcode);\n ir->src0 = insn->rd->init_val;\n ir->dest = dest;\n\n /* store global variable immediately after assignment */\n if (insn->rd->is_global) {\n ir = bb_add_ph2_ir(bb, OP_global_store);\n ir->src0 = dest;\n ir->src1 = insn->rd->offset;\n REGS[dest].polluted = 0;\n }\n\n break;\n case OP_address_of:\n case OP_global_address_of:\n /* Mark variable as address-taken, disable constant\n * optimization\n */\n insn->rs1->address_taken = true;\n insn->rs1->is_const = false;\n\n /* make sure variable is on stack */\n if (!insn->rs1->space_is_allocated) {\n insn->rs1->offset = bb->belong_to->stack_size;\n insn->rs1->space_is_allocated = true;\n bb->belong_to->stack_size += 4;\n\n for (int i = 0; i < REG_CNT; i++)\n if (REGS[i].var == insn->rs1) {\n ir = bb_add_ph2_ir(bb, OP_store);\n ir->src0 = i;\n ir->src1 = insn->rs1->offset;\n ir->ofs_based_on_stack_top =\n insn->rs1->ofs_based_on_stack_top;\n /* Clear stale register tracking */\n REGS[i].var = NULL;\n }\n }\n\n dest = prepare_dest(bb, insn->rd, -1, -1);\n if (insn->rs1->is_global ||\n insn->opcode == OP_global_address_of)\n ir = bb_add_ph2_ir(bb, OP_global_address_of);\n else\n ir = bb_add_ph2_ir(bb, OP_address_of);\n ir->src0 = insn->rs1->offset;\n ir->dest = dest;\n ir->ofs_based_on_stack_top =\n insn->rs1->ofs_based_on_stack_top;\n break;\n case OP_assign:\n if (insn->rd->consumed == -1)\n break;\n\n track_var_use(insn->rs1, insn->idx);\n src0 = find_in_regs(insn->rs1);\n\n /* If operand is loaded from stack, clear the original slot\n * after moving.\n */\n if (src0 > -1)\n clear_reg = 0;\n else {\n clear_reg = 1;\n src0 = prepare_operand(bb, insn->rs1, -1);\n }\n dest = prepare_dest(bb, insn->rd, src0, -1);\n ir = bb_add_ph2_ir(bb, OP_assign);\n ir->src0 = src0;\n ir->dest = dest;\n\n /* store global variable immediately after assignment */\n if (insn->rd->is_global) {\n ir = bb_add_ph2_ir(bb, OP_global_store);\n ir->src0 = dest;\n ir->src1 = insn->rd->offset;\n REGS[dest].polluted = 0;\n }\n\n if (clear_reg) {\n vreg_clear_phys(REGS[src0].var);\n REGS[src0].var = NULL;\n }\n\n break;\n case OP_read:\n src0 = prepare_operand(bb, insn->rs1, -1);\n dest = prepare_dest(bb, insn->rd, src0, -1);\n ir = bb_add_ph2_ir(bb, OP_read);\n ir->src0 = src0;\n ir->src1 = insn->sz;\n ir->dest = dest;\n break;\n case OP_write:\n if (insn->rs2->is_func) {\n src0 = prepare_operand(bb, insn->rs1, -1);\n ir = bb_add_ph2_ir(bb, OP_address_of_func);\n ir->src0 = src0;\n strcpy(ir->func_name, insn->rs2->var_name);\n if (dynlink) {\n func_t *target_fn = find_func(ir->func_name);\n if (target_fn)\n target_fn->is_used = true;\n }\n } else {\n /* FIXME: Register content becomes stale after store\n * operation. Current workaround causes redundant\n * spilling - need better register invalidation\n * strategy.\n */\n spill_alive(bb, insn);\n src0 = prepare_operand(bb, insn->rs1, -1);\n src1 = prepare_operand(bb, insn->rs2, src0);\n ir = bb_add_ph2_ir(bb, OP_write);\n ir->src0 = src0;\n ir->src1 = src1;\n ir->dest = insn->sz;\n }\n break;\n case OP_branch:\n src0 = prepare_operand(bb, insn->rs1, -1);\n\n /* REGS[src0].var had been set to NULL, but the actual\n * content is still holded in the register.\n */\n spill_live_out(bb);\n\n ir = bb_add_ph2_ir(bb, OP_branch);\n ir->src0 = src0;\n ir->then_bb = bb->then_;\n ir->else_bb = bb->else_;\n break;\n case OP_push:\n extend_liveness(bb, insn, insn->rs1, insn->sz);\n\n if (!is_pushing_args) {\n spill_alive(bb, insn);\n is_pushing_args = true;\n }\n if (!handle_abi) {\n args_on_stack = abi_lower_call_args(bb, insn);\n handle_abi = true;\n }\n\n if (args_on_stack && args >= MAX_ARGS_IN_REG)\n break;\n\n src0 = prepare_operand(bb, insn->rs1, -1);\n ir = bb_add_ph2_ir(bb, OP_assign);\n ir->src0 = src0;\n ir->dest = args++;\n REGS[ir->dest].var = insn->rs1;\n REGS[ir->dest].polluted = 0;\n break;\n case OP_call:\n callee_func = find_func(insn->str);\n if (!callee_func->num_params)\n spill_alive(bb, insn);\n\n if (dynlink)\n callee_func->is_used = true;\n\n ir = bb_add_ph2_ir(bb, OP_call);\n strcpy(ir->func_name, insn->str);\n\n is_pushing_args = false;\n args = 0;\n handle_abi = false;\n\n for (int i = 0; i < REG_CNT; i++)\n REGS[i].var = NULL;\n\n break;\n case OP_indirect:\n if (!args)\n spill_alive(bb, insn);\n\n src0 = prepare_operand(bb, insn->rs1, -1);\n ir = bb_add_ph2_ir(bb, OP_load_func);\n ir->src0 = src0;\n\n bb_add_ph2_ir(bb, OP_indirect);\n\n is_pushing_args = false;\n args = 0;\n handle_abi = false;\n break;\n case OP_func_ret:\n dest = prepare_dest(bb, insn->rd, -1, -1);\n ir = bb_add_ph2_ir(bb, OP_assign);\n ir->src0 = 0;\n ir->dest = dest;\n break;\n case OP_return:\n if (insn->rs1)\n src0 = prepare_operand(bb, insn->rs1, -1);\n else\n src0 = -1;\n\n ir = bb_add_ph2_ir(bb, OP_return);\n ir->src0 = src0;\n break;\n case OP_add:\n case OP_sub:\n case OP_mul:\n case OP_div:\n case OP_mod:\n case OP_lshift:\n case OP_rshift:\n case OP_eq:\n case OP_neq:\n case OP_gt:\n case OP_geq:\n case OP_lt:\n case OP_leq:\n case OP_bit_and:\n case OP_bit_or:\n case OP_bit_xor:\n track_var_use(insn->rs1, insn->idx);\n track_var_use(insn->rs2, insn->idx);\n src0 = prepare_operand(bb, insn->rs1, -1);\n src1 = prepare_operand(bb, insn->rs2, src0);\n dest = prepare_dest(bb, insn->rd, src0, src1);\n ir = bb_add_ph2_ir(bb, insn->opcode);\n ir->src0 = src0;\n ir->src1 = src1;\n ir->dest = dest;\n break;\n case OP_negate:\n case OP_bit_not:\n case OP_log_not:\n src0 = prepare_operand(bb, insn->rs1, -1);\n dest = prepare_dest(bb, insn->rd, src0, -1);\n ir = bb_add_ph2_ir(bb, insn->opcode);\n ir->src0 = src0;\n ir->dest = dest;\n break;\n case OP_trunc:\n case OP_sign_ext:\n case OP_cast:\n src0 = prepare_operand(bb, insn->rs1, -1);\n dest = prepare_dest(bb, insn->rd, src0, -1);\n ir = bb_add_ph2_ir(bb, insn->opcode);\n ir->src1 = insn->sz;\n ir->src0 = src0;\n ir->dest = dest;\n break;\n default:\n printf(\"Unknown opcode\\n\");\n abort();\n }\n }\n\n if (bb->next)\n spill_live_out(bb);\n\n if (bb == func->exit)\n continue;\n\n /* append jump instruction for the normal block only */\n if (!bb->next)\n continue;\n\n if (bb->next == func->exit)\n continue;\n\n /* jump to the beginning of loop or over the else block */\n if (bb->next->visited == func->visited ||\n bb->next->rpo != bb->rpo + 1) {\n ph2_ir_t *ir = bb_add_ph2_ir(bb, OP_jump);\n ir->next_bb = bb->next;\n }\n }\n\n /* handle implicit return */\n for (int i = 0; i < MAX_BB_PRED; i++) {\n basic_block_t *bb = func->exit->prev[i].bb;\n if (!bb)\n continue;\n\n if (func->return_def.type != TY_void)\n continue;\n\n if (bb->insn_list.tail)\n if (bb->insn_list.tail->opcode == OP_return)\n continue;\n\n ph2_ir_t *ir = bb_add_ph2_ir(bb, OP_return);\n ir->src0 = -1;\n }\n }\n}\n\nvoid dump_ph2_ir(void)\n{\n for (int i = 0; i < ph2_ir_idx; i++) {\n ph2_ir_t *ph2_ir = PH2_IR_FLATTEN[i];\n\n const int rd = ph2_ir->dest + 48;\n const int rs1 = ph2_ir->src0 + 48;\n const int rs2 = ph2_ir->src1 + 48;\n\n switch (ph2_ir->op) {\n case OP_define:\n printf(\"%s:\", ph2_ir->func_name);\n break;\n case OP_allocat:\n continue;\n case OP_assign:\n printf(\"\\t%%x%c = %%x%c\", rd, rs1);\n break;\n case OP_load_constant:\n printf(\"\\tli %%x%c, $%d\", rd, ph2_ir->src0);\n break;\n case OP_load_data_address:\n printf(\"\\t%%x%c = .data(%d)\", rd, ph2_ir->src0);\n break;\n case OP_load_rodata_address:\n printf(\"\\t%%x%c = .rodata(%d)\", rd, ph2_ir->src0);\n break;\n case OP_address_of:\n printf(\"\\t%%x%c = %%sp + %d\", rd, ph2_ir->src0);\n break;\n case OP_global_address_of:\n printf(\"\\t%%x%c = %%gp + %d\", rd, ph2_ir->src0);\n break;\n case OP_branch:\n printf(\"\\tbr %%x%c\", rs1);\n break;\n case OP_jump:\n printf(\"\\tj %s\", ph2_ir->func_name);\n break;\n case OP_call:\n printf(\"\\tcall @%s\", ph2_ir->func_name);\n break;\n case OP_return:\n if (ph2_ir->src0 == -1)\n printf(\"\\tret\");\n else\n printf(\"\\tret %%x%c\", rs1);\n break;\n case OP_load:\n printf(\"\\tload %%x%c, %d(sp)\", rd, ph2_ir->src0);\n break;\n case OP_store:\n printf(\"\\tstore %%x%c, %d(sp)\", rs1, ph2_ir->src1);\n break;\n case OP_global_load:\n printf(\"\\tload %%x%c, %d(gp)\", rd, ph2_ir->src0);\n break;\n case OP_global_store:\n printf(\"\\tstore %%x%c, %d(gp)\", rs1, ph2_ir->src1);\n break;\n case OP_read:\n printf(\"\\t%%x%c = (%%x%c)\", rd, rs1);\n break;\n case OP_write:\n printf(\"\\t(%%x%c) = %%x%c\", rs1, rs2);\n break;\n case OP_address_of_func:\n printf(\"\\t(%%x%c) = @%s\", rs1, ph2_ir->func_name);\n break;\n case OP_load_func:\n printf(\"\\tload %%t0, %d(sp)\", ph2_ir->src0);\n break;\n case OP_global_load_func:\n printf(\"\\tload %%t0, %d(gp)\", ph2_ir->src0);\n break;\n case OP_indirect:\n printf(\"\\tindirect call @(%%t0)\");\n break;\n case OP_negate:\n printf(\"\\tneg %%x%c, %%x%c\", rd, rs1);\n break;\n case OP_add:\n printf(\"\\t%%x%c = add %%x%c, %%x%c\", rd, rs1, rs2);\n break;\n case OP_sub:\n printf(\"\\t%%x%c = sub %%x%c, %%x%c\", rd, rs1, rs2);\n break;\n case OP_mul:\n printf(\"\\t%%x%c = mul %%x%c, %%x%c\", rd, rs1, rs2);\n break;\n case OP_div:\n printf(\"\\t%%x%c = div %%x%c, %%x%c\", rd, rs1, rs2);\n break;\n case OP_mod:\n printf(\"\\t%%x%c = mod %%x%c, %%x%c\", rd, rs1, rs2);\n break;\n case OP_eq:\n printf(\"\\t%%x%c = eq %%x%c, %%x%c\", rd, rs1, rs2);\n break;\n case OP_neq:\n printf(\"\\t%%x%c = neq %%x%c, %%x%c\", rd, rs1, rs2);\n break;\n case OP_gt:\n printf(\"\\t%%x%c = gt %%x%c, %%x%c\", rd, rs1, rs2);\n break;\n case OP_lt:\n printf(\"\\t%%x%c = lt %%x%c, %%x%c\", rd, rs1, rs2);\n break;\n case OP_geq:\n printf(\"\\t%%x%c = geq %%x%c, %%x%c\", rd, rs1, rs2);\n break;\n case OP_leq:\n printf(\"\\t%%x%c = leq %%x%c, %%x%c\", rd, rs1, rs2);\n break;\n case OP_bit_and:\n printf(\"\\t%%x%c = and %%x%c, %%x%c\", rd, rs1, rs2);\n break;\n case OP_bit_or:\n printf(\"\\t%%x%c = or %%x%c, %%x%c\", rd, rs1, rs2);\n break;\n case OP_bit_not:\n printf(\"\\t%%x%c = not %%x%c\", rd, rs1);\n break;\n case OP_bit_xor:\n printf(\"\\t%%x%c = xor %%x%c, %%x%c\", rd, rs1, rs2);\n break;\n case OP_log_not:\n printf(\"\\t%%x%c = not %%x%c\", rd, rs1);\n break;\n case OP_rshift:\n printf(\"\\t%%x%c = rshift %%x%c, %%x%c\", rd, rs1, rs2);\n break;\n case OP_lshift:\n printf(\"\\t%%x%c = lshift %%x%c, %%x%c\", rd, rs1, rs2);\n break;\n case OP_trunc:\n printf(\"\\t%%x%c = trunc %%x%c, %d\", rd, rs1, ph2_ir->src1);\n break;\n case OP_sign_ext:\n printf(\"\\t%%x%c = sign_ext %%x%c, %d\", rd, rs1, ph2_ir->src1);\n break;\n case OP_cast:\n printf(\"\\t%%x%c = cast %%x%c\", rd, rs1);\n break;\n default:\n break;\n }\n printf(\"\\n\");\n }\n}\n" }, { "path": "src/riscv-codegen.c", "content": "/*\n * shecc - Self-Hosting and Educational C Compiler.\n *\n * shecc is freely redistributable under the BSD 2 clause license. See the\n * file \"LICENSE\" for information on usage and redistribution of this file.\n */\n\n/* Translate IR to target machine code */\n#include \"defs.h\"\n#include \"globals.c\"\n#include \"riscv.c\"\n\nvoid update_elf_offset(ph2_ir_t *ph2_ir)\n{\n switch (ph2_ir->op) {\n case OP_load_constant:\n if (ph2_ir->src0 < -2048 || ph2_ir->src0 > 2047)\n elf_offset += 8;\n else\n elf_offset += 4;\n return;\n case OP_address_of:\n case OP_global_address_of:\n if (ph2_ir->src0 < -2048 || ph2_ir->src0 > 2047)\n elf_offset += 12;\n else\n elf_offset += 4;\n return;\n case OP_assign:\n elf_offset += 4;\n return;\n case OP_load:\n case OP_global_load:\n if (ph2_ir->src0 < -2048 || ph2_ir->src0 > 2047)\n elf_offset += 16;\n else\n elf_offset += 4;\n return;\n case OP_store:\n case OP_global_store:\n if (ph2_ir->src1 < -2048 || ph2_ir->src1 > 2047)\n elf_offset += 16;\n else\n elf_offset += 4;\n return;\n case OP_read:\n case OP_write:\n case OP_jump:\n case OP_call:\n case OP_load_func:\n case OP_indirect:\n case OP_add:\n case OP_sub:\n case OP_lshift:\n case OP_rshift:\n case OP_gt:\n case OP_lt:\n case OP_bit_and:\n case OP_bit_or:\n case OP_bit_xor:\n case OP_negate:\n case OP_bit_not:\n elf_offset += 4;\n return;\n case OP_mul:\n if (hard_mul_div)\n elf_offset += 4;\n else\n elf_offset += 52;\n return;\n case OP_div:\n case OP_mod:\n if (hard_mul_div)\n elf_offset += 4;\n else\n elf_offset += 108;\n return;\n case OP_load_data_address:\n case OP_load_rodata_address:\n case OP_neq:\n case OP_geq:\n case OP_leq:\n case OP_log_not:\n elf_offset += 8;\n return;\n case OP_address_of_func:\n case OP_eq:\n elf_offset += 12;\n return;\n case OP_branch:\n elf_offset += 20;\n return;\n case OP_return:\n elf_offset += 24;\n return;\n case OP_trunc:\n if (ph2_ir->src1 == 2)\n elf_offset += 8;\n else\n elf_offset += 4;\n return;\n case OP_sign_ext: {\n /* Decode source size from upper 16 bits */\n int source_size = (ph2_ir->src1 >> 16) & 0xFFFF;\n if (source_size == 2)\n elf_offset += 8; /* short extension: 2 instructions */\n else\n elf_offset += 12; /* byte extension: 3 instructions */\n return;\n }\n case OP_cast:\n elf_offset += 4;\n return;\n default:\n fatal(\"Unknown opcode\");\n }\n}\n\nvoid cfg_flatten(void)\n{\n func_t *func = find_func(\"__syscall\");\n /* Prologue ~ 6 instructions (24 bytes). Place __syscall right after. */\n func->bbs->elf_offset = 24;\n\n /* Reserve space for prologue (24) + syscall trampoline (36) = 60 bytes. */\n elf_offset = 60;\n GLOBAL_FUNC->bbs->elf_offset = elf_offset;\n\n for (ph2_ir_t *ph2_ir = GLOBAL_FUNC->bbs->ph2_ir_list.head; ph2_ir;\n ph2_ir = ph2_ir->next) {\n update_elf_offset(ph2_ir);\n }\n\n /* prepare 'argc' and 'argv', then proceed to 'main' function */\n elf_offset += 24;\n\n for (func = FUNC_LIST.head; func; func = func->next) {\n /* Skip function declarations without bodies */\n if (!func->bbs)\n continue;\n\n /* reserve stack */\n ph2_ir_t *flatten_ir = add_ph2_ir(OP_define);\n flatten_ir->src0 = func->stack_size;\n strncpy(flatten_ir->func_name, func->return_def.var_name, MAX_VAR_LEN);\n\n for (basic_block_t *bb = func->bbs; bb; bb = bb->rpo_next) {\n bb->elf_offset = elf_offset;\n\n if (bb == func->bbs) {\n /* save ra, sp */\n elf_offset += 16;\n }\n\n for (ph2_ir_t *insn = bb->ph2_ir_list.head; insn;\n insn = insn->next) {\n /* TODO: recalculate the offset for instructions with the\n * 'ofs_based_on_stack_top' flag set.\n */\n flatten_ir = add_existed_ph2_ir(insn);\n\n if (insn->op == OP_return) {\n /* restore sp */\n flatten_ir->src1 = bb->belong_to->stack_size;\n }\n\n update_elf_offset(flatten_ir);\n }\n }\n }\n}\n\nvoid emit(int code)\n{\n elf_write_int(elf_code, code);\n}\n\nvoid emit_ph2_ir(ph2_ir_t *ph2_ir)\n{\n func_t *func;\n int rd = ph2_ir->dest + 10;\n int rs1 = ph2_ir->src0 + 10;\n int rs2 = ph2_ir->src1 + 10;\n int ofs;\n\n /* Prepare the variables to reuse the same code for\n * the instruction sequence of\n * 1. division and modulo.\n * 2. load and store operations.\n * 3. address-of operations.\n */\n rv_reg interm, divisor_mask = __t1;\n\n switch (ph2_ir->op) {\n case OP_define:\n emit(__sw(__ra, __sp, -4));\n emit(__lui(__t0, rv_hi(ph2_ir->src0 + 4)));\n emit(__addi(__t0, __t0, rv_lo(ph2_ir->src0 + 4)));\n emit(__sub(__sp, __sp, __t0));\n return;\n case OP_load_constant:\n if (ph2_ir->src0 < -2048 || ph2_ir->src0 > 2047) {\n emit(__lui(rd, rv_hi(ph2_ir->src0)));\n emit(__addi(rd, rd, rv_lo(ph2_ir->src0)));\n\n } else\n emit(__addi(rd, __zero, ph2_ir->src0));\n return;\n case OP_address_of:\n case OP_global_address_of:\n interm = ph2_ir->op == OP_address_of ? __sp : __gp;\n if (ph2_ir->src0 < -2048 || ph2_ir->src0 > 2047) {\n emit(__lui(__t0, rv_hi(ph2_ir->src0)));\n emit(__addi(__t0, __t0, rv_lo(ph2_ir->src0)));\n emit(__add(rd, interm, __t0));\n } else\n emit(__addi(rd, interm, ph2_ir->src0));\n return;\n case OP_assign:\n emit(__addi(rd, rs1, 0));\n return;\n case OP_load:\n case OP_global_load:\n interm = ph2_ir->op == OP_load ? __sp : __gp;\n if (ph2_ir->src0 < -2048 || ph2_ir->src0 > 2047) {\n emit(__lui(__t0, rv_hi(ph2_ir->src0)));\n emit(__addi(__t0, __t0, rv_lo(ph2_ir->src0)));\n emit(__add(__t0, interm, __t0));\n emit(__lw(rd, __t0, 0));\n } else\n emit(__lw(rd, interm, ph2_ir->src0));\n return;\n case OP_store:\n case OP_global_store:\n interm = ph2_ir->op == OP_store ? __sp : __gp;\n if (ph2_ir->src1 < -2048 || ph2_ir->src1 > 2047) {\n emit(__lui(__t0, rv_hi(ph2_ir->src1)));\n emit(__addi(__t0, __t0, rv_lo(ph2_ir->src1)));\n emit(__add(__t0, interm, __t0));\n emit(__sw(rs1, __t0, 0));\n } else\n emit(__sw(rs1, interm, ph2_ir->src1));\n return;\n case OP_read:\n if (ph2_ir->src1 == 1)\n emit(__lb(rd, rs1, 0));\n else if (ph2_ir->src1 == 2)\n emit(__lh(rd, rs1, 0));\n else if (ph2_ir->src1 == 4)\n emit(__lw(rd, rs1, 0));\n else\n abort();\n return;\n case OP_write:\n if (ph2_ir->dest == 1)\n emit(__sb(rs2, rs1, 0));\n else if (ph2_ir->dest == 2)\n emit(__sh(rs2, rs1, 0));\n else if (ph2_ir->dest == 4)\n emit(__sw(rs2, rs1, 0));\n else\n abort();\n return;\n case OP_branch:\n ofs = elf_code_start + ph2_ir->then_bb->elf_offset;\n emit(__lui(__t0, rv_hi(ofs)));\n emit(__addi(__t0, __t0, rv_lo(ofs)));\n emit(__beq(rs1, __zero, 8));\n emit(__jalr(__zero, __t0, 0));\n emit(__jal(__zero, ph2_ir->else_bb->elf_offset - elf_code->size));\n return;\n case OP_jump:\n emit(__jal(__zero, ph2_ir->next_bb->elf_offset - elf_code->size));\n return;\n case OP_call:\n func = find_func(ph2_ir->func_name);\n emit(__jal(__ra, func->bbs->elf_offset - elf_code->size));\n return;\n case OP_load_data_address:\n emit(__lui(rd, rv_hi(elf_data_start + ph2_ir->src0)));\n emit(__addi(rd, rd, rv_lo(elf_data_start + ph2_ir->src0)));\n return;\n case OP_load_rodata_address:\n emit(__lui(rd, rv_hi(elf_rodata_start + ph2_ir->src0)));\n emit(__addi(rd, rd, rv_lo(elf_rodata_start + ph2_ir->src0)));\n return;\n case OP_address_of_func:\n func = find_func(ph2_ir->func_name);\n ofs = elf_code_start + func->bbs->elf_offset;\n emit(__lui(__t0, rv_hi(ofs)));\n emit(__addi(__t0, __t0, rv_lo(ofs)));\n emit(__sw(__t0, rs1, 0));\n return;\n case OP_load_func:\n emit(__addi(__t0, rs1, 0));\n return;\n case OP_indirect:\n emit(__jalr(__ra, __t0, 0));\n return;\n case OP_return:\n if (ph2_ir->src0 == -1)\n emit(__addi(__zero, __zero, 0));\n else\n emit(__addi(__a0, rs1, 0));\n emit(__lui(__t0, rv_hi(ph2_ir->src1 + 4)));\n emit(__addi(__t0, __t0, rv_lo(ph2_ir->src1 + 4)));\n emit(__add(__sp, __sp, __t0));\n emit(__lw(__ra, __sp, -4));\n emit(__jalr(__zero, __ra, 0));\n return;\n case OP_add:\n emit(__add(rd, rs1, rs2));\n return;\n case OP_sub:\n emit(__sub(rd, rs1, rs2));\n return;\n case OP_mul:\n if (hard_mul_div)\n emit(__mul(rd, rs1, rs2));\n else {\n emit(__addi(__t0, __zero, 0));\n emit(__addi(__t1, __zero, 0));\n emit(__addi(__t3, rs1, 0));\n emit(__addi(__t4, rs2, 0));\n emit(__beq(__t3, __zero, 32));\n emit(__beq(__t4, __zero, 28));\n emit(__andi(__t1, __t4, 1));\n emit(__beq(__t1, __zero, 8));\n emit(__add(__t0, __t0, __t3));\n emit(__slli(__t3, __t3, 1));\n emit(__srli(__t4, __t4, 1));\n emit(__jal(__zero, -28));\n emit(__addi(rd, __t0, 0));\n }\n return;\n case OP_div:\n case OP_mod:\n if (hard_mul_div) {\n if (ph2_ir->op == OP_div)\n emit(__div(rd, rs1, rs2));\n else\n emit(__mod(rd, rs1, rs2));\n return;\n }\n interm = __t0;\n /* div/mod emulation */\n if (ph2_ir->op == OP_mod) {\n /* If the requested operation is modulo, the result will be stored\n * in __t2. The sign of the divisor is irrelevant for determining\n * the result's sign.\n */\n interm = __t2;\n divisor_mask = __zero;\n }\n /* Obtain absolute values of the dividend and divisor */\n emit(__addi(__t2, rs1, 0));\n emit(__addi(__t3, rs2, 0));\n emit(__srai(__t0, __t2, 31));\n emit(__add(__t2, __t2, __t0));\n emit(__xor(__t2, __t2, __t0));\n emit(__srai(__t1, __t3, 31));\n emit(__add(__t3, __t3, __t1));\n emit(__xor(__t3, __t3, __t1));\n emit(__xor(__t5, __t0, divisor_mask));\n /* Unsigned integer division */\n emit(__addi(__t0, __zero, 0));\n emit(__addi(__t1, __zero, 1));\n emit(__beq(__t3, __zero, 52));\n emit(__beq(__t2, __zero, 48));\n emit(__beq(__t2, __t3, 20));\n emit(__bltu(__t2, __t3, 16));\n emit(__slli(__t3, __t3, 1));\n emit(__slli(__t1, __t1, 1));\n emit(__jal(__zero, -16));\n emit(__bltu(__t2, __t3, 12));\n emit(__sub(__t2, __t2, __t3));\n emit(__add(__t0, __t0, __t1));\n emit(__srli(__t1, __t1, 1));\n emit(__srli(__t3, __t3, 1));\n emit(__bne(__t1, __zero, -20));\n emit(__addi(rd, interm, 0));\n /* Handle the correct sign for the quotient or remainder */\n emit(__beq(__t5, __zero, 8));\n emit(__sub(rd, __zero, rd));\n return;\n case OP_lshift:\n emit(__sll(rd, rs1, rs2));\n return;\n case OP_rshift:\n emit(__sra(rd, rs1, rs2));\n return;\n case OP_eq:\n emit(__sub(rd, rs1, rs2));\n emit(__sltu(rd, __zero, rd));\n emit(__xori(rd, rd, 1));\n return;\n case OP_neq:\n emit(__sub(rd, rs1, rs2));\n emit(__sltu(rd, __zero, rd));\n return;\n case OP_gt:\n emit(__slt(rd, rs2, rs1));\n return;\n case OP_geq:\n emit(__slt(rd, rs1, rs2));\n emit(__xori(rd, rd, 1));\n return;\n case OP_lt:\n emit(__slt(rd, rs1, rs2));\n return;\n case OP_leq:\n emit(__slt(rd, rs2, rs1));\n emit(__xori(rd, rd, 1));\n return;\n case OP_negate:\n emit(__sub(rd, __zero, rs1));\n return;\n case OP_bit_not:\n emit(__xori(rd, rs1, -1));\n return;\n case OP_bit_and:\n emit(__and(rd, rs1, rs2));\n return;\n case OP_bit_or:\n emit(__or(rd, rs1, rs2));\n return;\n case OP_bit_xor:\n emit(__xor(rd, rs1, rs2));\n return;\n case OP_log_not:\n emit(__sltu(rd, __zero, rs1));\n emit(__xori(rd, rd, 1));\n return;\n case OP_trunc:\n if (ph2_ir->src1 == 1) {\n emit(__andi(rd, rs1, 0xFF));\n } else if (ph2_ir->src1 == 2) {\n /* For short truncation,\n * use shift operations since 0xFFFF is too large\n */\n emit(__slli(rd, rs1, 16)); /* Shift left 16 bits */\n emit(__srli(rd, rd, 16)); /* Shift right 16 bits logical */\n } else if (ph2_ir->src1 == 4) {\n /* No truncation needed for 32-bit values */\n emit(__add(rd, rs1, __zero));\n } else {\n fatal(\"Unsupported truncation operation with invalid target size\");\n }\n return;\n case OP_sign_ext: {\n /* Decode size information:\n * Lower 16 bits: target size\n * Upper 16 bits: source size\n */\n int target_size = ph2_ir->src1 & 0xFFFF;\n int source_size = (ph2_ir->src1 >> 16) & 0xFFFF;\n\n /* Calculate shift amount based on target and source sizes */\n int shift_amount = (target_size - source_size) * 8;\n\n if (source_size == 2) {\n /* Sign extend from short to word (16-bit shift)\n * For 16-bit sign extension, use only shift operations\n * since 0xFFFF is too large for RISC-V immediate field\n */\n emit(__slli(rd, rs1, shift_amount));\n emit(__srai(rd, rd, shift_amount));\n } else {\n /* Fallback for other sizes */\n emit(__andi(rd, rs1, 0xFF));\n emit(__slli(rd, rd, shift_amount));\n emit(__srai(rd, rd, shift_amount));\n }\n return;\n }\n case OP_cast:\n /* Generic cast operation - for now, just move the value */\n emit(__addi(rd, rs1, 0));\n return;\n default:\n fatal(\"Unknown opcode\");\n }\n}\n\nvoid code_generate(void)\n{\n /* start: save original sp in s0; allocate global stack; run init */\n emit(__addi(__s0, __sp, 0));\n emit(__lui(__t0, rv_hi(GLOBAL_FUNC->stack_size)));\n emit(__addi(__t0, __t0, rv_lo(GLOBAL_FUNC->stack_size)));\n emit(__sub(__sp, __sp, __t0));\n emit(__addi(__gp, __sp, 0)); /* Set up global pointer */\n emit(__jal(__ra, GLOBAL_FUNC->bbs->elf_offset - elf_code->size));\n\n /* syscall trampoline for __syscall - must be at offset 24 */\n emit(__addi(__a7, __a0, 0));\n emit(__addi(__a0, __a1, 0));\n emit(__addi(__a1, __a2, 0));\n emit(__addi(__a2, __a3, 0));\n emit(__addi(__a3, __a4, 0));\n emit(__addi(__a4, __a5, 0));\n emit(__addi(__a5, __a6, 0));\n emit(__ecall());\n emit(__jalr(__zero, __ra, 0));\n\n ph2_ir_t *ph2_ir;\n for (ph2_ir = GLOBAL_FUNC->bbs->ph2_ir_list.head; ph2_ir;\n ph2_ir = ph2_ir->next)\n emit_ph2_ir(ph2_ir);\n\n /* prepare 'argc' and 'argv', then proceed to 'main' function */\n /* use original sp saved in s0 to get argc/argv */\n if (MAIN_BB) {\n emit(__addi(__t0, __s0, 0));\n emit(__lw(__a0, __t0, 0));\n emit(__addi(__a1, __t0, 4));\n emit(__jal(__ra, MAIN_BB->elf_offset - elf_code->size));\n\n /* exit with main's return value in a0 */\n emit(__addi(__a7, __zero, 93));\n emit(__ecall());\n }\n\n for (int i = 0; i < ph2_ir_idx; i++) {\n ph2_ir = PH2_IR_FLATTEN[i];\n emit_ph2_ir(ph2_ir);\n }\n}\n" }, { "path": "src/riscv.c", "content": "/*\n * shecc - Self-Hosting and Educational C Compiler.\n *\n * shecc is freely redistributable under the BSD 2 clause license. See the\n * file \"LICENSE\" for information on usage and redistribution of this file.\n */\n\n/* RISC-V instruction encoding */\n\n/* opcodes */\ntypedef enum {\n /* R type */\n rv_add = 51 /* 0b110011 + (0 << 12) */,\n rv_sub = 1073741875 /* 0b110011 + (0 << 12) + (0x20 << 25) */,\n rv_xor = 16435 /* 0b110011 + (4 << 12) */,\n rv_or = 24627 /* 0b110011 + (6 << 12) */,\n rv_and = 28723 /* 0b110011 + (7 << 12) */,\n rv_sll = 4147 /* 0b110011 + (1 << 12) */,\n rv_srl = 20531 /* 0b110011 + (5 << 12) */,\n rv_sra = 1073762355 /* 0b110011 + (5 << 12) + (0x20 << 25) */,\n rv_slt = 8243 /* 0b110011 + (2 << 12) */,\n rv_sltu = 12339 /* 0b110011 + (3 << 12) */,\n /* I type */\n rv_addi = 19 /* 0b0010011 */,\n rv_xori = 16403 /* 0b0010011 + (4 << 12) */,\n rv_ori = 24595 /* 0b0010011 + (6 << 12) */,\n rv_andi = 28691 /* 0b0010011 + (7 << 12) */,\n rv_slli = 4115 /* 0b0010011 + (1 << 12) */,\n rv_srli = 20499 /* 0b0010011 + (5 << 12) */,\n rv_srai = 1073762323 /* 0b0010011 + (5 << 12) + (0x20 << 25) */,\n rv_slti = 8211 /* 0b0010011 + (2 << 12) */,\n rv_sltiu = 12307 /* 0b0010011 + (3 << 12) */,\n rv_sext_b =\n 1614811155 /* 0b0010011 + (1 << 12) + (0x604 << 20) (imm included)*/,\n /* load/store */\n rv_lb = 3 /* 0b11 */,\n rv_lh = 4099 /* 0b11 + (1 << 12) */,\n rv_lw = 8195 /* 0b11 + (2 << 12) */,\n rv_lbu = 16387 /* 0b11 + (4 << 12) */,\n rv_lhu = 20483 /* 0b11 + (5 << 12) */,\n rv_sb = 35 /* 0b0100011 */,\n rv_sh = 4131 /* 0b0100011 + (1 << 12) */,\n rv_sw = 8227 /* 0b0100011 + (2 << 12) */,\n /* branch */\n rv_beq = 99 /* 0b1100011 */,\n rv_bne = 4195 /* 0b1100011 + (1 << 12) */,\n rv_blt = 16483 /* 0b1100011 + (4 << 12) */,\n rv_bge = 20579 /* 0b1100011 + (5 << 12) */,\n rv_bltu = 24675 /* 0b1100011 + (6 << 12) */,\n rv_bgeu = 28771 /* 0b1100011 + (7 << 12) */,\n /* jumps */\n rv_jal = 111 /* 0b1101111 */,\n rv_jalr = 103 /* 0b1100111 */,\n /* misc */\n rv_lui = 55 /* 0b0110111 */,\n rv_auipc = 23 /* 0b0010111 */,\n rv_ecall = 115 /* 0b1110011 */,\n rv_ebreak = 1048691 /* 0b1110011 + (1 << 20) */,\n /* m */\n rv_mul = 33554483 /* 0b0110011 + (1 << 25) */,\n rv_div = 33570867 /* 0b0110011 + (1 << 25) + (4 << 12) */,\n rv_mod = 33579059 /* 0b0110011 + (1 << 25) + (6 << 12) */\n} rv_op;\n\n/* registers */\ntypedef enum {\n __zero = 0,\n __ra = 1,\n __sp = 2,\n __gp = 3,\n __tp = 4,\n __t0 = 5,\n __t1 = 6,\n __t2 = 7,\n __s0 = 8,\n __s1 = 9,\n __a0 = 10,\n __a1 = 11,\n __a2 = 12,\n __a3 = 13,\n __a4 = 14,\n __a5 = 15,\n __a6 = 16,\n __a7 = 17,\n __s2 = 18,\n __s3 = 19,\n __s4 = 20,\n __s5 = 21,\n __s6 = 22,\n __s7 = 23,\n __s8 = 24,\n __s9 = 25,\n __s10 = 26,\n __s11 = 27,\n __t3 = 28,\n __t4 = 29,\n __t5 = 30,\n __t6 = 31\n} rv_reg;\n\nint rv_extract_bits(int imm, int i_start, int i_end, int d_start, int d_end)\n{\n int v;\n\n if (d_end - d_start != i_end - i_start || i_start > i_end ||\n d_start > d_end)\n fatal(\"Invalid bit copy\");\n\n v = imm >> i_start;\n v &= ((2 << (i_end - i_start)) - 1);\n v <<= d_start;\n return v;\n}\n\nint rv_hi(int val)\n{\n return val + ((val & (1 << 11)) << 1);\n}\n\nint rv_lo(int val)\n{\n return (val & 0xFFF) - ((val & (1 << 11)) << 1);\n}\n\nint rv_encode_R(rv_op op, rv_reg rd, rv_reg rs1, rv_reg rs2)\n{\n return op + (rd << 7) + (rs1 << 15) + (rs2 << 20);\n}\n\nint rv_encode_I(rv_op op, rv_reg rd, rv_reg rs1, int imm)\n{\n if (imm > 2047 || imm < -2048)\n fatal(\"Offset too large\");\n\n if (imm < 0) {\n imm += 4096;\n imm &= (1 << 13) - 1;\n }\n return op + (rd << 7) + (rs1 << 15) + (imm << 20);\n}\n\nint rv_encode_S(rv_op op, rv_reg rs1, rv_reg rs2, int imm)\n{\n if (imm > 2047 || imm < -2048)\n fatal(\"Offset too large\");\n\n if (imm < 0) {\n imm += 4096;\n imm &= (1 << 13) - 1;\n }\n return op + (rs1 << 15) + (rs2 << 20) + rv_extract_bits(imm, 0, 4, 7, 11) +\n rv_extract_bits(imm, 5, 11, 25, 31);\n}\n\nint rv_encode_B(rv_op op, rv_reg rs1, rv_reg rs2, int imm)\n{\n bool sign = false;\n\n /* 13 signed bits, with bit zero ignored */\n if (imm > 4095 || imm < -4096)\n fatal(\"Offset too large\");\n\n if (imm < 0)\n sign = true;\n\n return op + (rs1 << 15) + (rs2 << 20) + rv_extract_bits(imm, 11, 11, 7, 7) +\n rv_extract_bits(imm, 1, 4, 8, 11) +\n rv_extract_bits(imm, 5, 10, 25, 30) + (sign << 31);\n}\n\nint rv_encode_J(rv_op op, rv_reg rd, int imm)\n{\n bool sign = false;\n\n if (imm < 0) {\n sign = true;\n imm = -imm;\n imm = (1 << 21) - imm;\n }\n return op + (rd << 7) + rv_extract_bits(imm, 1, 10, 21, 30) +\n rv_extract_bits(imm, 11, 11, 20, 20) +\n rv_extract_bits(imm, 12, 19, 12, 19) + (sign << 31);\n}\n\nint rv_encode_U(rv_op op, rv_reg rd, int imm)\n{\n return op + (rd << 7) + rv_extract_bits(imm, 12, 31, 12, 31);\n}\n\nint __add(rv_reg rd, rv_reg rs1, rv_reg rs2)\n{\n return rv_encode_R(rv_add, rd, rs1, rs2);\n}\n\nint __sub(rv_reg rd, rv_reg rs1, rv_reg rs2)\n{\n return rv_encode_R(rv_sub, rd, rs1, rs2);\n}\n\nint __xor(rv_reg rd, rv_reg rs1, rv_reg rs2)\n{\n return rv_encode_R(rv_xor, rd, rs1, rs2);\n}\n\nint __or(rv_reg rd, rv_reg rs1, rv_reg rs2)\n{\n return rv_encode_R(rv_or, rd, rs1, rs2);\n}\n\nint __and(rv_reg rd, rv_reg rs1, rv_reg rs2)\n{\n return rv_encode_R(rv_and, rd, rs1, rs2);\n}\n\nint __sll(rv_reg rd, rv_reg rs1, rv_reg rs2)\n{\n return rv_encode_R(rv_sll, rd, rs1, rs2);\n}\n\nint __srl(rv_reg rd, rv_reg rs1, rv_reg rs2)\n{\n return rv_encode_R(rv_srl, rd, rs1, rs2);\n}\n\nint __sra(rv_reg rd, rv_reg rs1, rv_reg rs2)\n{\n return rv_encode_R(rv_sra, rd, rs1, rs2);\n}\n\nint __slt(rv_reg rd, rv_reg rs1, rv_reg rs2)\n{\n return rv_encode_R(rv_slt, rd, rs1, rs2);\n}\n\nint __sltu(rv_reg rd, rv_reg rs1, rv_reg rs2)\n{\n return rv_encode_R(rv_sltu, rd, rs1, rs2);\n}\n\nint __addi(rv_reg rd, rv_reg rs1, int imm)\n{\n return rv_encode_I(rv_addi, rd, rs1, imm);\n}\n\nint __xori(rv_reg rd, rv_reg rs1, int imm)\n{\n return rv_encode_I(rv_xori, rd, rs1, imm);\n}\n\nint __ori(rv_reg rd, rv_reg rs1, int imm)\n{\n return rv_encode_I(rv_ori, rd, rs1, imm);\n}\n\nint __andi(rv_reg rd, rv_reg rs1, int imm)\n{\n return rv_encode_I(rv_andi, rd, rs1, imm);\n}\n\nint __slli(rv_reg rd, rv_reg rs1, int imm)\n{\n return rv_encode_I(rv_slli, rd, rs1, imm);\n}\n\nint __srli(rv_reg rd, rv_reg rs1, int imm)\n{\n return rv_encode_I(rv_srli, rd, rs1, imm);\n}\n\nint __srai(rv_reg rd, rv_reg rs1, int imm)\n{\n return rv_encode_I(rv_srai, rd, rs1, imm);\n}\n\nint __slti(rv_reg rd, rv_reg rs1, int imm)\n{\n return rv_encode_I(rv_slti, rd, rs1, imm);\n}\n\nint __sltiu(rv_reg rd, rv_reg rs1, int imm)\n{\n return rv_encode_I(rv_sltiu, rd, rs1, imm);\n}\n\nint __lb(rv_reg rd, rv_reg rs1, int imm)\n{\n return rv_encode_I(rv_lb, rd, rs1, imm);\n}\n\nint __lh(rv_reg rd, rv_reg rs1, int imm)\n{\n return rv_encode_I(rv_lh, rd, rs1, imm);\n}\n\nint __lw(rv_reg rd, rv_reg rs1, int imm)\n{\n return rv_encode_I(rv_lw, rd, rs1, imm);\n}\n\nint __lbu(rv_reg rd, rv_reg rs1, int imm)\n{\n return rv_encode_I(rv_lbu, rd, rs1, imm);\n}\n\nint __lhu(rv_reg rd, rv_reg rs1, int imm)\n{\n return rv_encode_I(rv_lhu, rd, rs1, imm);\n}\n\nint __sb(rv_reg rd, rv_reg rs1, int imm)\n{\n return rv_encode_S(rv_sb, rs1, rd, imm);\n}\n\nint __sh(rv_reg rd, rv_reg rs1, int imm)\n{\n return rv_encode_S(rv_sh, rs1, rd, imm);\n}\n\nint __sw(rv_reg rd, rv_reg rs1, int imm)\n{\n return rv_encode_S(rv_sw, rs1, rd, imm);\n}\n\nint __beq(rv_reg rs1, rv_reg rs2, int imm)\n{\n return rv_encode_B(rv_beq, rs1, rs2, imm);\n}\n\nint __bne(rv_reg rs1, rv_reg rs2, int imm)\n{\n return rv_encode_B(rv_bne, rs1, rs2, imm);\n}\n\nint __blt(rv_reg rs1, rv_reg rs2, int imm)\n{\n return rv_encode_B(rv_blt, rs1, rs2, imm);\n}\n\nint __bge(rv_reg rs1, rv_reg rs2, int imm)\n{\n return rv_encode_B(rv_bge, rs1, rs2, imm);\n}\n\nint __bltu(rv_reg rs1, rv_reg rs2, int imm)\n{\n return rv_encode_B(rv_bltu, rs1, rs2, imm);\n}\n\nint __bgeu(rv_reg rs1, rv_reg rs2, int imm)\n{\n return rv_encode_B(rv_bgeu, rs1, rs2, imm);\n}\n\nint __jal(rv_reg rd, int imm)\n{\n return rv_encode_J(rv_jal, rd, imm);\n}\n\nint __jalr(rv_reg rd, rv_reg rs1, int imm)\n{\n return rv_encode_I(rv_jalr, rd, rs1, imm);\n}\n\nint __lui(rv_reg rd, int imm)\n{\n return rv_encode_U(rv_lui, rd, imm);\n}\n\nint __auipc(rv_reg rd, int imm)\n{\n return rv_encode_U(rv_auipc, rd, imm);\n}\n\nint __ecall(void)\n{\n return rv_encode_I(rv_ecall, __zero, __zero, 0);\n}\n\n\nint __mul(rv_reg rd, rv_reg rs1, rv_reg rs2)\n{\n return rv_encode_R(rv_mul, rd, rs1, rs2);\n}\n\nint __div(rv_reg rd, rv_reg rs1, rv_reg rs2)\n{\n return rv_encode_R(rv_div, rd, rs1, rs2);\n}\n\nint __mod(rv_reg rd, rv_reg rs1, rv_reg rs2)\n{\n return rv_encode_R(rv_mod, rd, rs1, rs2);\n}\n\nint __sext_b(rv_reg rd, rv_reg rs)\n{\n return rv_encode_I(rv_sext_b, rd, rs, 0);\n}\n" }, { "path": "src/ssa.c", "content": "/*\n * shecc - Self-Hosting and Educational C Compiler.\n *\n * shecc is freely redistributable under the BSD 2 clause license. See the\n * file \"LICENSE\" for information on usage and redistribution of this file.\n */\n#include \n#include \n\n#include \"defs.h\"\n#include \"globals.c\"\n\n/* SCCP (Sparse Conditional Constant Propagation) optimization */\n#include \"opt-sccp.c\"\n\n/* Configuration constants - replace magic numbers */\n#define PHI_WORKLIST_SIZE 128\n#define DCE_WORKLIST_SIZE 2048\n\n/* Dead store elimination window size */\n#define OVERWRITE_WINDOW 3\n\nvoid var_list_ensure_capacity(var_list_t *list, int min_capacity)\n{\n if (list->capacity >= min_capacity)\n return;\n\n int new_capacity = list->capacity ? list->capacity : HOST_PTR_SIZE;\n\n while (new_capacity < min_capacity)\n new_capacity <<= 1;\n\n var_t **new_elements = arena_alloc(BB_ARENA, new_capacity * HOST_PTR_SIZE);\n\n if (list->elements)\n memcpy(new_elements, list->elements, list->size * HOST_PTR_SIZE);\n\n list->elements = new_elements;\n list->capacity = new_capacity;\n}\n\nvoid var_list_add_var(var_list_t *list, var_t *var)\n{\n for (int i = 0; i < list->size; i++) {\n if (list->elements[i] == var)\n return;\n }\n\n var_list_ensure_capacity(list, list->size + 1);\n list->elements[list->size++] = var;\n}\n\nvoid var_list_assign_array(var_list_t *list, var_t **data, int count)\n{\n var_list_ensure_capacity(list, count);\n memcpy(list->elements, data, count * HOST_PTR_SIZE);\n list->size = count;\n}\n\n/* cfront does not accept structure as an argument, pass pointer */\nvoid bb_forward_traversal(bb_traversal_args_t *args)\n{\n args->bb->visited++;\n\n if (args->preorder_cb)\n args->preorder_cb(args->func, args->bb);\n\n /* 'args' is a reference, do not modify it */\n bb_traversal_args_t next_args;\n memcpy(&next_args, args, sizeof(bb_traversal_args_t));\n\n if (args->bb->next) {\n if (args->bb->next->visited < args->func->visited) {\n next_args.bb = args->bb->next;\n bb_forward_traversal(&next_args);\n }\n }\n if (args->bb->then_) {\n if (args->bb->then_->visited < args->func->visited) {\n next_args.bb = args->bb->then_;\n bb_forward_traversal(&next_args);\n }\n }\n if (args->bb->else_) {\n if (args->bb->else_->visited < args->func->visited) {\n next_args.bb = args->bb->else_;\n bb_forward_traversal(&next_args);\n }\n }\n\n if (args->postorder_cb)\n args->postorder_cb(args->func, args->bb);\n}\n\n/* cfront does not accept structure as an argument, pass pointer */\nvoid bb_backward_traversal(bb_traversal_args_t *args)\n{\n args->bb->visited++;\n\n if (args->preorder_cb)\n args->preorder_cb(args->func, args->bb);\n\n for (int i = 0; i < MAX_BB_PRED; i++) {\n if (!args->bb->prev[i].bb)\n continue;\n if (args->bb->prev[i].bb->visited < args->func->visited) {\n /* 'args' is a reference, do not modify it */\n bb_traversal_args_t next_args;\n memcpy(&next_args, args, sizeof(bb_traversal_args_t));\n\n next_args.bb = args->bb->prev[i].bb;\n bb_backward_traversal(&next_args);\n }\n }\n\n if (args->postorder_cb)\n args->postorder_cb(args->func, args->bb);\n}\n\nvoid bb_index_rpo(func_t *func, basic_block_t *bb)\n{\n bb->rpo = func->bb_cnt++;\n}\n\nvoid bb_reverse_index(func_t *func, basic_block_t *bb)\n{\n bb->rpo = func->bb_cnt - bb->rpo;\n}\n\nvoid bb_build_rpo(func_t *func, basic_block_t *bb)\n{\n if (func->bbs == bb)\n return;\n\n basic_block_t *prev = func->bbs;\n basic_block_t *curr = prev->rpo_next;\n for (; curr; curr = curr->rpo_next) {\n if (curr->rpo < bb->rpo) {\n prev = curr;\n continue;\n }\n bb->rpo_next = curr;\n prev->rpo_next = bb;\n prev = curr;\n return;\n }\n\n prev->rpo_next = bb;\n}\n\nvoid build_rpo(void)\n{\n bb_traversal_args_t *args = arena_alloc_traversal_args();\n for (func_t *func = FUNC_LIST.head; func; func = func->next) {\n /* Skip function declarations without bodies */\n if (!func->bbs)\n continue;\n\n args->func = func;\n args->bb = func->bbs;\n\n func->visited++;\n args->postorder_cb = bb_index_rpo;\n bb_forward_traversal(args);\n\n func->visited++;\n args->postorder_cb = bb_reverse_index;\n bb_forward_traversal(args);\n\n func->visited++;\n args->postorder_cb = bb_build_rpo;\n bb_forward_traversal(args);\n }\n}\n\nbasic_block_t *intersect(basic_block_t *i, basic_block_t *j)\n{\n while (i != j) {\n while (i->rpo > j->rpo)\n i = i->idom;\n while (j->rpo > i->rpo)\n j = j->idom;\n }\n return i;\n}\n\n/* Find the immediate dominator of each basic block to build the dominator tree.\n *\n * Once the dominator tree is built, we can perform the more advanced\n * optimiaztion according to the liveness analysis and the reachability\n * analysis, e.g. common subexpression elimination, loop optimiaztion or dead\n * code elimination .\n *\n * Reference:\n * Cooper, Keith D.; Harvey, Timothy J.; Kennedy, Ken (2001).\n * \"A Simple, Fast Dominance Algorithm\"\n */\nvoid build_idom(void)\n{\n for (func_t *func = FUNC_LIST.head; func; func = func->next) {\n /* Skip function declarations without bodies */\n if (!func->bbs)\n continue;\n\n bool changed;\n\n func->bbs->idom = func->bbs;\n\n do {\n changed = false;\n\n for (basic_block_t *bb = func->bbs->rpo_next; bb;\n bb = bb->rpo_next) {\n /* pick one predecessor */\n basic_block_t *pred;\n for (int i = 0; i < MAX_BB_PRED; i++) {\n if (!bb->prev[i].bb)\n continue;\n if (!bb->prev[i].bb->idom)\n continue;\n pred = bb->prev[i].bb;\n break;\n }\n\n for (int i = 0; i < MAX_BB_PRED; i++) {\n if (!bb->prev[i].bb)\n continue;\n if (bb->prev[i].bb == pred)\n continue;\n if (bb->prev[i].bb->idom)\n pred = intersect(bb->prev[i].bb, pred);\n }\n if (bb->idom != pred) {\n bb->idom = pred;\n changed = true;\n }\n }\n } while (changed);\n }\n}\n\nbool dom_connect(basic_block_t *pred, basic_block_t *succ)\n{\n if (succ->dom_prev)\n return false;\n\n int i;\n for (i = 0; i < MAX_BB_DOM_SUCC; i++) {\n if (pred->dom_next[i] == succ)\n return false;\n if (!pred->dom_next[i])\n break;\n }\n\n if (i > MAX_BB_DOM_SUCC - 1)\n fatal(\"Too many predecessors in dominator tree\");\n\n pred->dom_next[i++] = succ;\n succ->dom_prev = pred;\n return true;\n}\n\nvoid bb_build_dom(func_t *func, basic_block_t *bb)\n{\n basic_block_t *curr = bb;\n while (curr != func->bbs) {\n if (!dom_connect(curr->idom, curr))\n break;\n curr = curr->idom;\n }\n}\n\nvoid build_dom(void)\n{\n bb_traversal_args_t *args = arena_alloc_traversal_args();\n for (func_t *func = FUNC_LIST.head; func; func = func->next) {\n /* Skip function declarations without bodies */\n if (!func->bbs)\n continue;\n\n args->func = func;\n args->bb = func->bbs;\n\n func->visited++;\n args->preorder_cb = bb_build_dom;\n bb_forward_traversal(args);\n }\n}\n\nvoid bb_build_df(func_t *func, basic_block_t *bb)\n{\n UNUSED(func);\n\n int cnt = 0;\n for (int i = 0; i < MAX_BB_PRED; i++) {\n if (bb->prev[i].bb)\n cnt++;\n }\n if (cnt <= 0)\n return;\n\n for (int i = 0; i < MAX_BB_PRED; i++) {\n if (bb->prev[i].bb) {\n for (basic_block_t *curr = bb->prev[i].bb; curr != bb->idom;\n curr = curr->idom)\n curr->DF[curr->df_idx++] = bb;\n }\n }\n}\n\nvoid build_df(void)\n{\n bb_traversal_args_t *args = arena_alloc_traversal_args();\n for (func_t *func = FUNC_LIST.head; func; func = func->next) {\n /* Skip function declarations without bodies */\n if (!func->bbs)\n continue;\n\n args->func = func;\n args->bb = func->bbs;\n\n func->visited++;\n args->postorder_cb = bb_build_df;\n bb_forward_traversal(args);\n }\n}\n\nbasic_block_t *reverse_intersect(basic_block_t *i, basic_block_t *j)\n{\n while (i != j) {\n while (i->rpo_r > j->rpo_r)\n i = i->r_idom;\n while (j->rpo_r > i->rpo_r)\n j = j->r_idom;\n }\n return i;\n}\n\nvoid build_r_idom(void)\n{\n for (func_t *func = FUNC_LIST.head; func; func = func->next) {\n /* Skip function declarations without bodies */\n if (!func->bbs)\n continue;\n\n bool changed;\n\n func->exit->r_idom = func->exit;\n\n do {\n changed = false;\n\n for (basic_block_t *bb = func->exit->rpo_r_next; bb;\n bb = bb->rpo_r_next) {\n /* pick one predecessor */\n basic_block_t *pred;\n if (bb->next && bb->next->r_idom) {\n pred = bb->next;\n } else if (bb->else_ && bb->else_->r_idom) {\n pred = bb->else_;\n } else if (bb->then_ && bb->then_->r_idom) {\n pred = bb->then_;\n }\n\n if (bb->next && bb->next != pred && bb->next->r_idom)\n pred = reverse_intersect(bb->next, pred);\n if (bb->else_ && bb->else_ != pred && bb->else_->r_idom)\n pred = reverse_intersect(bb->else_, pred);\n if (bb->then_ && bb->then_ != pred && bb->then_->r_idom)\n pred = reverse_intersect(bb->then_, pred);\n if (bb->r_idom != pred) {\n bb->r_idom = pred;\n changed = true;\n }\n }\n } while (changed);\n }\n}\n\nbool rdom_connect(basic_block_t *pred, basic_block_t *succ)\n{\n if (succ->rdom_prev)\n return false;\n\n int i;\n for (i = 0; i < MAX_BB_RDOM_SUCC; i++) {\n if (pred->rdom_next[i] == succ)\n return false;\n if (!pred->rdom_next[i])\n break;\n }\n\n if (i > MAX_BB_RDOM_SUCC - 1)\n fatal(\"Too many predecessors in reverse dominator tree\");\n\n pred->rdom_next[i++] = succ;\n succ->rdom_prev = pred;\n return true;\n}\n\nvoid bb_build_rdom(func_t *func, basic_block_t *bb)\n{\n if (!func->bbs)\n return;\n for (basic_block_t *curr = bb; curr != func->exit; curr = curr->r_idom) {\n if (!rdom_connect(curr->r_idom, curr))\n break;\n }\n}\n\nvoid build_rdom(void)\n{\n bb_traversal_args_t *args = arena_alloc_traversal_args();\n for (func_t *func = FUNC_LIST.head; func; func = func->next) {\n /* Skip function declarations without bodies */\n if (!func->bbs)\n continue;\n\n args->func = func;\n args->bb = func->exit;\n\n func->visited++;\n args->preorder_cb = bb_build_rdom;\n bb_backward_traversal(args);\n }\n}\n\nvoid bb_build_rdf(func_t *func, basic_block_t *bb)\n{\n UNUSED(func);\n\n int cnt = 0;\n if (bb->next)\n cnt++;\n if (bb->then_)\n cnt++;\n if (bb->else_)\n cnt++;\n if (cnt <= 0)\n return;\n\n if (bb->next) {\n for (basic_block_t *curr = bb->next; curr != bb->r_idom;\n curr = curr->r_idom)\n curr->RDF[curr->rdf_idx++] = bb;\n }\n if (bb->else_) {\n for (basic_block_t *curr = bb->else_; curr != bb->r_idom;\n curr = curr->r_idom)\n curr->RDF[curr->rdf_idx++] = bb;\n }\n if (bb->then_) {\n for (basic_block_t *curr = bb->then_; curr != bb->r_idom;\n curr = curr->r_idom)\n curr->RDF[curr->rdf_idx++] = bb;\n }\n}\n\nvoid build_rdf(void)\n{\n bb_traversal_args_t *args = arena_alloc_traversal_args();\n for (func_t *func = FUNC_LIST.head; func; func = func->next) {\n /* Skip function declarations without bodies */\n if (!func->bbs)\n continue;\n\n args->func = func;\n args->bb = func->exit;\n\n func->visited++;\n args->postorder_cb = bb_build_rdf;\n bb_backward_traversal(args);\n }\n}\n\nvoid use_chain_add_tail(insn_t *i, var_t *var)\n{\n use_chain_t *u = arena_calloc(INSN_ARENA, 1, sizeof(use_chain_t));\n\n u->insn = i;\n if (!var->users_head)\n var->users_head = u;\n else\n var->users_tail->next = u;\n u->prev = var->users_tail;\n var->users_tail = u;\n}\n\nvoid use_chain_delete(use_chain_t *u, var_t *var)\n{\n if (u->prev)\n u->prev->next = u->next;\n else {\n var->users_head = u->next;\n u->next->prev = NULL;\n }\n if (u->next)\n u->next->prev = u->prev;\n else {\n var->users_tail = u->prev;\n u->prev->next = NULL;\n }\n}\n\nvoid use_chain_build(void)\n{\n for (func_t *func = FUNC_LIST.head; func; func = func->next) {\n /* Skip function declarations without bodies */\n if (!func->bbs)\n continue;\n\n for (basic_block_t *bb = func->bbs; bb; bb = bb->rpo_next) {\n for (insn_t *i = bb->insn_list.head; i; i = i->next) {\n if (i->rs1)\n use_chain_add_tail(i, i->rs1);\n if (i->rs2)\n use_chain_add_tail(i, i->rs2);\n }\n }\n }\n}\n\nbool var_check_killed(var_t *var, basic_block_t *bb)\n{\n for (int i = 0; i < bb->live_kill.size; i++) {\n if (bb->live_kill.elements[i] == var)\n return true;\n }\n return false;\n}\n\nvoid bb_add_killed_var(basic_block_t *bb, var_t *var)\n{\n var_list_add_var(&bb->live_kill, var);\n}\n\nvoid var_add_killed_bb(var_t *var, basic_block_t *bb)\n{\n bool found = false;\n ref_block_t *ref;\n for (ref = var->ref_block_list.head; ref; ref = ref->next) {\n if (ref->bb == bb) {\n found = true;\n break;\n }\n }\n if (found)\n return;\n\n ref = arena_calloc(GENERAL_ARENA, 1, sizeof(ref_block_t));\n ref->bb = bb;\n if (!var->ref_block_list.head)\n var->ref_block_list.head = ref;\n else\n var->ref_block_list.tail->next = ref;\n\n var->ref_block_list.tail = ref;\n}\n\nvoid fn_add_global(func_t *func, var_t *var)\n{\n bool found = false;\n symbol_t *sym;\n for (sym = func->global_sym_list.head; sym; sym = sym->next) {\n if (sym->var == var) {\n found = true;\n break;\n }\n }\n if (found)\n return;\n\n sym = arena_alloc_symbol();\n sym->var = var;\n if (!func->global_sym_list.head) {\n sym->index = 0;\n func->global_sym_list.head = sym;\n func->global_sym_list.tail = sym;\n } else {\n sym->index = func->global_sym_list.tail->index + 1;\n func->global_sym_list.tail->next = sym;\n func->global_sym_list.tail = sym;\n }\n}\n\nvoid bb_solve_globals(func_t *func, basic_block_t *bb)\n{\n UNUSED(func);\n\n for (insn_t *insn = bb->insn_list.head; insn; insn = insn->next) {\n if (insn->rs1)\n if (!var_check_killed(insn->rs1, bb))\n fn_add_global(bb->belong_to, insn->rs1);\n if (insn->rs2)\n if (!var_check_killed(insn->rs2, bb))\n fn_add_global(bb->belong_to, insn->rs2);\n if (insn->rd) {\n bb_add_killed_var(bb, insn->rd);\n var_add_killed_bb(insn->rd, bb);\n }\n }\n}\n\nvoid solve_globals(void)\n{\n bb_traversal_args_t *args = arena_alloc_traversal_args();\n for (func_t *func = FUNC_LIST.head; func; func = func->next) {\n /* Skip function declarations without bodies */\n if (!func->bbs)\n continue;\n\n args->func = func;\n args->bb = func->bbs;\n\n func->visited++;\n args->postorder_cb = bb_solve_globals;\n bb_forward_traversal(args);\n }\n}\n\nbool var_check_in_scope(var_t *var, block_t *block)\n{\n func_t *func = block->func;\n\n while (block) {\n for (int i = 0; i < block->locals.capacity; i++) {\n if (var == block->locals.elements[i])\n return true;\n }\n block = block->parent;\n }\n\n for (int i = 0; i < func->num_params; i++) {\n if (&func->param_defs[i] == var)\n return true;\n }\n\n return false;\n}\n\nbool insert_phi_insn(basic_block_t *bb, var_t *var)\n{\n bool found = false;\n for (insn_t *insn = bb->insn_list.head; insn; insn = insn->next) {\n if ((insn->opcode == OP_phi) && (insn->rd == var)) {\n found = true;\n break;\n }\n }\n if (found)\n return false;\n\n insn_t *head = bb->insn_list.head;\n insn_t *n = arena_calloc(INSN_ARENA, 1, sizeof(insn_t));\n n->opcode = OP_phi;\n n->rd = var;\n n->rs1 = var;\n n->rs2 = var;\n if (!head) {\n bb->insn_list.head = n;\n bb->insn_list.tail = n;\n } else {\n head->prev = n;\n n->next = head;\n bb->insn_list.head = n;\n }\n return true;\n}\n\nvoid solve_phi_insertion(void)\n{\n for (func_t *func = FUNC_LIST.head; func; func = func->next) {\n /* Skip function declarations without bodies */\n if (!func->bbs)\n continue;\n\n for (symbol_t *sym = func->global_sym_list.head; sym; sym = sym->next) {\n var_t *var = sym->var;\n\n basic_block_t *work_list[PHI_WORKLIST_SIZE];\n int work_list_idx = 0;\n\n for (ref_block_t *ref = var->ref_block_list.head; ref;\n ref = ref->next) {\n if (work_list_idx >= PHI_WORKLIST_SIZE - 1)\n fatal(\"PHI worklist overflow\");\n work_list[work_list_idx++] = ref->bb;\n }\n\n for (int i = 0; i < work_list_idx; i++) {\n basic_block_t *bb = work_list[i];\n for (int j = 0; j < bb->df_idx; j++) {\n basic_block_t *df = bb->DF[j];\n if (!var_check_in_scope(var, df->scope))\n continue;\n\n bool is_decl = false;\n for (symbol_t *s = df->symbol_list.head; s; s = s->next) {\n if (s->var == var) {\n is_decl = true;\n break;\n }\n }\n\n if (is_decl)\n continue;\n\n if (df == func->exit)\n continue;\n\n if (var->is_global)\n continue;\n\n if (insert_phi_insn(df, var)) {\n bool found = false;\n\n /* Restrict phi insertion of ternary operation, and\n * logical-and/or operation.\n *\n * The ternary and logical-and/or operations don't\n * create new scope, so prevent temporary variable from\n * propagating through the dominance tree.\n */\n if (var->is_ternary_ret || var->is_logical_ret)\n continue;\n\n for (int l = 0; l < work_list_idx; l++) {\n if (work_list[l] == df) {\n found = true;\n break;\n }\n }\n if (!found) {\n if (work_list_idx >= PHI_WORKLIST_SIZE - 1)\n fatal(\"PHI worklist overflow\");\n work_list[work_list_idx++] = df;\n }\n }\n }\n }\n }\n }\n}\n\nvar_t *require_var(block_t *blk);\n\nvoid new_name(block_t *block, var_t **var)\n{\n var_t *v = *var;\n if (!v->base)\n v->base = v;\n if (v->is_global)\n return;\n\n int i = v->base->rename.counter++;\n v->base->rename.stack[v->base->rename.stack_idx++] = i;\n var_t *vd = require_var(block);\n memcpy(vd, *var, sizeof(var_t));\n vd->base = *var;\n vd->subscript = i;\n v->subscripts[v->subscripts_idx++] = vd;\n var[0] = vd;\n}\n\nvar_t *get_stack_top_subscript_var(var_t *var)\n{\n if (var->base->rename.stack_idx < 1)\n return var; /* fallback: use base when no prior definition */\n\n int sub = var->base->rename.stack[var->base->rename.stack_idx - 1];\n for (int i = 0; i < var->base->subscripts_idx; i++) {\n if (var->base->subscripts[i]->subscript == sub)\n return var->base->subscripts[i];\n }\n\n fatal(\"Failed to find subscript variable on rename stack\");\n return NULL; /* unreachable, but silences compiler warning */\n}\n\nvoid rename_var(var_t **var)\n{\n var_t *v = *var;\n if (!v->base)\n v->base = v;\n if (v->is_global)\n return;\n\n var[0] = get_stack_top_subscript_var(*var);\n}\n\nvoid pop_name(var_t *var)\n{\n if (var->is_global)\n return;\n var->base->rename.stack_idx--;\n}\n\nvoid append_phi_operand(insn_t *insn, var_t *var, basic_block_t *bb_from)\n{\n phi_operand_t *op = arena_calloc(GENERAL_ARENA, 1, sizeof(phi_operand_t));\n op->from = bb_from;\n op->var = get_stack_top_subscript_var(var);\n\n phi_operand_t *tail = insn->phi_ops;\n if (tail) {\n while (tail->next)\n tail = tail->next;\n tail->next = op;\n } else\n insn->phi_ops = op;\n}\n\nvoid bb_solve_phi_params(basic_block_t *bb)\n{\n for (insn_t *insn = bb->insn_list.head; insn; insn = insn->next) {\n if (insn->opcode == OP_phi)\n new_name(bb->scope, &insn->rd);\n else {\n if (insn->rs1)\n rename_var(&insn->rs1);\n if (insn->rs2)\n if (!insn->rs2->is_func)\n rename_var(&insn->rs2);\n if (insn->rd)\n new_name(bb->scope, &insn->rd);\n }\n }\n\n if (bb->next) {\n for (insn_t *insn = bb->next->insn_list.head; insn; insn = insn->next) {\n if (insn->opcode == OP_phi)\n append_phi_operand(insn, insn->rd, bb);\n }\n }\n\n if (bb->then_) {\n for (insn_t *insn = bb->then_->insn_list.head; insn;\n insn = insn->next) {\n if (insn->opcode == OP_phi)\n append_phi_operand(insn, insn->rd, bb);\n }\n }\n\n if (bb->else_) {\n for (insn_t *insn = bb->else_->insn_list.head; insn;\n insn = insn->next) {\n if (insn->opcode == OP_phi)\n append_phi_operand(insn, insn->rd, bb);\n }\n }\n\n for (int i = 0; i < MAX_BB_DOM_SUCC; i++) {\n if (!bb->dom_next[i])\n break;\n bb_solve_phi_params(bb->dom_next[i]);\n }\n\n for (insn_t *insn = bb->insn_list.head; insn; insn = insn->next) {\n if (insn->opcode == OP_phi)\n pop_name(insn->rd);\n else if (insn->rd)\n pop_name(insn->rd);\n }\n}\n\nvoid solve_phi_params(void)\n{\n for (func_t *func = FUNC_LIST.head; func; func = func->next) {\n /* Skip function declarations without bodies */\n if (!func->bbs)\n continue;\n\n for (int i = 0; i < func->num_params; i++) {\n /* FIXME: Direct argument renaming in SSA construction phase may\n * interfere with later optimization passes\n */\n var_t *var = require_var(func->bbs->scope);\n var_t *base = &func->param_defs[i];\n memcpy(var, base, sizeof(var_t));\n var->base = base;\n var->subscript = 0;\n\n base->rename.stack[base->rename.stack_idx++] =\n base->rename.counter++;\n base->subscripts[base->subscripts_idx++] = var;\n }\n\n bb_solve_phi_params(func->bbs);\n }\n}\n\nvoid append_unwound_phi_insn(basic_block_t *bb, var_t *dest, var_t *rs)\n{\n insn_t *n = arena_calloc(INSN_ARENA, 1, sizeof(insn_t));\n n->opcode = OP_unwound_phi;\n n->rd = dest;\n n->rs1 = rs;\n n->belong_to = bb;\n\n insn_t *tail = bb->insn_list.tail;\n if (!tail) {\n bb->insn_list.head = n;\n bb->insn_list.tail = n;\n } else {\n /* insert it before branch instruction */\n if (tail->opcode == OP_branch) {\n if (tail->prev) {\n tail->prev->next = n;\n n->prev = tail->prev;\n } else\n bb->insn_list.head = n;\n\n n->next = tail;\n tail->prev = n;\n } else {\n tail->next = n;\n bb->insn_list.tail = n;\n }\n }\n}\n\nvoid bb_unwind_phi(func_t *func, basic_block_t *bb)\n{\n UNUSED(func);\n\n insn_t *insn;\n for (insn = bb->insn_list.head; insn; insn = insn->next) {\n if (insn->opcode != OP_phi)\n break;\n\n for (phi_operand_t *operand = insn->phi_ops; operand;\n operand = operand->next)\n append_unwound_phi_insn(operand->from, insn->rd, operand->var);\n }\n\n bb->insn_list.head = insn;\n if (!insn)\n bb->insn_list.tail = NULL;\n else\n insn->prev = NULL;\n}\n\nvoid unwind_phi(void)\n{\n bb_traversal_args_t *args = arena_alloc_traversal_args();\n for (func_t *func = FUNC_LIST.head; func; func = func->next) {\n /* Skip function declarations without bodies */\n if (!func->bbs)\n continue;\n\n args->func = func;\n args->bb = func->bbs;\n\n func->visited++;\n args->preorder_cb = bb_unwind_phi;\n bb_forward_traversal(args);\n }\n}\n\nbool is_dominate(basic_block_t *pred, basic_block_t *succ)\n{\n int i;\n bool found = false;\n for (i = 0; i < MAX_BB_DOM_SUCC; i++) {\n if (!pred->dom_next[i])\n break;\n if (pred->dom_next[i] == succ) {\n found = true;\n break;\n }\n found |= is_dominate(pred->dom_next[i], succ);\n }\n\n return found;\n}\n\n/*\n * For any variable, the basic block that defines it must dominate all the\n * basic blocks where it is used; otherwise, it is an invalid cross-block\n * initialization.\n */\nvoid bb_check_var_cross_init(func_t *func, basic_block_t *bb)\n{\n UNUSED(func);\n\n for (insn_t *insn = bb->insn_list.head; insn; insn = insn->next) {\n if (insn->opcode != OP_allocat)\n continue;\n\n var_t *var = insn->rd;\n ref_block_t *ref;\n for (ref = var->ref_block_list.head; ref; ref = ref->next) {\n if (ref->bb == bb)\n continue;\n\n if (!is_dominate(bb, ref->bb))\n printf(\"Warning: Variable '%s' cross-initialized\\n\",\n var->var_name);\n }\n }\n}\n\n/**\n * A variable's initialization lives in a basic block that does not dominate\n * all of its uses, so control flow can reach a use without first passing\n * through its initialization (i.e., a possibly-uninitialized use).\n *\n * For Example:\n * // Jumps directly to 'label', skipping the declaration below\n * goto label;\n * if (1) {\n * // This line is never executed when 'goto' is taken\n * int x;\n * label:\n * // Uses 'x' after its declaration was bypassed\n * x = 5;\n * }\n */\nvoid check_var_cross_init()\n{\n bb_traversal_args_t *args = arena_alloc_traversal_args();\n for (func_t *func = FUNC_LIST.head; func; func = func->next) {\n /* Skip function declarations without bodies */\n if (!func->bbs)\n continue;\n\n args->func = func;\n args->bb = func->bbs;\n\n func->visited++;\n args->postorder_cb = bb_check_var_cross_init;\n bb_forward_traversal(args);\n }\n}\n\n#ifdef __SHECC__\n#else\nvoid bb_dump_connection(FILE *fd,\n basic_block_t *curr,\n basic_block_t *next,\n bb_connection_type_t type)\n{\n char *str;\n\n switch (type) {\n case NEXT:\n str = \"%s_%p:s->%s_%p:n\\n\";\n break;\n case THEN:\n str = \"%s_%p:sw->%s_%p:n\\n\";\n break;\n case ELSE:\n str = \"%s_%p:se->%s_%p:n\\n\";\n break;\n default:\n fatal(\"Unknown basic block connection type\");\n }\n\n char *pred;\n void *pred_id;\n if (curr->insn_list.tail) {\n pred = \"insn\";\n pred_id = curr->insn_list.tail;\n } else {\n pred = \"pseudo\";\n pred_id = curr;\n }\n\n char *succ;\n void *succ_id;\n if (next->insn_list.tail) {\n succ = \"insn\";\n succ_id = next->insn_list.head;\n } else {\n succ = \"pseudo\";\n succ_id = next;\n }\n\n fprintf(fd, str, pred, pred_id, succ, succ_id);\n}\n\n/* escape character for the tag in dot file */\nchar *get_insn_op(insn_t *insn)\n{\n switch (insn->opcode) {\n case OP_add:\n return \"+\";\n case OP_sub:\n return \"-\";\n case OP_mul:\n return \"*\";\n case OP_div:\n return \"/\";\n case OP_mod:\n return \"%%\";\n case OP_lshift:\n return \"<<\";\n case OP_rshift:\n return \">>\";\n case OP_eq:\n return \"==\";\n case OP_neq:\n return \"!=\";\n case OP_gt:\n return \">\";\n case OP_lt:\n return \"<\";\n case OP_geq:\n return \">=\";\n case OP_leq:\n return \"<=\";\n case OP_bit_and:\n return \"&\";\n case OP_bit_or:\n return \"|\";\n case OP_bit_xor:\n return \"^\";\n case OP_log_and:\n return \"&&\";\n case OP_log_or:\n return \"||\";\n default:\n fatal(\"Unknown opcode in operator string conversion\");\n return \"\"; /* unreachable, but silences compiler warning */\n }\n}\n\nvoid bb_dump(FILE *fd, func_t *func, basic_block_t *bb)\n{\n bb->visited++;\n\n bool next_ = false, then_ = false, else_ = false;\n if (bb->next)\n next_ = true;\n if (bb->then_)\n then_ = true;\n if (bb->else_)\n else_ = true;\n if (then_ && !else_)\n printf(\"Warning: missing false branch\\n\");\n if (!then_ && else_)\n printf(\"Warning: missing true branch\\n\");\n if (next_ && (then_ || else_))\n printf(\"Warning: normal BB with condition\\n\");\n\n fprintf(fd, \"subgraph cluster_%p {\\n\", bb);\n fprintf(fd, \"label=\\\"BasicBlock %p (%s)\\\"\\n\", bb, bb->bb_label_name);\n\n insn_t *insn = bb->insn_list.head;\n if (!insn)\n fprintf(fd, \"pseudo_%p [label=\\\"pseudo\\\"]\\n\", bb);\n if (!insn && (then_ || else_))\n printf(\"Warning: pseudo node should only have NEXT\\n\");\n\n for (; insn; insn = insn->next) {\n if (insn->opcode == OP_phi) {\n fprintf(fd, \"insn_%p [label=\", insn);\n fprintf(fd, \"<%s%d := PHI(%s%d\",\n insn->rd->var_name, insn->rd->subscript,\n insn->phi_ops->var->var_name,\n insn->phi_ops->var->subscript);\n\n for (phi_operand_t *op = insn->phi_ops->next; op; op = op->next) {\n fprintf(fd, \", %s%d\", op->var->var_name,\n op->var->subscript);\n }\n fprintf(fd, \")>]\\n\");\n } else {\n char str[256];\n switch (insn->opcode) {\n case OP_allocat:\n sprintf(str, \"<%s%d := ALLOC>\", insn->rd->var_name,\n insn->rd->subscript);\n break;\n case OP_load_constant:\n sprintf(str, \"<%s%d := CONST %d>\",\n insn->rd->var_name, insn->rd->subscript,\n insn->rd->init_val);\n break;\n case OP_load_data_address:\n sprintf(str, \"<%s%d := [.data] + %d>\",\n insn->rd->var_name, insn->rd->subscript,\n insn->rd->init_val);\n break;\n case OP_load_rodata_address:\n sprintf(str, \"<%s%d := [.rodata] + %d>\",\n insn->rd->var_name, insn->rd->subscript,\n insn->rd->init_val);\n break;\n case OP_address_of:\n sprintf(str, \"<%s%d := &%s%d>\",\n insn->rd->var_name, insn->rd->subscript,\n insn->rs1->var_name, insn->rs1->subscript);\n break;\n case OP_assign:\n sprintf(str, \"<%s%d := %s%d>\",\n insn->rd->var_name, insn->rd->subscript,\n insn->rs1->var_name, insn->rs1->subscript);\n break;\n case OP_read:\n sprintf(str, \"<%s%d := (%s%d)>\",\n insn->rd->var_name, insn->rd->subscript,\n insn->rs1->var_name, insn->rs1->subscript);\n break;\n case OP_write:\n if (insn->rs2->is_func)\n sprintf(str, \"<(%s%d) := %s>\",\n insn->rs1->var_name, insn->rs1->subscript,\n insn->rs2->var_name);\n else\n sprintf(str, \"<(%s%d) := %s%d>\",\n insn->rs1->var_name, insn->rs1->subscript,\n insn->rs2->var_name, insn->rs2->subscript);\n break;\n case OP_branch:\n sprintf(str, \"%d>\", insn->rs1->var_name,\n insn->rs1->subscript);\n break;\n case OP_jump:\n sprintf(str, \"\");\n break;\n case OP_label:\n sprintf(str, \"