java开发C语言编译器:消除冗余语句和把ifelse控制语句编译成字节码

当前编译器已经能够把很多C语言的源程序编译成可以在java虚拟机上运行的字节码，但一直存在一个问题是，编译出的字节码存有冗余语句，例如赋值语句: a = 1; 它编译成java字节码后情况如下：

aload 0sipush 1astore 0

假设变量a在虚拟机局部变量队列中的存储位置为0，那么上面代码冗余之处在于多出了一条语句aload 0, 要给变量a赋值，只需下面两条语句便足够了。之所以产生冗余语句，是因为编译器的实现有问题，在编译器解析代码时，一旦遇到变量名，它就会把该变量加载到虚拟机的执行堆栈上，或者是解析到数字字符常量时，它也会把字符代表的数值压到堆栈上。解析数字字符常量和代码变量的语法表达式是：
NUMBER -> UNARY
NAME -> UNARY

所以产生冗余语句的编译器实现代码如下：

public class UnaryNodeExecutor extends BaseExecutor implements IExecutorReceiver{    private Symbol structObjSymbol = null;    private Symbol monitorSymbol = null;    @Override    public Object Execute(ICodeNode root) {    ....    case CGrammarInitializer.Number_TO_Unary:            text = (String)root.getAttribute(ICodeKey.TEXT);            boolean isFloat = text.indexOf('.') != -1;            if (isFloat) {                value = Float.valueOf(text);                root.setAttribute(ICodeKey.VALUE, Float.valueOf(text));             } else {                value = Integer.valueOf(text);                root.setAttribute(ICodeKey.VALUE, Integer.valueOf(text));            }            ProgramGenerator.getInstance().emit(Instruction.SIPUSH, "" + value);            break;        case CGrammarInitializer.Name_TO_Unary:            symbol = (Symbol)root.getAttribute(ICodeKey.SYMBOL);            if (symbol != null) {                root.setAttribute(ICodeKey.VALUE, symbol.getValue());                root.setAttribute(ICodeKey.TEXT, symbol.getName());                ICodeNode func = CodeTreeBuilder.getCodeTreeBuilder().getFunctionNodeByName(symbol.getName());                if (func == null && symbol.getValue() != null) {                    ProgramGenerator generator = ProgramGenerator.getInstance();                    int idx = generator.getLocalVariableIndex(symbol);                    generator.emit(Instruction.ILOAD, "" + idx);                    }            }            break;    ....    }}

上面代码是编译器解析变量名和数字字符常量的地方，其中有一部分代码是使用sipush指令把数字常量压入堆栈或是通过iload指令把变量从队列加载到堆栈的，产生冗余语句的也正是这部分代码，要消除冗余，我们需要把带有generator.emit的语句给注释掉。

为了保证代码修改不影响编译器的正确性，我们还需对相关部分进行修改。编译器解析赋值语句，例如 a = 1;是通过NoCommaExprExecutor实现的，所以该执行器的代码需要做相应修改如下：

public class NoCommaExprExecutor extends BaseExecutor{    ExecutorFactory factory = ExecutorFactory.getExecutorFactory();    ProgramGenerator generator = ProgramGenerator.getInstance();    @Override     public Object Execute(ICodeNode root) {    ....    child = root.getChildren().get(0);            String t = (String)child.getAttribute(ICodeKey.TEXT);            IValueSetter setter;            setter = (IValueSetter)child.getAttribute(ICodeKey.SYMBOL);            child = root.getChildren().get(1);            //newly add            value = child.getAttribute(ICodeKey.SYMBOL);            if (value == null) {                value = child.getAttribute(ICodeKey.VALUE);            }            try {                setter.setValue(value);            } catch (Exception e) {                ....            }    ....    }}

如果赋值语句形式为 a = b; 也就是用一个变量给另一个变量赋值，那么通过ICodeKey.Symbol 就可以得到变量b对应的Symbol对象，如果赋值语句形式为 a = 1; 那么ICodeKey.VALUE 就会把数值1返回给变量value, setter对应的是变量a的Symol对象，调用其setValue函数完成赋值功能，因此我们需要进入Symbol.java修改相应代码：

public void setValue(Object obj) {    ....    ProgramGenerator generator = ProgramGenerator.getInstance();        if (obj instanceof Symbol) {            Symbol symbol = (Symbol)obj;            this.value = symbol.value;            int i = generator.getLocalVariableIndex(symbol);            generator.emit(Instruction.ILOAD, "" + i);        } else if (obj instanceof Integer){            Integer val = (Integer)obj;            generator.emit(Instruction.SIPUSH, "" + val);            this.value = obj;        }    ....}

执行赋值操作时，如果是用变量给变量赋值，那么编译器生成iload语句，把用来赋值的变量加载到虚拟机的堆栈上，如果用数字字符常量赋值，那么需要使用sipush语句把该数值压到堆栈上。 最后我们还需修改下实现printf函数调用的代码，在clibcall.java里：

private void generateJavaAssemblyForPrintf(String argStr, int argCount) {.....ArrayList<Object> argList = FunctionArgumentList.getFunctionArgumentList().getFuncArgSymsList(true);        int localVariableNum = list.size();        int count = 0;        int argSymCount = 0;        while (count < argCount) {            Symbol argSym = (Symbol)argList.get(argSymCount);            argSymCount++;            int d = generator.getLocalVariableIndex(argSym);            generator.emit(Instruction.ILOAD, "" + d);            generator.emit(Instruction.ISTORE, "" + (localVariableNum + count));            count++;        }   ....}

这部分代码用于把printf语句中的变量加载到虚拟机堆栈上，例如printf(“value of a and b is %d, %d”, a, b);
代码会把变量a,b从虚拟机的局部变量队列加载到堆栈上，以便打印输出。经过上面的修改后，在生成java字节码时，就不再会有冗余语句了。现在我们看看，如何把if else 这些分支控制语句转换为java字节码。

在jvm中，有专门用于比较大小然后跳转到指定分支的指令，例如 Int1>=Int2 对应的指令为if_icmpge， Int1> Int2对应的指令为if_icmpgt, Int1<=Int2对应的指令为if_icmplt，Int1

if ( 1 < 2) {  a = 1;} else {  a = 2;}a = 3;

编译成java字节码后如下：

sipush 1sipush 2if_cmpge  branch0sipush 1astore 0goto out_branch0branch0:sipush 2istore 0out_branch0:sipush 3istore 0

要比较1和2大小，先要把两个数值压到堆栈上，C语言代码使用的是1<2，编译成字节码时，我们要使用指令if_cmpge 也就是>=, 于是当堆栈上两个数的值是大于等于关系时，跳转到branch0所在位置的代码去执行，要不然继续往下执行，然后通过goto 直接跳转到out_branch0的位置去执行代码，上面指令执行的分支跳转逻辑与C语言是一致的。

如果有多个平行并列的if else, 我们则把branch 和 out_branch后面的0加1，变成branch1和out_branch1,需要注意的还有间套的if else, 例如下面的C代码：

if (a > 1 ) {       if (b > 2) {           b = 5;       }   }   else {       b = 4;    }

我们编译间套里面的if else时，把内部的ifelse对应的分支名称在前面加上i,比如一层间套，那么它对应的就是ibranch0,两层就是iibranch0,同理一层间套对应iout_branch0,两层就是iiout_branch0. 由于存在间套原因，ifelse语句编译比较困难，且容易出错。我们看看实现编译的代码实现，首先是修改program_generator.java:

public class ProgramGenerator extends CodeGenerator {....    private int branch_count = 0;    private int branch_out = 0;    private String embedded = "";    public int getIfElseEmbedCount() {        return embedded.length();    }    public void incraseIfElseEmbed() {        embedded += "i";    }    public void decraseIfElseEmbed() {        embedded = embedded.substring(1);    }    public void  emitBranchOut() {        String s = "\n" + embedded+"branch_out" + branch_out + ":\n";        this.emitString(s);        branch_out++;    }    public String getBranchOut() {        String s = embedded + "branch_out" + branch_out;        return s;    }    public String getCurrentBranch() {        String str = embedded + "branch" + branch_count;        return str;    }    public void increaseBranch() {        branch_count++;    }    public String getAheadBranch(int ahead) {        String str =  embedded + "branch" + branch_count + ahead + ":";        this.emitString(str);        return str;    }....}

如果编译时发现有ifelse间套，那么需要调用getIfElseEmbedCount这样使得编译出的跳转分支名称前面能加上一个字母i，完成间套后要调用decraseIfElseEmbed(), 其余接口调用都是用来编译ifelse跳转时的分支名称的。

如果ifelse 在代码中一起出现时，ElseStatementExecutor会被执行，如果代码中只有if出现时，那么只有IfStatementExecutor会被执行，我们看看相关代码：

public class ElseStatementExecutor extends BaseExecutor {    private ProgramGenerator generator = ProgramGenerator.getInstance();    @Override    public Object Execute(ICodeNode root) {         BaseExecutor.inIfElseStatement = true;        //先执行if 部分         ICodeNode res = executeChild(root, 0);         BaseExecutor.inIfElseStatement = false;         String branch = generator.getCurrentBranch();         branch = "\n" + branch + ":\n";         generator.emitString(branch);         if (generator.getIfElseEmbedCount() == 0) {             generator.increaseBranch();              }         Object obj = res.getAttribute(ICodeKey.VALUE);         if ((Integer)obj == 0 || BaseExecutor.isCompileMode) {             generator.incraseIfElseEmbed();             //if 部分没有执行，所以执行else部分             res = executeChild(root, 1);              generator.decraseIfElseEmbed();         }         copyChild(root, res);         generator.emitBranchOut();         return root;    }}

在编译ifelse时，如果if条件不成立就会跳转到else部分，我们用’branchX’来表示else部分代码分支开始之处，由于编译器在执行ifelse语句时，IfStatementExecutor先会被执行，当它执行时需要知道当前代码是ifelse还是仅仅包含if语句，如果inIfElseStatement设置成true,那表明当前代码是ifelse形式，如果是false表明当前代码是if形式，两种形式不同，输出的字节码就不同。在输出else部分的指令时，编译器先把else部分的代码分支名称输出来。else之后的代码就是branch_outX分支所对应的代码，如果if条件成立，那么if接下来的指令会被执行，执行完后直接通过goto跳转到branch_outX部分，避开else部分指令的执行。

在看看IfStatementExecutor的实现：

public class IfStatementExecutor extends BaseExecutor {     @Override      public Object Execute(ICodeNode root) {         ProgramGenerator generator = ProgramGenerator.getInstance();         ICodeNode res = executeChild(root, 0);          Integer val = (Integer)res.getAttribute(ICodeKey.VALUE);         copyChild(root, res);           if ((val != null && val != 0) || BaseExecutor.isCompileMode) {             generator.incraseIfElseEmbed();             boolean b = BaseExecutor.inIfElseStatement;             BaseExecutor.inIfElseStatement = false;             executeChild(root, 1);             BaseExecutor.inIfElseStatement = b;             generator.decraseIfElseEmbed();         }         if (BaseExecutor.inIfElseStatement == true) {             String branchOut = generator.getBranchOut();             generator.emitString(Instruction.GOTO.toString() + " " + branchOut);             } else {             String curBranch = generator.getCurrentBranch();             generator.emitString(curBranch + ":\n");         }        return root;    }}

在编译if部分的指令时，如果没有else部分，那么就不需要输出goto指令，执行完if部分的代码后，继续往下执行就可以，如果有else部分，那么需要输出goto指令，越过else部分的代码。

在编译if部分的代码时，一定要调用incraseIfElseEmbed，因为if内部很可能会出现ifelse的间套，同理在编译else部分的代码时，也要调用这个接口，因为else部分也会出现ifelse间套。

完成上面的代码后，我们尝试编译下面的C语言代码：

void main () {   int a;   int b;   a = 2;   b = 3;   if (a > 1 ) {       if (b > 2) {           b = 5;       }   }   else {       b = 4;    }    printf("value of b is :%d", b);}

上面代码中存有ifelse间套，我们看看编译出来的java字节码时怎样的，运行修改代码后的编译器，然后输入上面C语言代码，得到的编译结果如下：

.class public CSourceToJava.super java/lang/Object.method public static main([Ljava/lang/String;)V    sipush  2    istore  1    sipush  3    istore  0    iload   1    sipush  1if_icmple branch0    iload   0    sipush  2if_icmple ibranch0    sipush  5    istore  0ibranch0:goto branch_out0branch0:    sipush  4    istore  0branch_out0:    iload   0    istore  2    getstatic   java/lang/System/out Ljava/io/PrintStream;    ldc "value of b is :"    invokevirtual   java/io/PrintStream/print(Ljava/lang/String;)V    getstatic   java/lang/System/out Ljava/io/PrintStream;    iload   2    invokevirtual   java/io/PrintStream/print(I)V    getstatic   java/lang/System/out Ljava/io/PrintStream;    ldc ""    invokevirtual   java/io/PrintStream/print(Ljava/lang/String;)V    return.end method.end class

在ifcmple指令前，iload 1表示把变量a加入堆栈，sipush 1把数字常量1压入堆栈，如果变量a的值小于1的话则跳转到branch0处执行，branch0处的指令作用是把数值4赋值给变量b, 如果a的值大于1，则继续往下执行，iload 0表示把变量b加载到堆栈，sipush 2表示把数值2压入堆栈如果变量b的值小于数值2则跳转到ibranch0执行，这个分支名称前面的i就是因为ifelse间套而添加的。branch_out0处指令的意识是通过printf把相关信息打印出来。

把编译出来的java汇编转换成二进制字节码运行后结果如下：

从结果上看，打印出来的b的值是5，由此可见我们编译输出的结果应该是正确的。ifelse编译由于需要考虑到间套，所以逻辑上比较复杂，具体的理解需要通过视频讲解后，并亲手调试代码才好掌握，请参看视频用java开发C语言编译器

当前我们的编译方法面对更复杂的ifelse间套时可能还会有问题，基于尽可能简单原则，我们先这么做，以后遇到问题时才进一步完善。

更多技术信息，包括操作系统，编译器，面试算法，机器学习，人工智能，请关照我的公众号：