jdk-sandbox: comparison hotspot/src/share/vm/c1/c1

equal deleted inserted replaced

-:ef9996662fd5
+:bbe0fcde6e13
 void set_type(ValueType* type) {
 assert(type != NULL, "type must exist");
 _type = type;
 }
+// Helper class to keep track of which arguments need a null check
+class ArgsNonNullState {
+private:
+int _nonnull_state; // mask identifying which args are nonnull
+public:
+ArgsNonNullState()
+: _nonnull_state(AllBits) {}
+// Does argument number i needs a null check?
+bool arg_needs_null_check(int i) const {
+// No data is kept for arguments starting at position 33 so
+// conservatively assume that they need a null check.
+if (i >= 0 && i < (int)sizeof(_nonnull_state) * BitsPerByte) {
+return is_set_nth_bit(_nonnull_state, i);
+}
+return true;
+}
+// Set whether argument number i needs a null check or not
+void set_arg_needs_null_check(int i, bool check) {
+if (i >= 0 && i < (int)sizeof(_nonnull_state) * BitsPerByte) {
+if (check) {
+_nonnull_state |= nth_bit(i);
+} else {
+_nonnull_state &= ~(nth_bit(i));
+}
+}
+}
+};
 public:
 void* operator new(size_t size) throw() {
 Compilation* c = Compilation::current();
 void* res = c->arena()->Amalloc(size);
 ((Instruction*)res)->_id = c->get_next_id();
 virtual void input_values_do(ValueVisitor* f)   = 0;
 virtual void state_values_do(ValueVisitor* f);
 virtual void other_values_do(ValueVisitor* f)   { /* usually no other - override on demand */ }
 void       values_do(ValueVisitor* f)   { input_values_do(f); state_values_do(f); other_values_do(f); }
-virtual ciType* exact_type() const             { return NULL; }
+virtual ciType* exact_type() const;
 virtual ciType* declared_type() const          { return NULL; }
 // hashing
 virtual const char* name() const               = 0;
 HASHING1(Instruction, false, id())             // hashing disabled by default
 // accessors
 int java_index() const                         { return _java_index; }
 virtual ciType* declared_type() const          { return _declared_type; }
-virtual ciType* exact_type() const;
 // generic
 virtual void input_values_do(ValueVisitor* f)   { /* no values */ }
 };
 ValueStack* state_before, bool needs_patching)
 : AccessField(obj, offset, field, is_static, state_before, needs_patching)
 {}
 ciType* declared_type() const;
-ciType* exact_type() const;
 // generic
 HASHING2(LoadField, !needs_patching() && !field()->is_volatile(), obj()->subst(), offset())  // cannot be eliminated if needs patching or if volatile
 };
 // accessors
 Value length() const                           { return _length; }
 virtual bool needs_exception_state() const     { return false; }
+ciType* exact_type() const                     { return NULL; }
 ciType* declared_type() const;
 // generic
 virtual bool can_trap() const                  { return true; }
 virtual void input_values_do(ValueVisitor* f)   { StateSplit::input_values_do(f); f->visit(&_length); }
 bool is_incompatible_class_change_check() const {
 return check_flag(ThrowIncompatibleClassChangeErrorFlag);
 }
 ciType* declared_type() const;
-ciType* exact_type() const;
 };
 LEAF(InstanceOf, TypeCheck)
 public:
 LEAF(Intrinsic, StateSplit)
 private:
 vmIntrinsics::ID _id;
 Values*          _args;
 Value            _recv;
-int              _nonnull_state; // mask identifying which args are nonnull
+ArgsNonNullState _nonnull_state;
 public:
 // preserves_state can be set to true for Intrinsics
 // which are guaranteed to preserve register state across any slow
 // cases; setting it to true does not mean that the Intrinsic can
 bool cantrap = true)
 : StateSplit(type, state_before)
 , _id(id)
 , _args(args)
 , _recv(NULL)
-, _nonnull_state(AllBits)
 {
 assert(args != NULL, "args must exist");
 ASSERT_VALUES
 set_flag(PreservesStateFlag, preserves_state);
 set_flag(CanTrapFlag,        cantrap);
 bool has_receiver() const                      { return (_recv != NULL); }
 Value receiver() const                         { assert(has_receiver(), "must have receiver"); return _recv; }
 bool preserves_state() const                   { return check_flag(PreservesStateFlag); }
-bool arg_needs_null_check(int i) {
+bool arg_needs_null_check(int i) const {
-if (i >= 0 && i < (int)sizeof(_nonnull_state) * BitsPerByte) {
+return _nonnull_state.arg_needs_null_check(i);
-return is_set_nth_bit(_nonnull_state, i);
-}
-return true;
 }
 void set_arg_needs_null_check(int i, bool check) {
-if (i >= 0 && i < (int)sizeof(_nonnull_state) * BitsPerByte) {
+_nonnull_state.set_arg_needs_null_check(i, check);
-if (check) {
-_nonnull_state |= nth_bit(i);
-} else {
-_nonnull_state &= ~(nth_bit(i));
-}
-}
 }
 // generic
 virtual bool can_trap() const                  { return check_flag(CanTrapFlag); }
 virtual void input_values_do(ValueVisitor* f) {
 }
 };
 LEAF(ProfileCall, Instruction)
 private:
-ciMethod* _method;
+ciMethod*        _method;
-int       _bci_of_invoke;
+int              _bci_of_invoke;
-ciMethod* _callee;         // the method that is called at the given bci
+ciMethod*        _callee;         // the method that is called at the given bci
-Value     _recv;
+Value            _recv;
-ciKlass*  _known_holder;
+ciKlass*         _known_holder;
+Values*          _obj_args;       // arguments for type profiling
-public:
+ArgsNonNullState _nonnull_state;  // Do we know whether some arguments are never null?
-ProfileCall(ciMethod* method, int bci, ciMethod* callee, Value recv, ciKlass* known_holder)
+bool             _inlined;        // Are we profiling a call that is inlined
+public:
+ProfileCall(ciMethod* method, int bci, ciMethod* callee, Value recv, ciKlass* known_holder, Values* obj_args, bool inlined)
 : Instruction(voidType)
 , _method(method)
 , _bci_of_invoke(bci)
 , _callee(callee)
 , _recv(recv)
 , _known_holder(known_holder)
+, _obj_args(obj_args)
+, _inlined(inlined)
 {
 // The ProfileCall has side-effects and must occur precisely where located
 pin();
 }
-ciMethod* method()      { return _method; }
+ciMethod* method()             const { return _method; }
-int bci_of_invoke()     { return _bci_of_invoke; }
+int bci_of_invoke()            const { return _bci_of_invoke; }
-ciMethod* callee()      { return _callee; }
+ciMethod* callee()             const { return _callee; }
-Value recv()            { return _recv; }
+Value recv()                   const { return _recv; }
-ciKlass* known_holder() { return _known_holder; }
+ciKlass* known_holder()        const { return _known_holder; }
+int nb_profiled_args()         const { return _obj_args == NULL ? 0 : _obj_args->length(); }
-virtual void input_values_do(ValueVisitor* f)   { if (_recv != NULL) f->visit(&_recv); }
+Value profiled_arg_at(int i)   const { return _obj_args->at(i); }
-};
+bool arg_needs_null_check(int i) const {
+return _nonnull_state.arg_needs_null_check(i);
+}
+bool inlined()                 const { return _inlined; }
+void set_arg_needs_null_check(int i, bool check) {
+_nonnull_state.set_arg_needs_null_check(i, check);
+}
+virtual void input_values_do(ValueVisitor* f)   {
+if (_recv != NULL) {
+f->visit(&_recv);
+}
+for (int i = 0; i < nb_profiled_args(); i++) {
+f->visit(_obj_args->adr_at(i));
+}
+}
+};
 // Call some C runtime function that doesn't safepoint,
 // optionally passing the current thread as the first argument.
 LEAF(RuntimeCall, Instruction)
 private:

changeset 20702	bbe0fcde6e13
parent 19696	bd5a0131bde1
child 20709	034be898bf04