graal-compiler: src/share/vm/opto/compile.hpp comparison

comparison src/share/vm/opto/compile.hpp @ 7482:989155e2d07a

Merge with hs25-b15.

author	Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date	Wed, 16 Jan 2013 01:34:24 +0100
parents	5698813d45eb
children	8b3da8d14c93

comparison

equal deleted inserted replaced

-:6761a8f854a4
+:989155e2d07a
 #include "asm/codeBuffer.hpp"
 #include "ci/compilerInterface.hpp"
 #include "code/debugInfoRec.hpp"
 #include "code/exceptionHandlerTable.hpp"
 #include "compiler/compilerOracle.hpp"
+#include "compiler/compileBroker.hpp"
 #include "libadt/dict.hpp"
 #include "libadt/port.hpp"
 #include "libadt/vectset.hpp"
 #include "memory/resourceArea.hpp"
 #include "opto/idealGraphPrinter.hpp"
 class StartNode;
 class SafePointNode;
 class JVMState;
 class TypeData;
 class TypePtr;
+class TypeOopPtr;
 class TypeFunc;
 class Unique_Node_List;
 class nmethod;
 class WarmCallInfo;
 class Node_Stack;
 // For deopt
 int                   _orig_pc_slot;
 int                   _orig_pc_slot_offset_in_bytes;
 int                   _major_progress;        // Count of something big happening
+bool                  _inlining_progress;     // progress doing incremental inlining?
+bool                  _inlining_incrementally;// Are we doing incremental inlining (post parse)
 bool                  _has_loops;             // True if the method _may_ have some loops
 bool                  _has_split_ifs;         // True if the method _may_ have some split-if
 bool                  _has_unsafe_access;     // True if the method _may_ produce faults in unsafe loads or stores.
 bool                  _has_stringbuilder;     // True StringBuffers or StringBuilders are allocated
 int                   _max_vector_size;       // Maximum size of generated vectors
 // Parsing, optimization
 PhaseGVN*             _initial_gvn;           // Results of parse-time PhaseGVN
 Unique_Node_List*     _for_igvn;              // Initial work-list for next round of Iterative GVN
 WarmCallInfo*         _warm_calls;            // Sorted work-list for heat-based inlining.
-GrowableArray<CallGenerator*> _late_inlines;  // List of CallGenerators to be revisited after
+GrowableArray<CallGenerator*> _late_inlines;        // List of CallGenerators to be revisited after
 // main parsing has finished.
+GrowableArray<CallGenerator*> _string_late_inlines; // same but for string operations
+int                           _late_inlines_pos;    // Where in the queue should the next late inlining candidate go (emulate depth first inlining)
+uint                          _number_of_mh_late_inlines; // number of method handle late inlining still pending
+// Inlining may not happen in parse order which would make
+// PrintInlining output confusing. Keep track of PrintInlining
+// pieces in order.
+class PrintInliningBuffer : public ResourceObj {
+private:
+CallGenerator* _cg;
+stringStream* _ss;
+public:
+PrintInliningBuffer()
+: _cg(NULL) { _ss = new stringStream(); }
+stringStream* ss() const { return _ss; }
+CallGenerator* cg() const { return _cg; }
+void set_cg(CallGenerator* cg) { _cg = cg; }
+};
+GrowableArray<PrintInliningBuffer>* _print_inlining_list;
+int _print_inlining;
+public:
+outputStream* print_inlining_stream() const {
+return _print_inlining_list->at(_print_inlining).ss();
+}
+void print_inlining_skip(CallGenerator* cg) {
+if (PrintInlining) {
+_print_inlining_list->at(_print_inlining).set_cg(cg);
+_print_inlining++;
+_print_inlining_list->insert_before(_print_inlining, PrintInliningBuffer());
+}
+}
+void print_inlining_insert(CallGenerator* cg) {
+if (PrintInlining) {
+for (int i = 0; i < _print_inlining_list->length(); i++) {
+if (_print_inlining_list->at(i).cg() == cg) {
+_print_inlining_list->insert_before(i+1, PrintInliningBuffer());
+_print_inlining = i+1;
+_print_inlining_list->at(i).set_cg(NULL);
+return;
+}
+}
+ShouldNotReachHere();
+}
+}
+void print_inlining(ciMethod* method, int inline_level, int bci, const char* msg = NULL) {
+stringStream ss;
+CompileTask::print_inlining(&ss, method, inline_level, bci, msg);
+print_inlining_stream()->print(ss.as_string());
+}
+private:
 // Matching, CFG layout, allocation, code generation
 PhaseCFG*             _cfg;                   // Results of CFG finding
 bool                  _select_24_bit_instr;   // We selected an instruction with a 24-bit result
 bool                  _in_24_bit_fp_mode;     // We are emitting instructions with 24-bit results
 int                   _java_calls;            // Number of java calls in the method
 // Control of this compilation.
 int               fixed_slots() const         { assert(_fixed_slots >= 0, "");         return _fixed_slots; }
 void          set_fixed_slots(int n)          { _fixed_slots = n; }
 int               major_progress() const      { return _major_progress; }
+void          set_inlining_progress(bool z)   { _inlining_progress = z; }
+int               inlining_progress() const   { return _inlining_progress; }
+void          set_inlining_incrementally(bool z) { _inlining_incrementally = z; }
+int               inlining_incrementally() const { return _inlining_incrementally; }
 void          set_major_progress()            { _major_progress++; }
 void        clear_major_progress()            { _major_progress = 0; }
 int               num_loop_opts() const       { return _num_loop_opts; }
 void          set_num_loop_opts(int n)        { _num_loop_opts = n; }
 int               max_inline_size() const     { return _max_inline_size; }
 }
 uint         dead_node_count()           { return _dead_node_count; }
 void         reset_dead_node_list()      { _dead_node_list.Reset();
 _dead_node_count = 0;
 }
-uint          live_nodes()               {
+uint          live_nodes() const         {
 int  val = _unique - _dead_node_count;
 assert (val >= 0, err_msg_res("number of tracked dead nodes %d more than created nodes %d", _unique, _dead_node_count));
 return (uint) val;
 }
 #ifdef ASSERT
 void              return_values(JVMState* jvms);
 JVMState*         build_start_state(StartNode* start, const TypeFunc* tf);
 // Decide how to build a call.
 // The profile factor is a discount to apply to this site's interp. profile.
-CallGenerator*    call_generator(ciMethod* call_method, int vtable_index, bool call_is_virtual, JVMState* jvms, bool allow_inline, float profile_factor, bool allow_intrinsics = true);
+CallGenerator*    call_generator(ciMethod* call_method, int vtable_index, bool call_does_dispatch, JVMState* jvms, bool allow_inline, float profile_factor, bool allow_intrinsics = true, bool delayed_forbidden = false);
 bool should_delay_inlining(ciMethod* call_method, JVMState* jvms);
+// Helper functions to identify inlining potential at call-site
+ciMethod* optimize_virtual_call(ciMethod* caller, int bci, ciInstanceKlass* klass,
+ciMethod* callee, const TypeOopPtr* receiver_type,
+bool is_virtual,
+bool &call_does_dispatch, int &vtable_index);
+ciMethod* optimize_inlining(ciMethod* caller, int bci, ciInstanceKlass* klass,
+ciMethod* callee, const TypeOopPtr* receiver_type);
 // Report if there were too many traps at a current method and bci.
 // Report if a trap was recorded, and/or PerMethodTrapLimit was exceeded.
 // If there is no MDO at all, report no trap unless told to assume it.
 bool too_many_traps(ciMethod* method, int bci, Deoptimization::DeoptReason reason);
 void gvn_replace_by(Node* n, Node* nn);
 void              identify_useful_nodes(Unique_Node_List &useful);
 void              update_dead_node_list(Unique_Node_List &useful);
-void              remove_useless_nodes  (Unique_Node_List &useful);
+void              remove_useless_nodes (Unique_Node_List &useful);
 WarmCallInfo*     warm_calls() const          { return _warm_calls; }
 void          set_warm_calls(WarmCallInfo* l) { _warm_calls = l; }
 WarmCallInfo* pop_warm_call();
 // Record this CallGenerator for inlining at the end of parsing.
-void              add_late_inline(CallGenerator* cg) { _late_inlines.push(cg); }
+void              add_late_inline(CallGenerator* cg)        {
+_late_inlines.insert_before(_late_inlines_pos, cg);
+_late_inlines_pos++;
+}
+void              prepend_late_inline(CallGenerator* cg)    {
+_late_inlines.insert_before(0, cg);
+}
+void              add_string_late_inline(CallGenerator* cg) {
+_string_late_inlines.push(cg);
+}
+void remove_useless_late_inlines(GrowableArray<CallGenerator*>* inlines, Unique_Node_List &useful);
+void dump_inlining();
+bool over_inlining_cutoff() const {
+if (!inlining_incrementally()) {
+return unique() > (uint)NodeCountInliningCutoff;
+} else {
+return live_nodes() > (uint)LiveNodeCountInliningCutoff;
+}
+}
+void inc_number_of_mh_late_inlines() { _number_of_mh_late_inlines++; }
+void dec_number_of_mh_late_inlines() { assert(_number_of_mh_late_inlines > 0, "_number_of_mh_late_inlines < 0 !"); _number_of_mh_late_inlines--; }
+bool has_mh_late_inlines() const     { return _number_of_mh_late_inlines > 0; }
+void inline_incrementally_one(PhaseIterGVN& igvn);
+void inline_incrementally(PhaseIterGVN& igvn);
+void inline_string_calls(bool parse_time);
 // Matching, CFG layout, allocation, code generation
 PhaseCFG*         cfg()                       { return _cfg; }
 bool              select_24_bit_instr() const { return _select_24_bit_instr; }
 bool              in_24_bit_fp_mode() const   { return _in_24_bit_fp_mode; }

Mercurial > hg > graal-compiler

comparison src/share/vm/opto/compile.hpp @ 7482:989155e2d07a