jdk-sandbox: comparison src/hotspot/share/opto/compile.hpp

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 class Bundle;
 class C2Compiler;
 class CallGenerator;
 class CloneMap;
 class ConnectionGraph;
+class IdealGraphPrinter;
 class InlineTree;
 class Int_Array;
-class LoadBarrierNode;
 class Matcher;
 class MachConstantNode;
 class MachConstantBaseNode;
 class MachNode;
 class MachOper;
 LoopOptsDefault,
 LoopOptsNone,
 LoopOptsShenandoahExpand,
 LoopOptsShenandoahPostExpand,
 LoopOptsSkipSplitIf,
-LoopOptsVerify,
+LoopOptsVerify
-LoopOptsLastRound
 };
 typedef unsigned int node_idx_t;
 class NodeCloneInfo {
 private:
 bool                  _has_irreducible_loop;  // Found irreducible loops
 // JSR 292
 bool                  _has_method_handle_invokes; // True if this method has MethodHandle invokes.
 RTMState              _rtm_state;             // State of Restricted Transactional Memory usage
 int                   _loop_opts_cnt;         // loop opts round
+bool                  _clinit_barrier_on_entry; // True if clinit barrier is needed on nmethod entry
 // Compilation environment.
 Arena                 _comp_arena;            // Arena with lifetime equivalent to Compile
 void*                 _barrier_set_state;     // Potential GC barrier state for Compile
 ciEnv*                _env;                   // CI interface
 // Type management
 Arena                 _Compile_types;         // Arena for all types
 Arena*                _type_arena;            // Alias for _Compile_types except in Initialize_shared()
 Dict*                 _type_dict;             // Intern table
 CloneMap              _clone_map;             // used for recording history of cloned nodes
-void*                 _type_hwm;              // Last allocation (see Type::operator new/delete)
 size_t                _type_last_size;        // Last allocation size (see Type::operator new/delete)
 ciMethod*             _last_tf_m;             // Cache for
 const TypeFunc*       _last_tf;               //  TypeFunc::make
 AliasType**           _alias_types;           // List of alias types seen so far.
 int                   _num_alias_types;       // Logical length of _alias_types
 void          set_inlining_incrementally(bool z) { _inlining_incrementally = z; }
 int               inlining_incrementally() const { return _inlining_incrementally; }
 void          set_do_cleanup(bool z)          { _do_cleanup = z; }
 int               do_cleanup() const          { return _do_cleanup; }
 void          set_major_progress()            { _major_progress++; }
+void          restore_major_progress(int progress) { _major_progress += progress; }
 void        clear_major_progress()            { _major_progress = 0; }
 int               max_inline_size() const     { return _max_inline_size; }
 void          set_freq_inline_size(int n)     { _freq_inline_size = n; }
 int               freq_inline_size() const    { return _freq_inline_size; }
 void          set_max_inline_size(int n)      { _max_inline_size = n; }
 void          set_rtm_state(RTMState s)        { _rtm_state = s; }
 bool              use_rtm() const              { return (_rtm_state & NoRTM) == 0; }
 bool          profile_rtm() const              { return _rtm_state == ProfileRTM; }
 uint              max_node_limit() const       { return (uint)_max_node_limit; }
 void          set_max_node_limit(uint n)       { _max_node_limit = n; }
+bool              clinit_barrier_on_entry()       { return _clinit_barrier_on_entry; }
+void          set_clinit_barrier_on_entry(bool z) { _clinit_barrier_on_entry = z; }
 // check the CompilerOracle for special behaviours for this compile
 bool          method_has_option(const char * option) {
 return method() != NULL && method()->has_option(option);
 }
 }
 #endif
 C->_latest_stage_start_counter.stamp();
 }
-void print_method(CompilerPhaseType cpt, int level = 1) {
+bool should_print(int level = 1) {
+#ifndef PRODUCT
+return (_printer && _printer->should_print(level));
+#else
+return false;
+#endif
+}
+void print_method(CompilerPhaseType cpt, int level = 1, int idx = 0) {
 EventCompilerPhase event;
 if (event.should_commit()) {
 event.set_starttime(C->_latest_stage_start_counter);
 event.set_phase((u1) cpt);
 event.set_compileId(C->_compile_id);
 event.set_phaseLevel(level);
 event.commit();
 }
 #ifndef PRODUCT
-if (_printer && _printer->should_print(level)) {
+if (should_print(level)) {
-_printer->print_method(CompilerPhaseTypeHelper::to_string(cpt), level);
+char output[1024];
+if (idx != 0) {
+sprintf(output, "%s:%d", CompilerPhaseTypeHelper::to_string(cpt), idx);
+} else {
+sprintf(output, "%s", CompilerPhaseTypeHelper::to_string(cpt));
+}
+_printer->print_method(output, level);
 }
 #endif
 C->_latest_stage_start_counter.stamp();
 }
 void grow_node_notes(GrowableArray<Node_Notes*>* arr, int grow_by);
 // Type management
 Arena*            type_arena()                { return _type_arena; }
 Dict*             type_dict()                 { return _type_dict; }
-void*             type_hwm()                  { return _type_hwm; }
 size_t            type_last_size()            { return _type_last_size; }
 int               num_alias_types()           { return _num_alias_types; }
 void          init_type_arena()                       { _type_arena = &_Compile_types; }
 void          set_type_arena(Arena* a)                { _type_arena = a; }
 void          set_type_dict(Dict* d)                  { _type_dict = d; }
-void          set_type_hwm(void* p)                   { _type_hwm = p; }
 void          set_type_last_size(size_t sz)           { _type_last_size = sz; }
 const TypeFunc* last_tf(ciMethod* m) {
 return (m == _last_tf_m) ? _last_tf : NULL;
 }
 uint              scratch_emit_size(const Node* n);
 void       set_in_scratch_emit_size(bool x)   {        _in_scratch_emit_size = x; }
 bool           in_scratch_emit_size() const   { return _in_scratch_emit_size;     }
 enum ScratchBufferBlob {
-#if defined(PPC64)
 MAX_inst_size       = 2048,
-#else
-MAX_inst_size       = 1024,
-#endif
 MAX_locs_size       = 128, // number of relocInfo elements
 MAX_const_size      = 128,
 MAX_stubs_size      = 128
 };
 ObjectValue* sv );
 // Process an OopMap Element while emitting nodes
 void Process_OopMap_Node(MachNode *mach, int code_offset);
+class BufferSizingData {
+public:
+int _stub;
+int _code;
+int _const;
+int _reloc;
+BufferSizingData() :
+_stub(0),
+_code(0),
+_const(0),
+_reloc(0)
+{ };
+};
 // Initialize code buffer
-CodeBuffer* init_buffer(uint* blk_starts);
+void        estimate_buffer_size(int& const_req);
+CodeBuffer* init_buffer(BufferSizingData& buf_sizes);
 // Write out basic block data to code buffer
 void fill_buffer(CodeBuffer* cb, uint* blk_starts);
 // Determine which variable sized branches can be shortened
-void shorten_branches(uint* blk_starts, int& code_size, int& reloc_size, int& stub_size);
+void shorten_branches(uint* blk_starts, BufferSizingData& buf_sizes);
 // Compute the size of first NumberOfLoopInstrToAlign instructions
 // at the head of a loop.
 void compute_loop_first_inst_sizes();
 // supporting clone_map
 CloneMap&     clone_map();
 void          set_clone_map(Dict* d);
-bool is_compiling_clinit_for(ciKlass* k);
+bool needs_clinit_barrier(ciField* ik,         ciMethod* accessing_method);
+bool needs_clinit_barrier(ciMethod* ik,        ciMethod* accessing_method);
+bool needs_clinit_barrier(ciInstanceKlass* ik, ciMethod* accessing_method);
 };
 #endif // SHARE_OPTO_COMPILE_HPP

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 54960	e46fe26d7f77
child 58679	9c3209ff7550