259   void monitorexit(Value x, int bci);
 260   void new_multi_array(int dimensions);
 261   void throw_op(int bci);
 262   Value round_fp(Value fp_value);
 263 
 264   // stack/code manipulation helpers
 265   Instruction* append_with_bci(Instruction* instr, int bci);
 266   Instruction* append(Instruction* instr);
 267   Instruction* append_split(StateSplit* instr);
 268 
 269   // other helpers
 270   BlockBegin* block_at(int bci)                  { return scope_data()->block_at(bci); }
 271   XHandlers* handle_exception(Instruction* instruction);
 272   void connect_to_end(BlockBegin* beg);
 273   void null_check(Value value);
 274   void eliminate_redundant_phis(BlockBegin* start);
 275   BlockEnd* iterate_bytecodes_for_block(int bci);
 276   void iterate_all_blocks(bool start_in_current_block_for_inlining = false);
 277   Dependencies* dependency_recorder() const; // = compilation()->dependencies()
 278   bool direct_compare(ciKlass* k);

 279 
 280   void kill_all();
 281 
 282   // use of state copy routines (try to minimize unnecessary state
 283   // object allocations):
 284 
 285   // - if the instruction unconditionally needs a full copy of the
 286   // state (for patching for example), then use copy_state_before*
 287 
 288   // - if the instruction needs a full copy of the state only for
 289   // handler generation (Instruction::needs_exception_state() returns
 290   // false) then use copy_state_exhandling*
 291 
 292   // - if the instruction needs either a full copy of the state for
 293   // handler generation and a least a minimal copy of the state (as
 294   // returned by Instruction::exception_state()) for debug info
 295   // generation (that is when Instruction::needs_exception_state()
 296   // returns true) then use copy_state_for_exception*
 297 
 298   ValueStack* copy_state_before_with_bci(int bci);

 259   void monitorexit(Value x, int bci);
 260   void new_multi_array(int dimensions);
 261   void throw_op(int bci);
 262   Value round_fp(Value fp_value);
 263 
 264   // stack/code manipulation helpers
 265   Instruction* append_with_bci(Instruction* instr, int bci);
 266   Instruction* append(Instruction* instr);
 267   Instruction* append_split(StateSplit* instr);
 268 
 269   // other helpers
 270   BlockBegin* block_at(int bci)                  { return scope_data()->block_at(bci); }
 271   XHandlers* handle_exception(Instruction* instruction);
 272   void connect_to_end(BlockBegin* beg);
 273   void null_check(Value value);
 274   void eliminate_redundant_phis(BlockBegin* start);
 275   BlockEnd* iterate_bytecodes_for_block(int bci);
 276   void iterate_all_blocks(bool start_in_current_block_for_inlining = false);
 277   Dependencies* dependency_recorder() const; // = compilation()->dependencies()
 278   bool direct_compare(ciKlass* k);
 279   Value make_constant(ciConstant value, ciField* field);
 280 
 281   void kill_all();
 282 
 283   // use of state copy routines (try to minimize unnecessary state
 284   // object allocations):
 285 
 286   // - if the instruction unconditionally needs a full copy of the
 287   // state (for patching for example), then use copy_state_before*
 288 
 289   // - if the instruction needs a full copy of the state only for
 290   // handler generation (Instruction::needs_exception_state() returns
 291   // false) then use copy_state_exhandling*
 292 
 293   // - if the instruction needs either a full copy of the state for
 294   // handler generation and a least a minimal copy of the state (as
 295   // returned by Instruction::exception_state()) for debug info
 296   // generation (that is when Instruction::needs_exception_state()
 297   // returns true) then use copy_state_for_exception*
 298 
 299   ValueStack* copy_state_before_with_bci(int bci);