gimple-print.cc

#include <gcc-plugin.h>
#include <plugin-version.h>
#include <coretypes.h>
#include <tree.h>
#include <gimple.h>
#include <gimple-iterator.h>
#include <tree-pass.h>
#include <context.h>
#include <basic-block.h>
#include <ssa.h>
#include <ssa-iterators.h>

int plugin_is_GPL_compatible;

static struct plugin_info gimple_print_info = 
{
  version: "1.0",
  help: "This plugin prints the GIMPLE/IR"
};

const pass_data gimple_print_data =
{
  type: GIMPLE_PASS,
  name: "gimple-print pass",
  optinfo_flags: OPTGROUP_NONE,
  tv_id: TV_NONE, 
  properties_required: PROP_gimple_any,  
  properties_provided: 0,
  properties_destroyed: 0,
  todo_flags_start: 0,
  todo_flags_finish: 0
};

const char*
tree_code_name(enum tree_code code)
{
  switch(code)
  {
    case ERROR_MARK: return("ERROR_MARK");
    case IDENTIFIER_NODE: return("IDENTIFIER_NODE");
    case TREE_LIST: return("TREE_LIST");
    case TREE_VEC: return("TREE_VEC");
    case BLOCK: return("BLOCK");
    case OFFSET_TYPE: return("OFFSET_TYPE");
    case ENUMERAL_TYPE: return("ENUMERAL_TYPE");
    case BOOLEAN_TYPE: return("BOOLEAN_TYPE");
    case INTEGER_TYPE: return("INTEGER_TYPE");
    case REAL_TYPE: return("REAL_TYPE");
    case POINTER_TYPE: return("POINTER_TYPE");
    case REFERENCE_TYPE: return("REFERENCE_TYPE");
    case NULLPTR_TYPE: return("NULLPTR_TYPE");
    case FIXED_POINT_TYPE: return("FIXED_POINT_TYPE");
    case COMPLEX_TYPE: return("COMPLEX_TYPE");
    case VECTOR_TYPE: return("VECTOR_TYPE");
    case ARRAY_TYPE: return("ARRAY_TYPE");
    case RECORD_TYPE: return("RECORD_TYPE");
    case UNION_TYPE: return("UNION_TYPE");
    case QUAL_UNION_TYPE: return("QUAL_UNION_TYPE");
    case VOID_TYPE: return("VOID_TYPE");
    case POINTER_BOUNDS_TYPE: return("POINTER_BOUNDS_TYPE");
    case FUNCTION_TYPE: return("FUNCTION_TYPE");
    case METHOD_TYPE: return("METHOD_TYPE");
    case LANG_TYPE: return("LANG_TYPE");
    case VOID_CST: return("VOID_CST");
    case INTEGER_CST: return("INTEGER_CST");
    case POLY_INT_CST: return("POLY_INT_CST");
    case REAL_CST: return("REAL_CST");
    case FIXED_CST: return("FIXED_CST");
    case COMPLEX_CST: return("COMPLEX_CST");
    case VECTOR_CST: return("VECTOR_CST");
    case STRING_CST: return("STRING_CST");
    case FUNCTION_DECL: return("FUNCTION_DECL");
    case LABEL_DECL: return("LABEL_DECL");
    case FIELD_DECL: return("FIELD_DECL");
    case VAR_DECL: return("VAR_DECL");
    case CONST_DECL: return("CONST_DECL");
    case PARM_DECL: return("PARM_DECL");
    case TYPE_DECL: return("TYPE_DECL");
    case RESULT_DECL: return("RESULT_DECL");
    case DEBUG_EXPR_DECL: return("DEBUG_EXPR_DECL");
    case DEBUG_BEGIN_STMT: return("DEBUG_BEGIN_STMT");
    case NAMESPACE_DECL: return("NAMESPACE_DECL");
    case IMPORTED_DECL: return("IMPORTED_DECL");
    case NAMELIST_DECL: return("NAMELIST_DECL");
    case TRANSLATION_UNIT_DECL: return("TRANSLATION_UNIT_DECL");
    case COMPONENT_REF: return("COMPONENT_REF");
    case BIT_FIELD_REF: return("BIT_FIELD_REF");
    case ARRAY_REF: return("ARRAY_REF");
    case ARRAY_RANGE_REF: return("ARRAY_RANGE_REF");
    case REALPART_EXPR: return("REALPART_EXPR");
    case IMAGPART_EXPR: return("IMAGPART_EXPR");
    case VIEW_CONVERT_EXPR: return("VIEW_CONVERT_EXPR");
    case INDIRECT_REF: return("INDIRECT_REF");
    case OBJ_TYPE_REF: return("OBJ_TYPE_REF");
    case CONSTRUCTOR: return("CONSTRUCTOR");
    case COMPOUND_EXPR: return("COMPOUND_EXPR");
    case MODIFY_EXPR: return("MODIFY_EXPR");
    case INIT_EXPR: return("INIT_EXPR");
    case TARGET_EXPR: return("TARGET_EXPR");
    case COND_EXPR: return("COND_EXPR");
    case VEC_DUPLICATE_EXPR: return("VEC_DUPLICATE_EXPR");
    case VEC_SERIES_EXPR: return("VEC_SERIES_EXPR");
    case VEC_COND_EXPR: return("VEC_COND_EXPR");
    case VEC_PERM_EXPR: return("VEC_PERM_EXPR");
    case BIND_EXPR: return("BIND_EXPR");
    case CALL_EXPR: return("CALL_EXPR");
    case WITH_CLEANUP_EXPR: return("WITH_CLEANUP_EXPR");
    case CLEANUP_POINT_EXPR: return("CLEANUP_POINT_EXPR");
    case PLACEHOLDER_EXPR: return("PLACEHOLDER_EXPR");
    case PLUS_EXPR: return("PLUS_EXPR");
    case MINUS_EXPR: return("MINUS_EXPR");
    case MULT_EXPR: return("MULT_EXPR");
    case POINTER_PLUS_EXPR: return("POINTER_PLUS_EXPR");
    case POINTER_DIFF_EXPR: return("POINTER_DIFF_EXPR");
    case MULT_HIGHPART_EXPR: return("MULT_HIGHPART_EXPR");
    case TRUNC_DIV_EXPR: return("TRUNC_DIV_EXPR");
    case CEIL_DIV_EXPR: return("CEIL_DIV_EXPR");
    case FLOOR_DIV_EXPR: return("FLOOR_DIV_EXPR");
    case ROUND_DIV_EXPR: return("ROUND_DIV_EXPR");
    case TRUNC_MOD_EXPR: return("TRUNC_MOD_EXPR");
    case CEIL_MOD_EXPR: return("CEIL_MOD_EXPR");
    case FLOOR_MOD_EXPR: return("FLOOR_MOD_EXPR");
    case ROUND_MOD_EXPR: return("ROUND_MOD_EXPR");
    case RDIV_EXPR: return("RDIV_EXPR");
    case EXACT_DIV_EXPR: return("EXACT_DIV_EXPR");
    case FIX_TRUNC_EXPR: return("FIX_TRUNC_EXPR");
    case FLOAT_EXPR: return("FLOAT_EXPR");
    case NEGATE_EXPR: return("NEGATE_EXPR");
    case MIN_EXPR: return("MIN_EXPR");
    case MAX_EXPR: return("MAX_EXPR");
    case ABS_EXPR: return("ABS_EXPR");
    case LSHIFT_EXPR: return("LSHIFT_EXPR");
    case RSHIFT_EXPR: return("RSHIFT_EXPR");
    case LROTATE_EXPR: return("LROTATE_EXPR");
    case RROTATE_EXPR: return("RROTATE_EXPR");
    case BIT_IOR_EXPR: return("BIT_IOR_EXPR");
    case BIT_XOR_EXPR: return("BIT_XOR_EXPR");
    case BIT_AND_EXPR: return("BIT_AND_EXPR");
    case BIT_NOT_EXPR: return("BIT_NOT_EXPR");
    case TRUTH_ANDIF_EXPR: return("TRUTH_ANDIF_EXPR");
    case TRUTH_ORIF_EXPR: return("TRUTH_ORIF_EXPR");
    case TRUTH_AND_EXPR: return("TRUTH_AND_EXPR");
    case TRUTH_OR_EXPR: return("TRUTH_OR_EXPR");
    case TRUTH_XOR_EXPR: return("TRUTH_XOR_EXPR");
    case TRUTH_NOT_EXPR: return("TRUTH_NOT_EXPR");
    case LT_EXPR: return("LT_EXPR");
    case LE_EXPR: return("LE_EXPR");
    case GT_EXPR: return("GT_EXPR");
    case GE_EXPR: return("GE_EXPR");
    case EQ_EXPR: return("EQ_EXPR");
    case NE_EXPR: return("NE_EXPR");
    case UNORDERED_EXPR: return("UNORDERED_EXPR");
    case ORDERED_EXPR: return("ORDERED_EXPR");
    case UNLT_EXPR: return("UNLT_EXPR");
    case UNLE_EXPR: return("UNLE_EXPR");
    case UNGT_EXPR: return("UNGT_EXPR");
    case UNGE_EXPR: return("UNGE_EXPR");
    case UNEQ_EXPR: return("UNEQ_EXPR");
    case LTGT_EXPR: return("LTGT_EXPR");
    case RANGE_EXPR: return("RANGE_EXPR");
    case PAREN_EXPR: return("PAREN_EXPR");
    case CONVERT_EXPR: return("CONVERT_EXPR");
    case ADDR_SPACE_CONVERT_EXPR: return("ADDR_SPACE_CONVERT_EXPR");
    case FIXED_CONVERT_EXPR: return("FIXED_CONVERT_EXPR");
    case NOP_EXPR: return("NOP_EXPR");
    case NON_LVALUE_EXPR: return("NON_LVALUE_EXPR");
    case COMPOUND_LITERAL_EXPR: return("COMPOUND_LITERAL_EXPR");
    case SAVE_EXPR: return("SAVE_EXPR");
    case ADDR_EXPR: return("ADDR_EXPR");
    case FDESC_EXPR: return("FDESC_EXPR");
    case BIT_INSERT_EXPR: return("BIT_INSERT_EXPR");
    case COMPLEX_EXPR: return("COMPLEX_EXPR");
    case CONJ_EXPR: return("CONJ_EXPR");
    case PREDECREMENT_EXPR: return("PREDECREMENT_EXPR");
    case PREINCREMENT_EXPR: return("PREINCREMENT_EXPR");
    case POSTDECREMENT_EXPR: return("POSTDECREMENT_EXPR");
    case POSTINCREMENT_EXPR: return("POSTINCREMENT_EXPR");
    case VA_ARG_EXPR: return("VA_ARG_EXPR");
    case TRY_CATCH_EXPR: return("TRY_CATCH_EXPR");
    case TRY_FINALLY_EXPR: return("TRY_FINALLY_EXPR");
    case DECL_EXPR: return("DECL_EXPR");
    case LABEL_EXPR: return("LABEL_EXPR");
    case GOTO_EXPR: return("GOTO_EXPR");
    case RETURN_EXPR: return("RETURN_EXPR");
    case EXIT_EXPR: return("EXIT_EXPR");
    case LOOP_EXPR: return("LOOP_EXPR");
    case SWITCH_EXPR: return("SWITCH_EXPR");
    case CASE_LABEL_EXPR: return("CASE_LABEL_EXPR");
    case ASM_EXPR: return("ASM_EXPR");
    case SSA_NAME: return("SSA_NAME");
    case CATCH_EXPR: return("CATCH_EXPR");
    case EH_FILTER_EXPR: return("EH_FILTER_EXPR");
    case SCEV_KNOWN: return("SCEV_KNOWN");
    case SCEV_NOT_KNOWN: return("SCEV_NOT_KNOWN");
    case POLYNOMIAL_CHREC: return("POLYNOMIAL_CHREC");
    case STATEMENT_LIST: return("STATEMENT_LIST");
    case ASSERT_EXPR: return("ASSERT_EXPR");
    case TREE_BINFO: return("TREE_BINFO");
    case WITH_SIZE_EXPR: return("WITH_SIZE_EXPR");
    case REALIGN_LOAD_EXPR: return("REALIGN_LOAD_EXPR");
    case TARGET_MEM_REF: return("TARGET_MEM_REF");
    case MEM_REF: return("MEM_REF");
    case OACC_PARALLEL: return("OACC_PARALLEL");
    case OACC_KERNELS: return("OACC_KERNELS");
    case OACC_DATA: return("OACC_DATA");
    case OACC_HOST_DATA: return("OACC_HOST_DATA");
    case OMP_PARALLEL: return("OMP_PARALLEL");
    case OMP_TASK: return("OMP_TASK");
    case OMP_FOR: return("OMP_FOR");
    case OMP_SIMD: return("OMP_SIMD");
    case OMP_DISTRIBUTE: return("OMP_DISTRIBUTE");
    case OMP_TASKLOOP: return("OMP_TASKLOOP");
    case OACC_LOOP: return("OACC_LOOP");
    case OMP_TEAMS: return("OMP_TEAMS");
    case OMP_TARGET_DATA: return("OMP_TARGET_DATA");
    case OMP_TARGET: return("OMP_TARGET");
    case OMP_SECTIONS: return("OMP_SECTIONS");
    case OMP_ORDERED: return("OMP_ORDERED");
    case OMP_CRITICAL: return("OMP_CRITICAL");
    case OMP_SINGLE: return("OMP_SINGLE");
    case OMP_SECTION: return("OMP_SECTION");
    case OMP_MASTER: return("OMP_MASTER");
    case OMP_TASKGROUP: return("OMP_TASKGROUP");
    case OACC_CACHE: return("OACC_CACHE");
    case OACC_DECLARE: return("OACC_DECLARE");
    case OACC_ENTER_DATA: return("OACC_ENTER_DATA");
    case OACC_EXIT_DATA: return("OACC_EXIT_DATA");
    case OACC_UPDATE: return("OACC_UPDATE");
    case OMP_TARGET_UPDATE: return("OMP_TARGET_UPDATE");
    case OMP_TARGET_ENTER_DATA: return("OMP_TARGET_ENTER_DATA");
    case OMP_TARGET_EXIT_DATA: return("OMP_TARGET_EXIT_DATA");
    case OMP_ATOMIC: return("OMP_ATOMIC");
    case OMP_ATOMIC_READ: return("OMP_ATOMIC_READ");
    case OMP_ATOMIC_CAPTURE_OLD: return("OMP_ATOMIC_CAPTURE_OLD");
    case OMP_ATOMIC_CAPTURE_NEW: return("OMP_ATOMIC_CAPTURE_NEW");
    case OMP_CLAUSE: return("OMP_CLAUSE");
    case TRANSACTION_EXPR: return("TRANSACTION_EXPR");
    case DOT_PROD_EXPR: return("DOT_PROD_EXPR");
    case WIDEN_SUM_EXPR: return("WIDEN_SUM_EXPR");
    case SAD_EXPR: return("SAD_EXPR");
    case WIDEN_MULT_EXPR: return("WIDEN_MULT_EXPR");
    case WIDEN_MULT_PLUS_EXPR: return("WIDEN_MULT_PLUS_EXPR");
    case WIDEN_MULT_MINUS_EXPR: return("WIDEN_MULT_MINUS_EXPR");
    case WIDEN_LSHIFT_EXPR: return("WIDEN_LSHIFT_EXPR");
    case FMA_EXPR: return("FMA_EXPR");
    case VEC_WIDEN_MULT_HI_EXPR: return("VEC_WIDEN_MULT_HI_EXPR");
    case VEC_WIDEN_MULT_LO_EXPR: return("VEC_WIDEN_MULT_LO_EXPR");
    case VEC_WIDEN_MULT_EVEN_EXPR: return("VEC_WIDEN_MULT_EVEN_EXPR");
    case VEC_WIDEN_MULT_ODD_EXPR: return("VEC_WIDEN_MULT_ODD_EXPR");
    case VEC_UNPACK_HI_EXPR: return("VEC_UNPACK_HI_EXPR");
    case VEC_UNPACK_LO_EXPR: return("VEC_UNPACK_LO_EXPR");
    case VEC_UNPACK_FLOAT_HI_EXPR: return("VEC_UNPACK_FLOAT_HI_EXPR");
    case VEC_UNPACK_FLOAT_LO_EXPR: return("VEC_UNPACK_FLOAT_LO_EXPR");
    case VEC_PACK_TRUNC_EXPR: return("VEC_PACK_TRUNC_EXPR");
    case VEC_PACK_SAT_EXPR: return("VEC_PACK_SAT_EXPR");
    case VEC_PACK_FIX_TRUNC_EXPR: return("VEC_PACK_FIX_TRUNC_EXPR");
    case VEC_WIDEN_LSHIFT_HI_EXPR: return("VEC_WIDEN_LSHIFT_HI_EXPR");
    case VEC_WIDEN_LSHIFT_LO_EXPR: return("VEC_WIDEN_LSHIFT_LO_EXPR");
    case PREDICT_EXPR: return("PREDICT_EXPR");
    case OPTIMIZATION_NODE: return("OPTIMIZATION_NODE");
    case TARGET_OPTION_NODE: return("TARGET_OPTION_NODE");
    case ANNOTATE_EXPR: return("ANNOTATE_EXPR");
    default: 
      return("UNKNOWN TREE CODE");
  }
}

const char*
gimple_stmt_name(enum gimple_code code)
{
  switch (code)
  {
    case GIMPLE_ERROR_MARK: return("GIMPLE_ERROR_MARK");
    case GIMPLE_COND: return("GIMPLE_COND");
    case GIMPLE_DEBUG: return("GIMPLE_DEBUG");
    case GIMPLE_GOTO: return("GIMPLE_GOTO");
    case GIMPLE_LABEL: return("GIMPLE_LABEL");
    case GIMPLE_SWITCH: return("GIMPLE_SWITCH");
    case GIMPLE_ASSIGN: return("GIMPLE_ASSIGN");
    case GIMPLE_ASM: return("GIMPLE_ASM");
    case GIMPLE_CALL: return("GIMPLE_CALL");
    case GIMPLE_TRANSACTION: return("GIMPLE_TRANSACTION");
    case GIMPLE_RETURN: return("GIMPLE_RETURN");
    case GIMPLE_BIND: return("GIMPLE_BIND");
    case GIMPLE_CATCH: return("GIMPLE_CATCH");
    case GIMPLE_EH_FILTER: return("GIMPLE_EH_FILTER");
    case GIMPLE_EH_MUST_NOT_THROW: return("GIMPLE_EH_MUST_NOT_THROW");
    case GIMPLE_EH_ELSE: return("GIMPLE_EH_ELSE");
    case GIMPLE_RESX: return("GIMPLE_RESX");
    case GIMPLE_EH_DISPATCH: return("GIMPLE_EH_DISPATCH");
    case GIMPLE_PHI: return("GIMPLE_PHI");
    case GIMPLE_TRY: return("GIMPLE_TRY");
    case GIMPLE_NOP: return("GIMPLE_NOP");
    case GIMPLE_OMP_ATOMIC_LOAD: return("GIMPLE_OMP_ATOMIC_LOAD");
    case GIMPLE_OMP_ATOMIC_STORE: return("GIMPLE_OMP_ATOMIC_STORE");
    case GIMPLE_OMP_CONTINUE: return("GIMPLE_OMP_CONTINUE");
    case GIMPLE_OMP_CRITICAL: return("GIMPLE_OMP_CRITICAL");
    case GIMPLE_OMP_FOR: return("GIMPLE_OMP_FOR");
    case GIMPLE_OMP_MASTER: return("GIMPLE_OMP_MASTER");
    case GIMPLE_OMP_TASKGROUP: return("GIMPLE_OMP_TASKGROUP");
    case GIMPLE_OMP_PARALLEL: return("GIMPLE_OMP_PARALLEL");
    case GIMPLE_OMP_TASK: return("GIMPLE_OMP_TASK");
    case GIMPLE_OMP_RETURN: return("GIMPLE_OMP_RETURN");
    case GIMPLE_OMP_SECTION: return("GIMPLE_OMP_SECTION");
    case GIMPLE_OMP_SECTIONS: return("GIMPLE_OMP_SECTIONS");
    case GIMPLE_OMP_SECTIONS_SWITCH: return("GIMPLE_OMP_SECTIONS_SWITCH");
    case GIMPLE_OMP_SINGLE: return("GIMPLE_OMP_SINGLE");
    case GIMPLE_OMP_TARGET: return("GIMPLE_OMP_TARGET");
    case GIMPLE_OMP_TEAMS: return("GIMPLE_OMP_TEAMS");
    case GIMPLE_OMP_ORDERED: return("GIMPLE_OMP_ORDERED");
    case GIMPLE_OMP_GRID_BODY: return("GIMPLE_OMP_GRID_BODY");
    case GIMPLE_PREDICT: return("GIMPLE_PREDICT");
    case GIMPLE_WITH_CLEANUP_EXPR: return("GIMPLE_WITH_CLEANUP_EXPR");
    default:
      return("UNKNOWN STATEMENT CODE");
  }
}

struct gimple_print_pass : gimple_opt_pass
{
  gimple_print_pass(gcc::context *ctx)
    : gimple_opt_pass(gimple_print_data, ctx) 
    {
    }

  virtual unsigned execute(function *fun) override
  {
    basic_block bb;

    FOR_ALL_BB_FN(bb, fun)
    {
      gimple *stmt, *phi;
      gimple_bb_info *bb_info = &bb->il.gimple;
      enum gimple_code code;
      int line;

      switch (bb->index)
      {
        case 0:
          printf("ENTRY BASIC BLOCK OF \'%s\' \n", function_name(fun));
          break;
        case 1:
          printf("EXIT BASIC BLOCK OF \'%s\'\n", function_name(fun));
          break;
        default:
          printf("INNER BASIC BLOCK #%d OF \'%s\' (PREV = %d, NEXT = %d)\n", bb->index, function_name(fun),
                                                                             bb->prev_bb->index, bb->next_bb->index);
          for (gimple_stmt_iterator gsi = gsi_start(bb_info->seq); !gsi_end_p(gsi); gsi_next(&gsi))
          {
            stmt = gsi_stmt(gsi);
            code = gimple_code(stmt);
            line = gimple_lineno(stmt);
            
            printf("\t");
            if (line > 0)
            {
              printf("LINE %d: ", line);
            }
            printf("%s\n", gimple_stmt_name(code));

            if (code == GIMPLE_ASSIGN)
            {
              tree lhs = gimple_assign_lhs(stmt);
              tree rhs1 = gimple_assign_rhs1(stmt);
              printf("\t\tLHS: %s\n", tree_code_name(TREE_CODE(lhs)));
              printf("\t\tRHS: %s\n", tree_code_name(gimple_assign_rhs_code(stmt)));
              printf("\t\t\tRHS1: %s\n", tree_code_name(TREE_CODE(rhs1)));

              enum gimple_rhs_class rhs_class = get_gimple_rhs_class(gimple_assign_rhs_code(stmt));
              if (rhs_class == GIMPLE_BINARY_RHS)
              {
                tree rhs2 = gimple_assign_rhs2(stmt);
                printf("\t\t\tRHS2: %s\n", tree_code_name(TREE_CODE(rhs2)));
              }
            }
            else if (code == GIMPLE_PHI)
            {
              // Handled separately
            }
            else if (code == GIMPLE_COND)
            {
              tree lhs = gimple_cond_lhs(stmt);
              tree rhs = gimple_cond_rhs(stmt);
              printf("\t\tLHS: %s\n", tree_code_name(TREE_CODE(lhs)));
              printf("\t\tRHS: %s\n", tree_code_name(TREE_CODE(rhs)));

              // FIXME: segfaults
              // const gcond *entry = as_a<gcond *>(stmt);
              // printf("\t\tTRUE: %s\n", tree_code_name(TREE_CODE(gimple_cond_true_label(entry))));
              // printf("\t\tFALSE: %s\n", tree_code_name(TREE_CODE(gimple_cond_false_label(entry))));
            }
            else if (code == GIMPLE_SWITCH)
            {
              const gswitch *entry = as_a<gswitch *>(stmt);
              unsigned int n_cases = gimple_switch_num_labels(entry);
              printf("\t\tTOTAL CASES: %d\n", n_cases);
            }
          }

          for (gimple_stmt_iterator si = gsi_start_phis(bb); !gsi_end_p(si); gsi_next(&si))
          {
            phi = gsi_stmt(si);
            code = gimple_code(phi);
            tree phi_result = gimple_phi_result(phi);
            unsigned int n_args = gimple_phi_num_args(phi);
            line = gimple_lineno(phi);
            
            printf("\t");
            if (line > 0)
            {
              printf("LINE %d: ", line);
            }
            printf("%s\n", gimple_stmt_name(code));

            printf("\t\tTOTAL PHI ARGS: %d\n", n_args);
            printf("\t\tPHI RESULT: %s\n", tree_code_name(TREE_CODE(phi_result)));
            
            for (unsigned int i = 0; i < n_args; ++i)
            {
              tree def = gimple_phi_arg(phi, i)->def;
              printf("\t\tPHI ARG %d: %s\n", i, tree_code_name(TREE_CODE(def)));
            }
          }
        }
        printf("\n");
      }
    return 0;
  }
};

int plugin_init(struct plugin_name_args   *info,
                struct plugin_gcc_version *ver)
{
  if(!plugin_default_version_check(ver, &gcc_version))
  {
    printf("This GCC plugin is for GCC version %d.%d\n", GCCPLUGIN_VERSION_MAJOR, GCCPLUGIN_VERSION_MINOR);
    return 1;
  }

  struct register_pass_info pass;

  pass.pass = new gimple_print_pass(g);
  pass.reference_pass_name = "ssa";
  pass.ref_pass_instance_number = 1;
  pass.pos_op = PASS_POS_INSERT_AFTER;

  register_callback("gimple-print", PLUGIN_PASS_MANAGER_SETUP, NULL, &pass);
  register_callback("gimple-print", PLUGIN_INFO, NULL, &gimple_print_info);

  // printf("GIMPLE-PRINT plugin initialized...\n");

  return 0;
}