Quelle  constantTable.cpp   Sprache: C

/*
 * Copyright (c) 2020, 2022, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 *
 */

#include "precompiled.hpp"
#include "asm/codeBuffer.hpp"
#include "asm/macroAssembler.hpp"
#include "opto/block.hpp"
#include "opto/constantTable.hpp"
#include "opto/machnode.hpp"
#include "opto/output.hpp"

//=============================================================================
// Two Constant's are equal when the type and the value are equal.
bool ConstantTable::Constant::operator==(const Constant& other) {
  if (type()          != other.type()         )  return false;
  if (can_be_reused() != other.can_be_reused())  return false;
  if (is_array() || other.is_array()) {
    if (is_array() != other.is_array() ||
        get_array()->length() != other.get_array()->length()) {
      return false;
    }
    for (int i = 0; i < get_array()->length(); i++) {
      jvalue ele1 = get_array()->at(i);
      jvalue ele2 = other.get_array()->at(i);
      bool is_eq;
      switch (type()) {
        case T_BOOLEAN: is_eq = ele1.z == ele2.z; break;
        case T_BYTE:    is_eq = ele1.b == ele2.b; break;
        case T_CHAR:    is_eq = ele1.c == ele2.c; break;
        case T_SHORT:   is_eq = ele1.s == ele2.s; break;
        case T_INT:     is_eq = ele1.i == ele2.i; break;
        case T_LONG:    is_eq = ele1.j == ele2.j; break;
        case T_FLOAT:   is_eq = jint_cast(ele1.f)  == jint_cast(ele2.f);  break;
        case T_DOUBLE:  is_eq = jlong_cast(ele1.d) == jlong_cast(ele2.d); break;
        default: ShouldNotReachHere(); is_eq = false;
      }
      if (!is_eq) {
        return false;
      }
    }
    return true;
  }
  // For floating point values we compare the bit pattern.
  switch (type()) {
  case T_INT:     return (_v._value.i == other._v._value.i);
  case T_FLOAT:   return jint_cast(_v._value.f) == jint_cast(other._v._value.f);
  case T_LONG:    return (_v._value.j == other._v._value.j);
  case T_DOUBLE:  return jlong_cast(_v._value.d) == jlong_cast(other._v._value.d);
  case T_OBJECT:
  case T_ADDRESS: return (_v._value.l == other._v._value.l);
  case T_VOID:    return (_v._value.l == other._v._value.l);  // jump-table entries
  case T_METADATA: return (_v._metadata == other._v._metadata);
  default: ShouldNotReachHere(); return false;
  }
}

int ConstantTable::qsort_comparator(Constant* a, Constant* b) {
  // sort descending
  if (a->freq() > b->freq())  return -1;
  if (a->freq() < b->freq())  return  1;
  return 0;
}

static int constant_size(ConstantTable::Constant* con) {
  if (con->is_array()) {
    return type2aelembytes(con->type()) * con->get_array()->length();
  }
  switch (con->type()) {
  case T_INT:     return sizeof(jint   );
  case T_LONG:    return sizeof(jlong  );
  case T_FLOAT:   return sizeof(jfloat );
  case T_DOUBLE:  return sizeof(jdouble);
  case T_METADATA: return sizeof(Metadata*);
    // We use T_VOID as marker for jump-table entries (labels) which
    // need an internal word relocation.
  case T_VOID:
  case T_ADDRESS:
  case T_OBJECT:  return sizeof(jobject);
  default:
    ShouldNotReachHere();
    return -1;
  }
}

void ConstantTable::calculate_offsets_and_size() {
  // First, sort the array by frequencies.
  _constants.sort(qsort_comparator);

#ifdef ASSERT
  // Make sure all jump-table entries were sorted to the end of the
  // array (they have a negative frequency).
  bool found_void = false;
  for (int i = 0; i < _constants.length(); i++) {
    Constant con = _constants.at(i);
    if (con.type() == T_VOID)
      found_void = true;  // jump-tables
    else
      assert(!found_void, "wrong sorting");
  }
#endif

  int offset = 0;
  for (int i = 0; i < _constants.length(); i++) {
    Constant* con = _constants.adr_at(i);

    // Align offset for type.
    int typesize = constant_size(con);
    assert(typesize <= 8 || con->is_array(), "sanity");
    offset = align_up(offset, con->alignment());
    con->set_offset(offset);   // set constant's offset

    if (con->type() == T_VOID) {
      MachConstantNode* n = (MachConstantNode*) con->get_jobject();
      offset = offset + typesize * n->outcnt();  // expand jump-table
    } else {
      offset = offset + typesize;
    }
  }

  // Align size up to the next section start (which is insts; see
  // CodeBuffer::align_at_start).
  assert(_size == -1, "already set?");
  _size = align_up(offset, (int)CodeEntryAlignment);
}

bool ConstantTable::emit(CodeBuffer& cb) const {
  MacroAssembler _masm(&cb);
  for (int i = 0; i < _constants.length(); i++) {
    Constant con = _constants.at(i);
    address constant_addr = NULL;
    if (con.is_array()) {
      constant_addr = _masm.array_constant(con.type(), con.get_array(), con.alignment());
    } else {
      switch (con.type()) {
      case T_INT:    constant_addr = _masm.int_constant(   con.get_jint()   ); break;
      case T_LONG:   constant_addr = _masm.long_constant(  con.get_jlong()  ); break;
      case T_FLOAT:  constant_addr = _masm.float_constant( con.get_jfloat() ); break;
      case T_DOUBLE: constant_addr = _masm.double_constant(con.get_jdouble()); break;
      case T_OBJECT: {
        jobject obj = con.get_jobject();
        int oop_index = _masm.oop_recorder()->find_index(obj);
        constant_addr = _masm.address_constant((address) obj, oop_Relocation::spec(oop_index));
        break;
      }
      case T_ADDRESS: {
        address addr = (address) con.get_jobject();
        constant_addr = _masm.address_constant(addr);
        break;
      }
      // We use T_VOID as marker for jump-table entries (labels) which
      // need an internal word relocation.
      case T_VOID: {
        MachConstantNode* n = (MachConstantNode*) con.get_jobject();
        // Fill the jump-table with a dummy word.  The real value is
        // filled in later in fill_jump_table.
        address dummy = (address) n;
        constant_addr = _masm.address_constant(dummy);
        if (constant_addr == NULL) {
          return false;
        }
        assert((constant_addr - _masm.code()->consts()->start()) == con.offset(),
              "must be: %d == %d", (int)(constant_addr - _masm.code()->consts()->start()), (int)(con.offset()));

        // Expand jump-table
        address last_addr = NULL;
        for (uint j = 1; j < n->outcnt(); j++) {
          last_addr = _masm.address_constant(dummy + j);
          if (last_addr == NULL) {
            return false;
          }
        }
#ifdef ASSERT
        address start = _masm.code()->consts()->start();
        address new_constant_addr = last_addr - ((n->outcnt() - 1) * sizeof(address));
        // Expanding the jump-table could result in an expansion of the const code section.
        // In that case, we need to check if the new constant address matches the offset.
        assert((constant_addr - start == con.offset()) || (new_constant_addr - start == con.offset()),
              "must be: %d == %d or %d == %d (after an expansion)", (int)(constant_addr - start), (int)(con.offset()),
              (int)(new_constant_addr - start), (int)(con.offset()));
#endif
        continue; // Loop
      }
      case T_METADATA: {
        Metadata* obj = con.get_metadata();
        int metadata_index = _masm.oop_recorder()->find_index(obj);
        constant_addr = _masm.address_constant((address) obj, metadata_Relocation::spec(metadata_index));
        break;
      }
      default: ShouldNotReachHere();
      }
    }

    if (constant_addr == NULL) {
      return false;
    }
    assert((constant_addr - _masm.code()->consts()->start()) == con.offset(),
            "must be: %d == %d", (int)(constant_addr - _masm.code()->consts()->start()), (int)(con.offset()));
  }
  return true;
}

int ConstantTable::find_offset(Constant& con) const {
  int idx = _constants.find(con);
  guarantee(idx != -1, "constant must be in constant table");
  int offset = _constants.at(idx).offset();
  guarantee(offset != -1, "constant table not emitted yet?");
  return offset;
}

void ConstantTable::add(Constant& con) {
  if (con.can_be_reused()) {
    int idx = _constants.find(con);
    if (idx != -1 && _constants.at(idx).can_be_reused()) {
      _constants.adr_at(idx)->inc_freq(con.freq());  // increase the frequency by the current value
      return;
    }
  }
  (void) _constants.append(con);
}

ConstantTable::Constant ConstantTable::add(MachConstantNode* n, BasicType type, jvalue value) {
  Block* b = Compile::current()->cfg()->get_block_for_node(n);
  Constant con(type, value, b->_freq);
  add(con);
  return con;
}

ConstantTable::Constant ConstantTable::add(Metadata* metadata) {
  Constant con(metadata);
  add(con);
  return con;
}

ConstantTable::Constant ConstantTable::add(MachConstantNode* n, BasicType bt,
                                           GrowableArray<jvalue>* array, int alignment) {
  Constant con(bt, array, alignment);
  add(con);
  return con;
}

ConstantTable::Constant ConstantTable::add(MachConstantNode* n, BasicType bt,
                                           GrowableArray<jvalue>* array) {
  return add(n, bt, array, array->length() * type2aelembytes(bt));
}

ConstantTable::Constant ConstantTable::add(MachConstantNode* n, MachOper* oper) {
  jvalue value;
  BasicType type = oper->type()->basic_type();
  switch (type) {
  case T_LONG:    value.j = oper->constantL(); break;
  case T_FLOAT:   value.f = oper->constantF(); break;
  case T_DOUBLE:  value.d = oper->constantD(); break;
  case T_OBJECT:
  case T_ADDRESS: value.l = (jobject) oper->constant(); break;
  case T_METADATA: return add((Metadata*)oper->constant()); break;
  default: guarantee(false, "unhandled type: %s", type2name(type));
  }
  return add(n, type, value);
}

ConstantTable::Constant ConstantTable::add_jump_table(MachConstantNode* n) {
  jvalue value;
  // We can use the node pointer here to identify the right jump-table
  // as this method is called from Compile::Fill_buffer right before
  // the MachNodes are emitted and the jump-table is filled (means the
  // MachNode pointers do not change anymore).
  value.l = (jobject) n;
  Constant con(T_VOID, value, next_jump_table_freq(), false);  // Labels of a jump-table cannot be reused.
  add(con);
  return con;
}

void ConstantTable::fill_jump_table(CodeBuffer& cb, MachConstantNode* n, GrowableArray<Label*> labels) const {
  // If called from Compile::scratch_emit_size do nothing.
  if (Compile::current()->output()->in_scratch_emit_size())  return;

  assert(labels.is_nonempty(), "must be");
  assert((uint) labels.length() == n->outcnt(), "must be equal: %d == %d", labels.length(), n->outcnt());

  // Since MachConstantNode::constant_offset() also contains
  // table_base_offset() we need to subtract the table_base_offset()
  // to get the plain offset into the constant table.
  int offset = n->constant_offset() - table_base_offset();

  MacroAssembler _masm(&cb);
  address* jump_table_base = (address*) (_masm.code()->consts()->start() + offset);

  for (uint i = 0; i < n->outcnt(); i++) {
    address* constant_addr = &jump_table_base[i];
    assert(*constant_addr == (((address) n) + i), "all jump-table entries must contain adjusted node pointer: " INTPTR_FORMAT " == " INTPTR_FORMAT, p2i(*constant_addr), p2i(((address) n) + i));
    *constant_addr = cb.consts()->target(*labels.at(i), (address) constant_addr);
    cb.consts()->relocate((address) constant_addr, relocInfo::internal_word_type);
  }
}