/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1

Bug Summary

File:	jdk/src/hotspot/share/c1/c1_Instruction.hpp
Warning:	line 1067, column 55 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name c1_GraphBuilder.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mthread-model posix -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/hotspot/variant-server/libjvm/objs/precompiled -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D _GNU_SOURCE -D _REENTRANT -D LIBC=gnu -D LINUX -D VM_LITTLE_ENDIAN -D _LP64=1 -D ASSERT -D CHECK_UNHANDLED_OOPS -D TARGET_ARCH_x86 -D INCLUDE_SUFFIX_OS=_linux -D INCLUDE_SUFFIX_CPU=_x86 -D INCLUDE_SUFFIX_COMPILER=_gcc -D TARGET_COMPILER_gcc -D AMD64 -D HOTSPOT_LIB_ARCH="amd64" -D COMPILER1 -D COMPILER2 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/hotspot/variant-server/gensrc/adfiles -I /home/daniel/Projects/java/jdk/src/hotspot/share -I /home/daniel/Projects/java/jdk/src/hotspot/os/linux -I /home/daniel/Projects/java/jdk/src/hotspot/os/posix -I /home/daniel/Projects/java/jdk/src/hotspot/cpu/x86 -I /home/daniel/Projects/java/jdk/src/hotspot/os_cpu/linux_x86 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/hotspot/variant-server/gensrc -I /home/daniel/Projects/java/jdk/src/hotspot/share/precompiled -I /home/daniel/Projects/java/jdk/src/hotspot/share/include -I /home/daniel/Projects/java/jdk/src/hotspot/os/posix/include -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base/linux -I /home/daniel/Projects/java/jdk/src/java.base/share/native/libjimage -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/hotspot/variant-server/gensrc/adfiles -I /home/daniel/Projects/java/jdk/src/hotspot/share -I /home/daniel/Projects/java/jdk/src/hotspot/os/linux -I /home/daniel/Projects/java/jdk/src/hotspot/os/posix -I /home/daniel/Projects/java/jdk/src/hotspot/cpu/x86 -I /home/daniel/Projects/java/jdk/src/hotspot/os_cpu/linux_x86 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/hotspot/variant-server/gensrc -D _FORTIFY_SOURCE=2 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/c++/7.5.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/x86_64-linux-gnu/c++/7.5.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/x86_64-linux-gnu/c++/7.5.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/c++/7.5.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-format-zero-length -Wno-unused-parameter -Wno-unused -Wno-parentheses -Wno-comment -Wno-unknown-pragmas -Wno-address -Wno-delete-non-virtual-dtor -Wno-char-subscripts -Wno-array-bounds -Wno-int-in-bool-context -Wno-ignored-qualifiers -Wno-missing-field-initializers -Wno-implicit-fallthrough -Wno-empty-body -Wno-strict-overflow -Wno-sequence-point -Wno-maybe-uninitialized -Wno-misleading-indentation -Wno-cast-function-type -Wno-shift-negative-value -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /home/daniel/Projects/java/jdk/make/hotspot -ferror-limit 19 -fmessage-length 0 -fvisibility hidden -stack-protector 1 -fno-rtti -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -o /home/daniel/Projects/java/scan/2021-12-21-193737-8510-1 -x c++ /home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp

/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp

→

1/*
* Copyright (c) 1999, 2021, 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.
*
*/

25#include "precompiled.hpp"
26#include "c1/c1_CFGPrinter.hpp"
27#include "c1/c1_Canonicalizer.hpp"
28#include "c1/c1_Compilation.hpp"
29#include "c1/c1_GraphBuilder.hpp"
30#include "c1/c1_InstructionPrinter.hpp"
31#include "ci/ciCallSite.hpp"
32#include "ci/ciField.hpp"
33#include "ci/ciKlass.hpp"
34#include "ci/ciMemberName.hpp"
35#include "ci/ciSymbols.hpp"
36#include "ci/ciUtilities.inline.hpp"
37#include "compiler/compilationPolicy.hpp"
38#include "compiler/compileBroker.hpp"
39#include "compiler/compilerEvent.hpp"
40#include "interpreter/bytecode.hpp"
41#include "jfr/jfrEvents.hpp"
42#include "memory/resourceArea.hpp"
43#include "oops/oop.inline.hpp"
44#include "runtime/sharedRuntime.hpp"
45#include "runtime/vm_version.hpp"
46#include "utilities/bitMap.inline.hpp"
47#include "utilities/powerOfTwo.hpp"

49class BlockListBuilder {
private:
Compilation* _compilation;
IRScope*     _scope;

BlockList    _blocks;                // internal list of all blocks
BlockList*   _bci2block;             // mapping from bci to blocks for GraphBuilder
GrowableArray<BlockList> _bci2block_successors; // Mapping bcis to their blocks successors while we dont have a blockend

// fields used by mark_loops
ResourceBitMap _active;              // for iteration of control flow graph
ResourceBitMap _visited;             // for iteration of control flow graph
intArray       _loop_map;            // caches the information if a block is contained in a loop
int            _next_loop_index;     // next free loop number
int            _next_block_number;   // for reverse postorder numbering of blocks

// accessors
Compilation*  compilation() const              { return _compilation; }
IRScope*      scope() const                    { return _scope; }
ciMethod*     method() const                   { return scope()->method(); }
XHandlers*    xhandlers() const                { return scope()->xhandlers(); }

// unified bailout support
void          bailout(const char* msg) const   { compilation()->bailout(msg); }
bool          bailed_out() const               { return compilation()->bailed_out(); }

// helper functions
BlockBegin* make_block_at(int bci, BlockBegin* predecessor);
void handle_exceptions(BlockBegin* current, int cur_bci);
void handle_jsr(BlockBegin* current, int sr_bci, int next_bci);
void store_one(BlockBegin* current, int local);
void store_two(BlockBegin* current, int local);
void set_entries(int osr_bci);
void set_leaders();

void make_loop_header(BlockBegin* block);
void mark_loops();
int  mark_loops(BlockBegin* b, bool in_subroutine);

// debugging
89#ifndef PRODUCT
void print();
91#endif

int number_of_successors(BlockBegin* block);
BlockBegin* successor_at(BlockBegin* block, int i);
void add_successor(BlockBegin* block, BlockBegin* sux);
bool is_successor(BlockBegin* block, BlockBegin* sux);

public:
// creation
BlockListBuilder(Compilation* compilation, IRScope* scope, int osr_bci);

// accessors for GraphBuilder
BlockList*    bci2block() const                { return _bci2block; }
104};


107// Implementation of BlockListBuilder

109BlockListBuilder::BlockListBuilder(Compilation* compilation, IRScope* scope, int osr_bci)
: _compilation(compilation)
, _scope(scope)
, _blocks(16)
, _bci2block(new BlockList(scope->method()->code_size(), NULL__null))
, _bci2block_successors(scope->method()->code_size())
, _active()         // size not known yet
, _visited()        // size not known yet
, _loop_map() // size not known yet
, _next_loop_index(0)
, _next_block_number(0)
120{
set_entries(osr_bci);
set_leaders();
CHECK_BAILOUT(){ if (bailed_out()) return; };

mark_loops();
NOT_PRODUCT(if (PrintInitialBlockList) print())if (PrintInitialBlockList) print();

// _bci2block still contains blocks with _end == null and > 0 sux in _bci2block_successors.

130#ifndef PRODUCT
if (PrintCFGToFile) {
  stringStream title;
  title.print("BlockListBuilder ");
  scope->method()->print_name(&title);
  CFGPrinter::print_cfg(_bci2block, title.as_string(), false, false);
}
137#endif
138}


141void BlockListBuilder::set_entries(int osr_bci) {
// generate start blocks
BlockBegin* std_entry = make_block_at(0, NULL__null);
if (scope()->caller() == NULL__null) {
  std_entry->set(BlockBegin::std_entry_flag);
}
if (osr_bci != -1) {
  BlockBegin* osr_entry = make_block_at(osr_bci, NULL__null);
  osr_entry->set(BlockBegin::osr_entry_flag);
}

// generate exception entry blocks
XHandlers* list = xhandlers();
const int n = list->length();
for (int i = 0; i < n; i++) {
  XHandler* h = list->handler_at(i);
  BlockBegin* entry = make_block_at(h->handler_bci(), NULL__null);
  entry->set(BlockBegin::exception_entry_flag);
  h->set_entry_block(entry);
}
161}


164BlockBegin* BlockListBuilder::make_block_at(int cur_bci, BlockBegin* predecessor) {
assert(method()->bci_block_start().at(cur_bci), "wrong block starts of MethodLivenessAnalyzer")do { if (!(method()->bci_block_start().at(cur_bci))) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 165, "assert(" "method()->bci_block_start().at(cur_bci)"
 ") failed", "wrong block starts of MethodLivenessAnalyzer");
 ::breakpoint(); } } while (0);

BlockBegin* block = _bci2block->at(cur_bci);
if (block == NULL__null) {
  block = new BlockBegin(cur_bci);
  block->init_stores_to_locals(method()->max_locals());
  _bci2block->at_put(cur_bci, block);
  _bci2block_successors.at_put_grow(cur_bci, BlockList());
  _blocks.append(block);

  assert(predecessor == NULL || predecessor->bci() < cur_bci, "targets for backward branches must already exist")do { if (!(predecessor == __null || predecessor->bci() <
 cur_bci)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 175, "assert(" "predecessor == __null || predecessor->bci() < cur_bci"
 ") failed", "targets for backward branches must already exist"
); ::breakpoint(); } } while (0);
}

if (predecessor != NULL__null) {
  if (block->is_set(BlockBegin::exception_entry_flag)) {
    BAILOUT_("Exception handler can be reached by both normal and exceptional control flow", block){ bailout("Exception handler can be reached by both normal and exceptional control flow"
); return block; };
  }

  add_successor(predecessor, block);
  block->increment_total_preds();
}

return block;
188}


191inline void BlockListBuilder::store_one(BlockBegin* current, int local) {
current->stores_to_locals().set_bit(local);
193}
194inline void BlockListBuilder::store_two(BlockBegin* current, int local) {
store_one(current, local);
store_one(current, local + 1);
197}


200void BlockListBuilder::handle_exceptions(BlockBegin* current, int cur_bci) {
// Draws edges from a block to its exception handlers
XHandlers* list = xhandlers();
const int n = list->length();

for (int i = 0; i < n; i++) {
  XHandler* h = list->handler_at(i);

  if (h->covers(cur_bci)) {
    BlockBegin* entry = h->entry_block();
    assert(entry != NULL && entry == _bci2block->at(h->handler_bci()), "entry must be set")do { if (!(entry != __null && entry == _bci2block->
at(h->handler_bci()))) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 210, "assert(" "entry != __null && entry == _bci2block->at(h->handler_bci())"
 ") failed", "entry must be set"); ::breakpoint(); } } while (
0);
    assert(entry->is_set(BlockBegin::exception_entry_flag), "flag must be set")do { if (!(entry->is_set(BlockBegin::exception_entry_flag)
)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 211, "assert(" "entry->is_set(BlockBegin::exception_entry_flag)"
 ") failed", "flag must be set"); ::breakpoint(); } } while (
0);

    // add each exception handler only once
    if(!is_successor(current, entry)) {
      add_successor(current, entry);
      entry->increment_total_preds();
    }

    // stop when reaching catchall
    if (h->catch_type() == 0) break;
  }
}
223}

225void BlockListBuilder::handle_jsr(BlockBegin* current, int sr_bci, int next_bci) {
// start a new block after jsr-bytecode and link this block into cfg
make_block_at(next_bci, current);

// start a new block at the subroutine entry at mark it with special flag
BlockBegin* sr_block = make_block_at(sr_bci, current);
if (!sr_block->is_set(BlockBegin::subroutine_entry_flag)) {
  sr_block->set(BlockBegin::subroutine_entry_flag);
}
234}


237void BlockListBuilder::set_leaders() {
bool has_xhandlers = xhandlers()->has_handlers();
BlockBegin* current = NULL__null;

// The information which bci starts a new block simplifies the analysis
// Without it, backward branches could jump to a bci where no block was created
// during bytecode iteration. This would require the creation of a new block at the
// branch target and a modification of the successor lists.
const BitMap& bci_block_start = method()->bci_block_start();

ciBytecodeStream s(method());
while (s.next() != ciBytecodeStream::EOBC()) {
  int cur_bci = s.cur_bci();

  if (bci_block_start.at(cur_bci)) {
    current = make_block_at(cur_bci, current);
  }
  assert(current != NULL, "must have current block")do { if (!(current != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 254, "assert(" "current != __null" ") failed", "must have current block"
); ::breakpoint(); } } while (0);

  if (has_xhandlers && GraphBuilder::can_trap(method(), s.cur_bc())) {
    handle_exceptions(current, cur_bci);
  }

  switch (s.cur_bc()) {
    // track stores to local variables for selective creation of phi functions
    case Bytecodes::_iinc:     store_one(current, s.get_index()); break;
    case Bytecodes::_istore:   store_one(current, s.get_index()); break;
    case Bytecodes::_lstore:   store_two(current, s.get_index()); break;
    case Bytecodes::_fstore:   store_one(current, s.get_index()); break;
    case Bytecodes::_dstore:   store_two(current, s.get_index()); break;
    case Bytecodes::_astore:   store_one(current, s.get_index()); break;
    case Bytecodes::_istore_0: store_one(current, 0); break;
    case Bytecodes::_istore_1: store_one(current, 1); break;
    case Bytecodes::_istore_2: store_one(current, 2); break;
    case Bytecodes::_istore_3: store_one(current, 3); break;
    case Bytecodes::_lstore_0: store_two(current, 0); break;
    case Bytecodes::_lstore_1: store_two(current, 1); break;
    case Bytecodes::_lstore_2: store_two(current, 2); break;
    case Bytecodes::_lstore_3: store_two(current, 3); break;
    case Bytecodes::_fstore_0: store_one(current, 0); break;
    case Bytecodes::_fstore_1: store_one(current, 1); break;
    case Bytecodes::_fstore_2: store_one(current, 2); break;
    case Bytecodes::_fstore_3: store_one(current, 3); break;
    case Bytecodes::_dstore_0: store_two(current, 0); break;
    case Bytecodes::_dstore_1: store_two(current, 1); break;
    case Bytecodes::_dstore_2: store_two(current, 2); break;
    case Bytecodes::_dstore_3: store_two(current, 3); break;
    case Bytecodes::_astore_0: store_one(current, 0); break;
    case Bytecodes::_astore_1: store_one(current, 1); break;
    case Bytecodes::_astore_2: store_one(current, 2); break;
    case Bytecodes::_astore_3: store_one(current, 3); break;

    // track bytecodes that affect the control flow
    case Bytecodes::_athrow:  // fall through
    case Bytecodes::_ret:     // fall through
    case Bytecodes::_ireturn: // fall through
    case Bytecodes::_lreturn: // fall through
    case Bytecodes::_freturn: // fall through
    case Bytecodes::_dreturn: // fall through
    case Bytecodes::_areturn: // fall through
    case Bytecodes::_return:
      current = NULL__null;
      break;

    case Bytecodes::_ifeq:      // fall through
    case Bytecodes::_ifne:      // fall through
    case Bytecodes::_iflt:      // fall through
    case Bytecodes::_ifge:      // fall through
    case Bytecodes::_ifgt:      // fall through
    case Bytecodes::_ifle:      // fall through
    case Bytecodes::_if_icmpeq: // fall through
    case Bytecodes::_if_icmpne: // fall through
    case Bytecodes::_if_icmplt: // fall through
    case Bytecodes::_if_icmpge: // fall through
    case Bytecodes::_if_icmpgt: // fall through
    case Bytecodes::_if_icmple: // fall through
    case Bytecodes::_if_acmpeq: // fall through
    case Bytecodes::_if_acmpne: // fall through
    case Bytecodes::_ifnull:    // fall through
    case Bytecodes::_ifnonnull:
      make_block_at(s.next_bci(), current);
      make_block_at(s.get_dest(), current);
      current = NULL__null;
      break;

    case Bytecodes::_goto:
      make_block_at(s.get_dest(), current);
      current = NULL__null;
      break;

    case Bytecodes::_goto_w:
      make_block_at(s.get_far_dest(), current);
      current = NULL__null;
      break;

    case Bytecodes::_jsr:
      handle_jsr(current, s.get_dest(), s.next_bci());
      current = NULL__null;
      break;

    case Bytecodes::_jsr_w:
      handle_jsr(current, s.get_far_dest(), s.next_bci());
      current = NULL__null;
      break;

    case Bytecodes::_tableswitch: {
      // set block for each case
      Bytecode_tableswitch sw(&s);
      int l = sw.length();
      for (int i = 0; i < l; i++) {
        make_block_at(cur_bci + sw.dest_offset_at(i), current);
      }
      make_block_at(cur_bci + sw.default_offset(), current);
      current = NULL__null;
      break;
    }

    case Bytecodes::_lookupswitch: {
      // set block for each case
      Bytecode_lookupswitch sw(&s);
      int l = sw.number_of_pairs();
      for (int i = 0; i < l; i++) {
        make_block_at(cur_bci + sw.pair_at(i).offset(), current);
      }
      make_block_at(cur_bci + sw.default_offset(), current);
      current = NULL__null;
      break;
    }

    default:
      break;
  }
}
370}


373void BlockListBuilder::mark_loops() {
ResourceMark rm;

_active.initialize(BlockBegin::number_of_blocks());
_visited.initialize(BlockBegin::number_of_blocks());
_loop_map = intArray(BlockBegin::number_of_blocks(), BlockBegin::number_of_blocks(), 0);
_next_loop_index = 0;
_next_block_number = _blocks.length();

// recursively iterate the control flow graph
mark_loops(_bci2block->at(0), false);
assert(_next_block_number >= 0, "invalid block numbers")do { if (!(_next_block_number >= 0)) { (*g_assert_poison) =
 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 384, "assert(" "_next_block_number >= 0" ") failed", "invalid block numbers"
); ::breakpoint(); } } while (0);

// Remove dangling Resource pointers before the ResourceMark goes out-of-scope.
_active.resize(0);
_visited.resize(0);
389}

391void BlockListBuilder::make_loop_header(BlockBegin* block) {
if (block->is_set(BlockBegin::exception_entry_flag)) {
  // exception edges may look like loops but don't mark them as such
  // since it screws up block ordering.
  return;
}
if (!block->is_set(BlockBegin::parser_loop_header_flag)) {
  block->set(BlockBegin::parser_loop_header_flag);

  assert(_loop_map.at(block->block_id()) == 0, "must not be set yet")do { if (!(_loop_map.at(block->block_id()) == 0)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 400, "assert(" "_loop_map.at(block->block_id()) == 0" ") failed"
, "must not be set yet"); ::breakpoint(); } } while (0);
  assert(0 <= _next_loop_index && _next_loop_index < BitsPerInt, "_next_loop_index is used as a bit-index in integer")do { if (!(0 <= _next_loop_index && _next_loop_index
 < BitsPerInt)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 401, "assert(" "0 <= _next_loop_index && _next_loop_index < BitsPerInt"
 ") failed", "_next_loop_index is used as a bit-index in integer"
); ::breakpoint(); } } while (0);
  _loop_map.at_put(block->block_id(), 1 << _next_loop_index);
  if (_next_loop_index < 31) _next_loop_index++;
} else {
  // block already marked as loop header
  assert(is_power_of_2((unsigned int)_loop_map.at(block->block_id())), "exactly one bit must be set")do { if (!(is_power_of_2((unsigned int)_loop_map.at(block->
block_id())))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 406, "assert(" "is_power_of_2((unsigned int)_loop_map.at(block->block_id()))"
 ") failed", "exactly one bit must be set"); ::breakpoint(); }
 } while (0);
}
408}

410int BlockListBuilder::mark_loops(BlockBegin* block, bool in_subroutine) {
int block_id = block->block_id();

if (_visited.at(block_id)) {
  if (_active.at(block_id)) {
    // reached block via backward branch
    make_loop_header(block);
  }
  // return cached loop information for this block
  return _loop_map.at(block_id);
}

if (block->is_set(BlockBegin::subroutine_entry_flag)) {
  in_subroutine = true;
}

// set active and visited bits before successors are processed
_visited.set_bit(block_id);
_active.set_bit(block_id);

intptr_t loop_state = 0;
for (int i = number_of_successors(block) - 1; i >= 0; i--) {
  // recursively process all successors
  loop_state |= mark_loops(successor_at(block, i), in_subroutine);
}

// clear active-bit after all successors are processed
_active.clear_bit(block_id);

// reverse-post-order numbering of all blocks
block->set_depth_first_number(_next_block_number);
_next_block_number--;

if (loop_state != 0 || in_subroutine ) {
  // block is contained at least in one loop, so phi functions are necessary
  // phi functions are also necessary for all locals stored in a subroutine
  scope()->requires_phi_function().set_union(block->stores_to_locals());
}

if (block->is_set(BlockBegin::parser_loop_header_flag)) {
  int header_loop_state = _loop_map.at(block_id);
  assert(is_power_of_2((unsigned)header_loop_state), "exactly one bit must be set")do { if (!(is_power_of_2((unsigned)header_loop_state))) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 451, "assert(" "is_power_of_2((unsigned)header_loop_state)"
 ") failed", "exactly one bit must be set"); ::breakpoint(); }
 } while (0);

  // If the highest bit is set (i.e. when integer value is negative), the method
  // has 32 or more loops. This bit is never cleared because it is used for multiple loops
  if (header_loop_state >= 0) {
    clear_bits(loop_state, header_loop_state);
  }
}

// cache and return loop information for this block
_loop_map.at_put(block_id, loop_state);
return loop_state;
463}

465inline int BlockListBuilder::number_of_successors(BlockBegin* block)
466{
assert(_bci2block_successors.length() > block->bci(), "sux must exist")do { if (!(_bci2block_successors.length() > block->bci(
))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 467, "assert(" "_bci2block_successors.length() > block->bci()"
 ") failed", "sux must exist"); ::breakpoint(); } } while (0);
return _bci2block_successors.at(block->bci()).length();
469}

471inline BlockBegin* BlockListBuilder::successor_at(BlockBegin* block, int i)
472{
assert(_bci2block_successors.length() > block->bci(), "sux must exist")do { if (!(_bci2block_successors.length() > block->bci(
))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 473, "assert(" "_bci2block_successors.length() > block->bci()"
 ") failed", "sux must exist"); ::breakpoint(); } } while (0);
return _bci2block_successors.at(block->bci()).at(i);
475}

477inline void BlockListBuilder::add_successor(BlockBegin* block, BlockBegin* sux)
478{
assert(_bci2block_successors.length() > block->bci(), "sux must exist")do { if (!(_bci2block_successors.length() > block->bci(
))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 479, "assert(" "_bci2block_successors.length() > block->bci()"
 ") failed", "sux must exist"); ::breakpoint(); } } while (0);
_bci2block_successors.at(block->bci()).append(sux);
481}

483inline bool BlockListBuilder::is_successor(BlockBegin* block, BlockBegin* sux) {
assert(_bci2block_successors.length() > block->bci(), "sux must exist")do { if (!(_bci2block_successors.length() > block->bci(
))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 484, "assert(" "_bci2block_successors.length() > block->bci()"
 ") failed", "sux must exist"); ::breakpoint(); } } while (0);
return _bci2block_successors.at(block->bci()).contains(sux);
486}

488#ifndef PRODUCT

490int compare_depth_first(BlockBegin** a, BlockBegin** b) {
return (*a)->depth_first_number() - (*b)->depth_first_number();
492}

494void BlockListBuilder::print() {
tty->print("----- initial block list of BlockListBuilder for method ");
method()->print_short_name();
tty->cr();

// better readability if blocks are sorted in processing order
_blocks.sort(compare_depth_first);

for (int i = 0; i < _blocks.length(); i++) {
  BlockBegin* cur = _blocks.at(i);
  tty->print("%4d: B%-4d bci: %-4d  preds: %-4d ", cur->depth_first_number(), cur->block_id(), cur->bci(), cur->total_preds());

  tty->print(cur->is_set(BlockBegin::std_entry_flag)               ? " std" : "    ");
  tty->print(cur->is_set(BlockBegin::osr_entry_flag)               ? " osr" : "    ");
  tty->print(cur->is_set(BlockBegin::exception_entry_flag)         ? " ex" : "   ");
  tty->print(cur->is_set(BlockBegin::subroutine_entry_flag)        ? " sr" : "   ");
  tty->print(cur->is_set(BlockBegin::parser_loop_header_flag)      ? " lh" : "   ");

  if (number_of_successors(cur) > 0) {
    tty->print("    sux: ");
    for (int j = 0; j < number_of_successors(cur); j++) {
      BlockBegin* sux = successor_at(cur, j);
      tty->print("B%d ", sux->block_id());
    }
  }
  tty->cr();
}
521}

523#endif


526// A simple growable array of Values indexed by ciFields
527class FieldBuffer: public CompilationResourceObj {
private:
GrowableArray<Value> _values;

public:
FieldBuffer() {}

void kill() {
  _values.trunc_to(0);
}

Value at(ciField* field) {
  assert(field->holder()->is_loaded(), "must be a loaded field")do { if (!(field->holder()->is_loaded())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 539, "assert(" "field->holder()->is_loaded()" ") failed"
, "must be a loaded field"); ::breakpoint(); } } while (0);
  int offset = field->offset();
  if (offset < _values.length()) {
    return _values.at(offset);
  } else {
    return NULL__null;
  }
}

void at_put(ciField* field, Value value) {
  assert(field->holder()->is_loaded(), "must be a loaded field")do { if (!(field->holder()->is_loaded())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 549, "assert(" "field->holder()->is_loaded()" ") failed"
, "must be a loaded field"); ::breakpoint(); } } while (0);
  int offset = field->offset();
  _values.at_put_grow(offset, value, NULL__null);
}

554};


557// MemoryBuffer is fairly simple model of the current state of memory.
558// It partitions memory into several pieces.  The first piece is
559// generic memory where little is known about the owner of the memory.
560// This is conceptually represented by the tuple <O, F, V> which says
561// that the field F of object O has value V.  This is flattened so
562// that F is represented by the offset of the field and the parallel
563// arrays _objects and _values are used for O and V.  Loads of O.F can
564// simply use V.  Newly allocated objects are kept in a separate list
565// along with a parallel array for each object which represents the
566// current value of its fields.  Stores of the default value to fields
567// which have never been stored to before are eliminated since they
568// are redundant.  Once newly allocated objects are stored into
569// another object or they are passed out of the current compile they
570// are treated like generic memory.

572class MemoryBuffer: public CompilationResourceObj {
private:
FieldBuffer                 _values;
GrowableArray<Value>        _objects;
GrowableArray<Value>        _newobjects;
GrowableArray<FieldBuffer*> _fields;

public:
MemoryBuffer() {}

StoreField* store(StoreField* st) {
  if (!EliminateFieldAccess) {
    return st;
  }

  Value object = st->obj();
  Value value = st->value();
  ciField* field = st->field();
  if (field->holder()->is_loaded()) {
    int offset = field->offset();
    int index = _newobjects.find(object);
    if (index != -1) {
      // newly allocated object with no other stores performed on this field
      FieldBuffer* buf = _fields.at(index);
      if (buf->at(field) == NULL__null && is_default_value(value)) {
597#ifndef PRODUCT
        if (PrintIRDuringConstruction && Verbose) {
          tty->print_cr("Eliminated store for object %d:", index);
          st->print_line();
        }
602#endif
        return NULL__null;
      } else {
        buf->at_put(field, value);
      }
    } else {
      _objects.at_put_grow(offset, object, NULL__null);
      _values.at_put(field, value);
    }

    store_value(value);
  } else {
    // if we held onto field names we could alias based on names but
    // we don't know what's being stored to so kill it all.
    kill();
  }
  return st;
}


// return true if this value correspond to the default value of a field.
bool is_default_value(Value value) {
  Constant* con = value->as_Constant();
  if (con) {
    switch (con->type()->tag()) {
      case intTag:    return con->type()->as_IntConstant()->value() == 0;
      case longTag:   return con->type()->as_LongConstant()->value() == 0;
      case floatTag:  return jint_cast(con->type()->as_FloatConstant()->value()) == 0;
      case doubleTag: return jlong_cast(con->type()->as_DoubleConstant()->value()) == jlong_cast(0);
      case objectTag: return con->type() == objectNull;
      default:  ShouldNotReachHere()do { (*g_assert_poison) = 'X';; report_should_not_reach_here(
"/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 632); ::breakpoint(); } while (0);
    }
  }
  return false;
}


// return either the actual value of a load or the load itself
Value load(LoadField* load) {
  if (!EliminateFieldAccess) {
    return load;
  }

  if (strict_fp_requires_explicit_rounding && load->type()->is_float_kind()) {
646#ifdef IA32
    if (UseSSE < 2) {
      // can't skip load since value might get rounded as a side effect
      return load;
    }
651#else
    Unimplemented()do { (*g_assert_poison) = 'X';; report_unimplemented("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 652); ::breakpoint(); } while (0);
653#endif // IA32
  }

  ciField* field = load->field();
  Value object   = load->obj();
  if (field->holder()->is_loaded() && !field->is_volatile()) {
    int offset = field->offset();
    Value result = NULL__null;
    int index = _newobjects.find(object);
    if (index != -1) {
      result = _fields.at(index)->at(field);
    } else if (_objects.at_grow(offset, NULL__null) == object) {
      result = _values.at(field);
    }
    if (result != NULL__null) {
668#ifndef PRODUCT
      if (PrintIRDuringConstruction && Verbose) {
        tty->print_cr("Eliminated load: ");
        load->print_line();
      }
673#endif
      assert(result->type()->tag() == load->type()->tag(), "wrong types")do { if (!(result->type()->tag() == load->type()->
tag())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 674, "assert(" "result->type()->tag() == load->type()->tag()"
 ") failed", "wrong types"); ::breakpoint(); } } while (0);
      return result;
    }
  }
  return load;
}

// Record this newly allocated object
void new_instance(NewInstance* object) {
  int index = _newobjects.length();
  _newobjects.append(object);
  if (_fields.at_grow(index, NULL__null) == NULL__null) {
    _fields.at_put(index, new FieldBuffer());
  } else {
    _fields.at(index)->kill();
  }
}

void store_value(Value value) {
  int index = _newobjects.find(value);
  if (index != -1) {
    // stored a newly allocated object into another object.
    // Assume we've lost track of it as separate slice of memory.
    // We could do better by keeping track of whether individual
    // fields could alias each other.
    _newobjects.remove_at(index);
    // pull out the field info and store it at the end up the list
    // of field info list to be reused later.
    _fields.append(_fields.at(index));
    _fields.remove_at(index);
  }
}

void kill() {
  _newobjects.trunc_to(0);
  _objects.trunc_to(0);
  _values.kill();
}
712};


715// Implementation of GraphBuilder's ScopeData

717GraphBuilder::ScopeData::ScopeData(ScopeData* parent)
: _parent(parent)
, _bci2block(NULL__null)
, _scope(NULL__null)
, _has_handler(false)
, _stream(NULL__null)
, _work_list(NULL__null)
, _caller_stack_size(-1)
, _continuation(NULL__null)
, _parsing_jsr(false)
, _jsr_xhandlers(NULL__null)
, _num_returns(0)
, _cleanup_block(NULL__null)
, _cleanup_return_prev(NULL__null)
, _cleanup_state(NULL__null)
, _ignore_return(false)
733{
if (parent != NULL__null) {
  _max_inline_size = (intx) ((float) NestedInliningSizeRatio * (float) parent->max_inline_size() / 100.0f);
} else {
  _max_inline_size = C1MaxInlineSize;
}
if (_max_inline_size < C1MaxTrivialSize) {
  _max_inline_size = C1MaxTrivialSize;
}
742}


745void GraphBuilder::kill_all() {
if (UseLocalValueNumbering) {
  vmap()->kill_all();
}
_memory->kill();
750}


753BlockBegin* GraphBuilder::ScopeData::block_at(int bci) {
if (parsing_jsr()) {
  // It is necessary to clone all blocks associated with a
  // subroutine, including those for exception handlers in the scope
  // of the method containing the jsr (because those exception
  // handlers may contain ret instructions in some cases).
  BlockBegin* block = bci2block()->at(bci);
  if (block != NULL__null && block == parent()->bci2block()->at(bci)) {
    BlockBegin* new_block = new BlockBegin(block->bci());
    if (PrintInitialBlockList) {
      tty->print_cr("CFG: cloned block %d (bci %d) as block %d for jsr",
                    block->block_id(), block->bci(), new_block->block_id());
    }
    // copy data from cloned blocked
    new_block->set_depth_first_number(block->depth_first_number());
    if (block->is_set(BlockBegin::parser_loop_header_flag)) new_block->set(BlockBegin::parser_loop_header_flag);
    // Preserve certain flags for assertion checking
    if (block->is_set(BlockBegin::subroutine_entry_flag)) new_block->set(BlockBegin::subroutine_entry_flag);
    if (block->is_set(BlockBegin::exception_entry_flag))  new_block->set(BlockBegin::exception_entry_flag);

    // copy was_visited_flag to allow early detection of bailouts
    // if a block that is used in a jsr has already been visited before,
    // it is shared between the normal control flow and a subroutine
    // BlockBegin::try_merge returns false when the flag is set, this leads
    // to a compilation bailout
    if (block->is_set(BlockBegin::was_visited_flag))  new_block->set(BlockBegin::was_visited_flag);

    bci2block()->at_put(bci, new_block);
    block = new_block;
  }
  return block;
} else {
  return bci2block()->at(bci);
}
787}


790XHandlers* GraphBuilder::ScopeData::xhandlers() const {
if (_jsr_xhandlers == NULL__null) {
  assert(!parsing_jsr(), "")do { if (!(!parsing_jsr())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 792, "assert(" "!parsing_jsr()" ") failed", ""); ::breakpoint
(); } } while (0);
  return scope()->xhandlers();
}
assert(parsing_jsr(), "")do { if (!(parsing_jsr())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 795, "assert(" "parsing_jsr()" ") failed", ""); ::breakpoint
(); } } while (0);
return _jsr_xhandlers;
797}


800void GraphBuilder::ScopeData::set_scope(IRScope* scope) {
_scope = scope;
bool parent_has_handler = false;
if (parent() != NULL__null) {
  parent_has_handler = parent()->has_handler();
}
_has_handler = parent_has_handler || scope->xhandlers()->has_handlers();
807}


810void GraphBuilder::ScopeData::set_inline_cleanup_info(BlockBegin* block,
                                                    Instruction* return_prev,
                                                    ValueStack* return_state) {
_cleanup_block       = block;
_cleanup_return_prev = return_prev;
_cleanup_state       = return_state;
816}


819void GraphBuilder::ScopeData::add_to_work_list(BlockBegin* block) {
if (_work_list == NULL__null) {
  _work_list = new BlockList();
}

if (!block->is_set(BlockBegin::is_on_work_list_flag)) {
  // Do not start parsing the continuation block while in a
  // sub-scope
  if (parsing_jsr()) {
    if (block == jsr_continuation()) {
      return;
    }
  } else {
    if (block == continuation()) {
      return;
    }
  }
  block->set(BlockBegin::is_on_work_list_flag);
  _work_list->push(block);

  sort_top_into_worklist(_work_list, block);
}
841}


844void GraphBuilder::sort_top_into_worklist(BlockList* worklist, BlockBegin* top) {
assert(worklist->top() == top, "")do { if (!(worklist->top() == top)) { (*g_assert_poison) =
 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 845, "assert(" "worklist->top() == top" ") failed", "");
 ::breakpoint(); } } while (0);
// sort block descending into work list
const int dfn = top->depth_first_number();
assert(dfn != -1, "unknown depth first number")do { if (!(dfn != -1)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 848, "assert(" "dfn != -1" ") failed", "unknown depth first number"
); ::breakpoint(); } } while (0);
int i = worklist->length()-2;
while (i >= 0) {
  BlockBegin* b = worklist->at(i);
  if (b->depth_first_number() < dfn) {
    worklist->at_put(i+1, b);
  } else {
    break;
  }
  i --;
}
if (i >= -1) worklist->at_put(i + 1, top);
860}


863BlockBegin* GraphBuilder::ScopeData::remove_from_work_list() {
if (is_work_list_empty()) {
  return NULL__null;
}
return _work_list->pop();
868}


871bool GraphBuilder::ScopeData::is_work_list_empty() const {
return (_work_list == NULL__null || _work_list->length() == 0);
873}


876void GraphBuilder::ScopeData::setup_jsr_xhandlers() {
assert(parsing_jsr(), "")do { if (!(parsing_jsr())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 877, "assert(" "parsing_jsr()" ") failed", ""); ::breakpoint
(); } } while (0);
// clone all the exception handlers from the scope
XHandlers* handlers = new XHandlers(scope()->xhandlers());
const int n = handlers->length();
for (int i = 0; i < n; i++) {
  // The XHandlers need to be adjusted to dispatch to the cloned
  // handler block instead of the default one but the synthetic
  // unlocker needs to be handled specially.  The synthetic unlocker
  // should be left alone since there can be only one and all code
  // should dispatch to the same one.
  XHandler* h = handlers->handler_at(i);
  assert(h->handler_bci() != SynchronizationEntryBCI, "must be real")do { if (!(h->handler_bci() != SynchronizationEntryBCI)) {
 (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 888, "assert(" "h->handler_bci() != SynchronizationEntryBCI"
 ") failed", "must be real"); ::breakpoint(); } } while (0);
  h->set_entry_block(block_at(h->handler_bci()));
}
_jsr_xhandlers = handlers;
892}


895int GraphBuilder::ScopeData::num_returns() {
if (parsing_jsr()) {
  return parent()->num_returns();
}
return _num_returns;
900}


903void GraphBuilder::ScopeData::incr_num_returns() {
if (parsing_jsr()) {
  parent()->incr_num_returns();
} else {
  ++_num_returns;
}
909}


912// Implementation of GraphBuilder

914#define INLINE_BAILOUT(msg){ inline_bailout(msg); return false; }        { inline_bailout(msg); return false; }


917void GraphBuilder::load_constant() {
ciConstant con = stream()->get_constant();
if (con.basic_type() == T_ILLEGAL) {
  // FIXME: an unresolved Dynamic constant can get here,
  // and that should not terminate the whole compilation.
  BAILOUT("could not resolve a constant"){ bailout("could not resolve a constant"); return; };
} else {
  ValueType* t = illegalType;
  ValueStack* patch_state = NULL__null;
  switch (con.basic_type()) {
    case T_BOOLEAN: t = new IntConstant     (con.as_boolean()); break;
    case T_BYTE   : t = new IntConstant     (con.as_byte   ()); break;
    case T_CHAR   : t = new IntConstant     (con.as_char   ()); break;
    case T_SHORT  : t = new IntConstant     (con.as_short  ()); break;
    case T_INT    : t = new IntConstant     (con.as_int    ()); break;
    case T_LONG   : t = new LongConstant    (con.as_long   ()); break;
    case T_FLOAT  : t = new FloatConstant   (con.as_float  ()); break;
    case T_DOUBLE : t = new DoubleConstant  (con.as_double ()); break;
    case T_ARRAY  : t = new ArrayConstant   (con.as_object ()->as_array   ()); break;
    case T_OBJECT :
     {
      ciObject* obj = con.as_object();
      if (!obj->is_loaded()
          || (PatchALot && obj->klass() != ciEnv::current()->String_klass())) {
        // A Class, MethodType, MethodHandle, or String.
        // Unloaded condy nodes show up as T_ILLEGAL, above.
        patch_state = copy_state_before();
        t = new ObjectConstant(obj);
      } else {
        // Might be a Class, MethodType, MethodHandle, or Dynamic constant
        // result, which might turn out to be an array.
        if (obj->is_null_object())
          t = objectNull;
        else if (obj->is_array())
          t = new ArrayConstant(obj->as_array());
        else
          t = new InstanceConstant(obj->as_instance());
      }
      break;
     }
    default       : ShouldNotReachHere()do { (*g_assert_poison) = 'X';; report_should_not_reach_here(
"/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 957); ::breakpoint(); } while (0);
  }
  Value x;
  if (patch_state != NULL__null) {
    x = new Constant(t, patch_state);
  } else {
    x = new Constant(t);
  }
  push(t, append(x));
}
967}


970void GraphBuilder::load_local(ValueType* type, int index) {
Value x = state()->local_at(index);
assert(x != NULL && !x->type()->is_illegal(), "access of illegal local variable")do { if (!(x != __null && !x->type()->is_illegal
())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 972, "assert(" "x != __null && !x->type()->is_illegal()"
 ") failed", "access of illegal local variable"); ::breakpoint
(); } } while (0);
push(type, x);
974}


977void GraphBuilder::store_local(ValueType* type, int index) {
Value x = pop(type);
store_local(state(), x, index);
980}


983void GraphBuilder::store_local(ValueStack* state, Value x, int index) {
if (parsing_jsr()) {
  // We need to do additional tracking of the location of the return
  // address for jsrs since we don't handle arbitrary jsr/ret
  // constructs. Here we are figuring out in which circumstances we
  // need to bail out.
  if (x->type()->is_address()) {
    scope_data()->set_jsr_return_address_local(index);

    // Also check parent jsrs (if any) at this time to see whether
    // they are using this local. We don't handle skipping over a
    // ret.
    for (ScopeData* cur_scope_data = scope_data()->parent();
         cur_scope_data != NULL__null && cur_scope_data->parsing_jsr() && cur_scope_data->scope() == scope();
         cur_scope_data = cur_scope_data->parent()) {
      if (cur_scope_data->jsr_return_address_local() == index) {
        BAILOUT("subroutine overwrites return address from previous subroutine"){ bailout("subroutine overwrites return address from previous subroutine"
); return; };
      }
    }
  } else if (index == scope_data()->jsr_return_address_local()) {
    scope_data()->set_jsr_return_address_local(-1);
  }
}

state->store_local(index, round_fp(x));
1008}


1011void GraphBuilder::load_indexed(BasicType type) {
// In case of in block code motion in range check elimination
ValueStack* state_before = copy_state_indexed_access();
compilation()->set_has_access_indexed(true);
Value index = ipop();
Value array = apop();
Value length = NULL__null;
if (CSEArrayLength ||
    (array->as_Constant() != NULL__null) ||
    (array->as_AccessField() && array->as_AccessField()->field()->is_constant()) ||
    (array->as_NewArray() && array->as_NewArray()->length() && array->as_NewArray()->length()->type()->is_constant()) ||
    (array->as_NewMultiArray() && array->as_NewMultiArray()->dims()->at(0)->type()->is_constant())) {
  length = append(new ArrayLength(array, state_before));
}
push(as_ValueType(type), append(new LoadIndexed(array, index, length, type, state_before)));
1026}


1029void GraphBuilder::store_indexed(BasicType type) {
// In case of in block code motion in range check elimination
ValueStack* state_before = copy_state_indexed_access();
compilation()->set_has_access_indexed(true);
Value value = pop(as_ValueType(type));
Value index = ipop();
Value array = apop();
Value length = NULL__null;
if (CSEArrayLength ||
    (array->as_Constant() != NULL__null) ||
    (array->as_AccessField() && array->as_AccessField()->field()->is_constant()) ||
    (array->as_NewArray() && array->as_NewArray()->length() && array->as_NewArray()->length()->type()->is_constant()) ||
    (array->as_NewMultiArray() && array->as_NewMultiArray()->dims()->at(0)->type()->is_constant())) {
  length = append(new ArrayLength(array, state_before));
}
ciType* array_type = array->declared_type();
bool check_boolean = false;
if (array_type != NULL__null) {
  if (array_type->is_loaded() &&
    array_type->as_array_klass()->element_type()->basic_type() == T_BOOLEAN) {
    assert(type == T_BYTE, "boolean store uses bastore")do { if (!(type == T_BYTE)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1049, "assert(" "type == T_BYTE" ") failed", "boolean store uses bastore"
); ::breakpoint(); } } while (0);
    Value mask = append(new Constant(new IntConstant(1)));
    value = append(new LogicOp(Bytecodes::_iand, value, mask));
  }
} else if (type == T_BYTE) {
  check_boolean = true;
}
StoreIndexed* result = new StoreIndexed(array, index, length, type, value, state_before, check_boolean);
append(result);
_memory->store_value(value);

if (type == T_OBJECT && is_profiling()) {
  // Note that we'd collect profile data in this method if we wanted it.
  compilation()->set_would_profile(true);

  if (profile_checkcasts()) {
    result->set_profiled_method(method());
    result->set_profiled_bci(bci());
    result->set_should_profile(true);
  }
}
1070}


1073void GraphBuilder::stack_op(Bytecodes::Code code) {
switch (code) {
  case Bytecodes::_pop:
    { state()->raw_pop();
    }
    break;
  case Bytecodes::_pop2:
    { state()->raw_pop();
      state()->raw_pop();
    }
    break;
  case Bytecodes::_dup:
    { Value w = state()->raw_pop();
      state()->raw_push(w);
      state()->raw_push(w);
    }
    break;
  case Bytecodes::_dup_x1:
    { Value w1 = state()->raw_pop();
      Value w2 = state()->raw_pop();
      state()->raw_push(w1);
      state()->raw_push(w2);
      state()->raw_push(w1);
    }
    break;
  case Bytecodes::_dup_x2:
    { Value w1 = state()->raw_pop();
      Value w2 = state()->raw_pop();
      Value w3 = state()->raw_pop();
      state()->raw_push(w1);
      state()->raw_push(w3);
      state()->raw_push(w2);
      state()->raw_push(w1);
    }
    break;
  case Bytecodes::_dup2:
    { Value w1 = state()->raw_pop();
      Value w2 = state()->raw_pop();
      state()->raw_push(w2);
      state()->raw_push(w1);
      state()->raw_push(w2);
      state()->raw_push(w1);
    }
    break;
  case Bytecodes::_dup2_x1:
    { Value w1 = state()->raw_pop();
      Value w2 = state()->raw_pop();
      Value w3 = state()->raw_pop();
      state()->raw_push(w2);
      state()->raw_push(w1);
      state()->raw_push(w3);
      state()->raw_push(w2);
      state()->raw_push(w1);
    }
    break;
  case Bytecodes::_dup2_x2:
    { Value w1 = state()->raw_pop();
      Value w2 = state()->raw_pop();
      Value w3 = state()->raw_pop();
      Value w4 = state()->raw_pop();
      state()->raw_push(w2);
      state()->raw_push(w1);
      state()->raw_push(w4);
      state()->raw_push(w3);
      state()->raw_push(w2);
      state()->raw_push(w1);
    }
    break;
  case Bytecodes::_swap:
    { Value w1 = state()->raw_pop();
      Value w2 = state()->raw_pop();
      state()->raw_push(w1);
      state()->raw_push(w2);
    }
    break;
  default:
    ShouldNotReachHere()do { (*g_assert_poison) = 'X';; report_should_not_reach_here(
"/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1149); ::breakpoint(); } while (0);
    break;
}
1152}


1155void GraphBuilder::arithmetic_op(ValueType* type, Bytecodes::Code code, ValueStack* state_before) {
Value y = pop(type);
Value x = pop(type);
Value res = new ArithmeticOp(code, x, y, state_before);
// Note: currently single-precision floating-point rounding on Intel is handled at the LIRGenerator level
res = append(res);
res = round_fp(res);
push(type, res);
1163}


1166void GraphBuilder::negate_op(ValueType* type) {
push(type, append(new NegateOp(pop(type))));
1168}


1171void GraphBuilder::shift_op(ValueType* type, Bytecodes::Code code) {
Value s = ipop();
Value x = pop(type);
// try to simplify
// Note: This code should go into the canonicalizer as soon as it can
//       can handle canonicalized forms that contain more than one node.
if (CanonicalizeNodes && code == Bytecodes::_iushr) {
  // pattern: x >>> s
  IntConstant* s1 = s->type()->as_IntConstant();
  if (s1 != NULL__null) {
    // pattern: x >>> s1, with s1 constant
    ShiftOp* l = x->as_ShiftOp();
    if (l != NULL__null && l->op() == Bytecodes::_ishl) {
      // pattern: (a << b) >>> s1
      IntConstant* s0 = l->y()->type()->as_IntConstant();
      if (s0 != NULL__null) {
        // pattern: (a << s0) >>> s1
        const int s0c = s0->value() & 0x1F; // only the low 5 bits are significant for shifts
        const int s1c = s1->value() & 0x1F; // only the low 5 bits are significant for shifts
        if (s0c == s1c) {
          if (s0c == 0) {
            // pattern: (a << 0) >>> 0 => simplify to: a
            ipush(l->x());
          } else {
            // pattern: (a << s0c) >>> s0c => simplify to: a & m, with m constant
            assert(0 < s0c && s0c < BitsPerInt, "adjust code below to handle corner cases")do { if (!(0 < s0c && s0c < BitsPerInt)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1196, "assert(" "0 < s0c && s0c < BitsPerInt"
 ") failed", "adjust code below to handle corner cases"); ::breakpoint
(); } } while (0);
            const int m = (1 << (BitsPerInt - s0c)) - 1;
            Value s = append(new Constant(new IntConstant(m)));
            ipush(append(new LogicOp(Bytecodes::_iand, l->x(), s)));
          }
          return;
        }
      }
    }
  }
}
// could not simplify
push(type, append(new ShiftOp(code, x, s)));
1209}


1212void GraphBuilder::logic_op(ValueType* type, Bytecodes::Code code) {
Value y = pop(type);
Value x = pop(type);
push(type, append(new LogicOp(code, x, y)));
1216}


1219void GraphBuilder::compare_op(ValueType* type, Bytecodes::Code code) {
ValueStack* state_before = copy_state_before();
Value y = pop(type);
Value x = pop(type);
ipush(append(new CompareOp(code, x, y, state_before)));
1224}


1227void GraphBuilder::convert(Bytecodes::Code op, BasicType from, BasicType to) {
push(as_ValueType(to), append(new Convert(op, pop(as_ValueType(from)), as_ValueType(to))));
1229}


1232void GraphBuilder::increment() {
int index = stream()->get_index();
int delta = stream()->is_wide() ? (signed short)Bytes::get_Java_u2(stream()->cur_bcp() + 4) : (signed char)(stream()->cur_bcp()[2]);
load_local(intType, index);
ipush(append(new Constant(new IntConstant(delta))));
arithmetic_op(intType, Bytecodes::_iadd);
store_local(intType, index);
1239}


1242void GraphBuilder::_goto(int from_bci, int to_bci) {
Goto *x = new Goto(block_at(to_bci), to_bci <= from_bci);
if (is_profiling()) {
  compilation()->set_would_profile(true);
  x->set_profiled_bci(bci());
  if (profile_branches()) {
    x->set_profiled_method(method());
    x->set_should_profile(true);
  }
}
append(x);
1253}


1256void GraphBuilder::if_node(Value x, If::Condition cond, Value y, ValueStack* state_before) {
BlockBegin* tsux = block_at(stream()->get_dest());
BlockBegin* fsux = block_at(stream()->next_bci());
bool is_bb = tsux->bci() < stream()->cur_bci() || fsux->bci() < stream()->cur_bci();
// In case of loop invariant code motion or predicate insertion
// before the body of a loop the state is needed
Instruction *i = append(new If(x, cond, false, y, tsux, fsux, (is_bb || compilation()->is_optimistic()) ? state_before : NULL__null, is_bb));

assert(i->as_Goto() == NULL ||do { if (!(i->as_Goto() == __null || (i->as_Goto()->
sux_at(0) == tsux && i->as_Goto()->is_safepoint
() == tsux->bci() < stream()->cur_bci()) || (i->as_Goto
()->sux_at(0) == fsux && i->as_Goto()->is_safepoint
() == fsux->bci() < stream()->cur_bci()))) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1267, "assert(" "i->as_Goto() == __null || (i->as_Goto()->sux_at(0) == tsux && i->as_Goto()->is_safepoint() == tsux->bci() < stream()->cur_bci()) || (i->as_Goto()->sux_at(0) == fsux && i->as_Goto()->is_safepoint() == fsux->bci() < stream()->cur_bci())"
 ") failed", "safepoint state of Goto returned by canonicalizer incorrect"
); ::breakpoint(); } } while (0)
       (i->as_Goto()->sux_at(0) == tsux  && i->as_Goto()->is_safepoint() == tsux->bci() < stream()->cur_bci()) ||do { if (!(i->as_Goto() == __null || (i->as_Goto()->
sux_at(0) == tsux && i->as_Goto()->is_safepoint
() == tsux->bci() < stream()->cur_bci()) || (i->as_Goto
()->sux_at(0) == fsux && i->as_Goto()->is_safepoint
() == fsux->bci() < stream()->cur_bci()))) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1267, "assert(" "i->as_Goto() == __null || (i->as_Goto()->sux_at(0) == tsux && i->as_Goto()->is_safepoint() == tsux->bci() < stream()->cur_bci()) || (i->as_Goto()->sux_at(0) == fsux && i->as_Goto()->is_safepoint() == fsux->bci() < stream()->cur_bci())"
 ") failed", "safepoint state of Goto returned by canonicalizer incorrect"
); ::breakpoint(); } } while (0)
       (i->as_Goto()->sux_at(0) == fsux  && i->as_Goto()->is_safepoint() == fsux->bci() < stream()->cur_bci()),do { if (!(i->as_Goto() == __null || (i->as_Goto()->
sux_at(0) == tsux && i->as_Goto()->is_safepoint
() == tsux->bci() < stream()->cur_bci()) || (i->as_Goto
()->sux_at(0) == fsux && i->as_Goto()->is_safepoint
() == fsux->bci() < stream()->cur_bci()))) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1267, "assert(" "i->as_Goto() == __null || (i->as_Goto()->sux_at(0) == tsux && i->as_Goto()->is_safepoint() == tsux->bci() < stream()->cur_bci()) || (i->as_Goto()->sux_at(0) == fsux && i->as_Goto()->is_safepoint() == fsux->bci() < stream()->cur_bci())"
 ") failed", "safepoint state of Goto returned by canonicalizer incorrect"
); ::breakpoint(); } } while (0)
       "safepoint state of Goto returned by canonicalizer incorrect")do { if (!(i->as_Goto() == __null || (i->as_Goto()->
sux_at(0) == tsux && i->as_Goto()->is_safepoint
() == tsux->bci() < stream()->cur_bci()) || (i->as_Goto
()->sux_at(0) == fsux && i->as_Goto()->is_safepoint
() == fsux->bci() < stream()->cur_bci()))) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1267, "assert(" "i->as_Goto() == __null || (i->as_Goto()->sux_at(0) == tsux && i->as_Goto()->is_safepoint() == tsux->bci() < stream()->cur_bci()) || (i->as_Goto()->sux_at(0) == fsux && i->as_Goto()->is_safepoint() == fsux->bci() < stream()->cur_bci())"
 ") failed", "safepoint state of Goto returned by canonicalizer incorrect"
); ::breakpoint(); } } while (0);

if (is_profiling()) {
  If* if_node = i->as_If();
  if (if_node != NULL__null) {
    // Note that we'd collect profile data in this method if we wanted it.
    compilation()->set_would_profile(true);
    // At level 2 we need the proper bci to count backedges
    if_node->set_profiled_bci(bci());
    if (profile_branches()) {
      // Successors can be rotated by the canonicalizer, check for this case.
      if_node->set_profiled_method(method());
      if_node->set_should_profile(true);
      if (if_node->tsux() == fsux) {
        if_node->set_swapped(true);
      }
    }
    return;
  }

  // Check if this If was reduced to Goto.
  Goto *goto_node = i->as_Goto();
  if (goto_node != NULL__null) {
    compilation()->set_would_profile(true);
    goto_node->set_profiled_bci(bci());
    if (profile_branches()) {
      goto_node->set_profiled_method(method());
      goto_node->set_should_profile(true);
      // Find out which successor is used.
      if (goto_node->default_sux() == tsux) {
        goto_node->set_direction(Goto::taken);
      } else if (goto_node->default_sux() == fsux) {
        goto_node->set_direction(Goto::not_taken);
      } else {
        ShouldNotReachHere()do { (*g_assert_poison) = 'X';; report_should_not_reach_here(
"/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1301); ::breakpoint(); } while (0);
      }
    }
    return;
  }
}
1307}


1310void GraphBuilder::if_zero(ValueType* type, If::Condition cond) {
Value y = append(new Constant(intZero));
ValueStack* state_before = copy_state_before();
Value x = ipop();
if_node(x, cond, y, state_before);
1315}


1318void GraphBuilder::if_null(ValueType* type, If::Condition cond) {
Value y = append(new Constant(objectNull));
ValueStack* state_before = copy_state_before();
Value x = apop();
if_node(x, cond, y, state_before);
1323}


1326void GraphBuilder::if_same(ValueType* type, If::Condition cond) {
ValueStack* state_before = copy_state_before();
Value y = pop(type);
Value x = pop(type);
if_node(x, cond, y, state_before);
1331}


1334void GraphBuilder::jsr(int dest) {
// We only handle well-formed jsrs (those which are "block-structured").
// If the bytecodes are strange (jumping out of a jsr block) then we
// might end up trying to re-parse a block containing a jsr which
// has already been activated. Watch for this case and bail out.
for (ScopeData* cur_scope_data = scope_data();
     cur_scope_data != NULL__null && cur_scope_data->parsing_jsr() && cur_scope_data->scope() == scope();
     cur_scope_data = cur_scope_data->parent()) {
  if (cur_scope_data->jsr_entry_bci() == dest) {
    BAILOUT("too-complicated jsr/ret structure"){ bailout("too-complicated jsr/ret structure"); return; };
  }
}

push(addressType, append(new Constant(new AddressConstant(next_bci()))));
if (!try_inline_jsr(dest)) {
  return; // bailed out while parsing and inlining subroutine
}
1351}


1354void GraphBuilder::ret(int local_index) {
if (!parsing_jsr()) BAILOUT("ret encountered while not parsing subroutine"){ bailout("ret encountered while not parsing subroutine"); return
; };

if (local_index != scope_data()->jsr_return_address_local()) {
  BAILOUT("can not handle complicated jsr/ret constructs"){ bailout("can not handle complicated jsr/ret constructs"); return
; };
}

// Rets simply become (NON-SAFEPOINT) gotos to the jsr continuation
append(new Goto(scope_data()->jsr_continuation(), false));
1363}


1366void GraphBuilder::table_switch() {
Bytecode_tableswitch sw(stream());
const int l = sw.length();
if (CanonicalizeNodes && l == 1 && compilation()->env()->comp_level() != CompLevel_full_profile) {
  // total of 2 successors => use If instead of switch
  // Note: This code should go into the canonicalizer as soon as it can
  //       can handle canonicalized forms that contain more than one node.
  Value key = append(new Constant(new IntConstant(sw.low_key())));
  BlockBegin* tsux = block_at(bci() + sw.dest_offset_at(0));
  BlockBegin* fsux = block_at(bci() + sw.default_offset());
  bool is_bb = tsux->bci() < bci() || fsux->bci() < bci();
  // In case of loop invariant code motion or predicate insertion
  // before the body of a loop the state is needed
  ValueStack* state_before = copy_state_if_bb(is_bb);
  append(new If(ipop(), If::eql, true, key, tsux, fsux, state_before, is_bb));
} else {
  // collect successors
  BlockList* sux = new BlockList(l + 1, NULL__null);
  int i;
  bool has_bb = false;
  for (i = 0; i < l; i++) {
    sux->at_put(i, block_at(bci() + sw.dest_offset_at(i)));
    if (sw.dest_offset_at(i) < 0) has_bb = true;
  }
  // add default successor
  if (sw.default_offset() < 0) has_bb = true;
  sux->at_put(i, block_at(bci() + sw.default_offset()));
  // In case of loop invariant code motion or predicate insertion
  // before the body of a loop the state is needed
  ValueStack* state_before = copy_state_if_bb(has_bb);
  Instruction* res = append(new TableSwitch(ipop(), sux, sw.low_key(), state_before, has_bb));
1397#ifdef ASSERT1
  if (res->as_Goto()) {
    for (i = 0; i < l; i++) {
      if (sux->at(i) == res->as_Goto()->sux_at(0)) {
        assert(res->as_Goto()->is_safepoint() == sw.dest_offset_at(i) < 0, "safepoint state of Goto returned by canonicalizer incorrect")do { if (!(res->as_Goto()->is_safepoint() == sw.dest_offset_at
(i) < 0)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1401, "assert(" "res->as_Goto()->is_safepoint() == sw.dest_offset_at(i) < 0"
 ") failed", "safepoint state of Goto returned by canonicalizer incorrect"
); ::breakpoint(); } } while (0);
      }
    }
  }
1405#endif
}
1407}


1410void GraphBuilder::lookup_switch() {
Bytecode_lookupswitch sw(stream());
const int l = sw.number_of_pairs();
if (CanonicalizeNodes && l == 1 && compilation()->env()->comp_level() != CompLevel_full_profile) {
  // total of 2 successors => use If instead of switch
  // Note: This code should go into the canonicalizer as soon as it can
  //       can handle canonicalized forms that contain more than one node.
  // simplify to If
  LookupswitchPair pair = sw.pair_at(0);
  Value key = append(new Constant(new IntConstant(pair.match())));
  BlockBegin* tsux = block_at(bci() + pair.offset());
  BlockBegin* fsux = block_at(bci() + sw.default_offset());
  bool is_bb = tsux->bci() < bci() || fsux->bci() < bci();
  // In case of loop invariant code motion or predicate insertion
  // before the body of a loop the state is needed
  ValueStack* state_before = copy_state_if_bb(is_bb);;
  append(new If(ipop(), If::eql, true, key, tsux, fsux, state_before, is_bb));
} else {
  // collect successors & keys
  BlockList* sux = new BlockList(l + 1, NULL__null);
  intArray* keys = new intArray(l, l, 0);
  int i;
  bool has_bb = false;
  for (i = 0; i < l; i++) {
    LookupswitchPair pair = sw.pair_at(i);
    if (pair.offset() < 0) has_bb = true;
    sux->at_put(i, block_at(bci() + pair.offset()));
    keys->at_put(i, pair.match());
  }
  // add default successor
  if (sw.default_offset() < 0) has_bb = true;
  sux->at_put(i, block_at(bci() + sw.default_offset()));
  // In case of loop invariant code motion or predicate insertion
  // before the body of a loop the state is needed
  ValueStack* state_before = copy_state_if_bb(has_bb);
  Instruction* res = append(new LookupSwitch(ipop(), sux, keys, state_before, has_bb));
1446#ifdef ASSERT1
  if (res->as_Goto()) {
    for (i = 0; i < l; i++) {
      if (sux->at(i) == res->as_Goto()->sux_at(0)) {
        assert(res->as_Goto()->is_safepoint() == sw.pair_at(i).offset() < 0, "safepoint state of Goto returned by canonicalizer incorrect")do { if (!(res->as_Goto()->is_safepoint() == sw.pair_at
(i).offset() < 0)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1450, "assert(" "res->as_Goto()->is_safepoint() == sw.pair_at(i).offset() < 0"
 ") failed", "safepoint state of Goto returned by canonicalizer incorrect"
); ::breakpoint(); } } while (0);
      }
    }
  }
1454#endif
}
1456}

1458void GraphBuilder::call_register_finalizer() {
// If the receiver requires finalization then emit code to perform
// the registration on return.

// Gather some type information about the receiver
Value receiver = state()->local_at(0);
assert(receiver != NULL, "must have a receiver")do { if (!(receiver != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1464, "assert(" "receiver != __null" ") failed", "must have a receiver"
); ::breakpoint(); } } while (0);
ciType* declared_type = receiver->declared_type();
ciType* exact_type = receiver->exact_type();
if (exact_type == NULL__null &&
    receiver->as_Local() &&
    receiver->as_Local()->java_index() == 0) {
  ciInstanceKlass* ik = compilation()->method()->holder();
  if (ik->is_final()) {
    exact_type = ik;
  } else if (UseCHA && !(ik->has_subklass() || ik->is_interface())) {
    // test class is leaf class
    compilation()->dependency_recorder()->assert_leaf_type(ik);
    exact_type = ik;
  } else {
    declared_type = ik;
  }
}

// see if we know statically that registration isn't required
bool needs_check = true;
if (exact_type != NULL__null) {
  needs_check = exact_type->as_instance_klass()->has_finalizer();
} else if (declared_type != NULL__null) {
  ciInstanceKlass* ik = declared_type->as_instance_klass();
  if (!Dependencies::has_finalizable_subclass(ik)) {
    compilation()->dependency_recorder()->assert_has_no_finalizable_subclasses(ik);
    needs_check = false;
  }
}

if (needs_check) {
  // Perform the registration of finalizable objects.
  ValueStack* state_before = copy_state_for_exception();
  load_local(objectType, 0);
  append_split(new Intrinsic(voidType, vmIntrinsics::_Object_init,
                             state()->pop_arguments(1),
                             true, state_before, true));
}
1502}


1505void GraphBuilder::method_return(Value x, bool ignore_return) {
if (RegisterFinalizersAtInit &&
19
←
Assuming 'RegisterFinalizersAtInit' is false→
    method()->intrinsic_id() == vmIntrinsics::_Object_init) {
  call_register_finalizer();
}

// The conditions for a memory barrier are described in Parse::do_exits().
bool need_mem_bar = false;
if (method()->name() == ciSymbols::object_initializer_name() &&
20
←
Assuming the condition is false→
     (scope()->wrote_final() ||
       (AlwaysSafeConstructors && scope()->wrote_fields()) ||
       (support_IRIW_for_not_multiple_copy_atomic_cpu && scope()->wrote_volatile()))) {
  need_mem_bar = true;
}

BasicType bt = method()->return_type()->basic_type();
switch (bt) {
21
←
Control jumps to 'case T_BYTE:'  at line 1522→
  case T_BYTE:
  {
    Value shift = append(new Constant(new IntConstant(24)));
    x = append(new ShiftOp(Bytecodes::_ishl, x, shift));
22
←
Passing null pointer value via 2nd parameter 'x'→
23
←
Calling constructor for 'ShiftOp'→
    x = append(new ShiftOp(Bytecodes::_ishr, x, shift));
    break;
  }
  case T_SHORT:
  {
    Value shift = append(new Constant(new IntConstant(16)));
    x = append(new ShiftOp(Bytecodes::_ishl, x, shift));
    x = append(new ShiftOp(Bytecodes::_ishr, x, shift));
    break;
  }
  case T_CHAR:
  {
    Value mask = append(new Constant(new IntConstant(0xFFFF)));
    x = append(new LogicOp(Bytecodes::_iand, x, mask));
    break;
  }
  case T_BOOLEAN:
  {
    Value mask = append(new Constant(new IntConstant(1)));
    x = append(new LogicOp(Bytecodes::_iand, x, mask));
    break;
  }
  default:
    break;
}

// Check to see whether we are inlining. If so, Return
// instructions become Gotos to the continuation point.
if (continuation() != NULL__null) {

  int invoke_bci = state()->caller_state()->bci();

  if (x != NULL__null  && !ignore_return) {
    ciMethod* caller = state()->scope()->caller()->method();
    Bytecodes::Code invoke_raw_bc = caller->raw_code_at_bci(invoke_bci);
    if (invoke_raw_bc == Bytecodes::_invokehandle || invoke_raw_bc == Bytecodes::_invokedynamic) {
      ciType* declared_ret_type = caller->get_declared_signature_at_bci(invoke_bci)->return_type();
      if (declared_ret_type->is_klass() && x->exact_type() == NULL__null &&
          x->declared_type() != declared_ret_type && declared_ret_type != compilation()->env()->Object_klass()) {
        x = append(new TypeCast(declared_ret_type->as_klass(), x, copy_state_before()));
      }
    }
  }

  assert(!method()->is_synchronized() || InlineSynchronizedMethods, "can not inline synchronized methods yet")do { if (!(!method()->is_synchronized() || InlineSynchronizedMethods
)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1570, "assert(" "!method()->is_synchronized() || InlineSynchronizedMethods"
 ") failed", "can not inline synchronized methods yet"); ::breakpoint
(); } } while (0);

  if (compilation()->env()->dtrace_method_probes()) {
    // Report exit from inline methods
    Values* args = new Values(1);
    args->push(append(new Constant(new MethodConstant(method()))));
    append(new RuntimeCall(voidType, "dtrace_method_exit", CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_exit)((address)((address_word)(SharedRuntime::dtrace_method_exit))
), args));
  }

  // If the inlined method is synchronized, the monitor must be
  // released before we jump to the continuation block.
  if (method()->is_synchronized()) {
    assert(state()->locks_size() == 1, "receiver must be locked here")do { if (!(state()->locks_size() == 1)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1582, "assert(" "state()->locks_size() == 1" ") failed",
 "receiver must be locked here"); ::breakpoint(); } } while (
0);
    monitorexit(state()->lock_at(0), SynchronizationEntryBCI);
  }

  if (need_mem_bar) {
    append(new MemBar(lir_membar_storestore));
  }

  // State at end of inlined method is the state of the caller
  // without the method parameters on stack, including the
  // return value, if any, of the inlined method on operand stack.
  set_state(state()->caller_state()->copy_for_parsing());
  if (x != NULL__null) {
    if (!ignore_return) {
      state()->push(x->type(), x);
    }
    if (profile_return() && x->type()->is_object_kind()) {
      ciMethod* caller = state()->scope()->method();
      profile_return_type(x, method(), caller, invoke_bci);
    }
  }
  Goto* goto_callee = new Goto(continuation(), false);

  // See whether this is the first return; if so, store off some
  // of the state for later examination
  if (num_returns() == 0) {
    set_inline_cleanup_info();
  }

  // The current bci() is in the wrong scope, so use the bci() of
  // the continuation point.
  append_with_bci(goto_callee, scope_data()->continuation()->bci());
  incr_num_returns();
  return;
}

state()->truncate_stack(0);
if (method()->is_synchronized()) {
  // perform the unlocking before exiting the method
  Value receiver;
  if (!method()->is_static()) {
    receiver = _initial_state->local_at(0);
  } else {
    receiver = append(new Constant(new ClassConstant(method()->holder())));
  }
  append_split(new MonitorExit(receiver, state()->unlock()));
}

if (need_mem_bar) {
    append(new MemBar(lir_membar_storestore));
}

assert(!ignore_return, "Ignoring return value works only for inlining")do { if (!(!ignore_return)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1634, "assert(" "!ignore_return" ") failed", "Ignoring return value works only for inlining"
); ::breakpoint(); } } while (0);
append(new Return(x));
1636}

1638Value GraphBuilder::make_constant(ciConstant field_value, ciField* field) {
if (!field_value.is_valid())  return NULL__null;

BasicType field_type = field_value.basic_type();
ValueType* value = as_ValueType(field_value);

// Attach dimension info to stable arrays.
if (FoldStableValues &&
    field->is_stable() && field_type == T_ARRAY && !field_value.is_null_or_zero()) {
  ciArray* array = field_value.as_object()->as_array();
  jint dimension = field->type()->as_array_klass()->dimension();
  value = new StableArrayConstant(array, dimension);
}

switch (field_type) {
  case T_ARRAY:
  case T_OBJECT:
    if (field_value.as_object()->should_be_constant()) {
      return new Constant(value);
    }
    return NULL__null; // Not a constant.
  default:
    return new Constant(value);
}
1662}

1664void GraphBuilder::access_field(Bytecodes::Code code) {
bool will_link;
ciField* field = stream()->get_field(will_link);
ciInstanceKlass* holder = field->holder();
BasicType field_type = field->type()->basic_type();
ValueType* type = as_ValueType(field_type);
// call will_link again to determine if the field is valid.
const bool needs_patching = !holder->is_loaded() ||
                            !field->will_link(method(), code) ||
                            PatchALot;

ValueStack* state_before = NULL__null;
if (!holder->is_initialized() || needs_patching) {
  // save state before instruction for debug info when
  // deoptimization happens during patching
  state_before = copy_state_before();
}

Value obj = NULL__null;
if (code == Bytecodes::_getstatic || code == Bytecodes::_putstatic) {
  if (state_before != NULL__null) {
    // build a patching constant
    obj = new Constant(new InstanceConstant(holder->java_mirror()), state_before);
  } else {
    obj = new Constant(new InstanceConstant(holder->java_mirror()));
  }
}

if (field->is_final() && (code == Bytecodes::_putfield)) {
  scope()->set_wrote_final();
}

if (code == Bytecodes::_putfield) {
  scope()->set_wrote_fields();
  if (field->is_volatile()) {
    scope()->set_wrote_volatile();
  }
}

const int offset = !needs_patching ? field->offset() : -1;
switch (code) {
  case Bytecodes::_getstatic: {
    // check for compile-time constants, i.e., initialized static final fields
    Value constant = NULL__null;
    if (field->is_static_constant() && !PatchALot) {
      ciConstant field_value = field->constant_value();
      assert(!field->is_stable() || !field_value.is_null_or_zero(),do { if (!(!field->is_stable() || !field_value.is_null_or_zero
())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1711, "assert(" "!field->is_stable() || !field_value.is_null_or_zero()"
 ") failed", "stable static w/ default value shouldn't be a constant"
); ::breakpoint(); } } while (0)
             "stable static w/ default value shouldn't be a constant")do { if (!(!field->is_stable() || !field_value.is_null_or_zero
())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1711, "assert(" "!field->is_stable() || !field_value.is_null_or_zero()"
 ") failed", "stable static w/ default value shouldn't be a constant"
); ::breakpoint(); } } while (0);
      constant = make_constant(field_value, field);
    }
    if (constant != NULL__null) {
      push(type, append(constant));
    } else {
      if (state_before == NULL__null) {
        state_before = copy_state_for_exception();
      }
      push(type, append(new LoadField(append(obj), offset, field, true,
                                      state_before, needs_patching)));
    }
    break;
  }
  case Bytecodes::_putstatic: {
    Value val = pop(type);
    if (state_before == NULL__null) {
      state_before = copy_state_for_exception();
    }
    if (field->type()->basic_type() == T_BOOLEAN) {
      Value mask = append(new Constant(new IntConstant(1)));
      val = append(new LogicOp(Bytecodes::_iand, val, mask));
    }
    append(new StoreField(append(obj), offset, field, val, true, state_before, needs_patching));
    break;
  }
  case Bytecodes::_getfield: {
    // Check for compile-time constants, i.e., trusted final non-static fields.
    Value constant = NULL__null;
    obj = apop();
    ObjectType* obj_type = obj->type()->as_ObjectType();
    if (field->is_constant() && obj_type->is_constant() && !PatchALot) {
      ciObject* const_oop = obj_type->constant_value();
      if (!const_oop->is_null_object() && const_oop->is_loaded()) {
        ciConstant field_value = field->constant_value_of(const_oop);
        if (field_value.is_valid()) {
          constant = make_constant(field_value, field);
          // For CallSite objects add a dependency for invalidation of the optimization.
          if (field->is_call_site_target()) {
            ciCallSite* call_site = const_oop->as_call_site();
            if (!call_site->is_fully_initialized_constant_call_site()) {
              ciMethodHandle* target = field_value.as_object()->as_method_handle();
              dependency_recorder()->assert_call_site_target_value(call_site, target);
            }
          }
        }
      }
    }
    if (constant != NULL__null) {
      push(type, append(constant));
    } else {
      if (state_before == NULL__null) {
        state_before = copy_state_for_exception();
      }
      LoadField* load = new LoadField(obj, offset, field, false, state_before, needs_patching);
      Value replacement = !needs_patching ? _memory->load(load) : load;
      if (replacement != load) {
        assert(replacement->is_linked() || !replacement->can_be_linked(), "should already by linked")do { if (!(replacement->is_linked() || !replacement->can_be_linked
())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1768, "assert(" "replacement->is_linked() || !replacement->can_be_linked()"
 ") failed", "should already by linked"); ::breakpoint(); } }
 while (0);
        // Writing an (integer) value to a boolean, byte, char or short field includes an implicit narrowing
        // conversion. Emit an explicit conversion here to get the correct field value after the write.
        BasicType bt = field->type()->basic_type();
        switch (bt) {
        case T_BOOLEAN:
        case T_BYTE:
          replacement = append(new Convert(Bytecodes::_i2b, replacement, as_ValueType(bt)));
          break;
        case T_CHAR:
          replacement = append(new Convert(Bytecodes::_i2c, replacement, as_ValueType(bt)));
          break;
        case T_SHORT:
          replacement = append(new Convert(Bytecodes::_i2s, replacement, as_ValueType(bt)));
          break;
        default:
          break;
        }
        push(type, replacement);
      } else {
        push(type, append(load));
      }
    }
    break;
  }
  case Bytecodes::_putfield: {
    Value val = pop(type);
    obj = apop();
    if (state_before == NULL__null) {
      state_before = copy_state_for_exception();
    }
    if (field->type()->basic_type() == T_BOOLEAN) {
      Value mask = append(new Constant(new IntConstant(1)));
      val = append(new LogicOp(Bytecodes::_iand, val, mask));
    }
    StoreField* store = new StoreField(obj, offset, field, val, false, state_before, needs_patching);
    if (!needs_patching) store = _memory->store(store);
    if (store != NULL__null) {
      append(store);
    }
    break;
  }
  default:
    ShouldNotReachHere()do { (*g_assert_poison) = 'X';; report_should_not_reach_here(
"/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1811); ::breakpoint(); } while (0);
    break;
}
1814}


1817Dependencies* GraphBuilder::dependency_recorder() const {
assert(DeoptC1, "need debug information")do { if (!(DeoptC1)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1818, "assert(" "DeoptC1" ") failed", "need debug information"
); ::breakpoint(); } } while (0);
return compilation()->dependency_recorder();
1820}

1822// How many arguments do we want to profile?
1823Values* GraphBuilder::args_list_for_profiling(ciMethod* target, int& start, bool may_have_receiver) {
int n = 0;
bool has_receiver = may_have_receiver && Bytecodes::has_receiver(method()->java_code_at_bci(bci()));
start = has_receiver ? 1 : 0;
if (profile_arguments()) {
  ciProfileData* data = method()->method_data()->bci_to_data(bci());
  if (data != NULL__null && (data->is_CallTypeData() || data->is_VirtualCallTypeData())) {
    n = data->is_CallTypeData() ? data->as_CallTypeData()->number_of_arguments() : data->as_VirtualCallTypeData()->number_of_arguments();
  }
}
// If we are inlining then we need to collect arguments to profile parameters for the target
if (profile_parameters() && target != NULL__null) {
  if (target->method_data() != NULL__null && target->method_data()->parameters_type_data() != NULL__null) {
    // The receiver is profiled on method entry so it's included in
    // the number of parameters but here we're only interested in
    // actual arguments.
    n = MAX2(n, target->method_data()->parameters_type_data()->number_of_parameters() - start);
  }
}
if (n > 0) {
  return new Values(n);
}
return NULL__null;
1846}

1848void GraphBuilder::check_args_for_profiling(Values* obj_args, int expected) {
1849#ifdef ASSERT1
bool ignored_will_link;
ciSignature* declared_signature = NULL__null;
ciMethod* real_target = method()->get_method_at_bci(bci(), ignored_will_link, &declared_signature);
assert(expected == obj_args->max_length() || real_target->is_method_handle_intrinsic(), "missed on arg?")do { if (!(expected == obj_args->max_length() || real_target
->is_method_handle_intrinsic())) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1853, "assert(" "expected == obj_args->max_length() || real_target->is_method_handle_intrinsic()"
 ") failed", "missed on arg?"); ::breakpoint(); } } while (0);
1854#endif
1855}

1857// Collect arguments that we want to profile in a list
1858Values* GraphBuilder::collect_args_for_profiling(Values* args, ciMethod* target, bool may_have_receiver) {
int start = 0;
Values* obj_args = args_list_for_profiling(target, start, may_have_receiver);
if (obj_args == NULL__null) {
  return NULL__null;
}
int s = obj_args->max_length();
// if called through method handle invoke, some arguments may have been popped
for (int i = start, j = 0; j < s && i < args->length(); i++) {
  if (args->at(i)->type()->is_object_kind()) {
    obj_args->push(args->at(i));
    j++;
  }
}
check_args_for_profiling(obj_args, s);
return obj_args;
1874}


1877void GraphBuilder::invoke(Bytecodes::Code code) {
bool will_link;
ciSignature* declared_signature = NULL__null;
ciMethod*             target = stream()->get_method(will_link, &declared_signature);
ciKlass*              holder = stream()->get_declared_method_holder();
const Bytecodes::Code bc_raw = stream()->cur_bc_raw();
assert(declared_signature != NULL, "cannot be null")do { if (!(declared_signature != __null)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1883, "assert(" "declared_signature != __null" ") failed", "cannot be null"
); ::breakpoint(); } } while (0);
assert(will_link == target->is_loaded(), "")do { if (!(will_link == target->is_loaded())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1884, "assert(" "will_link == target->is_loaded()" ") failed"
, ""); ::breakpoint(); } } while (0);

ciInstanceKlass* klass = target->holder();
assert(!target->is_loaded() || klass->is_loaded(), "loaded target must imply loaded klass")do { if (!(!target->is_loaded() || klass->is_loaded()))
 { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1887, "assert(" "!target->is_loaded() || klass->is_loaded()"
 ") failed", "loaded target must imply loaded klass"); ::breakpoint
(); } } while (0);

// check if CHA possible: if so, change the code to invoke_special
ciInstanceKlass* calling_klass = method()->holder();
ciInstanceKlass* callee_holder = ciEnv::get_instance_klass_for_declared_method_holder(holder);
ciInstanceKlass* actual_recv = callee_holder;

CompileLog* log = compilation()->log();
if (log != NULL__null)
    log->elem("call method='%d' instr='%s'",
              log->identify(target),
              Bytecodes::name(code));

// Some methods are obviously bindable without any type checks so
// convert them directly to an invokespecial or invokestatic.
if (target->is_loaded() && !target->is_abstract() && target->can_be_statically_bound()) {
  switch (bc_raw) {
  case Bytecodes::_invokeinterface:
    // convert to invokespecial if the target is the private interface method.
    if (target->is_private()) {
      assert(holder->is_interface(), "How did we get a non-interface method here!")do { if (!(holder->is_interface())) { (*g_assert_poison) =
 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1907, "assert(" "holder->is_interface()" ") failed", "How did we get a non-interface method here!"
); ::breakpoint(); } } while (0);
      code = Bytecodes::_invokespecial;
    }
    break;
  case Bytecodes::_invokevirtual:
    code = Bytecodes::_invokespecial;
    break;
  case Bytecodes::_invokehandle:
    code = target->is_static() ? Bytecodes::_invokestatic : Bytecodes::_invokespecial;
    break;
  default:
    break;
  }
} else {
  if (bc_raw == Bytecodes::_invokehandle) {
    assert(!will_link, "should come here only for unlinked call")do { if (!(!will_link)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 1922, "assert(" "!will_link" ") failed", "should come here only for unlinked call"
); ::breakpoint(); } } while (0);
    code = Bytecodes::_invokespecial;
  }
}

if (code == Bytecodes::_invokespecial) {
  // Additional receiver subtype checks for interface calls via invokespecial or invokeinterface.
  ciKlass* receiver_constraint = nullptr;

  if (bc_raw == Bytecodes::_invokeinterface) {
    receiver_constraint = holder;
  } else if (bc_raw == Bytecodes::_invokespecial && !target->is_object_initializer() && calling_klass->is_interface()) {
    receiver_constraint = calling_klass;
  }

  if (receiver_constraint != nullptr) {
    int index = state()->stack_size() - (target->arg_size_no_receiver() + 1);
    Value receiver = state()->stack_at(index);
    CheckCast* c = new CheckCast(receiver_constraint, receiver, copy_state_before());
    // go to uncommon_trap when checkcast fails
    c->set_invokespecial_receiver_check();
    state()->stack_at_put(index, append_split(c));
  }
}

// Push appendix argument (MethodType, CallSite, etc.), if one.
bool patch_for_appendix = false;
int patching_appendix_arg = 0;
if (Bytecodes::has_optional_appendix(bc_raw) && (!will_link || PatchALot)) {
  Value arg = append(new Constant(new ObjectConstant(compilation()->env()->unloaded_ciinstance()), copy_state_before()));
  apush(arg);
  patch_for_appendix = true;
  patching_appendix_arg = (will_link && stream()->has_appendix()) ? 0 : 1;
} else if (stream()->has_appendix()) {
  ciObject* appendix = stream()->get_appendix();
  Value arg = append(new Constant(new ObjectConstant(appendix)));
  apush(arg);
}

ciMethod* cha_monomorphic_target = NULL__null;
ciMethod* exact_target = NULL__null;
Value better_receiver = NULL__null;
if (UseCHA && DeoptC1 && target->is_loaded() &&
    !(// %%% FIXME: Are both of these relevant?
      target->is_method_handle_intrinsic() ||
      target->is_compiled_lambda_form()) &&
    !patch_for_appendix) {
  Value receiver = NULL__null;
  ciInstanceKlass* receiver_klass = NULL__null;
  bool type_is_exact = false;
  // try to find a precise receiver type
  if (will_link && !target->is_static()) {
    int index = state()->stack_size() - (target->arg_size_no_receiver() + 1);
    receiver = state()->stack_at(index);
    ciType* type = receiver->exact_type();
    if (type != NULL__null && type->is_loaded() &&
        type->is_instance_klass() && !type->as_instance_klass()->is_interface()) {
      receiver_klass = (ciInstanceKlass*) type;
      type_is_exact = true;
    }
    if (type == NULL__null) {
      type = receiver->declared_type();
      if (type != NULL__null && type->is_loaded() &&
          type->is_instance_klass() && !type->as_instance_klass()->is_interface()) {
        receiver_klass = (ciInstanceKlass*) type;
        if (receiver_klass->is_leaf_type() && !receiver_klass->is_final()) {
          // Insert a dependency on this type since
          // find_monomorphic_target may assume it's already done.
          dependency_recorder()->assert_leaf_type(receiver_klass);
          type_is_exact = true;
        }
      }
    }
  }
  if (receiver_klass != NULL__null && type_is_exact &&
      receiver_klass->is_loaded() && code != Bytecodes::_invokespecial) {
    // If we have the exact receiver type we can bind directly to
    // the method to call.
    exact_target = target->resolve_invoke(calling_klass, receiver_klass);
    if (exact_target != NULL__null) {
      target = exact_target;
      code = Bytecodes::_invokespecial;
    }
  }
  if (receiver_klass != NULL__null &&
      receiver_klass->is_subtype_of(actual_recv) &&
      actual_recv->is_initialized()) {
    actual_recv = receiver_klass;
  }

  if ((code == Bytecodes::_invokevirtual && callee_holder->is_initialized()) ||
      (code == Bytecodes::_invokeinterface && callee_holder->is_initialized() && !actual_recv->is_interface())) {
    // Use CHA on the receiver to select a more precise method.
    cha_monomorphic_target = target->find_monomorphic_target(calling_klass, callee_holder, actual_recv);
  } else if (code == Bytecodes::_invokeinterface && callee_holder->is_loaded() && receiver != NULL__null) {
    assert(callee_holder->is_interface(), "invokeinterface to non interface?")do { if (!(callee_holder->is_interface())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2017, "assert(" "callee_holder->is_interface()" ") failed"
, "invokeinterface to non interface?"); ::breakpoint(); } } while
 (0);
    // If there is only one implementor of this interface then we
    // may be able bind this invoke directly to the implementing
    // klass but we need both a dependence on the single interface
    // and on the method we bind to.  Additionally since all we know
    // about the receiver type is the it's supposed to implement the
    // interface we have to insert a check that it's the class we
    // expect.  Interface types are not checked by the verifier so
    // they are roughly equivalent to Object.
    // The number of implementors for declared_interface is less or
    // equal to the number of implementors for target->holder() so
    // if number of implementors of target->holder() == 1 then
    // number of implementors for decl_interface is 0 or 1. If
    // it's 0 then no class implements decl_interface and there's
    // no point in inlining.
    ciInstanceKlass* declared_interface = callee_holder;
    ciInstanceKlass* singleton = declared_interface->unique_implementor();
    if (singleton != NULL__null) {
      assert(singleton != declared_interface, "not a unique implementor")do { if (!(singleton != declared_interface)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2035, "assert(" "singleton != declared_interface" ") failed"
, "not a unique implementor"); ::breakpoint(); } } while (0);
      cha_monomorphic_target = target->find_monomorphic_target(calling_klass, declared_interface, singleton);
      if (cha_monomorphic_target != NULL__null) {
        if (cha_monomorphic_target->holder() != compilation()->env()->Object_klass()) {
          // If CHA is able to bind this invoke then update the class
          // to match that class, otherwise klass will refer to the
          // interface.
          klass = cha_monomorphic_target->holder();
          actual_recv = declared_interface;

          // insert a check it's really the expected class.
          CheckCast* c = new CheckCast(klass, receiver, copy_state_for_exception());
          c->set_incompatible_class_change_check();
          c->set_direct_compare(klass->is_final());
          // pass the result of the checkcast so that the compiler has
          // more accurate type info in the inlinee
          better_receiver = append_split(c);
        } else {
          cha_monomorphic_target = NULL__null; // subtype check against Object is useless
        }
      }
    }
  }
}

if (cha_monomorphic_target != NULL__null) {
  assert(!target->can_be_statically_bound() || target == cha_monomorphic_target, "")do { if (!(!target->can_be_statically_bound() || target ==
 cha_monomorphic_target)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2061, "assert(" "!target->can_be_statically_bound() || target == cha_monomorphic_target"
 ") failed", ""); ::breakpoint(); } } while (0);
  assert(!cha_monomorphic_target->is_abstract(), "")do { if (!(!cha_monomorphic_target->is_abstract())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2062, "assert(" "!cha_monomorphic_target->is_abstract()"
 ") failed", ""); ::breakpoint(); } } while (0);
  if (!cha_monomorphic_target->can_be_statically_bound(actual_recv)) {
    // If we inlined because CHA revealed only a single target method,
    // then we are dependent on that target method not getting overridden
    // by dynamic class loading.  Be sure to test the "static" receiver
    // dest_method here, as opposed to the actual receiver, which may
    // falsely lead us to believe that the receiver is final or private.
    dependency_recorder()->assert_unique_concrete_method(actual_recv, cha_monomorphic_target, callee_holder, target);
  }
  code = Bytecodes::_invokespecial;
}

// check if we could do inlining
if (!PatchALot && Inline && target->is_loaded() && callee_holder->is_linked() && !patch_for_appendix) {
  // callee is known => check if we have static binding
  if ((code == Bytecodes::_invokestatic && callee_holder->is_initialized()) || // invokestatic involves an initialization barrier on resolved klass
      code == Bytecodes::_invokespecial ||
      (code == Bytecodes::_invokevirtual && target->is_final_method()) ||
      code == Bytecodes::_invokedynamic) {
    // static binding => check if callee is ok
    ciMethod* inline_target = (cha_monomorphic_target != NULL__null) ? cha_monomorphic_target : target;
    bool holder_known = (cha_monomorphic_target != NULL__null) || (exact_target != NULL__null);
    bool success = try_inline(inline_target, holder_known, false /* ignore_return */, code, better_receiver);

    CHECK_BAILOUT(){ if (bailed_out()) return; };
    clear_inline_bailout();

    if (success) {
      // Register dependence if JVMTI has either breakpoint
      // setting or hotswapping of methods capabilities since they may
      // cause deoptimization.
      if (compilation()->env()->jvmti_can_hotswap_or_post_breakpoint()) {
        dependency_recorder()->assert_evol_method(inline_target);
      }
      return;
    }
  } else {
    print_inlining(target, "no static binding", /*success*/ false);
  }
} else {
  print_inlining(target, "not inlineable", /*success*/ false);
}

// If we attempted an inline which did not succeed because of a
// bailout during construction of the callee graph, the entire
// compilation has to be aborted. This is fairly rare and currently
// seems to only occur for jasm-generated classes which contain
// jsr/ret pairs which are not associated with finally clauses and
// do not have exception handlers in the containing method, and are
// therefore not caught early enough to abort the inlining without
// corrupting the graph. (We currently bail out with a non-empty
// stack at a ret in these situations.)
CHECK_BAILOUT(){ if (bailed_out()) return; };

// inlining not successful => standard invoke
ValueType* result_type = as_ValueType(declared_signature->return_type());
ValueStack* state_before = copy_state_exhandling();

// The bytecode (code) might change in this method so we are checking this very late.
const bool has_receiver =
  code == Bytecodes::_invokespecial   ||
  code == Bytecodes::_invokevirtual   ||
  code == Bytecodes::_invokeinterface;
Values* args = state()->pop_arguments(target->arg_size_no_receiver() + patching_appendix_arg);
Value recv = has_receiver ? apop() : NULL__null;

// A null check is required here (when there is a receiver) for any of the following cases
// - invokespecial, always need a null check.
// - invokevirtual, when the target is final and loaded. Calls to final targets will become optimized
//   and require null checking. If the target is loaded a null check is emitted here.
//   If the target isn't loaded the null check must happen after the call resolution. We achieve that
//   by using the target methods unverified entry point (see CompiledIC::compute_monomorphic_entry).
//   (The JVM specification requires that LinkageError must be thrown before a NPE. An unloaded target may
//   potentially fail, and can't have the null check before the resolution.)
// - A call that will be profiled. (But we can't add a null check when the target is unloaded, by the same
//   reason as above, so calls with a receiver to unloaded targets can't be profiled.)
//
// Normal invokevirtual will perform the null check during lookup

bool need_null_check = (code == Bytecodes::_invokespecial) ||
    (target->is_loaded() && (target->is_final_method() || (is_profiling() && profile_calls())));

if (need_null_check) {
  if (recv != NULL__null) {
    null_check(recv);
  }

  if (is_profiling()) {
    // Note that we'd collect profile data in this method if we wanted it.
    compilation()->set_would_profile(true);

    if (profile_calls()) {
      assert(cha_monomorphic_target == NULL || exact_target == NULL, "both can not be set")do { if (!(cha_monomorphic_target == __null || exact_target ==
 __null)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2154, "assert(" "cha_monomorphic_target == __null || exact_target == __null"
 ") failed", "both can not be set"); ::breakpoint(); } } while
 (0);
      ciKlass* target_klass = NULL__null;
      if (cha_monomorphic_target != NULL__null) {
        target_klass = cha_monomorphic_target->holder();
      } else if (exact_target != NULL__null) {
        target_klass = exact_target->holder();
      }
      profile_call(target, recv, target_klass, collect_args_for_profiling(args, NULL__null, false), false);
    }
  }
}

Invoke* result = new Invoke(code, result_type, recv, args, target, state_before);
// push result
append_split(result);

if (result_type != voidType) {
  push(result_type, round_fp(result));
}
if (profile_return() && result_type->is_object_kind()) {
  profile_return_type(result, target);
}
2176}


2179void GraphBuilder::new_instance(int klass_index) {
ValueStack* state_before = copy_state_exhandling();
bool will_link;
ciKlass* klass = stream()->get_klass(will_link);
assert(klass->is_instance_klass(), "must be an instance klass")do { if (!(klass->is_instance_klass())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2183, "assert(" "klass->is_instance_klass()" ") failed",
 "must be an instance klass"); ::breakpoint(); } } while (0);
NewInstance* new_instance = new NewInstance(klass->as_instance_klass(), state_before, stream()->is_unresolved_klass());
_memory->new_instance(new_instance);
apush(append_split(new_instance));
2187}


2190void GraphBuilder::new_type_array() {
ValueStack* state_before = copy_state_exhandling();
apush(append_split(new NewTypeArray(ipop(), (BasicType)stream()->get_index(), state_before)));
2193}


2196void GraphBuilder::new_object_array() {
bool will_link;
ciKlass* klass = stream()->get_klass(will_link);
ValueStack* state_before = !klass->is_loaded() || PatchALot ? copy_state_before() : copy_state_exhandling();
NewArray* n = new NewObjectArray(klass, ipop(), state_before);
apush(append_split(n));
2202}


2205bool GraphBuilder::direct_compare(ciKlass* k) {
if (k->is_loaded() && k->is_instance_klass() && !UseSlowPath) {
  ciInstanceKlass* ik = k->as_instance_klass();
  if (ik->is_final()) {
    return true;
  } else {
    if (DeoptC1 && UseCHA && !(ik->has_subklass() || ik->is_interface())) {
      // test class is leaf class
      dependency_recorder()->assert_leaf_type(ik);
      return true;
    }
  }
}
return false;
2219}


2222void GraphBuilder::check_cast(int klass_index) {
bool will_link;
ciKlass* klass = stream()->get_klass(will_link);
ValueStack* state_before = !klass->is_loaded() || PatchALot ? copy_state_before() : copy_state_for_exception();
CheckCast* c = new CheckCast(klass, apop(), state_before);
apush(append_split(c));
c->set_direct_compare(direct_compare(klass));

if (is_profiling()) {
  // Note that we'd collect profile data in this method if we wanted it.
  compilation()->set_would_profile(true);

  if (profile_checkcasts()) {
    c->set_profiled_method(method());
    c->set_profiled_bci(bci());
    c->set_should_profile(true);
  }
}
2240}


2243void GraphBuilder::instance_of(int klass_index) {
bool will_link;
ciKlass* klass = stream()->get_klass(will_link);
ValueStack* state_before = !klass->is_loaded() || PatchALot ? copy_state_before() : copy_state_exhandling();
InstanceOf* i = new InstanceOf(klass, apop(), state_before);
ipush(append_split(i));
i->set_direct_compare(direct_compare(klass));

if (is_profiling()) {
  // Note that we'd collect profile data in this method if we wanted it.
  compilation()->set_would_profile(true);

  if (profile_checkcasts()) {
    i->set_profiled_method(method());
    i->set_profiled_bci(bci());
    i->set_should_profile(true);
  }
}
2261}


2264void GraphBuilder::monitorenter(Value x, int bci) {
// save state before locking in case of deoptimization after a NullPointerException
ValueStack* state_before = copy_state_for_exception_with_bci(bci);
append_with_bci(new MonitorEnter(x, state()->lock(x), state_before), bci);
kill_all();
2269}


2272void GraphBuilder::monitorexit(Value x, int bci) {
append_with_bci(new MonitorExit(x, state()->unlock()), bci);
kill_all();
2275}


2278void GraphBuilder::new_multi_array(int dimensions) {
bool will_link;
ciKlass* klass = stream()->get_klass(will_link);
ValueStack* state_before = !klass->is_loaded() || PatchALot ? copy_state_before() : copy_state_exhandling();

Values* dims = new Values(dimensions, dimensions, NULL__null);
// fill in all dimensions
int i = dimensions;
while (i-- > 0) dims->at_put(i, ipop());
// create array
NewArray* n = new NewMultiArray(klass, dims, state_before);
apush(append_split(n));
2290}


2293void GraphBuilder::throw_op(int bci) {
// We require that the debug info for a Throw be the "state before"
// the Throw (i.e., exception oop is still on TOS)
ValueStack* state_before = copy_state_before_with_bci(bci);
Throw* t = new Throw(apop(), state_before);
// operand stack not needed after a throw
state()->truncate_stack(0);
append_with_bci(t, bci);
2301}


2304Value GraphBuilder::round_fp(Value fp_value) {
if (strict_fp_requires_explicit_rounding) {
2306#ifdef IA32
  // no rounding needed if SSE2 is used
  if (UseSSE < 2) {
    // Must currently insert rounding node for doubleword values that
    // are results of expressions (i.e., not loads from memory or
    // constants)
    if (fp_value->type()->tag() == doubleTag &&
        fp_value->as_Constant() == NULL__null &&
        fp_value->as_Local() == NULL__null &&       // method parameters need no rounding
        fp_value->as_RoundFP() == NULL__null) {
      return append(new RoundFP(fp_value));
    }
  }
2319#else
  Unimplemented()do { (*g_assert_poison) = 'X';; report_unimplemented("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2320); ::breakpoint(); } while (0);
2321#endif // IA32
}
return fp_value;
2324}


2327Instruction* GraphBuilder::append_with_bci(Instruction* instr, int bci) {
Canonicalizer canon(compilation(), instr, bci);
Instruction* i1 = canon.canonical();
if (i1->is_linked() || !i1->can_be_linked()) {
  // Canonicalizer returned an instruction which was already
  // appended so simply return it.
  return i1;
}

if (UseLocalValueNumbering) {
  // Lookup the instruction in the ValueMap and add it to the map if
  // it's not found.
  Instruction* i2 = vmap()->find_insert(i1);
  if (i2 != i1) {
    // found an entry in the value map, so just return it.
    assert(i2->is_linked(), "should already be linked")do { if (!(i2->is_linked())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2342, "assert(" "i2->is_linked()" ") failed", "should already be linked"
); ::breakpoint(); } } while (0);
    return i2;
  }
  ValueNumberingEffects vne(vmap());
  i1->visit(&vne);
}

// i1 was not eliminated => append it
assert(i1->next() == NULL, "shouldn't already be linked")do { if (!(i1->next() == __null)) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2350, "assert(" "i1->next() == __null" ") failed", "shouldn't already be linked"
); ::breakpoint(); } } while (0);
_last = _last->set_next(i1, canon.bci());

if (++_instruction_count >= InstructionCountCutoff && !bailed_out()) {
  // set the bailout state but complete normal processing.  We
  // might do a little more work before noticing the bailout so we
  // want processing to continue normally until it's noticed.
  bailout("Method and/or inlining is too large");
}

2360#ifndef PRODUCT
if (PrintIRDuringConstruction) {
  InstructionPrinter ip;
  ip.print_line(i1);
  if (Verbose) {
    state()->print();
  }
}
2368#endif

// save state after modification of operand stack for StateSplit instructions
StateSplit* s = i1->as_StateSplit();
if (s != NULL__null) {
  if (EliminateFieldAccess) {
    Intrinsic* intrinsic = s->as_Intrinsic();
    if (s->as_Invoke() != NULL__null || (intrinsic && !intrinsic->preserves_state())) {
      _memory->kill();
    }
  }
  s->set_state(state()->copy(ValueStack::StateAfter, canon.bci()));
}

// set up exception handlers for this instruction if necessary
if (i1->can_trap()) {
  i1->set_exception_handlers(handle_exception(i1));
  assert(i1->exception_state() != NULL || !i1->needs_exception_state() || bailed_out(), "handle_exception must set exception state")do { if (!(i1->exception_state() != __null || !i1->needs_exception_state
() || bailed_out())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2385, "assert(" "i1->exception_state() != __null || !i1->needs_exception_state() || bailed_out()"
 ") failed", "handle_exception must set exception state"); ::
breakpoint(); } } while (0);
}
return i1;
2388}


2391Instruction* GraphBuilder::append(Instruction* instr) {
assert(instr->as_StateSplit() == NULL || instr->as_BlockEnd() != NULL, "wrong append used")do { if (!(instr->as_StateSplit() == __null || instr->as_BlockEnd
() != __null)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2392, "assert(" "instr->as_StateSplit() == __null || instr->as_BlockEnd() != __null"
 ") failed", "wrong append used"); ::breakpoint(); } } while (
0);
return append_with_bci(instr, bci());
2394}


2397Instruction* GraphBuilder::append_split(StateSplit* instr) {
return append_with_bci(instr, bci());
2399}


2402void GraphBuilder::null_check(Value value) {
if (value->as_NewArray() != NULL__null || value->as_NewInstance() != NULL__null) {
  return;
} else {
  Constant* con = value->as_Constant();
  if (con) {
    ObjectType* c = con->type()->as_ObjectType();
    if (c && c->is_loaded()) {
      ObjectConstant* oc = c->as_ObjectConstant();
      if (!oc || !oc->value()->is_null_object()) {
        return;
      }
    }
  }
}
append(new NullCheck(value, copy_state_for_exception()));
2418}



2422XHandlers* GraphBuilder::handle_exception(Instruction* instruction) {
if (!has_handler() && (!instruction->needs_exception_state() || instruction->exception_state() != NULL__null)) {
  assert(instruction->exception_state() == NULLdo { if (!(instruction->exception_state() == __null || instruction
->exception_state()->kind() == ValueStack::EmptyExceptionState
 || (instruction->exception_state()->kind() == ValueStack
::ExceptionState && _compilation->env()->should_retain_local_variables
()))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2427, "assert(" "instruction->exception_state() == __null || instruction->exception_state()->kind() == ValueStack::EmptyExceptionState || (instruction->exception_state()->kind() == ValueStack::ExceptionState && _compilation->env()->should_retain_local_variables())"
 ") failed", "exception_state should be of exception kind"); ::
breakpoint(); } } while (0)
         || instruction->exception_state()->kind() == ValueStack::EmptyExceptionStatedo { if (!(instruction->exception_state() == __null || instruction
->exception_state()->kind() == ValueStack::EmptyExceptionState
 || (instruction->exception_state()->kind() == ValueStack
::ExceptionState && _compilation->env()->should_retain_local_variables
()))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2427, "assert(" "instruction->exception_state() == __null || instruction->exception_state()->kind() == ValueStack::EmptyExceptionState || (instruction->exception_state()->kind() == ValueStack::ExceptionState && _compilation->env()->should_retain_local_variables())"
 ") failed", "exception_state should be of exception kind"); ::
breakpoint(); } } while (0)
         || (instruction->exception_state()->kind() == ValueStack::ExceptionState && _compilation->env()->should_retain_local_variables()),do { if (!(instruction->exception_state() == __null || instruction
->exception_state()->kind() == ValueStack::EmptyExceptionState
 || (instruction->exception_state()->kind() == ValueStack
::ExceptionState && _compilation->env()->should_retain_local_variables
()))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2427, "assert(" "instruction->exception_state() == __null || instruction->exception_state()->kind() == ValueStack::EmptyExceptionState || (instruction->exception_state()->kind() == ValueStack::ExceptionState && _compilation->env()->should_retain_local_variables())"
 ") failed", "exception_state should be of exception kind"); ::
breakpoint(); } } while (0)
         "exception_state should be of exception kind")do { if (!(instruction->exception_state() == __null || instruction
->exception_state()->kind() == ValueStack::EmptyExceptionState
 || (instruction->exception_state()->kind() == ValueStack
::ExceptionState && _compilation->env()->should_retain_local_variables
()))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2427, "assert(" "instruction->exception_state() == __null || instruction->exception_state()->kind() == ValueStack::EmptyExceptionState || (instruction->exception_state()->kind() == ValueStack::ExceptionState && _compilation->env()->should_retain_local_variables())"
 ") failed", "exception_state should be of exception kind"); ::
breakpoint(); } } while (0);
  return new XHandlers();
}

XHandlers*  exception_handlers = new XHandlers();
ScopeData*  cur_scope_data = scope_data();
ValueStack* cur_state = instruction->state_before();
ValueStack* prev_state = NULL__null;
int scope_count = 0;

assert(cur_state != NULL, "state_before must be set")do { if (!(cur_state != __null)) { (*g_assert_poison) = 'X';;
 report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2437, "assert(" "cur_state != __null" ") failed", "state_before must be set"
); ::breakpoint(); } } while (0);
do {
  int cur_bci = cur_state->bci();
  assert(cur_scope_data->scope() == cur_state->scope(), "scopes do not match")do { if (!(cur_scope_data->scope() == cur_state->scope(
))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2440, "assert(" "cur_scope_data->scope() == cur_state->scope()"
 ") failed", "scopes do not match"); ::breakpoint(); } } while
 (0);
  assert(cur_bci == SynchronizationEntryBCI || cur_bci == cur_scope_data->stream()->cur_bci(), "invalid bci")do { if (!(cur_bci == SynchronizationEntryBCI || cur_bci == cur_scope_data
->stream()->cur_bci())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2441, "assert(" "cur_bci == SynchronizationEntryBCI || cur_bci == cur_scope_data->stream()->cur_bci()"
 ") failed", "invalid bci"); ::breakpoint(); } } while (0);

  // join with all potential exception handlers
  XHandlers* list = cur_scope_data->xhandlers();
  const int n = list->length();
  for (int i = 0; i < n; i++) {
    XHandler* h = list->handler_at(i);
    if (h->covers(cur_bci)) {
      // h is a potential exception handler => join it
      compilation()->set_has_exception_handlers(true);

      BlockBegin* entry = h->entry_block();
      if (entry == block()) {
        // It's acceptable for an exception handler to cover itself
        // but we don't handle that in the parser currently.  It's
        // very rare so we bailout instead of trying to handle it.
        BAILOUT_("exception handler covers itself", exception_handlers){ bailout("exception handler covers itself"); return exception_handlers
; };
      }
      assert(entry->bci() == h->handler_bci(), "must match")do { if (!(entry->bci() == h->handler_bci())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2459, "assert(" "entry->bci() == h->handler_bci()" ") failed"
, "must match"); ::breakpoint(); } } while (0);
      assert(entry->bci() == -1 || entry == cur_scope_data->block_at(entry->bci()), "blocks must correspond")do { if (!(entry->bci() == -1 || entry == cur_scope_data->
block_at(entry->bci()))) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2460, "assert(" "entry->bci() == -1 || entry == cur_scope_data->block_at(entry->bci())"
 ") failed", "blocks must correspond"); ::breakpoint(); } } while
 (0);

      // previously this was a BAILOUT, but this is not necessary
      // now because asynchronous exceptions are not handled this way.
      assert(entry->state() == NULL || cur_state->total_locks_size() == entry->state()->total_locks_size(), "locks do not match")do { if (!(entry->state() == __null || cur_state->total_locks_size
() == entry->state()->total_locks_size())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2464, "assert(" "entry->state() == __null || cur_state->total_locks_size() == entry->state()->total_locks_size()"
 ") failed", "locks do not match"); ::breakpoint(); } } while
 (0);

      // xhandler start with an empty expression stack
      if (cur_state->stack_size() != 0) {
        cur_state = cur_state->copy(ValueStack::ExceptionState, cur_state->bci());
      }
      if (instruction->exception_state() == NULL__null) {
        instruction->set_exception_state(cur_state);
      }

      // Note: Usually this join must work. However, very
      // complicated jsr-ret structures where we don't ret from
      // the subroutine can cause the objects on the monitor
      // stacks to not match because blocks can be parsed twice.
      // The only test case we've seen so far which exhibits this
      // problem is caught by the infinite recursion test in
      // GraphBuilder::jsr() if the join doesn't work.
      if (!entry->try_merge(cur_state)) {
        BAILOUT_("error while joining with exception handler, prob. due to complicated jsr/rets", exception_handlers){ bailout("error while joining with exception handler, prob. due to complicated jsr/rets"
); return exception_handlers; };
      }

      // add current state for correct handling of phi functions at begin of xhandler
      int phi_operand = entry->add_exception_state(cur_state);

      // add entry to the list of xhandlers of this block
      _block->add_exception_handler(entry);

      // add back-edge from xhandler entry to this block
      if (!entry->is_predecessor(_block)) {
        entry->add_predecessor(_block);
      }

      // clone XHandler because phi_operand and scope_count can not be shared
      XHandler* new_xhandler = new XHandler(h);
      new_xhandler->set_phi_operand(phi_operand);
      new_xhandler->set_scope_count(scope_count);
      exception_handlers->append(new_xhandler);

      // fill in exception handler subgraph lazily
      assert(!entry->is_set(BlockBegin::was_visited_flag), "entry must not be visited yet")do { if (!(!entry->is_set(BlockBegin::was_visited_flag))) {
 (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2503, "assert(" "!entry->is_set(BlockBegin::was_visited_flag)"
 ") failed", "entry must not be visited yet"); ::breakpoint()
; } } while (0);
      cur_scope_data->add_to_work_list(entry);

      // stop when reaching catchall
      if (h->catch_type() == 0) {
        return exception_handlers;
      }
    }
  }

  if (exception_handlers->length() == 0) {
    // This scope and all callees do not handle exceptions, so the local
    // variables of this scope are not needed. However, the scope itself is
    // required for a correct exception stack trace -> clear out the locals.
    if (_compilation->env()->should_retain_local_variables()) {
      cur_state = cur_state->copy(ValueStack::ExceptionState, cur_state->bci());
    } else {
      cur_state = cur_state->copy(ValueStack::EmptyExceptionState, cur_state->bci());
    }
    if (prev_state != NULL__null) {
      prev_state->set_caller_state(cur_state);
    }
    if (instruction->exception_state() == NULL__null) {
      instruction->set_exception_state(cur_state);
    }
  }

  // Set up iteration for next time.
  // If parsing a jsr, do not grab exception handlers from the
  // parent scopes for this method (already got them, and they
  // needed to be cloned)

  while (cur_scope_data->parsing_jsr()) {
    cur_scope_data = cur_scope_data->parent();
  }

  assert(cur_scope_data->scope() == cur_state->scope(), "scopes do not match")do { if (!(cur_scope_data->scope() == cur_state->scope(
))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2539, "assert(" "cur_scope_data->scope() == cur_state->scope()"
 ") failed", "scopes do not match"); ::breakpoint(); } } while
 (0);
  assert(cur_state->locks_size() == 0 || cur_state->locks_size() == 1, "unlocking must be done in a catchall exception handler")do { if (!(cur_state->locks_size() == 0 || cur_state->locks_size
() == 1)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2540, "assert(" "cur_state->locks_size() == 0 || cur_state->locks_size() == 1"
 ") failed", "unlocking must be done in a catchall exception handler"
); ::breakpoint(); } } while (0);

  prev_state = cur_state;
  cur_state = cur_state->caller_state();
  cur_scope_data = cur_scope_data->parent();
  scope_count++;
} while (cur_scope_data != NULL__null);

return exception_handlers;
2549}


2552// Helper class for simplifying Phis.
2553class PhiSimplifier : public BlockClosure {
private:
bool _has_substitutions;
Value simplify(Value v);

public:
PhiSimplifier(BlockBegin* start) : _has_substitutions(false) {
  start->iterate_preorder(this);
  if (_has_substitutions) {
    SubstitutionResolver sr(start);
  }
}
void block_do(BlockBegin* b);
bool has_substitutions() const { return _has_substitutions; }
2567};


2570Value PhiSimplifier::simplify(Value v) {
Phi* phi = v->as_Phi();

if (phi == NULL__null) {
  // no phi function
  return v;
} else if (v->has_subst()) {
  // already substituted; subst can be phi itself -> simplify
  return simplify(v->subst());
} else if (phi->is_set(Phi::cannot_simplify)) {
  // already tried to simplify phi before
  return phi;
} else if (phi->is_set(Phi::visited)) {
  // break cycles in phi functions
  return phi;
} else if (phi->type()->is_illegal()) {
  // illegal phi functions are ignored anyway
  return phi;

} else {
  // mark phi function as processed to break cycles in phi functions
  phi->set(Phi::visited);

  // simplify x = [y, x] and x = [y, y] to y
  Value subst = NULL__null;
  int opd_count = phi->operand_count();
  for (int i = 0; i < opd_count; i++) {
    Value opd = phi->operand_at(i);
    assert(opd != NULL, "Operand must exist!")do { if (!(opd != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2598, "assert(" "opd != __null" ") failed", "Operand must exist!"
); ::breakpoint(); } } while (0);

    if (opd->type()->is_illegal()) {
      // if one operand is illegal, the entire phi function is illegal
      phi->make_illegal();
      phi->clear(Phi::visited);
      return phi;
    }

    Value new_opd = simplify(opd);
    assert(new_opd != NULL, "Simplified operand must exist!")do { if (!(new_opd != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2608, "assert(" "new_opd != __null" ") failed", "Simplified operand must exist!"
); ::breakpoint(); } } while (0);

    if (new_opd != phi && new_opd != subst) {
      if (subst == NULL__null) {
        subst = new_opd;
      } else {
        // no simplification possible
        phi->set(Phi::cannot_simplify);
        phi->clear(Phi::visited);
        return phi;
      }
    }
  }

  // sucessfully simplified phi function
  assert(subst != NULL, "illegal phi function")do { if (!(subst != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2623, "assert(" "subst != __null" ") failed", "illegal phi function"
); ::breakpoint(); } } while (0);
  _has_substitutions = true;
  phi->clear(Phi::visited);
  phi->set_subst(subst);

2628#ifndef PRODUCT
  if (PrintPhiFunctions) {
    tty->print_cr("simplified phi function %c%d to %c%d (Block B%d)", phi->type()->tchar(), phi->id(), subst->type()->tchar(), subst->id(), phi->block()->block_id());
  }
2632#endif

  return subst;
}
2636}


2639void PhiSimplifier::block_do(BlockBegin* b) {
for_each_phi_fun(b, phi,{ int cur_index; ValueStack* cur_state = b->state(); Value
 value; { int temp__2642 = cur_state->stack_size(); for (cur_index
 = 0; cur_index < temp__2642 && (value = cur_state
->stack_at(cur_index), true); cur_index += value->type(
)->size()) { Phi* phi = value->as_Phi(); if (phi != __null
 && phi->block() == b) { simplify(phi);; } } } { int
 temp__2642 = cur_state->locals_size(); for (cur_index = 0
; cur_index < temp__2642 && (value = cur_state->
local_at(cur_index), true); cur_index += (value == __null || value
->type()->is_illegal() ? 1 : value->type()->size(
))) if (value != __null) { Phi* phi = value->as_Phi(); if (
phi != __null && phi->block() == b) { simplify(phi
);; } } } }
  simplify(phi);{ int cur_index; ValueStack* cur_state = b->state(); Value
 value; { int temp__2642 = cur_state->stack_size(); for (cur_index
 = 0; cur_index < temp__2642 && (value = cur_state
->stack_at(cur_index), true); cur_index += value->type(
)->size()) { Phi* phi = value->as_Phi(); if (phi != __null
 && phi->block() == b) { simplify(phi);; } } } { int
 temp__2642 = cur_state->locals_size(); for (cur_index = 0
; cur_index < temp__2642 && (value = cur_state->
local_at(cur_index), true); cur_index += (value == __null || value
->type()->is_illegal() ? 1 : value->type()->size(
))) if (value != __null) { Phi* phi = value->as_Phi(); if (
phi != __null && phi->block() == b) { simplify(phi
);; } } } }
){ int cur_index; ValueStack* cur_state = b->state(); Value
 value; { int temp__2642 = cur_state->stack_size(); for (cur_index
 = 0; cur_index < temp__2642 && (value = cur_state
->stack_at(cur_index), true); cur_index += value->type(
)->size()) { Phi* phi = value->as_Phi(); if (phi != __null
 && phi->block() == b) { simplify(phi);; } } } { int
 temp__2642 = cur_state->locals_size(); for (cur_index = 0
; cur_index < temp__2642 && (value = cur_state->
local_at(cur_index), true); cur_index += (value == __null || value
->type()->is_illegal() ? 1 : value->type()->size(
))) if (value != __null) { Phi* phi = value->as_Phi(); if (
phi != __null && phi->block() == b) { simplify(phi
);; } } } };

2644#ifdef ASSERT1
for_each_phi_fun(b, phi,{ int cur_index; ValueStack* cur_state = b->state(); Value
 value; { int temp__2647 = cur_state->stack_size(); for (cur_index
 = 0; cur_index < temp__2647 && (value = cur_state
->stack_at(cur_index), true); cur_index += value->type(
)->size()) { Phi* phi = value->as_Phi(); if (phi != __null
 && phi->block() == b) { do { if (!(phi->operand_count
() != 1 || phi->subst() != phi || phi->is_illegal())) {
 (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2646, "assert(" "phi->operand_count() != 1 || phi->subst() != phi || phi->is_illegal()"
 ") failed", "missed trivial simplification"); ::breakpoint()
; } } while (0);; } } } { int temp__2647 = cur_state->locals_size
(); for (cur_index = 0; cur_index < temp__2647 && (
value = cur_state->local_at(cur_index), true); cur_index +=
 (value == __null || value->type()->is_illegal() ? 1 : value
->type()->size())) if (value != __null) { Phi* phi = value
->as_Phi(); if (phi != __null && phi->block() ==
 b) { do { if (!(phi->operand_count() != 1 || phi->subst
() != phi || phi->is_illegal())) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2646, "assert(" "phi->operand_count() != 1 || phi->subst() != phi || phi->is_illegal()"
 ") failed", "missed trivial simplification"); ::breakpoint()
; } } while (0);; } } } }
                 assert(phi->operand_count() != 1 || phi->subst() != phi || phi->is_illegal(), "missed trivial simplification");{ int cur_index; ValueStack* cur_state = b->state(); Value
 value; { int temp__2647 = cur_state->stack_size(); for (cur_index
 = 0; cur_index < temp__2647 && (value = cur_state
->stack_at(cur_index), true); cur_index += value->type(
)->size()) { Phi* phi = value->as_Phi(); if (phi != __null
 && phi->block() == b) { do { if (!(phi->operand_count
() != 1 || phi->subst() != phi || phi->is_illegal())) {
 (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2646, "assert(" "phi->operand_count() != 1 || phi->subst() != phi || phi->is_illegal()"
 ") failed", "missed trivial simplification"); ::breakpoint()
; } } while (0);; } } } { int temp__2647 = cur_state->locals_size
(); for (cur_index = 0; cur_index < temp__2647 && (
value = cur_state->local_at(cur_index), true); cur_index +=
 (value == __null || value->type()->is_illegal() ? 1 : value
->type()->size())) if (value != __null) { Phi* phi = value
->as_Phi(); if (phi != __null && phi->block() ==
 b) { do { if (!(phi->operand_count() != 1 || phi->subst
() != phi || phi->is_illegal())) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2646, "assert(" "phi->operand_count() != 1 || phi->subst() != phi || phi->is_illegal()"
 ") failed", "missed trivial simplification"); ::breakpoint()
; } } while (0);; } } } }
){ int cur_index; ValueStack* cur_state = b->state(); Value
 value; { int temp__2647 = cur_state->stack_size(); for (cur_index
 = 0; cur_index < temp__2647 && (value = cur_state
->stack_at(cur_index), true); cur_index += value->type(
)->size()) { Phi* phi = value->as_Phi(); if (phi != __null
 && phi->block() == b) { do { if (!(phi->operand_count
() != 1 || phi->subst() != phi || phi->is_illegal())) {
 (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2646, "assert(" "phi->operand_count() != 1 || phi->subst() != phi || phi->is_illegal()"
 ") failed", "missed trivial simplification"); ::breakpoint()
; } } while (0);; } } } { int temp__2647 = cur_state->locals_size
(); for (cur_index = 0; cur_index < temp__2647 && (
value = cur_state->local_at(cur_index), true); cur_index +=
 (value == __null || value->type()->is_illegal() ? 1 : value
->type()->size())) if (value != __null) { Phi* phi = value
->as_Phi(); if (phi != __null && phi->block() ==
 b) { do { if (!(phi->operand_count() != 1 || phi->subst
() != phi || phi->is_illegal())) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2646, "assert(" "phi->operand_count() != 1 || phi->subst() != phi || phi->is_illegal()"
 ") failed", "missed trivial simplification"); ::breakpoint()
; } } while (0);; } } } };

ValueStack* state = b->state()->caller_state();
for_each_state_value(state, value,{ int cur_index; ValueStack* cur_state = state; Value value; for
 (; cur_state != __null; cur_state = cur_state->caller_state
()) { { int temp__2653 = cur_state->locals_size(); for (cur_index
 = 0; cur_index < temp__2653 && (value = cur_state
->local_at(cur_index), true); cur_index += (value == __null
 || value->type()->is_illegal() ? 1 : value->type()->
size())) if (value != __null) { Phi* phi = value->as_Phi()
; do { if (!(phi == __null || phi->block() != b)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2652, "assert(" "phi == __null || phi->block() != b" ") failed"
, "must not have phi function to simplify in caller state"); ::
breakpoint(); } } while (0);; } } { int temp__2653 = cur_state
->stack_size(); for (cur_index = 0; cur_index < temp__2653
 && (value = cur_state->stack_at(cur_index), true)
; cur_index += value->type()->size()) { Phi* phi = value
->as_Phi(); do { if (!(phi == __null || phi->block() !=
 b)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2652, "assert(" "phi == __null || phi->block() != b" ") failed"
, "must not have phi function to simplify in caller state"); ::
breakpoint(); } } while (0);; } } } }
  Phi* phi = value->as_Phi();{ int cur_index; ValueStack* cur_state = state; Value value; for
 (; cur_state != __null; cur_state = cur_state->caller_state
()) { { int temp__2653 = cur_state->locals_size(); for (cur_index
 = 0; cur_index < temp__2653 && (value = cur_state
->local_at(cur_index), true); cur_index += (value == __null
 || value->type()->is_illegal() ? 1 : value->type()->
size())) if (value != __null) { Phi* phi = value->as_Phi()
; do { if (!(phi == __null || phi->block() != b)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2652, "assert(" "phi == __null || phi->block() != b" ") failed"
, "must not have phi function to simplify in caller state"); ::
breakpoint(); } } while (0);; } } { int temp__2653 = cur_state
->stack_size(); for (cur_index = 0; cur_index < temp__2653
 && (value = cur_state->stack_at(cur_index), true)
; cur_index += value->type()->size()) { Phi* phi = value
->as_Phi(); do { if (!(phi == __null || phi->block() !=
 b)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2652, "assert(" "phi == __null || phi->block() != b" ") failed"
, "must not have phi function to simplify in caller state"); ::
breakpoint(); } } while (0);; } } } }
  assert(phi == NULL || phi->block() != b, "must not have phi function to simplify in caller state");{ int cur_index; ValueStack* cur_state = state; Value value; for
 (; cur_state != __null; cur_state = cur_state->caller_state
()) { { int temp__2653 = cur_state->locals_size(); for (cur_index
 = 0; cur_index < temp__2653 && (value = cur_state
->local_at(cur_index), true); cur_index += (value == __null
 || value->type()->is_illegal() ? 1 : value->type()->
size())) if (value != __null) { Phi* phi = value->as_Phi()
; do { if (!(phi == __null || phi->block() != b)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2652, "assert(" "phi == __null || phi->block() != b" ") failed"
, "must not have phi function to simplify in caller state"); ::
breakpoint(); } } while (0);; } } { int temp__2653 = cur_state
->stack_size(); for (cur_index = 0; cur_index < temp__2653
 && (value = cur_state->stack_at(cur_index), true)
; cur_index += value->type()->size()) { Phi* phi = value
->as_Phi(); do { if (!(phi == __null || phi->block() !=
 b)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2652, "assert(" "phi == __null || phi->block() != b" ") failed"
, "must not have phi function to simplify in caller state"); ::
breakpoint(); } } while (0);; } } } }
){ int cur_index; ValueStack* cur_state = state; Value value; for
 (; cur_state != __null; cur_state = cur_state->caller_state
()) { { int temp__2653 = cur_state->locals_size(); for (cur_index
 = 0; cur_index < temp__2653 && (value = cur_state
->local_at(cur_index), true); cur_index += (value == __null
 || value->type()->is_illegal() ? 1 : value->type()->
size())) if (value != __null) { Phi* phi = value->as_Phi()
; do { if (!(phi == __null || phi->block() != b)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2652, "assert(" "phi == __null || phi->block() != b" ") failed"
, "must not have phi function to simplify in caller state"); ::
breakpoint(); } } while (0);; } } { int temp__2653 = cur_state
->stack_size(); for (cur_index = 0; cur_index < temp__2653
 && (value = cur_state->stack_at(cur_index), true)
; cur_index += value->type()->size()) { Phi* phi = value
->as_Phi(); do { if (!(phi == __null || phi->block() !=
 b)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2652, "assert(" "phi == __null || phi->block() != b" ") failed"
, "must not have phi function to simplify in caller state"); ::
breakpoint(); } } while (0);; } } } };
2654#endif
2655}

2657// This method is called after all blocks are filled with HIR instructions
2658// It eliminates all Phi functions of the form x = [y, y] and x = [y, x]
2659void GraphBuilder::eliminate_redundant_phis(BlockBegin* start) {
PhiSimplifier simplifier(start);
2661}


2664void GraphBuilder::connect_to_end(BlockBegin* beg) {
// setup iteration
kill_all();
_block = beg;
_state = beg->state()->copy_for_parsing();
_last  = beg;
iterate_bytecodes_for_block(beg->bci());
2671}


2674BlockEnd* GraphBuilder::iterate_bytecodes_for_block(int bci) {
2675#ifndef PRODUCT
if (PrintIRDuringConstruction) {
1
Assuming 'PrintIRDuringConstruction' is false→
2
←
Taking false branch→
  tty->cr();
  InstructionPrinter ip;
  ip.print_instr(_block); tty->cr();
  ip.print_stack(_block->state()); tty->cr();
  ip.print_inline_level(_block);
  ip.print_head();
  tty->print_cr("locals size: %d stack size: %d", state()->locals_size(), state()->stack_size());
}
2685#endif
_skip_block = false;
assert(state() != NULL, "ValueStack missing!")do { if (!(state() != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2687, "assert(" "state() != __null" ") failed", "ValueStack missing!"
); ::breakpoint(); } } while (0);
3
←
Assuming the condition is true→
4
←
Taking false branch→
5
←
Loop condition is false.  Exiting loop→
CompileLog* log = compilation()->log();
ciBytecodeStream s(method());
s.reset_to_bci(bci);
int prev_bci = bci;
scope_data()->set_stream(&s);
// iterate
Bytecodes::Code code = Bytecodes::_illegal;
bool push_exception = false;

if (block()->is_set(BlockBegin::exception_entry_flag) && block()->next() == NULL__null) {
  // first thing in the exception entry block should be the exception object.
  push_exception = true;
}

bool ignore_return = scope_data()->ignore_return();

while (!bailed_out() && last()->as_BlockEnd() == NULL__null &&
6
←
Assuming the condition is true→
9
←
Loop condition is true.  Entering loop body→
       (code = stream()->next()) != ciBytecodeStream::EOBC() &&
       (block_at(s.cur_bci()) == NULL__null || block_at(s.cur_bci()) == block())) {
7
←
Assuming the condition is false→
8
←
Assuming the condition is true→
  assert(state()->kind() == ValueStack::Parsing, "invalid state kind")do { if (!(state()->kind() == ValueStack::Parsing)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2707, "assert(" "state()->kind() == ValueStack::Parsing"
 ") failed", "invalid state kind"); ::breakpoint(); } } while
 (0);
10
←
Assuming the condition is true→
11
←
Taking false branch→
12
←
Loop condition is false.  Exiting loop→

  if (log != NULL__null)
13
←
Assuming 'log' is equal to NULL→
14
←
Taking false branch→
    log->set_context("bc code='%d' bci='%d'", (int)code, s.cur_bci());

  // Check for active jsr during OSR compilation
  if (compilation()->is_osr_compile()
      && scope()->is_top_scope()
      && parsing_jsr()
      && s.cur_bci() == compilation()->osr_bci()) {
    bailout("OSR not supported while a jsr is active");
  }

  if (push_exception14.1
'push_exception' is false
1
'push_exception' is false
) {
15
←
Taking false branch→
    apush(append(new ExceptionObject()));
    push_exception = false;
  }

  // handle bytecode
  switch (code) {
16
←
Control jumps to 'case _return:'  at line 2904→
    case Bytecodes::_nop            : /* nothing to do */ break;
    case Bytecodes::_aconst_null    : apush(append(new Constant(objectNull            ))); break;
    case Bytecodes::_iconst_m1      : ipush(append(new Constant(new IntConstant   (-1)))); break;
    case Bytecodes::_iconst_0       : ipush(append(new Constant(intZero               ))); break;
    case Bytecodes::_iconst_1       : ipush(append(new Constant(intOne                ))); break;
    case Bytecodes::_iconst_2       : ipush(append(new Constant(new IntConstant   ( 2)))); break;
    case Bytecodes::_iconst_3       : ipush(append(new Constant(new IntConstant   ( 3)))); break;
    case Bytecodes::_iconst_4       : ipush(append(new Constant(new IntConstant   ( 4)))); break;
    case Bytecodes::_iconst_5       : ipush(append(new Constant(new IntConstant   ( 5)))); break;
    case Bytecodes::_lconst_0       : lpush(append(new Constant(new LongConstant  ( 0)))); break;
    case Bytecodes::_lconst_1       : lpush(append(new Constant(new LongConstant  ( 1)))); break;
    case Bytecodes::_fconst_0       : fpush(append(new Constant(new FloatConstant ( 0)))); break;
    case Bytecodes::_fconst_1       : fpush(append(new Constant(new FloatConstant ( 1)))); break;
    case Bytecodes::_fconst_2       : fpush(append(new Constant(new FloatConstant ( 2)))); break;
    case Bytecodes::_dconst_0       : dpush(append(new Constant(new DoubleConstant( 0)))); break;
    case Bytecodes::_dconst_1       : dpush(append(new Constant(new DoubleConstant( 1)))); break;
    case Bytecodes::_bipush         : ipush(append(new Constant(new IntConstant(((signed char*)s.cur_bcp())[1])))); break;
    case Bytecodes::_sipush         : ipush(append(new Constant(new IntConstant((short)Bytes::get_Java_u2(s.cur_bcp()+1))))); break;
    case Bytecodes::_ldc            : // fall through
    case Bytecodes::_ldc_w          : // fall through
    case Bytecodes::_ldc2_w         : load_constant(); break;
    case Bytecodes::_iload          : load_local(intType     , s.get_index()); break;
    case Bytecodes::_lload          : load_local(longType    , s.get_index()); break;
    case Bytecodes::_fload          : load_local(floatType   , s.get_index()); break;
    case Bytecodes::_dload          : load_local(doubleType  , s.get_index()); break;
    case Bytecodes::_aload          : load_local(instanceType, s.get_index()); break;
    case Bytecodes::_iload_0        : load_local(intType   , 0); break;
    case Bytecodes::_iload_1        : load_local(intType   , 1); break;
    case Bytecodes::_iload_2        : load_local(intType   , 2); break;
    case Bytecodes::_iload_3        : load_local(intType   , 3); break;
    case Bytecodes::_lload_0        : load_local(longType  , 0); break;
    case Bytecodes::_lload_1        : load_local(longType  , 1); break;
    case Bytecodes::_lload_2        : load_local(longType  , 2); break;
    case Bytecodes::_lload_3        : load_local(longType  , 3); break;
    case Bytecodes::_fload_0        : load_local(floatType , 0); break;
    case Bytecodes::_fload_1        : load_local(floatType , 1); break;
    case Bytecodes::_fload_2        : load_local(floatType , 2); break;
    case Bytecodes::_fload_3        : load_local(floatType , 3); break;
    case Bytecodes::_dload_0        : load_local(doubleType, 0); break;
    case Bytecodes::_dload_1        : load_local(doubleType, 1); break;
    case Bytecodes::_dload_2        : load_local(doubleType, 2); break;
    case Bytecodes::_dload_3        : load_local(doubleType, 3); break;
    case Bytecodes::_aload_0        : load_local(objectType, 0); break;
    case Bytecodes::_aload_1        : load_local(objectType, 1); break;
    case Bytecodes::_aload_2        : load_local(objectType, 2); break;
    case Bytecodes::_aload_3        : load_local(objectType, 3); break;
    case Bytecodes::_iaload         : load_indexed(T_INT   ); break;
    case Bytecodes::_laload         : load_indexed(T_LONG  ); break;
    case Bytecodes::_faload         : load_indexed(T_FLOAT ); break;
    case Bytecodes::_daload         : load_indexed(T_DOUBLE); break;
    case Bytecodes::_aaload         : load_indexed(T_OBJECT); break;
    case Bytecodes::_baload         : load_indexed(T_BYTE  ); break;
    case Bytecodes::_caload         : load_indexed(T_CHAR  ); break;
    case Bytecodes::_saload         : load_indexed(T_SHORT ); break;
    case Bytecodes::_istore         : store_local(intType   , s.get_index()); break;
    case Bytecodes::_lstore         : store_local(longType  , s.get_index()); break;
    case Bytecodes::_fstore         : store_local(floatType , s.get_index()); break;
    case Bytecodes::_dstore         : store_local(doubleType, s.get_index()); break;
    case Bytecodes::_astore         : store_local(objectType, s.get_index()); break;
    case Bytecodes::_istore_0       : store_local(intType   , 0); break;
    case Bytecodes::_istore_1       : store_local(intType   , 1); break;
    case Bytecodes::_istore_2       : store_local(intType   , 2); break;
    case Bytecodes::_istore_3       : store_local(intType   , 3); break;
    case Bytecodes::_lstore_0       : store_local(longType  , 0); break;
    case Bytecodes::_lstore_1       : store_local(longType  , 1); break;
    case Bytecodes::_lstore_2       : store_local(longType  , 2); break;
    case Bytecodes::_lstore_3       : store_local(longType  , 3); break;
    case Bytecodes::_fstore_0       : store_local(floatType , 0); break;
    case Bytecodes::_fstore_1       : store_local(floatType , 1); break;
    case Bytecodes::_fstore_2       : store_local(floatType , 2); break;
    case Bytecodes::_fstore_3       : store_local(floatType , 3); break;
    case Bytecodes::_dstore_0       : store_local(doubleType, 0); break;
    case Bytecodes::_dstore_1       : store_local(doubleType, 1); break;
    case Bytecodes::_dstore_2       : store_local(doubleType, 2); break;
    case Bytecodes::_dstore_3       : store_local(doubleType, 3); break;
    case Bytecodes::_astore_0       : store_local(objectType, 0); break;
    case Bytecodes::_astore_1       : store_local(objectType, 1); break;
    case Bytecodes::_astore_2       : store_local(objectType, 2); break;
    case Bytecodes::_astore_3       : store_local(objectType, 3); break;
    case Bytecodes::_iastore        : store_indexed(T_INT   ); break;
    case Bytecodes::_lastore        : store_indexed(T_LONG  ); break;
    case Bytecodes::_fastore        : store_indexed(T_FLOAT ); break;
    case Bytecodes::_dastore        : store_indexed(T_DOUBLE); break;
    case Bytecodes::_aastore        : store_indexed(T_OBJECT); break;
    case Bytecodes::_bastore        : store_indexed(T_BYTE  ); break;
    case Bytecodes::_castore        : store_indexed(T_CHAR  ); break;
    case Bytecodes::_sastore        : store_indexed(T_SHORT ); break;
    case Bytecodes::_pop            : // fall through
    case Bytecodes::_pop2           : // fall through
    case Bytecodes::_dup            : // fall through
    case Bytecodes::_dup_x1         : // fall through
    case Bytecodes::_dup_x2         : // fall through
    case Bytecodes::_dup2           : // fall through
    case Bytecodes::_dup2_x1        : // fall through
    case Bytecodes::_dup2_x2        : // fall through
    case Bytecodes::_swap           : stack_op(code); break;
    case Bytecodes::_iadd           : arithmetic_op(intType   , code); break;
    case Bytecodes::_ladd           : arithmetic_op(longType  , code); break;
    case Bytecodes::_fadd           : arithmetic_op(floatType , code); break;
    case Bytecodes::_dadd           : arithmetic_op(doubleType, code); break;
    case Bytecodes::_isub           : arithmetic_op(intType   , code); break;
    case Bytecodes::_lsub           : arithmetic_op(longType  , code); break;
    case Bytecodes::_fsub           : arithmetic_op(floatType , code); break;
    case Bytecodes::_dsub           : arithmetic_op(doubleType, code); break;
    case Bytecodes::_imul           : arithmetic_op(intType   , code); break;
    case Bytecodes::_lmul           : arithmetic_op(longType  , code); break;
    case Bytecodes::_fmul           : arithmetic_op(floatType , code); break;
    case Bytecodes::_dmul           : arithmetic_op(doubleType, code); break;
    case Bytecodes::_idiv           : arithmetic_op(intType   , code, copy_state_for_exception()); break;
    case Bytecodes::_ldiv           : arithmetic_op(longType  , code, copy_state_for_exception()); break;
    case Bytecodes::_fdiv           : arithmetic_op(floatType , code); break;
    case Bytecodes::_ddiv           : arithmetic_op(doubleType, code); break;
    case Bytecodes::_irem           : arithmetic_op(intType   , code, copy_state_for_exception()); break;
    case Bytecodes::_lrem           : arithmetic_op(longType  , code, copy_state_for_exception()); break;
    case Bytecodes::_frem           : arithmetic_op(floatType , code); break;
    case Bytecodes::_drem           : arithmetic_op(doubleType, code); break;
    case Bytecodes::_ineg           : negate_op(intType   ); break;
    case Bytecodes::_lneg           : negate_op(longType  ); break;
    case Bytecodes::_fneg           : negate_op(floatType ); break;
    case Bytecodes::_dneg           : negate_op(doubleType); break;
    case Bytecodes::_ishl           : shift_op(intType , code); break;
    case Bytecodes::_lshl           : shift_op(longType, code); break;
    case Bytecodes::_ishr           : shift_op(intType , code); break;
    case Bytecodes::_lshr           : shift_op(longType, code); break;
    case Bytecodes::_iushr          : shift_op(intType , code); break;
    case Bytecodes::_lushr          : shift_op(longType, code); break;
    case Bytecodes::_iand           : logic_op(intType , code); break;
    case Bytecodes::_land           : logic_op(longType, code); break;
    case Bytecodes::_ior            : logic_op(intType , code); break;
    case Bytecodes::_lor            : logic_op(longType, code); break;
    case Bytecodes::_ixor           : logic_op(intType , code); break;
    case Bytecodes::_lxor           : logic_op(longType, code); break;
    case Bytecodes::_iinc           : increment(); break;
    case Bytecodes::_i2l            : convert(code, T_INT   , T_LONG  ); break;
    case Bytecodes::_i2f            : convert(code, T_INT   , T_FLOAT ); break;
    case Bytecodes::_i2d            : convert(code, T_INT   , T_DOUBLE); break;
    case Bytecodes::_l2i            : convert(code, T_LONG  , T_INT   ); break;
    case Bytecodes::_l2f            : convert(code, T_LONG  , T_FLOAT ); break;
    case Bytecodes::_l2d            : convert(code, T_LONG  , T_DOUBLE); break;
    case Bytecodes::_f2i            : convert(code, T_FLOAT , T_INT   ); break;
    case Bytecodes::_f2l            : convert(code, T_FLOAT , T_LONG  ); break;
    case Bytecodes::_f2d            : convert(code, T_FLOAT , T_DOUBLE); break;
    case Bytecodes::_d2i            : convert(code, T_DOUBLE, T_INT   ); break;
    case Bytecodes::_d2l            : convert(code, T_DOUBLE, T_LONG  ); break;
    case Bytecodes::_d2f            : convert(code, T_DOUBLE, T_FLOAT ); break;
    case Bytecodes::_i2b            : convert(code, T_INT   , T_BYTE  ); break;
    case Bytecodes::_i2c            : convert(code, T_INT   , T_CHAR  ); break;
    case Bytecodes::_i2s            : convert(code, T_INT   , T_SHORT ); break;
    case Bytecodes::_lcmp           : compare_op(longType  , code); break;
    case Bytecodes::_fcmpl          : compare_op(floatType , code); break;
    case Bytecodes::_fcmpg          : compare_op(floatType , code); break;
    case Bytecodes::_dcmpl          : compare_op(doubleType, code); break;
    case Bytecodes::_dcmpg          : compare_op(doubleType, code); break;
    case Bytecodes::_ifeq           : if_zero(intType   , If::eql); break;
    case Bytecodes::_ifne           : if_zero(intType   , If::neq); break;
    case Bytecodes::_iflt           : if_zero(intType   , If::lss); break;
    case Bytecodes::_ifge           : if_zero(intType   , If::geq); break;
    case Bytecodes::_ifgt           : if_zero(intType   , If::gtr); break;
    case Bytecodes::_ifle           : if_zero(intType   , If::leq); break;
    case Bytecodes::_if_icmpeq      : if_same(intType   , If::eql); break;
    case Bytecodes::_if_icmpne      : if_same(intType   , If::neq); break;
    case Bytecodes::_if_icmplt      : if_same(intType   , If::lss); break;
    case Bytecodes::_if_icmpge      : if_same(intType   , If::geq); break;
    case Bytecodes::_if_icmpgt      : if_same(intType   , If::gtr); break;
    case Bytecodes::_if_icmple      : if_same(intType   , If::leq); break;
    case Bytecodes::_if_acmpeq      : if_same(objectType, If::eql); break;
    case Bytecodes::_if_acmpne      : if_same(objectType, If::neq); break;
    case Bytecodes::_goto           : _goto(s.cur_bci(), s.get_dest()); break;
    case Bytecodes::_jsr            : jsr(s.get_dest()); break;
    case Bytecodes::_ret            : ret(s.get_index()); break;
    case Bytecodes::_tableswitch    : table_switch(); break;
    case Bytecodes::_lookupswitch   : lookup_switch(); break;
    case Bytecodes::_ireturn        : method_return(ipop(), ignore_return); break;
    case Bytecodes::_lreturn        : method_return(lpop(), ignore_return); break;
    case Bytecodes::_freturn        : method_return(fpop(), ignore_return); break;
    case Bytecodes::_dreturn        : method_return(dpop(), ignore_return); break;
    case Bytecodes::_areturn        : method_return(apop(), ignore_return); break;
    case Bytecodes::_return         : method_return(NULL__null  , ignore_return); break;
17
←
Passing null pointer value via 1st parameter 'x'→
18
←
Calling 'GraphBuilder::method_return'→
    case Bytecodes::_getstatic      : // fall through
    case Bytecodes::_putstatic      : // fall through
    case Bytecodes::_getfield       : // fall through
    case Bytecodes::_putfield       : access_field(code); break;
    case Bytecodes::_invokevirtual  : // fall through
    case Bytecodes::_invokespecial  : // fall through
    case Bytecodes::_invokestatic   : // fall through
    case Bytecodes::_invokedynamic  : // fall through
    case Bytecodes::_invokeinterface: invoke(code); break;
    case Bytecodes::_new            : new_instance(s.get_index_u2()); break;
    case Bytecodes::_newarray       : new_type_array(); break;
    case Bytecodes::_anewarray      : new_object_array(); break;
    case Bytecodes::_arraylength    : { ValueStack* state_before = copy_state_for_exception(); ipush(append(new ArrayLength(apop(), state_before))); break; }
    case Bytecodes::_athrow         : throw_op(s.cur_bci()); break;
    case Bytecodes::_checkcast      : check_cast(s.get_index_u2()); break;
    case Bytecodes::_instanceof     : instance_of(s.get_index_u2()); break;
    case Bytecodes::_monitorenter   : monitorenter(apop(), s.cur_bci()); break;
    case Bytecodes::_monitorexit    : monitorexit (apop(), s.cur_bci()); break;
    case Bytecodes::_wide           : ShouldNotReachHere()do { (*g_assert_poison) = 'X';; report_should_not_reach_here(
"/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2923); ::breakpoint(); } while (0); break;
    case Bytecodes::_multianewarray : new_multi_array(s.cur_bcp()[3]); break;
    case Bytecodes::_ifnull         : if_null(objectType, If::eql); break;
    case Bytecodes::_ifnonnull      : if_null(objectType, If::neq); break;
    case Bytecodes::_goto_w         : _goto(s.cur_bci(), s.get_far_dest()); break;
    case Bytecodes::_jsr_w          : jsr(s.get_far_dest()); break;
    case Bytecodes::_breakpoint     : BAILOUT_("concurrent setting of breakpoint", NULL){ bailout("concurrent setting of breakpoint"); return __null;
 };
    default                         : ShouldNotReachHere()do { (*g_assert_poison) = 'X';; report_should_not_reach_here(
"/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2930); ::breakpoint(); } while (0); break;
  }

  if (log != NULL__null)
    log->clear_context(); // skip marker if nothing was printed

  // save current bci to setup Goto at the end
  prev_bci = s.cur_bci();

}
CHECK_BAILOUT_(NULL){ if (bailed_out()) return __null; };
// stop processing of this block (see try_inline_full)
if (_skip_block) {
  _skip_block = false;
  assert(_last && _last->as_BlockEnd(), "")do { if (!(_last && _last->as_BlockEnd())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2944, "assert(" "_last && _last->as_BlockEnd()" ") failed"
, ""); ::breakpoint(); } } while (0);
  return _last->as_BlockEnd();
}
// if there are any, check if last instruction is a BlockEnd instruction
BlockEnd* end = last()->as_BlockEnd();
if (end == NULL__null) {
  // all blocks must end with a BlockEnd instruction => add a Goto
  end = new Goto(block_at(s.cur_bci()), false);
  append(end);
}
assert(end == last()->as_BlockEnd(), "inconsistency")do { if (!(end == last()->as_BlockEnd())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2954, "assert(" "end == last()->as_BlockEnd()" ") failed"
, "inconsistency"); ::breakpoint(); } } while (0);

assert(end->state() != NULL, "state must already be present")do { if (!(end->state() != __null)) { (*g_assert_poison) =
 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2956, "assert(" "end->state() != __null" ") failed", "state must already be present"
); ::breakpoint(); } } while (0);
assert(end->as_Return() == NULL || end->as_Throw() == NULL || end->state()->stack_size() == 0, "stack not needed for return and throw")do { if (!(end->as_Return() == __null || end->as_Throw(
) == __null || end->state()->stack_size() == 0)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2957, "assert(" "end->as_Return() == __null || end->as_Throw() == __null || end->state()->stack_size() == 0"
 ") failed", "stack not needed for return and throw"); ::breakpoint
(); } } while (0);

// connect to begin & set state
// NOTE that inlining may have changed the block we are parsing
block()->set_end(end);
// propagate state
for (int i = end->number_of_sux() - 1; i >= 0; i--) {
  BlockBegin* sux = end->sux_at(i);
  assert(sux->is_predecessor(block()), "predecessor missing")do { if (!(sux->is_predecessor(block()))) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 2965, "assert(" "sux->is_predecessor(block())" ") failed"
, "predecessor missing"); ::breakpoint(); } } while (0);
  // be careful, bailout if bytecodes are strange
  if (!sux->try_merge(end->state())) BAILOUT_("block join failed", NULL){ bailout("block join failed"); return __null; };
  scope_data()->add_to_work_list(end->sux_at(i));
}

scope_data()->set_stream(NULL__null);

// done
return end;
2975}


2978void GraphBuilder::iterate_all_blocks(bool start_in_current_block_for_inlining) {
do {
  if (start_in_current_block_for_inlining && !bailed_out()) {
    iterate_bytecodes_for_block(0);
    start_in_current_block_for_inlining = false;
  } else {
    BlockBegin* b;
    while ((b = scope_data()->remove_from_work_list()) != NULL__null) {
      if (!b->is_set(BlockBegin::was_visited_flag)) {
        if (b->is_set(BlockBegin::osr_entry_flag)) {
          // we're about to parse the osr entry block, so make sure
          // we setup the OSR edge leading into this block so that
          // Phis get setup correctly.
          setup_osr_entry_block();
          // this is no longer the osr entry block, so clear it.
          b->clear(BlockBegin::osr_entry_flag);
        }
        b->set(BlockBegin::was_visited_flag);
        connect_to_end(b);
      }
    }
  }
} while (!bailed_out() && !scope_data()->is_work_list_empty());
3001}


3004bool GraphBuilder::_can_trap      [Bytecodes::number_of_java_codes];

3006void GraphBuilder::initialize() {
// the following bytecodes are assumed to potentially
// throw exceptions in compiled code - note that e.g.
// monitorexit & the return bytecodes do not throw
// exceptions since monitor pairing proved that they
// succeed (if monitor pairing succeeded)
Bytecodes::Code can_trap_list[] =
  { Bytecodes::_ldc
  , Bytecodes::_ldc_w
  , Bytecodes::_ldc2_w
  , Bytecodes::_iaload
  , Bytecodes::_laload
  , Bytecodes::_faload
  , Bytecodes::_daload
  , Bytecodes::_aaload
  , Bytecodes::_baload
  , Bytecodes::_caload
  , Bytecodes::_saload
  , Bytecodes::_iastore
  , Bytecodes::_lastore
  , Bytecodes::_fastore
  , Bytecodes::_dastore
  , Bytecodes::_aastore
  , Bytecodes::_bastore
  , Bytecodes::_castore
  , Bytecodes::_sastore
  , Bytecodes::_idiv
  , Bytecodes::_ldiv
  , Bytecodes::_irem
  , Bytecodes::_lrem
  , Bytecodes::_getstatic
  , Bytecodes::_putstatic
  , Bytecodes::_getfield
  , Bytecodes::_putfield
  , Bytecodes::_invokevirtual
  , Bytecodes::_invokespecial
  , Bytecodes::_invokestatic
  , Bytecodes::_invokedynamic
  , Bytecodes::_invokeinterface
  , Bytecodes::_new
  , Bytecodes::_newarray
  , Bytecodes::_anewarray
  , Bytecodes::_arraylength
  , Bytecodes::_athrow
  , Bytecodes::_checkcast
  , Bytecodes::_instanceof
  , Bytecodes::_monitorenter
  , Bytecodes::_multianewarray
  };

// inititialize trap tables
for (int i = 0; i < Bytecodes::number_of_java_codes; i++) {
  _can_trap[i] = false;
}
// set standard trap info
for (uint j = 0; j < ARRAY_SIZE(can_trap_list)sizeof(array_size_impl(can_trap_list)); j++) {
  _can_trap[can_trap_list[j]] = true;
}
3064}


3067BlockBegin* GraphBuilder::header_block(BlockBegin* entry, BlockBegin::Flag f, ValueStack* state) {
assert(entry->is_set(f), "entry/flag mismatch")do { if (!(entry->is_set(f))) { (*g_assert_poison) = 'X';;
 report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3068, "assert(" "entry->is_set(f)" ") failed", "entry/flag mismatch"
); ::breakpoint(); } } while (0);
// create header block
BlockBegin* h = new BlockBegin(entry->bci());
h->set_depth_first_number(0);

Value l = h;
BlockEnd* g = new Goto(entry, false);
l->set_next(g, entry->bci());
h->set_end(g);
h->set(f);
// setup header block end state
ValueStack* s = state->copy(ValueStack::StateAfter, entry->bci()); // can use copy since stack is empty (=> no phis)
assert(s->stack_is_empty(), "must have empty stack at entry point")do { if (!(s->stack_is_empty())) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3080, "assert(" "s->stack_is_empty()" ") failed", "must have empty stack at entry point"
); ::breakpoint(); } } while (0);
g->set_state(s);
return h;
3083}



3087BlockBegin* GraphBuilder::setup_start_block(int osr_bci, BlockBegin* std_entry, BlockBegin* osr_entry, ValueStack* state) {
BlockBegin* start = new BlockBegin(0);

// This code eliminates the empty start block at the beginning of
// each method.  Previously, each method started with the
// start-block created below, and this block was followed by the
// header block that was always empty.  This header block is only
// necessary if std_entry is also a backward branch target because
// then phi functions may be necessary in the header block.  It's
// also necessary when profiling so that there's a single block that
// can increment the the counters.
// In addition, with range check elimination, we may need a valid block
// that dominates all the rest to insert range predicates.
BlockBegin* new_header_block;
if (std_entry->number_of_preds() > 0 || is_profiling() || RangeCheckElimination) {
  new_header_block = header_block(std_entry, BlockBegin::std_entry_flag, state);
} else {
  new_header_block = std_entry;
}

// setup start block (root for the IR graph)
Base* base =
  new Base(
    new_header_block,
    osr_entry
  );
start->set_next(base, 0);
start->set_end(base);
// create & setup state for start block
start->set_state(state->copy(ValueStack::StateAfter, std_entry->bci()));
base->set_state(state->copy(ValueStack::StateAfter, std_entry->bci()));

if (base->std_entry()->state() == NULL__null) {
  // setup states for header blocks
  base->std_entry()->merge(state);
}

assert(base->std_entry()->state() != NULL, "")do { if (!(base->std_entry()->state() != __null)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3124, "assert(" "base->std_entry()->state() != __null"
 ") failed", ""); ::breakpoint(); } } while (0);
return start;
3126}


3129void GraphBuilder::setup_osr_entry_block() {
assert(compilation()->is_osr_compile(), "only for osrs")do { if (!(compilation()->is_osr_compile())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3130, "assert(" "compilation()->is_osr_compile()" ") failed"
, "only for osrs"); ::breakpoint(); } } while (0);

int osr_bci = compilation()->osr_bci();
ciBytecodeStream s(method());
s.reset_to_bci(osr_bci);
s.next();
scope_data()->set_stream(&s);

// create a new block to be the osr setup code
_osr_entry = new BlockBegin(osr_bci);
_osr_entry->set(BlockBegin::osr_entry_flag);
_osr_entry->set_depth_first_number(0);
BlockBegin* target = bci2block()->at(osr_bci);
assert(target != NULL && target->is_set(BlockBegin::osr_entry_flag), "must be there")do { if (!(target != __null && target->is_set(BlockBegin
::osr_entry_flag))) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3143, "assert(" "target != __null && target->is_set(BlockBegin::osr_entry_flag)"
 ") failed", "must be there"); ::breakpoint(); } } while (0);
// the osr entry has no values for locals
ValueStack* state = target->state()->copy();
_osr_entry->set_state(state);

kill_all();
_block = _osr_entry;
_state = _osr_entry->state()->copy();
assert(_state->bci() == osr_bci, "mismatch")do { if (!(_state->bci() == osr_bci)) { (*g_assert_poison)
 = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3151, "assert(" "_state->bci() == osr_bci" ") failed", "mismatch"
); ::breakpoint(); } } while (0);
_last  = _osr_entry;
Value e = append(new OsrEntry());
e->set_needs_null_check(false);

// OSR buffer is
//
// locals[nlocals-1..0]
// monitors[number_of_locks-1..0]
//
// locals is a direct copy of the interpreter frame so in the osr buffer
// so first slot in the local array is the last local from the interpreter
// and last slot is local[0] (receiver) from the interpreter
//
// Similarly with locks. The first lock slot in the osr buffer is the nth lock
// from the interpreter frame, the nth lock slot in the osr buffer is 0th lock
// in the interpreter frame (the method lock if a sync method)

// Initialize monitors in the compiled activation.

int index;
Value local;

// find all the locals that the interpreter thinks contain live oops
const ResourceBitMap live_oops = method()->live_local_oops_at_bci(osr_bci);

// compute the offset into the locals so that we can treat the buffer
// as if the locals were still in the interpreter frame
int locals_offset = BytesPerWord * (method()->max_locals() - 1);
for_each_local_value(state, index, local)int temp__3180 = state->locals_size(); for (index = 0; index
 < temp__3180 && (local = state->local_at(index
), true); index += (local == __null || local->type()->is_illegal
() ? 1 : local->type()->size())) if (local != __null) {
  int offset = locals_offset - (index + local->type()->size() - 1) * BytesPerWord;
  Value get;
  if (local->type()->is_object_kind() && !live_oops.at(index)) {
    // The interpreter thinks this local is dead but the compiler
    // doesn't so pretend that the interpreter passed in null.
    get = append(new Constant(objectNull));
  } else {
    Value off_val = append(new Constant(new IntConstant(offset)));
    get = append(new UnsafeGet(as_BasicType(local->type()), e,
                               off_val,
                               false/*is_volatile*/,
                               true/*is_raw*/));
  }
  _state->store_local(index, get);
}

// the storage for the OSR buffer is freed manually in the LIRGenerator.

assert(state->caller_state() == NULL, "should be top scope")do { if (!(state->caller_state() == __null)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3199, "assert(" "state->caller_state() == __null" ") failed"
, "should be top scope"); ::breakpoint(); } } while (0);
state->clear_locals();
Goto* g = new Goto(target, false);
append(g);
_osr_entry->set_end(g);
target->merge(_osr_entry->end()->state());

scope_data()->set_stream(NULL__null);
3207}


3210ValueStack* GraphBuilder::state_at_entry() {
ValueStack* state = new ValueStack(scope(), NULL__null);

// Set up locals for receiver
int idx = 0;
if (!method()->is_static()) {
  // we should always see the receiver
  state->store_local(idx, new Local(method()->holder(), objectType, idx, true));
  idx = 1;
}

// Set up locals for incoming arguments
ciSignature* sig = method()->signature();
for (int i = 0; i < sig->count(); i++) {
  ciType* type = sig->type_at(i);
  BasicType basic_type = type->basic_type();
  // don't allow T_ARRAY to propagate into locals types
  if (is_reference_type(basic_type)) basic_type = T_OBJECT;
  ValueType* vt = as_ValueType(basic_type);
  state->store_local(idx, new Local(type, vt, idx, false));
  idx += type->size();
}

// lock synchronized method
if (method()->is_synchronized()) {
  state->lock(NULL__null);
}

return state;
3239}


3242GraphBuilder::GraphBuilder(Compilation* compilation, IRScope* scope)
: _scope_data(NULL__null)
, _compilation(compilation)
, _memory(new MemoryBuffer())
, _inline_bailout_msg(NULL__null)
, _instruction_count(0)
, _osr_entry(NULL__null)
3249{
int osr_bci = compilation->osr_bci();

// determine entry points and bci2block mapping
BlockListBuilder blm(compilation, scope, osr_bci);
CHECK_BAILOUT(){ if (bailed_out()) return; };

BlockList* bci2block = blm.bci2block();
BlockBegin* start_block = bci2block->at(0);

push_root_scope(scope, bci2block, start_block);

// setup state for std entry
_initial_state = state_at_entry();
start_block->merge(_initial_state);

// End nulls still exist here

// complete graph
_vmap        = new ValueMap();
switch (scope->method()->intrinsic_id()) {
case vmIntrinsics::_dabs          : // fall through
case vmIntrinsics::_dsqrt         : // fall through
case vmIntrinsics::_dsqrt_strict  : // fall through
case vmIntrinsics::_dsin          : // fall through
case vmIntrinsics::_dcos          : // fall through
case vmIntrinsics::_dtan          : // fall through
case vmIntrinsics::_dlog          : // fall through
case vmIntrinsics::_dlog10        : // fall through
case vmIntrinsics::_dexp          : // fall through
case vmIntrinsics::_dpow          : // fall through
  {
    // Compiles where the root method is an intrinsic need a special
    // compilation environment because the bytecodes for the method
    // shouldn't be parsed during the compilation, only the special
    // Intrinsic node should be emitted.  If this isn't done the the
    // code for the inlined version will be different than the root
    // compiled version which could lead to monotonicity problems on
    // intel.
    if (CheckIntrinsics && !scope->method()->intrinsic_candidate()) {
      BAILOUT("failed to inline intrinsic, method not annotated"){ bailout("failed to inline intrinsic, method not annotated")
; return; };
    }

    // Set up a stream so that appending instructions works properly.
    ciBytecodeStream s(scope->method());
    s.reset_to_bci(0);
    scope_data()->set_stream(&s);
    s.next();

    // setup the initial block state
    _block = start_block;
    _state = start_block->state()->copy_for_parsing();
    _last  = start_block;
    load_local(doubleType, 0);
    if (scope->method()->intrinsic_id() == vmIntrinsics::_dpow) {
      load_local(doubleType, 2);
    }

    // Emit the intrinsic node.
    bool result = try_inline_intrinsics(scope->method());
    if (!result) BAILOUT("failed to inline intrinsic"){ bailout("failed to inline intrinsic"); return; };
    method_return(dpop());

    // connect the begin and end blocks and we're all done.
    BlockEnd* end = last()->as_BlockEnd();
    block()->set_end(end);
    break;
  }

case vmIntrinsics::_Reference_get:
  {
    {
      // With java.lang.ref.reference.get() we must go through the
      // intrinsic - when G1 is enabled - even when get() is the root
      // method of the compile so that, if necessary, the value in
      // the referent field of the reference object gets recorded by
      // the pre-barrier code.
      // Specifically, if G1 is enabled, the value in the referent
      // field is recorded by the G1 SATB pre barrier. This will
      // result in the referent being marked live and the reference
      // object removed from the list of discovered references during
      // reference processing.
      if (CheckIntrinsics && !scope->method()->intrinsic_candidate()) {
        BAILOUT("failed to inline intrinsic, method not annotated"){ bailout("failed to inline intrinsic, method not annotated")
; return; };
      }

      // Also we need intrinsic to prevent commoning reads from this field
      // across safepoint since GC can change its value.

      // Set up a stream so that appending instructions works properly.
      ciBytecodeStream s(scope->method());
      s.reset_to_bci(0);
      scope_data()->set_stream(&s);
      s.next();

      // setup the initial block state
      _block = start_block;
      _state = start_block->state()->copy_for_parsing();
      _last  = start_block;
      load_local(objectType, 0);

      // Emit the intrinsic node.
      bool result = try_inline_intrinsics(scope->method());
      if (!result) BAILOUT("failed to inline intrinsic"){ bailout("failed to inline intrinsic"); return; };
      method_return(apop());

      // connect the begin and end blocks and we're all done.
      BlockEnd* end = last()->as_BlockEnd();
      block()->set_end(end);
      break;
    }
    // Otherwise, fall thru
  }

default:
  scope_data()->add_to_work_list(start_block);
  iterate_all_blocks();
  break;
}
CHECK_BAILOUT(){ if (bailed_out()) return; };

3370# ifdef ASSERT1
//All blocks reachable from start_block have _end != NULL
{
  BlockList processed;
  BlockList to_go;
  to_go.append(start_block);
  while(to_go.length() > 0) {
    BlockBegin* current = to_go.pop();
    assert(current != NULL, "Should not happen.")do { if (!(current != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3378, "assert(" "current != __null" ") failed", "Should not happen."
); ::breakpoint(); } } while (0);
    assert(current->end() != NULL, "All blocks reachable from start_block should have end() != NULL.")do { if (!(current->end() != __null)) { (*g_assert_poison)
 = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3379, "assert(" "current->end() != __null" ") failed", "All blocks reachable from start_block should have end() != NULL."
); ::breakpoint(); } } while (0);
    processed.append(current);
    for(int i = 0; i < current->number_of_sux(); i++) {
      BlockBegin* s = current->sux_at(i);
      if (!processed.contains(s)) {
        to_go.append(s);
      }
    }
  }
}
3389#endif // ASSERT

_start = setup_start_block(osr_bci, start_block, _osr_entry, _initial_state);

eliminate_redundant_phis(_start);

NOT_PRODUCT(if (PrintValueNumbering && Verbose) print_stats())if (PrintValueNumbering && Verbose) print_stats();
// for osr compile, bailout if some requirements are not fulfilled
if (osr_bci != -1) {
  BlockBegin* osr_block = blm.bci2block()->at(osr_bci);
  if (!osr_block->is_set(BlockBegin::was_visited_flag)) {
    BAILOUT("osr entry must have been visited for osr compile"){ bailout("osr entry must have been visited for osr compile")
; return; };
  }

  // check if osr entry point has empty stack - we cannot handle non-empty stacks at osr entry points
  if (!osr_block->state()->stack_is_empty()) {
    BAILOUT("stack not empty at OSR entry point"){ bailout("stack not empty at OSR entry point"); return; };
  }
}
3408#ifndef PRODUCT
if (PrintCompilation && Verbose) tty->print_cr("Created %d Instructions", _instruction_count);
3410#endif
3411}


3414ValueStack* GraphBuilder::copy_state_before() {
return copy_state_before_with_bci(bci());
3416}

3418ValueStack* GraphBuilder::copy_state_exhandling() {
return copy_state_exhandling_with_bci(bci());
3420}

3422ValueStack* GraphBuilder::copy_state_for_exception() {
return copy_state_for_exception_with_bci(bci());
3424}

3426ValueStack* GraphBuilder::copy_state_before_with_bci(int bci) {
return state()->copy(ValueStack::StateBefore, bci);
3428}

3430ValueStack* GraphBuilder::copy_state_exhandling_with_bci(int bci) {
if (!has_handler()) return NULL__null;
return state()->copy(ValueStack::StateBefore, bci);
3433}

3435ValueStack* GraphBuilder::copy_state_for_exception_with_bci(int bci) {
ValueStack* s = copy_state_exhandling_with_bci(bci);
if (s == NULL__null) {
  if (_compilation->env()->should_retain_local_variables()) {
    s = state()->copy(ValueStack::ExceptionState, bci);
  } else {
    s = state()->copy(ValueStack::EmptyExceptionState, bci);
  }
}
return s;
3445}

3447int GraphBuilder::recursive_inline_level(ciMethod* cur_callee) const {
int recur_level = 0;
for (IRScope* s = scope(); s != NULL__null; s = s->caller()) {
  if (s->method() == cur_callee) {
    ++recur_level;
  }
}
return recur_level;
3455}


3458bool GraphBuilder::try_inline(ciMethod* callee, bool holder_known, bool ignore_return, Bytecodes::Code bc, Value receiver) {
const char* msg = NULL__null;

// clear out any existing inline bailout condition
clear_inline_bailout();

// exclude methods we don't want to inline
msg = should_not_inline(callee);
if (msg != NULL__null) {
  print_inlining(callee, msg, /*success*/ false);
  return false;
}

// method handle invokes
if (callee->is_method_handle_intrinsic()) {
  if (try_method_handle_inline(callee, ignore_return)) {
    if (callee->has_reserved_stack_access()) {
      compilation()->set_has_reserved_stack_access(true);
    }
    return true;
  }
  return false;
}

// handle intrinsics
if (callee->intrinsic_id() != vmIntrinsics::_none &&
    callee->check_intrinsic_candidate()) {
  if (try_inline_intrinsics(callee, ignore_return)) {
    print_inlining(callee, "intrinsic");
    if (callee->has_reserved_stack_access()) {
      compilation()->set_has_reserved_stack_access(true);
    }
    return true;
  }
  // try normal inlining
}

// certain methods cannot be parsed at all
msg = check_can_parse(callee);
if (msg != NULL__null) {
  print_inlining(callee, msg, /*success*/ false);
  return false;
}

// If bytecode not set use the current one.
if (bc == Bytecodes::_illegal) {
  bc = code();
}
if (try_inline_full(callee, holder_known, ignore_return, bc, receiver)) {
  if (callee->has_reserved_stack_access()) {
    compilation()->set_has_reserved_stack_access(true);
  }
  return true;
}

// Entire compilation could fail during try_inline_full call.
// In that case printing inlining decision info is useless.
if (!bailed_out())
  print_inlining(callee, _inline_bailout_msg, /*success*/ false);

return false;
3519}


3522const char* GraphBuilder::check_can_parse(ciMethod* callee) const {
// Certain methods cannot be parsed at all:
if ( callee->is_native())            return "native method";
if ( callee->is_abstract())          return "abstract method";
if (!callee->can_be_parsed())        return "cannot be parsed";
return NULL__null;
3528}

3530// negative filter: should callee NOT be inlined?  returns NULL, ok to inline, or rejection msg
3531const char* GraphBuilder::should_not_inline(ciMethod* callee) const {
if ( compilation()->directive()->should_not_inline(callee)) return "disallowed by CompileCommand";
if ( callee->dont_inline())          return "don't inline by annotation";
return NULL__null;
3535}

3537void GraphBuilder::build_graph_for_intrinsic(ciMethod* callee, bool ignore_return) {
vmIntrinsics::ID id = callee->intrinsic_id();
assert(id != vmIntrinsics::_none, "must be a VM intrinsic")do { if (!(id != vmIntrinsics::_none)) { (*g_assert_poison) =
 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3539, "assert(" "id != vmIntrinsics::_none" ") failed", "must be a VM intrinsic"
); ::breakpoint(); } } while (0);

// Some intrinsics need special IR nodes.
switch(id) {
case vmIntrinsics::_getReference           : append_unsafe_get(callee, T_OBJECT,  false); return;
case vmIntrinsics::_getBoolean             : append_unsafe_get(callee, T_BOOLEAN, false); return;
case vmIntrinsics::_getByte                : append_unsafe_get(callee, T_BYTE,    false); return;
case vmIntrinsics::_getShort               : append_unsafe_get(callee, T_SHORT,   false); return;
case vmIntrinsics::_getChar                : append_unsafe_get(callee, T_CHAR,    false); return;
case vmIntrinsics::_getInt                 : append_unsafe_get(callee, T_INT,     false); return;
case vmIntrinsics::_getLong                : append_unsafe_get(callee, T_LONG,    false); return;
case vmIntrinsics::_getFloat               : append_unsafe_get(callee, T_FLOAT,   false); return;
case vmIntrinsics::_getDouble              : append_unsafe_get(callee, T_DOUBLE,  false); return;
case vmIntrinsics::_putReference           : append_unsafe_put(callee, T_OBJECT,  false); return;
case vmIntrinsics::_putBoolean             : append_unsafe_put(callee, T_BOOLEAN, false); return;
case vmIntrinsics::_putByte                : append_unsafe_put(callee, T_BYTE,    false); return;
case vmIntrinsics::_putShort               : append_unsafe_put(callee, T_SHORT,   false); return;
case vmIntrinsics::_putChar                : append_unsafe_put(callee, T_CHAR,    false); return;
case vmIntrinsics::_putInt                 : append_unsafe_put(callee, T_INT,     false); return;
case vmIntrinsics::_putLong                : append_unsafe_put(callee, T_LONG,    false); return;
case vmIntrinsics::_putFloat               : append_unsafe_put(callee, T_FLOAT,   false); return;
case vmIntrinsics::_putDouble              : append_unsafe_put(callee, T_DOUBLE,  false); return;
case vmIntrinsics::_getShortUnaligned      : append_unsafe_get(callee, T_SHORT,   false); return;
case vmIntrinsics::_getCharUnaligned       : append_unsafe_get(callee, T_CHAR,    false); return;
case vmIntrinsics::_getIntUnaligned        : append_unsafe_get(callee, T_INT,     false); return;
case vmIntrinsics::_getLongUnaligned       : append_unsafe_get(callee, T_LONG,    false); return;
case vmIntrinsics::_putShortUnaligned      : append_unsafe_put(callee, T_SHORT,   false); return;
case vmIntrinsics::_putCharUnaligned       : append_unsafe_put(callee, T_CHAR,    false); return;
case vmIntrinsics::_putIntUnaligned        : append_unsafe_put(callee, T_INT,     false); return;
case vmIntrinsics::_putLongUnaligned       : append_unsafe_put(callee, T_LONG,    false); return;
case vmIntrinsics::_getReferenceVolatile   : append_unsafe_get(callee, T_OBJECT,  true); return;
case vmIntrinsics::_getBooleanVolatile     : append_unsafe_get(callee, T_BOOLEAN, true); return;
case vmIntrinsics::_getByteVolatile        : append_unsafe_get(callee, T_BYTE,    true); return;
case vmIntrinsics::_getShortVolatile       : append_unsafe_get(callee, T_SHORT,   true); return;
case vmIntrinsics::_getCharVolatile        : append_unsafe_get(callee, T_CHAR,    true); return;
case vmIntrinsics::_getIntVolatile         : append_unsafe_get(callee, T_INT,     true); return;
case vmIntrinsics::_getLongVolatile        : append_unsafe_get(callee, T_LONG,    true); return;
case vmIntrinsics::_getFloatVolatile       : append_unsafe_get(callee, T_FLOAT,   true); return;
case vmIntrinsics::_getDoubleVolatile      : append_unsafe_get(callee, T_DOUBLE,  true); return;
case vmIntrinsics::_putReferenceVolatile   : append_unsafe_put(callee, T_OBJECT,  true); return;
case vmIntrinsics::_putBooleanVolatile     : append_unsafe_put(callee, T_BOOLEAN, true); return;
case vmIntrinsics::_putByteVolatile        : append_unsafe_put(callee, T_BYTE,    true); return;
case vmIntrinsics::_putShortVolatile       : append_unsafe_put(callee, T_SHORT,   true); return;
case vmIntrinsics::_putCharVolatile        : append_unsafe_put(callee, T_CHAR,    true); return;
case vmIntrinsics::_putIntVolatile         : append_unsafe_put(callee, T_INT,     true); return;
case vmIntrinsics::_putLongVolatile        : append_unsafe_put(callee, T_LONG,    true); return;
case vmIntrinsics::_putFloatVolatile       : append_unsafe_put(callee, T_FLOAT,   true); return;
case vmIntrinsics::_putDoubleVolatile      : append_unsafe_put(callee, T_DOUBLE,  true); return;
case vmIntrinsics::_compareAndSetLong:
case vmIntrinsics::_compareAndSetInt:
case vmIntrinsics::_compareAndSetReference : append_unsafe_CAS(callee); return;
case vmIntrinsics::_getAndAddInt:
case vmIntrinsics::_getAndAddLong          : append_unsafe_get_and_set(callee, true); return;
case vmIntrinsics::_getAndSetInt           :
case vmIntrinsics::_getAndSetLong          :
case vmIntrinsics::_getAndSetReference     : append_unsafe_get_and_set(callee, false); return;
case vmIntrinsics::_getCharStringU         : append_char_access(callee, false); return;
case vmIntrinsics::_putCharStringU         : append_char_access(callee, true); return;
default:
  break;
}

// create intrinsic node
const bool has_receiver = !callee->is_static();
ValueType* result_type = as_ValueType(callee->return_type());
ValueStack* state_before = copy_state_for_exception();

Values* args = state()->pop_arguments(callee->arg_size());

if (is_profiling()) {
  // Don't profile in the special case where the root method
  // is the intrinsic
  if (callee != method()) {
    // Note that we'd collect profile data in this method if we wanted it.
    compilation()->set_would_profile(true);
    if (profile_calls()) {
      Value recv = NULL__null;
      if (has_receiver) {
        recv = args->at(0);
        null_check(recv);
      }
      profile_call(callee, recv, NULL__null, collect_args_for_profiling(args, callee, true), true);
    }
  }
}

Intrinsic* result = new Intrinsic(result_type, callee->intrinsic_id(),
                                  args, has_receiver, state_before,
                                  vmIntrinsics::preserves_state(id),
                                  vmIntrinsics::can_trap(id));
// append instruction & push result
Value value = append_split(result);
if (result_type != voidType && !ignore_return) {
  push(result_type, value);
}

if (callee != method() && profile_return() && result_type->is_object_kind()) {
  profile_return_type(result, callee);
}
3638}

3640bool GraphBuilder::try_inline_intrinsics(ciMethod* callee, bool ignore_return) {
// For calling is_intrinsic_available we need to transition to
// the '_thread_in_vm' state because is_intrinsic_available()
// accesses critical VM-internal data.
bool is_available = false;
{
  VM_ENTRY_MARKCompilerThread* thread=CompilerThread::current(); ThreadInVMfromNative
 __tiv(thread); HandleMarkCleaner __hm(thread); JavaThread* __the_thread__
 = thread; VMNativeEntryWrapper __vew;;
  methodHandle mh(THREAD__the_thread__, callee->get_Method());
  is_available = _compilation->compiler()->is_intrinsic_available(mh, _compilation->directive());
}

if (!is_available) {
  if (!InlineNatives) {
    // Return false and also set message that the inlining of
    // intrinsics has been disabled in general.
    INLINE_BAILOUT("intrinsic method inlining disabled"){ inline_bailout("intrinsic method inlining disabled"); return
 false; };
  } else {
    return false;
  }
}
build_graph_for_intrinsic(callee, ignore_return);
return true;
3662}


3665bool GraphBuilder::try_inline_jsr(int jsr_dest_bci) {
// Introduce a new callee continuation point - all Ret instructions
// will be replaced with Gotos to this point.
BlockBegin* cont = block_at(next_bci());
assert(cont != NULL, "continuation must exist (BlockListBuilder starts a new block after a jsr")do { if (!(cont != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3669, "assert(" "cont != __null" ") failed", "continuation must exist (BlockListBuilder starts a new block after a jsr"
); ::breakpoint(); } } while (0);

// Note: can not assign state to continuation yet, as we have to
// pick up the state from the Ret instructions.

// Push callee scope
push_scope_for_jsr(cont, jsr_dest_bci);

// Temporarily set up bytecode stream so we can append instructions
// (only using the bci of this stream)
scope_data()->set_stream(scope_data()->parent()->stream());

BlockBegin* jsr_start_block = block_at(jsr_dest_bci);
assert(jsr_start_block != NULL, "jsr start block must exist")do { if (!(jsr_start_block != __null)) { (*g_assert_poison) =
 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3682, "assert(" "jsr_start_block != __null" ") failed", "jsr start block must exist"
); ::breakpoint(); } } while (0);
assert(!jsr_start_block->is_set(BlockBegin::was_visited_flag), "should not have visited jsr yet")do { if (!(!jsr_start_block->is_set(BlockBegin::was_visited_flag
))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3683, "assert(" "!jsr_start_block->is_set(BlockBegin::was_visited_flag)"
 ") failed", "should not have visited jsr yet"); ::breakpoint
(); } } while (0);
Goto* goto_sub = new Goto(jsr_start_block, false);
// Must copy state to avoid wrong sharing when parsing bytecodes
assert(jsr_start_block->state() == NULL, "should have fresh jsr starting block")do { if (!(jsr_start_block->state() == __null)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3686, "assert(" "jsr_start_block->state() == __null" ") failed"
, "should have fresh jsr starting block"); ::breakpoint(); } }
 while (0);
jsr_start_block->set_state(copy_state_before_with_bci(jsr_dest_bci));
append(goto_sub);
_block->set_end(goto_sub);
_last = _block = jsr_start_block;

// Clear out bytecode stream
scope_data()->set_stream(NULL__null);

scope_data()->add_to_work_list(jsr_start_block);

// Ready to resume parsing in subroutine
iterate_all_blocks();

// If we bailed out during parsing, return immediately (this is bad news)
CHECK_BAILOUT_(false){ if (bailed_out()) return false; };

// Detect whether the continuation can actually be reached. If not,
// it has not had state set by the join() operations in
// iterate_bytecodes_for_block()/ret() and we should not touch the
// iteration state. The calling activation of
// iterate_bytecodes_for_block will then complete normally.
if (cont->state() != NULL__null) {
  if (!cont->is_set(BlockBegin::was_visited_flag)) {
    // add continuation to work list instead of parsing it immediately
    scope_data()->parent()->add_to_work_list(cont);
  }
}

assert(jsr_continuation() == cont, "continuation must not have changed")do { if (!(jsr_continuation() == cont)) { (*g_assert_poison) =
 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3715, "assert(" "jsr_continuation() == cont" ") failed", "continuation must not have changed"
); ::breakpoint(); } } while (0);
assert(!jsr_continuation()->is_set(BlockBegin::was_visited_flag) ||do { if (!(!jsr_continuation()->is_set(BlockBegin::was_visited_flag
) || jsr_continuation()->is_set(BlockBegin::parser_loop_header_flag
))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3718, "assert(" "!jsr_continuation()->is_set(BlockBegin::was_visited_flag) || jsr_continuation()->is_set(BlockBegin::parser_loop_header_flag)"
 ") failed", "continuation can only be visited in case of backward branches"
); ::breakpoint(); } } while (0)
       jsr_continuation()->is_set(BlockBegin::parser_loop_header_flag),do { if (!(!jsr_continuation()->is_set(BlockBegin::was_visited_flag
) || jsr_continuation()->is_set(BlockBegin::parser_loop_header_flag
))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3718, "assert(" "!jsr_continuation()->is_set(BlockBegin::was_visited_flag) || jsr_continuation()->is_set(BlockBegin::parser_loop_header_flag)"
 ") failed", "continuation can only be visited in case of backward branches"
); ::breakpoint(); } } while (0)
       "continuation can only be visited in case of backward branches")do { if (!(!jsr_continuation()->is_set(BlockBegin::was_visited_flag
) || jsr_continuation()->is_set(BlockBegin::parser_loop_header_flag
))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3718, "assert(" "!jsr_continuation()->is_set(BlockBegin::was_visited_flag) || jsr_continuation()->is_set(BlockBegin::parser_loop_header_flag)"
 ") failed", "continuation can only be visited in case of backward branches"
); ::breakpoint(); } } while (0);
assert(_last && _last->as_BlockEnd(), "block must have end")do { if (!(_last && _last->as_BlockEnd())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3719, "assert(" "_last && _last->as_BlockEnd()" ") failed"
, "block must have end"); ::breakpoint(); } } while (0);

// continuation is in work list, so end iteration of current block
_skip_block = true;
pop_scope_for_jsr();

return true;
3726}


3729// Inline the entry of a synchronized method as a monitor enter and
3730// register the exception handler which releases the monitor if an
3731// exception is thrown within the callee. Note that the monitor enter
3732// cannot throw an exception itself, because the receiver is
3733// guaranteed to be non-null by the explicit null check at the
3734// beginning of inlining.
3735void GraphBuilder::inline_sync_entry(Value lock, BlockBegin* sync_handler) {
assert(lock != NULL && sync_handler != NULL, "lock or handler missing")do { if (!(lock != __null && sync_handler != __null))
 { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3736, "assert(" "lock != __null && sync_handler != __null"
 ") failed", "lock or handler missing"); ::breakpoint(); } } while
 (0);

monitorenter(lock, SynchronizationEntryBCI);
assert(_last->as_MonitorEnter() != NULL, "monitor enter expected")do { if (!(_last->as_MonitorEnter() != __null)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3739, "assert(" "_last->as_MonitorEnter() != __null" ") failed"
, "monitor enter expected"); ::breakpoint(); } } while (0);
_last->set_needs_null_check(false);

sync_handler->set(BlockBegin::exception_entry_flag);
sync_handler->set(BlockBegin::is_on_work_list_flag);

ciExceptionHandler* desc = new ciExceptionHandler(method()->holder(), 0, method()->code_size(), -1, 0);
XHandler* h = new XHandler(desc);
h->set_entry_block(sync_handler);
scope_data()->xhandlers()->append(h);
scope_data()->set_has_handler();
3750}


3753// If an exception is thrown and not handled within an inlined
3754// synchronized method, the monitor must be released before the
3755// exception is rethrown in the outer scope. Generate the appropriate
3756// instructions here.
3757void GraphBuilder::fill_sync_handler(Value lock, BlockBegin* sync_handler, bool default_handler) {
BlockBegin* orig_block = _block;
ValueStack* orig_state = _state;
Instruction* orig_last = _last;
_last = _block = sync_handler;
_state = sync_handler->state()->copy();

assert(sync_handler != NULL, "handler missing")do { if (!(sync_handler != __null)) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3764, "assert(" "sync_handler != __null" ") failed", "handler missing"
); ::breakpoint(); } } while (0);
assert(!sync_handler->is_set(BlockBegin::was_visited_flag), "is visited here")do { if (!(!sync_handler->is_set(BlockBegin::was_visited_flag
))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3765, "assert(" "!sync_handler->is_set(BlockBegin::was_visited_flag)"
 ") failed", "is visited here"); ::breakpoint(); } } while (0
);

assert(lock != NULL || default_handler, "lock or handler missing")do { if (!(lock != __null || default_handler)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3767, "assert(" "lock != __null || default_handler" ") failed"
, "lock or handler missing"); ::breakpoint(); } } while (0);

XHandler* h = scope_data()->xhandlers()->remove_last();
assert(h->entry_block() == sync_handler, "corrupt list of handlers")do { if (!(h->entry_block() == sync_handler)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3770, "assert(" "h->entry_block() == sync_handler" ") failed"
, "corrupt list of handlers"); ::breakpoint(); } } while (0);

block()->set(BlockBegin::was_visited_flag);
Value exception = append_with_bci(new ExceptionObject(), SynchronizationEntryBCI);
assert(exception->is_pinned(), "must be")do { if (!(exception->is_pinned())) { (*g_assert_poison) =
 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3774, "assert(" "exception->is_pinned()" ") failed", "must be"
); ::breakpoint(); } } while (0);

int bci = SynchronizationEntryBCI;
if (compilation()->env()->dtrace_method_probes()) {
  // Report exit from inline methods.  We don't have a stream here
  // so pass an explicit bci of SynchronizationEntryBCI.
  Values* args = new Values(1);
  args->push(append_with_bci(new Constant(new MethodConstant(method())), bci));
  append_with_bci(new RuntimeCall(voidType, "dtrace_method_exit", CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_exit)((address)((address_word)(SharedRuntime::dtrace_method_exit))
), args), bci);
}

if (lock) {
  assert(state()->locks_size() > 0 && state()->lock_at(state()->locks_size() - 1) == lock, "lock is missing")do { if (!(state()->locks_size() > 0 && state()
->lock_at(state()->locks_size() - 1) == lock)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3786, "assert(" "state()->locks_size() > 0 && state()->lock_at(state()->locks_size() - 1) == lock"
 ") failed", "lock is missing"); ::breakpoint(); } } while (0
);
  if (!lock->is_linked()) {
    lock = append_with_bci(lock, bci);
  }

  // exit the monitor in the context of the synchronized method
  monitorexit(lock, bci);

  // exit the context of the synchronized method
  if (!default_handler) {
    pop_scope();
    bci = _state->caller_state()->bci();
    _state = _state->caller_state()->copy_for_parsing();
  }
}

// perform the throw as if at the the call site
apush(exception);
throw_op(bci);

BlockEnd* end = last()->as_BlockEnd();
block()->set_end(end);

_block = orig_block;
_state = orig_state;
_last = orig_last;
3812}


3815bool GraphBuilder::try_inline_full(ciMethod* callee, bool holder_known, bool ignore_return, Bytecodes::Code bc, Value receiver) {
assert(!callee->is_native(), "callee must not be native")do { if (!(!callee->is_native())) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3816, "assert(" "!callee->is_native()" ") failed", "callee must not be native"
); ::breakpoint(); } } while (0);
if (CompilationPolicy::should_not_inline(compilation()->env(), callee)) {
  INLINE_BAILOUT("inlining prohibited by policy"){ inline_bailout("inlining prohibited by policy"); return false
; };
}
// first perform tests of things it's not possible to inline
if (callee->has_exception_handlers() &&
    !InlineMethodsWithExceptionHandlers) INLINE_BAILOUT("callee has exception handlers"){ inline_bailout("callee has exception handlers"); return false
; };
if (callee->is_synchronized() &&
    !InlineSynchronizedMethods         ) INLINE_BAILOUT("callee is synchronized"){ inline_bailout("callee is synchronized"); return false; };
if (!callee->holder()->is_linked())      INLINE_BAILOUT("callee's klass not linked yet"){ inline_bailout("callee's klass not linked yet"); return false
; };
if (bc == Bytecodes::_invokestatic &&
    !callee->holder()->is_initialized()) INLINE_BAILOUT("callee's klass not initialized yet"){ inline_bailout("callee's klass not initialized yet"); return
 false; };
if (!callee->has_balanced_monitors())    INLINE_BAILOUT("callee's monitors do not match"){ inline_bailout("callee's monitors do not match"); return false
; };

// Proper inlining of methods with jsrs requires a little more work.
if (callee->has_jsrs()                 ) INLINE_BAILOUT("jsrs not handled properly by inliner yet"){ inline_bailout("jsrs not handled properly by inliner yet");
 return false; };

if (is_profiling() && !callee->ensure_method_data()) {
  INLINE_BAILOUT("mdo allocation failed"){ inline_bailout("mdo allocation failed"); return false; };
}

const bool is_invokedynamic = (bc == Bytecodes::_invokedynamic);
const bool has_receiver = (bc != Bytecodes::_invokestatic && !is_invokedynamic);

const int args_base = state()->stack_size() - callee->arg_size();
assert(args_base >= 0, "stack underflow during inlining")do { if (!(args_base >= 0)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3841, "assert(" "args_base >= 0" ") failed", "stack underflow during inlining"
); ::breakpoint(); } } while (0);

Value recv = NULL__null;
if (has_receiver) {
  assert(!callee->is_static(), "callee must not be static")do { if (!(!callee->is_static())) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3845, "assert(" "!callee->is_static()" ") failed", "callee must not be static"
); ::breakpoint(); } } while (0);
  assert(callee->arg_size() > 0, "must have at least a receiver")do { if (!(callee->arg_size() > 0)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3846, "assert(" "callee->arg_size() > 0" ") failed", "must have at least a receiver"
); ::breakpoint(); } } while (0);

  recv = state()->stack_at(args_base);
  if (recv->is_null_obj()) {
    INLINE_BAILOUT("receiver is always null"){ inline_bailout("receiver is always null"); return false; };
  }
}

// now perform tests that are based on flag settings
bool inlinee_by_directive = compilation()->directive()->should_inline(callee);
if (callee->force_inline() || inlinee_by_directive) {
  if (inline_level() > MaxForceInlineLevel                      ) INLINE_BAILOUT("MaxForceInlineLevel"){ inline_bailout("MaxForceInlineLevel"); return false; };
  if (recursive_inline_level(callee) > C1MaxRecursiveInlineLevel) INLINE_BAILOUT("recursive inlining too deep"){ inline_bailout("recursive inlining too deep"); return false
; };

  const char* msg = "";
  if (callee->force_inline())  msg = "force inline by annotation";
  if (inlinee_by_directive)    msg = "force inline by CompileCommand";
  print_inlining(callee, msg);
} else {
  // use heuristic controls on inlining
  if (inline_level() > C1MaxInlineLevel                       ) INLINE_BAILOUT("inlining too deep"){ inline_bailout("inlining too deep"); return false; };
  int callee_recursive_level = recursive_inline_level(callee);
  if (callee_recursive_level > C1MaxRecursiveInlineLevel      ) INLINE_BAILOUT("recursive inlining too deep"){ inline_bailout("recursive inlining too deep"); return false
; };
  if (callee->code_size_for_inlining() > max_inline_size()    ) INLINE_BAILOUT("callee is too large"){ inline_bailout("callee is too large"); return false; };
  // Additional condition to limit stack usage for non-recursive calls.
  if ((callee_recursive_level == 0) &&
      (callee->max_stack() + callee->max_locals() - callee->size_of_parameters() > C1InlineStackLimit)) {
    INLINE_BAILOUT("callee uses too much stack"){ inline_bailout("callee uses too much stack"); return false;
 };
  }

  // don't inline throwable methods unless the inlining tree is rooted in a throwable class
  if (callee->name() == ciSymbols::object_initializer_name() &&
      callee->holder()->is_subclass_of(ciEnv::current()->Throwable_klass())) {
    // Throwable constructor call
    IRScope* top = scope();
    while (top->caller() != NULL__null) {
      top = top->caller();
    }
    if (!top->method()->holder()->is_subclass_of(ciEnv::current()->Throwable_klass())) {
      INLINE_BAILOUT("don't inline Throwable constructors"){ inline_bailout("don't inline Throwable constructors"); return
 false; };
    }
  }

  if (compilation()->env()->num_inlined_bytecodes() > DesiredMethodLimit) {
    INLINE_BAILOUT("total inlining greater than DesiredMethodLimit"){ inline_bailout("total inlining greater than DesiredMethodLimit"
); return false; };
  }
  // printing
  print_inlining(callee, "inline", /*success*/ true);
}

assert(bc != Bytecodes::_invokestatic || callee->holder()->is_initialized(), "required")do { if (!(bc != Bytecodes::_invokestatic || callee->holder
()->is_initialized())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3896, "assert(" "bc != Bytecodes::_invokestatic || callee->holder()->is_initialized()"
 ") failed", "required"); ::breakpoint(); } } while (0);

// NOTE: Bailouts from this point on, which occur at the
// GraphBuilder level, do not cause bailout just of the inlining but
// in fact of the entire compilation.

BlockBegin* orig_block = block();

// Insert null check if necessary
if (has_receiver) {
  // note: null check must happen even if first instruction of callee does
  //       an implicit null check since the callee is in a different scope
  //       and we must make sure exception handling does the right thing
  null_check(recv);
}

if (is_profiling()) {
  // Note that we'd collect profile data in this method if we wanted it.
  // this may be redundant here...
  compilation()->set_would_profile(true);

  if (profile_calls()) {
    int start = 0;
    Values* obj_args = args_list_for_profiling(callee, start, has_receiver);
    if (obj_args != NULL__null) {
      int s = obj_args->max_length();
      // if called through method handle invoke, some arguments may have been popped
      for (int i = args_base+start, j = 0; j < obj_args->max_length() && i < state()->stack_size(); ) {
        Value v = state()->stack_at_inc(i);
        if (v->type()->is_object_kind()) {
          obj_args->push(v);
          j++;
        }
      }
      check_args_for_profiling(obj_args, s);
    }
    profile_call(callee, recv, holder_known ? callee->holder() : NULL__null, obj_args, true);
  }
}

// Introduce a new callee continuation point - if the callee has
// more than one return instruction or the return does not allow
// fall-through of control flow, all return instructions of the
// callee will need to be replaced by Goto's pointing to this
// continuation point.
BlockBegin* cont = block_at(next_bci());
bool continuation_existed = true;
if (cont == NULL__null) {
  cont = new BlockBegin(next_bci());
  // low number so that continuation gets parsed as early as possible
  cont->set_depth_first_number(0);
  if (PrintInitialBlockList) {
    tty->print_cr("CFG: created block %d (bci %d) as continuation for inline at bci %d",
                  cont->block_id(), cont->bci(), bci());
  }
  continuation_existed = false;
}
// Record number of predecessors of continuation block before
// inlining, to detect if inlined method has edges to its
// continuation after inlining.
int continuation_preds = cont->number_of_preds();

// Push callee scope
push_scope(callee, cont);

// the BlockListBuilder for the callee could have bailed out
if (bailed_out())
    return false;

// Temporarily set up bytecode stream so we can append instructions
// (only using the bci of this stream)
scope_data()->set_stream(scope_data()->parent()->stream());

// Pass parameters into callee state: add assignments
// note: this will also ensure that all arguments are computed before being passed
ValueStack* callee_state = state();
ValueStack* caller_state = state()->caller_state();
for (int i = args_base; i < caller_state->stack_size(); ) {
  const int arg_no = i - args_base;
  Value arg = caller_state->stack_at_inc(i);
  store_local(callee_state, arg, arg_no);
}

// Remove args from stack.
// Note that we preserve locals state in case we can use it later
// (see use of pop_scope() below)
caller_state->truncate_stack(args_base);
assert(callee_state->stack_size() == 0, "callee stack must be empty")do { if (!(callee_state->stack_size() == 0)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 3983, "assert(" "callee_state->stack_size() == 0" ") failed"
, "callee stack must be empty"); ::breakpoint(); } } while (0
);

Value lock = NULL__null;
BlockBegin* sync_handler = NULL__null;

// Inline the locking of the receiver if the callee is synchronized
if (callee->is_synchronized()) {
  lock = callee->is_static() ? append(new Constant(new InstanceConstant(callee->holder()->java_mirror())))
                             : state()->local_at(0);
  sync_handler = new BlockBegin(SynchronizationEntryBCI);
  inline_sync_entry(lock, sync_handler);
}

if (compilation()->env()->dtrace_method_probes()) {
  Values* args = new Values(1);
  args->push(append(new Constant(new MethodConstant(method()))));
  append(new RuntimeCall(voidType, "dtrace_method_entry", CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_entry)((address)((address_word)(SharedRuntime::dtrace_method_entry)
)), args));
}

if (profile_inlined_calls()) {
  profile_invocation(callee, copy_state_before_with_bci(SynchronizationEntryBCI));
}

BlockBegin* callee_start_block = block_at(0);
if (callee_start_block != NULL__null) {
  assert(callee_start_block->is_set(BlockBegin::parser_loop_header_flag), "must be loop header")do { if (!(callee_start_block->is_set(BlockBegin::parser_loop_header_flag
))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 4008, "assert(" "callee_start_block->is_set(BlockBegin::parser_loop_header_flag)"
 ") failed", "must be loop header"); ::breakpoint(); } } while
 (0);
  Goto* goto_callee = new Goto(callee_start_block, false);
  // The state for this goto is in the scope of the callee, so use
  // the entry bci for the callee instead of the call site bci.
  append_with_bci(goto_callee, 0);
  _block->set_end(goto_callee);
  callee_start_block->merge(callee_state);

  _last = _block = callee_start_block;

  scope_data()->add_to_work_list(callee_start_block);
}

// Clear out bytecode stream
scope_data()->set_stream(NULL__null);
scope_data()->set_ignore_return(ignore_return);

CompileLog* log = compilation()->log();
if (log != NULL__null) log->head("parse method='%d'", log->identify(callee));

// Ready to resume parsing in callee (either in the same block we
// were in before or in the callee's start block)
iterate_all_blocks(callee_start_block == NULL__null);

if (log != NULL__null) log->done("parse");

// If we bailed out during parsing, return immediately (this is bad news)
if (bailed_out())
    return false;

// iterate_all_blocks theoretically traverses in random order; in
// practice, we have only traversed the continuation if we are
// inlining into a subroutine
assert(continuation_existed ||do { if (!(continuation_existed || !continuation()->is_set
(BlockBegin::was_visited_flag))) { (*g_assert_poison) = 'X';;
 report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 4043, "assert(" "continuation_existed || !continuation()->is_set(BlockBegin::was_visited_flag)"
 ") failed", "continuation should not have been parsed yet if we created it"
); ::breakpoint(); } } while (0)
       !continuation()->is_set(BlockBegin::was_visited_flag),do { if (!(continuation_existed || !continuation()->is_set
(BlockBegin::was_visited_flag))) { (*g_assert_poison) = 'X';;
 report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 4043, "assert(" "continuation_existed || !continuation()->is_set(BlockBegin::was_visited_flag)"
 ") failed", "continuation should not have been parsed yet if we created it"
); ::breakpoint(); } } while (0)
       "continuation should not have been parsed yet if we created it")do { if (!(continuation_existed || !continuation()->is_set
(BlockBegin::was_visited_flag))) { (*g_assert_poison) = 'X';;
 report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 4043, "assert(" "continuation_existed || !continuation()->is_set(BlockBegin::was_visited_flag)"
 ") failed", "continuation should not have been parsed yet if we created it"
); ::breakpoint(); } } while (0);

// At this point we are almost ready to return and resume parsing of
// the caller back in the GraphBuilder. The only thing we want to do
// first is an optimization: during parsing of the callee we
// generated at least one Goto to the continuation block. If we
// generated exactly one, and if the inlined method spanned exactly
// one block (and we didn't have to Goto its entry), then we snip
// off the Goto to the continuation, allowing control to fall
// through back into the caller block and effectively performing
// block merging. This allows load elimination and CSE to take place
// across multiple callee scopes if they are relatively simple, and
// is currently essential to making inlining profitable.
if (num_returns() == 1
    && block() == orig_block
    && block() == inline_cleanup_block()) {
  _last  = inline_cleanup_return_prev();
  _state = inline_cleanup_state();
} else if (continuation_preds == cont->number_of_preds()) {
  // Inlining caused that the instructions after the invoke in the
  // caller are not reachable any more. So skip filling this block
  // with instructions!
  assert(cont == continuation(), "")do { if (!(cont == continuation())) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 4065, "assert(" "cont == continuation()" ") failed", ""); ::
breakpoint(); } } while (0);
  assert(_last && _last->as_BlockEnd(), "")do { if (!(_last && _last->as_BlockEnd())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 4066, "assert(" "_last && _last->as_BlockEnd()" ") failed"
, ""); ::breakpoint(); } } while (0);
  _skip_block = true;
} else {
  // Resume parsing in continuation block unless it was already parsed.
  // Note that if we don't change _last here, iteration in
  // iterate_bytecodes_for_block will stop when we return.
  if (!continuation()->is_set(BlockBegin::was_visited_flag)) {
    // add continuation to work list instead of parsing it immediately
    assert(_last && _last->as_BlockEnd(), "")do { if (!(_last && _last->as_BlockEnd())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 4074, "assert(" "_last && _last->as_BlockEnd()" ") failed"
, ""); ::breakpoint(); } } while (0);
    scope_data()->parent()->add_to_work_list(continuation());
    _skip_block = true;
  }
}

// Fill the exception handler for synchronized methods with instructions
if (callee->is_synchronized() && sync_handler->state() != NULL__null) {
  fill_sync_handler(lock, sync_handler);
} else {
  pop_scope();
}

compilation()->notice_inlined_method(callee);

return true;
4090}


4093bool GraphBuilder::try_method_handle_inline(ciMethod* callee, bool ignore_return) {
ValueStack* state_before = copy_state_before();
vmIntrinsics::ID iid = callee->intrinsic_id();
switch (iid) {
case vmIntrinsics::_invokeBasic:
  {
    // get MethodHandle receiver
    const int args_base = state()->stack_size() - callee->arg_size();
    ValueType* type = state()->stack_at(args_base)->type();
    if (type->is_constant()) {
      ciMethod* target = type->as_ObjectType()->constant_value()->as_method_handle()->get_vmtarget();
      // We don't do CHA here so only inline static and statically bindable methods.
      if (target->is_static() || target->can_be_statically_bound()) {
        if (ciMethod::is_consistent_info(callee, target)) {
          Bytecodes::Code bc = target->is_static() ? Bytecodes::_invokestatic : Bytecodes::_invokevirtual;
          ignore_return = ignore_return || (callee->return_type()->is_void() && !target->return_type()->is_void());
          if (try_inline(target, /*holder_known*/ !callee->is_static(), ignore_return, bc)) {
            return true;
          }
        } else {
          print_inlining(target, "signatures mismatch", /*success*/ false);
        }
      } else {
        print_inlining(target, "not static or statically bindable", /*success*/ false);
      }
    } else {
      print_inlining(callee, "receiver not constant", /*success*/ false);
    }
  }
  break;

case vmIntrinsics::_linkToVirtual:
case vmIntrinsics::_linkToStatic:
case vmIntrinsics::_linkToSpecial:
case vmIntrinsics::_linkToInterface:
  {
    // pop MemberName argument
    const int args_base = state()->stack_size() - callee->arg_size();
    ValueType* type = apop()->type();
    if (type->is_constant()) {
      ciMethod* target = type->as_ObjectType()->constant_value()->as_member_name()->get_vmtarget();
      ignore_return = ignore_return || (callee->return_type()->is_void() && !target->return_type()->is_void());
      // If the target is another method handle invoke, try to recursively get
      // a better target.
      if (target->is_method_handle_intrinsic()) {
        if (try_method_handle_inline(target, ignore_return)) {
          return true;
        }
      } else if (!ciMethod::is_consistent_info(callee, target)) {
        print_inlining(target, "signatures mismatch", /*success*/ false);
      } else {
        ciSignature* signature = target->signature();
        const int receiver_skip = target->is_static() ? 0 : 1;
        // Cast receiver to its type.
        if (!target->is_static()) {
          ciKlass* tk = signature->accessing_klass();
          Value obj = state()->stack_at(args_base);
          if (obj->exact_type() == NULL__null &&
              obj->declared_type() != tk && tk != compilation()->env()->Object_klass()) {
            TypeCast* c = new TypeCast(tk, obj, state_before);
            append(c);
            state()->stack_at_put(args_base, c);
          }
        }
        // Cast reference arguments to its type.
        for (int i = 0, j = 0; i < signature->count(); i++) {
          ciType* t = signature->type_at(i);
          if (t->is_klass()) {
            ciKlass* tk = t->as_klass();
            Value obj = state()->stack_at(args_base + receiver_skip + j);
            if (obj->exact_type() == NULL__null &&
                obj->declared_type() != tk && tk != compilation()->env()->Object_klass()) {
              TypeCast* c = new TypeCast(t, obj, state_before);
              append(c);
              state()->stack_at_put(args_base + receiver_skip + j, c);
            }
          }
          j += t->size();  // long and double take two slots
        }
        // We don't do CHA here so only inline static and statically bindable methods.
        if (target->is_static() || target->can_be_statically_bound()) {
          Bytecodes::Code bc = target->is_static() ? Bytecodes::_invokestatic : Bytecodes::_invokevirtual;
          if (try_inline(target, /*holder_known*/ !callee->is_static(), ignore_return, bc)) {
            return true;
          }
        } else {
          print_inlining(target, "not static or statically bindable", /*success*/ false);
        }
      }
    } else {
      print_inlining(callee, "MemberName not constant", /*success*/ false);
    }
  }
  break;

case vmIntrinsics::_linkToNative:
  break; // TODO: NYI

default:
  fatal("unexpected intrinsic %d: %s", vmIntrinsics::as_int(iid), vmIntrinsics::name_at(iid))do { (*g_assert_poison) = 'X';; report_fatal(INTERNAL_ERROR, "/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 4192, "unexpected intrinsic %d: %s", vmIntrinsics::as_int(iid
), vmIntrinsics::name_at(iid)); ::breakpoint(); } while (0);
  break;
}
set_state(state_before->copy_for_parsing());
return false;
4197}


4200void GraphBuilder::inline_bailout(const char* msg) {
assert(msg != NULL, "inline bailout msg must exist")do { if (!(msg != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 4201, "assert(" "msg != __null" ") failed", "inline bailout msg must exist"
); ::breakpoint(); } } while (0);
_inline_bailout_msg = msg;
4203}


4206void GraphBuilder::clear_inline_bailout() {
_inline_bailout_msg = NULL__null;
4208}


4211void GraphBuilder::push_root_scope(IRScope* scope, BlockList* bci2block, BlockBegin* start) {
ScopeData* data = new ScopeData(NULL__null);
data->set_scope(scope);
data->set_bci2block(bci2block);
_scope_data = data;
_block = start;
4217}


4220void GraphBuilder::push_scope(ciMethod* callee, BlockBegin* continuation) {
IRScope* callee_scope = new IRScope(compilation(), scope(), bci(), callee, -1, false);
scope()->add_callee(callee_scope);

BlockListBuilder blb(compilation(), callee_scope, -1);
CHECK_BAILOUT(){ if (bailed_out()) return; };

if (!blb.bci2block()->at(0)->is_set(BlockBegin::parser_loop_header_flag)) {
  // this scope can be inlined directly into the caller so remove
  // the block at bci 0.
  blb.bci2block()->at_put(0, NULL__null);
}

set_state(new ValueStack(callee_scope, state()->copy(ValueStack::CallerState, bci())));

ScopeData* data = new ScopeData(scope_data());
data->set_scope(callee_scope);
data->set_bci2block(blb.bci2block());
data->set_continuation(continuation);
_scope_data = data;
4240}


4243void GraphBuilder::push_scope_for_jsr(BlockBegin* jsr_continuation, int jsr_dest_bci) {
ScopeData* data = new ScopeData(scope_data());
data->set_parsing_jsr();
data->set_jsr_entry_bci(jsr_dest_bci);
data->set_jsr_return_address_local(-1);
// Must clone bci2block list as we will be mutating it in order to
// properly clone all blocks in jsr region as well as exception
// handlers containing rets
BlockList* new_bci2block = new BlockList(bci2block()->length());
new_bci2block->appendAll(bci2block());
data->set_bci2block(new_bci2block);
data->set_scope(scope());
data->setup_jsr_xhandlers();
data->set_continuation(continuation());
data->set_jsr_continuation(jsr_continuation);
_scope_data = data;
4259}


4262void GraphBuilder::pop_scope() {
int number_of_locks = scope()->number_of_locks();
_scope_data = scope_data()->parent();
// accumulate minimum number of monitor slots to be reserved
scope()->set_min_number_of_locks(number_of_locks);
4267}


4270void GraphBuilder::pop_scope_for_jsr() {
_scope_data = scope_data()->parent();
4272}

4274void GraphBuilder::append_unsafe_get(ciMethod* callee, BasicType t, bool is_volatile) {
Values* args = state()->pop_arguments(callee->arg_size());
null_check(args->at(0));
Instruction* offset = args->at(2);
4278#ifndef _LP641
offset = append(new Convert(Bytecodes::_l2i, offset, as_ValueType(T_INT)));
4280#endif
Instruction* op = append(new UnsafeGet(t, args->at(1), offset, is_volatile));
push(op->type(), op);
compilation()->set_has_unsafe_access(true);
4284}


4287void GraphBuilder::append_unsafe_put(ciMethod* callee, BasicType t, bool is_volatile) {
Values* args = state()->pop_arguments(callee->arg_size());
null_check(args->at(0));
Instruction* offset = args->at(2);
4291#ifndef _LP641
offset = append(new Convert(Bytecodes::_l2i, offset, as_ValueType(T_INT)));
4293#endif
Value val = args->at(3);
if (t == T_BOOLEAN) {
  Value mask = append(new Constant(new IntConstant(1)));
  val = append(new LogicOp(Bytecodes::_iand, val, mask));
}
Instruction* op = append(new UnsafePut(t, args->at(1), offset, val, is_volatile));
compilation()->set_has_unsafe_access(true);
kill_all();
4302}

4304void GraphBuilder::append_unsafe_CAS(ciMethod* callee) {
ValueStack* state_before = copy_state_for_exception();
ValueType* result_type = as_ValueType(callee->return_type());
assert(result_type->is_int(), "int result")do { if (!(result_type->is_int())) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 4307, "assert(" "result_type->is_int()" ") failed", "int result"
); ::breakpoint(); } } while (0);
Values* args = state()->pop_arguments(callee->arg_size());

// Pop off some args to specially handle, then push back
Value newval = args->pop();
Value cmpval = args->pop();
Value offset = args->pop();
Value src = args->pop();
Value unsafe_obj = args->pop();

// Separately handle the unsafe arg. It is not needed for code
// generation, but must be null checked
null_check(unsafe_obj);

4321#ifndef _LP641
offset = append(new Convert(Bytecodes::_l2i, offset, as_ValueType(T_INT)));
4323#endif

args->push(src);
args->push(offset);
args->push(cmpval);
args->push(newval);

// An unsafe CAS can alias with other field accesses, but we don't
// know which ones so mark the state as no preserved.  This will
// cause CSE to invalidate memory across it.
bool preserves_state = false;
Intrinsic* result = new Intrinsic(result_type, callee->intrinsic_id(), args, false, state_before, preserves_state);
append_split(result);
push(result_type, result);
compilation()->set_has_unsafe_access(true);
4338}

4340void GraphBuilder::append_char_access(ciMethod* callee, bool is_store) {
// This intrinsic accesses byte[] array as char[] array. Computing the offsets
// correctly requires matched array shapes.
assert (arrayOopDesc::base_offset_in_bytes(T_CHAR) == arrayOopDesc::base_offset_in_bytes(T_BYTE),do { if (!(arrayOopDesc::base_offset_in_bytes(T_CHAR) == arrayOopDesc
::base_offset_in_bytes(T_BYTE))) { (*g_assert_poison) = 'X';;
 report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 4344, "assert(" "arrayOopDesc::base_offset_in_bytes(T_CHAR) == arrayOopDesc::base_offset_in_bytes(T_BYTE)"
 ") failed", "sanity: byte[] and char[] bases agree"); ::breakpoint
(); } } while (0)
        "sanity: byte[] and char[] bases agree")do { if (!(arrayOopDesc::base_offset_in_bytes(T_CHAR) == arrayOopDesc
::base_offset_in_bytes(T_BYTE))) { (*g_assert_poison) = 'X';;
 report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 4344, "assert(" "arrayOopDesc::base_offset_in_bytes(T_CHAR) == arrayOopDesc::base_offset_in_bytes(T_BYTE)"
 ") failed", "sanity: byte[] and char[] bases agree"); ::breakpoint
(); } } while (0);
assert (type2aelembytes(T_CHAR) == type2aelembytes(T_BYTE)*2,do { if (!(type2aelembytes(T_CHAR) == type2aelembytes(T_BYTE)
*2)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 4346, "assert(" "type2aelembytes(T_CHAR) == type2aelembytes(T_BYTE)*2"
 ") failed", "sanity: byte[] and char[] scales agree"); ::breakpoint
(); } } while (0)
        "sanity: byte[] and char[] scales agree")do { if (!(type2aelembytes(T_CHAR) == type2aelembytes(T_BYTE)
*2)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 4346, "assert(" "type2aelembytes(T_CHAR) == type2aelembytes(T_BYTE)*2"
 ") failed", "sanity: byte[] and char[] scales agree"); ::breakpoint
(); } } while (0);

ValueStack* state_before = copy_state_indexed_access();
compilation()->set_has_access_indexed(true);
Values* args = state()->pop_arguments(callee->arg_size());
Value array = args->at(0);
Value index = args->at(1);
if (is_store) {
  Value value = args->at(2);
  Instruction* store = append(new StoreIndexed(array, index, NULL__null, T_CHAR, value, state_before, false, true));
  store->set_flag(Instruction::NeedsRangeCheckFlag, false);
  _memory->store_value(value);
} else {
  Instruction* load = append(new LoadIndexed(array, index, NULL__null, T_CHAR, state_before, true));
  load->set_flag(Instruction::NeedsRangeCheckFlag, false);
  push(load->type(), load);
}
4363}

4365void GraphBuilder::print_inlining(ciMethod* callee, const char* msg, bool success) {
CompileLog* log = compilation()->log();
if (log != NULL__null) {
  assert(msg != NULL, "inlining msg should not be null!")do { if (!(msg != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 4368, "assert(" "msg != __null" ") failed", "inlining msg should not be null!"
); ::breakpoint(); } } while (0);
  if (success) {
    log->inline_success(msg);
  } else {
    log->inline_fail(msg);
  }
}
EventCompilerInlining event;
if (event.should_commit()) {
  CompilerEvent::InlineEvent::post(event, compilation()->env()->task()->compile_id(), method()->get_Method(), callee, success, msg, bci());
}

CompileTask::print_inlining_ul(callee, scope()->level(), bci(), msg);

if (!compilation()->directive()->PrintInliningOption) {
  return;
}
CompileTask::print_inlining_tty(callee, scope()->level(), bci(), msg);
if (success && CIPrintMethodCodes) {
  callee->print_codes();
}
4389}

4391void GraphBuilder::append_unsafe_get_and_set(ciMethod* callee, bool is_add) {
Values* args = state()->pop_arguments(callee->arg_size());
BasicType t = callee->return_type()->basic_type();
null_check(args->at(0));
Instruction* offset = args->at(2);
4396#ifndef _LP641
offset = append(new Convert(Bytecodes::_l2i, offset, as_ValueType(T_INT)));
4398#endif
Instruction* op = append(new UnsafeGetAndSet(t, args->at(1), offset, args->at(3), is_add));
compilation()->set_has_unsafe_access(true);
kill_all();
push(op->type(), op);
4403}

4405#ifndef PRODUCT
4406void GraphBuilder::print_stats() {
vmap()->print();
4408}
4409#endif // PRODUCT

4411void GraphBuilder::profile_call(ciMethod* callee, Value recv, ciKlass* known_holder, Values* obj_args, bool inlined) {
assert(known_holder == NULL || (known_holder->is_instance_klass() &&do { if (!(known_holder == __null || (known_holder->is_instance_klass
() && (!known_holder->is_interface() || ((ciInstanceKlass
*)known_holder)->has_nonstatic_concrete_methods())))) { (*
g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 4414, "assert(" "known_holder == __null || (known_holder->is_instance_klass() && (!known_holder->is_interface() || ((ciInstanceKlass*)known_holder)->has_nonstatic_concrete_methods()))"
 ") failed", "should be non-static concrete method"); ::breakpoint
(); } } while (0)
                                (!known_holder->is_interface() ||do { if (!(known_holder == __null || (known_holder->is_instance_klass
() && (!known_holder->is_interface() || ((ciInstanceKlass
*)known_holder)->has_nonstatic_concrete_methods())))) { (*
g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 4414, "assert(" "known_holder == __null || (known_holder->is_instance_klass() && (!known_holder->is_interface() || ((ciInstanceKlass*)known_holder)->has_nonstatic_concrete_methods()))"
 ") failed", "should be non-static concrete method"); ::breakpoint
(); } } while (0)
                                 ((ciInstanceKlass*)known_holder)->has_nonstatic_concrete_methods())), "should be non-static concrete method")do { if (!(known_holder == __null || (known_holder->is_instance_klass
() && (!known_holder->is_interface() || ((ciInstanceKlass
*)known_holder)->has_nonstatic_concrete_methods())))) { (*
g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 4414, "assert(" "known_holder == __null || (known_holder->is_instance_klass() && (!known_holder->is_interface() || ((ciInstanceKlass*)known_holder)->has_nonstatic_concrete_methods()))"
 ") failed", "should be non-static concrete method"); ::breakpoint
(); } } while (0);
if (known_holder != NULL__null) {
  if (known_holder->exact_klass() == NULL__null) {
    known_holder = compilation()->cha_exact_type(known_holder);
  }
}

append(new ProfileCall(method(), bci(), callee, recv, known_holder, obj_args, inlined));
4422}

4424void GraphBuilder::profile_return_type(Value ret, ciMethod* callee, ciMethod* m, int invoke_bci) {
assert((m == NULL) == (invoke_bci < 0), "invalid method and invalid bci together")do { if (!((m == __null) == (invoke_bci < 0))) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_GraphBuilder.cpp"
, 4425, "assert(" "(m == __null) == (invoke_bci < 0)" ") failed"
, "invalid method and invalid bci together"); ::breakpoint();
 } } while (0);
if (m == NULL__null) {
  m = method();
}
if (invoke_bci < 0) {
  invoke_bci = bci();
}
ciMethodData* md = m->method_data_or_null();
ciProfileData* data = md->bci_to_data(invoke_bci);
if (data != NULL__null && (data->is_CallTypeData() || data->is_VirtualCallTypeData())) {
  bool has_return = data->is_CallTypeData() ? ((ciCallTypeData*)data)->has_return() : ((ciVirtualCallTypeData*)data)->has_return();
  if (has_return) {
    append(new ProfileReturnType(m , invoke_bci, callee, ret));
  }
}
4440}

4442void GraphBuilder::profile_invocation(ciMethod* callee, ValueStack* state) {
append(new ProfileInvoke(callee, state));
4444}

←

/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp

1/*
* Copyright (c) 1999, 2021, 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.
*
*/

25#ifndef SHARE_C1_C1_INSTRUCTION_HPP
26#define SHARE_C1_C1_INSTRUCTION_HPP

28#include "c1/c1_Compilation.hpp"
29#include "c1/c1_LIR.hpp"
30#include "c1/c1_ValueType.hpp"
31#include "ci/ciField.hpp"

33// Predefined classes
34class ciField;
35class ValueStack;
36class InstructionPrinter;
37class IRScope;


40// Instruction class hierarchy
41//
42// All leaf classes in the class hierarchy are concrete classes
43// (i.e., are instantiated). All other classes are abstract and
44// serve factoring.

46class Instruction;
47class   Phi;
48class   Local;
49class   Constant;
50class   AccessField;
51class     LoadField;
52class     StoreField;
53class   AccessArray;
54class     ArrayLength;
55class     AccessIndexed;
56class       LoadIndexed;
57class       StoreIndexed;
58class   NegateOp;
59class   Op2;
60class     ArithmeticOp;
61class     ShiftOp;
62class     LogicOp;
63class     CompareOp;
64class     IfOp;
65class   Convert;
66class   NullCheck;
67class   TypeCast;
68class   OsrEntry;
69class   ExceptionObject;
70class   StateSplit;
71class     Invoke;
72class     NewInstance;
73class     NewArray;
74class       NewTypeArray;
75class       NewObjectArray;
76class       NewMultiArray;
77class     TypeCheck;
78class       CheckCast;
79class       InstanceOf;
80class     AccessMonitor;
81class       MonitorEnter;
82class       MonitorExit;
83class     Intrinsic;
84class     BlockBegin;
85class     BlockEnd;
86class       Goto;
87class       If;
88class       Switch;
89class         TableSwitch;
90class         LookupSwitch;
91class       Return;
92class       Throw;
93class       Base;
94class   RoundFP;
95class   UnsafeOp;
96class     UnsafeGet;
97class     UnsafePut;
98class     UnsafeGetAndSet;
99class   ProfileCall;
100class   ProfileReturnType;
101class   ProfileInvoke;
102class   RuntimeCall;
103class   MemBar;
104class   RangeCheckPredicate;
105#ifdef ASSERT1
106class   Assert;
107#endif

109// A Value is a reference to the instruction creating the value
110typedef Instruction* Value;
111typedef GrowableArray<Value> Values;
112typedef GrowableArray<ValueStack*> ValueStackStack;

114// BlockClosure is the base class for block traversal/iteration.

116class BlockClosure: public CompilationResourceObj {
public:
virtual void block_do(BlockBegin* block)       = 0;
119};


122// A simple closure class for visiting the values of an Instruction
123class ValueVisitor: public StackObj {
public:
virtual void visit(Value* v) = 0;
126};


129// Some array and list classes
130typedef GrowableArray<BlockBegin*> BlockBeginArray;

132class BlockList: public GrowableArray<BlockBegin*> {
public:
BlockList(): GrowableArray<BlockBegin*>() {}
BlockList(const int size): GrowableArray<BlockBegin*>(size) {}
BlockList(const int size, BlockBegin* init): GrowableArray<BlockBegin*>(size, size, init) {}

void iterate_forward(BlockClosure* closure);
void iterate_backward(BlockClosure* closure);
void values_do(ValueVisitor* f);
void print(bool cfg_only = false, bool live_only = false) PRODUCT_RETURN;
142};


145// InstructionVisitors provide type-based dispatch for instructions.
146// For each concrete Instruction class X, a virtual function do_X is
147// provided. Functionality that needs to be implemented for all classes
148// (e.g., printing, code generation) is factored out into a specialised
149// visitor instead of added to the Instruction classes itself.

151class InstructionVisitor: public StackObj {
public:
virtual void do_Phi            (Phi*             x) = 0;
virtual void do_Local          (Local*           x) = 0;
virtual void do_Constant       (Constant*        x) = 0;
virtual void do_LoadField      (LoadField*       x) = 0;
virtual void do_StoreField     (StoreField*      x) = 0;
virtual void do_ArrayLength    (ArrayLength*     x) = 0;
virtual void do_LoadIndexed    (LoadIndexed*     x) = 0;
virtual void do_StoreIndexed   (StoreIndexed*    x) = 0;
virtual void do_NegateOp       (NegateOp*        x) = 0;
virtual void do_ArithmeticOp   (ArithmeticOp*    x) = 0;
virtual void do_ShiftOp        (ShiftOp*         x) = 0;
virtual void do_LogicOp        (LogicOp*         x) = 0;
virtual void do_CompareOp      (CompareOp*       x) = 0;
virtual void do_IfOp           (IfOp*            x) = 0;
virtual void do_Convert        (Convert*         x) = 0;
virtual void do_NullCheck      (NullCheck*       x) = 0;
virtual void do_TypeCast       (TypeCast*        x) = 0;
virtual void do_Invoke         (Invoke*          x) = 0;
virtual void do_NewInstance    (NewInstance*     x) = 0;
virtual void do_NewTypeArray   (NewTypeArray*    x) = 0;
virtual void do_NewObjectArray (NewObjectArray*  x) = 0;
virtual void do_NewMultiArray  (NewMultiArray*   x) = 0;
virtual void do_CheckCast      (CheckCast*       x) = 0;
virtual void do_InstanceOf     (InstanceOf*      x) = 0;
virtual void do_MonitorEnter   (MonitorEnter*    x) = 0;
virtual void do_MonitorExit    (MonitorExit*     x) = 0;
virtual void do_Intrinsic      (Intrinsic*       x) = 0;
virtual void do_BlockBegin     (BlockBegin*      x) = 0;
virtual void do_Goto           (Goto*            x) = 0;
virtual void do_If             (If*              x) = 0;
virtual void do_TableSwitch    (TableSwitch*     x) = 0;
virtual void do_LookupSwitch   (LookupSwitch*    x) = 0;
virtual void do_Return         (Return*          x) = 0;
virtual void do_Throw          (Throw*           x) = 0;
virtual void do_Base           (Base*            x) = 0;
virtual void do_OsrEntry       (OsrEntry*        x) = 0;
virtual void do_ExceptionObject(ExceptionObject* x) = 0;
virtual void do_RoundFP        (RoundFP*         x) = 0;
virtual void do_UnsafeGet      (UnsafeGet*       x) = 0;
virtual void do_UnsafePut      (UnsafePut*       x) = 0;
virtual void do_UnsafeGetAndSet(UnsafeGetAndSet* x) = 0;
virtual void do_ProfileCall    (ProfileCall*     x) = 0;
virtual void do_ProfileReturnType (ProfileReturnType*  x) = 0;
virtual void do_ProfileInvoke  (ProfileInvoke*   x) = 0;
virtual void do_RuntimeCall    (RuntimeCall*     x) = 0;
virtual void do_MemBar         (MemBar*          x) = 0;
virtual void do_RangeCheckPredicate(RangeCheckPredicate* x) = 0;
200#ifdef ASSERT1
virtual void do_Assert         (Assert*          x) = 0;
202#endif
203};


206// Hashing support
207//
208// Note: This hash functions affect the performance
209//       of ValueMap - make changes carefully!

211#define HASH1(x1            )((intx)(x1))                    ((intx)(x1))
212#define HASH2(x1, x2        )((((intx)(x1)) << 7) ^ ((intx)(x2)))                    ((HASH1(x1        )((intx)(x1)) << 7) ^ HASH1(x2)((intx)(x2)))
213#define HASH3(x1, x2, x3    )((((((intx)(x1)) << 7) ^ ((intx)(x2))) << 7) ^ ((
intx)(x3)))                    ((HASH2(x1, x2    )((((intx)(x1)) << 7) ^ ((intx)(x2))) << 7) ^ HASH1(x3)((intx)(x3)))
214#define HASH4(x1, x2, x3, x4)((((((((intx)(x1)) << 7) ^ ((intx)(x2))) << 7) ^ (
(intx)(x3))) << 7) ^ ((intx)(x4)))                    ((HASH3(x1, x2, x3)((((((intx)(x1)) << 7) ^ ((intx)(x2))) << 7) ^ ((
intx)(x3))) << 7) ^ HASH1(x4)((intx)(x4)))


217// The following macros are used to implement instruction-specific hashing.
218// By default, each instruction implements hash() and is_equal(Value), used
219// for value numbering/common subexpression elimination. The default imple-
220// mentation disables value numbering. Each instruction which can be value-
221// numbered, should define corresponding hash() and is_equal(Value) functions
222// via the macros below. The f arguments specify all the values/op codes, etc.
223// that need to be identical for two instructions to be identical.
224//
225// Note: The default implementation of hash() returns 0 in order to indicate
226//       that the instruction should not be considered for value numbering.
227//       The currently used hash functions do not guarantee that never a 0
228//       is produced. While this is still correct, it may be a performance
229//       bug (no value numbering for that node). However, this situation is
230//       so unlikely, that we are not going to handle it specially.

232#define HASHING1(class_name, enabled, f1)virtual intx hash() const { return (enabled) ? ((((intx)(name
())) << 7) ^ ((intx)(f1))) : 0; } virtual bool is_equal
(Value v) const { if (!(enabled) ) return false; class_name* _v
 = v->as_class_name(); if (_v == __null ) return false; if
 (f1 != _v->f1) return false; return true; }             \
virtual intx hash() const {                         \
  return (enabled) ? HASH2(name(), f1)((((intx)(name())) << 7) ^ ((intx)(f1))) : 0;         \
}                                                   \
virtual bool is_equal(Value v) const {              \
  if (!(enabled)  ) return false;                   \
  class_name* _v = v->as_##class_name();            \
  if (_v == NULL__null  ) return false;                   \
  if (f1 != _v->f1) return false;                   \
  return true;                                      \
}                                                   \


245#define HASHING2(class_name, enabled, f1, f2)virtual intx hash() const { return (enabled) ? ((((((intx)(name
())) << 7) ^ ((intx)(f1))) << 7) ^ ((intx)(f2))) :
 0; } virtual bool is_equal(Value v) const { if (!(enabled) )
 return false; class_name* _v = v->as_class_name(); if (_v
 == __null ) return false; if (f1 != _v->f1) return false;
 if (f2 != _v->f2) return false; return true; }         \
virtual intx hash() const {                         \
  return (enabled) ? HASH3(name(), f1, f2)((((((intx)(name())) << 7) ^ ((intx)(f1))) << 7) ^
 ((intx)(f2))) : 0;     \
}                                                   \
virtual bool is_equal(Value v) const {              \
  if (!(enabled)  ) return false;                   \
  class_name* _v = v->as_##class_name();            \
  if (_v == NULL__null  ) return false;                   \
  if (f1 != _v->f1) return false;                   \
  if (f2 != _v->f2) return false;                   \
  return true;                                      \
}                                                   \


259#define HASHING3(class_name, enabled, f1, f2, f3)virtual intx hash() const { return (enabled) ? ((((((((intx)(
name())) << 7) ^ ((intx)(f1))) << 7) ^ ((intx)(f2
))) << 7) ^ ((intx)(f3))) : 0; } virtual bool is_equal(
Value v) const { if (!(enabled) ) return false; class_name* _v
 = v->as_class_name(); if (_v == __null ) return false; if
 (f1 != _v->f1) return false; if (f2 != _v->f2) return false
; if (f3 != _v->f3) return false; return true; }     \
virtual intx hash() const {                         \
  return (enabled) ? HASH4(name(), f1, f2, f3)((((((((intx)(name())) << 7) ^ ((intx)(f1))) << 7
) ^ ((intx)(f2))) << 7) ^ ((intx)(f3))) : 0; \
}                                                   \
virtual bool is_equal(Value v) const {              \
  if (!(enabled)  ) return false;                   \
  class_name* _v = v->as_##class_name();            \
  if (_v == NULL__null  ) return false;                   \
  if (f1 != _v->f1) return false;                   \
  if (f2 != _v->f2) return false;                   \
  if (f3 != _v->f3) return false;                   \
  return true;                                      \
}                                                   \


274// The mother of all instructions...

276class Instruction: public CompilationResourceObj {
private:
int          _id;                              // the unique instruction id
279#ifndef PRODUCT
int          _printable_bci;                   // the bci of the instruction for printing
281#endif
int          _use_count;                       // the number of instructions refering to this value (w/o prev/next); only roots can have use count = 0 or > 1
int          _pin_state;                       // set of PinReason describing the reason for pinning
ValueType*   _type;                            // the instruction value type
Instruction* _next;                            // the next instruction if any (NULL for BlockEnd instructions)
Instruction* _subst;                           // the substitution instruction if any
LIR_Opr      _operand;                         // LIR specific information
unsigned int _flags;                           // Flag bits

ValueStack*  _state_before;                    // Copy of state with input operands still on stack (or NULL)
ValueStack*  _exception_state;                 // Copy of state for exception handling
XHandlers*   _exception_handlers;              // Flat list of exception handlers covering this instruction

friend class UseCountComputer;

void update_exception_state(ValueStack* state);

protected:
BlockBegin*  _block;                           // Block that contains this instruction

void set_type(ValueType* type) {
  assert(type != NULL, "type must exist")do { if (!(type != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 302, "assert(" "type != __null" ") failed", "type must exist"
); ::breakpoint(); } } while (0);
  _type = type;
}

// Helper class to keep track of which arguments need a null check
class ArgsNonNullState {
private:
  int _nonnull_state; // mask identifying which args are nonnull
public:
  ArgsNonNullState()
    : _nonnull_state(AllBits) {}

  // Does argument number i needs a null check?
  bool arg_needs_null_check(int i) const {
    // No data is kept for arguments starting at position 33 so
    // conservatively assume that they need a null check.
    if (i >= 0 && i < (int)sizeof(_nonnull_state) * BitsPerByte) {
      return is_set_nth_bit(_nonnull_state, i);
    }
    return true;
  }

  // Set whether argument number i needs a null check or not
  void set_arg_needs_null_check(int i, bool check) {
    if (i >= 0 && i < (int)sizeof(_nonnull_state) * BitsPerByte) {
      if (check) {
        _nonnull_state |= nth_bit(i)(((i) >= BitsPerWord) ? 0 : (OneBit << (i)));
      } else {
        _nonnull_state &= ~(nth_bit(i)(((i) >= BitsPerWord) ? 0 : (OneBit << (i))));
      }
    }
  }
};

public:
void* operator new(size_t size) throw() {
  Compilation* c = Compilation::current();
  void* res = c->arena()->Amalloc(size);
  return res;
}

static const int no_bci = -99;

enum InstructionFlag {
  NeedsNullCheckFlag = 0,
  CanTrapFlag,
  DirectCompareFlag,
  IsEliminatedFlag,
  IsSafepointFlag,
  IsStaticFlag,
  NeedsStoreCheckFlag,
  NeedsWriteBarrierFlag,
  PreservesStateFlag,
  TargetIsFinalFlag,
  TargetIsLoadedFlag,
  UnorderedIsTrueFlag,
  NeedsPatchingFlag,
  ThrowIncompatibleClassChangeErrorFlag,
  InvokeSpecialReceiverCheckFlag,
  ProfileMDOFlag,
  IsLinkedInBlockFlag,
  NeedsRangeCheckFlag,
  InWorkListFlag,
  DeoptimizeOnException,
  InstructionLastFlag
};

public:
bool check_flag(InstructionFlag id) const      { return (_flags & (1 << id)) != 0;    }
void set_flag(InstructionFlag id, bool f)      { _flags = f ? (_flags | (1 << id)) : (_flags & ~(1 << id)); };

// 'globally' used condition values
enum Condition {
  eql, neq, lss, leq, gtr, geq, aeq, beq
};

// Instructions may be pinned for many reasons and under certain conditions
// with enough knowledge it's possible to safely unpin them.
enum PinReason {
    PinUnknown           = 1 << 0
  , PinExplicitNullCheck = 1 << 3
  , PinStackForStateSplit= 1 << 12
  , PinStateSplitConstructor= 1 << 13
  , PinGlobalValueNumbering= 1 << 14
};

static Condition mirror(Condition cond);
static Condition negate(Condition cond);

// initialization
static int number_of_instructions() {
  return Compilation::current()->number_of_instructions();
}

// creation
Instruction(ValueType* type, ValueStack* state_before = NULL__null, bool type_is_constant = false)
: _id(Compilation::current()->get_next_id()),
399#ifndef PRODUCT
_printable_bci(-99),
401#endif
  _use_count(0)
, _pin_state(0)
, _type(type)
, _next(NULL__null)
, _subst(NULL__null)
, _operand(LIR_OprFact::illegalOpr)
, _flags(0)
, _state_before(state_before)
, _exception_handlers(NULL__null)
, _block(NULL__null)
{
  check_state(state_before);
  assert(type != NULL && (!type->is_constant() || type_is_constant), "type must exist")do { if (!(type != __null && (!type->is_constant()
 || type_is_constant))) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 414, "assert(" "type != __null && (!type->is_constant() || type_is_constant)"
 ") failed", "type must exist"); ::breakpoint(); } } while (0
);
  update_exception_state(_state_before);
}

// accessors
int id() const                                 { return _id; }
420#ifndef PRODUCT
bool has_printable_bci() const                 { return _printable_bci != -99; }
int printable_bci() const                      { assert(has_printable_bci(), "_printable_bci should have been set")do { if (!(has_printable_bci())) { (*g_assert_poison) = 'X';;
 report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 422, "assert(" "has_printable_bci()" ") failed", "_printable_bci should have been set"
); ::breakpoint(); } } while (0); return _printable_bci; }
void set_printable_bci(int bci)                { _printable_bci = bci; }
424#endif
int dominator_depth();
int use_count() const                          { return _use_count; }
int pin_state() const                          { return _pin_state; }
bool is_pinned() const                         { return _pin_state != 0 || PinAllInstructions; }
ValueType* type() const                        { return _type; }
BlockBegin *block() const                      { return _block; }
Instruction* prev();                           // use carefully, expensive operation
Instruction* next() const                      { return _next; }
bool has_subst() const                         { return _subst != NULL__null; }
Instruction* subst()                           { return _subst == NULL__null ? this : _subst->subst(); }
LIR_Opr operand() const                        { return _operand; }

void set_needs_null_check(bool f)              { set_flag(NeedsNullCheckFlag, f); }
bool needs_null_check() const                  { return check_flag(NeedsNullCheckFlag); }
bool is_linked() const                         { return check_flag(IsLinkedInBlockFlag); }
bool can_be_linked()                           { return as_Local() == NULL__null && as_Phi() == NULL__null; }

bool is_null_obj()                             { return as_Constant() != NULL__null && type()->as_ObjectType()->constant_value()->is_null_object(); }

bool has_uses() const                          { return use_count() > 0; }
ValueStack* state_before() const               { return _state_before; }
ValueStack* exception_state() const            { return _exception_state; }
virtual bool needs_exception_state() const     { return true; }
XHandlers* exception_handlers() const          { return _exception_handlers; }

// manipulation
void pin(PinReason reason)                     { _pin_state |= reason; }
void pin()                                     { _pin_state |= PinUnknown; }
// DANGEROUS: only used by EliminateStores
void unpin(PinReason reason)                   { assert((reason & PinUnknown) == 0, "can't unpin unknown state")do { if (!((reason & PinUnknown) == 0)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 454, "assert(" "(reason & PinUnknown) == 0" ") failed",
 "can't unpin unknown state"); ::breakpoint(); } } while (0); _pin_state &= ~reason; }

Instruction* set_next(Instruction* next) {
  assert(next->has_printable_bci(), "_printable_bci should have been set")do { if (!(next->has_printable_bci())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 457, "assert(" "next->has_printable_bci()" ") failed", "_printable_bci should have been set"
); ::breakpoint(); } } while (0);
  assert(next != NULL, "must not be NULL")do { if (!(next != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 458, "assert(" "next != __null" ") failed", "must not be NULL"
); ::breakpoint(); } } while (0);
  assert(as_BlockEnd() == NULL, "BlockEnd instructions must have no next")do { if (!(as_BlockEnd() == __null)) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 459, "assert(" "as_BlockEnd() == __null" ") failed", "BlockEnd instructions must have no next"
); ::breakpoint(); } } while (0);
  assert(next->can_be_linked(), "shouldn't link these instructions into list")do { if (!(next->can_be_linked())) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 460, "assert(" "next->can_be_linked()" ") failed", "shouldn't link these instructions into list"
); ::breakpoint(); } } while (0);

  BlockBegin *block = this->block();
  next->_block = block;

  next->set_flag(Instruction::IsLinkedInBlockFlag, true);
  _next = next;
  return next;
}

Instruction* set_next(Instruction* next, int bci) {
471#ifndef PRODUCT
  next->set_printable_bci(bci);
473#endif
  return set_next(next);
}

// when blocks are merged
void fixup_block_pointers() {
  Instruction *cur = next()->next(); // next()'s block is set in set_next
  while (cur && cur->_block != block()) {
    cur->_block = block();
    cur = cur->next();
  }
}

Instruction *insert_after(Instruction *i) {
  Instruction* n = _next;
  set_next(i);
  i->set_next(n);
  return _next;
}

Instruction *insert_after_same_bci(Instruction *i) {
494#ifndef PRODUCT
  i->set_printable_bci(printable_bci());
496#endif
  return insert_after(i);
}

void set_subst(Instruction* subst)             {
  assert(subst == NULL ||do { if (!(subst == __null || type()->base() == subst->
type()->base() || subst->type()->base() == illegalType
)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 503, "assert(" "subst == __null || type()->base() == subst->type()->base() || subst->type()->base() == illegalType"
 ") failed", "type can't change"); ::breakpoint(); } } while (
0)
         type()->base() == subst->type()->base() ||do { if (!(subst == __null || type()->base() == subst->
type()->base() || subst->type()->base() == illegalType
)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 503, "assert(" "subst == __null || type()->base() == subst->type()->base() || subst->type()->base() == illegalType"
 ") failed", "type can't change"); ::breakpoint(); } } while (
0)
         subst->type()->base() == illegalType, "type can't change")do { if (!(subst == __null || type()->base() == subst->
type()->base() || subst->type()->base() == illegalType
)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 503, "assert(" "subst == __null || type()->base() == subst->type()->base() || subst->type()->base() == illegalType"
 ") failed", "type can't change"); ::breakpoint(); } } while (
0);
  _subst = subst;
}
void set_exception_handlers(XHandlers *xhandlers) { _exception_handlers = xhandlers; }
void set_exception_state(ValueStack* s)        { check_state(s); _exception_state = s; }
void set_state_before(ValueStack* s)           { check_state(s); _state_before = s; }

// machine-specifics
void set_operand(LIR_Opr operand)              { assert(operand != LIR_OprFact::illegalOpr, "operand must exist")do { if (!(operand != LIR_OprFact::illegalOpr)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 511, "assert(" "operand != LIR_OprFact::illegalOpr" ") failed"
, "operand must exist"); ::breakpoint(); } } while (0); _operand = operand; }
void clear_operand()                           { _operand = LIR_OprFact::illegalOpr; }

// generic
virtual Instruction*      as_Instruction()     { return this; } // to satisfy HASHING1 macro
virtual Phi*              as_Phi()             { return NULL__null; }
virtual Local*            as_Local()           { return NULL__null; }
virtual Constant*         as_Constant()        { return NULL__null; }
virtual AccessField*      as_AccessField()     { return NULL__null; }
virtual LoadField*        as_LoadField()       { return NULL__null; }
virtual StoreField*       as_StoreField()      { return NULL__null; }
virtual AccessArray*      as_AccessArray()     { return NULL__null; }
virtual ArrayLength*      as_ArrayLength()     { return NULL__null; }
virtual AccessIndexed*    as_AccessIndexed()   { return NULL__null; }
virtual LoadIndexed*      as_LoadIndexed()     { return NULL__null; }
virtual StoreIndexed*     as_StoreIndexed()    { return NULL__null; }
virtual NegateOp*         as_NegateOp()        { return NULL__null; }
virtual Op2*              as_Op2()             { return NULL__null; }
virtual ArithmeticOp*     as_ArithmeticOp()    { return NULL__null; }
virtual ShiftOp*          as_ShiftOp()         { return NULL__null; }
virtual LogicOp*          as_LogicOp()         { return NULL__null; }
virtual CompareOp*        as_CompareOp()       { return NULL__null; }
virtual IfOp*             as_IfOp()            { return NULL__null; }
virtual Convert*          as_Convert()         { return NULL__null; }
virtual NullCheck*        as_NullCheck()       { return NULL__null; }
virtual OsrEntry*         as_OsrEntry()        { return NULL__null; }
virtual StateSplit*       as_StateSplit()      { return NULL__null; }
virtual Invoke*           as_Invoke()          { return NULL__null; }
virtual NewInstance*      as_NewInstance()     { return NULL__null; }
virtual NewArray*         as_NewArray()        { return NULL__null; }
virtual NewTypeArray*     as_NewTypeArray()    { return NULL__null; }
virtual NewObjectArray*   as_NewObjectArray()  { return NULL__null; }
virtual NewMultiArray*    as_NewMultiArray()   { return NULL__null; }
virtual TypeCheck*        as_TypeCheck()       { return NULL__null; }
virtual CheckCast*        as_CheckCast()       { return NULL__null; }
virtual InstanceOf*       as_InstanceOf()      { return NULL__null; }
virtual TypeCast*         as_TypeCast()        { return NULL__null; }
virtual AccessMonitor*    as_AccessMonitor()   { return NULL__null; }
virtual MonitorEnter*     as_MonitorEnter()    { return NULL__null; }
virtual MonitorExit*      as_MonitorExit()     { return NULL__null; }
virtual Intrinsic*        as_Intrinsic()       { return NULL__null; }
virtual BlockBegin*       as_BlockBegin()      { return NULL__null; }
virtual BlockEnd*         as_BlockEnd()        { return NULL__null; }
virtual Goto*             as_Goto()            { return NULL__null; }
virtual If*               as_If()              { return NULL__null; }
virtual TableSwitch*      as_TableSwitch()     { return NULL__null; }
virtual LookupSwitch*     as_LookupSwitch()    { return NULL__null; }
virtual Return*           as_Return()          { return NULL__null; }
virtual Throw*            as_Throw()           { return NULL__null; }
virtual Base*             as_Base()            { return NULL__null; }
virtual RoundFP*          as_RoundFP()         { return NULL__null; }
virtual ExceptionObject*  as_ExceptionObject() { return NULL__null; }
virtual UnsafeOp*         as_UnsafeOp()        { return NULL__null; }
virtual ProfileInvoke*    as_ProfileInvoke()   { return NULL__null; }
virtual RangeCheckPredicate* as_RangeCheckPredicate() { return NULL__null; }

567#ifdef ASSERT1
virtual Assert*           as_Assert()          { return NULL__null; }
569#endif

virtual void visit(InstructionVisitor* v)      = 0;

virtual bool can_trap() const                  { return false; }

virtual void input_values_do(ValueVisitor* f)   = 0;
virtual void state_values_do(ValueVisitor* f);
virtual void other_values_do(ValueVisitor* f)   { /* usually no other - override on demand */ }
        void       values_do(ValueVisitor* f)   { input_values_do(f); state_values_do(f); other_values_do(f); }

virtual ciType* exact_type() const;
virtual ciType* declared_type() const          { return NULL__null; }

// hashing
virtual const char* name() const               = 0;
HASHING1(Instruction, false, id())virtual intx hash() const { return (false) ? ((((intx)(name()
)) << 7) ^ ((intx)(id()))) : 0; } virtual bool is_equal
(Value v) const { if (!(false) ) return false; Instruction* _v
 = v->as_Instruction(); if (_v == __null ) return false; if
 (id() != _v->id()) return false; return true; }             // hashing disabled by default

// debugging
static void check_state(ValueStack* state)     PRODUCT_RETURN;
void print()                                   PRODUCT_RETURN;
void print_line()                              PRODUCT_RETURN;
void print(InstructionPrinter& ip)             PRODUCT_RETURN;
592};


595// The following macros are used to define base (i.e., non-leaf)
596// and leaf instruction classes. They define class-name related
597// generic functionality in one place.

599#define BASE(class_name, super_class_name)class class_name: public super_class_name { public: virtual class_name
* as_class_name() { return this; }       \
class class_name: public super_class_name {    \
 public:                                       \
  virtual class_name* as_##class_name()        { return this; }              \


605#define LEAF(class_name, super_class_name)class class_name: public super_class_name { public: virtual class_name
* as_class_name() { return this; } public: virtual const char
* name() const { return "class_name"; } virtual void visit(InstructionVisitor
* v) { v->do_class_name(this); }       \
BASE(class_name, super_class_name)class class_name: public super_class_name { public: virtual class_name
* as_class_name() { return this; }             \
 public:                                       \
  virtual const char* name() const             { return #class_name; }       \
  virtual void visit(InstructionVisitor* v)    { v->do_##class_name(this); } \


612// Debugging support


615#ifdef ASSERT1
616class AssertValues: public ValueVisitor {
void visit(Value* x)             { assert((*x) != NULL, "value must exist")do { if (!((*x) != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 617, "assert(" "(*x) != __null" ") failed", "value must exist"
); ::breakpoint(); } } while (0); }
618};
#define ASSERT_VALUES                          { AssertValues assert_value; values_do(&assert_value); }
620#else
#define ASSERT_VALUES
622#endif // ASSERT


625// A Phi is a phi function in the sense of SSA form. It stands for
626// the value of a local variable at the beginning of a join block.
627// A Phi consists of n operands, one for every incoming branch.

629LEAF(Phi, Instruction)class Phi: public Instruction { public: virtual Phi* as_Phi()
 { return this; } public: virtual const char* name() const { return
 "Phi"; } virtual void visit(InstructionVisitor* v) { v->do_Phi
(this); }
private:
int         _pf_flags; // the flags of the phi function
int         _index;    // to value on operand stack (index < 0) or to local
public:
// creation
Phi(ValueType* type, BlockBegin* b, int index)
: Instruction(type->base())
, _pf_flags(0)
, _index(index)
{
  _block = b;
  NOT_PRODUCT(set_printable_bci(Value(b)->printable_bci()))set_printable_bci(Value(b)->printable_bci());
  if (type->is_illegal()) {
    make_illegal();
  }
}

// flags
enum Flag {
  no_flag         = 0,
  visited         = 1 << 0,
  cannot_simplify = 1 << 1
};

// accessors
bool  is_local() const          { return _index >= 0; }
bool  is_on_stack() const       { return !is_local(); }
int   local_index() const       { assert(is_local(), "")do { if (!(is_local())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 657, "assert(" "is_local()" ") failed", ""); ::breakpoint()
; } } while (0); return _index; }
int   stack_index() const       { assert(is_on_stack(), "")do { if (!(is_on_stack())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 658, "assert(" "is_on_stack()" ") failed", ""); ::breakpoint
(); } } while (0); return -(_index+1); }

Value operand_at(int i) const;
int   operand_count() const;

void   set(Flag f)              { _pf_flags |=  f; }
void   clear(Flag f)            { _pf_flags &= ~f; }
bool   is_set(Flag f) const     { return (_pf_flags & f) != 0; }

// Invalidates phis corresponding to merges of locals of two different types
// (these should never be referenced, otherwise the bytecodes are illegal)
void   make_illegal() {
  set(cannot_simplify);
  set_type(illegalType);
}

bool is_illegal() const {
  return type()->is_illegal();
}

// generic
virtual void input_values_do(ValueVisitor* f) {
}
681};


684// A local is a placeholder for an incoming argument to a function call.
685LEAF(Local, Instruction)class Local: public Instruction { public: virtual Local* as_Local
() { return this; } public: virtual const char* name() const {
 return "Local"; } virtual void visit(InstructionVisitor* v) {
 v->do_Local(this); }
private:
int      _java_index;                          // the local index within the method to which the local belongs
bool     _is_receiver;                         // if local variable holds the receiver: "this" for non-static methods
ciType*  _declared_type;
public:
// creation
Local(ciType* declared, ValueType* type, int index, bool receiver)
  : Instruction(type)
  , _java_index(index)
  , _is_receiver(receiver)
  , _declared_type(declared)
{
  NOT_PRODUCT(set_printable_bci(-1))set_printable_bci(-1);
}

// accessors
int java_index() const                         { return _java_index; }
bool is_receiver() const                       { return _is_receiver; }

virtual ciType* declared_type() const          { return _declared_type; }

// generic
virtual void input_values_do(ValueVisitor* f)   { /* no values */ }
709};


712LEAF(Constant, Instruction)class Constant: public Instruction { public: virtual Constant
* as_Constant() { return this; } public: virtual const char* name
() const { return "Constant"; } virtual void visit(InstructionVisitor
* v) { v->do_Constant(this); }
public:
// creation
Constant(ValueType* type):
    Instruction(type, NULL__null, /*type_is_constant*/ true)
{
  assert(type->is_constant(), "must be a constant")do { if (!(type->is_constant())) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 718, "assert(" "type->is_constant()" ") failed", "must be a constant"
); ::breakpoint(); } } while (0);
}

Constant(ValueType* type, ValueStack* state_before):
  Instruction(type, state_before, /*type_is_constant*/ true)
{
  assert(state_before != NULL, "only used for constants which need patching")do { if (!(state_before != __null)) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 724, "assert(" "state_before != __null" ") failed", "only used for constants which need patching"
); ::breakpoint(); } } while (0);
  assert(type->is_constant(), "must be a constant")do { if (!(type->is_constant())) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 725, "assert(" "type->is_constant()" ") failed", "must be a constant"
); ::breakpoint(); } } while (0);
  // since it's patching it needs to be pinned
  pin();
}

// generic
virtual bool can_trap() const                  { return state_before() != NULL__null; }
virtual void input_values_do(ValueVisitor* f)   { /* no values */ }

virtual intx hash() const;
virtual bool is_equal(Value v) const;

virtual ciType* exact_type() const;

enum CompareResult { not_comparable = -1, cond_false, cond_true };

virtual CompareResult compare(Instruction::Condition condition, Value right) const;
BlockBegin* compare(Instruction::Condition cond, Value right,
                    BlockBegin* true_sux, BlockBegin* false_sux) const {
  switch (compare(cond, right)) {
  case not_comparable:
    return NULL__null;
  case cond_false:
    return false_sux;
  case cond_true:
    return true_sux;
  default:
    ShouldNotReachHere()do { (*g_assert_poison) = 'X';; report_should_not_reach_here(
"/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 752); ::breakpoint(); } while (0);
    return NULL__null;
  }
}
756};


759BASE(AccessField, Instruction)class AccessField: public Instruction { public: virtual AccessField
* as_AccessField() { return this; }
private:
Value       _obj;
int         _offset;
ciField*    _field;
NullCheck*  _explicit_null_check;              // For explicit null check elimination

public:
// creation
AccessField(Value obj, int offset, ciField* field, bool is_static,
            ValueStack* state_before, bool needs_patching)
: Instruction(as_ValueType(field->type()->basic_type()), state_before)
, _obj(obj)
, _offset(offset)
, _field(field)
, _explicit_null_check(NULL__null)
{
  set_needs_null_check(!is_static);
  set_flag(IsStaticFlag, is_static);
  set_flag(NeedsPatchingFlag, needs_patching);
  ASSERT_VALUES
  // pin of all instructions with memory access
  pin();
}

// accessors
Value obj() const                              { return _obj; }
int offset() const                             { return _offset; }
ciField* field() const                         { return _field; }
BasicType field_type() const                   { return _field->type()->basic_type(); }
bool is_static() const                         { return check_flag(IsStaticFlag); }
NullCheck* explicit_null_check() const         { return _explicit_null_check; }
bool needs_patching() const                    { return check_flag(NeedsPatchingFlag); }

// Unresolved getstatic and putstatic can cause initialization.
// Technically it occurs at the Constant that materializes the base
// of the static fields but it's simpler to model it here.
bool is_init_point() const                     { return is_static() && (needs_patching() || !_field->holder()->is_initialized()); }

// manipulation

// Under certain circumstances, if a previous NullCheck instruction
// proved the target object non-null, we can eliminate the explicit
// null check and do an implicit one, simply specifying the debug
// information from the NullCheck. This field should only be consulted
// if needs_null_check() is true.
void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }

// generic
virtual bool can_trap() const                  { return needs_null_check() || needs_patching(); }
virtual void input_values_do(ValueVisitor* f)   { f->visit(&_obj); }
810};


813LEAF(LoadField, AccessField)class LoadField: public AccessField { public: virtual LoadField
* as_LoadField() { return this; } public: virtual const char*
 name() const { return "LoadField"; } virtual void visit(InstructionVisitor
* v) { v->do_LoadField(this); }
public:
// creation
LoadField(Value obj, int offset, ciField* field, bool is_static,
          ValueStack* state_before, bool needs_patching)
: AccessField(obj, offset, field, is_static, state_before, needs_patching)
{}

ciType* declared_type() const;

// generic; cannot be eliminated if needs patching or if volatile.
HASHING3(LoadField, !needs_patching() && !field()->is_volatile(), obj()->subst(), offset(), declared_type())virtual intx hash() const { return (!needs_patching() &&
 !field()->is_volatile()) ? ((((((((intx)(name())) <<
 7) ^ ((intx)(obj()->subst()))) << 7) ^ ((intx)(offset
()))) << 7) ^ ((intx)(declared_type()))) : 0; } virtual
 bool is_equal(Value v) const { if (!(!needs_patching() &&
 !field()->is_volatile()) ) return false; LoadField* _v = v
->as_LoadField(); if (_v == __null ) return false; if (obj
()->subst() != _v->obj()->subst()) return false; if (
offset() != _v->offset()) return false; if (declared_type(
) != _v->declared_type()) return false; return true; }
825};


828LEAF(StoreField, AccessField)class StoreField: public AccessField { public: virtual StoreField
* as_StoreField() { return this; } public: virtual const char
* name() const { return "StoreField"; } virtual void visit(InstructionVisitor
* v) { v->do_StoreField(this); }
private:
Value _value;

public:
// creation
StoreField(Value obj, int offset, ciField* field, Value value, bool is_static,
           ValueStack* state_before, bool needs_patching)
: AccessField(obj, offset, field, is_static, state_before, needs_patching)
, _value(value)
{
  set_flag(NeedsWriteBarrierFlag, as_ValueType(field_type())->is_object());
  ASSERT_VALUES
  pin();
}

// accessors
Value value() const                            { return _value; }
bool needs_write_barrier() const               { return check_flag(NeedsWriteBarrierFlag); }

// generic
virtual void input_values_do(ValueVisitor* f)   { AccessField::input_values_do(f); f->visit(&_value); }
850};


853BASE(AccessArray, Instruction)class AccessArray: public Instruction { public: virtual AccessArray
* as_AccessArray() { return this; }
private:
Value       _array;

public:
// creation
AccessArray(ValueType* type, Value array, ValueStack* state_before)
: Instruction(type, state_before)
, _array(array)
{
  set_needs_null_check(true);
  ASSERT_VALUES
  pin(); // instruction with side effect (null exception or range check throwing)
}

Value array() const                            { return _array; }

// generic
virtual bool can_trap() const                  { return needs_null_check(); }
virtual void input_values_do(ValueVisitor* f)   { f->visit(&_array); }
873};


876LEAF(ArrayLength, AccessArray)class ArrayLength: public AccessArray { public: virtual ArrayLength
* as_ArrayLength() { return this; } public: virtual const char
* name() const { return "ArrayLength"; } virtual void visit(InstructionVisitor
* v) { v->do_ArrayLength(this); }
private:
NullCheck*  _explicit_null_check;              // For explicit null check elimination

public:
// creation
ArrayLength(Value array, ValueStack* state_before)
: AccessArray(intType, array, state_before)
, _explicit_null_check(NULL__null) {}

// accessors
NullCheck* explicit_null_check() const         { return _explicit_null_check; }

// setters
// See LoadField::set_explicit_null_check for documentation
void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }

// generic
HASHING1(ArrayLength, true, array()->subst())virtual intx hash() const { return (true) ? ((((intx)(name())
) << 7) ^ ((intx)(array()->subst()))) : 0; } virtual
 bool is_equal(Value v) const { if (!(true) ) return false; ArrayLength
* _v = v->as_ArrayLength(); if (_v == __null ) return false
; if (array()->subst() != _v->array()->subst()) return
 false; return true; }
895};


898BASE(AccessIndexed, AccessArray)class AccessIndexed: public AccessArray { public: virtual AccessIndexed
* as_AccessIndexed() { return this; }
private:
Value     _index;
Value     _length;
BasicType _elt_type;
bool      _mismatched;

public:
// creation
AccessIndexed(Value array, Value index, Value length, BasicType elt_type, ValueStack* state_before, bool mismatched)
: AccessArray(as_ValueType(elt_type), array, state_before)
, _index(index)
, _length(length)
, _elt_type(elt_type)
, _mismatched(mismatched)
{
  set_flag(Instruction::NeedsRangeCheckFlag, true);
  ASSERT_VALUES
}

// accessors
Value index() const                            { return _index; }
Value length() const                           { return _length; }
BasicType elt_type() const                     { return _elt_type; }
bool mismatched() const                        { return _mismatched; }

void clear_length()                            { _length = NULL__null; }
// perform elimination of range checks involving constants
bool compute_needs_range_check();

// generic
virtual void input_values_do(ValueVisitor* f)   { AccessArray::input_values_do(f); f->visit(&_index); if (_length != NULL__null) f->visit(&_length); }
930};


933LEAF(LoadIndexed, AccessIndexed)class LoadIndexed: public AccessIndexed { public: virtual LoadIndexed
* as_LoadIndexed() { return this; } public: virtual const char
* name() const { return "LoadIndexed"; } virtual void visit(InstructionVisitor
* v) { v->do_LoadIndexed(this); }
private:
NullCheck*  _explicit_null_check;              // For explicit null check elimination

public:
// creation
LoadIndexed(Value array, Value index, Value length, BasicType elt_type, ValueStack* state_before, bool mismatched = false)
: AccessIndexed(array, index, length, elt_type, state_before, mismatched)
, _explicit_null_check(NULL__null) {}

// accessors
NullCheck* explicit_null_check() const         { return _explicit_null_check; }

// setters
// See LoadField::set_explicit_null_check for documentation
void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }

ciType* exact_type() const;
ciType* declared_type() const;

// generic;
HASHING3(LoadIndexed, true, type()->tag(), array()->subst(), index()->subst())virtual intx hash() const { return (true) ? ((((((((intx)(name
())) << 7) ^ ((intx)(type()->tag()))) << 7) ^ (
(intx)(array()->subst()))) << 7) ^ ((intx)(index()->
subst()))) : 0; } virtual bool is_equal(Value v) const { if (
!(true) ) return false; LoadIndexed* _v = v->as_LoadIndexed
(); if (_v == __null ) return false; if (type()->tag() != _v
->type()->tag()) return false; if (array()->subst() !=
 _v->array()->subst()) return false; if (index()->subst
() != _v->index()->subst()) return false; return true; }
955};


958LEAF(StoreIndexed, AccessIndexed)class StoreIndexed: public AccessIndexed { public: virtual StoreIndexed
* as_StoreIndexed() { return this; } public: virtual const char
* name() const { return "StoreIndexed"; } virtual void visit(
InstructionVisitor* v) { v->do_StoreIndexed(this); }
private:
Value       _value;

ciMethod* _profiled_method;
int       _profiled_bci;
bool      _check_boolean;

public:
// creation
StoreIndexed(Value array, Value index, Value length, BasicType elt_type, Value value, ValueStack* state_before,
             bool check_boolean, bool mismatched = false)
: AccessIndexed(array, index, length, elt_type, state_before, mismatched)
, _value(value), _profiled_method(NULL__null), _profiled_bci(0), _check_boolean(check_boolean)
{
  set_flag(NeedsWriteBarrierFlag, (as_ValueType(elt_type)->is_object()));
  set_flag(NeedsStoreCheckFlag, (as_ValueType(elt_type)->is_object()));
  ASSERT_VALUES
  pin();
}

// accessors
Value value() const                            { return _value; }
bool needs_write_barrier() const               { return check_flag(NeedsWriteBarrierFlag); }
bool needs_store_check() const                 { return check_flag(NeedsStoreCheckFlag); }
bool check_boolean() const                     { return _check_boolean; }
// Helpers for MethodData* profiling
void set_should_profile(bool value)                { set_flag(ProfileMDOFlag, value); }
void set_profiled_method(ciMethod* method)         { _profiled_method = method;   }
void set_profiled_bci(int bci)                     { _profiled_bci = bci;         }
bool      should_profile() const                   { return check_flag(ProfileMDOFlag); }
ciMethod* profiled_method() const                  { return _profiled_method;     }
int       profiled_bci() const                     { return _profiled_bci;        }
// generic
virtual void input_values_do(ValueVisitor* f)   { AccessIndexed::input_values_do(f); f->visit(&_value); }
993};


996LEAF(NegateOp, Instruction)class NegateOp: public Instruction { public: virtual NegateOp
* as_NegateOp() { return this; } public: virtual const char* name
() const { return "NegateOp"; } virtual void visit(InstructionVisitor
* v) { v->do_NegateOp(this); }
private:
Value _x;

public:
// creation
NegateOp(Value x) : Instruction(x->type()->base()), _x(x) {
  ASSERT_VALUES
}

// accessors
Value x() const                                { return _x; }

// generic
virtual void input_values_do(ValueVisitor* f)   { f->visit(&_x); }
1011};


1014BASE(Op2, Instruction)class Op2: public Instruction { public: virtual Op2* as_Op2()
 { return this; }
private:
Bytecodes::Code _op;
Value           _x;
Value           _y;

public:
// creation
Op2(ValueType* type, Bytecodes::Code op, Value x, Value y, ValueStack* state_before = NULL__null)
: Instruction(type, state_before)
, _op(op)
, _x(x)
, _y(y)
{
  ASSERT_VALUES
}

// accessors
Bytecodes::Code op() const                     { return _op; }
Value x() const                                { return _x; }
Value y() const                                { return _y; }

// manipulators
void swap_operands() {
  assert(is_commutative(), "operation must be commutative")do { if (!(is_commutative())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 1038, "assert(" "is_commutative()" ") failed", "operation must be commutative"
); ::breakpoint(); } } while (0);
  Value t = _x; _x = _y; _y = t;
}

// generic
virtual bool is_commutative() const            { return false; }
virtual void input_values_do(ValueVisitor* f)   { f->visit(&_x); f->visit(&_y); }
1045};


1048LEAF(ArithmeticOp, Op2)class ArithmeticOp: public Op2 { public: virtual ArithmeticOp
* as_ArithmeticOp() { return this; } public: virtual const char
* name() const { return "ArithmeticOp"; } virtual void visit(
InstructionVisitor* v) { v->do_ArithmeticOp(this); }
public:
// creation
ArithmeticOp(Bytecodes::Code op, Value x, Value y, ValueStack* state_before)
: Op2(x->type()->meet(y->type()), op, x, y, state_before)
{
  if (can_trap()) pin();
}

// generic
virtual bool is_commutative() const;
virtual bool can_trap() const;
HASHING3(Op2, true, op(), x()->subst(), y()->subst())virtual intx hash() const { return (true) ? ((((((((intx)(name
())) << 7) ^ ((intx)(op()))) << 7) ^ ((intx)(x()->
subst()))) << 7) ^ ((intx)(y()->subst()))) : 0; } virtual
 bool is_equal(Value v) const { if (!(true) ) return false; Op2
* _v = v->as_Op2(); if (_v == __null ) return false; if (op
() != _v->op()) return false; if (x()->subst() != _v->
x()->subst()) return false; if (y()->subst() != _v->
y()->subst()) return false; return true; }
1061};


1064LEAF(ShiftOp, Op2)class ShiftOp: public Op2 { public: virtual ShiftOp* as_ShiftOp
() { return this; } public: virtual const char* name() const {
 return "ShiftOp"; } virtual void visit(InstructionVisitor* v
) { v->do_ShiftOp(this); }
public:
// creation
ShiftOp(Bytecodes::Code op, Value x, Value s) : Op2(x->type()->base(), op, x, s) {}
24
←
Called C++ object pointer is null

// generic
HASHING3(Op2, true, op(), x()->subst(), y()->subst())virtual intx hash() const { return (true) ? ((((((((intx)(name
())) << 7) ^ ((intx)(op()))) << 7) ^ ((intx)(x()->
subst()))) << 7) ^ ((intx)(y()->subst()))) : 0; } virtual
 bool is_equal(Value v) const { if (!(true) ) return false; Op2
* _v = v->as_Op2(); if (_v == __null ) return false; if (op
() != _v->op()) return false; if (x()->subst() != _v->
x()->subst()) return false; if (y()->subst() != _v->
y()->subst()) return false; return true; }
1071};


1074LEAF(LogicOp, Op2)class LogicOp: public Op2 { public: virtual LogicOp* as_LogicOp
() { return this; } public: virtual const char* name() const {
 return "LogicOp"; } virtual void visit(InstructionVisitor* v
) { v->do_LogicOp(this); }
public:
// creation
LogicOp(Bytecodes::Code op, Value x, Value y) : Op2(x->type()->meet(y->type()), op, x, y) {}

// generic
virtual bool is_commutative() const;
HASHING3(Op2, true, op(), x()->subst(), y()->subst())virtual intx hash() const { return (true) ? ((((((((intx)(name
())) << 7) ^ ((intx)(op()))) << 7) ^ ((intx)(x()->
subst()))) << 7) ^ ((intx)(y()->subst()))) : 0; } virtual
 bool is_equal(Value v) const { if (!(true) ) return false; Op2
* _v = v->as_Op2(); if (_v == __null ) return false; if (op
() != _v->op()) return false; if (x()->subst() != _v->
x()->subst()) return false; if (y()->subst() != _v->
y()->subst()) return false; return true; }
1082};


1085LEAF(CompareOp, Op2)class CompareOp: public Op2 { public: virtual CompareOp* as_CompareOp
() { return this; } public: virtual const char* name() const {
 return "CompareOp"; } virtual void visit(InstructionVisitor*
 v) { v->do_CompareOp(this); }
public:
// creation
CompareOp(Bytecodes::Code op, Value x, Value y, ValueStack* state_before)
: Op2(intType, op, x, y, state_before)
{}

// generic
HASHING3(Op2, true, op(), x()->subst(), y()->subst())virtual intx hash() const { return (true) ? ((((((((intx)(name
())) << 7) ^ ((intx)(op()))) << 7) ^ ((intx)(x()->
subst()))) << 7) ^ ((intx)(y()->subst()))) : 0; } virtual
 bool is_equal(Value v) const { if (!(true) ) return false; Op2
* _v = v->as_Op2(); if (_v == __null ) return false; if (op
() != _v->op()) return false; if (x()->subst() != _v->
x()->subst()) return false; if (y()->subst() != _v->
y()->subst()) return false; return true; }
1094};


1097LEAF(IfOp, Op2)class IfOp: public Op2 { public: virtual IfOp* as_IfOp() { return
 this; } public: virtual const char* name() const { return "IfOp"
; } virtual void visit(InstructionVisitor* v) { v->do_IfOp
(this); }
private:
Value _tval;
Value _fval;

public:
// creation
IfOp(Value x, Condition cond, Value y, Value tval, Value fval)
: Op2(tval->type()->meet(fval->type()), (Bytecodes::Code)cond, x, y)
, _tval(tval)
, _fval(fval)
{
  ASSERT_VALUES
  assert(tval->type()->tag() == fval->type()->tag(), "types must match")do { if (!(tval->type()->tag() == fval->type()->tag
())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 1110, "assert(" "tval->type()->tag() == fval->type()->tag()"
 ") failed", "types must match"); ::breakpoint(); } } while (
0);
}

// accessors
virtual bool is_commutative() const;
Bytecodes::Code op() const                     { ShouldNotCallThis()do { (*g_assert_poison) = 'X';; report_should_not_call("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 1115); ::breakpoint(); } while (0); return Bytecodes::_illegal; }
Condition cond() const                         { return (Condition)Op2::op(); }
Value tval() const                             { return _tval; }
Value fval() const                             { return _fval; }

// generic
virtual void input_values_do(ValueVisitor* f)   { Op2::input_values_do(f); f->visit(&_tval); f->visit(&_fval); }
1122};


1125LEAF(Convert, Instruction)class Convert: public Instruction { public: virtual Convert* as_Convert
() { return this; } public: virtual const char* name() const {
 return "Convert"; } virtual void visit(InstructionVisitor* v
) { v->do_Convert(this); }
private:
Bytecodes::Code _op;
Value           _value;

public:
// creation
Convert(Bytecodes::Code op, Value value, ValueType* to_type) : Instruction(to_type), _op(op), _value(value) {
  ASSERT_VALUES
}

// accessors
Bytecodes::Code op() const                     { return _op; }
Value value() const                            { return _value; }

// generic
virtual void input_values_do(ValueVisitor* f)   { f->visit(&_value); }
HASHING2(Convert, true, op(), value()->subst())virtual intx hash() const { return (true) ? ((((((intx)(name(
))) << 7) ^ ((intx)(op()))) << 7) ^ ((intx)(value
()->subst()))) : 0; } virtual bool is_equal(Value v) const
 { if (!(true) ) return false; Convert* _v = v->as_Convert
(); if (_v == __null ) return false; if (op() != _v->op())
 return false; if (value()->subst() != _v->value()->
subst()) return false; return true; }
1143};


1146LEAF(NullCheck, Instruction)class NullCheck: public Instruction { public: virtual NullCheck
* as_NullCheck() { return this; } public: virtual const char*
 name() const { return "NullCheck"; } virtual void visit(InstructionVisitor
* v) { v->do_NullCheck(this); }
private:
Value       _obj;

public:
// creation
NullCheck(Value obj, ValueStack* state_before)
: Instruction(obj->type()->base(), state_before)
, _obj(obj)
{
  ASSERT_VALUES
  set_can_trap(true);
  assert(_obj->type()->is_object(), "null check must be applied to objects only")do { if (!(_obj->type()->is_object())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 1158, "assert(" "_obj->type()->is_object()" ") failed"
, "null check must be applied to objects only"); ::breakpoint
(); } } while (0);
  pin(Instruction::PinExplicitNullCheck);
}

// accessors
Value obj() const                              { return _obj; }

// setters
void set_can_trap(bool can_trap)               { set_flag(CanTrapFlag, can_trap); }

// generic
virtual bool can_trap() const                  { return check_flag(CanTrapFlag); /* null-check elimination sets to false */ }
virtual void input_values_do(ValueVisitor* f)   { f->visit(&_obj); }
HASHING1(NullCheck, true, obj()->subst())virtual intx hash() const { return (true) ? ((((intx)(name())
) << 7) ^ ((intx)(obj()->subst()))) : 0; } virtual bool
 is_equal(Value v) const { if (!(true) ) return false; NullCheck
* _v = v->as_NullCheck(); if (_v == __null ) return false;
 if (obj()->subst() != _v->obj()->subst()) return false
; return true; }
1172};


1175// This node is supposed to cast the type of another node to a more precise
1176// declared type.
1177LEAF(TypeCast, Instruction)class TypeCast: public Instruction { public: virtual TypeCast
* as_TypeCast() { return this; } public: virtual const char* name
() const { return "TypeCast"; } virtual void visit(InstructionVisitor
* v) { v->do_TypeCast(this); }
private:
ciType* _declared_type;
Value   _obj;

public:
// The type of this node is the same type as the object type (and it might be constant).
TypeCast(ciType* type, Value obj, ValueStack* state_before)
: Instruction(obj->type(), state_before, obj->type()->is_constant()),
  _declared_type(type),
  _obj(obj) {}

// accessors
ciType* declared_type() const                  { return _declared_type; }
Value   obj() const                            { return _obj; }

// generic
virtual void input_values_do(ValueVisitor* f)  { f->visit(&_obj); }
1195};


1198BASE(StateSplit, Instruction)class StateSplit: public Instruction { public: virtual StateSplit
* as_StateSplit() { return this; }
private:
ValueStack* _state;

protected:
static void substitute(BlockList& list, BlockBegin* old_block, BlockBegin* new_block);

public:
// creation
StateSplit(ValueType* type, ValueStack* state_before = NULL__null)
: Instruction(type, state_before)
, _state(NULL__null)
{
  pin(PinStateSplitConstructor);
}

// accessors
ValueStack* state() const                      { return _state; }
IRScope* scope() const;                        // the state's scope

// manipulation
void set_state(ValueStack* state)              { assert(_state == NULL, "overwriting existing state")do { if (!(_state == __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 1219, "assert(" "_state == __null" ") failed", "overwriting existing state"
); ::breakpoint(); } } while (0); check_state(state); _state = state; }

// generic
virtual void input_values_do(ValueVisitor* f)   { /* no values */ }
virtual void state_values_do(ValueVisitor* f);
1224};


1227LEAF(Invoke, StateSplit)class Invoke: public StateSplit { public: virtual Invoke* as_Invoke
() { return this; } public: virtual const char* name() const {
 return "Invoke"; } virtual void visit(InstructionVisitor* v)
 { v->do_Invoke(this); }
private:
Bytecodes::Code _code;
Value           _recv;
Values*         _args;
BasicTypeList*  _signature;
ciMethod*       _target;

public:
// creation
Invoke(Bytecodes::Code code, ValueType* result_type, Value recv, Values* args,
       ciMethod* target, ValueStack* state_before);

// accessors
Bytecodes::Code code() const                   { return _code; }
Value receiver() const                         { return _recv; }
bool has_receiver() const                      { return receiver() != NULL__null; }
int number_of_arguments() const                { return _args->length(); }
Value argument_at(int i) const                 { return _args->at(i); }
BasicTypeList* signature() const               { return _signature; }
ciMethod* target() const                       { return _target; }

ciType* declared_type() const;

// Returns false if target is not loaded
bool target_is_final() const                   { return check_flag(TargetIsFinalFlag); }
bool target_is_loaded() const                  { return check_flag(TargetIsLoadedFlag); }

// JSR 292 support
bool is_invokedynamic() const                  { return code() == Bytecodes::_invokedynamic; }
bool is_method_handle_intrinsic() const        { return target()->is_method_handle_intrinsic(); }

virtual bool needs_exception_state() const     { return false; }

// generic
virtual bool can_trap() const                  { return true; }
virtual void input_values_do(ValueVisitor* f) {
  StateSplit::input_values_do(f);
  if (has_receiver()) f->visit(&_recv);
  for (int i = 0; i < _args->length(); i++) f->visit(_args->adr_at(i));
}
virtual void state_values_do(ValueVisitor *f);
1269};


1272LEAF(NewInstance, StateSplit)class NewInstance: public StateSplit { public: virtual NewInstance
* as_NewInstance() { return this; } public: virtual const char
* name() const { return "NewInstance"; } virtual void visit(InstructionVisitor
* v) { v->do_NewInstance(this); }
private:
ciInstanceKlass* _klass;
bool _is_unresolved;

public:
// creation
NewInstance(ciInstanceKlass* klass, ValueStack* state_before, bool is_unresolved)
: StateSplit(instanceType, state_before)
, _klass(klass), _is_unresolved(is_unresolved)
{}

// accessors
ciInstanceKlass* klass() const                 { return _klass; }
bool is_unresolved() const                     { return _is_unresolved; }

virtual bool needs_exception_state() const     { return false; }

// generic
virtual bool can_trap() const                  { return true; }
ciType* exact_type() const;
ciType* declared_type() const;
1294};


1297BASE(NewArray, StateSplit)class NewArray: public StateSplit { public: virtual NewArray*
 as_NewArray() { return this; }
private:
Value       _length;

public:
// creation
NewArray(Value length, ValueStack* state_before)
: StateSplit(objectType, state_before)
, _length(length)
{
  // Do not ASSERT_VALUES since length is NULL for NewMultiArray
}

// accessors
Value length() const                           { return _length; }

virtual bool needs_exception_state() const     { return false; }

ciType* exact_type() const                     { return NULL__null; }
ciType* declared_type() const;

// generic
virtual bool can_trap() const                  { return true; }
virtual void input_values_do(ValueVisitor* f)   { StateSplit::input_values_do(f); f->visit(&_length); }
1321};


1324LEAF(NewTypeArray, NewArray)class NewTypeArray: public NewArray { public: virtual NewTypeArray
* as_NewTypeArray() { return this; } public: virtual const char
* name() const { return "NewTypeArray"; } virtual void visit(
InstructionVisitor* v) { v->do_NewTypeArray(this); }
private:
BasicType _elt_type;

public:
// creation
NewTypeArray(Value length, BasicType elt_type, ValueStack* state_before)
: NewArray(length, state_before)
, _elt_type(elt_type)
{}

// accessors
BasicType elt_type() const                     { return _elt_type; }
ciType* exact_type() const;
1338};


1341LEAF(NewObjectArray, NewArray)class NewObjectArray: public NewArray { public: virtual NewObjectArray
* as_NewObjectArray() { return this; } public: virtual const char
* name() const { return "NewObjectArray"; } virtual void visit
(InstructionVisitor* v) { v->do_NewObjectArray(this); }
private:
ciKlass* _klass;

public:
// creation
NewObjectArray(ciKlass* klass, Value length, ValueStack* state_before) : NewArray(length, state_before), _klass(klass) {}

// accessors
ciKlass* klass() const                         { return _klass; }
ciType* exact_type() const;
1352};


1355LEAF(NewMultiArray, NewArray)class NewMultiArray: public NewArray { public: virtual NewMultiArray
* as_NewMultiArray() { return this; } public: virtual const char
* name() const { return "NewMultiArray"; } virtual void visit
(InstructionVisitor* v) { v->do_NewMultiArray(this); }
private:
ciKlass* _klass;
Values*  _dims;

public:
// creation
NewMultiArray(ciKlass* klass, Values* dims, ValueStack* state_before) : NewArray(NULL__null, state_before), _klass(klass), _dims(dims) {
  ASSERT_VALUES
}

// accessors
ciKlass* klass() const                         { return _klass; }
Values* dims() const                           { return _dims; }
int rank() const                               { return dims()->length(); }

// generic
virtual void input_values_do(ValueVisitor* f) {
  // NOTE: we do not call NewArray::input_values_do since "length"
  // is meaningless for a multi-dimensional array; passing the
  // zeroth element down to NewArray as its length is a bad idea
  // since there will be a copy in the "dims" array which doesn't
  // get updated, and the value must not be traversed twice. Was bug
  // - kbr 4/10/2001
  StateSplit::input_values_do(f);
  for (int i = 0; i < _dims->length(); i++) f->visit(_dims->adr_at(i));
}
1382};


1385BASE(TypeCheck, StateSplit)class TypeCheck: public StateSplit { public: virtual TypeCheck
* as_TypeCheck() { return this; }
private:
ciKlass*    _klass;
Value       _obj;

ciMethod* _profiled_method;
int       _profiled_bci;

public:
// creation
TypeCheck(ciKlass* klass, Value obj, ValueType* type, ValueStack* state_before)
: StateSplit(type, state_before), _klass(klass), _obj(obj),
  _profiled_method(NULL__null), _profiled_bci(0) {
  ASSERT_VALUES
  set_direct_compare(false);
}

// accessors
ciKlass* klass() const                         { return _klass; }
Value obj() const                              { return _obj; }
bool is_loaded() const                         { return klass() != NULL__null; }
bool direct_compare() const                    { return check_flag(DirectCompareFlag); }

// manipulation
void set_direct_compare(bool flag)             { set_flag(DirectCompareFlag, flag); }

// generic
virtual bool can_trap() const                  { return true; }
virtual void input_values_do(ValueVisitor* f)   { StateSplit::input_values_do(f); f->visit(&_obj); }

// Helpers for MethodData* profiling
void set_should_profile(bool value)                { set_flag(ProfileMDOFlag, value); }
void set_profiled_method(ciMethod* method)         { _profiled_method = method;   }
void set_profiled_bci(int bci)                     { _profiled_bci = bci;         }
bool      should_profile() const                   { return check_flag(ProfileMDOFlag); }
ciMethod* profiled_method() const                  { return _profiled_method;     }
int       profiled_bci() const                     { return _profiled_bci;        }
1422};


1425LEAF(CheckCast, TypeCheck)class CheckCast: public TypeCheck { public: virtual CheckCast
* as_CheckCast() { return this; } public: virtual const char*
 name() const { return "CheckCast"; } virtual void visit(InstructionVisitor
* v) { v->do_CheckCast(this); }
public:
// creation
CheckCast(ciKlass* klass, Value obj, ValueStack* state_before)
: TypeCheck(klass, obj, objectType, state_before) {}

void set_incompatible_class_change_check() {
  set_flag(ThrowIncompatibleClassChangeErrorFlag, true);
}
bool is_incompatible_class_change_check() const {
  return check_flag(ThrowIncompatibleClassChangeErrorFlag);
}
void set_invokespecial_receiver_check() {
  set_flag(InvokeSpecialReceiverCheckFlag, true);
}
bool is_invokespecial_receiver_check() const {
  return check_flag(InvokeSpecialReceiverCheckFlag);
}

virtual bool needs_exception_state() const {
  return !is_invokespecial_receiver_check();
}

ciType* declared_type() const;
1449};


1452LEAF(InstanceOf, TypeCheck)class InstanceOf: public TypeCheck { public: virtual InstanceOf
* as_InstanceOf() { return this; } public: virtual const char
* name() const { return "InstanceOf"; } virtual void visit(InstructionVisitor
* v) { v->do_InstanceOf(this); }
public:
// creation
InstanceOf(ciKlass* klass, Value obj, ValueStack* state_before) : TypeCheck(klass, obj, intType, state_before) {}

virtual bool needs_exception_state() const     { return false; }
1458};


1461BASE(AccessMonitor, StateSplit)class AccessMonitor: public StateSplit { public: virtual AccessMonitor
* as_AccessMonitor() { return this; }
private:
Value       _obj;
int         _monitor_no;

public:
// creation
AccessMonitor(Value obj, int monitor_no, ValueStack* state_before = NULL__null)
: StateSplit(illegalType, state_before)
, _obj(obj)
, _monitor_no(monitor_no)
{
  set_needs_null_check(true);
  ASSERT_VALUES
}

// accessors
Value obj() const                              { return _obj; }
int monitor_no() const                         { return _monitor_no; }

// generic
virtual void input_values_do(ValueVisitor* f)   { StateSplit::input_values_do(f); f->visit(&_obj); }
1483};


1486LEAF(MonitorEnter, AccessMonitor)class MonitorEnter: public AccessMonitor { public: virtual MonitorEnter
* as_MonitorEnter() { return this; } public: virtual const char
* name() const { return "MonitorEnter"; } virtual void visit(
InstructionVisitor* v) { v->do_MonitorEnter(this); }
public:
// creation
MonitorEnter(Value obj, int monitor_no, ValueStack* state_before)
: AccessMonitor(obj, monitor_no, state_before)
{
  ASSERT_VALUES
}

// generic
virtual bool can_trap() const                  { return true; }
1497};


1500LEAF(MonitorExit, AccessMonitor)class MonitorExit: public AccessMonitor { public: virtual MonitorExit
* as_MonitorExit() { return this; } public: virtual const char
* name() const { return "MonitorExit"; } virtual void visit(InstructionVisitor
* v) { v->do_MonitorExit(this); }
public:
// creation
MonitorExit(Value obj, int monitor_no)
: AccessMonitor(obj, monitor_no, NULL__null)
{
  ASSERT_VALUES
}
1508};


1511LEAF(Intrinsic, StateSplit)class Intrinsic: public StateSplit { public: virtual Intrinsic
* as_Intrinsic() { return this; } public: virtual const char*
 name() const { return "Intrinsic"; } virtual void visit(InstructionVisitor
* v) { v->do_Intrinsic(this); }
private:
vmIntrinsics::ID _id;
Values*          _args;
Value            _recv;
ArgsNonNullState _nonnull_state;

public:
// preserves_state can be set to true for Intrinsics
// which are guaranteed to preserve register state across any slow
// cases; setting it to true does not mean that the Intrinsic can
// not trap, only that if we continue execution in the same basic
// block after the Intrinsic, all of the registers are intact. This
// allows load elimination and common expression elimination to be
// performed across the Intrinsic.  The default value is false.
Intrinsic(ValueType* type,
          vmIntrinsics::ID id,
          Values* args,
          bool has_receiver,
          ValueStack* state_before,
          bool preserves_state,
          bool cantrap = true)
: StateSplit(type, state_before)
, _id(id)
, _args(args)
, _recv(NULL__null)
{
  assert(args != NULL, "args must exist")do { if (!(args != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 1538, "assert(" "args != __null" ") failed", "args must exist"
); ::breakpoint(); } } while (0);
  ASSERT_VALUES
  set_flag(PreservesStateFlag, preserves_state);
  set_flag(CanTrapFlag,        cantrap);
  if (has_receiver) {
    _recv = argument_at(0);
  }
  set_needs_null_check(has_receiver);

  // some intrinsics can't trap, so don't force them to be pinned
  if (!can_trap() && !vmIntrinsics::should_be_pinned(_id)) {
    unpin(PinStateSplitConstructor);
  }
}

// accessors
vmIntrinsics::ID id() const                    { return _id; }
int number_of_arguments() const                { return _args->length(); }
Value argument_at(int i) const                 { return _args->at(i); }

bool has_receiver() const                      { return (_recv != NULL__null); }
Value receiver() const                         { assert(has_receiver(), "must have receiver")do { if (!(has_receiver())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 1559, "assert(" "has_receiver()" ") failed", "must have receiver"
); ::breakpoint(); } } while (0); return _recv; }
bool preserves_state() const                   { return check_flag(PreservesStateFlag); }

bool arg_needs_null_check(int i) const {
  return _nonnull_state.arg_needs_null_check(i);
}

void set_arg_needs_null_check(int i, bool check) {
  _nonnull_state.set_arg_needs_null_check(i, check);
}

// generic
virtual bool can_trap() const                  { return check_flag(CanTrapFlag); }
virtual void input_values_do(ValueVisitor* f) {
  StateSplit::input_values_do(f);
  for (int i = 0; i < _args->length(); i++) f->visit(_args->adr_at(i));
}
1576};


1579class LIR_List;

1581LEAF(BlockBegin, StateSplit)class BlockBegin: public StateSplit { public: virtual BlockBegin
* as_BlockBegin() { return this; } public: virtual const char
* name() const { return "BlockBegin"; } virtual void visit(InstructionVisitor
* v) { v->do_BlockBegin(this); }
private:
int        _block_id;                          // the unique block id
int        _bci;                               // start-bci of block
int        _depth_first_number;                // number of this block in a depth-first ordering
int        _linear_scan_number;                // number of this block in linear-scan ordering
int        _dominator_depth;
int        _loop_depth;                        // the loop nesting level of this block
int        _loop_index;                        // number of the innermost loop of this block
int        _flags;                             // the flags associated with this block

// fields used by BlockListBuilder
int            _total_preds;                   // number of predecessors found by BlockListBuilder
ResourceBitMap _stores_to_locals;              // bit is set when a local variable is stored in the block

// SSA specific fields: (factor out later)
BlockList   _predecessors;                     // the predecessors of this block
BlockList   _dominates;                        // list of blocks that are dominated by this block
BlockBegin* _dominator;                        // the dominator of this block
// SSA specific ends
BlockEnd*  _end;                               // the last instruction of this block
BlockList  _exception_handlers;                // the exception handlers potentially invoked by this block
ValueStackStack* _exception_states;            // only for xhandler entries: states of all instructions that have an edge to this xhandler
int        _exception_handler_pco;             // if this block is the start of an exception handler,
                                               // this records the PC offset in the assembly code of the
                                               // first instruction in this block
Label      _label;                             // the label associated with this block
LIR_List*  _lir;                               // the low level intermediate representation for this block

ResourceBitMap _live_in;                       // set of live LIR_Opr registers at entry to this block
ResourceBitMap _live_out;                      // set of live LIR_Opr registers at exit from this block
ResourceBitMap _live_gen;                      // set of registers used before any redefinition in this block
ResourceBitMap _live_kill;                     // set of registers defined in this block

ResourceBitMap _fpu_register_usage;
intArray*      _fpu_stack_state;               // For x86 FPU code generation with UseLinearScan
int            _first_lir_instruction_id;      // ID of first LIR instruction in this block
int            _last_lir_instruction_id;       // ID of last LIR instruction in this block

void iterate_preorder (boolArray& mark, BlockClosure* closure);
void iterate_postorder(boolArray& mark, BlockClosure* closure);

friend class SuxAndWeightAdjuster;

public:
 void* operator new(size_t size) throw() {
  Compilation* c = Compilation::current();
  void* res = c->arena()->Amalloc(size);
  return res;
}

// initialization/counting
static int  number_of_blocks() {
  return Compilation::current()->number_of_blocks();
}

// creation
BlockBegin(int bci)
: StateSplit(illegalType)
, _block_id(Compilation::current()->get_next_block_id())
, _bci(bci)
, _depth_first_number(-1)
, _linear_scan_number(-1)
, _dominator_depth(-1)
, _loop_depth(0)
, _loop_index(-1)
, _flags(0)
, _total_preds(0)
, _stores_to_locals()
, _predecessors(2)
, _dominates(2)
, _dominator(NULL__null)
, _end(NULL__null)
, _exception_handlers(1)
, _exception_states(NULL__null)
, _exception_handler_pco(-1)
, _lir(NULL__null)
, _live_in()
, _live_out()
, _live_gen()
, _live_kill()
, _fpu_register_usage()
, _fpu_stack_state(NULL__null)
, _first_lir_instruction_id(-1)
, _last_lir_instruction_id(-1)
{
  _block = this;
1668#ifndef PRODUCT
  set_printable_bci(bci);
1670#endif
}

// accessors
int block_id() const                           { return _block_id; }
int bci() const                                { return _bci; }
BlockList* dominates()                         { return &_dominates; }
BlockBegin* dominator() const                  { return _dominator; }
int loop_depth() const                         { return _loop_depth; }
int dominator_depth() const                    { return _dominator_depth; }
int depth_first_number() const                 { return _depth_first_number; }
int linear_scan_number() const                 { return _linear_scan_number; }
BlockEnd* end() const                          { return _end; }
Label* label()                                 { return &_label; }
LIR_List* lir() const                          { return _lir; }
int exception_handler_pco() const              { return _exception_handler_pco; }
ResourceBitMap& live_in()                      { return _live_in;        }
ResourceBitMap& live_out()                     { return _live_out;       }
ResourceBitMap& live_gen()                     { return _live_gen;       }
ResourceBitMap& live_kill()                    { return _live_kill;      }
ResourceBitMap& fpu_register_usage()           { return _fpu_register_usage; }
intArray* fpu_stack_state() const              { return _fpu_stack_state;    }
int first_lir_instruction_id() const           { return _first_lir_instruction_id; }
int last_lir_instruction_id() const            { return _last_lir_instruction_id; }
int total_preds() const                        { return _total_preds; }
BitMap& stores_to_locals()                     { return _stores_to_locals; }

// manipulation
void set_dominator(BlockBegin* dom)            { _dominator = dom; }
void set_loop_depth(int d)                     { _loop_depth = d; }
void set_dominator_depth(int d)                { _dominator_depth = d; }
void set_depth_first_number(int dfn)           { _depth_first_number = dfn; }
void set_linear_scan_number(int lsn)           { _linear_scan_number = lsn; }
void set_end(BlockEnd* new_end);
static void disconnect_edge(BlockBegin* from, BlockBegin* to);
BlockBegin* insert_block_between(BlockBegin* sux);
void substitute_sux(BlockBegin* old_sux, BlockBegin* new_sux);
void set_lir(LIR_List* lir)                    { _lir = lir; }
void set_exception_handler_pco(int pco)        { _exception_handler_pco = pco; }
void set_live_in  (const ResourceBitMap& map)  { _live_in = map;   }
void set_live_out (const ResourceBitMap& map)  { _live_out = map;  }
void set_live_gen (const ResourceBitMap& map)  { _live_gen = map;  }
void set_live_kill(const ResourceBitMap& map)  { _live_kill = map; }
void set_fpu_register_usage(const ResourceBitMap& map) { _fpu_register_usage = map; }
void set_fpu_stack_state(intArray* state)      { _fpu_stack_state = state;  }
void set_first_lir_instruction_id(int id)      { _first_lir_instruction_id = id;  }
void set_last_lir_instruction_id(int id)       { _last_lir_instruction_id = id;  }
void increment_total_preds(int n = 1)          { _total_preds += n; }
void init_stores_to_locals(int locals_count)   { _stores_to_locals.initialize(locals_count); }

// generic
virtual void state_values_do(ValueVisitor* f);

// successors and predecessors
int number_of_sux() const;
BlockBegin* sux_at(int i) const;
void add_predecessor(BlockBegin* pred);
void remove_predecessor(BlockBegin* pred);
bool is_predecessor(BlockBegin* pred) const    { return _predecessors.contains(pred); }
int number_of_preds() const                    { return _predecessors.length(); }
BlockBegin* pred_at(int i) const               { return _predecessors.at(i); }

// exception handlers potentially invoked by this block
void add_exception_handler(BlockBegin* b);
bool is_exception_handler(BlockBegin* b) const { return _exception_handlers.contains(b); }
int  number_of_exception_handlers() const      { return _exception_handlers.length(); }
BlockBegin* exception_handler_at(int i) const  { return _exception_handlers.at(i); }

// states of the instructions that have an edge to this exception handler
int number_of_exception_states()               { assert(is_set(exception_entry_flag), "only for xhandlers")do { if (!(is_set(exception_entry_flag))) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 1739, "assert(" "is_set(exception_entry_flag)" ") failed", "only for xhandlers"
); ::breakpoint(); } } while (0); return _exception_states == NULL__null ? 0 : _exception_states->length(); }
ValueStack* exception_state_at(int idx) const  { assert(is_set(exception_entry_flag), "only for xhandlers")do { if (!(is_set(exception_entry_flag))) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 1740, "assert(" "is_set(exception_entry_flag)" ") failed", "only for xhandlers"
); ::breakpoint(); } } while (0); return _exception_states->at(idx); }
int add_exception_state(ValueStack* state);

// flags
enum Flag {
  no_flag                       = 0,
  std_entry_flag                = 1 << 0,
  osr_entry_flag                = 1 << 1,
  exception_entry_flag          = 1 << 2,
  subroutine_entry_flag         = 1 << 3,
  backward_branch_target_flag   = 1 << 4,
  is_on_work_list_flag          = 1 << 5,
  was_visited_flag              = 1 << 6,
  parser_loop_header_flag       = 1 << 7,  // set by parser to identify blocks where phi functions can not be created on demand
  critical_edge_split_flag      = 1 << 8, // set for all blocks that are introduced when critical edges are split
  linear_scan_loop_header_flag  = 1 << 9, // set during loop-detection for LinearScan
  linear_scan_loop_end_flag     = 1 << 10, // set during loop-detection for LinearScan
  donot_eliminate_range_checks  = 1 << 11  // Should be try to eliminate range checks in this block
};

void set(Flag f)                               { _flags |= f; }
void clear(Flag f)                             { _flags &= ~f; }
bool is_set(Flag f) const                      { return (_flags & f) != 0; }
bool is_entry_block() const {
  const int entry_mask = std_entry_flag | osr_entry_flag | exception_entry_flag;
  return (_flags & entry_mask) != 0;
}

// iteration
void iterate_preorder   (BlockClosure* closure);
void iterate_postorder  (BlockClosure* closure);

void block_values_do(ValueVisitor* f);

// loops
void set_loop_index(int ix)                    { _loop_index = ix;        }
int  loop_index() const                        { return _loop_index;      }

// merging
bool try_merge(ValueStack* state);             // try to merge states at block begin
void merge(ValueStack* state)                  { bool b = try_merge(state); assert(b, "merge failed")do { if (!(b)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 1780, "assert(" "b" ") failed", "merge failed"); ::breakpoint
(); } } while (0); }

// debugging
void print_block()                             PRODUCT_RETURN;
void print_block(InstructionPrinter& ip, bool live_only = false) PRODUCT_RETURN;

1786};


1789BASE(BlockEnd, StateSplit)class BlockEnd: public StateSplit { public: virtual BlockEnd*
 as_BlockEnd() { return this; }
private:
BlockList*  _sux;

protected:
BlockList* sux() const                         { return _sux; }

void set_sux(BlockList* sux) {
1797#ifdef ASSERT1
  assert(sux != NULL, "sux must exist")do { if (!(sux != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 1798, "assert(" "sux != __null" ") failed", "sux must exist"
); ::breakpoint(); } } while (0);
  for (int i = sux->length() - 1; i >= 0; i--) assert(sux->at(i) != NULL, "sux must exist")do { if (!(sux->at(i) != __null)) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 1799, "assert(" "sux->at(i) != __null" ") failed", "sux must exist"
); ::breakpoint(); } } while (0);
1800#endif
  _sux = sux;
}

public:
// creation
BlockEnd(ValueType* type, ValueStack* state_before, bool is_safepoint)
: StateSplit(type, state_before)
, _sux(NULL__null)
{
  set_flag(IsSafepointFlag, is_safepoint);
}

// accessors
bool is_safepoint() const                      { return check_flag(IsSafepointFlag); }
// For compatibility with old code, for new code use block()
BlockBegin* begin() const                      { return _block; }

// manipulation
inline void remove_sux_at(int i) { _sux->remove_at(i);}
inline int find_sux(BlockBegin* sux) {return _sux->find(sux);}

// successors
int number_of_sux() const                      { return _sux != NULL__null ? _sux->length() : 0; }
BlockBegin* sux_at(int i) const                { return _sux->at(i); }
BlockBegin* default_sux() const                { return sux_at(number_of_sux() - 1); }
void substitute_sux(BlockBegin* old_sux, BlockBegin* new_sux);
1827};


1830LEAF(Goto, BlockEnd)class Goto: public BlockEnd { public: virtual Goto* as_Goto()
 { return this; } public: virtual const char* name() const { return
 "Goto"; } virtual void visit(InstructionVisitor* v) { v->
do_Goto(this); }
public:
enum Direction {
  none,            // Just a regular goto
  taken, not_taken // Goto produced from If
};
private:
ciMethod*   _profiled_method;
int         _profiled_bci;
Direction   _direction;
public:
// creation
Goto(BlockBegin* sux, ValueStack* state_before, bool is_safepoint = false)
  : BlockEnd(illegalType, state_before, is_safepoint)
  , _profiled_method(NULL__null)
  , _profiled_bci(0)
  , _direction(none) {
  BlockList* s = new BlockList(1);
  s->append(sux);
  set_sux(s);
}

Goto(BlockBegin* sux, bool is_safepoint) : BlockEnd(illegalType, NULL__null, is_safepoint)
                                         , _profiled_method(NULL__null)
                                         , _profiled_bci(0)
                                         , _direction(none) {
  BlockList* s = new BlockList(1);
  s->append(sux);
  set_sux(s);
}

bool should_profile() const                    { return check_flag(ProfileMDOFlag); }
ciMethod* profiled_method() const              { return _profiled_method; } // set only for profiled branches
int profiled_bci() const                       { return _profiled_bci; }
Direction direction() const                    { return _direction; }

void set_should_profile(bool value)            { set_flag(ProfileMDOFlag, value); }
void set_profiled_method(ciMethod* method)     { _profiled_method = method; }
void set_profiled_bci(int bci)                 { _profiled_bci = bci; }
void set_direction(Direction d)                { _direction = d; }
1870};

1872#ifdef ASSERT1
1873LEAF(Assert, Instruction)class Assert: public Instruction { public: virtual Assert* as_Assert
() { return this; } public: virtual const char* name() const {
 return "Assert"; } virtual void visit(InstructionVisitor* v)
 { v->do_Assert(this); }
private:
Value       _x;
Condition   _cond;
Value       _y;
char        *_message;

public:
// creation
// unordered_is_true is valid for float/double compares only
 Assert(Value x, Condition cond, bool unordered_is_true, Value y);

// accessors
Value x() const                                { return _x; }
Condition cond() const                         { return _cond; }
bool unordered_is_true() const                 { return check_flag(UnorderedIsTrueFlag); }
Value y() const                                { return _y; }
const char *message() const                    { return _message; }

// generic
virtual void input_values_do(ValueVisitor* f)  { f->visit(&_x); f->visit(&_y); }
1894};
1895#endif

1897LEAF(RangeCheckPredicate, StateSplit)class RangeCheckPredicate: public StateSplit { public: virtual
 RangeCheckPredicate* as_RangeCheckPredicate() { return this;
 } public: virtual const char* name() const { return "RangeCheckPredicate"
; } virtual void visit(InstructionVisitor* v) { v->do_RangeCheckPredicate
(this); }
private:
Value       _x;
Condition   _cond;
Value       _y;

void check_state();

public:
// creation
// unordered_is_true is valid for float/double compares only
 RangeCheckPredicate(Value x, Condition cond, bool unordered_is_true, Value y, ValueStack* state) : StateSplit(illegalType)
, _x(x)
, _cond(cond)
, _y(y)
{
  ASSERT_VALUES
  set_flag(UnorderedIsTrueFlag, unordered_is_true);
  assert(x->type()->tag() == y->type()->tag(), "types must match")do { if (!(x->type()->tag() == y->type()->tag()))
 { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 1915, "assert(" "x->type()->tag() == y->type()->tag()"
 ") failed", "types must match"); ::breakpoint(); } } while (
0);
  this->set_state(state);
  check_state();
}

// Always deoptimize
RangeCheckPredicate(ValueStack* state) : StateSplit(illegalType)
{
  this->set_state(state);
  _x = _y = NULL__null;
  check_state();
}

// accessors
Value x() const                                { return _x; }
Condition cond() const                         { return _cond; }
bool unordered_is_true() const                 { return check_flag(UnorderedIsTrueFlag); }
Value y() const                                { return _y; }

void always_fail()                             { _x = _y = NULL__null; }

// generic
virtual void input_values_do(ValueVisitor* f)  { StateSplit::input_values_do(f); f->visit(&_x); f->visit(&_y); }
HASHING3(RangeCheckPredicate, true, x()->subst(), y()->subst(), cond())virtual intx hash() const { return (true) ? ((((((((intx)(name
())) << 7) ^ ((intx)(x()->subst()))) << 7) ^ (
(intx)(y()->subst()))) << 7) ^ ((intx)(cond()))) : 0
; } virtual bool is_equal(Value v) const { if (!(true) ) return
 false; RangeCheckPredicate* _v = v->as_RangeCheckPredicate
(); if (_v == __null ) return false; if (x()->subst() != _v
->x()->subst()) return false; if (y()->subst() != _v
->y()->subst()) return false; if (cond() != _v->cond
()) return false; return true; }
1939};

1941LEAF(If, BlockEnd)class If: public BlockEnd { public: virtual If* as_If() { return
 this; } public: virtual const char* name() const { return "If"
; } virtual void visit(InstructionVisitor* v) { v->do_If(this
); }
private:
Value       _x;
Condition   _cond;
Value       _y;
ciMethod*   _profiled_method;
int         _profiled_bci; // Canonicalizer may alter bci of If node
bool        _swapped;      // Is the order reversed with respect to the original If in the
                           // bytecode stream?
public:
// creation
// unordered_is_true is valid for float/double compares only
If(Value x, Condition cond, bool unordered_is_true, Value y, BlockBegin* tsux, BlockBegin* fsux, ValueStack* state_before, bool is_safepoint)
  : BlockEnd(illegalType, state_before, is_safepoint)
, _x(x)
, _cond(cond)
, _y(y)
, _profiled_method(NULL__null)
, _profiled_bci(0)
, _swapped(false)
{
  ASSERT_VALUES
  set_flag(UnorderedIsTrueFlag, unordered_is_true);
  assert(x->type()->tag() == y->type()->tag(), "types must match")do { if (!(x->type()->tag() == y->type()->tag()))
 { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 1964, "assert(" "x->type()->tag() == y->type()->tag()"
 ") failed", "types must match"); ::breakpoint(); } } while (
0);
  BlockList* s = new BlockList(2);
  s->append(tsux);
  s->append(fsux);
  set_sux(s);
}

// accessors
Value x() const                                { return _x; }
Condition cond() const                         { return _cond; }
bool unordered_is_true() const                 { return check_flag(UnorderedIsTrueFlag); }
Value y() const                                { return _y; }
BlockBegin* sux_for(bool is_true) const        { return sux_at(is_true ? 0 : 1); }
BlockBegin* tsux() const                       { return sux_for(true); }
BlockBegin* fsux() const                       { return sux_for(false); }
BlockBegin* usux() const                       { return sux_for(unordered_is_true()); }
bool should_profile() const                    { return check_flag(ProfileMDOFlag); }
ciMethod* profiled_method() const              { return _profiled_method; } // set only for profiled branches
int profiled_bci() const                       { return _profiled_bci; }    // set for profiled branches and tiered
bool is_swapped() const                        { return _swapped; }

// manipulation
void swap_operands() {
  Value t = _x; _x = _y; _y = t;
  _cond = mirror(_cond);
}

void set_should_profile(bool value)             { set_flag(ProfileMDOFlag, value); }
void set_profiled_method(ciMethod* method)      { _profiled_method = method; }
void set_profiled_bci(int bci)                  { _profiled_bci = bci;       }
void set_swapped(bool value)                    { _swapped = value;         }
// generic
virtual void input_values_do(ValueVisitor* f)   { BlockEnd::input_values_do(f); f->visit(&_x); f->visit(&_y); }
1997};


2000BASE(Switch, BlockEnd)class Switch: public BlockEnd { public: virtual Switch* as_Switch
() { return this; }
private:
Value       _tag;

public:
// creation
Switch(Value tag, BlockList* sux, ValueStack* state_before, bool is_safepoint)
: BlockEnd(illegalType, state_before, is_safepoint)
, _tag(tag) {
  ASSERT_VALUES
  set_sux(sux);
}

// accessors
Value tag() const                              { return _tag; }
int length() const                             { return number_of_sux() - 1; }

virtual bool needs_exception_state() const     { return false; }

// generic
virtual void input_values_do(ValueVisitor* f)   { BlockEnd::input_values_do(f); f->visit(&_tag); }
2021};


2024LEAF(TableSwitch, Switch)class TableSwitch: public Switch { public: virtual TableSwitch
* as_TableSwitch() { return this; } public: virtual const char
* name() const { return "TableSwitch"; } virtual void visit(InstructionVisitor
* v) { v->do_TableSwitch(this); }
private:
int _lo_key;

public:
// creation
TableSwitch(Value tag, BlockList* sux, int lo_key, ValueStack* state_before, bool is_safepoint)
  : Switch(tag, sux, state_before, is_safepoint)
, _lo_key(lo_key) { assert(_lo_key <= hi_key(), "integer overflow")do { if (!(_lo_key <= hi_key())) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 2032, "assert(" "_lo_key <= hi_key()" ") failed", "integer overflow"
); ::breakpoint(); } } while (0); }

// accessors
int lo_key() const                             { return _lo_key; }
int hi_key() const                             { return _lo_key + (length() - 1); }
2037};


2040LEAF(LookupSwitch, Switch)class LookupSwitch: public Switch { public: virtual LookupSwitch
* as_LookupSwitch() { return this; } public: virtual const char
* name() const { return "LookupSwitch"; } virtual void visit(
InstructionVisitor* v) { v->do_LookupSwitch(this); }
private:
intArray* _keys;

public:
// creation
LookupSwitch(Value tag, BlockList* sux, intArray* keys, ValueStack* state_before, bool is_safepoint)
: Switch(tag, sux, state_before, is_safepoint)
, _keys(keys) {
  assert(keys != NULL, "keys must exist")do { if (!(keys != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 2049, "assert(" "keys != __null" ") failed", "keys must exist"
); ::breakpoint(); } } while (0);
  assert(keys->length() == length(), "sux & keys have incompatible lengths")do { if (!(keys->length() == length())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 2050, "assert(" "keys->length() == length()" ") failed",
 "sux & keys have incompatible lengths"); ::breakpoint();
 } } while (0);
}

// accessors
int key_at(int i) const                        { return _keys->at(i); }
2055};


2058LEAF(Return, BlockEnd)class Return: public BlockEnd { public: virtual Return* as_Return
() { return this; } public: virtual const char* name() const {
 return "Return"; } virtual void visit(InstructionVisitor* v)
 { v->do_Return(this); }
private:
Value _result;

public:
// creation
Return(Value result) :
  BlockEnd(result == NULL__null ? voidType : result->type()->base(), NULL__null, true),
  _result(result) {}

// accessors
Value result() const                           { return _result; }
bool has_result() const                        { return result() != NULL__null; }

// generic
virtual void input_values_do(ValueVisitor* f) {
  BlockEnd::input_values_do(f);
  if (has_result()) f->visit(&_result);
}
2077};


2080LEAF(Throw, BlockEnd)class Throw: public BlockEnd { public: virtual Throw* as_Throw
() { return this; } public: virtual const char* name() const {
 return "Throw"; } virtual void visit(InstructionVisitor* v) {
 v->do_Throw(this); }
private:
Value _exception;

public:
// creation
Throw(Value exception, ValueStack* state_before) : BlockEnd(illegalType, state_before, true), _exception(exception) {
  ASSERT_VALUES
}

// accessors
Value exception() const                        { return _exception; }

// generic
virtual bool can_trap() const                  { return true; }
virtual void input_values_do(ValueVisitor* f)   { BlockEnd::input_values_do(f); f->visit(&_exception); }
2096};


2099LEAF(Base, BlockEnd)class Base: public BlockEnd { public: virtual Base* as_Base()
 { return this; } public: virtual const char* name() const { return
 "Base"; } virtual void visit(InstructionVisitor* v) { v->
do_Base(this); }
public:
// creation
Base(BlockBegin* std_entry, BlockBegin* osr_entry) : BlockEnd(illegalType, NULL__null, false) {
  assert(std_entry->is_set(BlockBegin::std_entry_flag), "std entry must be flagged")do { if (!(std_entry->is_set(BlockBegin::std_entry_flag)))
 { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 2103, "assert(" "std_entry->is_set(BlockBegin::std_entry_flag)"
 ") failed", "std entry must be flagged"); ::breakpoint(); } }
 while (0);
  assert(osr_entry == NULL || osr_entry->is_set(BlockBegin::osr_entry_flag), "osr entry must be flagged")do { if (!(osr_entry == __null || osr_entry->is_set(BlockBegin
::osr_entry_flag))) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 2104, "assert(" "osr_entry == __null || osr_entry->is_set(BlockBegin::osr_entry_flag)"
 ") failed", "osr entry must be flagged"); ::breakpoint(); } }
 while (0);
  BlockList* s = new BlockList(2);
  if (osr_entry != NULL__null) s->append(osr_entry);
  s->append(std_entry); // must be default sux!
  set_sux(s);
}

// accessors
BlockBegin* std_entry() const                  { return default_sux(); }
BlockBegin* osr_entry() const                  { return number_of_sux() < 2 ? NULL__null : sux_at(0); }
2114};


2117LEAF(OsrEntry, Instruction)class OsrEntry: public Instruction { public: virtual OsrEntry
* as_OsrEntry() { return this; } public: virtual const char* name
() const { return "OsrEntry"; } virtual void visit(InstructionVisitor
* v) { v->do_OsrEntry(this); }
public:
// creation
2120#ifdef _LP641
OsrEntry() : Instruction(longType) { pin(); }
2122#else
OsrEntry() : Instruction(intType)  { pin(); }
2124#endif

// generic
virtual void input_values_do(ValueVisitor* f)   { }
2128};


2131// Models the incoming exception at a catch site
2132LEAF(ExceptionObject, Instruction)class ExceptionObject: public Instruction { public: virtual ExceptionObject
* as_ExceptionObject() { return this; } public: virtual const
 char* name() const { return "ExceptionObject"; } virtual void
 visit(InstructionVisitor* v) { v->do_ExceptionObject(this
); }
public:
// creation
ExceptionObject() : Instruction(objectType) {
  pin();
}

// generic
virtual void input_values_do(ValueVisitor* f)   { }
2141};


2144// Models needed rounding for floating-point values on Intel.
2145// Currently only used to represent rounding of double-precision
2146// values stored into local variables, but could be used to model
2147// intermediate rounding of single-precision values as well.
2148LEAF(RoundFP, Instruction)class RoundFP: public Instruction { public: virtual RoundFP* as_RoundFP
() { return this; } public: virtual const char* name() const {
 return "RoundFP"; } virtual void visit(InstructionVisitor* v
) { v->do_RoundFP(this); }
private:
Value _input;             // floating-point value to be rounded

public:
RoundFP(Value input)
: Instruction(input->type()) // Note: should not be used for constants
, _input(input)
{
  ASSERT_VALUES
}

// accessors
Value input() const                            { return _input; }

// generic
virtual void input_values_do(ValueVisitor* f)   { f->visit(&_input); }
2165};


2168BASE(UnsafeOp, Instruction)class UnsafeOp: public Instruction { public: virtual UnsafeOp
* as_UnsafeOp() { return this; }
private:
Value _object;                                 // Object to be fetched from or mutated
Value _offset;                                 // Offset within object
bool  _is_volatile;                            // true if volatile - dl/JSR166
BasicType _basic_type;                         // ValueType can not express byte-sized integers

protected:
// creation
UnsafeOp(BasicType basic_type, Value object, Value offset, bool is_put, bool is_volatile)
  : Instruction(is_put ? voidType : as_ValueType(basic_type)),
  _object(object), _offset(offset), _is_volatile(is_volatile), _basic_type(basic_type)
{
  //Note:  Unsafe ops are not not guaranteed to throw NPE.
  // Convservatively, Unsafe operations must be pinned though we could be
  // looser about this if we wanted to..
  pin();
}

public:
// accessors
BasicType basic_type()                         { return _basic_type; }
Value object()                                 { return _object; }
Value offset()                                 { return _offset; }
bool  is_volatile()                            { return _is_volatile; }

// generic
virtual void input_values_do(ValueVisitor* f)   { f->visit(&_object);
                                                  f->visit(&_offset); }
2197};

2199LEAF(UnsafeGet, UnsafeOp)class UnsafeGet: public UnsafeOp { public: virtual UnsafeGet*
 as_UnsafeGet() { return this; } public: virtual const char* name
() const { return "UnsafeGet"; } virtual void visit(InstructionVisitor
* v) { v->do_UnsafeGet(this); }
private:
bool _is_raw;
public:
UnsafeGet(BasicType basic_type, Value object, Value offset, bool is_volatile)
: UnsafeOp(basic_type, object, offset, false, is_volatile)
{
  ASSERT_VALUES
  _is_raw = false;
}
UnsafeGet(BasicType basic_type, Value object, Value offset, bool is_volatile, bool is_raw)
: UnsafeOp(basic_type, object, offset, false, is_volatile), _is_raw(is_raw)
{
  ASSERT_VALUES
}

// accessors
bool is_raw()                             { return _is_raw; }
2217};


2220LEAF(UnsafePut, UnsafeOp)class UnsafePut: public UnsafeOp { public: virtual UnsafePut*
 as_UnsafePut() { return this; } public: virtual const char* name
() const { return "UnsafePut"; } virtual void visit(InstructionVisitor
* v) { v->do_UnsafePut(this); }
private:
Value _value;                                  // Value to be stored
public:
UnsafePut(BasicType basic_type, Value object, Value offset, Value value, bool is_volatile)
: UnsafeOp(basic_type, object, offset, true, is_volatile)
  , _value(value)
{
  ASSERT_VALUES
}

// accessors
Value value()                                  { return _value; }

// generic
virtual void input_values_do(ValueVisitor* f)   { UnsafeOp::input_values_do(f);
                                                 f->visit(&_value); }
2237};

2239LEAF(UnsafeGetAndSet, UnsafeOp)class UnsafeGetAndSet: public UnsafeOp { public: virtual UnsafeGetAndSet
* as_UnsafeGetAndSet() { return this; } public: virtual const
 char* name() const { return "UnsafeGetAndSet"; } virtual void
 visit(InstructionVisitor* v) { v->do_UnsafeGetAndSet(this
); }
private:
Value _value;                                  // Value to be stored
bool  _is_add;
public:
UnsafeGetAndSet(BasicType basic_type, Value object, Value offset, Value value, bool is_add)
: UnsafeOp(basic_type, object, offset, false, false)
  , _value(value)
  , _is_add(is_add)
{
  ASSERT_VALUES
}

// accessors
bool is_add() const                            { return _is_add; }
Value value()                                  { return _value; }

// generic
virtual void input_values_do(ValueVisitor* f)   { UnsafeOp::input_values_do(f);
                                                 f->visit(&_value); }
2259};

2261LEAF(ProfileCall, Instruction)class ProfileCall: public Instruction { public: virtual ProfileCall
* as_ProfileCall() { return this; } public: virtual const char
* name() const { return "ProfileCall"; } virtual void visit(InstructionVisitor
* v) { v->do_ProfileCall(this); }
private:
ciMethod*        _method;
int              _bci_of_invoke;
ciMethod*        _callee;         // the method that is called at the given bci
Value            _recv;
ciKlass*         _known_holder;
Values*          _obj_args;       // arguments for type profiling
ArgsNonNullState _nonnull_state;  // Do we know whether some arguments are never null?
bool             _inlined;        // Are we profiling a call that is inlined

public:
ProfileCall(ciMethod* method, int bci, ciMethod* callee, Value recv, ciKlass* known_holder, Values* obj_args, bool inlined)
  : Instruction(voidType)
  , _method(method)
  , _bci_of_invoke(bci)
  , _callee(callee)
  , _recv(recv)
  , _known_holder(known_holder)
  , _obj_args(obj_args)
  , _inlined(inlined)
{
  // The ProfileCall has side-effects and must occur precisely where located
  pin();
}

ciMethod* method()             const { return _method; }
int bci_of_invoke()            const { return _bci_of_invoke; }
ciMethod* callee()             const { return _callee; }
Value recv()                   const { return _recv; }
ciKlass* known_holder()        const { return _known_holder; }
int nb_profiled_args()         const { return _obj_args == NULL__null ? 0 : _obj_args->length(); }
Value profiled_arg_at(int i)   const { return _obj_args->at(i); }
bool arg_needs_null_check(int i) const {
  return _nonnull_state.arg_needs_null_check(i);
}
bool inlined()                 const { return _inlined; }

void set_arg_needs_null_check(int i, bool check) {
  _nonnull_state.set_arg_needs_null_check(i, check);
}

virtual void input_values_do(ValueVisitor* f)   {
  if (_recv != NULL__null) {
    f->visit(&_recv);
  }
  for (int i = 0; i < nb_profiled_args(); i++) {
    f->visit(_obj_args->adr_at(i));
  }
}
2311};

2313LEAF(ProfileReturnType, Instruction)class ProfileReturnType: public Instruction { public: virtual
 ProfileReturnType* as_ProfileReturnType() { return this; } public
: virtual const char* name() const { return "ProfileReturnType"
; } virtual void visit(InstructionVisitor* v) { v->do_ProfileReturnType
(this); }
private:
ciMethod*        _method;
ciMethod*        _callee;
int              _bci_of_invoke;
Value            _ret;

public:
ProfileReturnType(ciMethod* method, int bci, ciMethod* callee, Value ret)
  : Instruction(voidType)
  , _method(method)
  , _callee(callee)
  , _bci_of_invoke(bci)
  , _ret(ret)
{
  set_needs_null_check(true);
  // The ProfileType has side-effects and must occur precisely where located
  pin();
}

ciMethod* method()             const { return _method; }
ciMethod* callee()             const { return _callee; }
int bci_of_invoke()            const { return _bci_of_invoke; }
Value ret()                    const { return _ret; }

virtual void input_values_do(ValueVisitor* f)   {
  if (_ret != NULL__null) {
    f->visit(&_ret);
  }
}
2343};

2345// Call some C runtime function that doesn't safepoint,
2346// optionally passing the current thread as the first argument.
2347LEAF(RuntimeCall, Instruction)class RuntimeCall: public Instruction { public: virtual RuntimeCall
* as_RuntimeCall() { return this; } public: virtual const char
* name() const { return "RuntimeCall"; } virtual void visit(InstructionVisitor
* v) { v->do_RuntimeCall(this); }
private:
const char* _entry_name;
address     _entry;
Values*     _args;
bool        _pass_thread;  // Pass the JavaThread* as an implicit first argument

public:
RuntimeCall(ValueType* type, const char* entry_name, address entry, Values* args, bool pass_thread = true)
  : Instruction(type)
  , _entry_name(entry_name)
  , _entry(entry)
  , _args(args)
  , _pass_thread(pass_thread) {
  ASSERT_VALUES
  pin();
}

const char* entry_name() const  { return _entry_name; }
address entry() const           { return _entry; }
int number_of_arguments() const { return _args->length(); }
Value argument_at(int i) const  { return _args->at(i); }
bool pass_thread() const        { return _pass_thread; }

virtual void input_values_do(ValueVisitor* f)   {
  for (int i = 0; i < _args->length(); i++) f->visit(_args->adr_at(i));
}
2374};

2376// Use to trip invocation counter of an inlined method

2378LEAF(ProfileInvoke, Instruction)class ProfileInvoke: public Instruction { public: virtual ProfileInvoke
* as_ProfileInvoke() { return this; } public: virtual const char
* name() const { return "ProfileInvoke"; } virtual void visit
(InstructionVisitor* v) { v->do_ProfileInvoke(this); }
private:
ciMethod*   _inlinee;
ValueStack* _state;

public:
ProfileInvoke(ciMethod* inlinee,  ValueStack* state)
  : Instruction(voidType)
  , _inlinee(inlinee)
  , _state(state)
{
  // The ProfileInvoke has side-effects and must occur precisely where located QQQ???
  pin();
}

ciMethod* inlinee()      { return _inlinee; }
ValueStack* state()      { return _state; }
virtual void input_values_do(ValueVisitor*)   {}
virtual void state_values_do(ValueVisitor*);
2397};

2399LEAF(MemBar, Instruction)class MemBar: public Instruction { public: virtual MemBar* as_MemBar
() { return this; } public: virtual const char* name() const {
 return "MemBar"; } virtual void visit(InstructionVisitor* v)
 { v->do_MemBar(this); }
private:
LIR_Code _code;

public:
MemBar(LIR_Code code)
  : Instruction(voidType)
  , _code(code)
{
  pin();
}

LIR_Code code()           { return _code; }

virtual void input_values_do(ValueVisitor*)   {}
2414};

2416class BlockPair: public CompilationResourceObj {
private:
BlockBegin* _from;
BlockBegin* _to;
public:
BlockPair(BlockBegin* from, BlockBegin* to): _from(from), _to(to) {}
BlockBegin* from() const { return _from; }
BlockBegin* to() const   { return _to;   }
bool is_same(BlockBegin* from, BlockBegin* to) const { return  _from == from && _to == to; }
bool is_same(BlockPair* p) const { return  _from == p->from() && _to == p->to(); }
void set_to(BlockBegin* b)   { _to = b; }
void set_from(BlockBegin* b) { _from = b; }
2428};

2430typedef GrowableArray<BlockPair*> BlockPairList;

2432inline int         BlockBegin::number_of_sux() const            { assert(_end != NULL, "need end")do { if (!(_end != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 2432, "assert(" "_end != __null" ") failed", "need end"); ::
breakpoint(); } } while (0); return _end->number_of_sux(); }
2433inline BlockBegin* BlockBegin::sux_at(int i) const              { assert(_end != NULL , "need end")do { if (!(_end != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/c1/c1_Instruction.hpp"
, 2433, "assert(" "_end != __null" ") failed", "need end"); ::
breakpoint(); } } while (0); return _end->sux_at(i); }

2435#undef ASSERT_VALUES

2437#endif // SHARE_C1_C1_INSTRUCTION_HPP