binutils

const struct riscv_opcode riscv_builtin_opcodes[] = {
    {"unimp", "I", "", 0, 0xffff, match_opcode, 0},
    {"nop", "I", "", MATCH_ADDI, MASK_ADDI | MASK_RD | MASK_RS1 | MASK_IMM,
     match_opcode, INSN_ALIAS},
    {"li", "I", "d,j", MATCH_ADDI, MASK_ADDI | MASK_RS1, match_opcode,
     INSN_ALIAS | WR_xd}, /* addi */
    {"li", "I", "d,I", 0, (int)M_LI, match_never, INSN_MACRO},
    {"mv", "I", "d,s", MATCH_ADDI, MASK_ADDI | MASK_IMM, match_opcode,
     INSN_ALIAS | WR_xd | RD_xs1},
    {"move", "I", "d,s", MATCH_ADDI, MASK_ADDI | MASK_IMM, match_opcode,
     INSN_ALIAS | WR_xd | RD_xs1},
    {"b", "I", "p", MATCH_BEQ, MASK_BEQ | MASK_RS1 | MASK_RS2, match_opcode,
     0}, /* beq 0,0 */
    {"andi", "I", "d,s,j", MATCH_ANDI, MASK_ANDI, match_opcode, WR_xd | RD_xs1},
    {"and", "I", "d,s,t", MATCH_AND, MASK_AND, match_opcode,
     WR_xd | RD_xs1 | RD_xs2},
    {"and", "I", "d,s,j", MATCH_ANDI, MASK_ANDI, match_opcode,
     INSN_ALIAS | WR_xd | RD_xs1},
    /* ... */
    {"addi", "I", "d,s,j", MATCH_ADDI, MASK_ADDI, match_opcode, WR_xd | RD_xs1},
    {"add", "I", "d,s,t", MATCH_ADD, MASK_ADD, match_opcode,
     WR_xd | RD_xs1 | RD_xs2},
    {"add", "I", "d,s,t,0", MATCH_ADD, MASK_ADD, match_opcode,
     WR_xd | RD_xs1 | RD_xs2},
    {"add", "I", "d,s,j", MATCH_ADDI, MASK_ADDI, match_opcode,
     INSN_ALIAS | WR_xd | RD_xs1},
    // ...
};

void md_assemble(char *str) {
    struct mips_cl_insn insn;

    imm_expr.X_op = O_absent;
    offset_expr.X_op = O_absent;
    imm_reloc = BFD_RELOC_UNUSED;
    offset_reloc = BFD_RELOC_UNUSED;

    mips_ip(str, &insn);

    if (insn.insn_mo->pinfo == INSN_MACRO)
        macro(&insn);
    else {
        if (imm_expr.X_op != O_absent)
            append_insn(&insn, &imm_expr, imm_reloc);
        else if (offset_expr.X_op != O_absent)
            append_insn(&insn, &offset_expr, offset_reloc);
        else
            append_insn(&insn, NULL, BFD_RELOC_UNUSED);
    }
}

static void mips_ip(char *str, struct mips_cl_insn *ip) {
    char *s;
    const char *args;
    char c = 0;
    struct riscv_opcode *insn;
    char *argsStart;
    unsigned int regno;
    char save_c = 0;
    int argnum;
    unsigned int rtype;
    const struct percent_op_match *p;

    /* op_hash 是一个以 name 为 key 的 hash table, 用于快速的根据汇编指令的名字
     * (如 addi) 找到对应的模板. 这里用的是和 objdump 相同的一套模板. 但由于存在
     * 名字相同而参数不同的模板, 所以这里 op_hash 保存的是名字对应的第一个模板,
     * 后续在查找时会依次处理名字匹配的所有模板*/
    insn = (struct riscv_opcode *)hash_find(op_hash, str);

    argsStart = s;
    for (;;) {
        bfd_boolean ok = TRUE;

        /* create_insn 会把 insn 的 opcode (op->match) 先填充到 ip 中, 然后后续
         * 的代码要填充 args */
        create_insn(ip, insn);
        argnum = 1;
        for (args = insn->args;; ++args) {
            s += strspn(s, " \t");
            /* args 是模板参数, s 是实际参数 */
            switch (*args) {
                case '\0': /* end of args */
                    if (*s == '\0') return;
                    break;

                case ',':
                    ++argnum;
                    if (*s++ == *args) continue;
                    s--;
                    break;

                case '(':
                case ')':
                case '[':
                case ']':
                    if (*s++ == *args) continue;
                    break;

                case 'd': /* destination register */
                case 's': /* source register */
                case 't': /* target register */
                    /* s 是汇编中的对应于模板参数位置的寄存器的名字, 例如 s0, x0
                     * 等, reg_lookup 是找到 s0 对应的 regno: 2 */
                    ok = reg_lookup(&s, RTYPE_NUM | RTYPE_GP, &regno);
                    if (ok) {
                        c = *args;
                        if (*s == ' ') ++s;

                        /* Now that we have assembled one operand, we use the
                         * args string to figure out where it goes in the
                         * instruction.  */
                        switch (c) {
                            case 's':
                                /* INSERT_OPERAND 先根据 OP_MASK_RS1 和
                                 * OP_SH_RS1 把regno 写到 ip 的特定位置 */
                                INSERT_OPERAND(RS1, *ip, regno);
                                break;
                            case 'd':
                                INSERT_OPERAND(RD, *ip, regno);
                                break;
                            case 't':
                                INSERT_OPERAND(RS2, *ip, regno);
                                break;
                        }
                        continue;
                    }
                    break;

                case 'j': /* sign-extended immediate */
                    offset_reloc = BFD_RELOC_RISCV_LO12_I;
                    p = percent_op_itype;
                    goto alu_op;

                alu_op:
                    if (!my_getSmallExpression(
                            &offset_expr, &offset_reloc, s, p)) {
                        normalize_constant_expr(&offset_expr);
                        if (offset_expr.X_op != O_constant ||
                            (*args == '0' && offset_expr.X_add_number != 0) ||
                            offset_expr.X_add_number >=
                                (signed)RISCV_IMM_REACH / 2 ||
                            offset_expr.X_add_number <
                                -(signed)RISCV_IMM_REACH / 2)
                            break;
                    }
                    /* offset_expr.X_add_number 会是汇编中的立即数, offset_expr
                     * 是一个全局变量, 后续 md_assemble 中的 append_insn 会把它
                     * 编码到指令中*/
                    s = expr_end;
                    continue;
                /* ... */
                default:
                    as_bad(_("bad char = '%c'\n"), *args);
                    internalError();
            }
            break;
        }
        /* 当前模板的参数与指令不匹配, 则继续处理下一条同名的模板, 所以在
         * riscv_opcodes 中相同名字的模板需要放在一起 */
        if (insn + 1 < &riscv_opcodes[NUMOPCODES] &&
            !strcmp(insn->name, insn[1].name)) {
            ++insn;
            s = argsStart;
            insn_error = _("illegal operands");
            continue;
        }
        if (save_c) *(--argsStart) = save_c;
        insn_error = _("illegal operands");
        return;
    }
}

static void macro(struct mips_cl_insn *ip) {
    unsigned int rd, rs1, rs2;
    int mask;

    /* rd, rs1, rs2, imm_expr, offset_expr 不再需要从汇编中解析, 因为前面已经解
     * 析完了 */

    rd = (ip->insn_opcode >> OP_SH_RD) & OP_MASK_RD;
    rs1 = (ip->insn_opcode >> OP_SH_RS1) & OP_MASK_RS1;
    rs2 = (ip->insn_opcode >> OP_SH_RS2) & OP_MASK_RS2;
    mask = ip->insn_mo->mask;

    /* 以 li 为例:
     * {"li",        "I",   "d,I",  0,    (int) M_LI,  match_never, INSN_MACRO
     * },
     * */
    switch (mask) {
        case M_LI:
            /* load_const 会变成两条指令: lui & addi */
            load_const(rd, &imm_expr);
            break;

        case M_LA:
        case M_LLA:
            /* Load the address of a symbol into a register. */
            if (!IS_SEXT_32BIT_NUM(offset_expr.X_add_number))
                as_bad(_("offset too large"));

            if (offset_expr.X_op == O_constant)
                load_const(rd, &offset_expr);
            else if (is_pic && mask == M_LA) /* Global PIC symbol */
                pcrel_load(
                    rd, rd, &offset_expr, LOAD_ADDRESS_INSN,
                    BFD_RELOC_RISCV_GOT_HI20, BFD_RELOC_RISCV_GOT_LO12);
            else /* Local PIC symbol, or any non-PIC symbol */
                pcrel_load(
                    rd, rd, &offset_expr, "addi", BFD_RELOC_RISCV_PCREL_HI20,
                    BFD_RELOC_RISCV_PCREL_LO12_I);
            break;

        /* ... */
        case M_JUMP:
            rd = 0;
            goto do_call;
        case M_CALL:
            rd = LINK_REG;
        do_call:
            rs1 = reg_lookup_assert("t0", RTYPE_GP);
            riscv_call(rd, rs1, &offset_expr, offset_reloc);
            break;

        default:
            as_bad(_("Macro %s not implemented"), ip->insn_mo->name);
            break;
    }
}

static void load_const(int reg, expressionS *ep) {
    if (rv64 && !IS_SEXT_32BIT_NUM(ep->X_add_number)) {
        /* 64 bit */
        /* ... */
    } else {
        /* 32 bit */
        int hi_reg = ZERO;
        /* NOTE: 这里的处理需要参考 RISCV_CONST_HIGH_PART */
        int32_t hi = ep->X_add_number & (RISCV_IMM_REACH - 1);
        hi = hi << (32 - RISCV_IMM_BITS) >> (32 - RISCV_IMM_BITS);
        hi = (int32_t)ep->X_add_number - hi;
        /* 这里会对应两条指令:
         * lui rd, %hi(imm)
         * addi rd, zero, %lo(imm)
         * */
        if (hi) {
            /* macro_build 和 mips_ip 类似 */
            macro_build(ep, "lui", "d,u", reg, BFD_RELOC_RISCV_HI20);
            hi_reg = reg;
        }

        if ((ep->X_add_number & (RISCV_IMM_REACH - 1)) || hi_reg == ZERO)
            macro_build(
                ep, ADD32_INSN, "d,s,j", reg, hi_reg, BFD_RELOC_RISCV_LO12_I);
    }
}

static void riscv_call(
    int destreg, int tempreg, expressionS *ep, bfd_reloc_code_real_type reloc) {
    macro_build(ep, "auipc", "d,u", tempreg, reloc);
    macro_build(NULL, "jalr", "d,s", destreg, tempreg);
}

    # riscv64-unknown-elf-as -march=rv64gcv  test.s -o test.o
.extern hello
    .global _start

_start:
    blt a0,a1,hello
    blt a0,a1,1f

    .rept   1024
    .word 1
    .endr
1:

.extern hello
_start:
    # 第一个 frag
    addi a0,a0,0
    addi a0,a0,10
    blt a0,a1,hello

    # 第二个 frag
    addi a0,a0,0
    .fill 20, 8, 1

    # 第三个 frag
    addi a0,a0,0
    .fill 10, 4, 1

write_contents(
    bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *xxx ATTRIBUTE_UNUSED):
  for (f = seginfo->frchainP->frch_root;
       f;
       f = f->fr_next):
      /* NOTE: frag 中 fix 的部分 */
      if (f->fr_fix):
          bfd_set_section_contents (stdoutput, sec,
                    f->fr_literal, (file_ptr) offset,
                    (bfd_size_type) f->fr_fix);
          offset += f->fr_fix;

      fill_size = f->fr_var;
      count = f->fr_offset;
      fill_literal = f->fr_literal + f->fr_fix;

      /* 这里使用了 buf 来加速 fr_literal 到 bfd 的 memcpy */
      char buf[256];
      char *bufp;
      n_per_buf = sizeof (buf) / fill_size;
      for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size):
          memcpy (bufp, fill_literal, fill_size);
      for (; count > 0; count -= n_per_buf):
          n_per_buf = n_per_buf > count ? count : n_per_buf;
          bfd_set_section_contents
            (stdoutput, sec, buf, (file_ptr) offset,
             (bfd_size_type) n_per_buf * fill_size);
          offset += n_per_buf * fill_size;