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

comparison src/share/vm/opto/compile.hpp @ 14422:2b8e28fdf503

Merge

author	kvn
date	Tue, 05 Nov 2013 17:38:04 -0800
parents	b2ee5dc63353
children	94a83e0f9ce1

comparison

equal deleted inserted replaced

-:3068270ba476
+:2b8e28fdf503
 class relocInfo;
 class Scope;
 class StartNode;
 class SafePointNode;
 class JVMState;
+class Type;
 class TypeData;
 class TypePtr;
 class TypeOopPtr;
 class TypeFunc;
 class Unique_Node_List;
 friend class Compile;
 int             _index;         // unique index, used with MergeMemNode
 const TypePtr*  _adr_type;      // normalized address type
 ciField*        _field;         // relevant instance field, or null if none
+const Type*     _element;       // relevant array element type, or null if none
 bool            _is_rewritable; // false if the memory is write-once only
 int             _general_index; // if this is type is an instance, the general
 // type that this is an instance of
 void Init(int i, const TypePtr* at);
 public:
 int             index()         const { return _index; }
 const TypePtr*  adr_type()      const { return _adr_type; }
 ciField*        field()         const { return _field; }
+const Type*     element()       const { return _element; }
 bool            is_rewritable() const { return _is_rewritable; }
 bool            is_volatile()   const { return (_field ? _field->is_volatile() : false); }
 int             general_index() const { return (_general_index != 0) ? _general_index : _index; }
 void set_rewritable(bool z) { _is_rewritable = z; }
 void set_field(ciField* f) {
 assert(!_field,"");
 _field = f;
-if (f->is_final())  _is_rewritable = false;
+if (f->is_final() || f->is_stable()) {
+// In the case of @Stable, multiple writes are possible but may be assumed to be no-ops.
+_is_rewritable = false;
+}
+}
+void set_element(const Type* e) {
+assert(_element == NULL, "");
+_element = e;
 }
 void print_on(outputStream* st) PRODUCT_RETURN;
 };
 bool                  _do_freq_based_layout;  // True if we intend to do frequency based block layout
 bool                  _do_count_invocations;  // True if we generate code to count invocations
 bool                  _do_method_data_update; // True if we generate code to update MethodData*s
 int                   _AliasLevel;            // Locally-adjusted version of AliasLevel flag.
 bool                  _print_assembly;        // True if we should dump assembly code for this compilation
+bool                  _print_inlining;        // True if we should print inlining for this compilation
+bool                  _print_intrinsics;      // True if we should print intrinsics for this compilation
 #ifndef PRODUCT
 bool                  _trace_opto_output;
 bool                  _parsed_irreducible_loop; // True if ciTypeFlow detected irreducible loops during parsing
 #endif
 CallGenerator* cg() const { return _cg; }
 void set_cg(CallGenerator* cg) { _cg = cg; }
 };
 GrowableArray<PrintInliningBuffer>* _print_inlining_list;
-int _print_inlining;
+int _print_inlining_idx;
 // Only keep nodes in the expensive node list that need to be optimized
 void cleanup_expensive_nodes(PhaseIterGVN &igvn);
 // Use for sorting expensive nodes to bring similar nodes together
 static int cmp_expensive_nodes(Node** n1, Node** n2);
 // Expensive nodes list already sorted?
 bool expensive_nodes_sorted() const;
+// Remove the speculative part of types and clean up the graph
+void remove_speculative_types(PhaseIterGVN &igvn);
+// Are we within a PreserveJVMState block?
+int _preserve_jvm_state;
 public:
 outputStream* print_inlining_stream() const {
-return _print_inlining_list->at(_print_inlining).ss();
+return _print_inlining_list->adr_at(_print_inlining_idx)->ss();
 }
 void print_inlining_skip(CallGenerator* cg) {
-if (PrintInlining) {
+if (_print_inlining) {
-_print_inlining_list->at(_print_inlining).set_cg(cg);
+_print_inlining_list->adr_at(_print_inlining_idx)->set_cg(cg);
-_print_inlining++;
+_print_inlining_idx++;
-_print_inlining_list->insert_before(_print_inlining, PrintInliningBuffer());
+_print_inlining_list->insert_before(_print_inlining_idx, PrintInliningBuffer());
 }
 }
 void print_inlining_insert(CallGenerator* cg) {
-if (PrintInlining) {
+if (_print_inlining) {
 for (int i = 0; i < _print_inlining_list->length(); i++) {
-if (_print_inlining_list->at(i).cg() == cg) {
+if (_print_inlining_list->adr_at(i)->cg() == cg) {
 _print_inlining_list->insert_before(i+1, PrintInliningBuffer());
-_print_inlining = i+1;
+_print_inlining_idx = i+1;
-_print_inlining_list->at(i).set_cg(NULL);
+_print_inlining_list->adr_at(i)->set_cg(NULL);
 return;
 }
 }
 ShouldNotReachHere();
 }
 bool              do_method_data_update() const { return _do_method_data_update; }
 void          set_do_method_data_update(bool z) { _do_method_data_update = z; }
 int               AliasLevel() const          { return _AliasLevel; }
 bool              print_assembly() const       { return _print_assembly; }
 void          set_print_assembly(bool z)       { _print_assembly = z; }
+bool              print_inlining() const       { return _print_inlining; }
+void          set_print_inlining(bool z)       { _print_inlining = z; }
+bool              print_intrinsics() const     { return _print_intrinsics; }
+void          set_print_intrinsics(bool z)     { _print_intrinsics = z; }
 // check the CompilerOracle for special behaviours for this compile
 bool          method_has_option(const char * option) {
 return method() != NULL && method()->has_option(option);
 }
 #ifndef PRODUCT
 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_does_dispatch, JVMState* jvms, bool allow_inline, float profile_factor, bool allow_intrinsics = true, bool delayed_forbidden = false);
+CallGenerator*    call_generator(ciMethod* call_method, int vtable_index, bool call_does_dispatch,
+JVMState* jvms, bool allow_inline, float profile_factor, ciKlass* speculative_receiver_type = NULL,
+bool allow_intrinsics = true, bool delayed_forbidden = false);
 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);
 // Definitions of pd methods
 static void pd_compiler2_init();
 // Auxiliary method for randomized fuzzing/stressing
 static bool randomized_select(int count);
+// enter a PreserveJVMState block
+void inc_preserve_jvm_state() {
+_preserve_jvm_state++;
+}
+// exit a PreserveJVMState block
+void dec_preserve_jvm_state() {
+_preserve_jvm_state--;
+assert(_preserve_jvm_state >= 0, "_preserve_jvm_state shouldn't be negative");
+}
+bool has_preserve_jvm_state() const {
+return _preserve_jvm_state > 0;
+}
 };
 #endif // SHARE_VM_OPTO_COMPILE_HPP

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/opto/compile.hpp @ 14422:2b8e28fdf503