truffle: src/share/vm/opto/compile.hpp comparison

comparison src/share/vm/opto/compile.hpp @ 10408:836a62f43af9

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Wed, 19 Jun 2013 10:45:56 +0200
parents	f2110083203d
children	edb5ab0f3fe5

comparison

equal deleted inserted replaced

-:e0fb8a213650
+:836a62f43af9
 /*
-* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2013, 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.
 #include "libadt/dict.hpp"
 #include "libadt/port.hpp"
 #include "libadt/vectset.hpp"
 #include "memory/resourceArea.hpp"
 #include "opto/idealGraphPrinter.hpp"
+#include "opto/phasetype.hpp"
 #include "opto/phase.hpp"
 #include "opto/regmask.hpp"
 #include "runtime/deoptimization.hpp"
 #include "runtime/vmThread.hpp"
+#include "trace/tracing.hpp"
 class Block;
 class Bundle;
 class C2Compiler;
 class CallGenerator;
 // Fixed parameters to this compilation.
 const int             _compile_id;
 const bool            _save_argument_registers; // save/restore arg regs for trampolines
 const bool            _subsume_loads;         // Load can be matched as part of a larger op.
 const bool            _do_escape_analysis;    // Do escape analysis.
+const bool            _eliminate_boxing;      // Do boxing elimination.
 ciMethod*             _method;                // The method being compiled.
 int                   _entry_bci;             // entry bci for osr methods.
 const TypeFunc*       _tf;                    // My kind of signature
 InlineTree*           _ilt;                   // Ditto (temporary).
 address               _stub_function;         // VM entry for stub being compiled, or NULL
 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
+bool                  _has_boxed_value;       // True if a boxed object is allocated
 int                   _max_vector_size;       // Maximum size of generated vectors
 uint                  _trap_hist[trapHistLength];  // Cumulative traps
 bool                  _trap_can_recompile;    // Have we emitted a recompiling trap?
 uint                  _decompile_count;       // Cumulative decompilation counts.
 bool                  _do_inlining;           // True if we intend to do inlining
 ConnectionGraph*      _congraph;
 #ifndef PRODUCT
 IdealGraphPrinter*    _printer;
 #endif
 // Node management
 uint                  _unique;                // Counter for unique Node indices
 VectorSet             _dead_node_list;        // Set of dead nodes
 uint                  _dead_node_count;       // Number of dead nodes; VectorSet::Size() is O(N).
 // So use this to keep count and make the call O(1).
 WarmCallInfo*         _warm_calls;            // Sorted work-list for heat-based inlining.
 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
+GrowableArray<CallGenerator*> _boxing_late_inlines; // same but for boxing 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
 // Does this compilation allow instructions to subsume loads?  User
 // instructions that subsume a load may result in an unschedulable
 // instruction sequence.
 bool              subsume_loads() const       { return _subsume_loads; }
-// Do escape analysis.
+/** Do escape analysis. */
 bool              do_escape_analysis() const  { return _do_escape_analysis; }
+/** Do boxing elimination. */
+bool              eliminate_boxing() const    { return _eliminate_boxing; }
+/** Do aggressive boxing elimination. */
+bool              aggressive_unboxing() const { return _eliminate_boxing && AggressiveUnboxing; }
 bool              save_argument_registers() const { return _save_argument_registers; }
 // Other fixed compilation parameters.
 ciMethod*         method() const              { return _method; }
 void          set_has_split_ifs(bool z)       { _has_split_ifs = z; }
 bool              has_unsafe_access() const   { return _has_unsafe_access; }
 void          set_has_unsafe_access(bool z)   { _has_unsafe_access = z; }
 bool              has_stringbuilder() const   { return _has_stringbuilder; }
 void          set_has_stringbuilder(bool z)   { _has_stringbuilder = z; }
+bool              has_boxed_value() const     { return _has_boxed_value; }
+void          set_has_boxed_value(bool z)     { _has_boxed_value = z; }
 int               max_vector_size() const     { return _max_vector_size; }
 void          set_max_vector_size(int s)      { _max_vector_size = s; }
 void          set_trap_count(uint r, uint c)  { assert(r < trapHistLength, "oob");        _trap_hist[r] = c; }
 uint              trap_count(uint r) const    { assert(r < trapHistLength, "oob"); return _trap_hist[r]; }
 bool              trap_can_recompile() const  { return _trap_can_recompile; }
 // JSR 292
 bool              has_method_handle_invokes() const { return _has_method_handle_invokes;     }
 void          set_has_method_handle_invokes(bool z) {        _has_method_handle_invokes = z; }
+jlong _latest_stage_start_counter;
 void begin_method() {
 #ifndef PRODUCT
 if (_printer) _printer->begin_method(this);
 #endif
-}
+C->_latest_stage_start_counter = os::elapsed_counter();
-void print_method(const char * name, int level = 1) {
+}
+void print_method(CompilerPhaseType cpt, int level = 1) {
+EventCompilerPhase event(UNTIMED);
+if (event.should_commit()) {
+event.set_starttime(C->_latest_stage_start_counter);
+event.set_endtime(os::elapsed_counter());
+event.set_phase((u1) cpt);
+event.set_compileID(C->_compile_id);
+event.set_phaseLevel(level);
+event.commit();
+}
 #ifndef PRODUCT
-if (_printer) _printer->print_method(this, name, level);
+if (_printer) _printer->print_method(this, CompilerPhaseTypeHelper::to_string(cpt), level);
 #endif
-}
+C->_latest_stage_start_counter = os::elapsed_counter();
-void end_method() {
+}
+void end_method(int level = 1) {
+EventCompilerPhase event(UNTIMED);
+if (event.should_commit()) {
+event.set_starttime(C->_latest_stage_start_counter);
+event.set_endtime(os::elapsed_counter());
+event.set_phase((u1) PHASE_END);
+event.set_compileID(C->_compile_id);
+event.set_phaseLevel(level);
+event.commit();
+}
 #ifndef PRODUCT
 if (_printer) _printer->end_method();
 #endif
 }
-int           macro_count()                   { return _macro_nodes->length(); }
+int           macro_count()             const { return _macro_nodes->length(); }
-int           predicate_count()               { return _predicate_opaqs->length();}
+int           predicate_count()         const { return _predicate_opaqs->length();}
-int           expensive_count()               { return _expensive_nodes->length(); }
+int           expensive_count()         const { return _expensive_nodes->length(); }
-Node*         macro_node(int idx)             { return _macro_nodes->at(idx); }
+Node*         macro_node(int idx)       const { return _macro_nodes->at(idx); }
-Node*         predicate_opaque1_node(int idx) { return _predicate_opaqs->at(idx);}
+Node*         predicate_opaque1_node(int idx) const { return _predicate_opaqs->at(idx);}
-Node*         expensive_node(int idx)         { return _expensive_nodes->at(idx); }
+Node*         expensive_node(int idx)   const { return _expensive_nodes->at(idx); }
 ConnectionGraph* congraph()                   { return _congraph;}
 void set_congraph(ConnectionGraph* congraph)  { _congraph = congraph;}
 void add_macro_node(Node * n) {
 //assert(n->is_macro(), "must be a macro node");
 assert(!_macro_nodes->contains(n), " duplicate entry in expand list");
 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_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);
+bool should_delay_inlining(ciMethod* call_method, JVMState* jvms) {
+return should_delay_string_inlining(call_method, jvms) ||
+should_delay_boxing_inlining(call_method, jvms);
+}
+bool should_delay_string_inlining(ciMethod* call_method, JVMState* jvms);
+bool should_delay_boxing_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,
 void              add_string_late_inline(CallGenerator* cg) {
 _string_late_inlines.push(cg);
 }
+void              add_boxing_late_inline(CallGenerator* cg) {
+_boxing_late_inlines.push(cg);
+}
 void remove_useless_late_inlines(GrowableArray<CallGenerator*>* inlines, Unique_Node_List &useful);
 void dump_inlining();
 bool over_inlining_cutoff() const {
 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);
+void inline_boxing_calls(PhaseIterGVN& igvn);
 // 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; }
 // Major entry point.  Given a Scope, compile the associated method.
 // For normal compilations, entry_bci is InvocationEntryBci.  For on stack
 // replacement, entry_bci indicates the bytecode for which to compile a
 // continuation.
 Compile(ciEnv* ci_env, C2Compiler* compiler, ciMethod* target,
-int entry_bci, bool subsume_loads, bool do_escape_analysis);
+int entry_bci, bool subsume_loads, bool do_escape_analysis,
+bool eliminate_boxing);
 // Second major entry point.  From the TypeFunc signature, generate code
 // to pass arguments from the Java calling convention to the C calling
 // convention.
 Compile(ciEnv* ci_env, const TypeFunc *(*gen)(),

Mercurial > hg > truffle

comparison src/share/vm/opto/compile.hpp @ 10408:836a62f43af9