1787 } else {
1788 slow_result = _resproj->clone();
1789 transform_later(slow_result);
1790 _igvn.replace_node(_resproj, result_phi_rawoop);
1791 }
1792
1793 // Plug slow-path into result merge point
1794 result_region ->init_req( slow_result_path, ctrl );
1795 result_phi_rawoop->init_req( slow_result_path, slow_result);
1796 result_phi_rawmem->init_req( slow_result_path, _memproj_fallthrough );
1797 transform_later(result_region);
1798 transform_later(result_phi_rawoop);
1799 transform_later(result_phi_rawmem);
1800 transform_later(result_phi_i_o);
1801 // This completes all paths into the result merge point
1802 }
1803
1804
1805 // Helper for PhaseMacroExpand::expand_allocate_common.
1806 // Initializes the newly-allocated storage.
1807 Node*
1808 PhaseMacroExpand::initialize_object(AllocateNode* alloc,
1809 Node* control, Node* rawmem, Node* object,
1810 Node* klass_node, Node* length,
1811 Node* size_in_bytes) {
1812 InitializeNode* init = alloc->initialization();
1813 // Store the klass & mark bits
1814 Node* mark_node = NULL;
1815 // For now only enable fast locking for non-array types
1816 if (UseBiasedLocking && (length == NULL)) {
1817 mark_node = make_load(control, rawmem, klass_node, in_bytes(Klass::prototype_header_offset()), TypeRawPtr::BOTTOM, T_ADDRESS);
1818 } else {
1819 mark_node = makecon(TypeRawPtr::make((address)markOopDesc::prototype()));
1820 }
1821 rawmem = make_store(control, rawmem, object, oopDesc::mark_offset_in_bytes(), mark_node, T_ADDRESS);
1822
1823 rawmem = make_store(control, rawmem, object, oopDesc::klass_offset_in_bytes(), klass_node, T_METADATA);
1824 int header_size = alloc->minimum_header_size(); // conservatively small
1825
1826 // Array length
1827 if (length != NULL) { // Arrays need length field
1828 rawmem = make_store(control, rawmem, object, arrayOopDesc::length_offset_in_bytes(), length, T_INT);
1829 // conservatively small header size:
1830 header_size = arrayOopDesc::base_offset_in_bytes(T_BYTE);
1831 ciKlass* k = _igvn.type(klass_node)->is_klassptr()->klass();
1832 if (k->is_array_klass()) // we know the exact header size in most cases:
1833 header_size = Klass::layout_helper_header_size(k->layout_helper());
1834 }
1835
1836 // Clear the object body, if necessary.
2712 Node* slow_excp = transform_later(new CatchProjNode(slow_catc, CatchProjNode::catch_all_index, CatchProjNode::no_handler_bci));
2713
2714 Node* ex_r = new RegionNode(3);
2715 Node* ex_mem_phi = new PhiNode(ex_r, Type::MEMORY, TypePtr::BOTTOM);
2716 Node* ex_io_phi = new PhiNode(ex_r, Type::ABIO);
2717 ex_r->init_req(1, slow_excp);
2718 ex_mem_phi->init_req(1, slow_mem);
2719 ex_io_phi->init_req(1, slow_io);
2720 ex_r->init_req(2, ex_ctl);
2721 ex_mem_phi->init_req(2, ex_mem);
2722 ex_io_phi->init_req(2, ex_io);
2723
2724 transform_later(ex_r);
2725 transform_later(ex_mem_phi);
2726 transform_later(ex_io_phi);
2727
2728 Node* slowpath_false = new IfFalseNode(slowpath_iff);
2729 transform_later(slowpath_false);
2730 Node* rawmem = new StorePNode(slowpath_false, mem, top_adr, TypeRawPtr::BOTTOM, new_top, MemNode::unordered);
2731 transform_later(rawmem);
2732 Node* mark_node = NULL;
2733 // For now only enable fast locking for non-array types
2734 if (UseBiasedLocking) {
2735 mark_node = make_load(slowpath_false, rawmem, klass_node, in_bytes(Klass::prototype_header_offset()), TypeRawPtr::BOTTOM, T_ADDRESS);
2736 } else {
2737 mark_node = makecon(TypeRawPtr::make((address)markOopDesc::prototype()));
2738 }
2739 rawmem = make_store(slowpath_false, rawmem, old_top, oopDesc::mark_offset_in_bytes(), mark_node, T_ADDRESS);
2740 rawmem = make_store(slowpath_false, rawmem, old_top, oopDesc::klass_offset_in_bytes(), klass_node, T_METADATA);
2741 if (UseCompressedClassPointers) {
2742 rawmem = make_store(slowpath_false, rawmem, old_top, oopDesc::klass_gap_offset_in_bytes(), intcon(0), T_INT);
2743 }
2744 Node* pack_handler = make_load(slowpath_false, rawmem, klass_node, in_bytes(ValueKlass::pack_handler_offset()), TypeRawPtr::BOTTOM, T_ADDRESS);
2745
2746 CallLeafNoFPNode* handler_call = new CallLeafNoFPNode(OptoRuntime::pack_value_type_Type(),
2747 NULL,
2748 "pack handler",
2749 TypeRawPtr::BOTTOM);
2750 handler_call->init_req(TypeFunc::Control, slowpath_false);
2751 handler_call->init_req(TypeFunc::Memory, rawmem);
2752 handler_call->init_req(TypeFunc::I_O, top());
2753 handler_call->init_req(TypeFunc::FramePtr, call->in(TypeFunc::FramePtr));
2754 handler_call->init_req(TypeFunc::ReturnAdr, top());
2755 handler_call->init_req(TypeFunc::Parms, pack_handler);
2756 handler_call->init_req(TypeFunc::Parms+1, old_top);
2757
2758 // We don't know how many values are returned. This assumes the
|
1787 } else {
1788 slow_result = _resproj->clone();
1789 transform_later(slow_result);
1790 _igvn.replace_node(_resproj, result_phi_rawoop);
1791 }
1792
1793 // Plug slow-path into result merge point
1794 result_region ->init_req( slow_result_path, ctrl );
1795 result_phi_rawoop->init_req( slow_result_path, slow_result);
1796 result_phi_rawmem->init_req( slow_result_path, _memproj_fallthrough );
1797 transform_later(result_region);
1798 transform_later(result_phi_rawoop);
1799 transform_later(result_phi_rawmem);
1800 transform_later(result_phi_i_o);
1801 // This completes all paths into the result merge point
1802 }
1803
1804
1805 // Helper for PhaseMacroExpand::expand_allocate_common.
1806 // Initializes the newly-allocated storage.
1807 Node* PhaseMacroExpand::initialize_object(AllocateNode* alloc,
1808 Node* control, Node* rawmem, Node* object,
1809 Node* klass_node, Node* length,
1810 Node* size_in_bytes) {
1811 InitializeNode* init = alloc->initialization();
1812 // Store the klass & mark bits
1813 Node* mark_node = NULL;
1814 // For now only enable fast locking for non-array types
1815 if ((EnableValhalla || UseBiasedLocking) && length == NULL) {
1816 mark_node = make_load(control, rawmem, klass_node, in_bytes(Klass::prototype_header_offset()), TypeRawPtr::BOTTOM, T_ADDRESS);
1817 } else {
1818 mark_node = makecon(TypeRawPtr::make((address)markOopDesc::prototype()));
1819 }
1820 rawmem = make_store(control, rawmem, object, oopDesc::mark_offset_in_bytes(), mark_node, T_ADDRESS);
1821
1822 rawmem = make_store(control, rawmem, object, oopDesc::klass_offset_in_bytes(), klass_node, T_METADATA);
1823 int header_size = alloc->minimum_header_size(); // conservatively small
1824
1825 // Array length
1826 if (length != NULL) { // Arrays need length field
1827 rawmem = make_store(control, rawmem, object, arrayOopDesc::length_offset_in_bytes(), length, T_INT);
1828 // conservatively small header size:
1829 header_size = arrayOopDesc::base_offset_in_bytes(T_BYTE);
1830 ciKlass* k = _igvn.type(klass_node)->is_klassptr()->klass();
1831 if (k->is_array_klass()) // we know the exact header size in most cases:
1832 header_size = Klass::layout_helper_header_size(k->layout_helper());
1833 }
1834
1835 // Clear the object body, if necessary.
2711 Node* slow_excp = transform_later(new CatchProjNode(slow_catc, CatchProjNode::catch_all_index, CatchProjNode::no_handler_bci));
2712
2713 Node* ex_r = new RegionNode(3);
2714 Node* ex_mem_phi = new PhiNode(ex_r, Type::MEMORY, TypePtr::BOTTOM);
2715 Node* ex_io_phi = new PhiNode(ex_r, Type::ABIO);
2716 ex_r->init_req(1, slow_excp);
2717 ex_mem_phi->init_req(1, slow_mem);
2718 ex_io_phi->init_req(1, slow_io);
2719 ex_r->init_req(2, ex_ctl);
2720 ex_mem_phi->init_req(2, ex_mem);
2721 ex_io_phi->init_req(2, ex_io);
2722
2723 transform_later(ex_r);
2724 transform_later(ex_mem_phi);
2725 transform_later(ex_io_phi);
2726
2727 Node* slowpath_false = new IfFalseNode(slowpath_iff);
2728 transform_later(slowpath_false);
2729 Node* rawmem = new StorePNode(slowpath_false, mem, top_adr, TypeRawPtr::BOTTOM, new_top, MemNode::unordered);
2730 transform_later(rawmem);
2731 Node* mark_node = mark_node = makecon(TypeRawPtr::make((address)markOopDesc::always_locked_prototype()));
2732 rawmem = make_store(slowpath_false, rawmem, old_top, oopDesc::mark_offset_in_bytes(), mark_node, T_ADDRESS);
2733 rawmem = make_store(slowpath_false, rawmem, old_top, oopDesc::klass_offset_in_bytes(), klass_node, T_METADATA);
2734 if (UseCompressedClassPointers) {
2735 rawmem = make_store(slowpath_false, rawmem, old_top, oopDesc::klass_gap_offset_in_bytes(), intcon(0), T_INT);
2736 }
2737 Node* pack_handler = make_load(slowpath_false, rawmem, klass_node, in_bytes(ValueKlass::pack_handler_offset()), TypeRawPtr::BOTTOM, T_ADDRESS);
2738
2739 CallLeafNoFPNode* handler_call = new CallLeafNoFPNode(OptoRuntime::pack_value_type_Type(),
2740 NULL,
2741 "pack handler",
2742 TypeRawPtr::BOTTOM);
2743 handler_call->init_req(TypeFunc::Control, slowpath_false);
2744 handler_call->init_req(TypeFunc::Memory, rawmem);
2745 handler_call->init_req(TypeFunc::I_O, top());
2746 handler_call->init_req(TypeFunc::FramePtr, call->in(TypeFunc::FramePtr));
2747 handler_call->init_req(TypeFunc::ReturnAdr, top());
2748 handler_call->init_req(TypeFunc::Parms, pack_handler);
2749 handler_call->init_req(TypeFunc::Parms+1, old_top);
2750
2751 // We don't know how many values are returned. This assumes the
|