1 /*
   2  * Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_RUNTIME_STACKVALUE_HPP
  26 #define SHARE_RUNTIME_STACKVALUE_HPP
  27 
  28 #include "code/location.hpp"
  29 #include "runtime/handles.hpp"
  30 
  31 class BasicLock;
  32 class RegisterMap;
  33 class ScopeValue;
  34 
  35 class StackValue : public ResourceObj {
  36  private:
  37   BasicType _type;
  38   intptr_t  _integer_value; // Blank java stack slot value
  39   Handle    _handle_value;  // Java stack slot value interpreted as a Handle
  40  public:
  41 
  42   StackValue(intptr_t value) {
  43     _type              = T_INT;
  44     _integer_value     = value;
  45   }
  46 
  47   StackValue(Handle value, intptr_t scalar_replaced = 0) {
  48     _type                = T_OBJECT;
  49     _integer_value       = scalar_replaced;
  50     _handle_value        = value;
  51     assert(_integer_value == 0 ||  _handle_value.is_null(), "not null object should not be marked as scalar replaced");
  52   }
  53 
  54   StackValue() {
  55     _type           = T_CONFLICT;
  56     _integer_value  = 0;
  57   }
  58 
  59   // Only used during deopt- preserve object type.
  60   StackValue(intptr_t o, BasicType t) {
  61     assert(t == T_OBJECT, "should not be used");
  62     _type          = t;
  63     _integer_value = o;
  64   }
  65 
  66   Handle get_obj() const {
  67     assert(type() == T_OBJECT, "type check");
  68     return _handle_value;
  69   }
  70 
  71   bool obj_is_scalar_replaced() const {
  72     assert(type() == T_OBJECT, "type check");
  73     return _integer_value != 0;
  74   }
  75 
  76   void set_obj(Handle value) {
  77     assert(type() == T_OBJECT, "type check");
  78     _integer_value = 0;
  79     _handle_value = value;
  80   }
  81 
  82   intptr_t get_int() const {
  83     assert(type() == T_INT, "type check");
  84     return _integer_value;
  85   }
  86 
  87   // For special case in deopt.
  88   intptr_t get_int(BasicType t) const {
  89     assert(t == T_OBJECT && type() == T_OBJECT, "type check");
  90     return _integer_value;
  91   }
  92 
  93   void set_int(intptr_t value) {
  94     assert(type() == T_INT, "type check");
  95     _integer_value = value;
  96   }
  97 
  98   BasicType type() const { return  _type; }
  99 
 100   bool equal(StackValue *value) {
 101     if (_type != value->_type) return false;
 102     if (_type == T_OBJECT)
 103       return (_handle_value == value->_handle_value);
 104     else {
 105       assert(_type == T_INT, "sanity check");
 106       // [phh] compare only low addressed portions of intptr_t slots
 107       return (*(int *)&_integer_value == *(int *)&value->_integer_value);
 108     }
 109   }
 110 
 111   static StackValue* create_stack_value(const frame* fr, const RegisterMap* reg_map, ScopeValue* sv);
 112   static BasicLock*  resolve_monitor_lock(const frame* fr, Location location);
 113 
 114 #ifndef PRODUCT
 115  public:
 116   // Printing
 117   void print_on(outputStream* st) const;
 118 #endif
 119 };
 120 
 121 #endif // SHARE_RUNTIME_STACKVALUE_HPP