jdk8-mips64-public/hotspot: comparison src/share/vm/c1/c1

-:c40600e85311
+:f02a8bbe6ed4
 // get the continuation point from the BlockList instead of
 // fabricating it anew because Invokes would be considered to be
 // BlockEnds.
 BlockBegin*  _continuation;
-// Without return value of inlined method on stack
-ValueStack*  _continuation_state;
 // Was this ScopeData created only for the parsing and inlining of
 // a jsr?
 bool         _parsing_jsr;
 // We track the destination bci of the jsr only to determine
 // bailout conditions, since we only handle a subset of all of the
 ciBytecodeStream* stream()                     { return _stream;            }
 void set_stream(ciBytecodeStream* stream)      { _stream = stream;          }
 intx max_inline_size() const                   { return _max_inline_size;   }
-int  caller_stack_size() const;
 BlockBegin* continuation() const               { return _continuation;      }
 void set_continuation(BlockBegin* cont)        { _continuation = cont;      }
-ValueStack* continuation_state() const         { return _continuation_state; }
-void set_continuation_state(ValueStack* s)     { _continuation_state = s; }
 // Indicates whether this ScopeData was pushed only for the
 // parsing and inlining of a jsr
 bool parsing_jsr() const                       { return _parsing_jsr;       }
 void set_parsing_jsr()                         { _parsing_jsr = true;       }
 ValueStack*  inline_cleanup_state() const      { return _cleanup_state; }
 };
 // for all GraphBuilders
 static bool       _can_trap[Bytecodes::number_of_java_codes];
-static bool       _is_async[Bytecodes::number_of_java_codes];
 // for each instance of GraphBuilder
 ScopeData*        _scope_data;                 // Per-scope data; used for inlining
 Compilation*      _compilation;                // the current compilation
 ValueMap*         _vmap;                       // the map of values encountered (for CSE)
 ValueStack*       _initial_state;              // The state for the start block
 // for each call to connect_to_end; can also be set by inliner
 BlockBegin*       _block;                      // the current block
 ValueStack*       _state;                      // the current execution state
-ValueStack*       _exception_state;            // state that will be used by handle_exception
 Instruction*      _last;                       // the last instruction added
 bool              _skip_block;                 // skip processing of the rest of this block
 // accessors
 ScopeData*        scope_data() const           { return _scope_data; }
 BlockBegin*       block() const                { return _block; }
 ValueStack*       state() const                { return _state; }
 void              set_state(ValueStack* state) { _state = state; }
 IRScope*          scope() const                { return scope_data()->scope(); }
-ValueStack*       exception_state() const      { return _exception_state; }
-void              set_exception_state(ValueStack* s) { _exception_state = s; }
 ciMethod*         method() const               { return scope()->method(); }
 ciBytecodeStream* stream() const               { return scope_data()->stream(); }
 Instruction*      last() const                 { return _last; }
 Bytecodes::Code   code() const                 { return stream()->cur_bc(); }
 int               bci() const                  { return stream()->cur_bci(); }
 void store_local(ValueType* type, int index);
 void store_local(ValueStack* state, Value value, ValueType* type, int index);
 void load_indexed (BasicType type);
 void store_indexed(BasicType type);
 void stack_op(Bytecodes::Code code);
-void arithmetic_op(ValueType* type, Bytecodes::Code code, ValueStack* lock_stack = NULL);
+void arithmetic_op(ValueType* type, Bytecodes::Code code, ValueStack* state_before = NULL);
 void negate_op(ValueType* type);
 void shift_op(ValueType* type, Bytecodes::Code code);
 void logic_op(ValueType* type, Bytecodes::Code code);
 void compare_op(ValueType* type, Bytecodes::Code code);
 void convert(Bytecodes::Code op, BasicType from, BasicType to);
 Instruction* append_with_bci(Instruction* instr, int bci);
 Instruction* append(Instruction* instr);
 Instruction* append_split(StateSplit* instr);
 // other helpers
-static bool is_async(Bytecodes::Code code) {
-assert(0 <= code && code < Bytecodes::number_of_java_codes, "illegal bytecode");
-return _is_async[code];
-}
 BlockBegin* block_at(int bci)                  { return scope_data()->block_at(bci); }
-XHandlers* handle_exception(int bci);
+XHandlers* handle_exception(Instruction* instruction);
 void connect_to_end(BlockBegin* beg);
 void null_check(Value value);
 void eliminate_redundant_phis(BlockBegin* start);
 BlockEnd* iterate_bytecodes_for_block(int bci);
 void iterate_all_blocks(bool start_in_current_block_for_inlining = false);
 Dependencies* dependency_recorder() const; // = compilation()->dependencies()
 bool direct_compare(ciKlass* k);
 void kill_all();
-ValueStack* lock_stack();
+// use of state copy routines (try to minimize unnecessary state
+// object allocations):
+// - if the instruction unconditionally needs a full copy of the
+// state (for patching for example), then use copy_state_before*
+// - if the instruction needs a full copy of the state only for
+// handler generation (Instruction::needs_exception_state() returns
+// false) then use copy_state_exhandling*
+// - if the instruction needs either a full copy of the state for
+// handler generation and a least a minimal copy of the state (as
+// returned by Instruction::exception_state()) for debug info
+// generation (that is when Instruction::needs_exception_state()
+// returns true) then use copy_state_for_exception*
+ValueStack* copy_state_before_with_bci(int bci);
+ValueStack* copy_state_before();
+ValueStack* copy_state_exhandling_with_bci(int bci);
+ValueStack* copy_state_exhandling();
+ValueStack* copy_state_for_exception_with_bci(int bci);
+ValueStack* copy_state_for_exception();
 //
 // Inlining support
 //
 // accessors
 bool parsing_jsr() const                               { return scope_data()->parsing_jsr();           }
 BlockBegin* continuation() const                       { return scope_data()->continuation();          }
-ValueStack* continuation_state() const                 { return scope_data()->continuation_state();    }
 BlockBegin* jsr_continuation() const                   { return scope_data()->jsr_continuation();      }
-int caller_stack_size() const                          { return scope_data()->caller_stack_size();     }
 void set_continuation(BlockBegin* continuation)        { scope_data()->set_continuation(continuation); }
 void set_inline_cleanup_info(BlockBegin* block,
 Instruction* return_prev,
 ValueStack* return_state) { scope_data()->set_inline_cleanup_info(block,
 return_prev,

comparison: src/share/vm/c1/c1_GraphBuilder.hpp

src/share/vm/c1/c1_GraphBuilder.hpp

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/c1/c1_GraphBuilder.hpp

src/share/vm/c1/c1_GraphBuilder.hpp