< prev index next >

src/hotspot/share/opto/runtime.cpp

Print this page




  33 #include "code/pcDesc.hpp"
  34 #include "code/scopeDesc.hpp"
  35 #include "code/vtableStubs.hpp"
  36 #include "compiler/compileBroker.hpp"
  37 #include "compiler/oopMap.hpp"
  38 #include "gc/g1/heapRegion.hpp"
  39 #include "gc/shared/barrierSet.hpp"
  40 #include "gc/shared/collectedHeap.hpp"
  41 #include "gc/shared/gcLocker.hpp"
  42 #include "interpreter/bytecode.hpp"
  43 #include "interpreter/interpreter.hpp"
  44 #include "interpreter/linkResolver.hpp"
  45 #include "logging/log.hpp"
  46 #include "logging/logStream.hpp"
  47 #include "memory/oopFactory.hpp"
  48 #include "memory/resourceArea.hpp"
  49 #include "oops/objArrayKlass.hpp"
  50 #include "oops/oop.inline.hpp"
  51 #include "oops/typeArrayOop.inline.hpp"
  52 #include "oops/valueArrayKlass.hpp"

  53 #include "opto/ad.hpp"
  54 #include "opto/addnode.hpp"
  55 #include "opto/callnode.hpp"
  56 #include "opto/cfgnode.hpp"
  57 #include "opto/graphKit.hpp"
  58 #include "opto/machnode.hpp"
  59 #include "opto/matcher.hpp"
  60 #include "opto/memnode.hpp"
  61 #include "opto/mulnode.hpp"
  62 #include "opto/runtime.hpp"
  63 #include "opto/subnode.hpp"
  64 #include "runtime/atomic.hpp"
  65 #include "runtime/frame.inline.hpp"
  66 #include "runtime/handles.inline.hpp"
  67 #include "runtime/interfaceSupport.inline.hpp"
  68 #include "runtime/javaCalls.hpp"
  69 #include "runtime/sharedRuntime.hpp"
  70 #include "runtime/signature.hpp"
  71 #include "runtime/threadCritical.hpp"
  72 #include "runtime/vframe.hpp"


1699   // We don't know the number of returned values and their
1700   // types. Assume all registers available to the return convention
1701   // are used.
1702   fields[TypeFunc::Parms] = TypeRawPtr::BOTTOM;
1703   fields[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM;
1704   uint i = 2;
1705   for (; i < SharedRuntime::java_return_convention_max_int+1; i++) {
1706     fields[TypeFunc::Parms+i] = TypeInt::INT;
1707   }
1708   for (; i < total; i+=2) {
1709     fields[TypeFunc::Parms+i] = Type::DOUBLE;
1710     fields[TypeFunc::Parms+i+1] = Type::HALF;
1711   }
1712   const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms + total, fields);
1713 
1714   // create result type (range)
1715   fields = TypeTuple::fields(1);
1716   fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL;
1717 
1718   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1,fields);


































































1719 
1720   return TypeFunc::make(domain, range);
1721 }


  33 #include "code/pcDesc.hpp"
  34 #include "code/scopeDesc.hpp"
  35 #include "code/vtableStubs.hpp"
  36 #include "compiler/compileBroker.hpp"
  37 #include "compiler/oopMap.hpp"
  38 #include "gc/g1/heapRegion.hpp"
  39 #include "gc/shared/barrierSet.hpp"
  40 #include "gc/shared/collectedHeap.hpp"
  41 #include "gc/shared/gcLocker.hpp"
  42 #include "interpreter/bytecode.hpp"
  43 #include "interpreter/interpreter.hpp"
  44 #include "interpreter/linkResolver.hpp"
  45 #include "logging/log.hpp"
  46 #include "logging/logStream.hpp"
  47 #include "memory/oopFactory.hpp"
  48 #include "memory/resourceArea.hpp"
  49 #include "oops/objArrayKlass.hpp"
  50 #include "oops/oop.inline.hpp"
  51 #include "oops/typeArrayOop.inline.hpp"
  52 #include "oops/valueArrayKlass.hpp"
  53 #include "oops/valueArrayOop.inline.hpp"
  54 #include "opto/ad.hpp"
  55 #include "opto/addnode.hpp"
  56 #include "opto/callnode.hpp"
  57 #include "opto/cfgnode.hpp"
  58 #include "opto/graphKit.hpp"
  59 #include "opto/machnode.hpp"
  60 #include "opto/matcher.hpp"
  61 #include "opto/memnode.hpp"
  62 #include "opto/mulnode.hpp"
  63 #include "opto/runtime.hpp"
  64 #include "opto/subnode.hpp"
  65 #include "runtime/atomic.hpp"
  66 #include "runtime/frame.inline.hpp"
  67 #include "runtime/handles.inline.hpp"
  68 #include "runtime/interfaceSupport.inline.hpp"
  69 #include "runtime/javaCalls.hpp"
  70 #include "runtime/sharedRuntime.hpp"
  71 #include "runtime/signature.hpp"
  72 #include "runtime/threadCritical.hpp"
  73 #include "runtime/vframe.hpp"


1700   // We don't know the number of returned values and their
1701   // types. Assume all registers available to the return convention
1702   // are used.
1703   fields[TypeFunc::Parms] = TypeRawPtr::BOTTOM;
1704   fields[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM;
1705   uint i = 2;
1706   for (; i < SharedRuntime::java_return_convention_max_int+1; i++) {
1707     fields[TypeFunc::Parms+i] = TypeInt::INT;
1708   }
1709   for (; i < total; i+=2) {
1710     fields[TypeFunc::Parms+i] = Type::DOUBLE;
1711     fields[TypeFunc::Parms+i+1] = Type::HALF;
1712   }
1713   const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms + total, fields);
1714 
1715   // create result type (range)
1716   fields = TypeTuple::fields(1);
1717   fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL;
1718 
1719   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1,fields);
1720 
1721   return TypeFunc::make(domain, range);
1722 }
1723 
1724 JRT_LEAF(void, OptoRuntime::load_unknown_value(valueArrayOopDesc* array, int index, instanceOopDesc* buffer))
1725 {
1726   Klass* klass = array->klass();
1727   assert(klass->is_valueArray_klass(), "expected value array oop");
1728 
1729   ValueArrayKlass* vaklass = ValueArrayKlass::cast(klass);
1730   ValueKlass* vklass = vaklass->element_klass();
1731   void* src = array->value_at_addr(index, vaklass->layout_helper());
1732   vklass->value_store(src, vklass->data_for_oop(buffer),
1733                         vaklass->element_byte_size(), true, false);
1734 }
1735 JRT_END
1736 
1737 const TypeFunc *OptoRuntime::load_unknown_value_Type() {
1738   // create input type (domain)
1739   const Type **fields = TypeTuple::fields(3);
1740   // We don't know the number of returned values and their
1741   // types. Assume all registers available to the return convention
1742   // are used.
1743   fields[TypeFunc::Parms] = TypeOopPtr::NOTNULL;
1744   fields[TypeFunc::Parms+1] = TypeInt::POS;
1745   fields[TypeFunc::Parms+2] = TypeInstPtr::NOTNULL;
1746 
1747   const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+3, fields);
1748 
1749   // create result type (range)
1750   fields = TypeTuple::fields(0);
1751   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
1752 
1753   return TypeFunc::make(domain, range);
1754 }
1755 
1756 JRT_LEAF(void, OptoRuntime::store_unknown_value(instanceOopDesc* buffer, valueArrayOopDesc* array, int index))
1757 {
1758   assert(buffer != NULL, "can't store null into flat array");
1759   Klass* klass = array->klass();
1760   assert(klass->is_valueArray_klass(), "expected value array");
1761   assert(ArrayKlass::cast(klass)->element_klass() == buffer->klass(), "Store type incorrect");
1762 
1763   ValueArrayKlass* vaklass = ValueArrayKlass::cast(klass);
1764   ValueKlass* vklass = vaklass->element_klass();
1765   const int lh = vaklass->layout_helper();
1766   vklass->value_store(vklass->data_for_oop(buffer), array->value_at_addr(index, lh),
1767                       vaklass->element_byte_size(), true, false);
1768 }
1769 JRT_END
1770 
1771 const TypeFunc *OptoRuntime::store_unknown_value_Type() {
1772   // create input type (domain)
1773   const Type **fields = TypeTuple::fields(3);
1774   // We don't know the number of returned values and their
1775   // types. Assume all registers available to the return convention
1776   // are used.
1777   fields[TypeFunc::Parms] = TypeInstPtr::NOTNULL;
1778   fields[TypeFunc::Parms+1] = TypeOopPtr::NOTNULL;
1779   fields[TypeFunc::Parms+2] = TypeInt::POS;
1780 
1781   const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+3, fields);
1782 
1783   // create result type (range)
1784   fields = TypeTuple::fields(0);
1785   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
1786 
1787   return TypeFunc::make(domain, range);
1788 }
< prev index next >