Another peephole optimization which removes superfluous expressions such as (A +...
authorDale Weiler <killfieldengine@gmail.com>
Fri, 4 Oct 2013 10:46:54 +0000 (06:46 -0400)
committerDale Weiler <killfieldengine@gmail.com>
Fri, 4 Oct 2013 10:46:54 +0000 (06:46 -0400)
ast.c
fold.c
parser.h

diff --git a/ast.c b/ast.c
index dc90019..598cf5f 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -438,6 +438,7 @@ bool ast_value_set_name(ast_value *self, const char *name)
 ast_binary* ast_binary_new(lex_ctx_t ctx, int op,
                            ast_expression* left, ast_expression* right)
 {
+    ast_binary *fold;
     ast_instantiate(ast_binary, ctx, ast_binary_delete);
     ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_binary_codegen);
 
@@ -449,6 +450,15 @@ ast_binary* ast_binary_new(lex_ctx_t ctx, int op,
     ast_propagate_effects(self, left);
     ast_propagate_effects(self, right);
 
+    /*
+     * Try to fold away superfluous binary operations, such as:
+     * A * 1, a + 0, etc.
+     */
+    if ((fold = (ast_binary*)fold_superfluous(left, right, op))) {
+        ast_binary_delete(self);
+        return fold;
+    }
+
     if (op >= INSTR_EQ_F && op <= INSTR_GT)
         self->expression.vtype = TYPE_FLOAT;
     else if (op == INSTR_AND || op == INSTR_OR) {
@@ -459,10 +469,8 @@ ast_binary* ast_binary_new(lex_ctx_t ctx, int op,
     }
     else if (op == INSTR_BITAND || op == INSTR_BITOR)
         self->expression.vtype = TYPE_FLOAT;
-    else if (op == INSTR_MUL_VF || op == INSTR_MUL_FV)
+    else if (op == INSTR_MUL_FV || op == INSTR_MUL_FV)
         self->expression.vtype = TYPE_VECTOR;
-    else if (op == INSTR_MUL_V)
-        self->expression.vtype = TYPE_FLOAT;
     else
         self->expression.vtype = left->vtype;
 
diff --git a/fold.c b/fold.c
index d51b765..160ef29 100644 (file)
--- a/fold.c
+++ b/fold.c
@@ -796,6 +796,39 @@ ast_expression *fold_intrin(fold_t *fold, const char *intrin, ast_expression **a
 #define fold_can_1(X)           ((X)->hasvalue && (X)->cvq == CV_CONST)
 /*#define fold_can_2(X,Y)         (fold_can_1(X) && fold_can_1(Y))*/
 
+ast_expression *fold_superfluous(ast_expression *left, ast_expression *right, int op) {
+    ast_value *load;
+
+    if (!ast_istype(left, ast_value))
+        return NULL;
+
+    load = (ast_value*)right;
+
+    switch (op) {
+        case INSTR_MUL_F:
+        case INSTR_MUL_V:
+        case INSTR_MUL_FV:
+        case INSTR_MUL_VF:
+        case INSTR_DIV_F:
+            if (fold_can_1(load) && fold_immvalue_float(load) == 1.0f) {
+                ++opts_optimizationcount[OPTIM_PEEPHOLE];
+                return (ast_expression*)left;
+            }
+            break;
+
+        case INSTR_ADD_F:
+        case INSTR_ADD_V:
+        case INSTR_SUB_F:
+        case INSTR_SUB_V:
+            if (fold_can_1(load) && fold_immvalue_float(load) == 0.0f) {
+                ++opts_optimizationcount[OPTIM_PEEPHOLE];
+                return (ast_expression*)left;
+            }
+            break;
+    }
+
+    return NULL;
+}
 
 static GMQCC_INLINE int fold_cond(ir_value *condval, ast_function *func, ast_ifthen *branch) {
     if (isfloat(condval) && fold_can_1(condval) && OPTS_OPTIMIZATION(OPTIM_CONST_FOLD_DCE)) {
index 54f93b2..b1c7a20 100644 (file)
--- a/parser.h
+++ b/parser.h
@@ -133,6 +133,7 @@ bool            fold_generate       (fold_t *, ir_builder *);
 ast_expression *fold_op             (fold_t *, const oper_info *, ast_expression **);
 ast_expression *fold_intrin         (fold_t *, const char      *, ast_expression **);
 
+ast_expression *fold_superfluous    (ast_expression *, ast_expression *, int);
 int             fold_cond_ifthen    (ir_value *, ast_function *, ast_ifthen  *);
 int             fold_cond_ternary   (ir_value *, ast_function *, ast_ternary *);