1799 }
1800 }
1801
1802 untaken_branch = _gvn.transform(untaken_branch);
1803 set_control(untaken_branch);
1804
1805 // Branch not taken.
1806 if (stopped() && ctrl_taken == NULL) {
1807 if (C->eliminate_boxing()) {
1808 // Mark the successor block as parsed (if caller does not re-wire control flow)
1809 next_block->next_path_num();
1810 }
1811 } else {
1812 // Update method data
1813 profile_not_taken_branch();
1814 adjust_map_after_if(untaken_btest, c, untaken_prob, next_block);
1815 }
1816 }
1817
1818 void Parse::do_acmp(BoolTest::mask btest, Node* a, Node* b) {
1819 // In the case were both operands might be value types, we need to
1820 // use the new acmp implementation. Otherwise, i.e. if one operand
1821 // is not a value type, we can use the old acmp implementation.
1822 Node* cmp = C->optimize_acmp(&_gvn, a, b);
1823 if (cmp != NULL) {
1824 // Use optimized/old acmp
1825 cmp = optimize_cmp_with_klass(_gvn.transform(cmp));
1826 do_if(btest, cmp);
1827 return;
1828 }
1829
1830 Node* ctrl = NULL;
1831 bool safe_for_replace = true;
1832 if (!UsePointerPerturbation) {
1833 // Emit old acmp before new acmp for quick a != b check
1834 cmp = CmpP(a, b);
1835 cmp = optimize_cmp_with_klass(_gvn.transform(cmp));
1836 if (btest == BoolTest::ne) {
1837 do_if(btest, cmp, true);
1838 if (stopped()) {
1839 return; // Never equal
1840 }
1841 } else if (btest == BoolTest::eq) {
1842 Node* is_equal = NULL;
1843 {
1844 PreserveJVMState pjvms(this);
1845 do_if(btest, cmp, false, &is_equal);
1846 if (!stopped()) {
1847 // Not equal, skip valuetype check
1848 ctrl = new RegionNode(3);
1849 ctrl->init_req(1, control());
1850 _gvn.set_type(ctrl, Type::CONTROL);
1851 record_for_igvn(ctrl);
1852 safe_for_replace = false;
1872 speculate = true;
1873 } else if (!_gvn.type(b)->speculative_maybe_null()) {
1874 speculate = true;
1875 swap(a, b);
1876 }
1877 }
1878 inc_sp(2);
1879 Node* null_ctl = top();
1880 Node* not_null_a = null_check_oop(a, &null_ctl, speculate, safe_for_replace, speculate);
1881 assert(!stopped(), "operand is always null");
1882 dec_sp(2);
1883 Node* region = new RegionNode(2);
1884 Node* is_value = new PhiNode(region, TypeX_X);
1885 if (null_ctl != top()) {
1886 assert(!speculate, "should never be null");
1887 region->add_req(null_ctl);
1888 is_value->add_req(_gvn.MakeConX(0));
1889 }
1890
1891 Node* value_mask = _gvn.MakeConX(markOopDesc::always_locked_pattern);
1892 if (UsePointerPerturbation) {
1893 Node* mark_addr = basic_plus_adr(not_null_a, oopDesc::mark_offset_in_bytes());
1894 Node* mark = make_load(NULL, mark_addr, TypeX_X, TypeX_X->basic_type(), MemNode::unordered);
1895 Node* not_mark = _gvn.transform(new XorXNode(mark, _gvn.MakeConX(-1)));
1896 Node* andn = _gvn.transform(new AndXNode(not_mark, value_mask));
1897 Node* neg_if_value = _gvn.transform(new SubXNode(andn, _gvn.MakeConX(1)));
1898 is_value->init_req(1, _gvn.transform(new RShiftXNode(neg_if_value, _gvn.intcon(63))));
1899 } else {
1900 is_value->init_req(1, is_always_locked(not_null_a));
1901 }
1902 region->init_req(1, control());
1903
1904 set_control(_gvn.transform(region));
1905 is_value = _gvn.transform(is_value);
1906
1907 if (UsePointerPerturbation) {
1908 // Perturbe oop if operand is a value type to make comparison fail
1909 Node* pert = _gvn.transform(new AddPNode(a, a, is_value));
1910 cmp = _gvn.transform(new CmpPNode(pert, b));
1911 } else {
1912 // Check for a value type because we already know that operands are equal
1913 cmp = _gvn.transform(new CmpXNode(is_value, value_mask));
1914 btest = (btest == BoolTest::eq) ? BoolTest::ne : BoolTest::eq;
1915 }
1916 cmp = optimize_cmp_with_klass(cmp);
1917 do_if(btest, cmp);
1918
1919 if (ctrl != NULL) {
1920 ctrl->init_req(2, control());
1921 set_control(_gvn.transform(ctrl));
1922 }
1923 }
1924
1925 bool Parse::path_is_suitable_for_uncommon_trap(float prob) const {
1926 // Don't want to speculate on uncommon traps when running with -Xcomp
1927 if (!UseInterpreter) {
|
1799 }
1800 }
1801
1802 untaken_branch = _gvn.transform(untaken_branch);
1803 set_control(untaken_branch);
1804
1805 // Branch not taken.
1806 if (stopped() && ctrl_taken == NULL) {
1807 if (C->eliminate_boxing()) {
1808 // Mark the successor block as parsed (if caller does not re-wire control flow)
1809 next_block->next_path_num();
1810 }
1811 } else {
1812 // Update method data
1813 profile_not_taken_branch();
1814 adjust_map_after_if(untaken_btest, c, untaken_prob, next_block);
1815 }
1816 }
1817
1818 void Parse::do_acmp(BoolTest::mask btest, Node* a, Node* b) {
1819 ciMethod* subst_method = ciEnv::current()->ValueBootstrapMethods_klass()->find_method(ciSymbol::isSubstitutable_name(), ciSymbol::object_object_boolean_signature());
1820 if (ACmpOnValues == 0 || !EnableValhalla || method() == subst_method) {
1821 Node* cmp = CmpP(a, b);
1822 cmp = optimize_cmp_with_klass(cmp);
1823 do_if(btest, cmp);
1824 return;
1825 }
1826
1827 if (ACmpOnValues == 3) {
1828 if (a->is_ValueType()) {
1829 inc_sp(2);
1830 a = a->as_ValueType()->allocate(this, true)->get_oop();
1831 dec_sp(2);
1832 }
1833 if (b->is_ValueType()) {
1834 inc_sp(2);
1835 b = b->as_ValueType()->allocate(this, true)->get_oop();
1836 dec_sp(2);
1837 }
1838
1839 const TypeOopPtr* ta = _gvn.type(a)->isa_oopptr();
1840 const TypeOopPtr* tb = _gvn.type(b)->isa_oopptr();
1841
1842 if (ta == NULL || !ta->can_be_value_type() ||
1843 tb == NULL || !tb->can_be_value_type()) {
1844 Node* cmp = CmpP(a, b);
1845 cmp = optimize_cmp_with_klass(cmp);
1846 do_if(btest, cmp);
1847 return;
1848 }
1849
1850 Node* cmp = CmpP(a, b);
1851 cmp = optimize_cmp_with_klass(cmp);
1852 Node* eq_region = NULL;
1853 if (btest == BoolTest::eq) {
1854 do_if(btest, cmp, true);
1855 if (stopped()) {
1856 return;
1857 }
1858 } else {
1859 assert(btest == BoolTest::ne, "only eq or ne");
1860 Node* is_not_equal = NULL;
1861 eq_region = new RegionNode(3);
1862 {
1863 PreserveJVMState pjvms(this);
1864 do_if(btest, cmp, false, &is_not_equal);
1865 if (!stopped()) {
1866 eq_region->init_req(1, control());
1867 }
1868 }
1869 if (is_not_equal == NULL || is_not_equal->is_top()) {
1870 record_for_igvn(eq_region);
1871 set_control(_gvn.transform(eq_region));
1872 return;
1873 }
1874 set_control(is_not_equal);
1875 }
1876 Node* ne_region = new RegionNode(6);
1877 inc_sp(2);
1878 Node* null_ctl = top();
1879 Node* not_null_a = null_check_oop(a, &null_ctl, !too_many_traps(Deoptimization::Reason_null_check), false, false);
1880 dec_sp(2);
1881 ne_region->init_req(1, null_ctl);
1882 if (stopped()) {
1883 record_for_igvn(ne_region);
1884 set_control(_gvn.transform(ne_region));
1885 if (btest == BoolTest::ne) {
1886 {
1887 PreserveJVMState pjvms(this);
1888 int target_bci = iter().get_dest();
1889 merge(target_bci);
1890 }
1891 record_for_igvn(eq_region);
1892 set_control(_gvn.transform(eq_region));
1893 }
1894 return;
1895 }
1896
1897 Node* is_value = is_always_locked(not_null_a);
1898 Node* value_mask = _gvn.MakeConX(markOopDesc::always_locked_pattern);
1899 Node* is_value_cmp = _gvn.transform(new CmpXNode(is_value, value_mask));
1900 Node* is_value_bol = _gvn.transform(new BoolNode(is_value_cmp, BoolTest::ne));
1901 IfNode* is_value_iff = create_and_map_if(control(), is_value_bol, PROB_FAIR, COUNT_UNKNOWN);
1902 Node* not_value = _gvn.transform(new IfTrueNode(is_value_iff));
1903 set_control(_gvn.transform(new IfFalseNode(is_value_iff)));
1904 ne_region->init_req(2, not_value);
1905
1906 inc_sp(2);
1907 null_ctl = top();
1908 Node* not_null_b = null_check_oop(b, &null_ctl, !too_many_traps(Deoptimization::Reason_null_check), false, false);
1909 dec_sp(2);
1910 ne_region->init_req(3, null_ctl);
1911 if (stopped()) {
1912 record_for_igvn(ne_region);
1913 set_control(_gvn.transform(ne_region));
1914 if (btest == BoolTest::ne) {
1915 {
1916 PreserveJVMState pjvms(this);
1917 int target_bci = iter().get_dest();
1918 merge(target_bci);
1919 }
1920 record_for_igvn(eq_region);
1921 set_control(_gvn.transform(eq_region));
1922 }
1923 return;
1924 }
1925 Node* kls_a = load_object_klass(not_null_a);
1926 Node* kls_b = load_object_klass(not_null_b);
1927 Node* kls_cmp = CmpP(kls_a, kls_b);
1928 Node* kls_bol = _gvn.transform(new BoolNode(kls_cmp, BoolTest::ne));
1929 IfNode* kls_iff = create_and_map_if(control(), kls_bol, PROB_FAIR, COUNT_UNKNOWN);
1930 Node* kls_ne = _gvn.transform(new IfTrueNode(kls_iff));
1931 set_control(_gvn.transform(new IfFalseNode(kls_iff)));
1932 ne_region->init_req(4, kls_ne);
1933
1934 if (stopped()) {
1935 record_for_igvn(ne_region);
1936 set_control(_gvn.transform(ne_region));
1937 if (btest == BoolTest::ne) {
1938 {
1939 PreserveJVMState pjvms(this);
1940 int target_bci = iter().get_dest();
1941 merge(target_bci);
1942 }
1943 record_for_igvn(eq_region);
1944 set_control(_gvn.transform(eq_region));
1945 }
1946 return;
1947 }
1948
1949 Node* ne_io_phi = PhiNode::make(ne_region, i_o());
1950 Node* mem = reset_memory();
1951 Node* ne_mem_phi = PhiNode::make(ne_region, mem);
1952
1953 Node* eq_io_phi = NULL;
1954 Node* eq_mem_phi = NULL;
1955 if (eq_region != NULL) {
1956 eq_io_phi = PhiNode::make(eq_region, i_o());
1957 eq_mem_phi = PhiNode::make(eq_region, mem);
1958 }
1959
1960 set_all_memory(mem);
1961
1962 kill_dead_locals();
1963 CallStaticJavaNode *call = new CallStaticJavaNode(C, TypeFunc::make(subst_method), SharedRuntime::get_resolve_static_call_stub(), subst_method, bci());
1964 call->set_override_symbolic_info(true);
1965 call->init_req(TypeFunc::Parms, not_null_a);
1966 call->init_req(TypeFunc::Parms+1, not_null_b);
1967 inc_sp(2);
1968 set_edges_for_java_call(call, false, false);
1969 Node* ret = set_results_for_java_call(call, false, true);
1970 dec_sp(2);
1971 Node* subst_cmp = _gvn.transform(new CmpINode(ret, intcon(1)));
1972 if (btest == BoolTest::eq) {
1973 do_if(btest, subst_cmp);
1974 } else {
1975 assert(btest == BoolTest::ne, "only eq or ne");
1976 Node* is_not_equal = NULL;
1977 {
1978 PreserveJVMState pjvms(this);
1979 do_if(btest, subst_cmp, false, &is_not_equal);
1980 if (!stopped()) {
1981 eq_region->init_req(2, control());
1982 eq_io_phi->init_req(2, i_o());
1983 eq_mem_phi->init_req(2, reset_memory());
1984 }
1985 }
1986 set_control(is_not_equal);
1987 }
1988 ne_region->init_req(5, control());
1989 ne_io_phi->init_req(5, i_o());
1990 ne_mem_phi->init_req(5, reset_memory());
1991
1992 record_for_igvn(ne_region);
1993 set_control(_gvn.transform(ne_region));
1994 set_i_o(_gvn.transform(ne_io_phi));
1995 set_all_memory(_gvn.transform(ne_mem_phi));
1996
1997 if (btest == BoolTest::ne) {
1998 {
1999 PreserveJVMState pjvms(this);
2000 int target_bci = iter().get_dest();
2001 merge(target_bci);
2002 }
2003
2004 record_for_igvn(eq_region);
2005 set_control(_gvn.transform(eq_region));
2006 set_i_o(_gvn.transform(eq_io_phi));
2007 set_all_memory(_gvn.transform(eq_mem_phi));
2008 }
2009
2010 return;
2011 }
2012 // In the case were both operands might be value types, we need to
2013 // use the new acmp implementation. Otherwise, i.e. if one operand
2014 // is not a value type, we can use the old acmp implementation.
2015 Node* cmp = C->optimize_acmp(&_gvn, a, b);
2016 if (cmp != NULL) {
2017 // Use optimized/old acmp
2018 cmp = optimize_cmp_with_klass(_gvn.transform(cmp));
2019 do_if(btest, cmp);
2020 return;
2021 }
2022
2023 Node* ctrl = NULL;
2024 bool safe_for_replace = true;
2025 if (ACmpOnValues != 1) {
2026 // Emit old acmp before new acmp for quick a != b check
2027 cmp = CmpP(a, b);
2028 cmp = optimize_cmp_with_klass(_gvn.transform(cmp));
2029 if (btest == BoolTest::ne) {
2030 do_if(btest, cmp, true);
2031 if (stopped()) {
2032 return; // Never equal
2033 }
2034 } else if (btest == BoolTest::eq) {
2035 Node* is_equal = NULL;
2036 {
2037 PreserveJVMState pjvms(this);
2038 do_if(btest, cmp, false, &is_equal);
2039 if (!stopped()) {
2040 // Not equal, skip valuetype check
2041 ctrl = new RegionNode(3);
2042 ctrl->init_req(1, control());
2043 _gvn.set_type(ctrl, Type::CONTROL);
2044 record_for_igvn(ctrl);
2045 safe_for_replace = false;
2065 speculate = true;
2066 } else if (!_gvn.type(b)->speculative_maybe_null()) {
2067 speculate = true;
2068 swap(a, b);
2069 }
2070 }
2071 inc_sp(2);
2072 Node* null_ctl = top();
2073 Node* not_null_a = null_check_oop(a, &null_ctl, speculate, safe_for_replace, speculate);
2074 assert(!stopped(), "operand is always null");
2075 dec_sp(2);
2076 Node* region = new RegionNode(2);
2077 Node* is_value = new PhiNode(region, TypeX_X);
2078 if (null_ctl != top()) {
2079 assert(!speculate, "should never be null");
2080 region->add_req(null_ctl);
2081 is_value->add_req(_gvn.MakeConX(0));
2082 }
2083
2084 Node* value_mask = _gvn.MakeConX(markOopDesc::always_locked_pattern);
2085 if (ACmpOnValues == 1) {
2086 Node* mark_addr = basic_plus_adr(not_null_a, oopDesc::mark_offset_in_bytes());
2087 Node* mark = make_load(NULL, mark_addr, TypeX_X, TypeX_X->basic_type(), MemNode::unordered);
2088 Node* not_mark = _gvn.transform(new XorXNode(mark, _gvn.MakeConX(-1)));
2089 Node* andn = _gvn.transform(new AndXNode(not_mark, value_mask));
2090 Node* neg_if_value = _gvn.transform(new SubXNode(andn, _gvn.MakeConX(1)));
2091 is_value->init_req(1, _gvn.transform(new RShiftXNode(neg_if_value, _gvn.intcon(63))));
2092 } else {
2093 is_value->init_req(1, is_always_locked(not_null_a));
2094 }
2095 region->init_req(1, control());
2096
2097 set_control(_gvn.transform(region));
2098 is_value = _gvn.transform(is_value);
2099
2100 if (ACmpOnValues == 1) {
2101 // Perturbe oop if operand is a value type to make comparison fail
2102 Node* pert = _gvn.transform(new AddPNode(a, a, is_value));
2103 cmp = _gvn.transform(new CmpPNode(pert, b));
2104 } else {
2105 // Check for a value type because we already know that operands are equal
2106 cmp = _gvn.transform(new CmpXNode(is_value, value_mask));
2107 btest = (btest == BoolTest::eq) ? BoolTest::ne : BoolTest::eq;
2108 }
2109 cmp = optimize_cmp_with_klass(cmp);
2110 do_if(btest, cmp);
2111
2112 if (ctrl != NULL) {
2113 ctrl->init_req(2, control());
2114 set_control(_gvn.transform(ctrl));
2115 }
2116 }
2117
2118 bool Parse::path_is_suitable_for_uncommon_trap(float prob) const {
2119 // Don't want to speculate on uncommon traps when running with -Xcomp
2120 if (!UseInterpreter) {
|