path: root/gcc/type-reconstructor.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 "tree-ssa-alias.h"
#include "tree-ssanames.h"
#include "gimple.h"
#include "cfg.h" // needed for gimple-iterator.h
#include "gimple-iterator.h"
#include "gimple-ssa.h"
#include <stdbool.h>
#include "types-inlines.h"

#include "type-reconstructor.hpp"
#include "type-stringifier.hpp"
#include "stor-layout.h"

bool
TypeReconstructor::is_memoized(const_tree t)
{
  const bool already_changed = _reorg_map.find(t) != _reorg_map.end();
  return already_changed;
}

static tree
get_new_identifier(const_tree type)
{
  const char* identifier = TypeStringifier::get_type_identifier(type).c_str();
  const bool is_new_type = strstr(identifier, "reorg");
  gcc_assert(!is_new_type);
  char *new_name;
  asprintf(&new_name, "%s.reorg", identifier);
  return get_identifier(new_name);
}

// Invariant for all _pre functions:
// _reorg_map[t] == NULL (due to memoization)
//
// Invariant for all _post functions:
// _reorg_map[TREE_TYPE(t)] != NULL
// unless TREE_TYPE(t) is not a type which points to a record
// a.k.a. no modifications
//
// To preserve invariant, we must include
// the following at the end of all _post functions:
// _reorg_map[t] = /* reorg type */
// 
// How information is passed?
// To further _post functions via stacks
//
// To previous _post functions via _reorg_map (and maybe others?)
//
//
void
TypeReconstructor::_walk_ARRAY_TYPE_pre(const_tree t)
{
  _working_stack.push(build_distinct_type_copy((tree)t));
}

void
TypeReconstructor::_walk_ARRAY_TYPE_post(const_tree t)
{
  const_tree inner_type = TREE_TYPE(t);
  gcc_assert(inner_type);
  const bool in_map = _reorg_map.find(inner_type) != _reorg_map.end();
  tree t_reorg = _working_stack.top();
  _working_stack.pop();

  if (!in_map) return;

  tree inner_reorg_type = _reorg_map[inner_type];
  TREE_TYPE(t_reorg) = inner_reorg_type;
  TYPE_NAME((tree)t_reorg) = get_new_identifier(t_reorg);
  _reorg_map[t] = t_reorg;
  log("working type %s\n", t_reorg ? "t" : "f");
}

void
TypeReconstructor::_walk_POINTER_TYPE_pre(const_tree t)
{
  // We really should only make a distinct type copy if 
  // it points to a pointer that will be rewritten...
  _working_stack.push(build_distinct_type_copy((tree)t));
}

void
TypeReconstructor::_walk_POINTER_TYPE_post(const_tree t)
{
  tree t_reorg = _working_stack.top();
  _working_stack.pop();

  const_tree inner_type = TREE_TYPE(t);
  const bool in_map = _reorg_map.find(inner_type) != _reorg_map.end();
  // We are pointing to an integer or something like that.
  if (!in_map) return;

  tree inner_type_reorg = _reorg_map[inner_type];
  TREE_TYPE((tree)t_reorg) = inner_type_reorg;
  TYPE_NAME((tree)t_reorg) = get_new_identifier(t_reorg);
  _reorg_map[t] = t_reorg;;
  log("working type %s\n", t_reorg ? "t" : "f");
}

void
TypeReconstructor::_walk_RECORD_TYPE_pre(const_tree t)
{
  const bool in_map = _records.find(t) != _records.end();
  // The modifying stack let's us know if the current record
  // type is being modified.
  _modifying.push(in_map);

  field_offsets_t empty;
  _record_stack.push(in_map ? _records[t] : empty);

  // We really should only make a distinct type copy if 
  // it points to a pointer that will be rewritten...
  _working_stack.push(build_distinct_type_copy((tree)t));

  type_vector_t vec;
  type_vector_t vec2;
  _field_decls.push(vec);
  _eliminated_fields.push(vec2);
}

void
TypeReconstructor::_walk_UNION_TYPE_pre(const_tree t)
{
  const bool in_map = _records.find(t) != _records.end();
  // The modifying stack let's us know if the current record
  // type is being modified.
  gcc_assert(!in_map);
  _modifying.push(in_map);

  field_offsets_t empty;
  _record_stack.push(in_map ? _records[t] : empty);

  // We really should only make a distinct type copy if 
  // it points to a pointer that will be rewritten...
  _working_stack.push(build_distinct_type_copy((tree)t));

  type_vector_t vec;
  type_vector_t vec2;
  _field_decls.push(vec);
  _eliminated_fields.push(vec2);
}

void
TypeReconstructor::_walk_UNION_TYPE_post(const_tree t)
{
  _walk_RECORD_TYPE_post(t);
}


void
TypeReconstructor::_walk_RECORD_TYPE_post(const_tree t)
{
  const bool already_changed = _reorg_map.find(t) != _reorg_map.end();
  type_vector_t fields_to_keep = _field_decls.top();
  for (auto i = fields_to_keep.cbegin(), e = fields_to_keep.cend(); i != e; ++i)
  {
    const_tree field = *i;
  }
  type_vector_t fields_to_eliminate = _eliminated_fields.top();
  _eliminated_fields.pop();
  _field_decls.pop();
  tree working_type = _working_stack.top();
  _working_stack.pop();
  _record_stack.pop();
  const bool should_be_modified = _modifying.top();
  _modifying.pop();

  // There are no fields to eliminate
  // if (fields_to_eliminate.empty()) return;
  // But, we can have a nested struct that will be rewritten
  // so, we should keep not exit early

  // There are no fields to keep
  // Can be an incomplete type

  // It is already changed, so just pop the stacks and that's it.
  if (already_changed) return;

  if (fields_to_keep.empty())
  {
    layout_type(working_type);
    TYPE_NAME(working_type) = get_new_identifier(working_type);
    _reorg_map[t] = working_type;
    return;
  }

  tree f = (tree) fields_to_keep[0];
  tree tf = TREE_TYPE(f);
  bool field_type_in_reorg_map = _reorg_map.find(tf) != _reorg_map.end();
  if (field_type_in_reorg_map)
  {
    TREE_TYPE(f) = _reorg_map[tf];
  }
  TYPE_FIELDS((tree)working_type) = f;
  unsigned s = fields_to_keep.size();

  for (unsigned i = 1; i < s; i++)
  {
    tree current = (tree) fields_to_keep[i];
    tree tf = TREE_TYPE(current);
    field_type_in_reorg_map = _reorg_map.find(tf) != _reorg_map.end();
    if (field_type_in_reorg_map)
    {
      TREE_TYPE(current) = _reorg_map[tf];
    }
    DECL_CHAIN(f) = current;
    f = current;
  }

  layout_type(working_type);
  TYPE_NAME(working_type) = get_new_identifier(working_type);
  log("working type %s\n", working_type ? "t" : "f");
  _reorg_map[t] = working_type;
}



void
TypeReconstructor::_walk_field_pre(const_tree t)
{
  unsigned f_offset = tree_to_uhwi(DECL_FIELD_OFFSET(t));
  unsigned f_offset_2 = tree_to_uhwi(DECL_FIELD_BIT_OFFSET(t));
  unsigned f_offset_3 = f_offset * 8 + f_offset_2;
  field_offsets_t field_offsets = _record_stack.top();
  const bool should_be_deleted = field_offsets.find(f_offset_3) != field_offsets.end();
  const bool should_be_modified = _modifying.top();
  if (should_be_modified && should_be_deleted) {
	  type_vector_t &vec_ = _eliminated_fields.top();
	  vec_.push_back(t);
	  return;
  }

  // This is a field declaration, that should be saved.
  type_vector_t &vec = _field_decls.top();
  vec.push_back(copy_node((tree)t));
}

void
TypeReconstructor::_walk_field_post(const_tree t)
{
}