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"

void
TypeReconstructor::set_is_not_modified_yet(const_tree t)
{
  gcc_assert(t);
  const bool is_in_reorg_map = _reorg_map.find(t) != _reorg_map.end();
  modified_map[t] = false;

  const_tree tt = TREE_TYPE(t);
  if (!tt) return;

  const bool is_in_reorg_map_2 = _reorg_map.find(tt) != _reorg_map.end();
  log ("is in reorg_map_2 ? %s\n", is_in_reorg_map_2 ? "t" : "f");
  if (!is_in_reorg_map_2) return;

  tree type = _reorg_map[tt];
  const bool is_modified = strstr(TypeStringifier::get_type_identifier(type).c_str(), ".reorg");
  log("is modified %s\n", is_modified ? "t" : "f");
  if (!is_modified) return;

  mark_all_pointing_here_as_modified();

}

void
TypeReconstructor::mark_all_pointing_here_as_modified()
{
  for (auto i = modified_map.begin(), e = modified_map.end(); i != e; ++i)
  {
    const_tree type = i->first;
    i->second = true;
  }
}

bool
TypeReconstructor::get_is_modified(const_tree t)
{
  gcc_assert(t);
  const bool in_map = modified_map.find(t) != modified_map.end();
  gcc_assert(in_map);
  bool retval = modified_map[t];
  modified_map.erase(t);
  return retval;
}

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)
{
  for_reference.push(t);
  set_is_not_modified_yet(t);

  tree copy = build_variant_type_copy((tree) t);
  in_progress.push(copy);

}

void
TypeReconstructor::_walk_ARRAY_TYPE_post(const_tree t)
{
  const_tree t2 = for_reference.top();
  gcc_assert(t2 == t);
  for_reference.pop();
  tree copy = in_progress.top();
  in_progress.pop();

  bool is_modified = get_is_modified(t);

  copy = is_modified ? build_distinct_type_copy(copy) : copy;
  TREE_TYPE(copy) = is_modified ? _reorg_map[TREE_TYPE(t)] : TREE_TYPE(copy);
  TYPE_NAME(copy) = is_modified ? get_new_identifier(copy) : TYPE_NAME(copy);
  // This is useful so that we go again through type layout
  TYPE_SIZE(copy) = is_modified ? NULL : TYPE_SIZE(copy);
  if (is_modified) layout_type(copy);

  _reorg_map[t] = is_modified ? copy : (tree)t;
}

void
TypeReconstructor::_walk_POINTER_TYPE_pre(const_tree t)
{
  for_reference.push(t);
  set_is_not_modified_yet(t);

  tree copy = build_variant_type_copy((tree) t);
  in_progress.push(copy);
}

void
TypeReconstructor::_walk_POINTER_TYPE_post(const_tree t)
{
  const_tree t2 = for_reference.top();
  gcc_assert(t2 == t);
  for_reference.pop();
  tree copy = in_progress.top();
  in_progress.pop();

  bool is_modified = get_is_modified(t);

  copy = is_modified ? build_variant_type_copy(copy) : copy;
  TREE_TYPE(copy) = is_modified ? _reorg_map[TREE_TYPE(t)] : TREE_TYPE(copy);
  TYPE_NAME(copy) = is_modified ? get_new_identifier(copy) : TYPE_NAME(copy);
  // This is useful so that we go again through type layout
  TYPE_SIZE(copy) = is_modified ? NULL : TYPE_SIZE(copy);
  if (is_modified) layout_type(copy);
  
  _reorg_map[t] = is_modified ? copy : (tree)t;
}

void
TypeReconstructor::_walk_RECORD_TYPE_pre(const_tree t)
{
  set_is_not_modified_yet(t);
  for_reference.push(t);
  // We don't know if we will modify this type t
  // So, let's make a copy. Just in case.
  tree copy = build_variant_type_copy((tree) t);
  in_progress.push(copy);
  field_list_stack.push( field_tuple_list_t() );
}

void
TypeReconstructor::_walk_RECORD_TYPE_post(const_tree t)
{
  const_tree t2 = for_reference.top();
  gcc_assert(t2 == t);
  for_reference.pop();

  tree copy = in_progress.top();
  in_progress.pop();
  field_tuple_list_t field_tuple_list = field_list_stack.top();
  field_list_stack.pop();

  // So, here all the work has been done to make sure
  // that the fields produced a field_tuple_list_t
  // with old fields and pointers to new fields.
  // There might be NULL values if new fields are eliminated.
  // So, now we want to do a couple of things.
  // First, is we need to change the TYPE_FIELDS
  // of the copy
  tree prev_field = NULL;
  for (auto i = field_tuple_list.cbegin(), e = field_tuple_list.cend(); i != e; ++i)
  {
    field_tuple_t field_tuple = *i;
    const_tree original_field = field_tuple.first;
    tree modified_field = field_tuple.second;
    if (!modified_field) {
      continue;
    }

    tree current_field = modified_field;
    if (!prev_field) {
      TYPE_FIELDS(copy) = current_field;
    } else {
      DECL_CHAIN(prev_field) = current_field;
    }
    prev_field = current_field;
  }


  bool is_modified = get_is_modified(t);
  // Ok, so now that we have fixed the TYPE_FIELDS of the copy...
  // We need to call layout_type
  copy = is_modified ? build_distinct_type_copy(copy) : copy;
  TYPE_NAME(copy) = is_modified ? get_new_identifier(copy) : TYPE_NAME(copy);
  // This is useful so that we go again through type layout
  TYPE_SIZE(copy) = is_modified ? NULL : TYPE_SIZE(copy);
  if (is_modified) layout_type(copy);
  _reorg_map[t] = is_modified ? copy : (tree)t;

  /*
  if (for_reference.empty()) return;
  gcc_assert(!in_progress.empty());

  // Now we need to find out
  // if we are modifying something in the parent as well?
  const_tree possible_field = for_reference.top();
  const enum tree_code code = TREE_CODE(possible_field);
  const bool is_field = FIELD_DECL == code;
  if (!is_field) return;

  tree field_in_progress = in_progress.top();
  TREE_TYPE(field_in_progress) = copy;
  */
}

void
TypeReconstructor::_walk_UNION_TYPE_pre(const_tree t)
{
}

void
TypeReconstructor::_walk_UNION_TYPE_post(const_tree t)
{
}

void
TypeReconstructor::_walk_field_pre(const_tree t)
{
  for_reference.push(t);
  // We don't know if we will rewrite the field
  // that we are working on. So proactively, let's make
  // a copy
  tree copy = copy_node((tree) t);
  tree type_copy = build_variant_type_copy((tree)(TREE_TYPE(t)));
  TREE_TYPE(copy) = type_copy;
  // To communicate this field to the other methods,
  // let's put it in the "in_progress" stack.
  in_progress.push(copy);
}

void
TypeReconstructor::_walk_field_post(const_tree t)
{
  const_tree t2 = for_reference.top();
  gcc_assert(t2 == t);
  for_reference.pop();

  // Let's get the copy we were working on.
  tree copy = in_progress.top();
  // Let's put the stack in the same position...
  in_progress.pop();

  // What record does this field belongs to?
  const_tree record = for_reference.top();

  // Is this a record that has a field that might be deleted?
  const bool is_record_interesting = _records.find(record) != _records.end();
  if (!is_record_interesting) {
    return;
  }

  field_offsets_t field_offsets = _records[record];
  // What's the field offset?
  unsigned f_byte_offset = tree_to_uhwi(DECL_FIELD_OFFSET(t));
  unsigned f_bit_offset = tree_to_uhwi(DECL_FIELD_BIT_OFFSET(t));
  unsigned f_offset = 8 * f_byte_offset + f_bit_offset;

  const bool can_field_be_deleted = field_offsets.find(f_offset) != field_offsets.end();
  if (can_field_be_deleted) mark_all_pointing_here_as_modified();
  const_tree original_type = TREE_TYPE(t);
  const bool type_memoized = is_memoized(original_type);
  // here we did a modification

  TREE_TYPE(copy) = type_memoized ? _reorg_map[TREE_TYPE(t)] : TREE_TYPE(copy);
  field_tuple_t tuple = std::make_pair(t, can_field_be_deleted ? NULL : copy);

  // Put the field into the vector
  field_tuple_list_t &field_tuple_list = field_list_stack.top();
  field_tuple_list.push_back(tuple);
  _reorg_fields[t] = copy;
}