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 }
|