path: root/gcc/ipa-hello-world.c

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "backend.h"
#include "tree.h"
#include "gimple-expr.h"
#include "predict.h"
#include "alloc-pool.h"
#include "tree-pass.h"
#include "cgraph.h"
#include "diagnostic.h"
#include "fold-const.h"
#include "gimple-fold.h"
#include "symbol-summary.h"
#include "tree-vrp.h"
#include "ipa-prop.h"
#include "tree-pretty-print.h"
#include "tree-inline.h"
#include "ipa-fnsummary.h"
#include "ipa-utils.h"
#include "tree-ssa-ccp.h"
#include "stringpool.h"
#include "attribs.h"
#include "gimple.h"
#include "cfg.h" // needed for gimple-iterator.h
#include "gimple-iterator.h"
#include <stdbool.h>


#include "types-inlines.h"
#include "ipa-type-collector.h"
#include "ipa-hello-world.h"
#include <map>

//#define OPTIMIZED
#define SANITY_CHECKS

typedef std::set<const_tree> undefset;

Reason
Reason::operator|(const Reason &other)
{
  Reason retval {}; 
  retval.is_escaping = this->is_escaping | other.is_escaping;
  retval.global_is_visible = this->global_is_visible | other.global_is_visible;
  retval.parameter_is_visible = this->parameter_is_visible | other.parameter_is_visible;
  retval.return_is_visible = this->return_is_visible | other.return_is_visible;
  retval.type_is_casted = this->type_is_casted | other.type_is_casted;
  retval.type_is_volatile = this->type_is_volatile | other.type_is_volatile;
  retval.type_is_in_union = this->type_is_in_union | other.type_is_in_union;
  return retval;
}

Reason&
Reason::operator|=(const Reason &other)
{
  this->is_escaping |= other.is_escaping;
  this->global_is_visible |= other.global_is_visible;
  this->parameter_is_visible |= other.parameter_is_visible;
  this->type_is_casted |= other.type_is_casted;
  this->type_is_volatile |= other.type_is_volatile;
  this->type_is_in_union |= other.type_is_in_union;
  return *this;
}

typedef std::map<const_tree, Reason> typemap;

static inline void
assert_type_is_in_universe(const_tree type, ptrset_t &types)
{
#ifdef SANITY_CHECKS
  gcc_assert(types.in_universe(type));
#endif
}

static inline void
assert_type_is_in_ptrset(const_tree type, ptrset_t &types)
{
#ifdef SANITY_CHECKS
  gcc_assert(types.in_points_to_record(type));
#endif
}

static void
update_typemap(const_tree type, ptrset_t &types, Reason reason, typemap &calc)
{
  gcc_assert(type);
  assert_type_is_in_universe(type, types);
  assert_type_is_in_ptrset(type, types);
  const bool already_in_typemap = calc.find(type) != calc.end();
  already_in_typemap ? calc[type] |= reason : calc[type] = reason;
}

static void update_escape_info( const_tree type, ptrset_t &types, Reason reason, typemap &calc);

static void
update_escape_info_wrapper(const_tree type, ptrset_t &types, Reason reason, typemap &calc)
{
  gcc_assert(type);
  update_typemap(type, types, reason, calc);
  const_tree inner_type = TREE_TYPE(type);
  update_escape_info(inner_type, types, reason, calc);
}

static void
update_escape_info_array(const_tree type, ptrset_t &types, Reason reason, typemap &calc)
{
  assert_is_type(type, ARRAY_TYPE);
  update_escape_info_wrapper(type, types, reason, calc);
}

static void
update_escape_info_pointer(const_tree type, ptrset_t &types, Reason reason, typemap &calc)
{
  assert_is_type(type, POINTER_TYPE);
  update_escape_info_wrapper(type, types, reason, calc);
}

static void
update_escape_info_reference(const_tree type, ptrset_t &types, Reason reason, typemap &calc)
{
  assert_is_type(type, REFERENCE_TYPE);
  update_escape_info_wrapper(type, types, reason, calc);
}

static void
update_escape_info_record(const_tree type, ptrset_t &types, Reason reason, typemap &calc)
{
  assert_is_type(type, RECORD_TYPE);
  update_typemap(type, types, reason, calc);
  for (tree field = TYPE_FIELDS(type); field; field = DECL_CHAIN(field))
  {
    const_tree field_type = TREE_TYPE(field);
    gcc_assert(field_type);
    update_escape_info(field_type, types, reason, calc);
  }
}

static void
update_escape_info_union(const_tree type, ptrset_t &types, Reason reason, typemap &calc)
{
  assert_is_type(type, UNION_TYPE);
  Reason inner_reason {};
  inner_reason.type_is_in_union = true;
  inner_reason.is_escaping = true;
  inner_reason |= reason;

  update_typemap(type, types, reason, calc);
  for (tree field = TYPE_FIELDS(type); field; field = DECL_CHAIN(field))
  {
    const_tree field_type = TREE_TYPE(field);
    gcc_assert(field_type);
    // We cannot change type that are on the surface level
    // of unions. (This is a type of casting).
    // But we might be able to change the types which 
    // are pointed by these types.
    update_typemap(field_type, types, inner_reason, calc);
    update_escape_info(field_type, types, reason, calc);
  }
}

static void
update_escape_info_qual_union(const_tree type, ptrset_t &types, Reason reason, typemap &calc)
{
  assert_is_type(type, QUAL_UNION_TYPE);
  update_escape_info_union(type, types, reason, calc);
}

static void
update_escape_info( const_tree type, ptrset_t &types, Reason reason, typemap &calc)
{
#ifdef OPTIMIZED
  // if (!reason.is_escaping) return;
  // Above not necessarily true, since we might point to a union
  // and unions are illegal?
  // instead use the following
  const bool in_set = calc.find(type) != calc.end(type);
  const bool will_not_escape = in_set && !reason.is_escaping;
  if (will_not_escape) return;

  const bool already_escaping = in_set && calc[type].is_escaping;
  if (already_escaping) return;
#endif

  assert_type_is_in_universe(type, types);

  bool is_interesting = types.in_points_to_record(type);
  if (!is_interesting) return;

  gcc_assert(type);
  const enum tree_code code = TREE_CODE(type);
  switch (code)
  {
    case ARRAY_TYPE:
      update_escape_info_array(type, types, reason, calc);
    break;
    case RECORD_TYPE:
      update_escape_info_record(type, types, reason, calc);
    break;
    case UNION_TYPE:
      update_escape_info_union(type, types, reason, calc);
    break;
    case QUAL_UNION_TYPE:
      update_escape_info_qual_union(type, types, reason, calc);
    break;
    case REFERENCE_TYPE:
      update_escape_info_reference(type, types, reason, calc);
    break;
    case POINTER_TYPE:
      update_escape_info_pointer(type, types, reason, calc);
    break;
    // I want to see if we see these and what it means for the code
    case FUNCTION_TYPE:
    // I think I can just pass the type here from cnode...
    // and it should work fine?
    case METHOD_TYPE:
    default:
    gcc_unreachable();
    break;
  }
}


static bool
is_variable_escaping(varpool_node *vnode)
{
  gcc_assert(vnode);
  return vnode->externally_visible;
}

static void
calculate_escaping_types_globals(ptrset_t &types, typemap &calc)
{
  varpool_node *vnode = NULL;
  FOR_EACH_VARIABLE(vnode);
  {
    bool is_escaping = is_variable_escaping(vnode);
    if (!is_escaping) return;

    const_tree decl = vnode->decl;
    gcc_assert(decl);
    const_tree type = TREE_TYPE(decl);
    gcc_assert(type);
    Reason reason {};  // Not sure why {} works but () doesn't... It believes it is a function?
    reason.is_escaping = is_escaping;
    reason.global_is_visible = is_escaping;
    update_escape_info (type, types, reason, calc);
  }
}

static bool 
filter_known_function(cgraph_node *node)
{
  gcc_assert(node);
  bool filter = false;
  const char *_free = "free";
  const char *_malloc = "malloc";
  const char *_realloc = "realloc";
  const char *_calloc = "calloc";
  const char *name = node->name();
  // TODO: we want memset here...
  // but we can't until we fix the sizeof tree...
  gcc_assert(name);
  filter |= strcmp(_free, name) == 0;
  filter |= strcmp(_malloc, name) == 0;
  filter |= strcmp(_realloc, name) == 0;
  filter |= strcmp(_calloc, name) == 0;
  return filter;
}

static bool 
is_function_escaping(cgraph_node *cnode)
{
  gcc_assert(cnode);
  return cnode->externally_visible;
}

static void
mark_escaping_parameters(ptrset_t &types, typemap &calc, cgraph_node *cnode, Reason reason)
{
  gcc_assert(cnode);
  const_tree decl = cnode->decl;
  gcc_assert(decl);
  assert_is_type(decl, FUNCTION_DECL);
#ifdef OPTIMIZED
  if (!reason.is_escaping) return;
#endif

  function_args_iterator iter;
  tree arg_type = NULL;
  const_tree function_type = TREE_TYPE(decl);
  gcc_assert(function_type);
  FOREACH_FUNCTION_ARGS(function_type, arg_type, iter)
  {
    update_escape_info(arg_type, types, reason, calc);
  }
}

static void
mark_escaping_return_type(ptrset_t &types, typemap &calc, cgraph_node *cnode, Reason reason)
{
  gcc_assert(cnode);
  const_tree decl = cnode->decl;
  gcc_assert(decl);
  assert_is_type(decl, FUNCTION_DECL);
#ifdef OPTIMIZED
  if (!reason.is_escaping) return;
#endif

  const_tree func_type = TREE_TYPE(decl);
  assert_is_type(func_type, FUNCTION_TYPE);
  const_tree ret_type = TREE_TYPE(func_type);
  gcc_assert(ret_type);
  update_escape_info(ret_type, types, reason, calc);
}

static void
mark_escaping_function(ptrset_t &types, typemap &calc, cgraph_node *cnode)
{
  gcc_assert(cnode);
  const bool is_escaping = is_function_escaping(cnode);
#ifdef OPTIMIZED
  if (!is_escaping) return;
#endif

  Reason reason1 {};
  reason1.is_escaping = is_escaping;
  reason1.parameter_is_visible = is_escaping;
  mark_escaping_parameters(types, calc, cnode, reason1);

  Reason reason2 {};
  reason2.is_escaping = is_escaping;
  reason2.return_is_visible = is_escaping;
  mark_escaping_return_type(types, calc, cnode, reason2);
}

static void
calculate_escaping_types_from_bb(ptrset_t &types, typemap &calc, undefset &undef, basic_block bb)
{
  gcc_assert(bb);
  for (auto gsi = gsi_start_bb(bb); !gsi_end_p(gsi); gsi_next(&gsi))
  {
    gimple *stmt = gsi_stmt(gsi);
  }
}

static void
calculate_escaping_types_from_cnode(ptrset_t &types, typemap &calc, cgraph_node *cnode, undefset &undef)
{
  gcc_assert(cnode);
  cnode->get_untransformed_body();
  const_tree decl = cnode->decl;
  gcc_assert(decl);
  function *func = DECL_STRUCT_FUNCTION(decl);
  gcc_assert(func);
  basic_block bb = NULL;
  push_cfun(func);
  FOR_EACH_BB_FN(bb, func)
  {
    calculate_escaping_types_from_bb(types, calc, undef, bb);
  }
  pop_cfun();
}

static void
calculate_escaping_functions(ptrset_t &types, typemap &calc)
{
  cgraph_node *cnode = NULL;
  undefset undefined_functions;
  FOR_EACH_FUNCTION(cnode)
  {
    gcc_assert(cnode);
    const bool filter = filter_known_function(cnode);
    if (filter) continue;

    const_tree decl = cnode->decl;
    gcc_assert(decl);
    undefined_functions.insert(decl);
  }

  FOR_EACH_FUNCTION_WITH_GIMPLE_BODY(cnode)
  {
    gcc_assert(cnode);
    cnode->get_untransformed_body();
    const_tree decl = cnode->decl;
    gcc_assert(decl);
    undefined_functions.erase(decl);
    mark_escaping_function(types, calc, cnode);
  }

  FOR_EACH_FUNCTION_WITH_GIMPLE_BODY(cnode)
  {
    gcc_assert(cnode);
    calculate_escaping_types_from_cnode(types, calc, cnode, undefined_functions);
  }
}

static void
calculate_escaping_types(ptrset_t &types, typemap &calc)
{
   calculate_escaping_types_globals(types, calc);
   calculate_escaping_functions(types, calc);
}

static unsigned int
iphw_execute()
{
  ptrset_t types;
  collect_types(types);

  typemap eacalc; // Escape Analysis Calculation
  // Intermediate results
  // Do not read escape analysis results from here
  calculate_escaping_types(types, eacalc);
  fprintf(dump_file, "Hello world!");
  return 0;
}

namespace {
const pass_data pass_data_ipa_hello_world =
{
  SIMPLE_IPA_PASS,
  "hello-world",
  OPTGROUP_NONE,
  TV_NONE,
  (PROP_cfg | PROP_ssa),
  0,
  0,
  0,
  0,
};

class pass_ipa_hello_world : public simple_ipa_opt_pass
{
public:
  pass_ipa_hello_world (gcc::context *ctx)
    : simple_ipa_opt_pass(pass_data_ipa_hello_world, ctx)
  {}

  virtual bool gate(function*) { return flag_ipa_hello_world; }
  virtual unsigned execute (function*) { return iphw_execute(); }
};
} // anon namespace

simple_ipa_opt_pass*
make_pass_ipa_hello_world (gcc::context *ctx)
{
  return new pass_ipa_hello_world (ctx);
}