[指令生成]语法制导的指令生成[4]

解析Jerry语言运算指令生成
最新推荐文章于 2025-02-06 14:06:45 发布
最新推荐文章于 2025-02-06 14:06:45 发布 · 217 阅读 · 0

本文深入解析Jerry语言中运算指令的生成过程，包括单目运算、双目运算及条件短路的实现细节。通过具体代码示例展示了不同类型运算符如何对应到具体的指令集，并特别关注了逻辑运算符的独特处理方式。

运算. 首先是单目运算指令, 相对而言比较简单, 只有3种情况

struct List* insUnaryOperationNode(void* node)
{
    struct UnaryOperationNode* self = (struct UnaryOperationNode*)node;
    AcceptType type = self->typeOf(self);
    // 如果是常数
    if (INTEGER == type) {
        int intVal;
        if (0 == self->staticInt(self, &intVal)) {
            struct List* ret = (struct List*)newArrayList();
            struct IntParamInstruction* ins = (struct IntParamInstruction*)
                        allocate(sizeof(struct IntParamInstruction));
            ins->code = CONST_INT;
            ins->param = intVal;
            ret->add(ret, ins);
            return ret;
        }
    } else {
        double realVal;
        if (0 == self->staticReal(self, &realVal)) {
            struct List* ret = (struct List*)newArrayList();
            struct RealParamInstruction* ins = (struct RealParamInstruction*)
                        allocate(sizeof(struct RealParamInstruction));
            ins->code = CONST_REAL;
            ins->param = realVal;
            ret->add(ret, ins);
            return ret;
        }
    }

    // 先取得子表达式的指令
    struct List* operandIns = self->operand->createInstruction(self->operand);
    // 运算指令
    struct NoParamInstruction* op = (struct NoParamInstruction*)
                                    allocate(sizeof(struct NoParamInstruction));
    if (MINUS == self->op) { // 求相反数, 思路是变成 0 - 该数
        struct List* ins = (struct List*)newArrayList();
        if (INTEGER == type) {
            op->code = INT_MINUS;
            struct IntParamInstruction* load0 = (struct IntParamInstruction*)
                                   allocate(sizeof(struct IntParamInstruction));
            load0->code = CONST_INT;
            load0->param = 0;
            appendIns(appendInsList(appendIns(ins, load0), operandIns), op);
        } else {
            op->code = REAL_MINUS;
            struct RealParamInstruction* load0 = (struct RealParamInstruction*)
                                  allocate(sizeof(struct RealParamInstruction));
            load0->code = CONST_REAL;
            load0->param = 0.0;
            appendIns(appendInsList(appendIns(ins, load0), operandIns), op);
        }
        return ins;
    } else if (NOT == self->op) { // 逻辑求反, 思路是变成 0 == 该数
        if (REAL == self->operand->typeOf(self->operand)) { // Oops~
            // 报错
            revert(op);
            return operandIns;
        }
        struct IntParamInstruction* load0 = (struct IntParamInstruction*)
                                   allocate(sizeof(struct IntParamInstruction));
        load0->code = CONST_INT;
        load0->param = 0;
        op->code = INT_EQ;
        return appendIns(appendIns(operandIns, load0), op);
    } else { // 加号可以无视了
        revert(op);
        return operandIns;
    }
}

双目运算, 之前提到过, 会将其拆分成3个分支(嗯, 也是3个)来进行, 它们是

static struct List* insNormalBinaryOp(struct BinaryOperationNode*);
static struct List* insAssignment(struct BinaryOperationNode*);
static struct List* insLogicShortcut(struct BinaryOperationNode*);

那么在指令产生成员函数中只需进行调度即可

struct List* insBinaryOperationNode(void* node)
{
    struct BinaryOperationNode* self = (struct BinaryOperationNode*)node;
    AcceptType type = self->typeOf(self);
    // 如果是常数
    if (INTEGER == type) {
        int intVal;
        if (0 == self->staticInt(self, &intVal)) {
            struct List* ret = (struct List*)newArrayList();
            struct IntParamInstruction* ins = (struct IntParamInstruction*)
                        allocate(sizeof(struct IntParamInstruction));
            ins->code = CONST_INT;
            ins->param = intVal;
            ret->add(ret, ins);
            return ret;
        }
    } else {
        double realVal;
        if (0 == self->staticReal(self, &realVal)) {
            struct List* ret = (struct List*)newArrayList();
            struct RealParamInstruction* ins = (struct RealParamInstruction*)
                        allocate(sizeof(struct RealParamInstruction));
            ins->code = CONST_REAL;
            ins->param = realVal;
            ret->add(ret, ins);
            return ret;
        }
    }

    if (ASSIGN == self->op) { // 是等号
        return insAssignment(self);
    } else if (isArithOperator(self->op) || isCompareOperator(self->op)) {
        // isArithOperator 和 isCompareOperator 是两个宏
        // 进行普通二目运算
        return insNormalBinaryOp(self);
    } else {
        // 逻辑运算 && 和 || 没有对应的指令, 需要进行条件短路来实现.
        return insLogicShortcut(self);
    }
}

赋值运算函数 insAssignment 参考实现. 需要注意左右值类型是否匹配.

static struct List* insAssignment(struct BinaryOperationNode* self)
{
    struct List* leftIns,* rightIns;
    // Oops~
    if (NULL == (leftIns = self->leftOperand->addressOf(self->leftOperand))) {
        // 报错: 左值不合法
        return (struct List*)newArrayList();
    }

    AcceptType leftType = self->leftOperand->typeOf(self->leftOperand),
              rightType = self->rightOperand->typeOf(self->rightOperand);
    rightIns = self->rightOperand->createInstruction(self->rightOperand);
    appendInsList(leftIns, rightIns);
    if (leftType == rightType) { // 左右值类型相同, 只需简单增加一条赋值指令
        struct NoParamInstruction* ins = (struct NoParamInstruction*)
                    allocate(sizeof(struct NoParamInstruction));
        if (INTEGER == leftType) {
                ins->code = INT_ASSIGN;
            } else {
                ins->code = REAL_ASSIGN;
            }
        appendIns(leftIns, ins);
    } else { // 类型不同
        // 类型转换指令
        struct NoParamInstruction* cast = (struct NoParamInstruction*)
                                    allocate(sizeof(struct NoParamInstruction));
        // 运算指令
        struct NoParamInstruction* ins = (struct NoParamInstruction*)
                                    allocate(sizeof(struct NoParamInstruction));
        if (INTEGER == leftType) {
            cast->code = REAL_2_INT;
            ins->code = INT_ASSIGN;
        } else {
            cast->code = INT_2_REAL;
            ins->code = REAL_ASSIGN;
        }
        appendIns(leftIns, cast);
        appendIns(leftIns, ins);
    }
    return leftIns;
}

普通运算也一样, 需要注意类型. 不同的是, 在赋值运算中, 如果左右值类型不匹配, 右值类型会被转换为左值; 但是在普通运算中, 类型会向精确度高的一边提升(INTEGER -> REAL). 因此在类型失配时处理方式与赋值运算会显著不一样.

static struct List* insNormalBinaryOp(struct BinaryOperationNode* self)
{
    AcceptType leftType = self->leftOperand->typeOf(self->leftOperand),
              rightType = self->rightOperand->typeOf(self->rightOperand);
    struct List* leftIns,* rightIns;
    leftIns = self->leftOperand->createInstruction(self->leftOperand);
    rightIns = self->rightOperand->createInstruction(self->rightOperand);
    if (leftType == rightType) {
        struct NoParamInstruction* ins = (struct NoParamInstruction*)
                                    allocate(sizeof(struct NoParamInstruction));
        if (INTEGER == leftType) {
            ins->code = getCodeByIntOp(self->op);
        } else {
            ins->code = getCodeByRealOp(self->op);
        }
        appendIns(appendInsList(leftIns, rightIns), ins);
    } else {
        struct NoParamInstruction* cast = (struct NoParamInstruction*)
                                    allocate(sizeof(struct NoParamInstruction));
        struct NoParamInstruction* ins = (struct NoParamInstruction*)
                                    allocate(sizeof(struct NoParamInstruction));
        ins->code = getCodeByRealOp(self->op);
        cast->code = INT_2_REAL;
        if (INTEGER == leftType) { // 转换整型那一边.
            appendInsList(appendIns(leftIns, cast), rightIns);
        } else {
            appendIns(appendInsList(leftIns, rightIns), cast);
        }
        appendIns(leftIns, ins);
    }
    return leftIns;
}

最后是条件短路. 思路参考可以这篇文章. 在一些设计中, 逻辑值与分支和循环语句的出口密切相关. 不过在Jerry语言中求逻辑值时我们缺乏上下文(我们也别把这种事情弄得太复杂), 所以Jerry实现时仅仅是在语法节点对应的指令执行结束时在栈顶放上一个真值或者假值(1 或者 0)

static struct List* insLogicShortcut(struct BinaryOperationNode* self)
{
    AcceptType leftType = self->leftOperand->typeOf(self->leftOperand),
              rightType = self->rightOperand->typeOf(self->rightOperand);
    if (REAL == leftType || REAL == rightType) { // Oops~
        // 报错
        return (struct List*)newArrayList();
    }

    struct List* leftIns,* rightIns;
    leftIns = self->leftOperand->createInstruction(self->leftOperand);
    rightIns = self->rightOperand->createInstruction(self->rightOperand);
    struct JumpInstruction* shortcut = (struct JumpInstruction*)
                                    allocate(sizeof(struct JumpInstruction));
    struct JumpInstruction* jumpout = (struct JumpInstruction*)
                                    allocate(sizeof(struct JumpInstruction));
    struct IntParamInstruction* putResult = (struct IntParamInstruction*)
                                   allocate(sizeof(struct IntParamInstruction));
    struct NoParamInstruction* outlet = (struct NoParamInstruction*)
                                    allocate(sizeof(struct NoParamInstruction));
/*  +-----------------------------+
    | 左子树指令
    +-----------------------------+
    | 条件跳转 (shortcut 指令) -> putResult 指令
    +-----------------------------+
    | 右子树指令
    +-----------------------------+
    | 跳出 (jumpout 指令) -> outlet 指令
    +-----------------------------+
    | 栈顶置结果 (putResult 指令)
    +-----------------------------+
    | 出口 (outlet 伪指令)
    +-----------------------------+
    指令结构如上图 */
    putResult->code = CONST_INT;
    jumpout->code = JMP;
    jumpout->targetIns = (struct AbstractInstruction*)outlet;
    outlet->code = NOP;
    shortcut->targetIns = (struct AbstractInstruction*)putResult;
    if (AND == self->op) { // 运算符不同, 产生的指令差异仅此两处
        shortcut->code = JMP_NOT_TOP;
        putResult->param = 0;
    } else {
        shortcut->code = JMP_IF_TOP;
        putResult->param = 1;
    }
    return appendIns(appendIns(appendIns(appendInsList(appendIns(
        leftIns,
        shortcut),
        rightIns),
        jumpout),
        putResult),
        outlet); // 确实, 这里看起来很令人心神不宁...
}

有趣的是, && 和 || 的结构是如此相似, 以至于两者产生的指令只有两处不同: 当运算符为 && 时, 短路条件为栈顶为假, 而表达式结果是 0, 而运算符为 || 时情况正好相反.

iteye_10703
关注
大语言模型原理基础与前沿 指令生成
AI架构师小马
10-04 888
大语言模型原理基础与前沿 指令生成 1. 背景介绍 1.1 问题的由来 近年来，随着人工智能技术的飞速发展，大语言模型（LLM）在自然语言处理领域取得了突破性的进展。LLM 能够理解和生成人类语言，并完成各种任务，例如文本摘要、机器翻译、问答
GCC源码分析（五）——指令生成
SonicLing的专栏
12-02 1万+
一、前言 　　又有好久没写了，的确很忙。前篇介绍了GCC的pass格局，它是GCC中间语言部分的核心架构，也是贯穿整个编译流程的核心。在完成优化处理之后，GCC必须做的最后一步就是生成最后的编译结果，通常情况下就是汇编文件（文本或者二进制并不重要）。 　　前面也讲到了，GCC中间语言的核心数据结构是GENERIC、GIMPLE和RTL。其中的RTL就是和指令紧密相关的一种结构，它是指令生成的起
[指令生成]语法制导的指令生成[1]
珠机
07-31 251
    每个节点生成的指令都是一个长长的指令列表，那么得弄几个小工具将这些列表给连接起来。 // 将一个指令追加到表末尾 static struct List* appendIns(struct List* list, void* ins) { list->addTo(list, ins, list->count(list)); return list; }...
[指令生成]语法制导的指令生成[接口]
珠机
07-24 233
    继续向语法树节点结构中追加成员。   #define memberAbstractSyntaxNode \ unsigned int line; \ struct AbstractSyntaxNode* nextNode; \ struct List* (*createIns...
[指令生成]语法制导的指令生成[5]
珠机
09-26 194
    最后还剩下一个, 声明语句的翻译. 因为符号表API已经很完善了, 所以声明语句的翻译不会太困难. 将一些小地方处理好了就行. 难对付的部分是设定初始值, 需要考虑到类型转换. OK, 代码说明一切. struct List* insDeclarationNode(void* node) { struct DeclarationNode* self = (struct Dec...
简单的C语言解释运行器实现（六）—— 生成指令
とある黄鱼のOIブログ
04-01 2130
上一篇：语义分析 执行指令 在我们有了带类型的语法树后，我们就可以生成指令了。如果你有读过Java虚拟机规范的话，可以看到庞大的JVM指令集，好像是近200条？接下来我们要考虑代码的执行过程并生成指令。 首先我们考虑代码的执行过程，我们知道程序运行是基于栈的，那么具体是怎么运行的呢？开篇我们提到了这样的一个语法树： S /|\ F = E | /|\ i F + ...
实验五_用语法制导方式生成中间代码生成器参照.pdf
11-21
实验五_用语法制导方式生成中间代码生成器参照 本实验的目的是掌握语法制导定义和翻译的原理和技术，在语法分析器的基础上...gen_goto函数可以将中间代码序列中的跳转指令生成到正确的地址上，从而实现源程序的执行。
yyfx.rar_4 3 2 1_C语法制导翻译_三地址_实验3递归下降_语法制导翻译
07-15
采用递归下降语法制导翻译法,对算术表达式、赋值语句进行语义分析并生成四元式序列。 实验的输入和输出 输入是语法分析提供的正确的单词串，输出为三地址指令形式的四元式序列。 例如：对于语句串 begin a:=2+3*4 x...
实验五 语法制导翻译和中间代码生成
水瓶KaKei的博客
07-12 1555
任务：实现语法制导翻译及赋值语句的中间代码生成 在前序实验中已实现了TINY+语言的词法分析及语法分析，本次实验要求基 于前序实验基础，实现TINY+语言的语法制导翻译及赋值语句的中间代码生成。 具体要求： 对于输入赋值语句a := b * c + d，应翻译成以下三地址码序列： t1 := b * c t2 := t1 + d a := t2 请修改TINY+的语法分析程序，添加语义翻译代码，实现对任意TINY+赋值语句的语义翻译及中间代码的生成。
编译原理-词法分析-语法分析-语义分析-中间代码生成-目标代码优化-符号表管理-错误处理-LL1文法-递归下降分析-语法制导翻译-四元式生成-寄存器分配-指令选择-控制流分析-数据.zip
最新发布
11-07
语法制导翻译是语义分析的一部分，它通过在语法分析树的节点上附加语义动作，将源代码转换为中间表示。 中间代码生成阶段是将经过语义分析的程序转换为一种独立于机器的中间代码表示。这种中间表示的目的是简化目标...
C语言子集编译器，基于PLY实现词法，语法分析器，进而实现语义分析，语法制导翻译与中间代码生成及汇编代码生成.zip
10-05
语法制导翻译是基于语法制导的方法，将抽象语法树转换成中间代码的过程。在这个阶段，编译器将AST中的每个构造映射到一个或多个中间代码指令。这些中间代码通常是一种低级的、与机器无关的代码表示形式，它们更接近...
我的世界4个实用指令生成网站：自定义物品/名称，自定义药水，自定义实体，数据包编写
热门推荐
凌凌1301的博客
08-30 5万+
这个网站功能很全，包括自定义合成表、自定义烟花火箭、超平坦世界生成器、自定义实体、附魔台计算、旗帜生成、自定义世界、盔甲颜色、皮肤获取、颜色代码、自定义标题、自定义木牌、书生成器、自定义信息、自定义MOTD代码、战利品表生成、自定义药水等。这个网站可以自定义指令生成，包含全面的自定义物品、自定义实体、技能生成器、OOC生成器、粒子画生成器、告示牌生成器等。这个网站可以制作自定义物品，还可以切换版本，自定义物品名称，设置黑体、粗体等。...
【Android安全】IDA 处理伪代码JUMPOUT指令（Undefine + Create Function）
Juruo@Security
04-15 1万+
【Android安全】IDA处理JUMPOUT（Undefine + Create Function）
ida编译arm汇编出现JUMPOUT的解决方案
bncmjnmlp的博客
04-18 6048
首先可以通过在反汇编得到的的c代码里确定JUMPOUT在汇编代码的位置 之后在汇编代码中跳转到该地址，应该可以看到一个跳转指令（B，BL，BX等）。 由于IDA无法识别跳转指令的跳转地址，所以会出现JUMPOUT的情况。 想要去除JUMPOUT，就要由我们自己将这个跳转指令算出来。手动将算出来的地址写入汇编指令，代替原来的跳转地址。 修改方法：工具栏 -> Edit -> Patch Program -> Change byte... 另外，也会出现跳转指令无法计算的情况
你真的会用DeepSeek？我整理了最实用的30个神级指令（记不住可以先关注收藏）
2401_85375151的博客
02-06 5170
其实，使用 DeepSeek 就像和一个聪明的朋友对话它很智能，但需要你的引导；它很强大，但需要你的指点掌握这些技巧，你就能让 DeepSeek 变成你的得力助手，帮你：写出更生动的文章解决更复杂的问题获得更专业的建议激发更多创意灵感记住一点：AI 不是万能的，但会用的人才是好啦，以上的分享就到这里啦！如果你觉得有收获，请关注在看！
【代码生成器】简易命令行代码生成（一）
努力的搬砖人
07-22 435
静态文件生成
拒绝一针串到底式参数类
JavaQ
01-17 203
当参数个数多于三个的时候，通常会将这些参数封装到一个类中，进而形成参数类。参数类通常是类间或方法间进行通信的纽带，起到承上启下的作用。基本上一个稍微有些规模的项目都会由多...
GCC后端指令生成分析(1)
softee的专栏
10-28 3691
主要研究GCC指令生成阶段的各个步骤,重点在编译器代码与机器描述之间的接口函数和数据结构。以一小段代码片段为示例,逐步追溯直至汇编代码生成的整个过程。引言机器描述文件是形如*.md的文件,其核心部分是两类定义:“define_insn”和“define_expand”。 图1 md文件中define_insn模版示意图define_insn主要分为以下几个部分。 名字，对应图1中的“addqi3_
掌握递归下降语法制导翻译实现三地址代码生成
资源摘要信息:"本资源名为'yyfx.rar_4 3 2 1_C语法制导翻译_三地址_实验3递归下降_语法制导翻译'，主要围绕着C语言的语法制导翻译和三地址码生成的主题展开。在该实验中，学生将通过实际操作深化对语法制导翻译原理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值