1683 value.load_byte_item(); 1684 } else { 1685 value.load_item(); 1686 } 1687 } else { 1688 value.load_for_store(field_type); 1689 } 1690 1691 set_no_result(x); 1692 1693 #ifndef PRODUCT 1694 if (PrintNotLoaded && needs_patching) { 1695 tty->print_cr(" ###class not loaded at store_%s bci %d", 1696 x->is_static() ? "static" : "field", x->printable_bci()); 1697 } 1698 #endif 1699 1700 if (x->needs_null_check() && 1701 (needs_patching || 1702 MacroAssembler::needs_explicit_null_check(x->offset()))) { 1703 // emit an explicit null check because the offset is too large 1704 __ null_check(object.result(), new CodeEmitInfo(info)); 1705 } 1706 1707 LIR_Address* address; 1708 if (needs_patching) { 1709 // we need to patch the offset in the instruction so don't allow 1710 // generate_address to try to be smart about emitting the -1. 1711 // Otherwise the patching code won't know how to find the 1712 // instruction to patch. 1713 address = new LIR_Address(object.result(), PATCHED_ADDR, field_type); 1714 } else { 1715 address = generate_address(object.result(), x->offset(), field_type); 1716 } 1717 1718 if (is_volatile && os::is_MP()) { 1719 __ membar_release(); 1720 } 1721 1722 if (is_oop) { 1723 // Do the pre-write barrier, if any. 1724 pre_barrier(LIR_OprFact::address(address), 1768 1769 object.load_item(); 1770 1771 #ifndef PRODUCT 1772 if (PrintNotLoaded && needs_patching) { 1773 tty->print_cr(" ###class not loaded at load_%s bci %d", 1774 x->is_static() ? "static" : "field", x->printable_bci()); 1775 } 1776 #endif 1777 1778 bool stress_deopt = StressLoopInvariantCodeMotion && info && info->deoptimize_on_exception(); 1779 if (x->needs_null_check() && 1780 (needs_patching || 1781 MacroAssembler::needs_explicit_null_check(x->offset()) || 1782 stress_deopt)) { 1783 LIR_Opr obj = object.result(); 1784 if (stress_deopt) { 1785 obj = new_register(T_OBJECT); 1786 __ move(LIR_OprFact::oopConst(NULL), obj); 1787 } 1788 // emit an explicit null check because the offset is too large 1789 __ null_check(obj, new CodeEmitInfo(info)); 1790 } 1791 1792 LIR_Opr reg = rlock_result(x, field_type); 1793 LIR_Address* address; 1794 if (needs_patching) { 1795 // we need to patch the offset in the instruction so don't allow 1796 // generate_address to try to be smart about emitting the -1. 1797 // Otherwise the patching code won't know how to find the 1798 // instruction to patch. 1799 address = new LIR_Address(object.result(), PATCHED_ADDR, field_type); 1800 } else { 1801 address = generate_address(object.result(), x->offset(), field_type); 1802 } 1803 1804 if (is_volatile && !needs_patching) { 1805 volatile_field_load(address, reg, info); 1806 } else { 1807 LIR_PatchCode patch_code = needs_patching ? lir_patch_normal : lir_patch_none; 1808 __ load(address, reg, info, patch_code); 1809 } | 1683 value.load_byte_item(); 1684 } else { 1685 value.load_item(); 1686 } 1687 } else { 1688 value.load_for_store(field_type); 1689 } 1690 1691 set_no_result(x); 1692 1693 #ifndef PRODUCT 1694 if (PrintNotLoaded && needs_patching) { 1695 tty->print_cr(" ###class not loaded at store_%s bci %d", 1696 x->is_static() ? "static" : "field", x->printable_bci()); 1697 } 1698 #endif 1699 1700 if (x->needs_null_check() && 1701 (needs_patching || 1702 MacroAssembler::needs_explicit_null_check(x->offset()))) { 1703 // Emit an explicit null check because the offset is too large. 1704 // If the class is not loaded and the object is NULL, we need to deoptimize to throw a 1705 // NoClassDefFoundError in the interpreter instead of an implicit NPE from compiled code. 1706 __ null_check(object.result(), new CodeEmitInfo(info), /* deoptimize */ needs_patching); 1707 } 1708 1709 LIR_Address* address; 1710 if (needs_patching) { 1711 // we need to patch the offset in the instruction so don't allow 1712 // generate_address to try to be smart about emitting the -1. 1713 // Otherwise the patching code won't know how to find the 1714 // instruction to patch. 1715 address = new LIR_Address(object.result(), PATCHED_ADDR, field_type); 1716 } else { 1717 address = generate_address(object.result(), x->offset(), field_type); 1718 } 1719 1720 if (is_volatile && os::is_MP()) { 1721 __ membar_release(); 1722 } 1723 1724 if (is_oop) { 1725 // Do the pre-write barrier, if any. 1726 pre_barrier(LIR_OprFact::address(address), 1770 1771 object.load_item(); 1772 1773 #ifndef PRODUCT 1774 if (PrintNotLoaded && needs_patching) { 1775 tty->print_cr(" ###class not loaded at load_%s bci %d", 1776 x->is_static() ? "static" : "field", x->printable_bci()); 1777 } 1778 #endif 1779 1780 bool stress_deopt = StressLoopInvariantCodeMotion && info && info->deoptimize_on_exception(); 1781 if (x->needs_null_check() && 1782 (needs_patching || 1783 MacroAssembler::needs_explicit_null_check(x->offset()) || 1784 stress_deopt)) { 1785 LIR_Opr obj = object.result(); 1786 if (stress_deopt) { 1787 obj = new_register(T_OBJECT); 1788 __ move(LIR_OprFact::oopConst(NULL), obj); 1789 } 1790 // Emit an explicit null check because the offset is too large. 1791 // If the class is not loaded and the object is NULL, we need to deoptimize to throw a 1792 // NoClassDefFoundError in the interpreter instead of an implicit NPE from compiled code. 1793 __ null_check(obj, new CodeEmitInfo(info), /* deoptimize */ needs_patching); 1794 } 1795 1796 LIR_Opr reg = rlock_result(x, field_type); 1797 LIR_Address* address; 1798 if (needs_patching) { 1799 // we need to patch the offset in the instruction so don't allow 1800 // generate_address to try to be smart about emitting the -1. 1801 // Otherwise the patching code won't know how to find the 1802 // instruction to patch. 1803 address = new LIR_Address(object.result(), PATCHED_ADDR, field_type); 1804 } else { 1805 address = generate_address(object.result(), x->offset(), field_type); 1806 } 1807 1808 if (is_volatile && !needs_patching) { 1809 volatile_field_load(address, reg, info); 1810 } else { 1811 LIR_PatchCode patch_code = needs_patching ? lir_patch_normal : lir_patch_none; 1812 __ load(address, reg, info, patch_code); 1813 } |