graal-compiler: src/share/vm/oops/methodData.hpp comparison

comparison src/share/vm/oops/methodData.hpp @ 18041:52b4284cb496

Merge with jdk8u20-b26

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Wed, 15 Oct 2014 16:02:50 +0200
parents	e165f4223650 ce9fd31ffd14
children	94faadc823ea

comparison

equal deleted inserted replaced

-:45d7b2c7029d
+:52b4284cb496
 branch_data_tag,
 multi_branch_data_tag,
 arg_info_data_tag,
 call_type_data_tag,
 virtual_call_type_data_tag,
-parameters_type_data_tag
+parameters_type_data_tag,
+speculative_trap_data_tag
 };
 enum {
 // The _struct._flags word is formatted as [trap_state:4 | flags:4].
 // The trap state breaks down further as [recompile:1 | reason:3].
 }
 void set_header(intptr_t value) {
 _header._bits = value;
 }
-void release_set_header(intptr_t value) {
-OrderAccess::release_store_ptr(&_header._bits, value);
-}
 intptr_t header() {
 return _header._bits;
 }
 void set_cell_at(int index, intptr_t value) {
 _cells[index] = value;
 return byte_offset_of(DataLayout, _header._struct._bci);
 }
 static ByteSize cell_offset(int index) {
 return byte_offset_of(DataLayout, _cells) + in_ByteSize(index * cell_size);
 }
+#ifdef CC_INTERP
+static int cell_offset_in_bytes(int index) {
+return (int)offset_of(DataLayout, _cells[index]);
+}
+#endif // CC_INTERP
 // Return a value which, when or-ed as a byte into _flags, sets the flag.
 static int flag_number_to_byte_constant(int flag_number) {
 assert(0 <= flag_number && flag_number < flag_limit, "oob");
 DataLayout temp; temp.set_header(0);
 temp.set_flag_at(flag_number);
 class     BranchData;
 class   ArrayData;
 class     MultiBranchData;
 class     ArgInfoData;
 class     ParametersTypeData;
+class   SpeculativeTrapData;
 // ProfileData
 //
 // A ProfileData object is created to refer to a section of profiling
 // data in a structured way.
 #endif // !PRODUCT
 // This is a pointer to a section of profiling data.
 DataLayout* _data;
+char* print_data_on_helper(const MethodData* md) const;
 protected:
 DataLayout* data() { return _data; }
 const DataLayout* data() const { return _data; }
 enum {
 }
 ProfileData(DataLayout* data) {
 _data = data;
 }
+#ifdef CC_INTERP
+// Static low level accessors for DataLayout with ProfileData's semantics.
+static int cell_offset_in_bytes(int index) {
+return DataLayout::cell_offset_in_bytes(index);
+}
+static void increment_uint_at_no_overflow(DataLayout* layout, int index,
+int inc = DataLayout::counter_increment) {
+uint count = ((uint)layout->cell_at(index)) + inc;
+if (count == 0) return;
+layout->set_cell_at(index, (intptr_t) count);
+}
+static int int_at(DataLayout* layout, int index) {
+return (int)layout->cell_at(index);
+}
+static int uint_at(DataLayout* layout, int index) {
+return (uint)layout->cell_at(index);
+}
+static oop oop_at(DataLayout* layout, int index) {
+return cast_to_oop(layout->cell_at(index));
+}
+static void set_intptr_at(DataLayout* layout, int index, intptr_t value) {
+layout->set_cell_at(index, (intptr_t) value);
+}
+static void set_flag_at(DataLayout* layout, int flag_number) {
+layout->set_flag_at(flag_number);
+}
+#endif // CC_INTERP
 public:
 // Constructor for invalid ProfileData.
 ProfileData();
 virtual bool is_MultiBranchData() const { return false; }
 virtual bool is_ArgInfoData()     const { return false; }
 virtual bool is_CallTypeData()    const { return false; }
 virtual bool is_VirtualCallTypeData()const { return false; }
 virtual bool is_ParametersTypeData() const { return false; }
+virtual bool is_SpeculativeTrapData()const { return false; }
 BitData* as_BitData() const {
 assert(is_BitData(), "wrong type");
 return is_BitData()         ? (BitData*)        this : NULL;
 return is_VirtualCallTypeData() ? (VirtualCallTypeData*)this : NULL;
 }
 ParametersTypeData* as_ParametersTypeData() const {
 assert(is_ParametersTypeData(), "wrong type");
 return is_ParametersTypeData() ? (ParametersTypeData*)this : NULL;
+}
+SpeculativeTrapData* as_SpeculativeTrapData() const {
+assert(is_SpeculativeTrapData(), "wrong type");
+return is_SpeculativeTrapData() ? (SpeculativeTrapData*)this : NULL;
 }
 // Subclass specific initialization
 virtual void post_initialize(BytecodeStream* stream, MethodData* mdo) {}
 // an oop in a ProfileData to the ci equivalent. Generally speaking,
 // most ProfileData don't require any translation, so we provide the null
 // translation here, and the required translators are in the ci subclasses.
 virtual void translate_from(const ProfileData* data) {}
-virtual void print_data_on(outputStream* st) const {
+virtual void print_data_on(outputStream* st, const char* extra = NULL) const {
 ShouldNotReachHere();
 }
+void print_data_on(outputStream* st, const MethodData* md) const;
 #ifndef PRODUCT
-void print_shared(outputStream* st, const char* name) const;
+void print_shared(outputStream* st, const char* name, const char* extra) const;
 void tab(outputStream* st, bool first = false) const;
 #endif
 };
 // BitData
 static ByteSize bit_data_size() {
 return cell_offset(bit_cell_count);
 }
+#ifdef CC_INTERP
+static int bit_data_size_in_bytes() {
+return cell_offset_in_bytes(bit_cell_count);
+}
+static void set_null_seen(DataLayout* layout) {
+set_flag_at(layout, null_seen_flag);
+}
+static DataLayout* advance(DataLayout* layout) {
+return (DataLayout*) (((address)layout) + (ssize_t)BitData::bit_data_size_in_bytes());
+}
+#endif // CC_INTERP
 #ifndef PRODUCT
-void print_data_on(outputStream* st) const;
+void print_data_on(outputStream* st, const char* extra = NULL) const;
 #endif
 };
 // CounterData
 //
 void set_count(uint count) {
 set_uint_at(count_off, count);
 }
+#ifdef CC_INTERP
+static int counter_data_size_in_bytes() {
+return cell_offset_in_bytes(counter_cell_count);
+}
+static void increment_count_no_overflow(DataLayout* layout) {
+increment_uint_at_no_overflow(layout, count_off);
+}
+// Support counter decrementation at checkcast / subtype check failed.
+static void decrement_count(DataLayout* layout) {
+increment_uint_at_no_overflow(layout, count_off, -1);
+}
+static DataLayout* advance(DataLayout* layout) {
+return (DataLayout*) (((address)layout) + (ssize_t)CounterData::counter_data_size_in_bytes());
+}
+#endif // CC_INTERP
 #ifndef PRODUCT
-void print_data_on(outputStream* st) const;
+void print_data_on(outputStream* st, const char* extra = NULL) const;
 #endif
 };
 // JumpData
 //
 static ByteSize displacement_offset() {
 return cell_offset(displacement_off_set);
 }
+#ifdef CC_INTERP
+static void increment_taken_count_no_overflow(DataLayout* layout) {
+increment_uint_at_no_overflow(layout, taken_off_set);
+}
+static DataLayout* advance_taken(DataLayout* layout) {
+return (DataLayout*) (((address)layout) + (ssize_t)int_at(layout, displacement_off_set));
+}
+static uint taken_count(DataLayout* layout) {
+return (uint) uint_at(layout, taken_off_set);
+}
+#endif // CC_INTERP
 // Specific initialization.
 void post_initialize(BytecodeStream* stream, MethodData* mdo);
 #ifndef PRODUCT
-void print_data_on(outputStream* st) const;
+void print_data_on(outputStream* st, const char* extra = NULL) const;
 #endif
 };
 // Entries in a ProfileData object to record types: it can either be
 // none (no profile), unknown (conflicting profile data) or a klass if
 }
 static ByteSize argument_type_offset(int i) {
 return in_ByteSize(argument_type_local_offset(i) * DataLayout::cell_size);
 }
+static ByteSize return_only_size() {
+return ReturnTypeEntry::size() + in_ByteSize(header_cell_count() * DataLayout::cell_size);
+}
 };
 // CallTypeData
 //
 // A CallTypeData is used to access profiling information about a non
 _ret.clean_weak_klass_links(is_alive_closure);
 }
 }
 #ifndef PRODUCT
-virtual void print_data_on(outputStream* st) const;
+virtual void print_data_on(outputStream* st, const char* extra = NULL) const;
 #endif
 };
 // ReceiverTypeData
 //
 }
 // GC support
 virtual void clean_weak_klass_links(BoolObjectClosure* is_alive_closure);
+#ifdef CC_INTERP
+static int receiver_type_data_size_in_bytes() {
+return cell_offset_in_bytes(static_cell_count());
+}
+static Klass *receiver_unchecked(DataLayout* layout, uint row) {
+Klass* recv = (Klass*)layout->cell_at(receiver_cell_index(row));
+return recv;
+}
+static void increment_receiver_count_no_overflow(DataLayout* layout, Klass *rcvr) {
+const int num_rows = row_limit();
+// Receiver already exists?
+for (int row = 0; row < num_rows; row++) {
+if (receiver_unchecked(layout, row) == rcvr) {
+increment_uint_at_no_overflow(layout, receiver_count_cell_index(row));
+return;
+}
+}
+// New receiver, find a free slot.
+for (int row = 0; row < num_rows; row++) {
+if (receiver_unchecked(layout, row) == NULL) {
+set_intptr_at(layout, receiver_cell_index(row), (intptr_t)rcvr);
+increment_uint_at_no_overflow(layout, receiver_count_cell_index(row));
+return;
+}
+}
+// Receiver did not match any saved receiver and there is no empty row for it.
+// Increment total counter to indicate polymorphic case.
+increment_count_no_overflow(layout);
+}
+static DataLayout* advance(DataLayout* layout) {
+return (DataLayout*) (((address)layout) + (ssize_t)ReceiverTypeData::receiver_type_data_size_in_bytes());
+}
+#endif // CC_INTERP
 #ifndef PRODUCT
 void print_receiver_data_on(outputStream* st) const;
-void print_data_on(outputStream* st) const;
+void print_data_on(outputStream* st, const char* extra = NULL) const;
 #endif
 };
 // VirtualCallData
 //
 // Direct accessors
 static ByteSize virtual_call_data_size() {
 return cell_offset(static_cell_count());
 }
+#ifdef CC_INTERP
+static int virtual_call_data_size_in_bytes() {
+return cell_offset_in_bytes(static_cell_count());
+}
+static DataLayout* advance(DataLayout* layout) {
+return (DataLayout*) (((address)layout) + (ssize_t)VirtualCallData::virtual_call_data_size_in_bytes());
+}
+#endif // CC_INTERP
 #ifdef GRAAL
 static ByteSize method_offset(uint row) {
 return cell_offset(method_cell_index(row));
 }
 static ByteSize method_count_offset(uint row) {
 #ifndef PRODUCT
 #ifdef GRAAL
 void print_method_data_on(outputStream* st) const;
 #endif
-void print_data_on(outputStream* st) const;
+void print_data_on(outputStream* st, const char* extra = NULL) const;
 #endif
 };
 // VirtualCallTypeData
 //
 _ret.clean_weak_klass_links(is_alive_closure);
 }
 }
 #ifndef PRODUCT
-virtual void print_data_on(outputStream* st) const;
+virtual void print_data_on(outputStream* st, const char* extra = NULL) const;
 #endif
 };
 // RetData
 //
 }
 static ByteSize bci_displacement_offset(uint row) {
 return cell_offset(bci_displacement_cell_index(row));
 }
+#ifdef CC_INTERP
+static DataLayout* advance(MethodData *md, int bci);
+#endif // CC_INTERP
 // Specific initialization.
 void post_initialize(BytecodeStream* stream, MethodData* mdo);
 #ifndef PRODUCT
-void print_data_on(outputStream* st) const;
+void print_data_on(outputStream* st, const char* extra = NULL) const;
 #endif
 };
 // BranchData
 //
 }
 static ByteSize branch_data_size() {
 return cell_offset(branch_cell_count);
 }
+#ifdef CC_INTERP
+static int branch_data_size_in_bytes() {
+return cell_offset_in_bytes(branch_cell_count);
+}
+static void increment_not_taken_count_no_overflow(DataLayout* layout) {
+increment_uint_at_no_overflow(layout, not_taken_off_set);
+}
+static DataLayout* advance_not_taken(DataLayout* layout) {
+return (DataLayout*) (((address)layout) + (ssize_t)BranchData::branch_data_size_in_bytes());
+}
+#endif // CC_INTERP
 // Specific initialization.
 void post_initialize(BytecodeStream* stream, MethodData* mdo);
 #ifndef PRODUCT
-void print_data_on(outputStream* st) const;
+void print_data_on(outputStream* st, const char* extra = NULL) const;
 #endif
 };
 // ArrayData
 //
 }
 void array_set_int_at(int index, int value) {
 int aindex = index + array_start_off_set;
 set_int_at(aindex, value);
 }
+#ifdef CC_INTERP
+// Static low level accessors for DataLayout with ArrayData's semantics.
+static void increment_array_uint_at_no_overflow(DataLayout* layout, int index) {
+int aindex = index + array_start_off_set;
+increment_uint_at_no_overflow(layout, aindex);
+}
+static int array_int_at(DataLayout* layout, int index) {
+int aindex = index + array_start_off_set;
+return int_at(layout, aindex);
+}
+#endif // CC_INTERP
 // Code generation support for subclasses.
 static ByteSize array_element_offset(int index) {
 return cell_offset(array_start_off_set + index);
 }
 }
 static ByteSize relative_displacement_offset() {
 return in_ByteSize(relative_displacement_off_set) * cell_size;
 }
+#ifdef CC_INTERP
+static void increment_count_no_overflow(DataLayout* layout, int index) {
+if (index == -1) {
+increment_array_uint_at_no_overflow(layout, default_count_off_set);
+} else {
+increment_array_uint_at_no_overflow(layout, case_array_start +
+index * per_case_cell_count +
+relative_count_off_set);
+}
+}
+static DataLayout* advance(DataLayout* layout, int index) {
+if (index == -1) {
+return (DataLayout*) (((address)layout) + (ssize_t)array_int_at(layout, default_disaplacement_off_set));
+} else {
+return (DataLayout*) (((address)layout) + (ssize_t)array_int_at(layout, case_array_start +
+index * per_case_cell_count +
+relative_displacement_off_set));
+}
+}
+#endif // CC_INTERP
 // Specific initialization.
 void post_initialize(BytecodeStream* stream, MethodData* mdo);
 #ifndef PRODUCT
-void print_data_on(outputStream* st) const;
+void print_data_on(outputStream* st, const char* extra = NULL) const;
 #endif
 };
 class ArgInfoData : public ArrayData {
 void set_arg_modified(int arg, uint val) {
 array_set_int_at(arg, val);
 }
 #ifndef PRODUCT
-void print_data_on(outputStream* st) const;
+void print_data_on(outputStream* st, const char* extra = NULL) const;
 #endif
 };
 // ParametersTypeData
 //
 virtual void clean_weak_klass_links(BoolObjectClosure* is_alive_closure) {
 _parameters.clean_weak_klass_links(is_alive_closure);
 }
 #ifndef PRODUCT
-virtual void print_data_on(outputStream* st) const;
+virtual void print_data_on(outputStream* st, const char* extra = NULL) const;
 #endif
 static ByteSize stack_slot_offset(int i) {
 return cell_offset(stack_slot_local_offset(i));
 }
 static ByteSize type_offset(int i) {
 return cell_offset(type_local_offset(i));
 }
+};
+// SpeculativeTrapData
+//
+// A SpeculativeTrapData is used to record traps due to type
+// speculation. It records the root of the compilation: that type
+// speculation is wrong in the context of one compilation (for
+// method1) doesn't mean it's wrong in the context of another one (for
+// method2). Type speculation could have more/different data in the
+// context of the compilation of method2 and it's worthwhile to try an
+// optimization that failed for compilation of method1 in the context
+// of compilation of method2.
+// Space for SpeculativeTrapData entries is allocated from the extra
+// data space in the MDO. If we run out of space, the trap data for
+// the ProfileData at that bci is updated.
+class SpeculativeTrapData : public ProfileData {
+protected:
+enum {
+method_offset,
+speculative_trap_cell_count
+};
+public:
+SpeculativeTrapData(DataLayout* layout) : ProfileData(layout) {
+assert(layout->tag() == DataLayout::speculative_trap_data_tag, "wrong type");
+}
+virtual bool is_SpeculativeTrapData() const { return true; }
+static int static_cell_count() {
+return speculative_trap_cell_count;
+}
+virtual int cell_count() const {
+return static_cell_count();
+}
+// Direct accessor
+Method* method() const {
+return (Method*)intptr_at(method_offset);
+}
+void set_method(Method* m) {
+set_intptr_at(method_offset, (intptr_t)m);
+}
+#ifndef PRODUCT
+virtual void print_data_on(outputStream* st, const char* extra = NULL) const;
+#endif
 };
 // MethodData*
 //
 // A MethodData* holds information which has been collected about
 // from the base of the data entry array.  A "displacement" is the byte offset
 // in certain ProfileData objects that indicate the amount the mdp must be
 // adjusted in the event of a change in control flow.
 //
+CC_INTERP_ONLY(class BytecodeInterpreter;)
 class MethodData : public Metadata {
 friend class VMStructs;
+CC_INTERP_ONLY(friend class BytecodeInterpreter;)
 private:
 friend class ProfileData;
 // Back pointer to the Method*
 Method* _method;
 // Size of this oop in bytes
 int _size;
 // Cached hint for bci_to_dp and bci_to_data
 int _hint_di;
+Mutex _extra_data_lock;
 MethodData(methodHandle method, int size, TRAPS);
 public:
 static MethodData* allocate(ClassLoaderData* loader_data, methodHandle method, TRAPS);
-MethodData() {}; // For ciMethodData
+MethodData() : _extra_data_lock(Monitor::leaf, "MDO extra data lock") {}; // For ciMethodData
 bool is_methodData() const volatile { return true; }
 void initialize(bool for_reprofile = false);
 // Whole-method sticky bits and flags
 enum {
-#ifdef GRAAL
+_trap_hist_limit    = 19 GRAAL_ONLY(+2),   // decoupled from Deoptimization::Reason_LIMIT
-_trap_hist_limit    = 19,   // decoupled from Deoptimization::Reason_LIMIT
-#else
-_trap_hist_limit    = 17,   // decoupled from Deoptimization::Reason_LIMIT
-#endif
 _trap_hist_mask     = max_jubyte,
 _extra_data_count   = 4     // extra DataLayout headers, for trap history
 }; // Public flag values
 private:
 uint _nof_decompiles;             // count of all nmethod removals
 // Same for backedges.
 InvocationCounter _backedge_counter;
 // Counter values at the time profiling started.
 int               _invocation_counter_start;
 int               _backedge_counter_start;
+#if INCLUDE_RTM_OPT
+// State of RTM code generation during compilation of the method
+int               _rtm_state;
+#endif
 // Number of loops and blocks is computed when compiling the first
 // time with C1. It is used to determine if method is trivial.
 short             _num_loops;
 short             _num_blocks;
 // Highest compile level this method has ever seen.
 intptr_t _data[1];
 // Helper for size computation
 static int compute_data_size(BytecodeStream* stream);
 static int bytecode_cell_count(Bytecodes::Code code);
+static bool is_speculative_trap_bytecode(Bytecodes::Code code);
 enum { no_profile_data = -1, variable_cell_count = -2 };
 // Helper for initialization
 DataLayout* data_layout_at(int data_index) const {
 assert(data_index % sizeof(intptr_t) == 0, "unaligned");
 }
 // What is the index of the first data entry?
 int first_di() const { return 0; }
+ProfileData* bci_to_extra_data_helper(int bci, Method* m, DataLayout*& dp, bool concurrent);
 // Find or create an extra ProfileData:
-ProfileData* bci_to_extra_data(int bci, bool create_if_missing);
+ProfileData* bci_to_extra_data(int bci, Method* m, bool create_if_missing);
 // return the argument info cell
 ArgInfoData *arg_info();
 enum {
 type_profile_all = 2
 };
 static bool profile_jsr292(methodHandle m, int bci);
 static int profile_arguments_flag();
-static bool profile_arguments_jsr292_only();
 static bool profile_all_arguments();
 static bool profile_arguments_for_invoke(methodHandle m, int bci);
 static int profile_return_flag();
 static bool profile_all_return();
 static bool profile_return_for_invoke(methodHandle m, int bci);
 static int profile_parameters_flag();
 static bool profile_parameters_jsr292_only();
 static bool profile_all_parameters();
+void clean_extra_data(BoolObjectClosure* is_alive);
+void clean_extra_data_helper(DataLayout* dp, int shift, bool reset = false);
+void verify_extra_data_clean(BoolObjectClosure* is_alive);
 public:
 static int header_size() {
 return sizeof(MethodData)/wordSize;
 }
 // Compute the size of a MethodData* before it is created.
 static int compute_allocation_size_in_bytes(methodHandle method);
 static int compute_allocation_size_in_words(methodHandle method);
-static int compute_extra_data_count(int data_size, int empty_bc_count);
+static int compute_extra_data_count(int data_size, int empty_bc_count, bool needs_speculative_traps);
 // Determine if a given bytecode can have profile information.
 static bool bytecode_has_profile(Bytecodes::Code code) {
 return bytecode_cell_count(code) != no_profile_data;
 }
 _backedge_counter_start = backedge_count();
 }
 InvocationCounter* invocation_counter()     { return &_invocation_counter; }
 InvocationCounter* backedge_counter()       { return &_backedge_counter;   }
+#if INCLUDE_RTM_OPT
+int rtm_state() const {
+return _rtm_state;
+}
+void set_rtm_state(RTMState rstate) {
+_rtm_state = (int)rstate;
+}
+void atomic_set_rtm_state(RTMState rstate) {
+Atomic::store((int)rstate, &_rtm_state);
+}
+static int rtm_state_offset_in_bytes() {
+return offset_of(MethodData, _rtm_state);
+}
+#endif
 void set_would_profile(bool p)              { _would_profile = p;    }
 bool would_profile() const                  { return _would_profile; }
 int highest_comp_level() const              { return _highest_comp_level;      }
 // Get the data at an arbitrary bci, or NULL if there is none.
 ProfileData* bci_to_data(int bci);
 // Same, but try to create an extra_data record if one is needed:
-ProfileData* allocate_bci_to_data(int bci) {
+ProfileData* allocate_bci_to_data(int bci, Method* m) {
-ProfileData* data = bci_to_data(bci);
+ProfileData* data = NULL;
-return (data != NULL) ? data : bci_to_extra_data(bci, true);
+// If m not NULL, try to allocate a SpeculativeTrapData entry
+if (m == NULL) {
+data = bci_to_data(bci);
+}
+if (data != NULL) {
+return data;
+}
+data = bci_to_extra_data(bci, m, true);
+if (data != NULL) {
+return data;
+}
+// If SpeculativeTrapData allocation fails try to allocate a
+// regular entry
+data = bci_to_data(bci);
+if (data != NULL) {
+return data;
+}
+return bci_to_extra_data(bci, NULL, true);
 }
 // Add a handful of extra data records, for trap tracking.
 DataLayout* extra_data_base() const { return limit_data_position(); }
 DataLayout* extra_data_limit() const { return (DataLayout*)((address)this + size_in_bytes()); }
 int extra_data_size() const { return (address)extra_data_limit()
 - (address)extra_data_base(); }
-static DataLayout* next_extra(DataLayout* dp) { return (DataLayout*)((address)dp + in_bytes(DataLayout::cell_offset(0))); }
+static DataLayout* next_extra(DataLayout* dp);
 // Return (uint)-1 for overflow.
 uint trap_count(int reason) const {
 assert((uint)reason < GRAAL_ONLY(2*) _trap_hist_limit, "oob");
 return (int)((_trap_hist._array[reason]+1) & _trap_hist_mask) - 1;
 void verify_on(outputStream* st);
 void verify_data_on(outputStream* st);
 static bool profile_parameters_for_method(methodHandle m);
 static bool profile_arguments();
+static bool profile_arguments_jsr292_only();
 static bool profile_return();
 static bool profile_parameters();
 static bool profile_return_jsr292_only();
+void clean_method_data(BoolObjectClosure* is_alive);
 void clean_weak_method_links();
 };
 #endif // SHARE_VM_OOPS_METHODDATAOOP_HPP

Mercurial > hg > graal-compiler

comparison src/share/vm/oops/methodData.hpp @ 18041:52b4284cb496