annotate src/share/vm/opto/library_call.cpp @ 4710:41406797186b

7113012: G1: rename not-fully-young GCs as "mixed" Summary: Renamed partially-young GCs as mixed and fully-young GCs as young. Change all external output that includes those terms (GC log and GC ergo log) as well as any comments, fields, methods, etc. The changeset also includes very minor code tidying up (added some curly brackets). Reviewed-by: johnc, brutisso
author tonyp
date Fri, 16 Dec 2011 02:14:27 -0500
parents a92cdbac8b9e
children 52b5d32fbfaf 069ab3f976d3
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
2320
41d4973cf100 6942326: x86 code in string_indexof() could read beyond reserved heap space
kvn
parents: 1972
diff changeset
2 * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load
duke
parents:
diff changeset
4 *
a61af66fc99e Initial load
duke
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load
duke
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load
duke
parents:
diff changeset
7 * published by the Free Software Foundation.
a61af66fc99e Initial load
duke
parents:
diff changeset
8 *
a61af66fc99e Initial load
duke
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load
duke
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load
duke
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load
duke
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load
duke
parents:
diff changeset
13 * accompanied this code).
a61af66fc99e Initial load
duke
parents:
diff changeset
14 *
a61af66fc99e Initial load
duke
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load
duke
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load
duke
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load
duke
parents:
diff changeset
18 *
1552
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1513
diff changeset
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1513
diff changeset
20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1513
diff changeset
21 * questions.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
22 *
a61af66fc99e Initial load
duke
parents:
diff changeset
23 */
a61af66fc99e Initial load
duke
parents:
diff changeset
24
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
26 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
27 #include "classfile/vmSymbols.hpp"
2405
3d58a4983660 7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents: 2385
diff changeset
28 #include "compiler/compileBroker.hpp"
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
29 #include "compiler/compileLog.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
30 #include "oops/objArrayKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
31 #include "opto/addnode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
32 #include "opto/callGenerator.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
33 #include "opto/cfgnode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
34 #include "opto/idealKit.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
35 #include "opto/mulnode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
36 #include "opto/parse.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
37 #include "opto/runtime.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
38 #include "opto/subnode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
39 #include "prims/nativeLookup.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1844
diff changeset
40 #include "runtime/sharedRuntime.hpp"
0
a61af66fc99e Initial load
duke
parents:
diff changeset
41
a61af66fc99e Initial load
duke
parents:
diff changeset
42 class LibraryIntrinsic : public InlineCallGenerator {
a61af66fc99e Initial load
duke
parents:
diff changeset
43 // Extend the set of intrinsics known to the runtime:
a61af66fc99e Initial load
duke
parents:
diff changeset
44 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
45 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
46 bool _is_virtual;
a61af66fc99e Initial load
duke
parents:
diff changeset
47 vmIntrinsics::ID _intrinsic_id;
a61af66fc99e Initial load
duke
parents:
diff changeset
48
a61af66fc99e Initial load
duke
parents:
diff changeset
49 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
50 LibraryIntrinsic(ciMethod* m, bool is_virtual, vmIntrinsics::ID id)
a61af66fc99e Initial load
duke
parents:
diff changeset
51 : InlineCallGenerator(m),
a61af66fc99e Initial load
duke
parents:
diff changeset
52 _is_virtual(is_virtual),
a61af66fc99e Initial load
duke
parents:
diff changeset
53 _intrinsic_id(id)
a61af66fc99e Initial load
duke
parents:
diff changeset
54 {
a61af66fc99e Initial load
duke
parents:
diff changeset
55 }
a61af66fc99e Initial load
duke
parents:
diff changeset
56 virtual bool is_intrinsic() const { return true; }
a61af66fc99e Initial load
duke
parents:
diff changeset
57 virtual bool is_virtual() const { return _is_virtual; }
a61af66fc99e Initial load
duke
parents:
diff changeset
58 virtual JVMState* generate(JVMState* jvms);
a61af66fc99e Initial load
duke
parents:
diff changeset
59 vmIntrinsics::ID intrinsic_id() const { return _intrinsic_id; }
a61af66fc99e Initial load
duke
parents:
diff changeset
60 };
a61af66fc99e Initial load
duke
parents:
diff changeset
61
a61af66fc99e Initial load
duke
parents:
diff changeset
62
a61af66fc99e Initial load
duke
parents:
diff changeset
63 // Local helper class for LibraryIntrinsic:
a61af66fc99e Initial load
duke
parents:
diff changeset
64 class LibraryCallKit : public GraphKit {
a61af66fc99e Initial load
duke
parents:
diff changeset
65 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
66 LibraryIntrinsic* _intrinsic; // the library intrinsic being called
a61af66fc99e Initial load
duke
parents:
diff changeset
67
a61af66fc99e Initial load
duke
parents:
diff changeset
68 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
69 LibraryCallKit(JVMState* caller, LibraryIntrinsic* intrinsic)
a61af66fc99e Initial load
duke
parents:
diff changeset
70 : GraphKit(caller),
a61af66fc99e Initial load
duke
parents:
diff changeset
71 _intrinsic(intrinsic)
a61af66fc99e Initial load
duke
parents:
diff changeset
72 {
a61af66fc99e Initial load
duke
parents:
diff changeset
73 }
a61af66fc99e Initial load
duke
parents:
diff changeset
74
a61af66fc99e Initial load
duke
parents:
diff changeset
75 ciMethod* caller() const { return jvms()->method(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
76 int bci() const { return jvms()->bci(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
77 LibraryIntrinsic* intrinsic() const { return _intrinsic; }
a61af66fc99e Initial load
duke
parents:
diff changeset
78 vmIntrinsics::ID intrinsic_id() const { return _intrinsic->intrinsic_id(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
79 ciMethod* callee() const { return _intrinsic->method(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
80 ciSignature* signature() const { return callee()->signature(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
81 int arg_size() const { return callee()->arg_size(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
82
a61af66fc99e Initial load
duke
parents:
diff changeset
83 bool try_to_inline();
a61af66fc99e Initial load
duke
parents:
diff changeset
84
a61af66fc99e Initial load
duke
parents:
diff changeset
85 // Helper functions to inline natives
a61af66fc99e Initial load
duke
parents:
diff changeset
86 void push_result(RegionNode* region, PhiNode* value);
a61af66fc99e Initial load
duke
parents:
diff changeset
87 Node* generate_guard(Node* test, RegionNode* region, float true_prob);
a61af66fc99e Initial load
duke
parents:
diff changeset
88 Node* generate_slow_guard(Node* test, RegionNode* region);
a61af66fc99e Initial load
duke
parents:
diff changeset
89 Node* generate_fair_guard(Node* test, RegionNode* region);
a61af66fc99e Initial load
duke
parents:
diff changeset
90 Node* generate_negative_guard(Node* index, RegionNode* region,
a61af66fc99e Initial load
duke
parents:
diff changeset
91 // resulting CastII of index:
a61af66fc99e Initial load
duke
parents:
diff changeset
92 Node* *pos_index = NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
93 Node* generate_nonpositive_guard(Node* index, bool never_negative,
a61af66fc99e Initial load
duke
parents:
diff changeset
94 // resulting CastII of index:
a61af66fc99e Initial load
duke
parents:
diff changeset
95 Node* *pos_index = NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
96 Node* generate_limit_guard(Node* offset, Node* subseq_length,
a61af66fc99e Initial load
duke
parents:
diff changeset
97 Node* array_length,
a61af66fc99e Initial load
duke
parents:
diff changeset
98 RegionNode* region);
a61af66fc99e Initial load
duke
parents:
diff changeset
99 Node* generate_current_thread(Node* &tls_output);
a61af66fc99e Initial load
duke
parents:
diff changeset
100 address basictype2arraycopy(BasicType t, Node *src_offset, Node *dest_offset,
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
101 bool disjoint_bases, const char* &name, bool dest_uninitialized);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
102 Node* load_mirror_from_klass(Node* klass);
a61af66fc99e Initial load
duke
parents:
diff changeset
103 Node* load_klass_from_mirror_common(Node* mirror, bool never_see_null,
a61af66fc99e Initial load
duke
parents:
diff changeset
104 int nargs,
a61af66fc99e Initial load
duke
parents:
diff changeset
105 RegionNode* region, int null_path,
a61af66fc99e Initial load
duke
parents:
diff changeset
106 int offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
107 Node* load_klass_from_mirror(Node* mirror, bool never_see_null, int nargs,
a61af66fc99e Initial load
duke
parents:
diff changeset
108 RegionNode* region, int null_path) {
a61af66fc99e Initial load
duke
parents:
diff changeset
109 int offset = java_lang_Class::klass_offset_in_bytes();
a61af66fc99e Initial load
duke
parents:
diff changeset
110 return load_klass_from_mirror_common(mirror, never_see_null, nargs,
a61af66fc99e Initial load
duke
parents:
diff changeset
111 region, null_path,
a61af66fc99e Initial load
duke
parents:
diff changeset
112 offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
113 }
a61af66fc99e Initial load
duke
parents:
diff changeset
114 Node* load_array_klass_from_mirror(Node* mirror, bool never_see_null,
a61af66fc99e Initial load
duke
parents:
diff changeset
115 int nargs,
a61af66fc99e Initial load
duke
parents:
diff changeset
116 RegionNode* region, int null_path) {
a61af66fc99e Initial load
duke
parents:
diff changeset
117 int offset = java_lang_Class::array_klass_offset_in_bytes();
a61af66fc99e Initial load
duke
parents:
diff changeset
118 return load_klass_from_mirror_common(mirror, never_see_null, nargs,
a61af66fc99e Initial load
duke
parents:
diff changeset
119 region, null_path,
a61af66fc99e Initial load
duke
parents:
diff changeset
120 offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
121 }
a61af66fc99e Initial load
duke
parents:
diff changeset
122 Node* generate_access_flags_guard(Node* kls,
a61af66fc99e Initial load
duke
parents:
diff changeset
123 int modifier_mask, int modifier_bits,
a61af66fc99e Initial load
duke
parents:
diff changeset
124 RegionNode* region);
a61af66fc99e Initial load
duke
parents:
diff changeset
125 Node* generate_interface_guard(Node* kls, RegionNode* region);
a61af66fc99e Initial load
duke
parents:
diff changeset
126 Node* generate_array_guard(Node* kls, RegionNode* region) {
a61af66fc99e Initial load
duke
parents:
diff changeset
127 return generate_array_guard_common(kls, region, false, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
128 }
a61af66fc99e Initial load
duke
parents:
diff changeset
129 Node* generate_non_array_guard(Node* kls, RegionNode* region) {
a61af66fc99e Initial load
duke
parents:
diff changeset
130 return generate_array_guard_common(kls, region, false, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
131 }
a61af66fc99e Initial load
duke
parents:
diff changeset
132 Node* generate_objArray_guard(Node* kls, RegionNode* region) {
a61af66fc99e Initial load
duke
parents:
diff changeset
133 return generate_array_guard_common(kls, region, true, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
134 }
a61af66fc99e Initial load
duke
parents:
diff changeset
135 Node* generate_non_objArray_guard(Node* kls, RegionNode* region) {
a61af66fc99e Initial load
duke
parents:
diff changeset
136 return generate_array_guard_common(kls, region, true, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
137 }
a61af66fc99e Initial load
duke
parents:
diff changeset
138 Node* generate_array_guard_common(Node* kls, RegionNode* region,
a61af66fc99e Initial load
duke
parents:
diff changeset
139 bool obj_array, bool not_array);
a61af66fc99e Initial load
duke
parents:
diff changeset
140 Node* generate_virtual_guard(Node* obj_klass, RegionNode* slow_region);
a61af66fc99e Initial load
duke
parents:
diff changeset
141 CallJavaNode* generate_method_call(vmIntrinsics::ID method_id,
a61af66fc99e Initial load
duke
parents:
diff changeset
142 bool is_virtual = false, bool is_static = false);
a61af66fc99e Initial load
duke
parents:
diff changeset
143 CallJavaNode* generate_method_call_static(vmIntrinsics::ID method_id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
144 return generate_method_call(method_id, false, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
145 }
a61af66fc99e Initial load
duke
parents:
diff changeset
146 CallJavaNode* generate_method_call_virtual(vmIntrinsics::ID method_id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
147 return generate_method_call(method_id, true, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
148 }
a61af66fc99e Initial load
duke
parents:
diff changeset
149
986
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
150 Node* make_string_method_node(int opcode, Node* str1, Node* cnt1, Node* str2, Node* cnt2);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
151 bool inline_string_compareTo();
a61af66fc99e Initial load
duke
parents:
diff changeset
152 bool inline_string_indexOf();
a61af66fc99e Initial load
duke
parents:
diff changeset
153 Node* string_indexOf(Node* string_object, ciTypeArray* target_array, jint offset, jint cache_i, jint md2_i);
681
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
154 bool inline_string_equals();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
155 Node* pop_math_arg();
a61af66fc99e Initial load
duke
parents:
diff changeset
156 bool runtime_math(const TypeFunc* call_type, address funcAddr, const char* funcName);
a61af66fc99e Initial load
duke
parents:
diff changeset
157 bool inline_math_native(vmIntrinsics::ID id);
a61af66fc99e Initial load
duke
parents:
diff changeset
158 bool inline_trig(vmIntrinsics::ID id);
a61af66fc99e Initial load
duke
parents:
diff changeset
159 bool inline_trans(vmIntrinsics::ID id);
a61af66fc99e Initial load
duke
parents:
diff changeset
160 bool inline_abs(vmIntrinsics::ID id);
a61af66fc99e Initial load
duke
parents:
diff changeset
161 bool inline_sqrt(vmIntrinsics::ID id);
a61af66fc99e Initial load
duke
parents:
diff changeset
162 bool inline_pow(vmIntrinsics::ID id);
a61af66fc99e Initial load
duke
parents:
diff changeset
163 bool inline_exp(vmIntrinsics::ID id);
a61af66fc99e Initial load
duke
parents:
diff changeset
164 bool inline_min_max(vmIntrinsics::ID id);
a61af66fc99e Initial load
duke
parents:
diff changeset
165 Node* generate_min_max(vmIntrinsics::ID id, Node* x, Node* y);
a61af66fc99e Initial load
duke
parents:
diff changeset
166 // This returns Type::AnyPtr, RawPtr, or OopPtr.
a61af66fc99e Initial load
duke
parents:
diff changeset
167 int classify_unsafe_addr(Node* &base, Node* &offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
168 Node* make_unsafe_address(Node* base, Node* offset);
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
169 // Helper for inline_unsafe_access.
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
170 // Generates the guards that check whether the result of
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
171 // Unsafe.getObject should be recorded in an SATB log buffer.
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
172 void insert_g1_pre_barrier(Node* base_oop, Node* offset, Node* pre_val);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
173 bool inline_unsafe_access(bool is_native_ptr, bool is_store, BasicType type, bool is_volatile);
a61af66fc99e Initial load
duke
parents:
diff changeset
174 bool inline_unsafe_prefetch(bool is_native_ptr, bool is_store, bool is_static);
a61af66fc99e Initial load
duke
parents:
diff changeset
175 bool inline_unsafe_allocate();
a61af66fc99e Initial load
duke
parents:
diff changeset
176 bool inline_unsafe_copyMemory();
a61af66fc99e Initial load
duke
parents:
diff changeset
177 bool inline_native_currentThread();
a61af66fc99e Initial load
duke
parents:
diff changeset
178 bool inline_native_time_funcs(bool isNano);
a61af66fc99e Initial load
duke
parents:
diff changeset
179 bool inline_native_isInterrupted();
a61af66fc99e Initial load
duke
parents:
diff changeset
180 bool inline_native_Class_query(vmIntrinsics::ID id);
a61af66fc99e Initial load
duke
parents:
diff changeset
181 bool inline_native_subtype_check();
a61af66fc99e Initial load
duke
parents:
diff changeset
182
a61af66fc99e Initial load
duke
parents:
diff changeset
183 bool inline_native_newArray();
a61af66fc99e Initial load
duke
parents:
diff changeset
184 bool inline_native_getLength();
a61af66fc99e Initial load
duke
parents:
diff changeset
185 bool inline_array_copyOf(bool is_copyOfRange);
169
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 164
diff changeset
186 bool inline_array_equals();
833
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
187 void copy_to_clone(Node* obj, Node* alloc_obj, Node* obj_size, bool is_array, bool card_mark);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
188 bool inline_native_clone(bool is_virtual);
a61af66fc99e Initial load
duke
parents:
diff changeset
189 bool inline_native_Reflection_getCallerClass();
a61af66fc99e Initial load
duke
parents:
diff changeset
190 bool inline_native_AtomicLong_get();
a61af66fc99e Initial load
duke
parents:
diff changeset
191 bool inline_native_AtomicLong_attemptUpdate();
a61af66fc99e Initial load
duke
parents:
diff changeset
192 bool is_method_invoke_or_aux_frame(JVMState* jvms);
a61af66fc99e Initial load
duke
parents:
diff changeset
193 // Helper function for inlining native object hash method
a61af66fc99e Initial load
duke
parents:
diff changeset
194 bool inline_native_hashcode(bool is_virtual, bool is_static);
a61af66fc99e Initial load
duke
parents:
diff changeset
195 bool inline_native_getClass();
a61af66fc99e Initial load
duke
parents:
diff changeset
196
a61af66fc99e Initial load
duke
parents:
diff changeset
197 // Helper functions for inlining arraycopy
a61af66fc99e Initial load
duke
parents:
diff changeset
198 bool inline_arraycopy();
a61af66fc99e Initial load
duke
parents:
diff changeset
199 void generate_arraycopy(const TypePtr* adr_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
200 BasicType basic_elem_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
201 Node* src, Node* src_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
202 Node* dest, Node* dest_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
203 Node* copy_length,
a61af66fc99e Initial load
duke
parents:
diff changeset
204 bool disjoint_bases = false,
a61af66fc99e Initial load
duke
parents:
diff changeset
205 bool length_never_negative = false,
a61af66fc99e Initial load
duke
parents:
diff changeset
206 RegionNode* slow_region = NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
207 AllocateArrayNode* tightly_coupled_allocation(Node* ptr,
a61af66fc99e Initial load
duke
parents:
diff changeset
208 RegionNode* slow_region);
a61af66fc99e Initial load
duke
parents:
diff changeset
209 void generate_clear_array(const TypePtr* adr_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
210 Node* dest,
a61af66fc99e Initial load
duke
parents:
diff changeset
211 BasicType basic_elem_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
212 Node* slice_off,
a61af66fc99e Initial load
duke
parents:
diff changeset
213 Node* slice_len,
a61af66fc99e Initial load
duke
parents:
diff changeset
214 Node* slice_end);
a61af66fc99e Initial load
duke
parents:
diff changeset
215 bool generate_block_arraycopy(const TypePtr* adr_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
216 BasicType basic_elem_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
217 AllocateNode* alloc,
a61af66fc99e Initial load
duke
parents:
diff changeset
218 Node* src, Node* src_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
219 Node* dest, Node* dest_offset,
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
220 Node* dest_size, bool dest_uninitialized);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
221 void generate_slow_arraycopy(const TypePtr* adr_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
222 Node* src, Node* src_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
223 Node* dest, Node* dest_offset,
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
224 Node* copy_length, bool dest_uninitialized);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
225 Node* generate_checkcast_arraycopy(const TypePtr* adr_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
226 Node* dest_elem_klass,
a61af66fc99e Initial load
duke
parents:
diff changeset
227 Node* src, Node* src_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
228 Node* dest, Node* dest_offset,
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
229 Node* copy_length, bool dest_uninitialized);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
230 Node* generate_generic_arraycopy(const TypePtr* adr_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
231 Node* src, Node* src_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
232 Node* dest, Node* dest_offset,
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
233 Node* copy_length, bool dest_uninitialized);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
234 void generate_unchecked_arraycopy(const TypePtr* adr_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
235 BasicType basic_elem_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
236 bool disjoint_bases,
a61af66fc99e Initial load
duke
parents:
diff changeset
237 Node* src, Node* src_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
238 Node* dest, Node* dest_offset,
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
239 Node* copy_length, bool dest_uninitialized);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
240 bool inline_unsafe_CAS(BasicType type);
a61af66fc99e Initial load
duke
parents:
diff changeset
241 bool inline_unsafe_ordered_store(BasicType type);
a61af66fc99e Initial load
duke
parents:
diff changeset
242 bool inline_fp_conversions(vmIntrinsics::ID id);
775
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
243 bool inline_numberOfLeadingZeros(vmIntrinsics::ID id);
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
244 bool inline_numberOfTrailingZeros(vmIntrinsics::ID id);
643
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
245 bool inline_bitCount(vmIntrinsics::ID id);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
246 bool inline_reverseBytes(vmIntrinsics::ID id);
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
247
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
248 bool inline_reference_get();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
249 };
a61af66fc99e Initial load
duke
parents:
diff changeset
250
a61af66fc99e Initial load
duke
parents:
diff changeset
251
a61af66fc99e Initial load
duke
parents:
diff changeset
252 //---------------------------make_vm_intrinsic----------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
253 CallGenerator* Compile::make_vm_intrinsic(ciMethod* m, bool is_virtual) {
a61af66fc99e Initial load
duke
parents:
diff changeset
254 vmIntrinsics::ID id = m->intrinsic_id();
a61af66fc99e Initial load
duke
parents:
diff changeset
255 assert(id != vmIntrinsics::_none, "must be a VM intrinsic");
a61af66fc99e Initial load
duke
parents:
diff changeset
256
a61af66fc99e Initial load
duke
parents:
diff changeset
257 if (DisableIntrinsic[0] != '\0'
a61af66fc99e Initial load
duke
parents:
diff changeset
258 && strstr(DisableIntrinsic, vmIntrinsics::name_at(id)) != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
259 // disabled by a user request on the command line:
a61af66fc99e Initial load
duke
parents:
diff changeset
260 // example: -XX:DisableIntrinsic=_hashCode,_getClass
a61af66fc99e Initial load
duke
parents:
diff changeset
261 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
262 }
a61af66fc99e Initial load
duke
parents:
diff changeset
263
a61af66fc99e Initial load
duke
parents:
diff changeset
264 if (!m->is_loaded()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
265 // do not attempt to inline unloaded methods
a61af66fc99e Initial load
duke
parents:
diff changeset
266 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
267 }
a61af66fc99e Initial load
duke
parents:
diff changeset
268
a61af66fc99e Initial load
duke
parents:
diff changeset
269 // Only a few intrinsics implement a virtual dispatch.
a61af66fc99e Initial load
duke
parents:
diff changeset
270 // They are expensive calls which are also frequently overridden.
a61af66fc99e Initial load
duke
parents:
diff changeset
271 if (is_virtual) {
a61af66fc99e Initial load
duke
parents:
diff changeset
272 switch (id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
273 case vmIntrinsics::_hashCode:
a61af66fc99e Initial load
duke
parents:
diff changeset
274 case vmIntrinsics::_clone:
a61af66fc99e Initial load
duke
parents:
diff changeset
275 // OK, Object.hashCode and Object.clone intrinsics come in both flavors
a61af66fc99e Initial load
duke
parents:
diff changeset
276 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
277 default:
a61af66fc99e Initial load
duke
parents:
diff changeset
278 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
279 }
a61af66fc99e Initial load
duke
parents:
diff changeset
280 }
a61af66fc99e Initial load
duke
parents:
diff changeset
281
a61af66fc99e Initial load
duke
parents:
diff changeset
282 // -XX:-InlineNatives disables nearly all intrinsics:
a61af66fc99e Initial load
duke
parents:
diff changeset
283 if (!InlineNatives) {
a61af66fc99e Initial load
duke
parents:
diff changeset
284 switch (id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
285 case vmIntrinsics::_indexOf:
a61af66fc99e Initial load
duke
parents:
diff changeset
286 case vmIntrinsics::_compareTo:
681
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
287 case vmIntrinsics::_equals:
169
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 164
diff changeset
288 case vmIntrinsics::_equalsC:
0
a61af66fc99e Initial load
duke
parents:
diff changeset
289 break; // InlineNatives does not control String.compareTo
a61af66fc99e Initial load
duke
parents:
diff changeset
290 default:
a61af66fc99e Initial load
duke
parents:
diff changeset
291 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
292 }
a61af66fc99e Initial load
duke
parents:
diff changeset
293 }
a61af66fc99e Initial load
duke
parents:
diff changeset
294
a61af66fc99e Initial load
duke
parents:
diff changeset
295 switch (id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
296 case vmIntrinsics::_compareTo:
a61af66fc99e Initial load
duke
parents:
diff changeset
297 if (!SpecialStringCompareTo) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
298 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
299 case vmIntrinsics::_indexOf:
a61af66fc99e Initial load
duke
parents:
diff changeset
300 if (!SpecialStringIndexOf) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
301 break;
681
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
302 case vmIntrinsics::_equals:
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
303 if (!SpecialStringEquals) return NULL;
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
304 break;
169
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 164
diff changeset
305 case vmIntrinsics::_equalsC:
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 164
diff changeset
306 if (!SpecialArraysEquals) return NULL;
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 164
diff changeset
307 break;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
308 case vmIntrinsics::_arraycopy:
a61af66fc99e Initial load
duke
parents:
diff changeset
309 if (!InlineArrayCopy) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
310 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
311 case vmIntrinsics::_copyMemory:
a61af66fc99e Initial load
duke
parents:
diff changeset
312 if (StubRoutines::unsafe_arraycopy() == NULL) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
313 if (!InlineArrayCopy) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
314 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
315 case vmIntrinsics::_hashCode:
a61af66fc99e Initial load
duke
parents:
diff changeset
316 if (!InlineObjectHash) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
317 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
318 case vmIntrinsics::_clone:
a61af66fc99e Initial load
duke
parents:
diff changeset
319 case vmIntrinsics::_copyOf:
a61af66fc99e Initial load
duke
parents:
diff changeset
320 case vmIntrinsics::_copyOfRange:
a61af66fc99e Initial load
duke
parents:
diff changeset
321 if (!InlineObjectCopy) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
322 // These also use the arraycopy intrinsic mechanism:
a61af66fc99e Initial load
duke
parents:
diff changeset
323 if (!InlineArrayCopy) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
324 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
325 case vmIntrinsics::_checkIndex:
a61af66fc99e Initial load
duke
parents:
diff changeset
326 // We do not intrinsify this. The optimizer does fine with it.
a61af66fc99e Initial load
duke
parents:
diff changeset
327 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
328
a61af66fc99e Initial load
duke
parents:
diff changeset
329 case vmIntrinsics::_get_AtomicLong:
a61af66fc99e Initial load
duke
parents:
diff changeset
330 case vmIntrinsics::_attemptUpdate:
a61af66fc99e Initial load
duke
parents:
diff changeset
331 if (!InlineAtomicLong) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
332 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
333
a61af66fc99e Initial load
duke
parents:
diff changeset
334 case vmIntrinsics::_getCallerClass:
a61af66fc99e Initial load
duke
parents:
diff changeset
335 if (!UseNewReflection) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
336 if (!InlineReflectionGetCallerClass) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
337 if (!JDK_Version::is_gte_jdk14x_version()) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
338 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
339
643
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
340 case vmIntrinsics::_bitCount_i:
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
341 case vmIntrinsics::_bitCount_l:
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
342 if (!UsePopCountInstruction) return NULL;
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
343 break;
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
344
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
345 case vmIntrinsics::_Reference_get:
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
346 // It is only when G1 is enabled that we absolutely
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
347 // need to use the intrinsic version of Reference.get()
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
348 // so that the value in the referent field, if necessary,
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
349 // can be registered by the pre-barrier code.
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
350 if (!UseG1GC) return NULL;
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
351 break;
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
352
0
a61af66fc99e Initial load
duke
parents:
diff changeset
353 default:
856
75596850f863 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 851
diff changeset
354 assert(id <= vmIntrinsics::LAST_COMPILER_INLINE, "caller responsibility");
75596850f863 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 851
diff changeset
355 assert(id != vmIntrinsics::_Object_init && id != vmIntrinsics::_invoke, "enum out of order?");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
356 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
357 }
a61af66fc99e Initial load
duke
parents:
diff changeset
358
a61af66fc99e Initial load
duke
parents:
diff changeset
359 // -XX:-InlineClassNatives disables natives from the Class class.
a61af66fc99e Initial load
duke
parents:
diff changeset
360 // The flag applies to all reflective calls, notably Array.newArray
a61af66fc99e Initial load
duke
parents:
diff changeset
361 // (visible to Java programmers as Array.newInstance).
a61af66fc99e Initial load
duke
parents:
diff changeset
362 if (m->holder()->name() == ciSymbol::java_lang_Class() ||
a61af66fc99e Initial load
duke
parents:
diff changeset
363 m->holder()->name() == ciSymbol::java_lang_reflect_Array()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
364 if (!InlineClassNatives) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
365 }
a61af66fc99e Initial load
duke
parents:
diff changeset
366
a61af66fc99e Initial load
duke
parents:
diff changeset
367 // -XX:-InlineThreadNatives disables natives from the Thread class.
a61af66fc99e Initial load
duke
parents:
diff changeset
368 if (m->holder()->name() == ciSymbol::java_lang_Thread()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
369 if (!InlineThreadNatives) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
370 }
a61af66fc99e Initial load
duke
parents:
diff changeset
371
a61af66fc99e Initial load
duke
parents:
diff changeset
372 // -XX:-InlineMathNatives disables natives from the Math,Float and Double classes.
a61af66fc99e Initial load
duke
parents:
diff changeset
373 if (m->holder()->name() == ciSymbol::java_lang_Math() ||
a61af66fc99e Initial load
duke
parents:
diff changeset
374 m->holder()->name() == ciSymbol::java_lang_Float() ||
a61af66fc99e Initial load
duke
parents:
diff changeset
375 m->holder()->name() == ciSymbol::java_lang_Double()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
376 if (!InlineMathNatives) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
377 }
a61af66fc99e Initial load
duke
parents:
diff changeset
378
a61af66fc99e Initial load
duke
parents:
diff changeset
379 // -XX:-InlineUnsafeOps disables natives from the Unsafe class.
a61af66fc99e Initial load
duke
parents:
diff changeset
380 if (m->holder()->name() == ciSymbol::sun_misc_Unsafe()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
381 if (!InlineUnsafeOps) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
382 }
a61af66fc99e Initial load
duke
parents:
diff changeset
383
a61af66fc99e Initial load
duke
parents:
diff changeset
384 return new LibraryIntrinsic(m, is_virtual, (vmIntrinsics::ID) id);
a61af66fc99e Initial load
duke
parents:
diff changeset
385 }
a61af66fc99e Initial load
duke
parents:
diff changeset
386
a61af66fc99e Initial load
duke
parents:
diff changeset
387 //----------------------register_library_intrinsics-----------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
388 // Initialize this file's data structures, for each Compile instance.
a61af66fc99e Initial load
duke
parents:
diff changeset
389 void Compile::register_library_intrinsics() {
a61af66fc99e Initial load
duke
parents:
diff changeset
390 // Nothing to do here.
a61af66fc99e Initial load
duke
parents:
diff changeset
391 }
a61af66fc99e Initial load
duke
parents:
diff changeset
392
a61af66fc99e Initial load
duke
parents:
diff changeset
393 JVMState* LibraryIntrinsic::generate(JVMState* jvms) {
a61af66fc99e Initial load
duke
parents:
diff changeset
394 LibraryCallKit kit(jvms, this);
a61af66fc99e Initial load
duke
parents:
diff changeset
395 Compile* C = kit.C;
a61af66fc99e Initial load
duke
parents:
diff changeset
396 int nodes = C->unique();
a61af66fc99e Initial load
duke
parents:
diff changeset
397 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
398 if ((PrintIntrinsics || PrintInlining NOT_PRODUCT( || PrintOptoInlining) ) && Verbose) {
a61af66fc99e Initial load
duke
parents:
diff changeset
399 char buf[1000];
a61af66fc99e Initial load
duke
parents:
diff changeset
400 const char* str = vmIntrinsics::short_name_as_C_string(intrinsic_id(), buf, sizeof(buf));
a61af66fc99e Initial load
duke
parents:
diff changeset
401 tty->print_cr("Intrinsic %s", str);
a61af66fc99e Initial load
duke
parents:
diff changeset
402 }
a61af66fc99e Initial load
duke
parents:
diff changeset
403 #endif
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
404
0
a61af66fc99e Initial load
duke
parents:
diff changeset
405 if (kit.try_to_inline()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
406 if (PrintIntrinsics || PrintInlining NOT_PRODUCT( || PrintOptoInlining) ) {
2405
3d58a4983660 7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents: 2385
diff changeset
407 CompileTask::print_inlining(kit.callee(), jvms->depth() - 1, kit.bci(), is_virtual() ? "(intrinsic, virtual)" : "(intrinsic)");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
408 }
a61af66fc99e Initial load
duke
parents:
diff changeset
409 C->gather_intrinsic_statistics(intrinsic_id(), is_virtual(), Compile::_intrinsic_worked);
a61af66fc99e Initial load
duke
parents:
diff changeset
410 if (C->log()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
411 C->log()->elem("intrinsic id='%s'%s nodes='%d'",
a61af66fc99e Initial load
duke
parents:
diff changeset
412 vmIntrinsics::name_at(intrinsic_id()),
a61af66fc99e Initial load
duke
parents:
diff changeset
413 (is_virtual() ? " virtual='1'" : ""),
a61af66fc99e Initial load
duke
parents:
diff changeset
414 C->unique() - nodes);
a61af66fc99e Initial load
duke
parents:
diff changeset
415 }
a61af66fc99e Initial load
duke
parents:
diff changeset
416 return kit.transfer_exceptions_into_jvms();
a61af66fc99e Initial load
duke
parents:
diff changeset
417 }
a61af66fc99e Initial load
duke
parents:
diff changeset
418
a61af66fc99e Initial load
duke
parents:
diff changeset
419 if (PrintIntrinsics) {
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
420 if (jvms->has_method()) {
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
421 // Not a root compile.
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
422 tty->print("Did not inline intrinsic %s%s at bci:%d in",
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
423 vmIntrinsics::name_at(intrinsic_id()),
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
424 (is_virtual() ? " (virtual)" : ""), kit.bci());
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
425 kit.caller()->print_short_name(tty);
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
426 tty->print_cr(" (%d bytes)", kit.caller()->code_size());
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
427 } else {
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
428 // Root compile
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
429 tty->print("Did not generate intrinsic %s%s at bci:%d in",
856
75596850f863 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 851
diff changeset
430 vmIntrinsics::name_at(intrinsic_id()),
75596850f863 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 851
diff changeset
431 (is_virtual() ? " (virtual)" : ""), kit.bci());
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
432 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
433 }
a61af66fc99e Initial load
duke
parents:
diff changeset
434 C->gather_intrinsic_statistics(intrinsic_id(), is_virtual(), Compile::_intrinsic_failed);
a61af66fc99e Initial load
duke
parents:
diff changeset
435 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
436 }
a61af66fc99e Initial load
duke
parents:
diff changeset
437
a61af66fc99e Initial load
duke
parents:
diff changeset
438 bool LibraryCallKit::try_to_inline() {
a61af66fc99e Initial load
duke
parents:
diff changeset
439 // Handle symbolic names for otherwise undistinguished boolean switches:
a61af66fc99e Initial load
duke
parents:
diff changeset
440 const bool is_store = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
441 const bool is_native_ptr = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
442 const bool is_static = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
443
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
444 if (!jvms()->has_method()) {
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
445 // Root JVMState has a null method.
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
446 assert(map()->memory()->Opcode() == Op_Parm, "");
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
447 // Insert the memory aliasing node
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
448 set_all_memory(reset_memory());
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
449 }
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
450 assert(merged_memory(), "");
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
451
0
a61af66fc99e Initial load
duke
parents:
diff changeset
452 switch (intrinsic_id()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
453 case vmIntrinsics::_hashCode:
a61af66fc99e Initial load
duke
parents:
diff changeset
454 return inline_native_hashcode(intrinsic()->is_virtual(), !is_static);
a61af66fc99e Initial load
duke
parents:
diff changeset
455 case vmIntrinsics::_identityHashCode:
a61af66fc99e Initial load
duke
parents:
diff changeset
456 return inline_native_hashcode(/*!virtual*/ false, is_static);
a61af66fc99e Initial load
duke
parents:
diff changeset
457 case vmIntrinsics::_getClass:
a61af66fc99e Initial load
duke
parents:
diff changeset
458 return inline_native_getClass();
a61af66fc99e Initial load
duke
parents:
diff changeset
459
a61af66fc99e Initial load
duke
parents:
diff changeset
460 case vmIntrinsics::_dsin:
a61af66fc99e Initial load
duke
parents:
diff changeset
461 case vmIntrinsics::_dcos:
a61af66fc99e Initial load
duke
parents:
diff changeset
462 case vmIntrinsics::_dtan:
a61af66fc99e Initial load
duke
parents:
diff changeset
463 case vmIntrinsics::_dabs:
a61af66fc99e Initial load
duke
parents:
diff changeset
464 case vmIntrinsics::_datan2:
a61af66fc99e Initial load
duke
parents:
diff changeset
465 case vmIntrinsics::_dsqrt:
a61af66fc99e Initial load
duke
parents:
diff changeset
466 case vmIntrinsics::_dexp:
a61af66fc99e Initial load
duke
parents:
diff changeset
467 case vmIntrinsics::_dlog:
a61af66fc99e Initial load
duke
parents:
diff changeset
468 case vmIntrinsics::_dlog10:
a61af66fc99e Initial load
duke
parents:
diff changeset
469 case vmIntrinsics::_dpow:
a61af66fc99e Initial load
duke
parents:
diff changeset
470 return inline_math_native(intrinsic_id());
a61af66fc99e Initial load
duke
parents:
diff changeset
471
a61af66fc99e Initial load
duke
parents:
diff changeset
472 case vmIntrinsics::_min:
a61af66fc99e Initial load
duke
parents:
diff changeset
473 case vmIntrinsics::_max:
a61af66fc99e Initial load
duke
parents:
diff changeset
474 return inline_min_max(intrinsic_id());
a61af66fc99e Initial load
duke
parents:
diff changeset
475
a61af66fc99e Initial load
duke
parents:
diff changeset
476 case vmIntrinsics::_arraycopy:
a61af66fc99e Initial load
duke
parents:
diff changeset
477 return inline_arraycopy();
a61af66fc99e Initial load
duke
parents:
diff changeset
478
a61af66fc99e Initial load
duke
parents:
diff changeset
479 case vmIntrinsics::_compareTo:
a61af66fc99e Initial load
duke
parents:
diff changeset
480 return inline_string_compareTo();
a61af66fc99e Initial load
duke
parents:
diff changeset
481 case vmIntrinsics::_indexOf:
a61af66fc99e Initial load
duke
parents:
diff changeset
482 return inline_string_indexOf();
681
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
483 case vmIntrinsics::_equals:
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
484 return inline_string_equals();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
485
a61af66fc99e Initial load
duke
parents:
diff changeset
486 case vmIntrinsics::_getObject:
a61af66fc99e Initial load
duke
parents:
diff changeset
487 return inline_unsafe_access(!is_native_ptr, !is_store, T_OBJECT, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
488 case vmIntrinsics::_getBoolean:
a61af66fc99e Initial load
duke
parents:
diff changeset
489 return inline_unsafe_access(!is_native_ptr, !is_store, T_BOOLEAN, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
490 case vmIntrinsics::_getByte:
a61af66fc99e Initial load
duke
parents:
diff changeset
491 return inline_unsafe_access(!is_native_ptr, !is_store, T_BYTE, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
492 case vmIntrinsics::_getShort:
a61af66fc99e Initial load
duke
parents:
diff changeset
493 return inline_unsafe_access(!is_native_ptr, !is_store, T_SHORT, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
494 case vmIntrinsics::_getChar:
a61af66fc99e Initial load
duke
parents:
diff changeset
495 return inline_unsafe_access(!is_native_ptr, !is_store, T_CHAR, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
496 case vmIntrinsics::_getInt:
a61af66fc99e Initial load
duke
parents:
diff changeset
497 return inline_unsafe_access(!is_native_ptr, !is_store, T_INT, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
498 case vmIntrinsics::_getLong:
a61af66fc99e Initial load
duke
parents:
diff changeset
499 return inline_unsafe_access(!is_native_ptr, !is_store, T_LONG, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
500 case vmIntrinsics::_getFloat:
a61af66fc99e Initial load
duke
parents:
diff changeset
501 return inline_unsafe_access(!is_native_ptr, !is_store, T_FLOAT, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
502 case vmIntrinsics::_getDouble:
a61af66fc99e Initial load
duke
parents:
diff changeset
503 return inline_unsafe_access(!is_native_ptr, !is_store, T_DOUBLE, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
504
a61af66fc99e Initial load
duke
parents:
diff changeset
505 case vmIntrinsics::_putObject:
a61af66fc99e Initial load
duke
parents:
diff changeset
506 return inline_unsafe_access(!is_native_ptr, is_store, T_OBJECT, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
507 case vmIntrinsics::_putBoolean:
a61af66fc99e Initial load
duke
parents:
diff changeset
508 return inline_unsafe_access(!is_native_ptr, is_store, T_BOOLEAN, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
509 case vmIntrinsics::_putByte:
a61af66fc99e Initial load
duke
parents:
diff changeset
510 return inline_unsafe_access(!is_native_ptr, is_store, T_BYTE, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
511 case vmIntrinsics::_putShort:
a61af66fc99e Initial load
duke
parents:
diff changeset
512 return inline_unsafe_access(!is_native_ptr, is_store, T_SHORT, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
513 case vmIntrinsics::_putChar:
a61af66fc99e Initial load
duke
parents:
diff changeset
514 return inline_unsafe_access(!is_native_ptr, is_store, T_CHAR, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
515 case vmIntrinsics::_putInt:
a61af66fc99e Initial load
duke
parents:
diff changeset
516 return inline_unsafe_access(!is_native_ptr, is_store, T_INT, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
517 case vmIntrinsics::_putLong:
a61af66fc99e Initial load
duke
parents:
diff changeset
518 return inline_unsafe_access(!is_native_ptr, is_store, T_LONG, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
519 case vmIntrinsics::_putFloat:
a61af66fc99e Initial load
duke
parents:
diff changeset
520 return inline_unsafe_access(!is_native_ptr, is_store, T_FLOAT, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
521 case vmIntrinsics::_putDouble:
a61af66fc99e Initial load
duke
parents:
diff changeset
522 return inline_unsafe_access(!is_native_ptr, is_store, T_DOUBLE, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
523
a61af66fc99e Initial load
duke
parents:
diff changeset
524 case vmIntrinsics::_getByte_raw:
a61af66fc99e Initial load
duke
parents:
diff changeset
525 return inline_unsafe_access(is_native_ptr, !is_store, T_BYTE, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
526 case vmIntrinsics::_getShort_raw:
a61af66fc99e Initial load
duke
parents:
diff changeset
527 return inline_unsafe_access(is_native_ptr, !is_store, T_SHORT, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
528 case vmIntrinsics::_getChar_raw:
a61af66fc99e Initial load
duke
parents:
diff changeset
529 return inline_unsafe_access(is_native_ptr, !is_store, T_CHAR, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
530 case vmIntrinsics::_getInt_raw:
a61af66fc99e Initial load
duke
parents:
diff changeset
531 return inline_unsafe_access(is_native_ptr, !is_store, T_INT, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
532 case vmIntrinsics::_getLong_raw:
a61af66fc99e Initial load
duke
parents:
diff changeset
533 return inline_unsafe_access(is_native_ptr, !is_store, T_LONG, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
534 case vmIntrinsics::_getFloat_raw:
a61af66fc99e Initial load
duke
parents:
diff changeset
535 return inline_unsafe_access(is_native_ptr, !is_store, T_FLOAT, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
536 case vmIntrinsics::_getDouble_raw:
a61af66fc99e Initial load
duke
parents:
diff changeset
537 return inline_unsafe_access(is_native_ptr, !is_store, T_DOUBLE, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
538 case vmIntrinsics::_getAddress_raw:
a61af66fc99e Initial load
duke
parents:
diff changeset
539 return inline_unsafe_access(is_native_ptr, !is_store, T_ADDRESS, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
540
a61af66fc99e Initial load
duke
parents:
diff changeset
541 case vmIntrinsics::_putByte_raw:
a61af66fc99e Initial load
duke
parents:
diff changeset
542 return inline_unsafe_access(is_native_ptr, is_store, T_BYTE, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
543 case vmIntrinsics::_putShort_raw:
a61af66fc99e Initial load
duke
parents:
diff changeset
544 return inline_unsafe_access(is_native_ptr, is_store, T_SHORT, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
545 case vmIntrinsics::_putChar_raw:
a61af66fc99e Initial load
duke
parents:
diff changeset
546 return inline_unsafe_access(is_native_ptr, is_store, T_CHAR, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
547 case vmIntrinsics::_putInt_raw:
a61af66fc99e Initial load
duke
parents:
diff changeset
548 return inline_unsafe_access(is_native_ptr, is_store, T_INT, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
549 case vmIntrinsics::_putLong_raw:
a61af66fc99e Initial load
duke
parents:
diff changeset
550 return inline_unsafe_access(is_native_ptr, is_store, T_LONG, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
551 case vmIntrinsics::_putFloat_raw:
a61af66fc99e Initial load
duke
parents:
diff changeset
552 return inline_unsafe_access(is_native_ptr, is_store, T_FLOAT, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
553 case vmIntrinsics::_putDouble_raw:
a61af66fc99e Initial load
duke
parents:
diff changeset
554 return inline_unsafe_access(is_native_ptr, is_store, T_DOUBLE, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
555 case vmIntrinsics::_putAddress_raw:
a61af66fc99e Initial load
duke
parents:
diff changeset
556 return inline_unsafe_access(is_native_ptr, is_store, T_ADDRESS, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
557
a61af66fc99e Initial load
duke
parents:
diff changeset
558 case vmIntrinsics::_getObjectVolatile:
a61af66fc99e Initial load
duke
parents:
diff changeset
559 return inline_unsafe_access(!is_native_ptr, !is_store, T_OBJECT, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
560 case vmIntrinsics::_getBooleanVolatile:
a61af66fc99e Initial load
duke
parents:
diff changeset
561 return inline_unsafe_access(!is_native_ptr, !is_store, T_BOOLEAN, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
562 case vmIntrinsics::_getByteVolatile:
a61af66fc99e Initial load
duke
parents:
diff changeset
563 return inline_unsafe_access(!is_native_ptr, !is_store, T_BYTE, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
564 case vmIntrinsics::_getShortVolatile:
a61af66fc99e Initial load
duke
parents:
diff changeset
565 return inline_unsafe_access(!is_native_ptr, !is_store, T_SHORT, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
566 case vmIntrinsics::_getCharVolatile:
a61af66fc99e Initial load
duke
parents:
diff changeset
567 return inline_unsafe_access(!is_native_ptr, !is_store, T_CHAR, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
568 case vmIntrinsics::_getIntVolatile:
a61af66fc99e Initial load
duke
parents:
diff changeset
569 return inline_unsafe_access(!is_native_ptr, !is_store, T_INT, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
570 case vmIntrinsics::_getLongVolatile:
a61af66fc99e Initial load
duke
parents:
diff changeset
571 return inline_unsafe_access(!is_native_ptr, !is_store, T_LONG, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
572 case vmIntrinsics::_getFloatVolatile:
a61af66fc99e Initial load
duke
parents:
diff changeset
573 return inline_unsafe_access(!is_native_ptr, !is_store, T_FLOAT, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
574 case vmIntrinsics::_getDoubleVolatile:
a61af66fc99e Initial load
duke
parents:
diff changeset
575 return inline_unsafe_access(!is_native_ptr, !is_store, T_DOUBLE, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
576
a61af66fc99e Initial load
duke
parents:
diff changeset
577 case vmIntrinsics::_putObjectVolatile:
a61af66fc99e Initial load
duke
parents:
diff changeset
578 return inline_unsafe_access(!is_native_ptr, is_store, T_OBJECT, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
579 case vmIntrinsics::_putBooleanVolatile:
a61af66fc99e Initial load
duke
parents:
diff changeset
580 return inline_unsafe_access(!is_native_ptr, is_store, T_BOOLEAN, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
581 case vmIntrinsics::_putByteVolatile:
a61af66fc99e Initial load
duke
parents:
diff changeset
582 return inline_unsafe_access(!is_native_ptr, is_store, T_BYTE, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
583 case vmIntrinsics::_putShortVolatile:
a61af66fc99e Initial load
duke
parents:
diff changeset
584 return inline_unsafe_access(!is_native_ptr, is_store, T_SHORT, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
585 case vmIntrinsics::_putCharVolatile:
a61af66fc99e Initial load
duke
parents:
diff changeset
586 return inline_unsafe_access(!is_native_ptr, is_store, T_CHAR, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
587 case vmIntrinsics::_putIntVolatile:
a61af66fc99e Initial load
duke
parents:
diff changeset
588 return inline_unsafe_access(!is_native_ptr, is_store, T_INT, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
589 case vmIntrinsics::_putLongVolatile:
a61af66fc99e Initial load
duke
parents:
diff changeset
590 return inline_unsafe_access(!is_native_ptr, is_store, T_LONG, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
591 case vmIntrinsics::_putFloatVolatile:
a61af66fc99e Initial load
duke
parents:
diff changeset
592 return inline_unsafe_access(!is_native_ptr, is_store, T_FLOAT, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
593 case vmIntrinsics::_putDoubleVolatile:
a61af66fc99e Initial load
duke
parents:
diff changeset
594 return inline_unsafe_access(!is_native_ptr, is_store, T_DOUBLE, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
595
a61af66fc99e Initial load
duke
parents:
diff changeset
596 case vmIntrinsics::_prefetchRead:
a61af66fc99e Initial load
duke
parents:
diff changeset
597 return inline_unsafe_prefetch(!is_native_ptr, !is_store, !is_static);
a61af66fc99e Initial load
duke
parents:
diff changeset
598 case vmIntrinsics::_prefetchWrite:
a61af66fc99e Initial load
duke
parents:
diff changeset
599 return inline_unsafe_prefetch(!is_native_ptr, is_store, !is_static);
a61af66fc99e Initial load
duke
parents:
diff changeset
600 case vmIntrinsics::_prefetchReadStatic:
a61af66fc99e Initial load
duke
parents:
diff changeset
601 return inline_unsafe_prefetch(!is_native_ptr, !is_store, is_static);
a61af66fc99e Initial load
duke
parents:
diff changeset
602 case vmIntrinsics::_prefetchWriteStatic:
a61af66fc99e Initial load
duke
parents:
diff changeset
603 return inline_unsafe_prefetch(!is_native_ptr, is_store, is_static);
a61af66fc99e Initial load
duke
parents:
diff changeset
604
a61af66fc99e Initial load
duke
parents:
diff changeset
605 case vmIntrinsics::_compareAndSwapObject:
a61af66fc99e Initial load
duke
parents:
diff changeset
606 return inline_unsafe_CAS(T_OBJECT);
a61af66fc99e Initial load
duke
parents:
diff changeset
607 case vmIntrinsics::_compareAndSwapInt:
a61af66fc99e Initial load
duke
parents:
diff changeset
608 return inline_unsafe_CAS(T_INT);
a61af66fc99e Initial load
duke
parents:
diff changeset
609 case vmIntrinsics::_compareAndSwapLong:
a61af66fc99e Initial load
duke
parents:
diff changeset
610 return inline_unsafe_CAS(T_LONG);
a61af66fc99e Initial load
duke
parents:
diff changeset
611
a61af66fc99e Initial load
duke
parents:
diff changeset
612 case vmIntrinsics::_putOrderedObject:
a61af66fc99e Initial load
duke
parents:
diff changeset
613 return inline_unsafe_ordered_store(T_OBJECT);
a61af66fc99e Initial load
duke
parents:
diff changeset
614 case vmIntrinsics::_putOrderedInt:
a61af66fc99e Initial load
duke
parents:
diff changeset
615 return inline_unsafe_ordered_store(T_INT);
a61af66fc99e Initial load
duke
parents:
diff changeset
616 case vmIntrinsics::_putOrderedLong:
a61af66fc99e Initial load
duke
parents:
diff changeset
617 return inline_unsafe_ordered_store(T_LONG);
a61af66fc99e Initial load
duke
parents:
diff changeset
618
a61af66fc99e Initial load
duke
parents:
diff changeset
619 case vmIntrinsics::_currentThread:
a61af66fc99e Initial load
duke
parents:
diff changeset
620 return inline_native_currentThread();
a61af66fc99e Initial load
duke
parents:
diff changeset
621 case vmIntrinsics::_isInterrupted:
a61af66fc99e Initial load
duke
parents:
diff changeset
622 return inline_native_isInterrupted();
a61af66fc99e Initial load
duke
parents:
diff changeset
623
a61af66fc99e Initial load
duke
parents:
diff changeset
624 case vmIntrinsics::_currentTimeMillis:
a61af66fc99e Initial load
duke
parents:
diff changeset
625 return inline_native_time_funcs(false);
a61af66fc99e Initial load
duke
parents:
diff changeset
626 case vmIntrinsics::_nanoTime:
a61af66fc99e Initial load
duke
parents:
diff changeset
627 return inline_native_time_funcs(true);
a61af66fc99e Initial load
duke
parents:
diff changeset
628 case vmIntrinsics::_allocateInstance:
a61af66fc99e Initial load
duke
parents:
diff changeset
629 return inline_unsafe_allocate();
a61af66fc99e Initial load
duke
parents:
diff changeset
630 case vmIntrinsics::_copyMemory:
a61af66fc99e Initial load
duke
parents:
diff changeset
631 return inline_unsafe_copyMemory();
a61af66fc99e Initial load
duke
parents:
diff changeset
632 case vmIntrinsics::_newArray:
a61af66fc99e Initial load
duke
parents:
diff changeset
633 return inline_native_newArray();
a61af66fc99e Initial load
duke
parents:
diff changeset
634 case vmIntrinsics::_getLength:
a61af66fc99e Initial load
duke
parents:
diff changeset
635 return inline_native_getLength();
a61af66fc99e Initial load
duke
parents:
diff changeset
636 case vmIntrinsics::_copyOf:
a61af66fc99e Initial load
duke
parents:
diff changeset
637 return inline_array_copyOf(false);
a61af66fc99e Initial load
duke
parents:
diff changeset
638 case vmIntrinsics::_copyOfRange:
a61af66fc99e Initial load
duke
parents:
diff changeset
639 return inline_array_copyOf(true);
169
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 164
diff changeset
640 case vmIntrinsics::_equalsC:
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 164
diff changeset
641 return inline_array_equals();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
642 case vmIntrinsics::_clone:
a61af66fc99e Initial load
duke
parents:
diff changeset
643 return inline_native_clone(intrinsic()->is_virtual());
a61af66fc99e Initial load
duke
parents:
diff changeset
644
a61af66fc99e Initial load
duke
parents:
diff changeset
645 case vmIntrinsics::_isAssignableFrom:
a61af66fc99e Initial load
duke
parents:
diff changeset
646 return inline_native_subtype_check();
a61af66fc99e Initial load
duke
parents:
diff changeset
647
a61af66fc99e Initial load
duke
parents:
diff changeset
648 case vmIntrinsics::_isInstance:
a61af66fc99e Initial load
duke
parents:
diff changeset
649 case vmIntrinsics::_getModifiers:
a61af66fc99e Initial load
duke
parents:
diff changeset
650 case vmIntrinsics::_isInterface:
a61af66fc99e Initial load
duke
parents:
diff changeset
651 case vmIntrinsics::_isArray:
a61af66fc99e Initial load
duke
parents:
diff changeset
652 case vmIntrinsics::_isPrimitive:
a61af66fc99e Initial load
duke
parents:
diff changeset
653 case vmIntrinsics::_getSuperclass:
a61af66fc99e Initial load
duke
parents:
diff changeset
654 case vmIntrinsics::_getComponentType:
a61af66fc99e Initial load
duke
parents:
diff changeset
655 case vmIntrinsics::_getClassAccessFlags:
a61af66fc99e Initial load
duke
parents:
diff changeset
656 return inline_native_Class_query(intrinsic_id());
a61af66fc99e Initial load
duke
parents:
diff changeset
657
a61af66fc99e Initial load
duke
parents:
diff changeset
658 case vmIntrinsics::_floatToRawIntBits:
a61af66fc99e Initial load
duke
parents:
diff changeset
659 case vmIntrinsics::_floatToIntBits:
a61af66fc99e Initial load
duke
parents:
diff changeset
660 case vmIntrinsics::_intBitsToFloat:
a61af66fc99e Initial load
duke
parents:
diff changeset
661 case vmIntrinsics::_doubleToRawLongBits:
a61af66fc99e Initial load
duke
parents:
diff changeset
662 case vmIntrinsics::_doubleToLongBits:
a61af66fc99e Initial load
duke
parents:
diff changeset
663 case vmIntrinsics::_longBitsToDouble:
a61af66fc99e Initial load
duke
parents:
diff changeset
664 return inline_fp_conversions(intrinsic_id());
a61af66fc99e Initial load
duke
parents:
diff changeset
665
775
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
666 case vmIntrinsics::_numberOfLeadingZeros_i:
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
667 case vmIntrinsics::_numberOfLeadingZeros_l:
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
668 return inline_numberOfLeadingZeros(intrinsic_id());
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
669
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
670 case vmIntrinsics::_numberOfTrailingZeros_i:
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
671 case vmIntrinsics::_numberOfTrailingZeros_l:
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
672 return inline_numberOfTrailingZeros(intrinsic_id());
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
673
643
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
674 case vmIntrinsics::_bitCount_i:
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
675 case vmIntrinsics::_bitCount_l:
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
676 return inline_bitCount(intrinsic_id());
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
677
0
a61af66fc99e Initial load
duke
parents:
diff changeset
678 case vmIntrinsics::_reverseBytes_i:
a61af66fc99e Initial load
duke
parents:
diff changeset
679 case vmIntrinsics::_reverseBytes_l:
1396
d7f654633cfe 6946040: add intrinsic for short and char reverseBytes
never
parents: 1152
diff changeset
680 case vmIntrinsics::_reverseBytes_s:
d7f654633cfe 6946040: add intrinsic for short and char reverseBytes
never
parents: 1152
diff changeset
681 case vmIntrinsics::_reverseBytes_c:
0
a61af66fc99e Initial load
duke
parents:
diff changeset
682 return inline_reverseBytes((vmIntrinsics::ID) intrinsic_id());
a61af66fc99e Initial load
duke
parents:
diff changeset
683
a61af66fc99e Initial load
duke
parents:
diff changeset
684 case vmIntrinsics::_get_AtomicLong:
a61af66fc99e Initial load
duke
parents:
diff changeset
685 return inline_native_AtomicLong_get();
a61af66fc99e Initial load
duke
parents:
diff changeset
686 case vmIntrinsics::_attemptUpdate:
a61af66fc99e Initial load
duke
parents:
diff changeset
687 return inline_native_AtomicLong_attemptUpdate();
a61af66fc99e Initial load
duke
parents:
diff changeset
688
a61af66fc99e Initial load
duke
parents:
diff changeset
689 case vmIntrinsics::_getCallerClass:
a61af66fc99e Initial load
duke
parents:
diff changeset
690 return inline_native_Reflection_getCallerClass();
a61af66fc99e Initial load
duke
parents:
diff changeset
691
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
692 case vmIntrinsics::_Reference_get:
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
693 return inline_reference_get();
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
694
0
a61af66fc99e Initial load
duke
parents:
diff changeset
695 default:
a61af66fc99e Initial load
duke
parents:
diff changeset
696 // If you get here, it may be that someone has added a new intrinsic
a61af66fc99e Initial load
duke
parents:
diff changeset
697 // to the list in vmSymbols.hpp without implementing it here.
a61af66fc99e Initial load
duke
parents:
diff changeset
698 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
699 if ((PrintMiscellaneous && (Verbose || WizardMode)) || PrintOpto) {
a61af66fc99e Initial load
duke
parents:
diff changeset
700 tty->print_cr("*** Warning: Unimplemented intrinsic %s(%d)",
a61af66fc99e Initial load
duke
parents:
diff changeset
701 vmIntrinsics::name_at(intrinsic_id()), intrinsic_id());
a61af66fc99e Initial load
duke
parents:
diff changeset
702 }
a61af66fc99e Initial load
duke
parents:
diff changeset
703 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
704 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
705 }
a61af66fc99e Initial load
duke
parents:
diff changeset
706 }
a61af66fc99e Initial load
duke
parents:
diff changeset
707
a61af66fc99e Initial load
duke
parents:
diff changeset
708 //------------------------------push_result------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
709 // Helper function for finishing intrinsics.
a61af66fc99e Initial load
duke
parents:
diff changeset
710 void LibraryCallKit::push_result(RegionNode* region, PhiNode* value) {
a61af66fc99e Initial load
duke
parents:
diff changeset
711 record_for_igvn(region);
a61af66fc99e Initial load
duke
parents:
diff changeset
712 set_control(_gvn.transform(region));
a61af66fc99e Initial load
duke
parents:
diff changeset
713 BasicType value_type = value->type()->basic_type();
a61af66fc99e Initial load
duke
parents:
diff changeset
714 push_node(value_type, _gvn.transform(value));
a61af66fc99e Initial load
duke
parents:
diff changeset
715 }
a61af66fc99e Initial load
duke
parents:
diff changeset
716
a61af66fc99e Initial load
duke
parents:
diff changeset
717 //------------------------------generate_guard---------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
718 // Helper function for generating guarded fast-slow graph structures.
a61af66fc99e Initial load
duke
parents:
diff changeset
719 // The given 'test', if true, guards a slow path. If the test fails
a61af66fc99e Initial load
duke
parents:
diff changeset
720 // then a fast path can be taken. (We generally hope it fails.)
a61af66fc99e Initial load
duke
parents:
diff changeset
721 // In all cases, GraphKit::control() is updated to the fast path.
a61af66fc99e Initial load
duke
parents:
diff changeset
722 // The returned value represents the control for the slow path.
a61af66fc99e Initial load
duke
parents:
diff changeset
723 // The return value is never 'top'; it is either a valid control
a61af66fc99e Initial load
duke
parents:
diff changeset
724 // or NULL if it is obvious that the slow path can never be taken.
a61af66fc99e Initial load
duke
parents:
diff changeset
725 // Also, if region and the slow control are not NULL, the slow edge
a61af66fc99e Initial load
duke
parents:
diff changeset
726 // is appended to the region.
a61af66fc99e Initial load
duke
parents:
diff changeset
727 Node* LibraryCallKit::generate_guard(Node* test, RegionNode* region, float true_prob) {
a61af66fc99e Initial load
duke
parents:
diff changeset
728 if (stopped()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
729 // Already short circuited.
a61af66fc99e Initial load
duke
parents:
diff changeset
730 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
731 }
a61af66fc99e Initial load
duke
parents:
diff changeset
732
a61af66fc99e Initial load
duke
parents:
diff changeset
733 // Build an if node and its projections.
a61af66fc99e Initial load
duke
parents:
diff changeset
734 // If test is true we take the slow path, which we assume is uncommon.
a61af66fc99e Initial load
duke
parents:
diff changeset
735 if (_gvn.type(test) == TypeInt::ZERO) {
a61af66fc99e Initial load
duke
parents:
diff changeset
736 // The slow branch is never taken. No need to build this guard.
a61af66fc99e Initial load
duke
parents:
diff changeset
737 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
738 }
a61af66fc99e Initial load
duke
parents:
diff changeset
739
a61af66fc99e Initial load
duke
parents:
diff changeset
740 IfNode* iff = create_and_map_if(control(), test, true_prob, COUNT_UNKNOWN);
a61af66fc99e Initial load
duke
parents:
diff changeset
741
a61af66fc99e Initial load
duke
parents:
diff changeset
742 Node* if_slow = _gvn.transform( new (C, 1) IfTrueNode(iff) );
a61af66fc99e Initial load
duke
parents:
diff changeset
743 if (if_slow == top()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
744 // The slow branch is never taken. No need to build this guard.
a61af66fc99e Initial load
duke
parents:
diff changeset
745 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
746 }
a61af66fc99e Initial load
duke
parents:
diff changeset
747
a61af66fc99e Initial load
duke
parents:
diff changeset
748 if (region != NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
749 region->add_req(if_slow);
a61af66fc99e Initial load
duke
parents:
diff changeset
750
a61af66fc99e Initial load
duke
parents:
diff changeset
751 Node* if_fast = _gvn.transform( new (C, 1) IfFalseNode(iff) );
a61af66fc99e Initial load
duke
parents:
diff changeset
752 set_control(if_fast);
a61af66fc99e Initial load
duke
parents:
diff changeset
753
a61af66fc99e Initial load
duke
parents:
diff changeset
754 return if_slow;
a61af66fc99e Initial load
duke
parents:
diff changeset
755 }
a61af66fc99e Initial load
duke
parents:
diff changeset
756
a61af66fc99e Initial load
duke
parents:
diff changeset
757 inline Node* LibraryCallKit::generate_slow_guard(Node* test, RegionNode* region) {
a61af66fc99e Initial load
duke
parents:
diff changeset
758 return generate_guard(test, region, PROB_UNLIKELY_MAG(3));
a61af66fc99e Initial load
duke
parents:
diff changeset
759 }
a61af66fc99e Initial load
duke
parents:
diff changeset
760 inline Node* LibraryCallKit::generate_fair_guard(Node* test, RegionNode* region) {
a61af66fc99e Initial load
duke
parents:
diff changeset
761 return generate_guard(test, region, PROB_FAIR);
a61af66fc99e Initial load
duke
parents:
diff changeset
762 }
a61af66fc99e Initial load
duke
parents:
diff changeset
763
a61af66fc99e Initial load
duke
parents:
diff changeset
764 inline Node* LibraryCallKit::generate_negative_guard(Node* index, RegionNode* region,
a61af66fc99e Initial load
duke
parents:
diff changeset
765 Node* *pos_index) {
a61af66fc99e Initial load
duke
parents:
diff changeset
766 if (stopped())
a61af66fc99e Initial load
duke
parents:
diff changeset
767 return NULL; // already stopped
a61af66fc99e Initial load
duke
parents:
diff changeset
768 if (_gvn.type(index)->higher_equal(TypeInt::POS)) // [0,maxint]
a61af66fc99e Initial load
duke
parents:
diff changeset
769 return NULL; // index is already adequately typed
a61af66fc99e Initial load
duke
parents:
diff changeset
770 Node* cmp_lt = _gvn.transform( new (C, 3) CmpINode(index, intcon(0)) );
a61af66fc99e Initial load
duke
parents:
diff changeset
771 Node* bol_lt = _gvn.transform( new (C, 2) BoolNode(cmp_lt, BoolTest::lt) );
a61af66fc99e Initial load
duke
parents:
diff changeset
772 Node* is_neg = generate_guard(bol_lt, region, PROB_MIN);
a61af66fc99e Initial load
duke
parents:
diff changeset
773 if (is_neg != NULL && pos_index != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
774 // Emulate effect of Parse::adjust_map_after_if.
a61af66fc99e Initial load
duke
parents:
diff changeset
775 Node* ccast = new (C, 2) CastIINode(index, TypeInt::POS);
a61af66fc99e Initial load
duke
parents:
diff changeset
776 ccast->set_req(0, control());
a61af66fc99e Initial load
duke
parents:
diff changeset
777 (*pos_index) = _gvn.transform(ccast);
a61af66fc99e Initial load
duke
parents:
diff changeset
778 }
a61af66fc99e Initial load
duke
parents:
diff changeset
779 return is_neg;
a61af66fc99e Initial load
duke
parents:
diff changeset
780 }
a61af66fc99e Initial load
duke
parents:
diff changeset
781
a61af66fc99e Initial load
duke
parents:
diff changeset
782 inline Node* LibraryCallKit::generate_nonpositive_guard(Node* index, bool never_negative,
a61af66fc99e Initial load
duke
parents:
diff changeset
783 Node* *pos_index) {
a61af66fc99e Initial load
duke
parents:
diff changeset
784 if (stopped())
a61af66fc99e Initial load
duke
parents:
diff changeset
785 return NULL; // already stopped
a61af66fc99e Initial load
duke
parents:
diff changeset
786 if (_gvn.type(index)->higher_equal(TypeInt::POS1)) // [1,maxint]
a61af66fc99e Initial load
duke
parents:
diff changeset
787 return NULL; // index is already adequately typed
a61af66fc99e Initial load
duke
parents:
diff changeset
788 Node* cmp_le = _gvn.transform( new (C, 3) CmpINode(index, intcon(0)) );
a61af66fc99e Initial load
duke
parents:
diff changeset
789 BoolTest::mask le_or_eq = (never_negative ? BoolTest::eq : BoolTest::le);
a61af66fc99e Initial load
duke
parents:
diff changeset
790 Node* bol_le = _gvn.transform( new (C, 2) BoolNode(cmp_le, le_or_eq) );
a61af66fc99e Initial load
duke
parents:
diff changeset
791 Node* is_notp = generate_guard(bol_le, NULL, PROB_MIN);
a61af66fc99e Initial load
duke
parents:
diff changeset
792 if (is_notp != NULL && pos_index != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
793 // Emulate effect of Parse::adjust_map_after_if.
a61af66fc99e Initial load
duke
parents:
diff changeset
794 Node* ccast = new (C, 2) CastIINode(index, TypeInt::POS1);
a61af66fc99e Initial load
duke
parents:
diff changeset
795 ccast->set_req(0, control());
a61af66fc99e Initial load
duke
parents:
diff changeset
796 (*pos_index) = _gvn.transform(ccast);
a61af66fc99e Initial load
duke
parents:
diff changeset
797 }
a61af66fc99e Initial load
duke
parents:
diff changeset
798 return is_notp;
a61af66fc99e Initial load
duke
parents:
diff changeset
799 }
a61af66fc99e Initial load
duke
parents:
diff changeset
800
a61af66fc99e Initial load
duke
parents:
diff changeset
801 // Make sure that 'position' is a valid limit index, in [0..length].
a61af66fc99e Initial load
duke
parents:
diff changeset
802 // There are two equivalent plans for checking this:
a61af66fc99e Initial load
duke
parents:
diff changeset
803 // A. (offset + copyLength) unsigned<= arrayLength
a61af66fc99e Initial load
duke
parents:
diff changeset
804 // B. offset <= (arrayLength - copyLength)
a61af66fc99e Initial load
duke
parents:
diff changeset
805 // We require that all of the values above, except for the sum and
a61af66fc99e Initial load
duke
parents:
diff changeset
806 // difference, are already known to be non-negative.
a61af66fc99e Initial load
duke
parents:
diff changeset
807 // Plan A is robust in the face of overflow, if offset and copyLength
a61af66fc99e Initial load
duke
parents:
diff changeset
808 // are both hugely positive.
a61af66fc99e Initial load
duke
parents:
diff changeset
809 //
a61af66fc99e Initial load
duke
parents:
diff changeset
810 // Plan B is less direct and intuitive, but it does not overflow at
a61af66fc99e Initial load
duke
parents:
diff changeset
811 // all, since the difference of two non-negatives is always
a61af66fc99e Initial load
duke
parents:
diff changeset
812 // representable. Whenever Java methods must perform the equivalent
a61af66fc99e Initial load
duke
parents:
diff changeset
813 // check they generally use Plan B instead of Plan A.
a61af66fc99e Initial load
duke
parents:
diff changeset
814 // For the moment we use Plan A.
a61af66fc99e Initial load
duke
parents:
diff changeset
815 inline Node* LibraryCallKit::generate_limit_guard(Node* offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
816 Node* subseq_length,
a61af66fc99e Initial load
duke
parents:
diff changeset
817 Node* array_length,
a61af66fc99e Initial load
duke
parents:
diff changeset
818 RegionNode* region) {
a61af66fc99e Initial load
duke
parents:
diff changeset
819 if (stopped())
a61af66fc99e Initial load
duke
parents:
diff changeset
820 return NULL; // already stopped
a61af66fc99e Initial load
duke
parents:
diff changeset
821 bool zero_offset = _gvn.type(offset) == TypeInt::ZERO;
a61af66fc99e Initial load
duke
parents:
diff changeset
822 if (zero_offset && _gvn.eqv_uncast(subseq_length, array_length))
a61af66fc99e Initial load
duke
parents:
diff changeset
823 return NULL; // common case of whole-array copy
a61af66fc99e Initial load
duke
parents:
diff changeset
824 Node* last = subseq_length;
a61af66fc99e Initial load
duke
parents:
diff changeset
825 if (!zero_offset) // last += offset
a61af66fc99e Initial load
duke
parents:
diff changeset
826 last = _gvn.transform( new (C, 3) AddINode(last, offset));
a61af66fc99e Initial load
duke
parents:
diff changeset
827 Node* cmp_lt = _gvn.transform( new (C, 3) CmpUNode(array_length, last) );
a61af66fc99e Initial load
duke
parents:
diff changeset
828 Node* bol_lt = _gvn.transform( new (C, 2) BoolNode(cmp_lt, BoolTest::lt) );
a61af66fc99e Initial load
duke
parents:
diff changeset
829 Node* is_over = generate_guard(bol_lt, region, PROB_MIN);
a61af66fc99e Initial load
duke
parents:
diff changeset
830 return is_over;
a61af66fc99e Initial load
duke
parents:
diff changeset
831 }
a61af66fc99e Initial load
duke
parents:
diff changeset
832
a61af66fc99e Initial load
duke
parents:
diff changeset
833
a61af66fc99e Initial load
duke
parents:
diff changeset
834 //--------------------------generate_current_thread--------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
835 Node* LibraryCallKit::generate_current_thread(Node* &tls_output) {
a61af66fc99e Initial load
duke
parents:
diff changeset
836 ciKlass* thread_klass = env()->Thread_klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
837 const Type* thread_type = TypeOopPtr::make_from_klass(thread_klass)->cast_to_ptr_type(TypePtr::NotNull);
a61af66fc99e Initial load
duke
parents:
diff changeset
838 Node* thread = _gvn.transform(new (C, 1) ThreadLocalNode());
a61af66fc99e Initial load
duke
parents:
diff changeset
839 Node* p = basic_plus_adr(top()/*!oop*/, thread, in_bytes(JavaThread::threadObj_offset()));
a61af66fc99e Initial load
duke
parents:
diff changeset
840 Node* threadObj = make_load(NULL, p, thread_type, T_OBJECT);
a61af66fc99e Initial load
duke
parents:
diff changeset
841 tls_output = thread;
a61af66fc99e Initial load
duke
parents:
diff changeset
842 return threadObj;
a61af66fc99e Initial load
duke
parents:
diff changeset
843 }
a61af66fc99e Initial load
duke
parents:
diff changeset
844
a61af66fc99e Initial load
duke
parents:
diff changeset
845
986
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
846 //------------------------------make_string_method_node------------------------
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
847 // Helper method for String intrinsic finctions.
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
848 Node* LibraryCallKit::make_string_method_node(int opcode, Node* str1, Node* cnt1, Node* str2, Node* cnt2) {
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
849 const int value_offset = java_lang_String::value_offset_in_bytes();
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
850 const int count_offset = java_lang_String::count_offset_in_bytes();
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
851 const int offset_offset = java_lang_String::offset_offset_in_bytes();
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
852
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
853 Node* no_ctrl = NULL;
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
854
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
855 ciInstanceKlass* klass = env()->String_klass();
1496
e8e83be27dd7 6951190: assert(!klass_is_exact(),"only non-exact klass") while building JDK
never
parents: 1396
diff changeset
856 const TypeOopPtr* string_type = TypeOopPtr::make_from_klass(klass);
986
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
857
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
858 const TypeAryPtr* value_type =
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
859 TypeAryPtr::make(TypePtr::NotNull,
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
860 TypeAry::make(TypeInt::CHAR,TypeInt::POS),
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
861 ciTypeArrayKlass::make(T_CHAR), true, 0);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
862
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
863 // Get start addr of string and substring
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
864 Node* str1_valuea = basic_plus_adr(str1, str1, value_offset);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
865 Node* str1_value = make_load(no_ctrl, str1_valuea, value_type, T_OBJECT, string_type->add_offset(value_offset));
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
866 Node* str1_offseta = basic_plus_adr(str1, str1, offset_offset);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
867 Node* str1_offset = make_load(no_ctrl, str1_offseta, TypeInt::INT, T_INT, string_type->add_offset(offset_offset));
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
868 Node* str1_start = array_element_address(str1_value, str1_offset, T_CHAR);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
869
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
870 Node* str2_valuea = basic_plus_adr(str2, str2, value_offset);
3337
e6d7eed3330c 7041100: The load in String.equals intrinsic executed before null check
kvn
parents: 3284
diff changeset
871 Node* str2_value = make_load(no_ctrl, str2_valuea, value_type, T_OBJECT, string_type->add_offset(value_offset));
986
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
872 Node* str2_offseta = basic_plus_adr(str2, str2, offset_offset);
3337
e6d7eed3330c 7041100: The load in String.equals intrinsic executed before null check
kvn
parents: 3284
diff changeset
873 Node* str2_offset = make_load(no_ctrl, str2_offseta, TypeInt::INT, T_INT, string_type->add_offset(offset_offset));
986
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
874 Node* str2_start = array_element_address(str2_value, str2_offset, T_CHAR);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
875
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
876 Node* result = NULL;
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
877 switch (opcode) {
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
878 case Op_StrIndexOf:
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
879 result = new (C, 6) StrIndexOfNode(control(), memory(TypeAryPtr::CHARS),
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
880 str1_start, cnt1, str2_start, cnt2);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
881 break;
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
882 case Op_StrComp:
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
883 result = new (C, 6) StrCompNode(control(), memory(TypeAryPtr::CHARS),
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
884 str1_start, cnt1, str2_start, cnt2);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
885 break;
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
886 case Op_StrEquals:
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
887 result = new (C, 5) StrEqualsNode(control(), memory(TypeAryPtr::CHARS),
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
888 str1_start, str2_start, cnt1);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
889 break;
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
890 default:
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
891 ShouldNotReachHere();
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
892 return NULL;
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
893 }
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
894
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
895 // All these intrinsics have checks.
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
896 C->set_has_split_ifs(true); // Has chance for split-if optimization
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
897
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
898 return _gvn.transform(result);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
899 }
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
900
0
a61af66fc99e Initial load
duke
parents:
diff changeset
901 //------------------------------inline_string_compareTo------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
902 bool LibraryCallKit::inline_string_compareTo() {
a61af66fc99e Initial load
duke
parents:
diff changeset
903
681
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
904 if (!Matcher::has_match_rule(Op_StrComp)) return false;
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
905
0
a61af66fc99e Initial load
duke
parents:
diff changeset
906 const int value_offset = java_lang_String::value_offset_in_bytes();
a61af66fc99e Initial load
duke
parents:
diff changeset
907 const int count_offset = java_lang_String::count_offset_in_bytes();
a61af66fc99e Initial load
duke
parents:
diff changeset
908 const int offset_offset = java_lang_String::offset_offset_in_bytes();
a61af66fc99e Initial load
duke
parents:
diff changeset
909
a61af66fc99e Initial load
duke
parents:
diff changeset
910 _sp += 2;
a61af66fc99e Initial load
duke
parents:
diff changeset
911 Node *argument = pop(); // pop non-receiver first: it was pushed second
a61af66fc99e Initial load
duke
parents:
diff changeset
912 Node *receiver = pop();
a61af66fc99e Initial load
duke
parents:
diff changeset
913
a61af66fc99e Initial load
duke
parents:
diff changeset
914 // Null check on self without removing any arguments. The argument
a61af66fc99e Initial load
duke
parents:
diff changeset
915 // null check technically happens in the wrong place, which can lead to
a61af66fc99e Initial load
duke
parents:
diff changeset
916 // invalid stack traces when string compare is inlined into a method
a61af66fc99e Initial load
duke
parents:
diff changeset
917 // which handles NullPointerExceptions.
a61af66fc99e Initial load
duke
parents:
diff changeset
918 _sp += 2;
a61af66fc99e Initial load
duke
parents:
diff changeset
919 receiver = do_null_check(receiver, T_OBJECT);
a61af66fc99e Initial load
duke
parents:
diff changeset
920 argument = do_null_check(argument, T_OBJECT);
a61af66fc99e Initial load
duke
parents:
diff changeset
921 _sp -= 2;
a61af66fc99e Initial load
duke
parents:
diff changeset
922 if (stopped()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
923 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
924 }
a61af66fc99e Initial load
duke
parents:
diff changeset
925
a61af66fc99e Initial load
duke
parents:
diff changeset
926 ciInstanceKlass* klass = env()->String_klass();
1496
e8e83be27dd7 6951190: assert(!klass_is_exact(),"only non-exact klass") while building JDK
never
parents: 1396
diff changeset
927 const TypeOopPtr* string_type = TypeOopPtr::make_from_klass(klass);
986
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
928 Node* no_ctrl = NULL;
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
929
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
930 // Get counts for string and argument
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
931 Node* receiver_cnta = basic_plus_adr(receiver, receiver, count_offset);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
932 Node* receiver_cnt = make_load(no_ctrl, receiver_cnta, TypeInt::INT, T_INT, string_type->add_offset(count_offset));
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
933
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
934 Node* argument_cnta = basic_plus_adr(argument, argument, count_offset);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
935 Node* argument_cnt = make_load(no_ctrl, argument_cnta, TypeInt::INT, T_INT, string_type->add_offset(count_offset));
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
936
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
937 Node* compare = make_string_method_node(Op_StrComp, receiver, receiver_cnt, argument, argument_cnt);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
938 push(compare);
a61af66fc99e Initial load
duke
parents:
diff changeset
939 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
940 }
a61af66fc99e Initial load
duke
parents:
diff changeset
941
681
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
942 //------------------------------inline_string_equals------------------------
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
943 bool LibraryCallKit::inline_string_equals() {
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
944
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
945 if (!Matcher::has_match_rule(Op_StrEquals)) return false;
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
946
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
947 const int value_offset = java_lang_String::value_offset_in_bytes();
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
948 const int count_offset = java_lang_String::count_offset_in_bytes();
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
949 const int offset_offset = java_lang_String::offset_offset_in_bytes();
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
950
1746
4b29a725c43c 6912064: type profiles need to be exploited more for dynamic language support
jrose
parents: 1609
diff changeset
951 int nargs = 2;
4b29a725c43c 6912064: type profiles need to be exploited more for dynamic language support
jrose
parents: 1609
diff changeset
952 _sp += nargs;
681
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
953 Node* argument = pop(); // pop non-receiver first: it was pushed second
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
954 Node* receiver = pop();
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
955
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
956 // Null check on self without removing any arguments. The argument
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
957 // null check technically happens in the wrong place, which can lead to
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
958 // invalid stack traces when string compare is inlined into a method
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
959 // which handles NullPointerExceptions.
1746
4b29a725c43c 6912064: type profiles need to be exploited more for dynamic language support
jrose
parents: 1609
diff changeset
960 _sp += nargs;
681
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
961 receiver = do_null_check(receiver, T_OBJECT);
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
962 //should not do null check for argument for String.equals(), because spec
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
963 //allows to specify NULL as argument.
1746
4b29a725c43c 6912064: type profiles need to be exploited more for dynamic language support
jrose
parents: 1609
diff changeset
964 _sp -= nargs;
681
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
965
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
966 if (stopped()) {
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
967 return true;
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
968 }
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
969
986
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
970 // paths (plus control) merge
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
971 RegionNode* region = new (C, 5) RegionNode(5);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
972 Node* phi = new (C, 5) PhiNode(region, TypeInt::BOOL);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
973
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
974 // does source == target string?
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
975 Node* cmp = _gvn.transform(new (C, 3) CmpPNode(receiver, argument));
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
976 Node* bol = _gvn.transform(new (C, 2) BoolNode(cmp, BoolTest::eq));
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
977
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
978 Node* if_eq = generate_slow_guard(bol, NULL);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
979 if (if_eq != NULL) {
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
980 // receiver == argument
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
981 phi->init_req(2, intcon(1));
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
982 region->init_req(2, if_eq);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
983 }
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
984
681
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
985 // get String klass for instanceOf
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
986 ciInstanceKlass* klass = env()->String_klass();
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
987
986
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
988 if (!stopped()) {
1746
4b29a725c43c 6912064: type profiles need to be exploited more for dynamic language support
jrose
parents: 1609
diff changeset
989 _sp += nargs; // gen_instanceof might do an uncommon trap
986
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
990 Node* inst = gen_instanceof(argument, makecon(TypeKlassPtr::make(klass)));
1746
4b29a725c43c 6912064: type profiles need to be exploited more for dynamic language support
jrose
parents: 1609
diff changeset
991 _sp -= nargs;
986
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
992 Node* cmp = _gvn.transform(new (C, 3) CmpINode(inst, intcon(1)));
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
993 Node* bol = _gvn.transform(new (C, 2) BoolNode(cmp, BoolTest::ne));
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
994
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
995 Node* inst_false = generate_guard(bol, NULL, PROB_MIN);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
996 //instanceOf == true, fallthrough
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
997
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
998 if (inst_false != NULL) {
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
999 phi->init_req(3, intcon(0));
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1000 region->init_req(3, inst_false);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1001 }
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1002 }
681
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1003
1496
e8e83be27dd7 6951190: assert(!klass_is_exact(),"only non-exact klass") while building JDK
never
parents: 1396
diff changeset
1004 const TypeOopPtr* string_type = TypeOopPtr::make_from_klass(klass);
681
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1005
986
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1006 Node* no_ctrl = NULL;
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1007 Node* receiver_cnt;
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1008 Node* argument_cnt;
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1009
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1010 if (!stopped()) {
1496
e8e83be27dd7 6951190: assert(!klass_is_exact(),"only non-exact klass") while building JDK
never
parents: 1396
diff changeset
1011 // Properly cast the argument to String
e8e83be27dd7 6951190: assert(!klass_is_exact(),"only non-exact klass") while building JDK
never
parents: 1396
diff changeset
1012 argument = _gvn.transform(new (C, 2) CheckCastPPNode(control(), argument, string_type));
3337
e6d7eed3330c 7041100: The load in String.equals intrinsic executed before null check
kvn
parents: 3284
diff changeset
1013 // This path is taken only when argument's type is String:NotNull.
e6d7eed3330c 7041100: The load in String.equals intrinsic executed before null check
kvn
parents: 3284
diff changeset
1014 argument = cast_not_null(argument, false);
1496
e8e83be27dd7 6951190: assert(!klass_is_exact(),"only non-exact klass") while building JDK
never
parents: 1396
diff changeset
1015
986
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1016 // Get counts for string and argument
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1017 Node* receiver_cnta = basic_plus_adr(receiver, receiver, count_offset);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1018 receiver_cnt = make_load(no_ctrl, receiver_cnta, TypeInt::INT, T_INT, string_type->add_offset(count_offset));
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1019
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1020 Node* argument_cnta = basic_plus_adr(argument, argument, count_offset);
3337
e6d7eed3330c 7041100: The load in String.equals intrinsic executed before null check
kvn
parents: 3284
diff changeset
1021 argument_cnt = make_load(no_ctrl, argument_cnta, TypeInt::INT, T_INT, string_type->add_offset(count_offset));
986
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1022
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1023 // Check for receiver count != argument count
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1024 Node* cmp = _gvn.transform( new(C, 3) CmpINode(receiver_cnt, argument_cnt) );
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1025 Node* bol = _gvn.transform( new(C, 2) BoolNode(cmp, BoolTest::ne) );
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1026 Node* if_ne = generate_slow_guard(bol, NULL);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1027 if (if_ne != NULL) {
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1028 phi->init_req(4, intcon(0));
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1029 region->init_req(4, if_ne);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1030 }
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1031 }
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1032
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1033 // Check for count == 0 is done by mach node StrEquals.
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1034
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1035 if (!stopped()) {
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1036 Node* equals = make_string_method_node(Op_StrEquals, receiver, receiver_cnt, argument, argument_cnt);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1037 phi->init_req(1, equals);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1038 region->init_req(1, control());
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1039 }
681
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1040
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1041 // post merge
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1042 set_control(_gvn.transform(region));
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1043 record_for_igvn(region);
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1044
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1045 push(_gvn.transform(phi));
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1046
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1047 return true;
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1048 }
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1049
169
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 164
diff changeset
1050 //------------------------------inline_array_equals----------------------------
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 164
diff changeset
1051 bool LibraryCallKit::inline_array_equals() {
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 164
diff changeset
1052
174
510f98a80563 6709972: runThese failed with assert(false,"bad AD file")
rasbold
parents: 169
diff changeset
1053 if (!Matcher::has_match_rule(Op_AryEq)) return false;
510f98a80563 6709972: runThese failed with assert(false,"bad AD file")
rasbold
parents: 169
diff changeset
1054
169
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 164
diff changeset
1055 _sp += 2;
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 164
diff changeset
1056 Node *argument2 = pop();
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 164
diff changeset
1057 Node *argument1 = pop();
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 164
diff changeset
1058
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 164
diff changeset
1059 Node* equals =
986
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1060 _gvn.transform(new (C, 4) AryEqNode(control(), memory(TypeAryPtr::CHARS),
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1061 argument1, argument2) );
169
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 164
diff changeset
1062 push(equals);
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 164
diff changeset
1063 return true;
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 164
diff changeset
1064 }
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 164
diff changeset
1065
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1066 // Java version of String.indexOf(constant string)
a61af66fc99e Initial load
duke
parents:
diff changeset
1067 // class StringDecl {
a61af66fc99e Initial load
duke
parents:
diff changeset
1068 // StringDecl(char[] ca) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1069 // offset = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
1070 // count = ca.length;
a61af66fc99e Initial load
duke
parents:
diff changeset
1071 // value = ca;
a61af66fc99e Initial load
duke
parents:
diff changeset
1072 // }
a61af66fc99e Initial load
duke
parents:
diff changeset
1073 // int offset;
a61af66fc99e Initial load
duke
parents:
diff changeset
1074 // int count;
a61af66fc99e Initial load
duke
parents:
diff changeset
1075 // char[] value;
a61af66fc99e Initial load
duke
parents:
diff changeset
1076 // }
a61af66fc99e Initial load
duke
parents:
diff changeset
1077 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1078 // static int string_indexOf_J(StringDecl string_object, char[] target_object,
a61af66fc99e Initial load
duke
parents:
diff changeset
1079 // int targetOffset, int cache_i, int md2) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1080 // int cache = cache_i;
a61af66fc99e Initial load
duke
parents:
diff changeset
1081 // int sourceOffset = string_object.offset;
a61af66fc99e Initial load
duke
parents:
diff changeset
1082 // int sourceCount = string_object.count;
a61af66fc99e Initial load
duke
parents:
diff changeset
1083 // int targetCount = target_object.length;
a61af66fc99e Initial load
duke
parents:
diff changeset
1084 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1085 // int targetCountLess1 = targetCount - 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
1086 // int sourceEnd = sourceOffset + sourceCount - targetCountLess1;
a61af66fc99e Initial load
duke
parents:
diff changeset
1087 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1088 // char[] source = string_object.value;
a61af66fc99e Initial load
duke
parents:
diff changeset
1089 // char[] target = target_object;
a61af66fc99e Initial load
duke
parents:
diff changeset
1090 // int lastChar = target[targetCountLess1];
a61af66fc99e Initial load
duke
parents:
diff changeset
1091 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1092 // outer_loop:
a61af66fc99e Initial load
duke
parents:
diff changeset
1093 // for (int i = sourceOffset; i < sourceEnd; ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1094 // int src = source[i + targetCountLess1];
a61af66fc99e Initial load
duke
parents:
diff changeset
1095 // if (src == lastChar) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1096 // // With random strings and a 4-character alphabet,
a61af66fc99e Initial load
duke
parents:
diff changeset
1097 // // reverse matching at this point sets up 0.8% fewer
a61af66fc99e Initial load
duke
parents:
diff changeset
1098 // // frames, but (paradoxically) makes 0.3% more probes.
a61af66fc99e Initial load
duke
parents:
diff changeset
1099 // // Since those probes are nearer the lastChar probe,
a61af66fc99e Initial load
duke
parents:
diff changeset
1100 // // there is may be a net D$ win with reverse matching.
a61af66fc99e Initial load
duke
parents:
diff changeset
1101 // // But, reversing loop inhibits unroll of inner loop
a61af66fc99e Initial load
duke
parents:
diff changeset
1102 // // for unknown reason. So, does running outer loop from
a61af66fc99e Initial load
duke
parents:
diff changeset
1103 // // (sourceOffset - targetCountLess1) to (sourceOffset + sourceCount)
a61af66fc99e Initial load
duke
parents:
diff changeset
1104 // for (int j = 0; j < targetCountLess1; j++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1105 // if (target[targetOffset + j] != source[i+j]) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1106 // if ((cache & (1 << source[i+j])) == 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1107 // if (md2 < j+1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1108 // i += j+1;
a61af66fc99e Initial load
duke
parents:
diff changeset
1109 // continue outer_loop;
a61af66fc99e Initial load
duke
parents:
diff changeset
1110 // }
a61af66fc99e Initial load
duke
parents:
diff changeset
1111 // }
a61af66fc99e Initial load
duke
parents:
diff changeset
1112 // i += md2;
a61af66fc99e Initial load
duke
parents:
diff changeset
1113 // continue outer_loop;
a61af66fc99e Initial load
duke
parents:
diff changeset
1114 // }
a61af66fc99e Initial load
duke
parents:
diff changeset
1115 // }
a61af66fc99e Initial load
duke
parents:
diff changeset
1116 // return i - sourceOffset;
a61af66fc99e Initial load
duke
parents:
diff changeset
1117 // }
a61af66fc99e Initial load
duke
parents:
diff changeset
1118 // if ((cache & (1 << src)) == 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1119 // i += targetCountLess1;
a61af66fc99e Initial load
duke
parents:
diff changeset
1120 // } // using "i += targetCount;" and an "else i++;" causes a jump to jump.
a61af66fc99e Initial load
duke
parents:
diff changeset
1121 // i++;
a61af66fc99e Initial load
duke
parents:
diff changeset
1122 // }
a61af66fc99e Initial load
duke
parents:
diff changeset
1123 // return -1;
a61af66fc99e Initial load
duke
parents:
diff changeset
1124 // }
a61af66fc99e Initial load
duke
parents:
diff changeset
1125
a61af66fc99e Initial load
duke
parents:
diff changeset
1126 //------------------------------string_indexOf------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1127 Node* LibraryCallKit::string_indexOf(Node* string_object, ciTypeArray* target_array, jint targetOffset_i,
a61af66fc99e Initial load
duke
parents:
diff changeset
1128 jint cache_i, jint md2_i) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1129
a61af66fc99e Initial load
duke
parents:
diff changeset
1130 Node* no_ctrl = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1131 float likely = PROB_LIKELY(0.9);
a61af66fc99e Initial load
duke
parents:
diff changeset
1132 float unlikely = PROB_UNLIKELY(0.9);
a61af66fc99e Initial load
duke
parents:
diff changeset
1133
2383
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries
kvn
parents: 2324
diff changeset
1134 const int nargs = 2; // number of arguments to push back for uncommon trap in predicate
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries
kvn
parents: 2324
diff changeset
1135
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1136 const int value_offset = java_lang_String::value_offset_in_bytes();
a61af66fc99e Initial load
duke
parents:
diff changeset
1137 const int count_offset = java_lang_String::count_offset_in_bytes();
a61af66fc99e Initial load
duke
parents:
diff changeset
1138 const int offset_offset = java_lang_String::offset_offset_in_bytes();
a61af66fc99e Initial load
duke
parents:
diff changeset
1139
a61af66fc99e Initial load
duke
parents:
diff changeset
1140 ciInstanceKlass* klass = env()->String_klass();
1496
e8e83be27dd7 6951190: assert(!klass_is_exact(),"only non-exact klass") while building JDK
never
parents: 1396
diff changeset
1141 const TypeOopPtr* string_type = TypeOopPtr::make_from_klass(klass);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1142 const TypeAryPtr* source_type = TypeAryPtr::make(TypePtr::NotNull, TypeAry::make(TypeInt::CHAR,TypeInt::POS), ciTypeArrayKlass::make(T_CHAR), true, 0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1143
a61af66fc99e Initial load
duke
parents:
diff changeset
1144 Node* sourceOffseta = basic_plus_adr(string_object, string_object, offset_offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
1145 Node* sourceOffset = make_load(no_ctrl, sourceOffseta, TypeInt::INT, T_INT, string_type->add_offset(offset_offset));
a61af66fc99e Initial load
duke
parents:
diff changeset
1146 Node* sourceCounta = basic_plus_adr(string_object, string_object, count_offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
1147 Node* sourceCount = make_load(no_ctrl, sourceCounta, TypeInt::INT, T_INT, string_type->add_offset(count_offset));
a61af66fc99e Initial load
duke
parents:
diff changeset
1148 Node* sourcea = basic_plus_adr(string_object, string_object, value_offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
1149 Node* source = make_load(no_ctrl, sourcea, source_type, T_OBJECT, string_type->add_offset(value_offset));
a61af66fc99e Initial load
duke
parents:
diff changeset
1150
2379
b099aaf51bf8 6962931: move interned strings out of the perm gen
jcoomes
parents: 2324
diff changeset
1151 Node* target = _gvn.transform( makecon(TypeOopPtr::make_from_constant(target_array, true)) );
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1152 jint target_length = target_array->length();
a61af66fc99e Initial load
duke
parents:
diff changeset
1153 const TypeAry* target_array_type = TypeAry::make(TypeInt::CHAR, TypeInt::make(0, target_length, Type::WidenMin));
a61af66fc99e Initial load
duke
parents:
diff changeset
1154 const TypeAryPtr* target_type = TypeAryPtr::make(TypePtr::BotPTR, target_array_type, target_array->klass(), true, Type::OffsetBot);
a61af66fc99e Initial load
duke
parents:
diff changeset
1155
2444
07acc51c1d2a 7032314: Allow to generate CallLeafNoFPNode in IdealKit
kvn
parents: 2405
diff changeset
1156 IdealKit kit(this, false, true);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1157 #define __ kit.
a61af66fc99e Initial load
duke
parents:
diff changeset
1158 Node* zero = __ ConI(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1159 Node* one = __ ConI(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
1160 Node* cache = __ ConI(cache_i);
a61af66fc99e Initial load
duke
parents:
diff changeset
1161 Node* md2 = __ ConI(md2_i);
a61af66fc99e Initial load
duke
parents:
diff changeset
1162 Node* lastChar = __ ConI(target_array->char_at(target_length - 1));
a61af66fc99e Initial load
duke
parents:
diff changeset
1163 Node* targetCount = __ ConI(target_length);
a61af66fc99e Initial load
duke
parents:
diff changeset
1164 Node* targetCountLess1 = __ ConI(target_length - 1);
a61af66fc99e Initial load
duke
parents:
diff changeset
1165 Node* targetOffset = __ ConI(targetOffset_i);
a61af66fc99e Initial load
duke
parents:
diff changeset
1166 Node* sourceEnd = __ SubI(__ AddI(sourceOffset, sourceCount), targetCountLess1);
a61af66fc99e Initial load
duke
parents:
diff changeset
1167
851
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 836
diff changeset
1168 IdealVariable rtn(kit), i(kit), j(kit); __ declarations_done();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1169 Node* outer_loop = __ make_label(2 /* goto */);
a61af66fc99e Initial load
duke
parents:
diff changeset
1170 Node* return_ = __ make_label(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
1171
a61af66fc99e Initial load
duke
parents:
diff changeset
1172 __ set(rtn,__ ConI(-1));
2383
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries
kvn
parents: 2324
diff changeset
1173 __ loop(this, nargs, i, sourceOffset, BoolTest::lt, sourceEnd); {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1174 Node* i2 = __ AddI(__ value(i), targetCountLess1);
a61af66fc99e Initial load
duke
parents:
diff changeset
1175 // pin to prohibit loading of "next iteration" value which may SEGV (rare)
a61af66fc99e Initial load
duke
parents:
diff changeset
1176 Node* src = load_array_element(__ ctrl(), source, i2, TypeAryPtr::CHARS);
a61af66fc99e Initial load
duke
parents:
diff changeset
1177 __ if_then(src, BoolTest::eq, lastChar, unlikely); {
2383
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries
kvn
parents: 2324
diff changeset
1178 __ loop(this, nargs, j, zero, BoolTest::lt, targetCountLess1); {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1179 Node* tpj = __ AddI(targetOffset, __ value(j));
a61af66fc99e Initial load
duke
parents:
diff changeset
1180 Node* targ = load_array_element(no_ctrl, target, tpj, target_type);
a61af66fc99e Initial load
duke
parents:
diff changeset
1181 Node* ipj = __ AddI(__ value(i), __ value(j));
a61af66fc99e Initial load
duke
parents:
diff changeset
1182 Node* src2 = load_array_element(no_ctrl, source, ipj, TypeAryPtr::CHARS);
a61af66fc99e Initial load
duke
parents:
diff changeset
1183 __ if_then(targ, BoolTest::ne, src2); {
a61af66fc99e Initial load
duke
parents:
diff changeset
1184 __ if_then(__ AndI(cache, __ LShiftI(one, src2)), BoolTest::eq, zero); {
a61af66fc99e Initial load
duke
parents:
diff changeset
1185 __ if_then(md2, BoolTest::lt, __ AddI(__ value(j), one)); {
a61af66fc99e Initial load
duke
parents:
diff changeset
1186 __ increment(i, __ AddI(__ value(j), one));
a61af66fc99e Initial load
duke
parents:
diff changeset
1187 __ goto_(outer_loop);
a61af66fc99e Initial load
duke
parents:
diff changeset
1188 } __ end_if(); __ dead(j);
a61af66fc99e Initial load
duke
parents:
diff changeset
1189 }__ end_if(); __ dead(j);
a61af66fc99e Initial load
duke
parents:
diff changeset
1190 __ increment(i, md2);
a61af66fc99e Initial load
duke
parents:
diff changeset
1191 __ goto_(outer_loop);
a61af66fc99e Initial load
duke
parents:
diff changeset
1192 }__ end_if();
a61af66fc99e Initial load
duke
parents:
diff changeset
1193 __ increment(j, one);
a61af66fc99e Initial load
duke
parents:
diff changeset
1194 }__ end_loop(); __ dead(j);
a61af66fc99e Initial load
duke
parents:
diff changeset
1195 __ set(rtn, __ SubI(__ value(i), sourceOffset)); __ dead(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
1196 __ goto_(return_);
a61af66fc99e Initial load
duke
parents:
diff changeset
1197 }__ end_if();
a61af66fc99e Initial load
duke
parents:
diff changeset
1198 __ if_then(__ AndI(cache, __ LShiftI(one, src)), BoolTest::eq, zero, likely); {
a61af66fc99e Initial load
duke
parents:
diff changeset
1199 __ increment(i, targetCountLess1);
a61af66fc99e Initial load
duke
parents:
diff changeset
1200 }__ end_if();
a61af66fc99e Initial load
duke
parents:
diff changeset
1201 __ increment(i, one);
a61af66fc99e Initial load
duke
parents:
diff changeset
1202 __ bind(outer_loop);
a61af66fc99e Initial load
duke
parents:
diff changeset
1203 }__ end_loop(); __ dead(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
1204 __ bind(return_);
851
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 836
diff changeset
1205
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 836
diff changeset
1206 // Final sync IdealKit and GraphKit.
2444
07acc51c1d2a 7032314: Allow to generate CallLeafNoFPNode in IdealKit
kvn
parents: 2405
diff changeset
1207 final_sync(kit);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1208 Node* result = __ value(rtn);
a61af66fc99e Initial load
duke
parents:
diff changeset
1209 #undef __
a61af66fc99e Initial load
duke
parents:
diff changeset
1210 C->set_has_loops(true);
a61af66fc99e Initial load
duke
parents:
diff changeset
1211 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
1212 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1213
a61af66fc99e Initial load
duke
parents:
diff changeset
1214 //------------------------------inline_string_indexOf------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1215 bool LibraryCallKit::inline_string_indexOf() {
a61af66fc99e Initial load
duke
parents:
diff changeset
1216
a61af66fc99e Initial load
duke
parents:
diff changeset
1217 const int value_offset = java_lang_String::value_offset_in_bytes();
a61af66fc99e Initial load
duke
parents:
diff changeset
1218 const int count_offset = java_lang_String::count_offset_in_bytes();
a61af66fc99e Initial load
duke
parents:
diff changeset
1219 const int offset_offset = java_lang_String::offset_offset_in_bytes();
a61af66fc99e Initial load
duke
parents:
diff changeset
1220
a61af66fc99e Initial load
duke
parents:
diff changeset
1221 _sp += 2;
681
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1222 Node *argument = pop(); // pop non-receiver first: it was pushed second
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1223 Node *receiver = pop();
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1224
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1225 Node* result;
1504
ae8f909e5fc7 6948602: Disable use of SSE4.2 in String.indexOf intrinsic until 6942326 is fixed
iveresov
parents: 1396
diff changeset
1226 // Disable the use of pcmpestri until it can be guaranteed that
ae8f909e5fc7 6948602: Disable use of SSE4.2 in String.indexOf intrinsic until 6942326 is fixed
iveresov
parents: 1396
diff changeset
1227 // the load doesn't cross into the uncommited space.
2320
41d4973cf100 6942326: x86 code in string_indexof() could read beyond reserved heap space
kvn
parents: 1972
diff changeset
1228 if (Matcher::has_match_rule(Op_StrIndexOf) &&
681
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1229 UseSSE42Intrinsics) {
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1230 // Generate SSE4.2 version of indexOf
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1231 // We currently only have match rules that use SSE4.2
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1232
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1233 // Null check on self without removing any arguments. The argument
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1234 // null check technically happens in the wrong place, which can lead to
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1235 // invalid stack traces when string compare is inlined into a method
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1236 // which handles NullPointerExceptions.
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1237 _sp += 2;
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1238 receiver = do_null_check(receiver, T_OBJECT);
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1239 argument = do_null_check(argument, T_OBJECT);
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1240 _sp -= 2;
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1241
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1242 if (stopped()) {
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1243 return true;
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1244 }
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1245
2320
41d4973cf100 6942326: x86 code in string_indexof() could read beyond reserved heap space
kvn
parents: 1972
diff changeset
1246 ciInstanceKlass* str_klass = env()->String_klass();
41d4973cf100 6942326: x86 code in string_indexof() could read beyond reserved heap space
kvn
parents: 1972
diff changeset
1247 const TypeOopPtr* string_type = TypeOopPtr::make_from_klass(str_klass);
41d4973cf100 6942326: x86 code in string_indexof() could read beyond reserved heap space
kvn
parents: 1972
diff changeset
1248
986
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1249 // Make the merge point
2320
41d4973cf100 6942326: x86 code in string_indexof() could read beyond reserved heap space
kvn
parents: 1972
diff changeset
1250 RegionNode* result_rgn = new (C, 4) RegionNode(4);
41d4973cf100 6942326: x86 code in string_indexof() could read beyond reserved heap space
kvn
parents: 1972
diff changeset
1251 Node* result_phi = new (C, 4) PhiNode(result_rgn, TypeInt::INT);
986
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1252 Node* no_ctrl = NULL;
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1253
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1254 // Get counts for string and substr
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1255 Node* source_cnta = basic_plus_adr(receiver, receiver, count_offset);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1256 Node* source_cnt = make_load(no_ctrl, source_cnta, TypeInt::INT, T_INT, string_type->add_offset(count_offset));
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1257
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1258 Node* substr_cnta = basic_plus_adr(argument, argument, count_offset);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1259 Node* substr_cnt = make_load(no_ctrl, substr_cnta, TypeInt::INT, T_INT, string_type->add_offset(count_offset));
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1260
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1261 // Check for substr count > string count
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1262 Node* cmp = _gvn.transform( new(C, 3) CmpINode(substr_cnt, source_cnt) );
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1263 Node* bol = _gvn.transform( new(C, 2) BoolNode(cmp, BoolTest::gt) );
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1264 Node* if_gt = generate_slow_guard(bol, NULL);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1265 if (if_gt != NULL) {
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1266 result_phi->init_req(2, intcon(-1));
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1267 result_rgn->init_req(2, if_gt);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1268 }
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1269
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1270 if (!stopped()) {
2320
41d4973cf100 6942326: x86 code in string_indexof() could read beyond reserved heap space
kvn
parents: 1972
diff changeset
1271 // Check for substr count == 0
41d4973cf100 6942326: x86 code in string_indexof() could read beyond reserved heap space
kvn
parents: 1972
diff changeset
1272 cmp = _gvn.transform( new(C, 3) CmpINode(substr_cnt, intcon(0)) );
41d4973cf100 6942326: x86 code in string_indexof() could read beyond reserved heap space
kvn
parents: 1972
diff changeset
1273 bol = _gvn.transform( new(C, 2) BoolNode(cmp, BoolTest::eq) );
41d4973cf100 6942326: x86 code in string_indexof() could read beyond reserved heap space
kvn
parents: 1972
diff changeset
1274 Node* if_zero = generate_slow_guard(bol, NULL);
41d4973cf100 6942326: x86 code in string_indexof() could read beyond reserved heap space
kvn
parents: 1972
diff changeset
1275 if (if_zero != NULL) {
41d4973cf100 6942326: x86 code in string_indexof() could read beyond reserved heap space
kvn
parents: 1972
diff changeset
1276 result_phi->init_req(3, intcon(0));
41d4973cf100 6942326: x86 code in string_indexof() could read beyond reserved heap space
kvn
parents: 1972
diff changeset
1277 result_rgn->init_req(3, if_zero);
41d4973cf100 6942326: x86 code in string_indexof() could read beyond reserved heap space
kvn
parents: 1972
diff changeset
1278 }
41d4973cf100 6942326: x86 code in string_indexof() could read beyond reserved heap space
kvn
parents: 1972
diff changeset
1279 }
41d4973cf100 6942326: x86 code in string_indexof() could read beyond reserved heap space
kvn
parents: 1972
diff changeset
1280
41d4973cf100 6942326: x86 code in string_indexof() could read beyond reserved heap space
kvn
parents: 1972
diff changeset
1281 if (!stopped()) {
986
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1282 result = make_string_method_node(Op_StrIndexOf, receiver, source_cnt, argument, substr_cnt);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1283 result_phi->init_req(1, result);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1284 result_rgn->init_req(1, control());
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1285 }
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1286 set_control(_gvn.transform(result_rgn));
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1287 record_for_igvn(result_rgn);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1288 result = _gvn.transform(result_phi);
62001a362ce9 6827605: new String intrinsics may prevent EA scalar replacement
kvn
parents: 958
diff changeset
1289
2320
41d4973cf100 6942326: x86 code in string_indexof() could read beyond reserved heap space
kvn
parents: 1972
diff changeset
1290 } else { // Use LibraryCallKit::string_indexOf
41d4973cf100 6942326: x86 code in string_indexof() could read beyond reserved heap space
kvn
parents: 1972
diff changeset
1291 // don't intrinsify if argument isn't a constant string.
681
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1292 if (!argument->is_Con()) {
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1293 return false;
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1294 }
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1295 const TypeOopPtr* str_type = _gvn.type(argument)->isa_oopptr();
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1296 if (str_type == NULL) {
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1297 return false;
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1298 }
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1299 ciInstanceKlass* klass = env()->String_klass();
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1300 ciObject* str_const = str_type->const_oop();
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1301 if (str_const == NULL || str_const->klass() != klass) {
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1302 return false;
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1303 }
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1304 ciInstance* str = str_const->as_instance();
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1305 assert(str != NULL, "must be instance");
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1306
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1307 ciObject* v = str->field_value_by_offset(value_offset).as_object();
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1308 int o = str->field_value_by_offset(offset_offset).as_int();
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1309 int c = str->field_value_by_offset(count_offset).as_int();
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1310 ciTypeArray* pat = v->as_type_array(); // pattern (argument) character array
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1311
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1312 // constant strings have no offset and count == length which
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1313 // simplifies the resulting code somewhat so lets optimize for that.
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1314 if (o != 0 || c != pat->length()) {
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1315 return false;
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1316 }
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1317
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1318 // Null check on self without removing any arguments. The argument
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1319 // null check technically happens in the wrong place, which can lead to
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1320 // invalid stack traces when string compare is inlined into a method
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1321 // which handles NullPointerExceptions.
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1322 _sp += 2;
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1323 receiver = do_null_check(receiver, T_OBJECT);
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1324 // No null check on the argument is needed since it's a constant String oop.
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1325 _sp -= 2;
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1326 if (stopped()) {
2320
41d4973cf100 6942326: x86 code in string_indexof() could read beyond reserved heap space
kvn
parents: 1972
diff changeset
1327 return true;
681
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1328 }
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1329
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1330 // The null string as a pattern always returns 0 (match at beginning of string)
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1331 if (c == 0) {
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1332 push(intcon(0));
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1333 return true;
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1334 }
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1335
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1336 // Generate default indexOf
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1337 jchar lastChar = pat->char_at(o + (c - 1));
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1338 int cache = 0;
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1339 int i;
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1340 for (i = 0; i < c - 1; i++) {
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1341 assert(i < pat->length(), "out of range");
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1342 cache |= (1 << (pat->char_at(o + i) & (sizeof(cache) * BitsPerByte - 1)));
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1343 }
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1344
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1345 int md2 = c;
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1346 for (i = 0; i < c - 1; i++) {
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1347 assert(i < pat->length(), "out of range");
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1348 if (pat->char_at(o + i) == lastChar) {
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1349 md2 = (c - 1) - i;
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1350 }
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1351 }
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1352
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics
cfang
parents: 643
diff changeset
1353 result = string_indexOf(receiver, pat, o, cache, md2);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1354 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1355
a61af66fc99e Initial load
duke
parents:
diff changeset
1356 push(result);
a61af66fc99e Initial load
duke
parents:
diff changeset
1357 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
1358 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1359
a61af66fc99e Initial load
duke
parents:
diff changeset
1360 //--------------------------pop_math_arg--------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1361 // Pop a double argument to a math function from the stack
a61af66fc99e Initial load
duke
parents:
diff changeset
1362 // rounding it if necessary.
a61af66fc99e Initial load
duke
parents:
diff changeset
1363 Node * LibraryCallKit::pop_math_arg() {
a61af66fc99e Initial load
duke
parents:
diff changeset
1364 Node *arg = pop_pair();
a61af66fc99e Initial load
duke
parents:
diff changeset
1365 if( Matcher::strict_fp_requires_explicit_rounding && UseSSE<=1 )
a61af66fc99e Initial load
duke
parents:
diff changeset
1366 arg = _gvn.transform( new (C, 2) RoundDoubleNode(0, arg) );
a61af66fc99e Initial load
duke
parents:
diff changeset
1367 return arg;
a61af66fc99e Initial load
duke
parents:
diff changeset
1368 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1369
a61af66fc99e Initial load
duke
parents:
diff changeset
1370 //------------------------------inline_trig----------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1371 // Inline sin/cos/tan instructions, if possible. If rounding is required, do
a61af66fc99e Initial load
duke
parents:
diff changeset
1372 // argument reduction which will turn into a fast/slow diamond.
a61af66fc99e Initial load
duke
parents:
diff changeset
1373 bool LibraryCallKit::inline_trig(vmIntrinsics::ID id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1374 _sp += arg_size(); // restore stack pointer
a61af66fc99e Initial load
duke
parents:
diff changeset
1375 Node* arg = pop_math_arg();
a61af66fc99e Initial load
duke
parents:
diff changeset
1376 Node* trig = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1377
a61af66fc99e Initial load
duke
parents:
diff changeset
1378 switch (id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1379 case vmIntrinsics::_dsin:
a61af66fc99e Initial load
duke
parents:
diff changeset
1380 trig = _gvn.transform((Node*)new (C, 2) SinDNode(arg));
a61af66fc99e Initial load
duke
parents:
diff changeset
1381 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1382 case vmIntrinsics::_dcos:
a61af66fc99e Initial load
duke
parents:
diff changeset
1383 trig = _gvn.transform((Node*)new (C, 2) CosDNode(arg));
a61af66fc99e Initial load
duke
parents:
diff changeset
1384 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1385 case vmIntrinsics::_dtan:
a61af66fc99e Initial load
duke
parents:
diff changeset
1386 trig = _gvn.transform((Node*)new (C, 2) TanDNode(arg));
a61af66fc99e Initial load
duke
parents:
diff changeset
1387 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1388 default:
a61af66fc99e Initial load
duke
parents:
diff changeset
1389 assert(false, "bad intrinsic was passed in");
a61af66fc99e Initial load
duke
parents:
diff changeset
1390 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
1391 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1392
a61af66fc99e Initial load
duke
parents:
diff changeset
1393 // Rounding required? Check for argument reduction!
a61af66fc99e Initial load
duke
parents:
diff changeset
1394 if( Matcher::strict_fp_requires_explicit_rounding ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1395
a61af66fc99e Initial load
duke
parents:
diff changeset
1396 static const double pi_4 = 0.7853981633974483;
a61af66fc99e Initial load
duke
parents:
diff changeset
1397 static const double neg_pi_4 = -0.7853981633974483;
a61af66fc99e Initial load
duke
parents:
diff changeset
1398 // pi/2 in 80-bit extended precision
a61af66fc99e Initial load
duke
parents:
diff changeset
1399 // static const unsigned char pi_2_bits_x[] = {0x35,0xc2,0x68,0x21,0xa2,0xda,0x0f,0xc9,0xff,0x3f,0x00,0x00,0x00,0x00,0x00,0x00};
a61af66fc99e Initial load
duke
parents:
diff changeset
1400 // -pi/2 in 80-bit extended precision
a61af66fc99e Initial load
duke
parents:
diff changeset
1401 // static const unsigned char neg_pi_2_bits_x[] = {0x35,0xc2,0x68,0x21,0xa2,0xda,0x0f,0xc9,0xff,0xbf,0x00,0x00,0x00,0x00,0x00,0x00};
a61af66fc99e Initial load
duke
parents:
diff changeset
1402 // Cutoff value for using this argument reduction technique
a61af66fc99e Initial load
duke
parents:
diff changeset
1403 //static const double pi_2_minus_epsilon = 1.564660403643354;
a61af66fc99e Initial load
duke
parents:
diff changeset
1404 //static const double neg_pi_2_plus_epsilon = -1.564660403643354;
a61af66fc99e Initial load
duke
parents:
diff changeset
1405
a61af66fc99e Initial load
duke
parents:
diff changeset
1406 // Pseudocode for sin:
a61af66fc99e Initial load
duke
parents:
diff changeset
1407 // if (x <= Math.PI / 4.0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1408 // if (x >= -Math.PI / 4.0) return fsin(x);
a61af66fc99e Initial load
duke
parents:
diff changeset
1409 // if (x >= -Math.PI / 2.0) return -fcos(x + Math.PI / 2.0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1410 // } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1411 // if (x <= Math.PI / 2.0) return fcos(x - Math.PI / 2.0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1412 // }
a61af66fc99e Initial load
duke
parents:
diff changeset
1413 // return StrictMath.sin(x);
a61af66fc99e Initial load
duke
parents:
diff changeset
1414
a61af66fc99e Initial load
duke
parents:
diff changeset
1415 // Pseudocode for cos:
a61af66fc99e Initial load
duke
parents:
diff changeset
1416 // if (x <= Math.PI / 4.0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1417 // if (x >= -Math.PI / 4.0) return fcos(x);
a61af66fc99e Initial load
duke
parents:
diff changeset
1418 // if (x >= -Math.PI / 2.0) return fsin(x + Math.PI / 2.0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1419 // } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1420 // if (x <= Math.PI / 2.0) return -fsin(x - Math.PI / 2.0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1421 // }
a61af66fc99e Initial load
duke
parents:
diff changeset
1422 // return StrictMath.cos(x);
a61af66fc99e Initial load
duke
parents:
diff changeset
1423
a61af66fc99e Initial load
duke
parents:
diff changeset
1424 // Actually, sticking in an 80-bit Intel value into C2 will be tough; it
a61af66fc99e Initial load
duke
parents:
diff changeset
1425 // requires a special machine instruction to load it. Instead we'll try
a61af66fc99e Initial load
duke
parents:
diff changeset
1426 // the 'easy' case. If we really need the extra range +/- PI/2 we'll
a61af66fc99e Initial load
duke
parents:
diff changeset
1427 // probably do the math inside the SIN encoding.
a61af66fc99e Initial load
duke
parents:
diff changeset
1428
a61af66fc99e Initial load
duke
parents:
diff changeset
1429 // Make the merge point
a61af66fc99e Initial load
duke
parents:
diff changeset
1430 RegionNode *r = new (C, 3) RegionNode(3);
a61af66fc99e Initial load
duke
parents:
diff changeset
1431 Node *phi = new (C, 3) PhiNode(r,Type::DOUBLE);
a61af66fc99e Initial load
duke
parents:
diff changeset
1432
a61af66fc99e Initial load
duke
parents:
diff changeset
1433 // Flatten arg so we need only 1 test
a61af66fc99e Initial load
duke
parents:
diff changeset
1434 Node *abs = _gvn.transform(new (C, 2) AbsDNode(arg));
a61af66fc99e Initial load
duke
parents:
diff changeset
1435 // Node for PI/4 constant
a61af66fc99e Initial load
duke
parents:
diff changeset
1436 Node *pi4 = makecon(TypeD::make(pi_4));
a61af66fc99e Initial load
duke
parents:
diff changeset
1437 // Check PI/4 : abs(arg)
a61af66fc99e Initial load
duke
parents:
diff changeset
1438 Node *cmp = _gvn.transform(new (C, 3) CmpDNode(pi4,abs));
a61af66fc99e Initial load
duke
parents:
diff changeset
1439 // Check: If PI/4 < abs(arg) then go slow
a61af66fc99e Initial load
duke
parents:
diff changeset
1440 Node *bol = _gvn.transform( new (C, 2) BoolNode( cmp, BoolTest::lt ) );
a61af66fc99e Initial load
duke
parents:
diff changeset
1441 // Branch either way
a61af66fc99e Initial load
duke
parents:
diff changeset
1442 IfNode *iff = create_and_xform_if(control(),bol, PROB_STATIC_FREQUENT, COUNT_UNKNOWN);
a61af66fc99e Initial load
duke
parents:
diff changeset
1443 set_control(opt_iff(r,iff));
a61af66fc99e Initial load
duke
parents:
diff changeset
1444
a61af66fc99e Initial load
duke
parents:
diff changeset
1445 // Set fast path result
a61af66fc99e Initial load
duke
parents:
diff changeset
1446 phi->init_req(2,trig);
a61af66fc99e Initial load
duke
parents:
diff changeset
1447
a61af66fc99e Initial load
duke
parents:
diff changeset
1448 // Slow path - non-blocking leaf call
a61af66fc99e Initial load
duke
parents:
diff changeset
1449 Node* call = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1450 switch (id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1451 case vmIntrinsics::_dsin:
a61af66fc99e Initial load
duke
parents:
diff changeset
1452 call = make_runtime_call(RC_LEAF, OptoRuntime::Math_D_D_Type(),
a61af66fc99e Initial load
duke
parents:
diff changeset
1453 CAST_FROM_FN_PTR(address, SharedRuntime::dsin),
a61af66fc99e Initial load
duke
parents:
diff changeset
1454 "Sin", NULL, arg, top());
a61af66fc99e Initial load
duke
parents:
diff changeset
1455 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1456 case vmIntrinsics::_dcos:
a61af66fc99e Initial load
duke
parents:
diff changeset
1457 call = make_runtime_call(RC_LEAF, OptoRuntime::Math_D_D_Type(),
a61af66fc99e Initial load
duke
parents:
diff changeset
1458 CAST_FROM_FN_PTR(address, SharedRuntime::dcos),
a61af66fc99e Initial load
duke
parents:
diff changeset
1459 "Cos", NULL, arg, top());
a61af66fc99e Initial load
duke
parents:
diff changeset
1460 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1461 case vmIntrinsics::_dtan:
a61af66fc99e Initial load
duke
parents:
diff changeset
1462 call = make_runtime_call(RC_LEAF, OptoRuntime::Math_D_D_Type(),
a61af66fc99e Initial load
duke
parents:
diff changeset
1463 CAST_FROM_FN_PTR(address, SharedRuntime::dtan),
a61af66fc99e Initial load
duke
parents:
diff changeset
1464 "Tan", NULL, arg, top());
a61af66fc99e Initial load
duke
parents:
diff changeset
1465 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1466 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1467 assert(control()->in(0) == call, "");
a61af66fc99e Initial load
duke
parents:
diff changeset
1468 Node* slow_result = _gvn.transform(new (C, 1) ProjNode(call,TypeFunc::Parms));
a61af66fc99e Initial load
duke
parents:
diff changeset
1469 r->init_req(1,control());
a61af66fc99e Initial load
duke
parents:
diff changeset
1470 phi->init_req(1,slow_result);
a61af66fc99e Initial load
duke
parents:
diff changeset
1471
a61af66fc99e Initial load
duke
parents:
diff changeset
1472 // Post-merge
a61af66fc99e Initial load
duke
parents:
diff changeset
1473 set_control(_gvn.transform(r));
a61af66fc99e Initial load
duke
parents:
diff changeset
1474 record_for_igvn(r);
a61af66fc99e Initial load
duke
parents:
diff changeset
1475 trig = _gvn.transform(phi);
a61af66fc99e Initial load
duke
parents:
diff changeset
1476
a61af66fc99e Initial load
duke
parents:
diff changeset
1477 C->set_has_split_ifs(true); // Has chance for split-if optimization
a61af66fc99e Initial load
duke
parents:
diff changeset
1478 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1479 // Push result back on JVM stack
a61af66fc99e Initial load
duke
parents:
diff changeset
1480 push_pair(trig);
a61af66fc99e Initial load
duke
parents:
diff changeset
1481 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
1482 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1483
a61af66fc99e Initial load
duke
parents:
diff changeset
1484 //------------------------------inline_sqrt-------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1485 // Inline square root instruction, if possible.
a61af66fc99e Initial load
duke
parents:
diff changeset
1486 bool LibraryCallKit::inline_sqrt(vmIntrinsics::ID id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1487 assert(id == vmIntrinsics::_dsqrt, "Not square root");
a61af66fc99e Initial load
duke
parents:
diff changeset
1488 _sp += arg_size(); // restore stack pointer
a61af66fc99e Initial load
duke
parents:
diff changeset
1489 push_pair(_gvn.transform(new (C, 2) SqrtDNode(0, pop_math_arg())));
a61af66fc99e Initial load
duke
parents:
diff changeset
1490 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
1491 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1492
a61af66fc99e Initial load
duke
parents:
diff changeset
1493 //------------------------------inline_abs-------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1494 // Inline absolute value instruction, if possible.
a61af66fc99e Initial load
duke
parents:
diff changeset
1495 bool LibraryCallKit::inline_abs(vmIntrinsics::ID id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1496 assert(id == vmIntrinsics::_dabs, "Not absolute value");
a61af66fc99e Initial load
duke
parents:
diff changeset
1497 _sp += arg_size(); // restore stack pointer
a61af66fc99e Initial load
duke
parents:
diff changeset
1498 push_pair(_gvn.transform(new (C, 2) AbsDNode(pop_math_arg())));
a61af66fc99e Initial load
duke
parents:
diff changeset
1499 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
1500 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1501
a61af66fc99e Initial load
duke
parents:
diff changeset
1502 //------------------------------inline_exp-------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1503 // Inline exp instructions, if possible. The Intel hardware only misses
a61af66fc99e Initial load
duke
parents:
diff changeset
1504 // really odd corner cases (+/- Infinity). Just uncommon-trap them.
a61af66fc99e Initial load
duke
parents:
diff changeset
1505 bool LibraryCallKit::inline_exp(vmIntrinsics::ID id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1506 assert(id == vmIntrinsics::_dexp, "Not exp");
a61af66fc99e Initial load
duke
parents:
diff changeset
1507
a61af66fc99e Initial load
duke
parents:
diff changeset
1508 // If this inlining ever returned NaN in the past, we do not intrinsify it
a61af66fc99e Initial load
duke
parents:
diff changeset
1509 // every again. NaN results requires StrictMath.exp handling.
a61af66fc99e Initial load
duke
parents:
diff changeset
1510 if (too_many_traps(Deoptimization::Reason_intrinsic)) return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
1511
a61af66fc99e Initial load
duke
parents:
diff changeset
1512 // Do not intrinsify on older platforms which lack cmove.
a61af66fc99e Initial load
duke
parents:
diff changeset
1513 if (ConditionalMoveLimit == 0) return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
1514
a61af66fc99e Initial load
duke
parents:
diff changeset
1515 _sp += arg_size(); // restore stack pointer
a61af66fc99e Initial load
duke
parents:
diff changeset
1516 Node *x = pop_math_arg();
a61af66fc99e Initial load
duke
parents:
diff changeset
1517 Node *result = _gvn.transform(new (C, 2) ExpDNode(0,x));
a61af66fc99e Initial load
duke
parents:
diff changeset
1518
a61af66fc99e Initial load
duke
parents:
diff changeset
1519 //-------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1520 //result=(result.isNaN())? StrictMath::exp():result;
a61af66fc99e Initial load
duke
parents:
diff changeset
1521 // Check: If isNaN() by checking result!=result? then go to Strict Math
a61af66fc99e Initial load
duke
parents:
diff changeset
1522 Node* cmpisnan = _gvn.transform(new (C, 3) CmpDNode(result,result));
a61af66fc99e Initial load
duke
parents:
diff changeset
1523 // Build the boolean node
a61af66fc99e Initial load
duke
parents:
diff changeset
1524 Node* bolisnum = _gvn.transform( new (C, 2) BoolNode(cmpisnan, BoolTest::eq) );
a61af66fc99e Initial load
duke
parents:
diff changeset
1525
a61af66fc99e Initial load
duke
parents:
diff changeset
1526 { BuildCutout unless(this, bolisnum, PROB_STATIC_FREQUENT);
a61af66fc99e Initial load
duke
parents:
diff changeset
1527 // End the current control-flow path
a61af66fc99e Initial load
duke
parents:
diff changeset
1528 push_pair(x);
a61af66fc99e Initial load
duke
parents:
diff changeset
1529 // Math.exp intrinsic returned a NaN, which requires StrictMath.exp
a61af66fc99e Initial load
duke
parents:
diff changeset
1530 // to handle. Recompile without intrinsifying Math.exp
a61af66fc99e Initial load
duke
parents:
diff changeset
1531 uncommon_trap(Deoptimization::Reason_intrinsic,
a61af66fc99e Initial load
duke
parents:
diff changeset
1532 Deoptimization::Action_make_not_entrant);
a61af66fc99e Initial load
duke
parents:
diff changeset
1533 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1534
a61af66fc99e Initial load
duke
parents:
diff changeset
1535 C->set_has_split_ifs(true); // Has chance for split-if optimization
a61af66fc99e Initial load
duke
parents:
diff changeset
1536
a61af66fc99e Initial load
duke
parents:
diff changeset
1537 push_pair(result);
a61af66fc99e Initial load
duke
parents:
diff changeset
1538
a61af66fc99e Initial load
duke
parents:
diff changeset
1539 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
1540 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1541
a61af66fc99e Initial load
duke
parents:
diff changeset
1542 //------------------------------inline_pow-------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1543 // Inline power instructions, if possible.
a61af66fc99e Initial load
duke
parents:
diff changeset
1544 bool LibraryCallKit::inline_pow(vmIntrinsics::ID id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1545 assert(id == vmIntrinsics::_dpow, "Not pow");
a61af66fc99e Initial load
duke
parents:
diff changeset
1546
a61af66fc99e Initial load
duke
parents:
diff changeset
1547 // If this inlining ever returned NaN in the past, we do not intrinsify it
a61af66fc99e Initial load
duke
parents:
diff changeset
1548 // every again. NaN results requires StrictMath.pow handling.
a61af66fc99e Initial load
duke
parents:
diff changeset
1549 if (too_many_traps(Deoptimization::Reason_intrinsic)) return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
1550
a61af66fc99e Initial load
duke
parents:
diff changeset
1551 // Do not intrinsify on older platforms which lack cmove.
a61af66fc99e Initial load
duke
parents:
diff changeset
1552 if (ConditionalMoveLimit == 0) return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
1553
a61af66fc99e Initial load
duke
parents:
diff changeset
1554 // Pseudocode for pow
a61af66fc99e Initial load
duke
parents:
diff changeset
1555 // if (x <= 0.0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1556 // if ((double)((int)y)==y) { // if y is int
a61af66fc99e Initial load
duke
parents:
diff changeset
1557 // result = ((1&(int)y)==0)?-DPow(abs(x), y):DPow(abs(x), y)
a61af66fc99e Initial load
duke
parents:
diff changeset
1558 // } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1559 // result = NaN;
a61af66fc99e Initial load
duke
parents:
diff changeset
1560 // }
a61af66fc99e Initial load
duke
parents:
diff changeset
1561 // } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1562 // result = DPow(x,y);
a61af66fc99e Initial load
duke
parents:
diff changeset
1563 // }
a61af66fc99e Initial load
duke
parents:
diff changeset
1564 // if (result != result)? {
605
98cb887364d3 6810672: Comment typos
twisti
parents: 420
diff changeset
1565 // uncommon_trap();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1566 // }
a61af66fc99e Initial load
duke
parents:
diff changeset
1567 // return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
1568
a61af66fc99e Initial load
duke
parents:
diff changeset
1569 _sp += arg_size(); // restore stack pointer
a61af66fc99e Initial load
duke
parents:
diff changeset
1570 Node* y = pop_math_arg();
a61af66fc99e Initial load
duke
parents:
diff changeset
1571 Node* x = pop_math_arg();
a61af66fc99e Initial load
duke
parents:
diff changeset
1572
a61af66fc99e Initial load
duke
parents:
diff changeset
1573 Node *fast_result = _gvn.transform( new (C, 3) PowDNode(0, x, y) );
a61af66fc99e Initial load
duke
parents:
diff changeset
1574
a61af66fc99e Initial load
duke
parents:
diff changeset
1575 // Short form: if not top-level (i.e., Math.pow but inlining Math.pow
a61af66fc99e Initial load
duke
parents:
diff changeset
1576 // inside of something) then skip the fancy tests and just check for
a61af66fc99e Initial load
duke
parents:
diff changeset
1577 // NaN result.
a61af66fc99e Initial load
duke
parents:
diff changeset
1578 Node *result = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1579 if( jvms()->depth() >= 1 ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1580 result = fast_result;
a61af66fc99e Initial load
duke
parents:
diff changeset
1581 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1582
a61af66fc99e Initial load
duke
parents:
diff changeset
1583 // Set the merge point for If node with condition of (x <= 0.0)
a61af66fc99e Initial load
duke
parents:
diff changeset
1584 // There are four possible paths to region node and phi node
a61af66fc99e Initial load
duke
parents:
diff changeset
1585 RegionNode *r = new (C, 4) RegionNode(4);
a61af66fc99e Initial load
duke
parents:
diff changeset
1586 Node *phi = new (C, 4) PhiNode(r, Type::DOUBLE);
a61af66fc99e Initial load
duke
parents:
diff changeset
1587
a61af66fc99e Initial load
duke
parents:
diff changeset
1588 // Build the first if node: if (x <= 0.0)
a61af66fc99e Initial load
duke
parents:
diff changeset
1589 // Node for 0 constant
a61af66fc99e Initial load
duke
parents:
diff changeset
1590 Node *zeronode = makecon(TypeD::ZERO);
a61af66fc99e Initial load
duke
parents:
diff changeset
1591 // Check x:0
a61af66fc99e Initial load
duke
parents:
diff changeset
1592 Node *cmp = _gvn.transform(new (C, 3) CmpDNode(x, zeronode));
a61af66fc99e Initial load
duke
parents:
diff changeset
1593 // Check: If (x<=0) then go complex path
a61af66fc99e Initial load
duke
parents:
diff changeset
1594 Node *bol1 = _gvn.transform( new (C, 2) BoolNode( cmp, BoolTest::le ) );
a61af66fc99e Initial load
duke
parents:
diff changeset
1595 // Branch either way
a61af66fc99e Initial load
duke
parents:
diff changeset
1596 IfNode *if1 = create_and_xform_if(control(),bol1, PROB_STATIC_INFREQUENT, COUNT_UNKNOWN);
a61af66fc99e Initial load
duke
parents:
diff changeset
1597 Node *opt_test = _gvn.transform(if1);
a61af66fc99e Initial load
duke
parents:
diff changeset
1598 //assert( opt_test->is_If(), "Expect an IfNode");
a61af66fc99e Initial load
duke
parents:
diff changeset
1599 IfNode *opt_if1 = (IfNode*)opt_test;
a61af66fc99e Initial load
duke
parents:
diff changeset
1600 // Fast path taken; set region slot 3
a61af66fc99e Initial load
duke
parents:
diff changeset
1601 Node *fast_taken = _gvn.transform( new (C, 1) IfFalseNode(opt_if1) );
a61af66fc99e Initial load
duke
parents:
diff changeset
1602 r->init_req(3,fast_taken); // Capture fast-control
a61af66fc99e Initial load
duke
parents:
diff changeset
1603
a61af66fc99e Initial load
duke
parents:
diff changeset
1604 // Fast path not-taken, i.e. slow path
a61af66fc99e Initial load
duke
parents:
diff changeset
1605 Node *complex_path = _gvn.transform( new (C, 1) IfTrueNode(opt_if1) );
a61af66fc99e Initial load
duke
parents:
diff changeset
1606
a61af66fc99e Initial load
duke
parents:
diff changeset
1607 // Set fast path result
a61af66fc99e Initial load
duke
parents:
diff changeset
1608 Node *fast_result = _gvn.transform( new (C, 3) PowDNode(0, y, x) );
a61af66fc99e Initial load
duke
parents:
diff changeset
1609 phi->init_req(3, fast_result);
a61af66fc99e Initial load
duke
parents:
diff changeset
1610
a61af66fc99e Initial load
duke
parents:
diff changeset
1611 // Complex path
a61af66fc99e Initial load
duke
parents:
diff changeset
1612 // Build the second if node (if y is int)
a61af66fc99e Initial load
duke
parents:
diff changeset
1613 // Node for (int)y
a61af66fc99e Initial load
duke
parents:
diff changeset
1614 Node *inty = _gvn.transform( new (C, 2) ConvD2INode(y));
a61af66fc99e Initial load
duke
parents:
diff changeset
1615 // Node for (double)((int) y)
a61af66fc99e Initial load
duke
parents:
diff changeset
1616 Node *doubleinty= _gvn.transform( new (C, 2) ConvI2DNode(inty));
a61af66fc99e Initial load
duke
parents:
diff changeset
1617 // Check (double)((int) y) : y
a61af66fc99e Initial load
duke
parents:
diff changeset
1618 Node *cmpinty= _gvn.transform(new (C, 3) CmpDNode(doubleinty, y));
a61af66fc99e Initial load
duke
parents:
diff changeset
1619 // Check if (y isn't int) then go to slow path
a61af66fc99e Initial load
duke
parents:
diff changeset
1620
a61af66fc99e Initial load
duke
parents:
diff changeset
1621 Node *bol2 = _gvn.transform( new (C, 2) BoolNode( cmpinty, BoolTest::ne ) );
605
98cb887364d3 6810672: Comment typos
twisti
parents: 420
diff changeset
1622 // Branch either way
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1623 IfNode *if2 = create_and_xform_if(complex_path,bol2, PROB_STATIC_INFREQUENT, COUNT_UNKNOWN);
a61af66fc99e Initial load
duke
parents:
diff changeset
1624 Node *slow_path = opt_iff(r,if2); // Set region path 2
a61af66fc99e Initial load
duke
parents:
diff changeset
1625
a61af66fc99e Initial load
duke
parents:
diff changeset
1626 // Calculate DPow(abs(x), y)*(1 & (int)y)
a61af66fc99e Initial load
duke
parents:
diff changeset
1627 // Node for constant 1
a61af66fc99e Initial load
duke
parents:
diff changeset
1628 Node *conone = intcon(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
1629 // 1& (int)y
a61af66fc99e Initial load
duke
parents:
diff changeset
1630 Node *signnode= _gvn.transform( new (C, 3) AndINode(conone, inty) );
a61af66fc99e Initial load
duke
parents:
diff changeset
1631 // zero node
a61af66fc99e Initial load
duke
parents:
diff changeset
1632 Node *conzero = intcon(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1633 // Check (1&(int)y)==0?
a61af66fc99e Initial load
duke
parents:
diff changeset
1634 Node *cmpeq1 = _gvn.transform(new (C, 3) CmpINode(signnode, conzero));
a61af66fc99e Initial load
duke
parents:
diff changeset
1635 // Check if (1&(int)y)!=0?, if so the result is negative
a61af66fc99e Initial load
duke
parents:
diff changeset
1636 Node *bol3 = _gvn.transform( new (C, 2) BoolNode( cmpeq1, BoolTest::ne ) );
a61af66fc99e Initial load
duke
parents:
diff changeset
1637 // abs(x)
a61af66fc99e Initial load
duke
parents:
diff changeset
1638 Node *absx=_gvn.transform( new (C, 2) AbsDNode(x));
a61af66fc99e Initial load
duke
parents:
diff changeset
1639 // abs(x)^y
a61af66fc99e Initial load
duke
parents:
diff changeset
1640 Node *absxpowy = _gvn.transform( new (C, 3) PowDNode(0, y, absx) );
a61af66fc99e Initial load
duke
parents:
diff changeset
1641 // -abs(x)^y
a61af66fc99e Initial load
duke
parents:
diff changeset
1642 Node *negabsxpowy = _gvn.transform(new (C, 2) NegDNode (absxpowy));
a61af66fc99e Initial load
duke
parents:
diff changeset
1643 // (1&(int)y)==1?-DPow(abs(x), y):DPow(abs(x), y)
a61af66fc99e Initial load
duke
parents:
diff changeset
1644 Node *signresult = _gvn.transform( CMoveNode::make(C, NULL, bol3, absxpowy, negabsxpowy, Type::DOUBLE));
a61af66fc99e Initial load
duke
parents:
diff changeset
1645 // Set complex path fast result
a61af66fc99e Initial load
duke
parents:
diff changeset
1646 phi->init_req(2, signresult);
a61af66fc99e Initial load
duke
parents:
diff changeset
1647
a61af66fc99e Initial load
duke
parents:
diff changeset
1648 static const jlong nan_bits = CONST64(0x7ff8000000000000);
a61af66fc99e Initial load
duke
parents:
diff changeset
1649 Node *slow_result = makecon(TypeD::make(*(double*)&nan_bits)); // return NaN
a61af66fc99e Initial load
duke
parents:
diff changeset
1650 r->init_req(1,slow_path);
a61af66fc99e Initial load
duke
parents:
diff changeset
1651 phi->init_req(1,slow_result);
a61af66fc99e Initial load
duke
parents:
diff changeset
1652
a61af66fc99e Initial load
duke
parents:
diff changeset
1653 // Post merge
a61af66fc99e Initial load
duke
parents:
diff changeset
1654 set_control(_gvn.transform(r));
a61af66fc99e Initial load
duke
parents:
diff changeset
1655 record_for_igvn(r);
a61af66fc99e Initial load
duke
parents:
diff changeset
1656 result=_gvn.transform(phi);
a61af66fc99e Initial load
duke
parents:
diff changeset
1657 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1658
a61af66fc99e Initial load
duke
parents:
diff changeset
1659 //-------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1660 //result=(result.isNaN())? uncommon_trap():result;
a61af66fc99e Initial load
duke
parents:
diff changeset
1661 // Check: If isNaN() by checking result!=result? then go to Strict Math
a61af66fc99e Initial load
duke
parents:
diff changeset
1662 Node* cmpisnan = _gvn.transform(new (C, 3) CmpDNode(result,result));
a61af66fc99e Initial load
duke
parents:
diff changeset
1663 // Build the boolean node
a61af66fc99e Initial load
duke
parents:
diff changeset
1664 Node* bolisnum = _gvn.transform( new (C, 2) BoolNode(cmpisnan, BoolTest::eq) );
a61af66fc99e Initial load
duke
parents:
diff changeset
1665
a61af66fc99e Initial load
duke
parents:
diff changeset
1666 { BuildCutout unless(this, bolisnum, PROB_STATIC_FREQUENT);
a61af66fc99e Initial load
duke
parents:
diff changeset
1667 // End the current control-flow path
a61af66fc99e Initial load
duke
parents:
diff changeset
1668 push_pair(x);
a61af66fc99e Initial load
duke
parents:
diff changeset
1669 push_pair(y);
a61af66fc99e Initial load
duke
parents:
diff changeset
1670 // Math.pow intrinsic returned a NaN, which requires StrictMath.pow
a61af66fc99e Initial load
duke
parents:
diff changeset
1671 // to handle. Recompile without intrinsifying Math.pow.
a61af66fc99e Initial load
duke
parents:
diff changeset
1672 uncommon_trap(Deoptimization::Reason_intrinsic,
a61af66fc99e Initial load
duke
parents:
diff changeset
1673 Deoptimization::Action_make_not_entrant);
a61af66fc99e Initial load
duke
parents:
diff changeset
1674 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1675
a61af66fc99e Initial load
duke
parents:
diff changeset
1676 C->set_has_split_ifs(true); // Has chance for split-if optimization
a61af66fc99e Initial load
duke
parents:
diff changeset
1677
a61af66fc99e Initial load
duke
parents:
diff changeset
1678 push_pair(result);
a61af66fc99e Initial load
duke
parents:
diff changeset
1679
a61af66fc99e Initial load
duke
parents:
diff changeset
1680 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
1681 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1682
a61af66fc99e Initial load
duke
parents:
diff changeset
1683 //------------------------------inline_trans-------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1684 // Inline transcendental instructions, if possible. The Intel hardware gets
a61af66fc99e Initial load
duke
parents:
diff changeset
1685 // these right, no funny corner cases missed.
a61af66fc99e Initial load
duke
parents:
diff changeset
1686 bool LibraryCallKit::inline_trans(vmIntrinsics::ID id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1687 _sp += arg_size(); // restore stack pointer
a61af66fc99e Initial load
duke
parents:
diff changeset
1688 Node* arg = pop_math_arg();
a61af66fc99e Initial load
duke
parents:
diff changeset
1689 Node* trans = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1690
a61af66fc99e Initial load
duke
parents:
diff changeset
1691 switch (id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1692 case vmIntrinsics::_dlog:
a61af66fc99e Initial load
duke
parents:
diff changeset
1693 trans = _gvn.transform((Node*)new (C, 2) LogDNode(arg));
a61af66fc99e Initial load
duke
parents:
diff changeset
1694 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1695 case vmIntrinsics::_dlog10:
a61af66fc99e Initial load
duke
parents:
diff changeset
1696 trans = _gvn.transform((Node*)new (C, 2) Log10DNode(arg));
a61af66fc99e Initial load
duke
parents:
diff changeset
1697 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1698 default:
a61af66fc99e Initial load
duke
parents:
diff changeset
1699 assert(false, "bad intrinsic was passed in");
a61af66fc99e Initial load
duke
parents:
diff changeset
1700 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
1701 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1702
a61af66fc99e Initial load
duke
parents:
diff changeset
1703 // Push result back on JVM stack
a61af66fc99e Initial load
duke
parents:
diff changeset
1704 push_pair(trans);
a61af66fc99e Initial load
duke
parents:
diff changeset
1705 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
1706 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1707
a61af66fc99e Initial load
duke
parents:
diff changeset
1708 //------------------------------runtime_math-----------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1709 bool LibraryCallKit::runtime_math(const TypeFunc* call_type, address funcAddr, const char* funcName) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1710 Node* a = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1711 Node* b = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1712
a61af66fc99e Initial load
duke
parents:
diff changeset
1713 assert(call_type == OptoRuntime::Math_DD_D_Type() || call_type == OptoRuntime::Math_D_D_Type(),
a61af66fc99e Initial load
duke
parents:
diff changeset
1714 "must be (DD)D or (D)D type");
a61af66fc99e Initial load
duke
parents:
diff changeset
1715
a61af66fc99e Initial load
duke
parents:
diff changeset
1716 // Inputs
a61af66fc99e Initial load
duke
parents:
diff changeset
1717 _sp += arg_size(); // restore stack pointer
a61af66fc99e Initial load
duke
parents:
diff changeset
1718 if (call_type == OptoRuntime::Math_DD_D_Type()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1719 b = pop_math_arg();
a61af66fc99e Initial load
duke
parents:
diff changeset
1720 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1721 a = pop_math_arg();
a61af66fc99e Initial load
duke
parents:
diff changeset
1722
a61af66fc99e Initial load
duke
parents:
diff changeset
1723 const TypePtr* no_memory_effects = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1724 Node* trig = make_runtime_call(RC_LEAF, call_type, funcAddr, funcName,
a61af66fc99e Initial load
duke
parents:
diff changeset
1725 no_memory_effects,
a61af66fc99e Initial load
duke
parents:
diff changeset
1726 a, top(), b, b ? top() : NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
1727 Node* value = _gvn.transform(new (C, 1) ProjNode(trig, TypeFunc::Parms+0));
a61af66fc99e Initial load
duke
parents:
diff changeset
1728 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
1729 Node* value_top = _gvn.transform(new (C, 1) ProjNode(trig, TypeFunc::Parms+1));
a61af66fc99e Initial load
duke
parents:
diff changeset
1730 assert(value_top == top(), "second value must be top");
a61af66fc99e Initial load
duke
parents:
diff changeset
1731 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
1732
a61af66fc99e Initial load
duke
parents:
diff changeset
1733 push_pair(value);
a61af66fc99e Initial load
duke
parents:
diff changeset
1734 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
1735 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1736
a61af66fc99e Initial load
duke
parents:
diff changeset
1737 //------------------------------inline_math_native-----------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1738 bool LibraryCallKit::inline_math_native(vmIntrinsics::ID id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1739 switch (id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1740 // These intrinsics are not properly supported on all hardware
a61af66fc99e Initial load
duke
parents:
diff changeset
1741 case vmIntrinsics::_dcos: return Matcher::has_match_rule(Op_CosD) ? inline_trig(id) :
a61af66fc99e Initial load
duke
parents:
diff changeset
1742 runtime_math(OptoRuntime::Math_D_D_Type(), CAST_FROM_FN_PTR(address, SharedRuntime::dcos), "COS");
a61af66fc99e Initial load
duke
parents:
diff changeset
1743 case vmIntrinsics::_dsin: return Matcher::has_match_rule(Op_SinD) ? inline_trig(id) :
a61af66fc99e Initial load
duke
parents:
diff changeset
1744 runtime_math(OptoRuntime::Math_D_D_Type(), CAST_FROM_FN_PTR(address, SharedRuntime::dsin), "SIN");
a61af66fc99e Initial load
duke
parents:
diff changeset
1745 case vmIntrinsics::_dtan: return Matcher::has_match_rule(Op_TanD) ? inline_trig(id) :
a61af66fc99e Initial load
duke
parents:
diff changeset
1746 runtime_math(OptoRuntime::Math_D_D_Type(), CAST_FROM_FN_PTR(address, SharedRuntime::dtan), "TAN");
a61af66fc99e Initial load
duke
parents:
diff changeset
1747
a61af66fc99e Initial load
duke
parents:
diff changeset
1748 case vmIntrinsics::_dlog: return Matcher::has_match_rule(Op_LogD) ? inline_trans(id) :
a61af66fc99e Initial load
duke
parents:
diff changeset
1749 runtime_math(OptoRuntime::Math_D_D_Type(), CAST_FROM_FN_PTR(address, SharedRuntime::dlog), "LOG");
a61af66fc99e Initial load
duke
parents:
diff changeset
1750 case vmIntrinsics::_dlog10: return Matcher::has_match_rule(Op_Log10D) ? inline_trans(id) :
a61af66fc99e Initial load
duke
parents:
diff changeset
1751 runtime_math(OptoRuntime::Math_D_D_Type(), CAST_FROM_FN_PTR(address, SharedRuntime::dlog10), "LOG10");
a61af66fc99e Initial load
duke
parents:
diff changeset
1752
a61af66fc99e Initial load
duke
parents:
diff changeset
1753 // These intrinsics are supported on all hardware
a61af66fc99e Initial load
duke
parents:
diff changeset
1754 case vmIntrinsics::_dsqrt: return Matcher::has_match_rule(Op_SqrtD) ? inline_sqrt(id) : false;
a61af66fc99e Initial load
duke
parents:
diff changeset
1755 case vmIntrinsics::_dabs: return Matcher::has_match_rule(Op_AbsD) ? inline_abs(id) : false;
a61af66fc99e Initial load
duke
parents:
diff changeset
1756
a61af66fc99e Initial load
duke
parents:
diff changeset
1757 // These intrinsics don't work on X86. The ad implementation doesn't
a61af66fc99e Initial load
duke
parents:
diff changeset
1758 // handle NaN's properly. Instead of returning infinity, the ad
a61af66fc99e Initial load
duke
parents:
diff changeset
1759 // implementation returns a NaN on overflow. See bug: 6304089
a61af66fc99e Initial load
duke
parents:
diff changeset
1760 // Once the ad implementations are fixed, change the code below
a61af66fc99e Initial load
duke
parents:
diff changeset
1761 // to match the intrinsics above
a61af66fc99e Initial load
duke
parents:
diff changeset
1762
a61af66fc99e Initial load
duke
parents:
diff changeset
1763 case vmIntrinsics::_dexp: return
a61af66fc99e Initial load
duke
parents:
diff changeset
1764 runtime_math(OptoRuntime::Math_D_D_Type(), CAST_FROM_FN_PTR(address, SharedRuntime::dexp), "EXP");
a61af66fc99e Initial load
duke
parents:
diff changeset
1765 case vmIntrinsics::_dpow: return
a61af66fc99e Initial load
duke
parents:
diff changeset
1766 runtime_math(OptoRuntime::Math_DD_D_Type(), CAST_FROM_FN_PTR(address, SharedRuntime::dpow), "POW");
a61af66fc99e Initial load
duke
parents:
diff changeset
1767
a61af66fc99e Initial load
duke
parents:
diff changeset
1768 // These intrinsics are not yet correctly implemented
a61af66fc99e Initial load
duke
parents:
diff changeset
1769 case vmIntrinsics::_datan2:
a61af66fc99e Initial load
duke
parents:
diff changeset
1770 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
1771
a61af66fc99e Initial load
duke
parents:
diff changeset
1772 default:
a61af66fc99e Initial load
duke
parents:
diff changeset
1773 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
1774 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
1775 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1776 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1777
a61af66fc99e Initial load
duke
parents:
diff changeset
1778 static bool is_simple_name(Node* n) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1779 return (n->req() == 1 // constant
a61af66fc99e Initial load
duke
parents:
diff changeset
1780 || (n->is_Type() && n->as_Type()->type()->singleton())
a61af66fc99e Initial load
duke
parents:
diff changeset
1781 || n->is_Proj() // parameter or return value
a61af66fc99e Initial load
duke
parents:
diff changeset
1782 || n->is_Phi() // local of some sort
a61af66fc99e Initial load
duke
parents:
diff changeset
1783 );
a61af66fc99e Initial load
duke
parents:
diff changeset
1784 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1785
a61af66fc99e Initial load
duke
parents:
diff changeset
1786 //----------------------------inline_min_max-----------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1787 bool LibraryCallKit::inline_min_max(vmIntrinsics::ID id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1788 push(generate_min_max(id, argument(0), argument(1)));
a61af66fc99e Initial load
duke
parents:
diff changeset
1789
a61af66fc99e Initial load
duke
parents:
diff changeset
1790 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
1791 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1792
a61af66fc99e Initial load
duke
parents:
diff changeset
1793 Node*
a61af66fc99e Initial load
duke
parents:
diff changeset
1794 LibraryCallKit::generate_min_max(vmIntrinsics::ID id, Node* x0, Node* y0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1795 // These are the candidate return value:
a61af66fc99e Initial load
duke
parents:
diff changeset
1796 Node* xvalue = x0;
a61af66fc99e Initial load
duke
parents:
diff changeset
1797 Node* yvalue = y0;
a61af66fc99e Initial load
duke
parents:
diff changeset
1798
a61af66fc99e Initial load
duke
parents:
diff changeset
1799 if (xvalue == yvalue) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1800 return xvalue;
a61af66fc99e Initial load
duke
parents:
diff changeset
1801 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1802
a61af66fc99e Initial load
duke
parents:
diff changeset
1803 bool want_max = (id == vmIntrinsics::_max);
a61af66fc99e Initial load
duke
parents:
diff changeset
1804
a61af66fc99e Initial load
duke
parents:
diff changeset
1805 const TypeInt* txvalue = _gvn.type(xvalue)->isa_int();
a61af66fc99e Initial load
duke
parents:
diff changeset
1806 const TypeInt* tyvalue = _gvn.type(yvalue)->isa_int();
a61af66fc99e Initial load
duke
parents:
diff changeset
1807 if (txvalue == NULL || tyvalue == NULL) return top();
a61af66fc99e Initial load
duke
parents:
diff changeset
1808 // This is not really necessary, but it is consistent with a
a61af66fc99e Initial load
duke
parents:
diff changeset
1809 // hypothetical MaxINode::Value method:
a61af66fc99e Initial load
duke
parents:
diff changeset
1810 int widen = MAX2(txvalue->_widen, tyvalue->_widen);
a61af66fc99e Initial load
duke
parents:
diff changeset
1811
a61af66fc99e Initial load
duke
parents:
diff changeset
1812 // %%% This folding logic should (ideally) be in a different place.
a61af66fc99e Initial load
duke
parents:
diff changeset
1813 // Some should be inside IfNode, and there to be a more reliable
a61af66fc99e Initial load
duke
parents:
diff changeset
1814 // transformation of ?: style patterns into cmoves. We also want
a61af66fc99e Initial load
duke
parents:
diff changeset
1815 // more powerful optimizations around cmove and min/max.
a61af66fc99e Initial load
duke
parents:
diff changeset
1816
a61af66fc99e Initial load
duke
parents:
diff changeset
1817 // Try to find a dominating comparison of these guys.
a61af66fc99e Initial load
duke
parents:
diff changeset
1818 // It can simplify the index computation for Arrays.copyOf
a61af66fc99e Initial load
duke
parents:
diff changeset
1819 // and similar uses of System.arraycopy.
a61af66fc99e Initial load
duke
parents:
diff changeset
1820 // First, compute the normalized version of CmpI(x, y).
a61af66fc99e Initial load
duke
parents:
diff changeset
1821 int cmp_op = Op_CmpI;
a61af66fc99e Initial load
duke
parents:
diff changeset
1822 Node* xkey = xvalue;
a61af66fc99e Initial load
duke
parents:
diff changeset
1823 Node* ykey = yvalue;
a61af66fc99e Initial load
duke
parents:
diff changeset
1824 Node* ideal_cmpxy = _gvn.transform( new(C, 3) CmpINode(xkey, ykey) );
a61af66fc99e Initial load
duke
parents:
diff changeset
1825 if (ideal_cmpxy->is_Cmp()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1826 // E.g., if we have CmpI(length - offset, count),
a61af66fc99e Initial load
duke
parents:
diff changeset
1827 // it might idealize to CmpI(length, count + offset)
a61af66fc99e Initial load
duke
parents:
diff changeset
1828 cmp_op = ideal_cmpxy->Opcode();
a61af66fc99e Initial load
duke
parents:
diff changeset
1829 xkey = ideal_cmpxy->in(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
1830 ykey = ideal_cmpxy->in(2);
a61af66fc99e Initial load
duke
parents:
diff changeset
1831 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1832
a61af66fc99e Initial load
duke
parents:
diff changeset
1833 // Start by locating any relevant comparisons.
a61af66fc99e Initial load
duke
parents:
diff changeset
1834 Node* start_from = (xkey->outcnt() < ykey->outcnt()) ? xkey : ykey;
a61af66fc99e Initial load
duke
parents:
diff changeset
1835 Node* cmpxy = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1836 Node* cmpyx = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1837 for (DUIterator_Fast kmax, k = start_from->fast_outs(kmax); k < kmax; k++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1838 Node* cmp = start_from->fast_out(k);
a61af66fc99e Initial load
duke
parents:
diff changeset
1839 if (cmp->outcnt() > 0 && // must have prior uses
a61af66fc99e Initial load
duke
parents:
diff changeset
1840 cmp->in(0) == NULL && // must be context-independent
a61af66fc99e Initial load
duke
parents:
diff changeset
1841 cmp->Opcode() == cmp_op) { // right kind of compare
a61af66fc99e Initial load
duke
parents:
diff changeset
1842 if (cmp->in(1) == xkey && cmp->in(2) == ykey) cmpxy = cmp;
a61af66fc99e Initial load
duke
parents:
diff changeset
1843 if (cmp->in(1) == ykey && cmp->in(2) == xkey) cmpyx = cmp;
a61af66fc99e Initial load
duke
parents:
diff changeset
1844 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1845 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1846
a61af66fc99e Initial load
duke
parents:
diff changeset
1847 const int NCMPS = 2;
a61af66fc99e Initial load
duke
parents:
diff changeset
1848 Node* cmps[NCMPS] = { cmpxy, cmpyx };
a61af66fc99e Initial load
duke
parents:
diff changeset
1849 int cmpn;
a61af66fc99e Initial load
duke
parents:
diff changeset
1850 for (cmpn = 0; cmpn < NCMPS; cmpn++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1851 if (cmps[cmpn] != NULL) break; // find a result
a61af66fc99e Initial load
duke
parents:
diff changeset
1852 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1853 if (cmpn < NCMPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1854 // Look for a dominating test that tells us the min and max.
a61af66fc99e Initial load
duke
parents:
diff changeset
1855 int depth = 0; // Limit search depth for speed
a61af66fc99e Initial load
duke
parents:
diff changeset
1856 Node* dom = control();
a61af66fc99e Initial load
duke
parents:
diff changeset
1857 for (; dom != NULL; dom = IfNode::up_one_dom(dom, true)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1858 if (++depth >= 100) break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1859 Node* ifproj = dom;
a61af66fc99e Initial load
duke
parents:
diff changeset
1860 if (!ifproj->is_Proj()) continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
1861 Node* iff = ifproj->in(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1862 if (!iff->is_If()) continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
1863 Node* bol = iff->in(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
1864 if (!bol->is_Bool()) continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
1865 Node* cmp = bol->in(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
1866 if (cmp == NULL) continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
1867 for (cmpn = 0; cmpn < NCMPS; cmpn++)
a61af66fc99e Initial load
duke
parents:
diff changeset
1868 if (cmps[cmpn] == cmp) break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1869 if (cmpn == NCMPS) continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
1870 BoolTest::mask btest = bol->as_Bool()->_test._test;
a61af66fc99e Initial load
duke
parents:
diff changeset
1871 if (ifproj->is_IfFalse()) btest = BoolTest(btest).negate();
a61af66fc99e Initial load
duke
parents:
diff changeset
1872 if (cmp->in(1) == ykey) btest = BoolTest(btest).commute();
a61af66fc99e Initial load
duke
parents:
diff changeset
1873 // At this point, we know that 'x btest y' is true.
a61af66fc99e Initial load
duke
parents:
diff changeset
1874 switch (btest) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1875 case BoolTest::eq:
a61af66fc99e Initial load
duke
parents:
diff changeset
1876 // They are proven equal, so we can collapse the min/max.
a61af66fc99e Initial load
duke
parents:
diff changeset
1877 // Either value is the answer. Choose the simpler.
a61af66fc99e Initial load
duke
parents:
diff changeset
1878 if (is_simple_name(yvalue) && !is_simple_name(xvalue))
a61af66fc99e Initial load
duke
parents:
diff changeset
1879 return yvalue;
a61af66fc99e Initial load
duke
parents:
diff changeset
1880 return xvalue;
a61af66fc99e Initial load
duke
parents:
diff changeset
1881 case BoolTest::lt: // x < y
a61af66fc99e Initial load
duke
parents:
diff changeset
1882 case BoolTest::le: // x <= y
a61af66fc99e Initial load
duke
parents:
diff changeset
1883 return (want_max ? yvalue : xvalue);
a61af66fc99e Initial load
duke
parents:
diff changeset
1884 case BoolTest::gt: // x > y
a61af66fc99e Initial load
duke
parents:
diff changeset
1885 case BoolTest::ge: // x >= y
a61af66fc99e Initial load
duke
parents:
diff changeset
1886 return (want_max ? xvalue : yvalue);
a61af66fc99e Initial load
duke
parents:
diff changeset
1887 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1888 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1889 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1890
a61af66fc99e Initial load
duke
parents:
diff changeset
1891 // We failed to find a dominating test.
a61af66fc99e Initial load
duke
parents:
diff changeset
1892 // Let's pick a test that might GVN with prior tests.
a61af66fc99e Initial load
duke
parents:
diff changeset
1893 Node* best_bol = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1894 BoolTest::mask best_btest = BoolTest::illegal;
a61af66fc99e Initial load
duke
parents:
diff changeset
1895 for (cmpn = 0; cmpn < NCMPS; cmpn++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1896 Node* cmp = cmps[cmpn];
a61af66fc99e Initial load
duke
parents:
diff changeset
1897 if (cmp == NULL) continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
1898 for (DUIterator_Fast jmax, j = cmp->fast_outs(jmax); j < jmax; j++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1899 Node* bol = cmp->fast_out(j);
a61af66fc99e Initial load
duke
parents:
diff changeset
1900 if (!bol->is_Bool()) continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
1901 BoolTest::mask btest = bol->as_Bool()->_test._test;
a61af66fc99e Initial load
duke
parents:
diff changeset
1902 if (btest == BoolTest::eq || btest == BoolTest::ne) continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
1903 if (cmp->in(1) == ykey) btest = BoolTest(btest).commute();
a61af66fc99e Initial load
duke
parents:
diff changeset
1904 if (bol->outcnt() > (best_bol == NULL ? 0 : best_bol->outcnt())) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1905 best_bol = bol->as_Bool();
a61af66fc99e Initial load
duke
parents:
diff changeset
1906 best_btest = btest;
a61af66fc99e Initial load
duke
parents:
diff changeset
1907 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1908 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1909 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1910
a61af66fc99e Initial load
duke
parents:
diff changeset
1911 Node* answer_if_true = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1912 Node* answer_if_false = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1913 switch (best_btest) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1914 default:
a61af66fc99e Initial load
duke
parents:
diff changeset
1915 if (cmpxy == NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
1916 cmpxy = ideal_cmpxy;
a61af66fc99e Initial load
duke
parents:
diff changeset
1917 best_bol = _gvn.transform( new(C, 2) BoolNode(cmpxy, BoolTest::lt) );
a61af66fc99e Initial load
duke
parents:
diff changeset
1918 // and fall through:
a61af66fc99e Initial load
duke
parents:
diff changeset
1919 case BoolTest::lt: // x < y
a61af66fc99e Initial load
duke
parents:
diff changeset
1920 case BoolTest::le: // x <= y
a61af66fc99e Initial load
duke
parents:
diff changeset
1921 answer_if_true = (want_max ? yvalue : xvalue);
a61af66fc99e Initial load
duke
parents:
diff changeset
1922 answer_if_false = (want_max ? xvalue : yvalue);
a61af66fc99e Initial load
duke
parents:
diff changeset
1923 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1924 case BoolTest::gt: // x > y
a61af66fc99e Initial load
duke
parents:
diff changeset
1925 case BoolTest::ge: // x >= y
a61af66fc99e Initial load
duke
parents:
diff changeset
1926 answer_if_true = (want_max ? xvalue : yvalue);
a61af66fc99e Initial load
duke
parents:
diff changeset
1927 answer_if_false = (want_max ? yvalue : xvalue);
a61af66fc99e Initial load
duke
parents:
diff changeset
1928 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1929 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1930
a61af66fc99e Initial load
duke
parents:
diff changeset
1931 jint hi, lo;
a61af66fc99e Initial load
duke
parents:
diff changeset
1932 if (want_max) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1933 // We can sharpen the minimum.
a61af66fc99e Initial load
duke
parents:
diff changeset
1934 hi = MAX2(txvalue->_hi, tyvalue->_hi);
a61af66fc99e Initial load
duke
parents:
diff changeset
1935 lo = MAX2(txvalue->_lo, tyvalue->_lo);
a61af66fc99e Initial load
duke
parents:
diff changeset
1936 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1937 // We can sharpen the maximum.
a61af66fc99e Initial load
duke
parents:
diff changeset
1938 hi = MIN2(txvalue->_hi, tyvalue->_hi);
a61af66fc99e Initial load
duke
parents:
diff changeset
1939 lo = MIN2(txvalue->_lo, tyvalue->_lo);
a61af66fc99e Initial load
duke
parents:
diff changeset
1940 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1941
a61af66fc99e Initial load
duke
parents:
diff changeset
1942 // Use a flow-free graph structure, to avoid creating excess control edges
a61af66fc99e Initial load
duke
parents:
diff changeset
1943 // which could hinder other optimizations.
a61af66fc99e Initial load
duke
parents:
diff changeset
1944 // Since Math.min/max is often used with arraycopy, we want
a61af66fc99e Initial load
duke
parents:
diff changeset
1945 // tightly_coupled_allocation to be able to see beyond min/max expressions.
a61af66fc99e Initial load
duke
parents:
diff changeset
1946 Node* cmov = CMoveNode::make(C, NULL, best_bol,
a61af66fc99e Initial load
duke
parents:
diff changeset
1947 answer_if_false, answer_if_true,
a61af66fc99e Initial load
duke
parents:
diff changeset
1948 TypeInt::make(lo, hi, widen));
a61af66fc99e Initial load
duke
parents:
diff changeset
1949
a61af66fc99e Initial load
duke
parents:
diff changeset
1950 return _gvn.transform(cmov);
a61af66fc99e Initial load
duke
parents:
diff changeset
1951
a61af66fc99e Initial load
duke
parents:
diff changeset
1952 /*
a61af66fc99e Initial load
duke
parents:
diff changeset
1953 // This is not as desirable as it may seem, since Min and Max
a61af66fc99e Initial load
duke
parents:
diff changeset
1954 // nodes do not have a full set of optimizations.
a61af66fc99e Initial load
duke
parents:
diff changeset
1955 // And they would interfere, anyway, with 'if' optimizations
a61af66fc99e Initial load
duke
parents:
diff changeset
1956 // and with CMoveI canonical forms.
a61af66fc99e Initial load
duke
parents:
diff changeset
1957 switch (id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1958 case vmIntrinsics::_min:
a61af66fc99e Initial load
duke
parents:
diff changeset
1959 result_val = _gvn.transform(new (C, 3) MinINode(x,y)); break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1960 case vmIntrinsics::_max:
a61af66fc99e Initial load
duke
parents:
diff changeset
1961 result_val = _gvn.transform(new (C, 3) MaxINode(x,y)); break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1962 default:
a61af66fc99e Initial load
duke
parents:
diff changeset
1963 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
1964 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1965 */
a61af66fc99e Initial load
duke
parents:
diff changeset
1966 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1967
a61af66fc99e Initial load
duke
parents:
diff changeset
1968 inline int
a61af66fc99e Initial load
duke
parents:
diff changeset
1969 LibraryCallKit::classify_unsafe_addr(Node* &base, Node* &offset) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1970 const TypePtr* base_type = TypePtr::NULL_PTR;
a61af66fc99e Initial load
duke
parents:
diff changeset
1971 if (base != NULL) base_type = _gvn.type(base)->isa_ptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
1972 if (base_type == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1973 // Unknown type.
a61af66fc99e Initial load
duke
parents:
diff changeset
1974 return Type::AnyPtr;
a61af66fc99e Initial load
duke
parents:
diff changeset
1975 } else if (base_type == TypePtr::NULL_PTR) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1976 // Since this is a NULL+long form, we have to switch to a rawptr.
a61af66fc99e Initial load
duke
parents:
diff changeset
1977 base = _gvn.transform( new (C, 2) CastX2PNode(offset) );
a61af66fc99e Initial load
duke
parents:
diff changeset
1978 offset = MakeConX(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1979 return Type::RawPtr;
a61af66fc99e Initial load
duke
parents:
diff changeset
1980 } else if (base_type->base() == Type::RawPtr) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1981 return Type::RawPtr;
a61af66fc99e Initial load
duke
parents:
diff changeset
1982 } else if (base_type->isa_oopptr()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1983 // Base is never null => always a heap address.
a61af66fc99e Initial load
duke
parents:
diff changeset
1984 if (base_type->ptr() == TypePtr::NotNull) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1985 return Type::OopPtr;
a61af66fc99e Initial load
duke
parents:
diff changeset
1986 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1987 // Offset is small => always a heap address.
a61af66fc99e Initial load
duke
parents:
diff changeset
1988 const TypeX* offset_type = _gvn.type(offset)->isa_intptr_t();
a61af66fc99e Initial load
duke
parents:
diff changeset
1989 if (offset_type != NULL &&
a61af66fc99e Initial load
duke
parents:
diff changeset
1990 base_type->offset() == 0 && // (should always be?)
a61af66fc99e Initial load
duke
parents:
diff changeset
1991 offset_type->_lo >= 0 &&
a61af66fc99e Initial load
duke
parents:
diff changeset
1992 !MacroAssembler::needs_explicit_null_check(offset_type->_hi)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1993 return Type::OopPtr;
a61af66fc99e Initial load
duke
parents:
diff changeset
1994 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1995 // Otherwise, it might either be oop+off or NULL+addr.
a61af66fc99e Initial load
duke
parents:
diff changeset
1996 return Type::AnyPtr;
a61af66fc99e Initial load
duke
parents:
diff changeset
1997 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1998 // No information:
a61af66fc99e Initial load
duke
parents:
diff changeset
1999 return Type::AnyPtr;
a61af66fc99e Initial load
duke
parents:
diff changeset
2000 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2001 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2002
a61af66fc99e Initial load
duke
parents:
diff changeset
2003 inline Node* LibraryCallKit::make_unsafe_address(Node* base, Node* offset) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2004 int kind = classify_unsafe_addr(base, offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
2005 if (kind == Type::RawPtr) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2006 return basic_plus_adr(top(), base, offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
2007 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2008 return basic_plus_adr(base, offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
2009 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2010 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2011
775
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2012 //-------------------inline_numberOfLeadingZeros_int/long-----------------------
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2013 // inline int Integer.numberOfLeadingZeros(int)
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2014 // inline int Long.numberOfLeadingZeros(long)
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2015 bool LibraryCallKit::inline_numberOfLeadingZeros(vmIntrinsics::ID id) {
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2016 assert(id == vmIntrinsics::_numberOfLeadingZeros_i || id == vmIntrinsics::_numberOfLeadingZeros_l, "not numberOfLeadingZeros");
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2017 if (id == vmIntrinsics::_numberOfLeadingZeros_i && !Matcher::match_rule_supported(Op_CountLeadingZerosI)) return false;
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2018 if (id == vmIntrinsics::_numberOfLeadingZeros_l && !Matcher::match_rule_supported(Op_CountLeadingZerosL)) return false;
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2019 _sp += arg_size(); // restore stack pointer
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2020 switch (id) {
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2021 case vmIntrinsics::_numberOfLeadingZeros_i:
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2022 push(_gvn.transform(new (C, 2) CountLeadingZerosINode(pop())));
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2023 break;
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2024 case vmIntrinsics::_numberOfLeadingZeros_l:
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2025 push(_gvn.transform(new (C, 2) CountLeadingZerosLNode(pop_pair())));
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2026 break;
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2027 default:
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2028 ShouldNotReachHere();
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2029 }
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2030 return true;
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2031 }
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2032
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2033 //-------------------inline_numberOfTrailingZeros_int/long----------------------
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2034 // inline int Integer.numberOfTrailingZeros(int)
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2035 // inline int Long.numberOfTrailingZeros(long)
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2036 bool LibraryCallKit::inline_numberOfTrailingZeros(vmIntrinsics::ID id) {
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2037 assert(id == vmIntrinsics::_numberOfTrailingZeros_i || id == vmIntrinsics::_numberOfTrailingZeros_l, "not numberOfTrailingZeros");
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2038 if (id == vmIntrinsics::_numberOfTrailingZeros_i && !Matcher::match_rule_supported(Op_CountTrailingZerosI)) return false;
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2039 if (id == vmIntrinsics::_numberOfTrailingZeros_l && !Matcher::match_rule_supported(Op_CountTrailingZerosL)) return false;
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2040 _sp += arg_size(); // restore stack pointer
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2041 switch (id) {
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2042 case vmIntrinsics::_numberOfTrailingZeros_i:
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2043 push(_gvn.transform(new (C, 2) CountTrailingZerosINode(pop())));
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2044 break;
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2045 case vmIntrinsics::_numberOfTrailingZeros_l:
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2046 push(_gvn.transform(new (C, 2) CountTrailingZerosLNode(pop_pair())));
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2047 break;
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2048 default:
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2049 ShouldNotReachHere();
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2050 }
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2051 return true;
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2052 }
93c14e5562c4 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 730
diff changeset
2053
643
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
2054 //----------------------------inline_bitCount_int/long-----------------------
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
2055 // inline int Integer.bitCount(int)
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
2056 // inline int Long.bitCount(long)
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
2057 bool LibraryCallKit::inline_bitCount(vmIntrinsics::ID id) {
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
2058 assert(id == vmIntrinsics::_bitCount_i || id == vmIntrinsics::_bitCount_l, "not bitCount");
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
2059 if (id == vmIntrinsics::_bitCount_i && !Matcher::has_match_rule(Op_PopCountI)) return false;
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
2060 if (id == vmIntrinsics::_bitCount_l && !Matcher::has_match_rule(Op_PopCountL)) return false;
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
2061 _sp += arg_size(); // restore stack pointer
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
2062 switch (id) {
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
2063 case vmIntrinsics::_bitCount_i:
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
2064 push(_gvn.transform(new (C, 2) PopCountINode(pop())));
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
2065 break;
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
2066 case vmIntrinsics::_bitCount_l:
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
2067 push(_gvn.transform(new (C, 2) PopCountLNode(pop_pair())));
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
2068 break;
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
2069 default:
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
2070 ShouldNotReachHere();
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
2071 }
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
2072 return true;
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
2073 }
c771b7f43bbf 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 605
diff changeset
2074
1396
d7f654633cfe 6946040: add intrinsic for short and char reverseBytes
never
parents: 1152
diff changeset
2075 //----------------------------inline_reverseBytes_int/long/char/short-------------------
605
98cb887364d3 6810672: Comment typos
twisti
parents: 420
diff changeset
2076 // inline Integer.reverseBytes(int)
98cb887364d3 6810672: Comment typos
twisti
parents: 420
diff changeset
2077 // inline Long.reverseBytes(long)
1396
d7f654633cfe 6946040: add intrinsic for short and char reverseBytes
never
parents: 1152
diff changeset
2078 // inline Character.reverseBytes(char)
d7f654633cfe 6946040: add intrinsic for short and char reverseBytes
never
parents: 1152
diff changeset
2079 // inline Short.reverseBytes(short)
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2080 bool LibraryCallKit::inline_reverseBytes(vmIntrinsics::ID id) {
1396
d7f654633cfe 6946040: add intrinsic for short and char reverseBytes
never
parents: 1152
diff changeset
2081 assert(id == vmIntrinsics::_reverseBytes_i || id == vmIntrinsics::_reverseBytes_l ||
d7f654633cfe 6946040: add intrinsic for short and char reverseBytes
never
parents: 1152
diff changeset
2082 id == vmIntrinsics::_reverseBytes_c || id == vmIntrinsics::_reverseBytes_s,
d7f654633cfe 6946040: add intrinsic for short and char reverseBytes
never
parents: 1152
diff changeset
2083 "not reverse Bytes");
d7f654633cfe 6946040: add intrinsic for short and char reverseBytes
never
parents: 1152
diff changeset
2084 if (id == vmIntrinsics::_reverseBytes_i && !Matcher::has_match_rule(Op_ReverseBytesI)) return false;
d7f654633cfe 6946040: add intrinsic for short and char reverseBytes
never
parents: 1152
diff changeset
2085 if (id == vmIntrinsics::_reverseBytes_l && !Matcher::has_match_rule(Op_ReverseBytesL)) return false;
d7f654633cfe 6946040: add intrinsic for short and char reverseBytes
never
parents: 1152
diff changeset
2086 if (id == vmIntrinsics::_reverseBytes_c && !Matcher::has_match_rule(Op_ReverseBytesUS)) return false;
d7f654633cfe 6946040: add intrinsic for short and char reverseBytes
never
parents: 1152
diff changeset
2087 if (id == vmIntrinsics::_reverseBytes_s && !Matcher::has_match_rule(Op_ReverseBytesS)) return false;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2088 _sp += arg_size(); // restore stack pointer
a61af66fc99e Initial load
duke
parents:
diff changeset
2089 switch (id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2090 case vmIntrinsics::_reverseBytes_i:
a61af66fc99e Initial load
duke
parents:
diff changeset
2091 push(_gvn.transform(new (C, 2) ReverseBytesINode(0, pop())));
a61af66fc99e Initial load
duke
parents:
diff changeset
2092 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
2093 case vmIntrinsics::_reverseBytes_l:
a61af66fc99e Initial load
duke
parents:
diff changeset
2094 push_pair(_gvn.transform(new (C, 2) ReverseBytesLNode(0, pop_pair())));
a61af66fc99e Initial load
duke
parents:
diff changeset
2095 break;
1396
d7f654633cfe 6946040: add intrinsic for short and char reverseBytes
never
parents: 1152
diff changeset
2096 case vmIntrinsics::_reverseBytes_c:
d7f654633cfe 6946040: add intrinsic for short and char reverseBytes
never
parents: 1152
diff changeset
2097 push(_gvn.transform(new (C, 2) ReverseBytesUSNode(0, pop())));
d7f654633cfe 6946040: add intrinsic for short and char reverseBytes
never
parents: 1152
diff changeset
2098 break;
d7f654633cfe 6946040: add intrinsic for short and char reverseBytes
never
parents: 1152
diff changeset
2099 case vmIntrinsics::_reverseBytes_s:
d7f654633cfe 6946040: add intrinsic for short and char reverseBytes
never
parents: 1152
diff changeset
2100 push(_gvn.transform(new (C, 2) ReverseBytesSNode(0, pop())));
d7f654633cfe 6946040: add intrinsic for short and char reverseBytes
never
parents: 1152
diff changeset
2101 break;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2102 default:
a61af66fc99e Initial load
duke
parents:
diff changeset
2103 ;
a61af66fc99e Initial load
duke
parents:
diff changeset
2104 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2105 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2106 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2107
a61af66fc99e Initial load
duke
parents:
diff changeset
2108 //----------------------------inline_unsafe_access----------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2109
a61af66fc99e Initial load
duke
parents:
diff changeset
2110 const static BasicType T_ADDRESS_HOLDER = T_LONG;
a61af66fc99e Initial load
duke
parents:
diff changeset
2111
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2112 // Helper that guards and inserts a G1 pre-barrier.
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2113 void LibraryCallKit::insert_g1_pre_barrier(Node* base_oop, Node* offset, Node* pre_val) {
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2114 assert(UseG1GC, "should not call this otherwise");
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2115
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2116 // We could be accessing the referent field of a reference object. If so, when G1
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2117 // is enabled, we need to log the value in the referent field in an SATB buffer.
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2118 // This routine performs some compile time filters and generates suitable
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2119 // runtime filters that guard the pre-barrier code.
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2120
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2121 // Some compile time checks.
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2122
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2123 // If offset is a constant, is it java_lang_ref_Reference::_reference_offset?
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2124 const TypeX* otype = offset->find_intptr_t_type();
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2125 if (otype != NULL && otype->is_con() &&
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2126 otype->get_con() != java_lang_ref_Reference::referent_offset) {
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2127 // Constant offset but not the reference_offset so just return
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2128 return;
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2129 }
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2130
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2131 // We only need to generate the runtime guards for instances.
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2132 const TypeOopPtr* btype = base_oop->bottom_type()->isa_oopptr();
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2133 if (btype != NULL) {
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2134 if (btype->isa_aryptr()) {
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2135 // Array type so nothing to do
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2136 return;
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2137 }
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2138
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2139 const TypeInstPtr* itype = btype->isa_instptr();
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2140 if (itype != NULL) {
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2141 // Can the klass of base_oop be statically determined
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2142 // to be _not_ a sub-class of Reference?
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2143 ciKlass* klass = itype->klass();
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2144 if (klass->is_subtype_of(env()->Reference_klass()) &&
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2145 !env()->Reference_klass()->is_subtype_of(klass)) {
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2146 return;
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2147 }
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2148 }
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2149 }
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2150
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2151 // The compile time filters did not reject base_oop/offset so
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2152 // we need to generate the following runtime filters
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2153 //
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2154 // if (offset == java_lang_ref_Reference::_reference_offset) {
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2155 // if (base != null) {
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2156 // if (klass(base)->reference_type() != REF_NONE)) {
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2157 // pre_barrier(_, pre_val, ...);
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2158 // }
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2159 // }
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2160 // }
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2161
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2162 float likely = PROB_LIKELY(0.999);
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2163 float unlikely = PROB_UNLIKELY(0.999);
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2164
3255
johnc
parents: 2446 3254
diff changeset
2165 IdealKit ideal(this);
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2166 #define __ ideal.
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2167
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2168 const int reference_type_offset = instanceKlass::reference_type_offset_in_bytes() +
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2169 sizeof(oopDesc);
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2170
3254
59766fd005ff 7035117: G1: nsk/stress/jni/jnistress002 fails with assertion failure
johnc
parents: 3252
diff changeset
2171 Node* referent_off = __ ConX(java_lang_ref_Reference::referent_offset);
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2172
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2173 __ if_then(offset, BoolTest::eq, referent_off, unlikely); {
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2174 __ if_then(base_oop, BoolTest::ne, null(), likely); {
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2175
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2176 // Update graphKit memory and control from IdealKit.
3255
johnc
parents: 2446 3254
diff changeset
2177 sync_kit(ideal);
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2178
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2179 Node* ref_klass_con = makecon(TypeKlassPtr::make(env()->Reference_klass()));
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2180 Node* is_instof = gen_instanceof(base_oop, ref_klass_con);
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2181
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2182 // Update IdealKit memory and control from graphKit.
3255
johnc
parents: 2446 3254
diff changeset
2183 __ sync_kit(this);
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2184
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2185 Node* one = __ ConI(1);
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2186
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2187 __ if_then(is_instof, BoolTest::eq, one, unlikely); {
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2188
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2189 // Update graphKit from IdeakKit.
3255
johnc
parents: 2446 3254
diff changeset
2190 sync_kit(ideal);
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2191
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2192 // Use the pre-barrier to record the value in the referent field
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2193 pre_barrier(false /* do_load */,
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2194 __ ctrl(),
3258
edd9b016deb6 7036021: G1: build failure on win64 and linux with hs21 in jdk6 build environment
johnc
parents: 3255
diff changeset
2195 NULL /* obj */, NULL /* adr */, max_juint /* alias_idx */, NULL /* val */, NULL /* val_type */,
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2196 pre_val /* pre_val */,
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2197 T_OBJECT);
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2198
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2199 // Update IdealKit from graphKit.
3255
johnc
parents: 2446 3254
diff changeset
2200 __ sync_kit(this);
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2201
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2202 } __ end_if(); // _ref_type != ref_none
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2203 } __ end_if(); // base != NULL
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2204 } __ end_if(); // offset == referent_offset
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2205
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2206 // Final sync IdealKit and GraphKit.
3255
johnc
parents: 2446 3254
diff changeset
2207 final_sync(ideal);
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2208 #undef __
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2209 }
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2210
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2211
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2212 // Interpret Unsafe.fieldOffset cookies correctly:
a61af66fc99e Initial load
duke
parents:
diff changeset
2213 extern jlong Unsafe_field_offset_to_byte_offset(jlong field_offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
2214
a61af66fc99e Initial load
duke
parents:
diff changeset
2215 bool LibraryCallKit::inline_unsafe_access(bool is_native_ptr, bool is_store, BasicType type, bool is_volatile) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2216 if (callee()->is_static()) return false; // caller must have the capability!
a61af66fc99e Initial load
duke
parents:
diff changeset
2217
a61af66fc99e Initial load
duke
parents:
diff changeset
2218 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
2219 {
a61af66fc99e Initial load
duke
parents:
diff changeset
2220 ResourceMark rm;
a61af66fc99e Initial load
duke
parents:
diff changeset
2221 // Check the signatures.
a61af66fc99e Initial load
duke
parents:
diff changeset
2222 ciSignature* sig = signature();
a61af66fc99e Initial load
duke
parents:
diff changeset
2223 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
2224 if (!is_store) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2225 // Object getObject(Object base, int/long offset), etc.
a61af66fc99e Initial load
duke
parents:
diff changeset
2226 BasicType rtype = sig->return_type()->basic_type();
a61af66fc99e Initial load
duke
parents:
diff changeset
2227 if (rtype == T_ADDRESS_HOLDER && callee()->name() == ciSymbol::getAddress_name())
a61af66fc99e Initial load
duke
parents:
diff changeset
2228 rtype = T_ADDRESS; // it is really a C void*
a61af66fc99e Initial load
duke
parents:
diff changeset
2229 assert(rtype == type, "getter must return the expected value");
a61af66fc99e Initial load
duke
parents:
diff changeset
2230 if (!is_native_ptr) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2231 assert(sig->count() == 2, "oop getter has 2 arguments");
a61af66fc99e Initial load
duke
parents:
diff changeset
2232 assert(sig->type_at(0)->basic_type() == T_OBJECT, "getter base is object");
a61af66fc99e Initial load
duke
parents:
diff changeset
2233 assert(sig->type_at(1)->basic_type() == T_LONG, "getter offset is correct");
a61af66fc99e Initial load
duke
parents:
diff changeset
2234 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2235 assert(sig->count() == 1, "native getter has 1 argument");
a61af66fc99e Initial load
duke
parents:
diff changeset
2236 assert(sig->type_at(0)->basic_type() == T_LONG, "getter base is long");
a61af66fc99e Initial load
duke
parents:
diff changeset
2237 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2238 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2239 // void putObject(Object base, int/long offset, Object x), etc.
a61af66fc99e Initial load
duke
parents:
diff changeset
2240 assert(sig->return_type()->basic_type() == T_VOID, "putter must not return a value");
a61af66fc99e Initial load
duke
parents:
diff changeset
2241 if (!is_native_ptr) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2242 assert(sig->count() == 3, "oop putter has 3 arguments");
a61af66fc99e Initial load
duke
parents:
diff changeset
2243 assert(sig->type_at(0)->basic_type() == T_OBJECT, "putter base is object");
a61af66fc99e Initial load
duke
parents:
diff changeset
2244 assert(sig->type_at(1)->basic_type() == T_LONG, "putter offset is correct");
a61af66fc99e Initial load
duke
parents:
diff changeset
2245 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2246 assert(sig->count() == 2, "native putter has 2 arguments");
a61af66fc99e Initial load
duke
parents:
diff changeset
2247 assert(sig->type_at(0)->basic_type() == T_LONG, "putter base is long");
a61af66fc99e Initial load
duke
parents:
diff changeset
2248 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2249 BasicType vtype = sig->type_at(sig->count()-1)->basic_type();
a61af66fc99e Initial load
duke
parents:
diff changeset
2250 if (vtype == T_ADDRESS_HOLDER && callee()->name() == ciSymbol::putAddress_name())
a61af66fc99e Initial load
duke
parents:
diff changeset
2251 vtype = T_ADDRESS; // it is really a C void*
a61af66fc99e Initial load
duke
parents:
diff changeset
2252 assert(vtype == type, "putter must accept the expected value");
a61af66fc99e Initial load
duke
parents:
diff changeset
2253 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2254 #endif // ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
2255 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2256 #endif //PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
2257
a61af66fc99e Initial load
duke
parents:
diff changeset
2258 C->set_has_unsafe_access(true); // Mark eventual nmethod as "unsafe".
a61af66fc99e Initial load
duke
parents:
diff changeset
2259
a61af66fc99e Initial load
duke
parents:
diff changeset
2260 int type_words = type2size[ (type == T_ADDRESS) ? T_LONG : type ];
a61af66fc99e Initial load
duke
parents:
diff changeset
2261
a61af66fc99e Initial load
duke
parents:
diff changeset
2262 // Argument words: "this" plus (oop/offset) or (lo/hi) args plus maybe 1 or 2 value words
a61af66fc99e Initial load
duke
parents:
diff changeset
2263 int nargs = 1 + (is_native_ptr ? 2 : 3) + (is_store ? type_words : 0);
a61af66fc99e Initial load
duke
parents:
diff changeset
2264
a61af66fc99e Initial load
duke
parents:
diff changeset
2265 debug_only(int saved_sp = _sp);
a61af66fc99e Initial load
duke
parents:
diff changeset
2266 _sp += nargs;
a61af66fc99e Initial load
duke
parents:
diff changeset
2267
a61af66fc99e Initial load
duke
parents:
diff changeset
2268 Node* val;
a61af66fc99e Initial load
duke
parents:
diff changeset
2269 debug_only(val = (Node*)(uintptr_t)-1);
a61af66fc99e Initial load
duke
parents:
diff changeset
2270
a61af66fc99e Initial load
duke
parents:
diff changeset
2271
a61af66fc99e Initial load
duke
parents:
diff changeset
2272 if (is_store) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2273 // Get the value being stored. (Pop it first; it was pushed last.)
a61af66fc99e Initial load
duke
parents:
diff changeset
2274 switch (type) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2275 case T_DOUBLE:
a61af66fc99e Initial load
duke
parents:
diff changeset
2276 case T_LONG:
a61af66fc99e Initial load
duke
parents:
diff changeset
2277 case T_ADDRESS:
a61af66fc99e Initial load
duke
parents:
diff changeset
2278 val = pop_pair();
a61af66fc99e Initial load
duke
parents:
diff changeset
2279 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
2280 default:
a61af66fc99e Initial load
duke
parents:
diff changeset
2281 val = pop();
a61af66fc99e Initial load
duke
parents:
diff changeset
2282 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2283 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2284
a61af66fc99e Initial load
duke
parents:
diff changeset
2285 // Build address expression. See the code in inline_unsafe_prefetch.
a61af66fc99e Initial load
duke
parents:
diff changeset
2286 Node *adr;
a61af66fc99e Initial load
duke
parents:
diff changeset
2287 Node *heap_base_oop = top();
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2288 Node* offset = top();
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2289
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2290 if (!is_native_ptr) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2291 // The offset is a value produced by Unsafe.staticFieldOffset or Unsafe.objectFieldOffset
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2292 offset = pop_pair();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2293 // The base is either a Java object or a value produced by Unsafe.staticFieldBase
a61af66fc99e Initial load
duke
parents:
diff changeset
2294 Node* base = pop();
a61af66fc99e Initial load
duke
parents:
diff changeset
2295 // We currently rely on the cookies produced by Unsafe.xxxFieldOffset
a61af66fc99e Initial load
duke
parents:
diff changeset
2296 // to be plain byte offsets, which are also the same as those accepted
a61af66fc99e Initial load
duke
parents:
diff changeset
2297 // by oopDesc::field_base.
a61af66fc99e Initial load
duke
parents:
diff changeset
2298 assert(Unsafe_field_offset_to_byte_offset(11) == 11,
a61af66fc99e Initial load
duke
parents:
diff changeset
2299 "fieldOffset must be byte-scaled");
a61af66fc99e Initial load
duke
parents:
diff changeset
2300 // 32-bit machines ignore the high half!
a61af66fc99e Initial load
duke
parents:
diff changeset
2301 offset = ConvL2X(offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
2302 adr = make_unsafe_address(base, offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
2303 heap_base_oop = base;
a61af66fc99e Initial load
duke
parents:
diff changeset
2304 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2305 Node* ptr = pop_pair();
a61af66fc99e Initial load
duke
parents:
diff changeset
2306 // Adjust Java long to machine word:
a61af66fc99e Initial load
duke
parents:
diff changeset
2307 ptr = ConvL2X(ptr);
a61af66fc99e Initial load
duke
parents:
diff changeset
2308 adr = make_unsafe_address(NULL, ptr);
a61af66fc99e Initial load
duke
parents:
diff changeset
2309 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2310
a61af66fc99e Initial load
duke
parents:
diff changeset
2311 // Pop receiver last: it was pushed first.
a61af66fc99e Initial load
duke
parents:
diff changeset
2312 Node *receiver = pop();
a61af66fc99e Initial load
duke
parents:
diff changeset
2313
a61af66fc99e Initial load
duke
parents:
diff changeset
2314 assert(saved_sp == _sp, "must have correct argument count");
a61af66fc99e Initial load
duke
parents:
diff changeset
2315
a61af66fc99e Initial load
duke
parents:
diff changeset
2316 const TypePtr *adr_type = _gvn.type(adr)->isa_ptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
2317
a61af66fc99e Initial load
duke
parents:
diff changeset
2318 // First guess at the value type.
a61af66fc99e Initial load
duke
parents:
diff changeset
2319 const Type *value_type = Type::get_const_basic_type(type);
a61af66fc99e Initial load
duke
parents:
diff changeset
2320
a61af66fc99e Initial load
duke
parents:
diff changeset
2321 // Try to categorize the address. If it comes up as TypeJavaPtr::BOTTOM,
a61af66fc99e Initial load
duke
parents:
diff changeset
2322 // there was not enough information to nail it down.
a61af66fc99e Initial load
duke
parents:
diff changeset
2323 Compile::AliasType* alias_type = C->alias_type(adr_type);
a61af66fc99e Initial load
duke
parents:
diff changeset
2324 assert(alias_type->index() != Compile::AliasIdxBot, "no bare pointers here");
a61af66fc99e Initial load
duke
parents:
diff changeset
2325
a61af66fc99e Initial load
duke
parents:
diff changeset
2326 // We will need memory barriers unless we can determine a unique
a61af66fc99e Initial load
duke
parents:
diff changeset
2327 // alias category for this reference. (Note: If for some reason
a61af66fc99e Initial load
duke
parents:
diff changeset
2328 // the barriers get omitted and the unsafe reference begins to "pollute"
a61af66fc99e Initial load
duke
parents:
diff changeset
2329 // the alias analysis of the rest of the graph, either Compile::can_alias
a61af66fc99e Initial load
duke
parents:
diff changeset
2330 // or Compile::must_alias will throw a diagnostic assert.)
a61af66fc99e Initial load
duke
parents:
diff changeset
2331 bool need_mem_bar = (alias_type->adr_type() == TypeOopPtr::BOTTOM);
a61af66fc99e Initial load
duke
parents:
diff changeset
2332
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2333 // If we are reading the value of the referent field of a Reference
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2334 // object (either by using Unsafe directly or through reflection)
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2335 // then, if G1 is enabled, we need to record the referent in an
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2336 // SATB log buffer using the pre-barrier mechanism.
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2337 bool need_read_barrier = UseG1GC && !is_native_ptr && !is_store &&
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2338 offset != top() && heap_base_oop != top();
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2339
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2340 if (!is_store && type == T_OBJECT) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2341 // Attempt to infer a sharper value type from the offset and base type.
a61af66fc99e Initial load
duke
parents:
diff changeset
2342 ciKlass* sharpened_klass = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2343
a61af66fc99e Initial load
duke
parents:
diff changeset
2344 // See if it is an instance field, with an object type.
a61af66fc99e Initial load
duke
parents:
diff changeset
2345 if (alias_type->field() != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2346 assert(!is_native_ptr, "native pointer op cannot use a java address");
a61af66fc99e Initial load
duke
parents:
diff changeset
2347 if (alias_type->field()->type()->is_klass()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2348 sharpened_klass = alias_type->field()->type()->as_klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
2349 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2350 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2351
a61af66fc99e Initial load
duke
parents:
diff changeset
2352 // See if it is a narrow oop array.
a61af66fc99e Initial load
duke
parents:
diff changeset
2353 if (adr_type->isa_aryptr()) {
895
94b6d06fd759 6860920: serialize.cpp shouldn't use objArrayOopDesc::base_offset_in_bytes(T_BYTE)
twisti
parents: 851
diff changeset
2354 if (adr_type->offset() >= objArrayOopDesc::base_offset_in_bytes()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2355 const TypeOopPtr *elem_type = adr_type->is_aryptr()->elem()->isa_oopptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
2356 if (elem_type != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2357 sharpened_klass = elem_type->klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
2358 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2359 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2360 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2361
a61af66fc99e Initial load
duke
parents:
diff changeset
2362 if (sharpened_klass != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2363 const TypeOopPtr* tjp = TypeOopPtr::make_from_klass(sharpened_klass);
a61af66fc99e Initial load
duke
parents:
diff changeset
2364
a61af66fc99e Initial load
duke
parents:
diff changeset
2365 // Sharpen the value type.
a61af66fc99e Initial load
duke
parents:
diff changeset
2366 value_type = tjp;
a61af66fc99e Initial load
duke
parents:
diff changeset
2367
a61af66fc99e Initial load
duke
parents:
diff changeset
2368 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
2369 if (PrintIntrinsics || PrintInlining || PrintOptoInlining) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2370 tty->print(" from base type: "); adr_type->dump();
a61af66fc99e Initial load
duke
parents:
diff changeset
2371 tty->print(" sharpened value: "); value_type->dump();
a61af66fc99e Initial load
duke
parents:
diff changeset
2372 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2373 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
2374 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2375 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2376
a61af66fc99e Initial load
duke
parents:
diff changeset
2377 // Null check on self without removing any arguments. The argument
a61af66fc99e Initial load
duke
parents:
diff changeset
2378 // null check technically happens in the wrong place, which can lead to
a61af66fc99e Initial load
duke
parents:
diff changeset
2379 // invalid stack traces when the primitive is inlined into a method
a61af66fc99e Initial load
duke
parents:
diff changeset
2380 // which handles NullPointerExceptions.
a61af66fc99e Initial load
duke
parents:
diff changeset
2381 _sp += nargs;
a61af66fc99e Initial load
duke
parents:
diff changeset
2382 do_null_check(receiver, T_OBJECT);
a61af66fc99e Initial load
duke
parents:
diff changeset
2383 _sp -= nargs;
a61af66fc99e Initial load
duke
parents:
diff changeset
2384 if (stopped()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2385 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2386 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2387 // Heap pointers get a null-check from the interpreter,
a61af66fc99e Initial load
duke
parents:
diff changeset
2388 // as a courtesy. However, this is not guaranteed by Unsafe,
a61af66fc99e Initial load
duke
parents:
diff changeset
2389 // and it is not possible to fully distinguish unintended nulls
a61af66fc99e Initial load
duke
parents:
diff changeset
2390 // from intended ones in this API.
a61af66fc99e Initial load
duke
parents:
diff changeset
2391
a61af66fc99e Initial load
duke
parents:
diff changeset
2392 if (is_volatile) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2393 // We need to emit leading and trailing CPU membars (see below) in
a61af66fc99e Initial load
duke
parents:
diff changeset
2394 // addition to memory membars when is_volatile. This is a little
a61af66fc99e Initial load
duke
parents:
diff changeset
2395 // too strong, but avoids the need to insert per-alias-type
a61af66fc99e Initial load
duke
parents:
diff changeset
2396 // volatile membars (for stores; compare Parse::do_put_xxx), which
605
98cb887364d3 6810672: Comment typos
twisti
parents: 420
diff changeset
2397 // we cannot do effectively here because we probably only have a
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2398 // rough approximation of type.
a61af66fc99e Initial load
duke
parents:
diff changeset
2399 need_mem_bar = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2400 // For Stores, place a memory ordering barrier now.
a61af66fc99e Initial load
duke
parents:
diff changeset
2401 if (is_store)
a61af66fc99e Initial load
duke
parents:
diff changeset
2402 insert_mem_bar(Op_MemBarRelease);
a61af66fc99e Initial load
duke
parents:
diff changeset
2403 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2404
a61af66fc99e Initial load
duke
parents:
diff changeset
2405 // Memory barrier to prevent normal and 'unsafe' accesses from
a61af66fc99e Initial load
duke
parents:
diff changeset
2406 // bypassing each other. Happens after null checks, so the
a61af66fc99e Initial load
duke
parents:
diff changeset
2407 // exception paths do not take memory state from the memory barrier,
a61af66fc99e Initial load
duke
parents:
diff changeset
2408 // so there's no problems making a strong assert about mixing users
a61af66fc99e Initial load
duke
parents:
diff changeset
2409 // of safe & unsafe memory. Otherwise fails in a CTW of rt.jar
a61af66fc99e Initial load
duke
parents:
diff changeset
2410 // around 5701, class sun/reflect/UnsafeBooleanFieldAccessorImpl.
a61af66fc99e Initial load
duke
parents:
diff changeset
2411 if (need_mem_bar) insert_mem_bar(Op_MemBarCPUOrder);
a61af66fc99e Initial load
duke
parents:
diff changeset
2412
a61af66fc99e Initial load
duke
parents:
diff changeset
2413 if (!is_store) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2414 Node* p = make_load(control(), adr, value_type, type, adr_type, is_volatile);
a61af66fc99e Initial load
duke
parents:
diff changeset
2415 // load value and push onto stack
a61af66fc99e Initial load
duke
parents:
diff changeset
2416 switch (type) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2417 case T_BOOLEAN:
a61af66fc99e Initial load
duke
parents:
diff changeset
2418 case T_CHAR:
a61af66fc99e Initial load
duke
parents:
diff changeset
2419 case T_BYTE:
a61af66fc99e Initial load
duke
parents:
diff changeset
2420 case T_SHORT:
a61af66fc99e Initial load
duke
parents:
diff changeset
2421 case T_INT:
a61af66fc99e Initial load
duke
parents:
diff changeset
2422 case T_FLOAT:
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2423 push(p);
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2424 break;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2425 case T_OBJECT:
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2426 if (need_read_barrier) {
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2427 insert_g1_pre_barrier(heap_base_oop, offset, p);
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2428 }
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2429 push(p);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2430 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
2431 case T_ADDRESS:
a61af66fc99e Initial load
duke
parents:
diff changeset
2432 // Cast to an int type.
a61af66fc99e Initial load
duke
parents:
diff changeset
2433 p = _gvn.transform( new (C, 2) CastP2XNode(NULL,p) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2434 p = ConvX2L(p);
a61af66fc99e Initial load
duke
parents:
diff changeset
2435 push_pair(p);
a61af66fc99e Initial load
duke
parents:
diff changeset
2436 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
2437 case T_DOUBLE:
a61af66fc99e Initial load
duke
parents:
diff changeset
2438 case T_LONG:
a61af66fc99e Initial load
duke
parents:
diff changeset
2439 push_pair( p );
a61af66fc99e Initial load
duke
parents:
diff changeset
2440 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
2441 default: ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
2442 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2443 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2444 // place effect of store into memory
a61af66fc99e Initial load
duke
parents:
diff changeset
2445 switch (type) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2446 case T_DOUBLE:
a61af66fc99e Initial load
duke
parents:
diff changeset
2447 val = dstore_rounding(val);
a61af66fc99e Initial load
duke
parents:
diff changeset
2448 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
2449 case T_ADDRESS:
a61af66fc99e Initial load
duke
parents:
diff changeset
2450 // Repackage the long as a pointer.
a61af66fc99e Initial load
duke
parents:
diff changeset
2451 val = ConvL2X(val);
a61af66fc99e Initial load
duke
parents:
diff changeset
2452 val = _gvn.transform( new (C, 2) CastX2PNode(val) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2453 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
2454 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2455
a61af66fc99e Initial load
duke
parents:
diff changeset
2456 if (type != T_OBJECT ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2457 (void) store_to_memory(control(), adr, val, type, adr_type, is_volatile);
a61af66fc99e Initial load
duke
parents:
diff changeset
2458 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2459 // Possibly an oop being stored to Java heap or native memory
a61af66fc99e Initial load
duke
parents:
diff changeset
2460 if (!TypePtr::NULL_PTR->higher_equal(_gvn.type(heap_base_oop))) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2461 // oop to Java heap.
825
8f5825e0aeaa 6818666: G1: Type lost in g1 pre-barrier
never
parents: 787
diff changeset
2462 (void) store_oop_to_unknown(control(), heap_base_oop, adr, adr_type, val, type);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2463 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2464 // We can't tell at compile time if we are storing in the Java heap or outside
a61af66fc99e Initial load
duke
parents:
diff changeset
2465 // of it. So we need to emit code to conditionally do the proper type of
a61af66fc99e Initial load
duke
parents:
diff changeset
2466 // store.
a61af66fc99e Initial load
duke
parents:
diff changeset
2467
2444
07acc51c1d2a 7032314: Allow to generate CallLeafNoFPNode in IdealKit
kvn
parents: 2405
diff changeset
2468 IdealKit ideal(this);
851
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 836
diff changeset
2469 #define __ ideal.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2470 // QQQ who knows what probability is here??
851
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 836
diff changeset
2471 __ if_then(heap_base_oop, BoolTest::ne, null(), PROB_UNLIKELY(0.999)); {
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 836
diff changeset
2472 // Sync IdealKit and graphKit.
2444
07acc51c1d2a 7032314: Allow to generate CallLeafNoFPNode in IdealKit
kvn
parents: 2405
diff changeset
2473 sync_kit(ideal);
851
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 836
diff changeset
2474 Node* st = store_oop_to_unknown(control(), heap_base_oop, adr, adr_type, val, type);
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 836
diff changeset
2475 // Update IdealKit memory.
2444
07acc51c1d2a 7032314: Allow to generate CallLeafNoFPNode in IdealKit
kvn
parents: 2405
diff changeset
2476 __ sync_kit(this);
851
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 836
diff changeset
2477 } __ else_(); {
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 836
diff changeset
2478 __ store(__ ctrl(), adr, val, type, alias_type->index(), is_volatile);
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 836
diff changeset
2479 } __ end_if();
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 836
diff changeset
2480 // Final sync IdealKit and GraphKit.
2444
07acc51c1d2a 7032314: Allow to generate CallLeafNoFPNode in IdealKit
kvn
parents: 2405
diff changeset
2481 final_sync(ideal);
851
fc4be448891f 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 836
diff changeset
2482 #undef __
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2483 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2484 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2485 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2486
a61af66fc99e Initial load
duke
parents:
diff changeset
2487 if (is_volatile) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2488 if (!is_store)
a61af66fc99e Initial load
duke
parents:
diff changeset
2489 insert_mem_bar(Op_MemBarAcquire);
a61af66fc99e Initial load
duke
parents:
diff changeset
2490 else
a61af66fc99e Initial load
duke
parents:
diff changeset
2491 insert_mem_bar(Op_MemBarVolatile);
a61af66fc99e Initial load
duke
parents:
diff changeset
2492 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2493
a61af66fc99e Initial load
duke
parents:
diff changeset
2494 if (need_mem_bar) insert_mem_bar(Op_MemBarCPUOrder);
a61af66fc99e Initial load
duke
parents:
diff changeset
2495
a61af66fc99e Initial load
duke
parents:
diff changeset
2496 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2497 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2498
a61af66fc99e Initial load
duke
parents:
diff changeset
2499 //----------------------------inline_unsafe_prefetch----------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2500
a61af66fc99e Initial load
duke
parents:
diff changeset
2501 bool LibraryCallKit::inline_unsafe_prefetch(bool is_native_ptr, bool is_store, bool is_static) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2502 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
2503 {
a61af66fc99e Initial load
duke
parents:
diff changeset
2504 ResourceMark rm;
a61af66fc99e Initial load
duke
parents:
diff changeset
2505 // Check the signatures.
a61af66fc99e Initial load
duke
parents:
diff changeset
2506 ciSignature* sig = signature();
a61af66fc99e Initial load
duke
parents:
diff changeset
2507 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
2508 // Object getObject(Object base, int/long offset), etc.
a61af66fc99e Initial load
duke
parents:
diff changeset
2509 BasicType rtype = sig->return_type()->basic_type();
a61af66fc99e Initial load
duke
parents:
diff changeset
2510 if (!is_native_ptr) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2511 assert(sig->count() == 2, "oop prefetch has 2 arguments");
a61af66fc99e Initial load
duke
parents:
diff changeset
2512 assert(sig->type_at(0)->basic_type() == T_OBJECT, "prefetch base is object");
a61af66fc99e Initial load
duke
parents:
diff changeset
2513 assert(sig->type_at(1)->basic_type() == T_LONG, "prefetcha offset is correct");
a61af66fc99e Initial load
duke
parents:
diff changeset
2514 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2515 assert(sig->count() == 1, "native prefetch has 1 argument");
a61af66fc99e Initial load
duke
parents:
diff changeset
2516 assert(sig->type_at(0)->basic_type() == T_LONG, "prefetch base is long");
a61af66fc99e Initial load
duke
parents:
diff changeset
2517 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2518 #endif // ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
2519 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2520 #endif // !PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
2521
a61af66fc99e Initial load
duke
parents:
diff changeset
2522 C->set_has_unsafe_access(true); // Mark eventual nmethod as "unsafe".
a61af66fc99e Initial load
duke
parents:
diff changeset
2523
a61af66fc99e Initial load
duke
parents:
diff changeset
2524 // Argument words: "this" if not static, plus (oop/offset) or (lo/hi) args
a61af66fc99e Initial load
duke
parents:
diff changeset
2525 int nargs = (is_static ? 0 : 1) + (is_native_ptr ? 2 : 3);
a61af66fc99e Initial load
duke
parents:
diff changeset
2526
a61af66fc99e Initial load
duke
parents:
diff changeset
2527 debug_only(int saved_sp = _sp);
a61af66fc99e Initial load
duke
parents:
diff changeset
2528 _sp += nargs;
a61af66fc99e Initial load
duke
parents:
diff changeset
2529
a61af66fc99e Initial load
duke
parents:
diff changeset
2530 // Build address expression. See the code in inline_unsafe_access.
a61af66fc99e Initial load
duke
parents:
diff changeset
2531 Node *adr;
a61af66fc99e Initial load
duke
parents:
diff changeset
2532 if (!is_native_ptr) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2533 // The offset is a value produced by Unsafe.staticFieldOffset or Unsafe.objectFieldOffset
a61af66fc99e Initial load
duke
parents:
diff changeset
2534 Node* offset = pop_pair();
a61af66fc99e Initial load
duke
parents:
diff changeset
2535 // The base is either a Java object or a value produced by Unsafe.staticFieldBase
a61af66fc99e Initial load
duke
parents:
diff changeset
2536 Node* base = pop();
a61af66fc99e Initial load
duke
parents:
diff changeset
2537 // We currently rely on the cookies produced by Unsafe.xxxFieldOffset
a61af66fc99e Initial load
duke
parents:
diff changeset
2538 // to be plain byte offsets, which are also the same as those accepted
a61af66fc99e Initial load
duke
parents:
diff changeset
2539 // by oopDesc::field_base.
a61af66fc99e Initial load
duke
parents:
diff changeset
2540 assert(Unsafe_field_offset_to_byte_offset(11) == 11,
a61af66fc99e Initial load
duke
parents:
diff changeset
2541 "fieldOffset must be byte-scaled");
a61af66fc99e Initial load
duke
parents:
diff changeset
2542 // 32-bit machines ignore the high half!
a61af66fc99e Initial load
duke
parents:
diff changeset
2543 offset = ConvL2X(offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
2544 adr = make_unsafe_address(base, offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
2545 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2546 Node* ptr = pop_pair();
a61af66fc99e Initial load
duke
parents:
diff changeset
2547 // Adjust Java long to machine word:
a61af66fc99e Initial load
duke
parents:
diff changeset
2548 ptr = ConvL2X(ptr);
a61af66fc99e Initial load
duke
parents:
diff changeset
2549 adr = make_unsafe_address(NULL, ptr);
a61af66fc99e Initial load
duke
parents:
diff changeset
2550 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2551
a61af66fc99e Initial load
duke
parents:
diff changeset
2552 if (is_static) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2553 assert(saved_sp == _sp, "must have correct argument count");
a61af66fc99e Initial load
duke
parents:
diff changeset
2554 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2555 // Pop receiver last: it was pushed first.
a61af66fc99e Initial load
duke
parents:
diff changeset
2556 Node *receiver = pop();
a61af66fc99e Initial load
duke
parents:
diff changeset
2557 assert(saved_sp == _sp, "must have correct argument count");
a61af66fc99e Initial load
duke
parents:
diff changeset
2558
a61af66fc99e Initial load
duke
parents:
diff changeset
2559 // Null check on self without removing any arguments. The argument
a61af66fc99e Initial load
duke
parents:
diff changeset
2560 // null check technically happens in the wrong place, which can lead to
a61af66fc99e Initial load
duke
parents:
diff changeset
2561 // invalid stack traces when the primitive is inlined into a method
a61af66fc99e Initial load
duke
parents:
diff changeset
2562 // which handles NullPointerExceptions.
a61af66fc99e Initial load
duke
parents:
diff changeset
2563 _sp += nargs;
a61af66fc99e Initial load
duke
parents:
diff changeset
2564 do_null_check(receiver, T_OBJECT);
a61af66fc99e Initial load
duke
parents:
diff changeset
2565 _sp -= nargs;
a61af66fc99e Initial load
duke
parents:
diff changeset
2566 if (stopped()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2567 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2568 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2569 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2570
a61af66fc99e Initial load
duke
parents:
diff changeset
2571 // Generate the read or write prefetch
a61af66fc99e Initial load
duke
parents:
diff changeset
2572 Node *prefetch;
a61af66fc99e Initial load
duke
parents:
diff changeset
2573 if (is_store) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2574 prefetch = new (C, 3) PrefetchWriteNode(i_o(), adr);
a61af66fc99e Initial load
duke
parents:
diff changeset
2575 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2576 prefetch = new (C, 3) PrefetchReadNode(i_o(), adr);
a61af66fc99e Initial load
duke
parents:
diff changeset
2577 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2578 prefetch->init_req(0, control());
a61af66fc99e Initial load
duke
parents:
diff changeset
2579 set_i_o(_gvn.transform(prefetch));
a61af66fc99e Initial load
duke
parents:
diff changeset
2580
a61af66fc99e Initial load
duke
parents:
diff changeset
2581 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2582 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2583
a61af66fc99e Initial load
duke
parents:
diff changeset
2584 //----------------------------inline_unsafe_CAS----------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2585
a61af66fc99e Initial load
duke
parents:
diff changeset
2586 bool LibraryCallKit::inline_unsafe_CAS(BasicType type) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2587 // This basic scheme here is the same as inline_unsafe_access, but
a61af66fc99e Initial load
duke
parents:
diff changeset
2588 // differs in enough details that combining them would make the code
a61af66fc99e Initial load
duke
parents:
diff changeset
2589 // overly confusing. (This is a true fact! I originally combined
a61af66fc99e Initial load
duke
parents:
diff changeset
2590 // them, but even I was confused by it!) As much code/comments as
a61af66fc99e Initial load
duke
parents:
diff changeset
2591 // possible are retained from inline_unsafe_access though to make
605
98cb887364d3 6810672: Comment typos
twisti
parents: 420
diff changeset
2592 // the correspondences clearer. - dl
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2593
a61af66fc99e Initial load
duke
parents:
diff changeset
2594 if (callee()->is_static()) return false; // caller must have the capability!
a61af66fc99e Initial load
duke
parents:
diff changeset
2595
a61af66fc99e Initial load
duke
parents:
diff changeset
2596 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
2597 {
a61af66fc99e Initial load
duke
parents:
diff changeset
2598 ResourceMark rm;
a61af66fc99e Initial load
duke
parents:
diff changeset
2599 // Check the signatures.
a61af66fc99e Initial load
duke
parents:
diff changeset
2600 ciSignature* sig = signature();
a61af66fc99e Initial load
duke
parents:
diff changeset
2601 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
2602 BasicType rtype = sig->return_type()->basic_type();
a61af66fc99e Initial load
duke
parents:
diff changeset
2603 assert(rtype == T_BOOLEAN, "CAS must return boolean");
a61af66fc99e Initial load
duke
parents:
diff changeset
2604 assert(sig->count() == 4, "CAS has 4 arguments");
a61af66fc99e Initial load
duke
parents:
diff changeset
2605 assert(sig->type_at(0)->basic_type() == T_OBJECT, "CAS base is object");
a61af66fc99e Initial load
duke
parents:
diff changeset
2606 assert(sig->type_at(1)->basic_type() == T_LONG, "CAS offset is long");
a61af66fc99e Initial load
duke
parents:
diff changeset
2607 #endif // ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
2608 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2609 #endif //PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
2610
a61af66fc99e Initial load
duke
parents:
diff changeset
2611 // number of stack slots per value argument (1 or 2)
a61af66fc99e Initial load
duke
parents:
diff changeset
2612 int type_words = type2size[type];
a61af66fc99e Initial load
duke
parents:
diff changeset
2613
a61af66fc99e Initial load
duke
parents:
diff changeset
2614 // Cannot inline wide CAS on machines that don't support it natively
29
d5fc211aea19 6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents: 0
diff changeset
2615 if (type2aelembytes(type) > BytesPerInt && !VM_Version::supports_cx8())
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2616 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
2617
a61af66fc99e Initial load
duke
parents:
diff changeset
2618 C->set_has_unsafe_access(true); // Mark eventual nmethod as "unsafe".
a61af66fc99e Initial load
duke
parents:
diff changeset
2619
a61af66fc99e Initial load
duke
parents:
diff changeset
2620 // Argument words: "this" plus oop plus offset plus oldvalue plus newvalue;
a61af66fc99e Initial load
duke
parents:
diff changeset
2621 int nargs = 1 + 1 + 2 + type_words + type_words;
a61af66fc99e Initial load
duke
parents:
diff changeset
2622
a61af66fc99e Initial load
duke
parents:
diff changeset
2623 // pop arguments: newval, oldval, offset, base, and receiver
a61af66fc99e Initial load
duke
parents:
diff changeset
2624 debug_only(int saved_sp = _sp);
a61af66fc99e Initial load
duke
parents:
diff changeset
2625 _sp += nargs;
a61af66fc99e Initial load
duke
parents:
diff changeset
2626 Node* newval = (type_words == 1) ? pop() : pop_pair();
a61af66fc99e Initial load
duke
parents:
diff changeset
2627 Node* oldval = (type_words == 1) ? pop() : pop_pair();
a61af66fc99e Initial load
duke
parents:
diff changeset
2628 Node *offset = pop_pair();
a61af66fc99e Initial load
duke
parents:
diff changeset
2629 Node *base = pop();
a61af66fc99e Initial load
duke
parents:
diff changeset
2630 Node *receiver = pop();
a61af66fc99e Initial load
duke
parents:
diff changeset
2631 assert(saved_sp == _sp, "must have correct argument count");
a61af66fc99e Initial load
duke
parents:
diff changeset
2632
a61af66fc99e Initial load
duke
parents:
diff changeset
2633 // Null check receiver.
a61af66fc99e Initial load
duke
parents:
diff changeset
2634 _sp += nargs;
a61af66fc99e Initial load
duke
parents:
diff changeset
2635 do_null_check(receiver, T_OBJECT);
a61af66fc99e Initial load
duke
parents:
diff changeset
2636 _sp -= nargs;
a61af66fc99e Initial load
duke
parents:
diff changeset
2637 if (stopped()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2638 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2639 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2640
a61af66fc99e Initial load
duke
parents:
diff changeset
2641 // Build field offset expression.
a61af66fc99e Initial load
duke
parents:
diff changeset
2642 // We currently rely on the cookies produced by Unsafe.xxxFieldOffset
a61af66fc99e Initial load
duke
parents:
diff changeset
2643 // to be plain byte offsets, which are also the same as those accepted
a61af66fc99e Initial load
duke
parents:
diff changeset
2644 // by oopDesc::field_base.
a61af66fc99e Initial load
duke
parents:
diff changeset
2645 assert(Unsafe_field_offset_to_byte_offset(11) == 11, "fieldOffset must be byte-scaled");
a61af66fc99e Initial load
duke
parents:
diff changeset
2646 // 32-bit machines ignore the high half of long offsets
a61af66fc99e Initial load
duke
parents:
diff changeset
2647 offset = ConvL2X(offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
2648 Node* adr = make_unsafe_address(base, offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
2649 const TypePtr *adr_type = _gvn.type(adr)->isa_ptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
2650
a61af66fc99e Initial load
duke
parents:
diff changeset
2651 // (Unlike inline_unsafe_access, there seems no point in trying
a61af66fc99e Initial load
duke
parents:
diff changeset
2652 // to refine types. Just use the coarse types here.
a61af66fc99e Initial load
duke
parents:
diff changeset
2653 const Type *value_type = Type::get_const_basic_type(type);
a61af66fc99e Initial load
duke
parents:
diff changeset
2654 Compile::AliasType* alias_type = C->alias_type(adr_type);
a61af66fc99e Initial load
duke
parents:
diff changeset
2655 assert(alias_type->index() != Compile::AliasIdxBot, "no bare pointers here");
a61af66fc99e Initial load
duke
parents:
diff changeset
2656 int alias_idx = C->get_alias_index(adr_type);
a61af66fc99e Initial load
duke
parents:
diff changeset
2657
a61af66fc99e Initial load
duke
parents:
diff changeset
2658 // Memory-model-wise, a CAS acts like a little synchronized block,
605
98cb887364d3 6810672: Comment typos
twisti
parents: 420
diff changeset
2659 // so needs barriers on each side. These don't translate into
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2660 // actual barriers on most machines, but we still need rest of
a61af66fc99e Initial load
duke
parents:
diff changeset
2661 // compiler to respect ordering.
a61af66fc99e Initial load
duke
parents:
diff changeset
2662
a61af66fc99e Initial load
duke
parents:
diff changeset
2663 insert_mem_bar(Op_MemBarRelease);
a61af66fc99e Initial load
duke
parents:
diff changeset
2664 insert_mem_bar(Op_MemBarCPUOrder);
a61af66fc99e Initial load
duke
parents:
diff changeset
2665
a61af66fc99e Initial load
duke
parents:
diff changeset
2666 // 4984716: MemBars must be inserted before this
a61af66fc99e Initial load
duke
parents:
diff changeset
2667 // memory node in order to avoid a false
a61af66fc99e Initial load
duke
parents:
diff changeset
2668 // dependency which will confuse the scheduler.
a61af66fc99e Initial load
duke
parents:
diff changeset
2669 Node *mem = memory(alias_idx);
a61af66fc99e Initial load
duke
parents:
diff changeset
2670
a61af66fc99e Initial load
duke
parents:
diff changeset
2671 // For now, we handle only those cases that actually exist: ints,
a61af66fc99e Initial load
duke
parents:
diff changeset
2672 // longs, and Object. Adding others should be straightforward.
a61af66fc99e Initial load
duke
parents:
diff changeset
2673 Node* cas;
a61af66fc99e Initial load
duke
parents:
diff changeset
2674 switch(type) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2675 case T_INT:
a61af66fc99e Initial load
duke
parents:
diff changeset
2676 cas = _gvn.transform(new (C, 5) CompareAndSwapINode(control(), mem, adr, newval, oldval));
a61af66fc99e Initial load
duke
parents:
diff changeset
2677 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
2678 case T_LONG:
a61af66fc99e Initial load
duke
parents:
diff changeset
2679 cas = _gvn.transform(new (C, 5) CompareAndSwapLNode(control(), mem, adr, newval, oldval));
a61af66fc99e Initial load
duke
parents:
diff changeset
2680 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
2681 case T_OBJECT:
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 34
diff changeset
2682 // reference stores need a store barrier.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2683 // (They don't if CAS fails, but it isn't worth checking.)
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2684 pre_barrier(true /* do_load*/,
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2685 control(), base, adr, alias_idx, newval, value_type->make_oopptr(),
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2686 NULL /* pre_val*/,
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
2687 T_OBJECT);
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 34
diff changeset
2688 #ifdef _LP64
163
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 113
diff changeset
2689 if (adr->bottom_type()->is_ptr_to_narrowoop()) {
221
1e026f8da827 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 174
diff changeset
2690 Node *newval_enc = _gvn.transform(new (C, 2) EncodePNode(newval, newval->bottom_type()->make_narrowoop()));
1e026f8da827 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 174
diff changeset
2691 Node *oldval_enc = _gvn.transform(new (C, 2) EncodePNode(oldval, oldval->bottom_type()->make_narrowoop()));
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 34
diff changeset
2692 cas = _gvn.transform(new (C, 5) CompareAndSwapNNode(control(), mem, adr,
221
1e026f8da827 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 174
diff changeset
2693 newval_enc, oldval_enc));
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 34
diff changeset
2694 } else
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 34
diff changeset
2695 #endif
221
1e026f8da827 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 174
diff changeset
2696 {
1e026f8da827 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 174
diff changeset
2697 cas = _gvn.transform(new (C, 5) CompareAndSwapPNode(control(), mem, adr, newval, oldval));
1e026f8da827 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 174
diff changeset
2698 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2699 post_barrier(control(), cas, base, adr, alias_idx, newval, T_OBJECT, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
2700 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
2701 default:
a61af66fc99e Initial load
duke
parents:
diff changeset
2702 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
2703 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
2704 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2705
a61af66fc99e Initial load
duke
parents:
diff changeset
2706 // SCMemProjNodes represent the memory state of CAS. Their main
a61af66fc99e Initial load
duke
parents:
diff changeset
2707 // role is to prevent CAS nodes from being optimized away when their
a61af66fc99e Initial load
duke
parents:
diff changeset
2708 // results aren't used.
a61af66fc99e Initial load
duke
parents:
diff changeset
2709 Node* proj = _gvn.transform( new (C, 1) SCMemProjNode(cas));
a61af66fc99e Initial load
duke
parents:
diff changeset
2710 set_memory(proj, alias_idx);
a61af66fc99e Initial load
duke
parents:
diff changeset
2711
a61af66fc99e Initial load
duke
parents:
diff changeset
2712 // Add the trailing membar surrounding the access
a61af66fc99e Initial load
duke
parents:
diff changeset
2713 insert_mem_bar(Op_MemBarCPUOrder);
a61af66fc99e Initial load
duke
parents:
diff changeset
2714 insert_mem_bar(Op_MemBarAcquire);
a61af66fc99e Initial load
duke
parents:
diff changeset
2715
a61af66fc99e Initial load
duke
parents:
diff changeset
2716 push(cas);
a61af66fc99e Initial load
duke
parents:
diff changeset
2717 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2718 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2719
a61af66fc99e Initial load
duke
parents:
diff changeset
2720 bool LibraryCallKit::inline_unsafe_ordered_store(BasicType type) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2721 // This is another variant of inline_unsafe_access, differing in
a61af66fc99e Initial load
duke
parents:
diff changeset
2722 // that it always issues store-store ("release") barrier and ensures
a61af66fc99e Initial load
duke
parents:
diff changeset
2723 // store-atomicity (which only matters for "long").
a61af66fc99e Initial load
duke
parents:
diff changeset
2724
a61af66fc99e Initial load
duke
parents:
diff changeset
2725 if (callee()->is_static()) return false; // caller must have the capability!
a61af66fc99e Initial load
duke
parents:
diff changeset
2726
a61af66fc99e Initial load
duke
parents:
diff changeset
2727 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
2728 {
a61af66fc99e Initial load
duke
parents:
diff changeset
2729 ResourceMark rm;
a61af66fc99e Initial load
duke
parents:
diff changeset
2730 // Check the signatures.
a61af66fc99e Initial load
duke
parents:
diff changeset
2731 ciSignature* sig = signature();
a61af66fc99e Initial load
duke
parents:
diff changeset
2732 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
2733 BasicType rtype = sig->return_type()->basic_type();
a61af66fc99e Initial load
duke
parents:
diff changeset
2734 assert(rtype == T_VOID, "must return void");
a61af66fc99e Initial load
duke
parents:
diff changeset
2735 assert(sig->count() == 3, "has 3 arguments");
a61af66fc99e Initial load
duke
parents:
diff changeset
2736 assert(sig->type_at(0)->basic_type() == T_OBJECT, "base is object");
a61af66fc99e Initial load
duke
parents:
diff changeset
2737 assert(sig->type_at(1)->basic_type() == T_LONG, "offset is long");
a61af66fc99e Initial load
duke
parents:
diff changeset
2738 #endif // ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
2739 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2740 #endif //PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
2741
a61af66fc99e Initial load
duke
parents:
diff changeset
2742 // number of stack slots per value argument (1 or 2)
a61af66fc99e Initial load
duke
parents:
diff changeset
2743 int type_words = type2size[type];
a61af66fc99e Initial load
duke
parents:
diff changeset
2744
a61af66fc99e Initial load
duke
parents:
diff changeset
2745 C->set_has_unsafe_access(true); // Mark eventual nmethod as "unsafe".
a61af66fc99e Initial load
duke
parents:
diff changeset
2746
a61af66fc99e Initial load
duke
parents:
diff changeset
2747 // Argument words: "this" plus oop plus offset plus value;
a61af66fc99e Initial load
duke
parents:
diff changeset
2748 int nargs = 1 + 1 + 2 + type_words;
a61af66fc99e Initial load
duke
parents:
diff changeset
2749
a61af66fc99e Initial load
duke
parents:
diff changeset
2750 // pop arguments: val, offset, base, and receiver
a61af66fc99e Initial load
duke
parents:
diff changeset
2751 debug_only(int saved_sp = _sp);
a61af66fc99e Initial load
duke
parents:
diff changeset
2752 _sp += nargs;
a61af66fc99e Initial load
duke
parents:
diff changeset
2753 Node* val = (type_words == 1) ? pop() : pop_pair();
a61af66fc99e Initial load
duke
parents:
diff changeset
2754 Node *offset = pop_pair();
a61af66fc99e Initial load
duke
parents:
diff changeset
2755 Node *base = pop();
a61af66fc99e Initial load
duke
parents:
diff changeset
2756 Node *receiver = pop();
a61af66fc99e Initial load
duke
parents:
diff changeset
2757 assert(saved_sp == _sp, "must have correct argument count");
a61af66fc99e Initial load
duke
parents:
diff changeset
2758
a61af66fc99e Initial load
duke
parents:
diff changeset
2759 // Null check receiver.
a61af66fc99e Initial load
duke
parents:
diff changeset
2760 _sp += nargs;
a61af66fc99e Initial load
duke
parents:
diff changeset
2761 do_null_check(receiver, T_OBJECT);
a61af66fc99e Initial load
duke
parents:
diff changeset
2762 _sp -= nargs;
a61af66fc99e Initial load
duke
parents:
diff changeset
2763 if (stopped()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2764 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2765 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2766
a61af66fc99e Initial load
duke
parents:
diff changeset
2767 // Build field offset expression.
a61af66fc99e Initial load
duke
parents:
diff changeset
2768 assert(Unsafe_field_offset_to_byte_offset(11) == 11, "fieldOffset must be byte-scaled");
a61af66fc99e Initial load
duke
parents:
diff changeset
2769 // 32-bit machines ignore the high half of long offsets
a61af66fc99e Initial load
duke
parents:
diff changeset
2770 offset = ConvL2X(offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
2771 Node* adr = make_unsafe_address(base, offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
2772 const TypePtr *adr_type = _gvn.type(adr)->isa_ptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
2773 const Type *value_type = Type::get_const_basic_type(type);
a61af66fc99e Initial load
duke
parents:
diff changeset
2774 Compile::AliasType* alias_type = C->alias_type(adr_type);
a61af66fc99e Initial load
duke
parents:
diff changeset
2775
a61af66fc99e Initial load
duke
parents:
diff changeset
2776 insert_mem_bar(Op_MemBarRelease);
a61af66fc99e Initial load
duke
parents:
diff changeset
2777 insert_mem_bar(Op_MemBarCPUOrder);
a61af66fc99e Initial load
duke
parents:
diff changeset
2778 // Ensure that the store is atomic for longs:
a61af66fc99e Initial load
duke
parents:
diff changeset
2779 bool require_atomic_access = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2780 Node* store;
a61af66fc99e Initial load
duke
parents:
diff changeset
2781 if (type == T_OBJECT) // reference stores need a store barrier.
825
8f5825e0aeaa 6818666: G1: Type lost in g1 pre-barrier
never
parents: 787
diff changeset
2782 store = store_oop_to_unknown(control(), base, adr, adr_type, val, type);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2783 else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2784 store = store_to_memory(control(), adr, val, type, adr_type, require_atomic_access);
a61af66fc99e Initial load
duke
parents:
diff changeset
2785 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2786 insert_mem_bar(Op_MemBarCPUOrder);
a61af66fc99e Initial load
duke
parents:
diff changeset
2787 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2788 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2789
a61af66fc99e Initial load
duke
parents:
diff changeset
2790 bool LibraryCallKit::inline_unsafe_allocate() {
a61af66fc99e Initial load
duke
parents:
diff changeset
2791 if (callee()->is_static()) return false; // caller must have the capability!
a61af66fc99e Initial load
duke
parents:
diff changeset
2792 int nargs = 1 + 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
2793 assert(signature()->size() == nargs-1, "alloc has 1 argument");
a61af66fc99e Initial load
duke
parents:
diff changeset
2794 null_check_receiver(callee()); // check then ignore argument(0)
a61af66fc99e Initial load
duke
parents:
diff changeset
2795 _sp += nargs; // set original stack for use by uncommon_trap
a61af66fc99e Initial load
duke
parents:
diff changeset
2796 Node* cls = do_null_check(argument(1), T_OBJECT);
a61af66fc99e Initial load
duke
parents:
diff changeset
2797 _sp -= nargs;
a61af66fc99e Initial load
duke
parents:
diff changeset
2798 if (stopped()) return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2799
a61af66fc99e Initial load
duke
parents:
diff changeset
2800 Node* kls = load_klass_from_mirror(cls, false, nargs, NULL, 0);
a61af66fc99e Initial load
duke
parents:
diff changeset
2801 _sp += nargs; // set original stack for use by uncommon_trap
a61af66fc99e Initial load
duke
parents:
diff changeset
2802 kls = do_null_check(kls, T_OBJECT);
a61af66fc99e Initial load
duke
parents:
diff changeset
2803 _sp -= nargs;
a61af66fc99e Initial load
duke
parents:
diff changeset
2804 if (stopped()) return true; // argument was like int.class
a61af66fc99e Initial load
duke
parents:
diff changeset
2805
a61af66fc99e Initial load
duke
parents:
diff changeset
2806 // Note: The argument might still be an illegal value like
a61af66fc99e Initial load
duke
parents:
diff changeset
2807 // Serializable.class or Object[].class. The runtime will handle it.
a61af66fc99e Initial load
duke
parents:
diff changeset
2808 // But we must make an explicit check for initialization.
a61af66fc99e Initial load
duke
parents:
diff changeset
2809 Node* insp = basic_plus_adr(kls, instanceKlass::init_state_offset_in_bytes() + sizeof(oopDesc));
a61af66fc99e Initial load
duke
parents:
diff changeset
2810 Node* inst = make_load(NULL, insp, TypeInt::INT, T_INT);
a61af66fc99e Initial load
duke
parents:
diff changeset
2811 Node* bits = intcon(instanceKlass::fully_initialized);
a61af66fc99e Initial load
duke
parents:
diff changeset
2812 Node* test = _gvn.transform( new (C, 3) SubINode(inst, bits) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2813 // The 'test' is non-zero if we need to take a slow path.
a61af66fc99e Initial load
duke
parents:
diff changeset
2814
a61af66fc99e Initial load
duke
parents:
diff changeset
2815 Node* obj = new_instance(kls, test);
a61af66fc99e Initial load
duke
parents:
diff changeset
2816 push(obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
2817
a61af66fc99e Initial load
duke
parents:
diff changeset
2818 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2819 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2820
a61af66fc99e Initial load
duke
parents:
diff changeset
2821 //------------------------inline_native_time_funcs--------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2822 // inline code for System.currentTimeMillis() and System.nanoTime()
a61af66fc99e Initial load
duke
parents:
diff changeset
2823 // these have the same type and signature
a61af66fc99e Initial load
duke
parents:
diff changeset
2824 bool LibraryCallKit::inline_native_time_funcs(bool isNano) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2825 address funcAddr = isNano ? CAST_FROM_FN_PTR(address, os::javaTimeNanos) :
a61af66fc99e Initial load
duke
parents:
diff changeset
2826 CAST_FROM_FN_PTR(address, os::javaTimeMillis);
a61af66fc99e Initial load
duke
parents:
diff changeset
2827 const char * funcName = isNano ? "nanoTime" : "currentTimeMillis";
a61af66fc99e Initial load
duke
parents:
diff changeset
2828 const TypeFunc *tf = OptoRuntime::current_time_millis_Type();
a61af66fc99e Initial load
duke
parents:
diff changeset
2829 const TypePtr* no_memory_effects = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2830 Node* time = make_runtime_call(RC_LEAF, tf, funcAddr, funcName, no_memory_effects);
a61af66fc99e Initial load
duke
parents:
diff changeset
2831 Node* value = _gvn.transform(new (C, 1) ProjNode(time, TypeFunc::Parms+0));
a61af66fc99e Initial load
duke
parents:
diff changeset
2832 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
2833 Node* value_top = _gvn.transform(new (C, 1) ProjNode(time, TypeFunc::Parms + 1));
a61af66fc99e Initial load
duke
parents:
diff changeset
2834 assert(value_top == top(), "second value must be top");
a61af66fc99e Initial load
duke
parents:
diff changeset
2835 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
2836 push_pair(value);
a61af66fc99e Initial load
duke
parents:
diff changeset
2837 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2838 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2839
a61af66fc99e Initial load
duke
parents:
diff changeset
2840 //------------------------inline_native_currentThread------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2841 bool LibraryCallKit::inline_native_currentThread() {
a61af66fc99e Initial load
duke
parents:
diff changeset
2842 Node* junk = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2843 push(generate_current_thread(junk));
a61af66fc99e Initial load
duke
parents:
diff changeset
2844 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2845 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2846
a61af66fc99e Initial load
duke
parents:
diff changeset
2847 //------------------------inline_native_isInterrupted------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2848 bool LibraryCallKit::inline_native_isInterrupted() {
a61af66fc99e Initial load
duke
parents:
diff changeset
2849 const int nargs = 1+1; // receiver + boolean
a61af66fc99e Initial load
duke
parents:
diff changeset
2850 assert(nargs == arg_size(), "sanity");
a61af66fc99e Initial load
duke
parents:
diff changeset
2851 // Add a fast path to t.isInterrupted(clear_int):
a61af66fc99e Initial load
duke
parents:
diff changeset
2852 // (t == Thread.current() && (!TLS._osthread._interrupted || !clear_int))
a61af66fc99e Initial load
duke
parents:
diff changeset
2853 // ? TLS._osthread._interrupted : /*slow path:*/ t.isInterrupted(clear_int)
a61af66fc99e Initial load
duke
parents:
diff changeset
2854 // So, in the common case that the interrupt bit is false,
a61af66fc99e Initial load
duke
parents:
diff changeset
2855 // we avoid making a call into the VM. Even if the interrupt bit
a61af66fc99e Initial load
duke
parents:
diff changeset
2856 // is true, if the clear_int argument is false, we avoid the VM call.
a61af66fc99e Initial load
duke
parents:
diff changeset
2857 // However, if the receiver is not currentThread, we must call the VM,
a61af66fc99e Initial load
duke
parents:
diff changeset
2858 // because there must be some locking done around the operation.
a61af66fc99e Initial load
duke
parents:
diff changeset
2859
a61af66fc99e Initial load
duke
parents:
diff changeset
2860 // We only go to the fast case code if we pass two guards.
a61af66fc99e Initial load
duke
parents:
diff changeset
2861 // Paths which do not pass are accumulated in the slow_region.
a61af66fc99e Initial load
duke
parents:
diff changeset
2862 RegionNode* slow_region = new (C, 1) RegionNode(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
2863 record_for_igvn(slow_region);
a61af66fc99e Initial load
duke
parents:
diff changeset
2864 RegionNode* result_rgn = new (C, 4) RegionNode(1+3); // fast1, fast2, slow
a61af66fc99e Initial load
duke
parents:
diff changeset
2865 PhiNode* result_val = new (C, 4) PhiNode(result_rgn, TypeInt::BOOL);
a61af66fc99e Initial load
duke
parents:
diff changeset
2866 enum { no_int_result_path = 1,
a61af66fc99e Initial load
duke
parents:
diff changeset
2867 no_clear_result_path = 2,
a61af66fc99e Initial load
duke
parents:
diff changeset
2868 slow_result_path = 3
a61af66fc99e Initial load
duke
parents:
diff changeset
2869 };
a61af66fc99e Initial load
duke
parents:
diff changeset
2870
a61af66fc99e Initial load
duke
parents:
diff changeset
2871 // (a) Receiving thread must be the current thread.
a61af66fc99e Initial load
duke
parents:
diff changeset
2872 Node* rec_thr = argument(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
2873 Node* tls_ptr = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2874 Node* cur_thr = generate_current_thread(tls_ptr);
a61af66fc99e Initial load
duke
parents:
diff changeset
2875 Node* cmp_thr = _gvn.transform( new (C, 3) CmpPNode(cur_thr, rec_thr) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2876 Node* bol_thr = _gvn.transform( new (C, 2) BoolNode(cmp_thr, BoolTest::ne) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2877
a61af66fc99e Initial load
duke
parents:
diff changeset
2878 bool known_current_thread = (_gvn.type(bol_thr) == TypeInt::ZERO);
a61af66fc99e Initial load
duke
parents:
diff changeset
2879 if (!known_current_thread)
a61af66fc99e Initial load
duke
parents:
diff changeset
2880 generate_slow_guard(bol_thr, slow_region);
a61af66fc99e Initial load
duke
parents:
diff changeset
2881
a61af66fc99e Initial load
duke
parents:
diff changeset
2882 // (b) Interrupt bit on TLS must be false.
a61af66fc99e Initial load
duke
parents:
diff changeset
2883 Node* p = basic_plus_adr(top()/*!oop*/, tls_ptr, in_bytes(JavaThread::osthread_offset()));
a61af66fc99e Initial load
duke
parents:
diff changeset
2884 Node* osthread = make_load(NULL, p, TypeRawPtr::NOTNULL, T_ADDRESS);
a61af66fc99e Initial load
duke
parents:
diff changeset
2885 p = basic_plus_adr(top()/*!oop*/, osthread, in_bytes(OSThread::interrupted_offset()));
787
aabd393cf1ee 6772683: Thread.isInterrupted() fails to return true on multiprocessor PC
kvn
parents: 775
diff changeset
2886 // Set the control input on the field _interrupted read to prevent it floating up.
aabd393cf1ee 6772683: Thread.isInterrupted() fails to return true on multiprocessor PC
kvn
parents: 775
diff changeset
2887 Node* int_bit = make_load(control(), p, TypeInt::BOOL, T_INT);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2888 Node* cmp_bit = _gvn.transform( new (C, 3) CmpINode(int_bit, intcon(0)) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2889 Node* bol_bit = _gvn.transform( new (C, 2) BoolNode(cmp_bit, BoolTest::ne) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2890
a61af66fc99e Initial load
duke
parents:
diff changeset
2891 IfNode* iff_bit = create_and_map_if(control(), bol_bit, PROB_UNLIKELY_MAG(3), COUNT_UNKNOWN);
a61af66fc99e Initial load
duke
parents:
diff changeset
2892
a61af66fc99e Initial load
duke
parents:
diff changeset
2893 // First fast path: if (!TLS._interrupted) return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
2894 Node* false_bit = _gvn.transform( new (C, 1) IfFalseNode(iff_bit) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2895 result_rgn->init_req(no_int_result_path, false_bit);
a61af66fc99e Initial load
duke
parents:
diff changeset
2896 result_val->init_req(no_int_result_path, intcon(0));
a61af66fc99e Initial load
duke
parents:
diff changeset
2897
a61af66fc99e Initial load
duke
parents:
diff changeset
2898 // drop through to next case
a61af66fc99e Initial load
duke
parents:
diff changeset
2899 set_control( _gvn.transform(new (C, 1) IfTrueNode(iff_bit)) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2900
a61af66fc99e Initial load
duke
parents:
diff changeset
2901 // (c) Or, if interrupt bit is set and clear_int is false, use 2nd fast path.
a61af66fc99e Initial load
duke
parents:
diff changeset
2902 Node* clr_arg = argument(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
2903 Node* cmp_arg = _gvn.transform( new (C, 3) CmpINode(clr_arg, intcon(0)) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2904 Node* bol_arg = _gvn.transform( new (C, 2) BoolNode(cmp_arg, BoolTest::ne) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2905 IfNode* iff_arg = create_and_map_if(control(), bol_arg, PROB_FAIR, COUNT_UNKNOWN);
a61af66fc99e Initial load
duke
parents:
diff changeset
2906
a61af66fc99e Initial load
duke
parents:
diff changeset
2907 // Second fast path: ... else if (!clear_int) return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2908 Node* false_arg = _gvn.transform( new (C, 1) IfFalseNode(iff_arg) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2909 result_rgn->init_req(no_clear_result_path, false_arg);
a61af66fc99e Initial load
duke
parents:
diff changeset
2910 result_val->init_req(no_clear_result_path, intcon(1));
a61af66fc99e Initial load
duke
parents:
diff changeset
2911
a61af66fc99e Initial load
duke
parents:
diff changeset
2912 // drop through to next case
a61af66fc99e Initial load
duke
parents:
diff changeset
2913 set_control( _gvn.transform(new (C, 1) IfTrueNode(iff_arg)) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2914
a61af66fc99e Initial load
duke
parents:
diff changeset
2915 // (d) Otherwise, go to the slow path.
a61af66fc99e Initial load
duke
parents:
diff changeset
2916 slow_region->add_req(control());
a61af66fc99e Initial load
duke
parents:
diff changeset
2917 set_control( _gvn.transform(slow_region) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2918
a61af66fc99e Initial load
duke
parents:
diff changeset
2919 if (stopped()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2920 // There is no slow path.
a61af66fc99e Initial load
duke
parents:
diff changeset
2921 result_rgn->init_req(slow_result_path, top());
a61af66fc99e Initial load
duke
parents:
diff changeset
2922 result_val->init_req(slow_result_path, top());
a61af66fc99e Initial load
duke
parents:
diff changeset
2923 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2924 // non-virtual because it is a private non-static
a61af66fc99e Initial load
duke
parents:
diff changeset
2925 CallJavaNode* slow_call = generate_method_call(vmIntrinsics::_isInterrupted);
a61af66fc99e Initial load
duke
parents:
diff changeset
2926
a61af66fc99e Initial load
duke
parents:
diff changeset
2927 Node* slow_val = set_results_for_java_call(slow_call);
a61af66fc99e Initial load
duke
parents:
diff changeset
2928 // this->control() comes from set_results_for_java_call
a61af66fc99e Initial load
duke
parents:
diff changeset
2929
a61af66fc99e Initial load
duke
parents:
diff changeset
2930 // If we know that the result of the slow call will be true, tell the optimizer!
a61af66fc99e Initial load
duke
parents:
diff changeset
2931 if (known_current_thread) slow_val = intcon(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
2932
a61af66fc99e Initial load
duke
parents:
diff changeset
2933 Node* fast_io = slow_call->in(TypeFunc::I_O);
a61af66fc99e Initial load
duke
parents:
diff changeset
2934 Node* fast_mem = slow_call->in(TypeFunc::Memory);
a61af66fc99e Initial load
duke
parents:
diff changeset
2935 // These two phis are pre-filled with copies of of the fast IO and Memory
a61af66fc99e Initial load
duke
parents:
diff changeset
2936 Node* io_phi = PhiNode::make(result_rgn, fast_io, Type::ABIO);
a61af66fc99e Initial load
duke
parents:
diff changeset
2937 Node* mem_phi = PhiNode::make(result_rgn, fast_mem, Type::MEMORY, TypePtr::BOTTOM);
a61af66fc99e Initial load
duke
parents:
diff changeset
2938
a61af66fc99e Initial load
duke
parents:
diff changeset
2939 result_rgn->init_req(slow_result_path, control());
a61af66fc99e Initial load
duke
parents:
diff changeset
2940 io_phi ->init_req(slow_result_path, i_o());
a61af66fc99e Initial load
duke
parents:
diff changeset
2941 mem_phi ->init_req(slow_result_path, reset_memory());
a61af66fc99e Initial load
duke
parents:
diff changeset
2942 result_val->init_req(slow_result_path, slow_val);
a61af66fc99e Initial load
duke
parents:
diff changeset
2943
a61af66fc99e Initial load
duke
parents:
diff changeset
2944 set_all_memory( _gvn.transform(mem_phi) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2945 set_i_o( _gvn.transform(io_phi) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2946 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2947
a61af66fc99e Initial load
duke
parents:
diff changeset
2948 push_result(result_rgn, result_val);
a61af66fc99e Initial load
duke
parents:
diff changeset
2949 C->set_has_split_ifs(true); // Has chance for split-if optimization
a61af66fc99e Initial load
duke
parents:
diff changeset
2950
a61af66fc99e Initial load
duke
parents:
diff changeset
2951 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2952 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2953
a61af66fc99e Initial load
duke
parents:
diff changeset
2954 //---------------------------load_mirror_from_klass----------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2955 // Given a klass oop, load its java mirror (a java.lang.Class oop).
a61af66fc99e Initial load
duke
parents:
diff changeset
2956 Node* LibraryCallKit::load_mirror_from_klass(Node* klass) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2957 Node* p = basic_plus_adr(klass, Klass::java_mirror_offset_in_bytes() + sizeof(oopDesc));
a61af66fc99e Initial load
duke
parents:
diff changeset
2958 return make_load(NULL, p, TypeInstPtr::MIRROR, T_OBJECT);
a61af66fc99e Initial load
duke
parents:
diff changeset
2959 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2960
a61af66fc99e Initial load
duke
parents:
diff changeset
2961 //-----------------------load_klass_from_mirror_common-------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2962 // Given a java mirror (a java.lang.Class oop), load its corresponding klass oop.
a61af66fc99e Initial load
duke
parents:
diff changeset
2963 // Test the klass oop for null (signifying a primitive Class like Integer.TYPE),
a61af66fc99e Initial load
duke
parents:
diff changeset
2964 // and branch to the given path on the region.
a61af66fc99e Initial load
duke
parents:
diff changeset
2965 // If never_see_null, take an uncommon trap on null, so we can optimistically
a61af66fc99e Initial load
duke
parents:
diff changeset
2966 // compile for the non-null case.
a61af66fc99e Initial load
duke
parents:
diff changeset
2967 // If the region is NULL, force never_see_null = true.
a61af66fc99e Initial load
duke
parents:
diff changeset
2968 Node* LibraryCallKit::load_klass_from_mirror_common(Node* mirror,
a61af66fc99e Initial load
duke
parents:
diff changeset
2969 bool never_see_null,
a61af66fc99e Initial load
duke
parents:
diff changeset
2970 int nargs,
a61af66fc99e Initial load
duke
parents:
diff changeset
2971 RegionNode* region,
a61af66fc99e Initial load
duke
parents:
diff changeset
2972 int null_path,
a61af66fc99e Initial load
duke
parents:
diff changeset
2973 int offset) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2974 if (region == NULL) never_see_null = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2975 Node* p = basic_plus_adr(mirror, offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
2976 const TypeKlassPtr* kls_type = TypeKlassPtr::OBJECT_OR_NULL;
164
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
2977 Node* kls = _gvn.transform( LoadKlassNode::make(_gvn, immutable_memory(), p, TypeRawPtr::BOTTOM, kls_type) );
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2978 _sp += nargs; // any deopt will start just before call to enclosing method
a61af66fc99e Initial load
duke
parents:
diff changeset
2979 Node* null_ctl = top();
a61af66fc99e Initial load
duke
parents:
diff changeset
2980 kls = null_check_oop(kls, &null_ctl, never_see_null);
a61af66fc99e Initial load
duke
parents:
diff changeset
2981 if (region != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2982 // Set region->in(null_path) if the mirror is a primitive (e.g, int.class).
a61af66fc99e Initial load
duke
parents:
diff changeset
2983 region->init_req(null_path, null_ctl);
a61af66fc99e Initial load
duke
parents:
diff changeset
2984 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2985 assert(null_ctl == top(), "no loose ends");
a61af66fc99e Initial load
duke
parents:
diff changeset
2986 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2987 _sp -= nargs;
a61af66fc99e Initial load
duke
parents:
diff changeset
2988 return kls;
a61af66fc99e Initial load
duke
parents:
diff changeset
2989 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2990
a61af66fc99e Initial load
duke
parents:
diff changeset
2991 //--------------------(inline_native_Class_query helpers)---------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2992 // Use this for JVM_ACC_INTERFACE, JVM_ACC_IS_CLONEABLE, JVM_ACC_HAS_FINALIZER.
a61af66fc99e Initial load
duke
parents:
diff changeset
2993 // Fall through if (mods & mask) == bits, take the guard otherwise.
a61af66fc99e Initial load
duke
parents:
diff changeset
2994 Node* LibraryCallKit::generate_access_flags_guard(Node* kls, int modifier_mask, int modifier_bits, RegionNode* region) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2995 // Branch around if the given klass has the given modifier bit set.
a61af66fc99e Initial load
duke
parents:
diff changeset
2996 // Like generate_guard, adds a new path onto the region.
a61af66fc99e Initial load
duke
parents:
diff changeset
2997 Node* modp = basic_plus_adr(kls, Klass::access_flags_offset_in_bytes() + sizeof(oopDesc));
a61af66fc99e Initial load
duke
parents:
diff changeset
2998 Node* mods = make_load(NULL, modp, TypeInt::INT, T_INT);
a61af66fc99e Initial load
duke
parents:
diff changeset
2999 Node* mask = intcon(modifier_mask);
a61af66fc99e Initial load
duke
parents:
diff changeset
3000 Node* bits = intcon(modifier_bits);
a61af66fc99e Initial load
duke
parents:
diff changeset
3001 Node* mbit = _gvn.transform( new (C, 3) AndINode(mods, mask) );
a61af66fc99e Initial load
duke
parents:
diff changeset
3002 Node* cmp = _gvn.transform( new (C, 3) CmpINode(mbit, bits) );
a61af66fc99e Initial load
duke
parents:
diff changeset
3003 Node* bol = _gvn.transform( new (C, 2) BoolNode(cmp, BoolTest::ne) );
a61af66fc99e Initial load
duke
parents:
diff changeset
3004 return generate_fair_guard(bol, region);
a61af66fc99e Initial load
duke
parents:
diff changeset
3005 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3006 Node* LibraryCallKit::generate_interface_guard(Node* kls, RegionNode* region) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3007 return generate_access_flags_guard(kls, JVM_ACC_INTERFACE, 0, region);
a61af66fc99e Initial load
duke
parents:
diff changeset
3008 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3009
a61af66fc99e Initial load
duke
parents:
diff changeset
3010 //-------------------------inline_native_Class_query-------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
3011 bool LibraryCallKit::inline_native_Class_query(vmIntrinsics::ID id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3012 int nargs = 1+0; // just the Class mirror, in most cases
a61af66fc99e Initial load
duke
parents:
diff changeset
3013 const Type* return_type = TypeInt::BOOL;
a61af66fc99e Initial load
duke
parents:
diff changeset
3014 Node* prim_return_value = top(); // what happens if it's a primitive class?
a61af66fc99e Initial load
duke
parents:
diff changeset
3015 bool never_see_null = !too_many_traps(Deoptimization::Reason_null_check);
a61af66fc99e Initial load
duke
parents:
diff changeset
3016 bool expect_prim = false; // most of these guys expect to work on refs
a61af66fc99e Initial load
duke
parents:
diff changeset
3017
a61af66fc99e Initial load
duke
parents:
diff changeset
3018 enum { _normal_path = 1, _prim_path = 2, PATH_LIMIT };
a61af66fc99e Initial load
duke
parents:
diff changeset
3019
a61af66fc99e Initial load
duke
parents:
diff changeset
3020 switch (id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3021 case vmIntrinsics::_isInstance:
a61af66fc99e Initial load
duke
parents:
diff changeset
3022 nargs = 1+1; // the Class mirror, plus the object getting queried about
a61af66fc99e Initial load
duke
parents:
diff changeset
3023 // nothing is an instance of a primitive type
a61af66fc99e Initial load
duke
parents:
diff changeset
3024 prim_return_value = intcon(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
3025 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3026 case vmIntrinsics::_getModifiers:
a61af66fc99e Initial load
duke
parents:
diff changeset
3027 prim_return_value = intcon(JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC);
a61af66fc99e Initial load
duke
parents:
diff changeset
3028 assert(is_power_of_2((int)JVM_ACC_WRITTEN_FLAGS+1), "change next line");
a61af66fc99e Initial load
duke
parents:
diff changeset
3029 return_type = TypeInt::make(0, JVM_ACC_WRITTEN_FLAGS, Type::WidenMin);
a61af66fc99e Initial load
duke
parents:
diff changeset
3030 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3031 case vmIntrinsics::_isInterface:
a61af66fc99e Initial load
duke
parents:
diff changeset
3032 prim_return_value = intcon(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
3033 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3034 case vmIntrinsics::_isArray:
a61af66fc99e Initial load
duke
parents:
diff changeset
3035 prim_return_value = intcon(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
3036 expect_prim = true; // cf. ObjectStreamClass.getClassSignature
a61af66fc99e Initial load
duke
parents:
diff changeset
3037 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3038 case vmIntrinsics::_isPrimitive:
a61af66fc99e Initial load
duke
parents:
diff changeset
3039 prim_return_value = intcon(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
3040 expect_prim = true; // obviously
a61af66fc99e Initial load
duke
parents:
diff changeset
3041 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3042 case vmIntrinsics::_getSuperclass:
a61af66fc99e Initial load
duke
parents:
diff changeset
3043 prim_return_value = null();
a61af66fc99e Initial load
duke
parents:
diff changeset
3044 return_type = TypeInstPtr::MIRROR->cast_to_ptr_type(TypePtr::BotPTR);
a61af66fc99e Initial load
duke
parents:
diff changeset
3045 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3046 case vmIntrinsics::_getComponentType:
a61af66fc99e Initial load
duke
parents:
diff changeset
3047 prim_return_value = null();
a61af66fc99e Initial load
duke
parents:
diff changeset
3048 return_type = TypeInstPtr::MIRROR->cast_to_ptr_type(TypePtr::BotPTR);
a61af66fc99e Initial load
duke
parents:
diff changeset
3049 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3050 case vmIntrinsics::_getClassAccessFlags:
a61af66fc99e Initial load
duke
parents:
diff changeset
3051 prim_return_value = intcon(JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC);
a61af66fc99e Initial load
duke
parents:
diff changeset
3052 return_type = TypeInt::INT; // not bool! 6297094
a61af66fc99e Initial load
duke
parents:
diff changeset
3053 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3054 default:
a61af66fc99e Initial load
duke
parents:
diff changeset
3055 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
3056 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3057
a61af66fc99e Initial load
duke
parents:
diff changeset
3058 Node* mirror = argument(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
3059 Node* obj = (nargs <= 1)? top(): argument(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
3060
a61af66fc99e Initial load
duke
parents:
diff changeset
3061 const TypeInstPtr* mirror_con = _gvn.type(mirror)->isa_instptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
3062 if (mirror_con == NULL) return false; // cannot happen?
a61af66fc99e Initial load
duke
parents:
diff changeset
3063
a61af66fc99e Initial load
duke
parents:
diff changeset
3064 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
3065 if (PrintIntrinsics || PrintInlining || PrintOptoInlining) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3066 ciType* k = mirror_con->java_mirror_type();
a61af66fc99e Initial load
duke
parents:
diff changeset
3067 if (k) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3068 tty->print("Inlining %s on constant Class ", vmIntrinsics::name_at(intrinsic_id()));
a61af66fc99e Initial load
duke
parents:
diff changeset
3069 k->print_name();
a61af66fc99e Initial load
duke
parents:
diff changeset
3070 tty->cr();
a61af66fc99e Initial load
duke
parents:
diff changeset
3071 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3072 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3073 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
3074
a61af66fc99e Initial load
duke
parents:
diff changeset
3075 // Null-check the mirror, and the mirror's klass ptr (in case it is a primitive).
a61af66fc99e Initial load
duke
parents:
diff changeset
3076 RegionNode* region = new (C, PATH_LIMIT) RegionNode(PATH_LIMIT);
a61af66fc99e Initial load
duke
parents:
diff changeset
3077 record_for_igvn(region);
a61af66fc99e Initial load
duke
parents:
diff changeset
3078 PhiNode* phi = new (C, PATH_LIMIT) PhiNode(region, return_type);
a61af66fc99e Initial load
duke
parents:
diff changeset
3079
a61af66fc99e Initial load
duke
parents:
diff changeset
3080 // The mirror will never be null of Reflection.getClassAccessFlags, however
a61af66fc99e Initial load
duke
parents:
diff changeset
3081 // it may be null for Class.isInstance or Class.getModifiers. Throw a NPE
a61af66fc99e Initial load
duke
parents:
diff changeset
3082 // if it is. See bug 4774291.
a61af66fc99e Initial load
duke
parents:
diff changeset
3083
a61af66fc99e Initial load
duke
parents:
diff changeset
3084 // For Reflection.getClassAccessFlags(), the null check occurs in
a61af66fc99e Initial load
duke
parents:
diff changeset
3085 // the wrong place; see inline_unsafe_access(), above, for a similar
a61af66fc99e Initial load
duke
parents:
diff changeset
3086 // situation.
a61af66fc99e Initial load
duke
parents:
diff changeset
3087 _sp += nargs; // set original stack for use by uncommon_trap
a61af66fc99e Initial load
duke
parents:
diff changeset
3088 mirror = do_null_check(mirror, T_OBJECT);
a61af66fc99e Initial load
duke
parents:
diff changeset
3089 _sp -= nargs;
a61af66fc99e Initial load
duke
parents:
diff changeset
3090 // If mirror or obj is dead, only null-path is taken.
a61af66fc99e Initial load
duke
parents:
diff changeset
3091 if (stopped()) return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3092
a61af66fc99e Initial load
duke
parents:
diff changeset
3093 if (expect_prim) never_see_null = false; // expect nulls (meaning prims)
a61af66fc99e Initial load
duke
parents:
diff changeset
3094
a61af66fc99e Initial load
duke
parents:
diff changeset
3095 // Now load the mirror's klass metaobject, and null-check it.
a61af66fc99e Initial load
duke
parents:
diff changeset
3096 // Side-effects region with the control path if the klass is null.
a61af66fc99e Initial load
duke
parents:
diff changeset
3097 Node* kls = load_klass_from_mirror(mirror, never_see_null, nargs,
a61af66fc99e Initial load
duke
parents:
diff changeset
3098 region, _prim_path);
a61af66fc99e Initial load
duke
parents:
diff changeset
3099 // If kls is null, we have a primitive mirror.
a61af66fc99e Initial load
duke
parents:
diff changeset
3100 phi->init_req(_prim_path, prim_return_value);
a61af66fc99e Initial load
duke
parents:
diff changeset
3101 if (stopped()) { push_result(region, phi); return true; }
a61af66fc99e Initial load
duke
parents:
diff changeset
3102
a61af66fc99e Initial load
duke
parents:
diff changeset
3103 Node* p; // handy temp
a61af66fc99e Initial load
duke
parents:
diff changeset
3104 Node* null_ctl;
a61af66fc99e Initial load
duke
parents:
diff changeset
3105
a61af66fc99e Initial load
duke
parents:
diff changeset
3106 // Now that we have the non-null klass, we can perform the real query.
a61af66fc99e Initial load
duke
parents:
diff changeset
3107 // For constant classes, the query will constant-fold in LoadNode::Value.
a61af66fc99e Initial load
duke
parents:
diff changeset
3108 Node* query_value = top();
a61af66fc99e Initial load
duke
parents:
diff changeset
3109 switch (id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3110 case vmIntrinsics::_isInstance:
a61af66fc99e Initial load
duke
parents:
diff changeset
3111 // nothing is an instance of a primitive type
1746
4b29a725c43c 6912064: type profiles need to be exploited more for dynamic language support
jrose
parents: 1609
diff changeset
3112 _sp += nargs; // gen_instanceof might do an uncommon trap
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3113 query_value = gen_instanceof(obj, kls);
1746
4b29a725c43c 6912064: type profiles need to be exploited more for dynamic language support
jrose
parents: 1609
diff changeset
3114 _sp -= nargs;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3115 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3116
a61af66fc99e Initial load
duke
parents:
diff changeset
3117 case vmIntrinsics::_getModifiers:
a61af66fc99e Initial load
duke
parents:
diff changeset
3118 p = basic_plus_adr(kls, Klass::modifier_flags_offset_in_bytes() + sizeof(oopDesc));
a61af66fc99e Initial load
duke
parents:
diff changeset
3119 query_value = make_load(NULL, p, TypeInt::INT, T_INT);
a61af66fc99e Initial load
duke
parents:
diff changeset
3120 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3121
a61af66fc99e Initial load
duke
parents:
diff changeset
3122 case vmIntrinsics::_isInterface:
a61af66fc99e Initial load
duke
parents:
diff changeset
3123 // (To verify this code sequence, check the asserts in JVM_IsInterface.)
a61af66fc99e Initial load
duke
parents:
diff changeset
3124 if (generate_interface_guard(kls, region) != NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
3125 // A guard was added. If the guard is taken, it was an interface.
a61af66fc99e Initial load
duke
parents:
diff changeset
3126 phi->add_req(intcon(1));
a61af66fc99e Initial load
duke
parents:
diff changeset
3127 // If we fall through, it's a plain class.
a61af66fc99e Initial load
duke
parents:
diff changeset
3128 query_value = intcon(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
3129 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3130
a61af66fc99e Initial load
duke
parents:
diff changeset
3131 case vmIntrinsics::_isArray:
a61af66fc99e Initial load
duke
parents:
diff changeset
3132 // (To verify this code sequence, check the asserts in JVM_IsArrayClass.)
a61af66fc99e Initial load
duke
parents:
diff changeset
3133 if (generate_array_guard(kls, region) != NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
3134 // A guard was added. If the guard is taken, it was an array.
a61af66fc99e Initial load
duke
parents:
diff changeset
3135 phi->add_req(intcon(1));
a61af66fc99e Initial load
duke
parents:
diff changeset
3136 // If we fall through, it's a plain class.
a61af66fc99e Initial load
duke
parents:
diff changeset
3137 query_value = intcon(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
3138 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3139
a61af66fc99e Initial load
duke
parents:
diff changeset
3140 case vmIntrinsics::_isPrimitive:
a61af66fc99e Initial load
duke
parents:
diff changeset
3141 query_value = intcon(0); // "normal" path produces false
a61af66fc99e Initial load
duke
parents:
diff changeset
3142 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3143
a61af66fc99e Initial load
duke
parents:
diff changeset
3144 case vmIntrinsics::_getSuperclass:
a61af66fc99e Initial load
duke
parents:
diff changeset
3145 // The rules here are somewhat unfortunate, but we can still do better
a61af66fc99e Initial load
duke
parents:
diff changeset
3146 // with random logic than with a JNI call.
a61af66fc99e Initial load
duke
parents:
diff changeset
3147 // Interfaces store null or Object as _super, but must report null.
a61af66fc99e Initial load
duke
parents:
diff changeset
3148 // Arrays store an intermediate super as _super, but must report Object.
a61af66fc99e Initial load
duke
parents:
diff changeset
3149 // Other types can report the actual _super.
a61af66fc99e Initial load
duke
parents:
diff changeset
3150 // (To verify this code sequence, check the asserts in JVM_IsInterface.)
a61af66fc99e Initial load
duke
parents:
diff changeset
3151 if (generate_interface_guard(kls, region) != NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
3152 // A guard was added. If the guard is taken, it was an interface.
a61af66fc99e Initial load
duke
parents:
diff changeset
3153 phi->add_req(null());
a61af66fc99e Initial load
duke
parents:
diff changeset
3154 if (generate_array_guard(kls, region) != NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
3155 // A guard was added. If the guard is taken, it was an array.
a61af66fc99e Initial load
duke
parents:
diff changeset
3156 phi->add_req(makecon(TypeInstPtr::make(env()->Object_klass()->java_mirror())));
a61af66fc99e Initial load
duke
parents:
diff changeset
3157 // If we fall through, it's a plain class. Get its _super.
a61af66fc99e Initial load
duke
parents:
diff changeset
3158 p = basic_plus_adr(kls, Klass::super_offset_in_bytes() + sizeof(oopDesc));
164
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
3159 kls = _gvn.transform( LoadKlassNode::make(_gvn, immutable_memory(), p, TypeRawPtr::BOTTOM, TypeKlassPtr::OBJECT_OR_NULL) );
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3160 null_ctl = top();
a61af66fc99e Initial load
duke
parents:
diff changeset
3161 kls = null_check_oop(kls, &null_ctl);
a61af66fc99e Initial load
duke
parents:
diff changeset
3162 if (null_ctl != top()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3163 // If the guard is taken, Object.superClass is null (both klass and mirror).
a61af66fc99e Initial load
duke
parents:
diff changeset
3164 region->add_req(null_ctl);
a61af66fc99e Initial load
duke
parents:
diff changeset
3165 phi ->add_req(null());
a61af66fc99e Initial load
duke
parents:
diff changeset
3166 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3167 if (!stopped()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3168 query_value = load_mirror_from_klass(kls);
a61af66fc99e Initial load
duke
parents:
diff changeset
3169 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3170 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3171
a61af66fc99e Initial load
duke
parents:
diff changeset
3172 case vmIntrinsics::_getComponentType:
a61af66fc99e Initial load
duke
parents:
diff changeset
3173 if (generate_array_guard(kls, region) != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3174 // Be sure to pin the oop load to the guard edge just created:
a61af66fc99e Initial load
duke
parents:
diff changeset
3175 Node* is_array_ctrl = region->in(region->req()-1);
a61af66fc99e Initial load
duke
parents:
diff changeset
3176 Node* cma = basic_plus_adr(kls, in_bytes(arrayKlass::component_mirror_offset()) + sizeof(oopDesc));
a61af66fc99e Initial load
duke
parents:
diff changeset
3177 Node* cmo = make_load(is_array_ctrl, cma, TypeInstPtr::MIRROR, T_OBJECT);
a61af66fc99e Initial load
duke
parents:
diff changeset
3178 phi->add_req(cmo);
a61af66fc99e Initial load
duke
parents:
diff changeset
3179 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3180 query_value = null(); // non-array case is null
a61af66fc99e Initial load
duke
parents:
diff changeset
3181 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3182
a61af66fc99e Initial load
duke
parents:
diff changeset
3183 case vmIntrinsics::_getClassAccessFlags:
a61af66fc99e Initial load
duke
parents:
diff changeset
3184 p = basic_plus_adr(kls, Klass::access_flags_offset_in_bytes() + sizeof(oopDesc));
a61af66fc99e Initial load
duke
parents:
diff changeset
3185 query_value = make_load(NULL, p, TypeInt::INT, T_INT);
a61af66fc99e Initial load
duke
parents:
diff changeset
3186 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3187
a61af66fc99e Initial load
duke
parents:
diff changeset
3188 default:
a61af66fc99e Initial load
duke
parents:
diff changeset
3189 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
3190 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3191
a61af66fc99e Initial load
duke
parents:
diff changeset
3192 // Fall-through is the normal case of a query to a real class.
a61af66fc99e Initial load
duke
parents:
diff changeset
3193 phi->init_req(1, query_value);
a61af66fc99e Initial load
duke
parents:
diff changeset
3194 region->init_req(1, control());
a61af66fc99e Initial load
duke
parents:
diff changeset
3195
a61af66fc99e Initial load
duke
parents:
diff changeset
3196 push_result(region, phi);
a61af66fc99e Initial load
duke
parents:
diff changeset
3197 C->set_has_split_ifs(true); // Has chance for split-if optimization
a61af66fc99e Initial load
duke
parents:
diff changeset
3198
a61af66fc99e Initial load
duke
parents:
diff changeset
3199 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3200 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3201
a61af66fc99e Initial load
duke
parents:
diff changeset
3202 //--------------------------inline_native_subtype_check------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
3203 // This intrinsic takes the JNI calls out of the heart of
a61af66fc99e Initial load
duke
parents:
diff changeset
3204 // UnsafeFieldAccessorImpl.set, which improves Field.set, readObject, etc.
a61af66fc99e Initial load
duke
parents:
diff changeset
3205 bool LibraryCallKit::inline_native_subtype_check() {
a61af66fc99e Initial load
duke
parents:
diff changeset
3206 int nargs = 1+1; // the Class mirror, plus the other class getting examined
a61af66fc99e Initial load
duke
parents:
diff changeset
3207
a61af66fc99e Initial load
duke
parents:
diff changeset
3208 // Pull both arguments off the stack.
a61af66fc99e Initial load
duke
parents:
diff changeset
3209 Node* args[2]; // two java.lang.Class mirrors: superc, subc
a61af66fc99e Initial load
duke
parents:
diff changeset
3210 args[0] = argument(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
3211 args[1] = argument(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
3212 Node* klasses[2]; // corresponding Klasses: superk, subk
a61af66fc99e Initial load
duke
parents:
diff changeset
3213 klasses[0] = klasses[1] = top();
a61af66fc99e Initial load
duke
parents:
diff changeset
3214
a61af66fc99e Initial load
duke
parents:
diff changeset
3215 enum {
a61af66fc99e Initial load
duke
parents:
diff changeset
3216 // A full decision tree on {superc is prim, subc is prim}:
a61af66fc99e Initial load
duke
parents:
diff changeset
3217 _prim_0_path = 1, // {P,N} => false
a61af66fc99e Initial load
duke
parents:
diff changeset
3218 // {P,P} & superc!=subc => false
a61af66fc99e Initial load
duke
parents:
diff changeset
3219 _prim_same_path, // {P,P} & superc==subc => true
a61af66fc99e Initial load
duke
parents:
diff changeset
3220 _prim_1_path, // {N,P} => false
a61af66fc99e Initial load
duke
parents:
diff changeset
3221 _ref_subtype_path, // {N,N} & subtype check wins => true
a61af66fc99e Initial load
duke
parents:
diff changeset
3222 _both_ref_path, // {N,N} & subtype check loses => false
a61af66fc99e Initial load
duke
parents:
diff changeset
3223 PATH_LIMIT
a61af66fc99e Initial load
duke
parents:
diff changeset
3224 };
a61af66fc99e Initial load
duke
parents:
diff changeset
3225
a61af66fc99e Initial load
duke
parents:
diff changeset
3226 RegionNode* region = new (C, PATH_LIMIT) RegionNode(PATH_LIMIT);
a61af66fc99e Initial load
duke
parents:
diff changeset
3227 Node* phi = new (C, PATH_LIMIT) PhiNode(region, TypeInt::BOOL);
a61af66fc99e Initial load
duke
parents:
diff changeset
3228 record_for_igvn(region);
a61af66fc99e Initial load
duke
parents:
diff changeset
3229
a61af66fc99e Initial load
duke
parents:
diff changeset
3230 const TypePtr* adr_type = TypeRawPtr::BOTTOM; // memory type of loads
a61af66fc99e Initial load
duke
parents:
diff changeset
3231 const TypeKlassPtr* kls_type = TypeKlassPtr::OBJECT_OR_NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
3232 int class_klass_offset = java_lang_Class::klass_offset_in_bytes();
a61af66fc99e Initial load
duke
parents:
diff changeset
3233
a61af66fc99e Initial load
duke
parents:
diff changeset
3234 // First null-check both mirrors and load each mirror's klass metaobject.
a61af66fc99e Initial load
duke
parents:
diff changeset
3235 int which_arg;
a61af66fc99e Initial load
duke
parents:
diff changeset
3236 for (which_arg = 0; which_arg <= 1; which_arg++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3237 Node* arg = args[which_arg];
a61af66fc99e Initial load
duke
parents:
diff changeset
3238 _sp += nargs; // set original stack for use by uncommon_trap
a61af66fc99e Initial load
duke
parents:
diff changeset
3239 arg = do_null_check(arg, T_OBJECT);
a61af66fc99e Initial load
duke
parents:
diff changeset
3240 _sp -= nargs;
a61af66fc99e Initial load
duke
parents:
diff changeset
3241 if (stopped()) break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3242 args[which_arg] = _gvn.transform(arg);
a61af66fc99e Initial load
duke
parents:
diff changeset
3243
a61af66fc99e Initial load
duke
parents:
diff changeset
3244 Node* p = basic_plus_adr(arg, class_klass_offset);
164
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
3245 Node* kls = LoadKlassNode::make(_gvn, immutable_memory(), p, adr_type, kls_type);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3246 klasses[which_arg] = _gvn.transform(kls);
a61af66fc99e Initial load
duke
parents:
diff changeset
3247 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3248
a61af66fc99e Initial load
duke
parents:
diff changeset
3249 // Having loaded both klasses, test each for null.
a61af66fc99e Initial load
duke
parents:
diff changeset
3250 bool never_see_null = !too_many_traps(Deoptimization::Reason_null_check);
a61af66fc99e Initial load
duke
parents:
diff changeset
3251 for (which_arg = 0; which_arg <= 1; which_arg++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3252 Node* kls = klasses[which_arg];
a61af66fc99e Initial load
duke
parents:
diff changeset
3253 Node* null_ctl = top();
a61af66fc99e Initial load
duke
parents:
diff changeset
3254 _sp += nargs; // set original stack for use by uncommon_trap
a61af66fc99e Initial load
duke
parents:
diff changeset
3255 kls = null_check_oop(kls, &null_ctl, never_see_null);
a61af66fc99e Initial load
duke
parents:
diff changeset
3256 _sp -= nargs;
a61af66fc99e Initial load
duke
parents:
diff changeset
3257 int prim_path = (which_arg == 0 ? _prim_0_path : _prim_1_path);
a61af66fc99e Initial load
duke
parents:
diff changeset
3258 region->init_req(prim_path, null_ctl);
a61af66fc99e Initial load
duke
parents:
diff changeset
3259 if (stopped()) break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3260 klasses[which_arg] = kls;
a61af66fc99e Initial load
duke
parents:
diff changeset
3261 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3262
a61af66fc99e Initial load
duke
parents:
diff changeset
3263 if (!stopped()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3264 // now we have two reference types, in klasses[0..1]
a61af66fc99e Initial load
duke
parents:
diff changeset
3265 Node* subk = klasses[1]; // the argument to isAssignableFrom
a61af66fc99e Initial load
duke
parents:
diff changeset
3266 Node* superk = klasses[0]; // the receiver
a61af66fc99e Initial load
duke
parents:
diff changeset
3267 region->set_req(_both_ref_path, gen_subtype_check(subk, superk));
a61af66fc99e Initial load
duke
parents:
diff changeset
3268 // now we have a successful reference subtype check
a61af66fc99e Initial load
duke
parents:
diff changeset
3269 region->set_req(_ref_subtype_path, control());
a61af66fc99e Initial load
duke
parents:
diff changeset
3270 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3271
a61af66fc99e Initial load
duke
parents:
diff changeset
3272 // If both operands are primitive (both klasses null), then
a61af66fc99e Initial load
duke
parents:
diff changeset
3273 // we must return true when they are identical primitives.
a61af66fc99e Initial load
duke
parents:
diff changeset
3274 // It is convenient to test this after the first null klass check.
a61af66fc99e Initial load
duke
parents:
diff changeset
3275 set_control(region->in(_prim_0_path)); // go back to first null check
a61af66fc99e Initial load
duke
parents:
diff changeset
3276 if (!stopped()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3277 // Since superc is primitive, make a guard for the superc==subc case.
a61af66fc99e Initial load
duke
parents:
diff changeset
3278 Node* cmp_eq = _gvn.transform( new (C, 3) CmpPNode(args[0], args[1]) );
a61af66fc99e Initial load
duke
parents:
diff changeset
3279 Node* bol_eq = _gvn.transform( new (C, 2) BoolNode(cmp_eq, BoolTest::eq) );
a61af66fc99e Initial load
duke
parents:
diff changeset
3280 generate_guard(bol_eq, region, PROB_FAIR);
a61af66fc99e Initial load
duke
parents:
diff changeset
3281 if (region->req() == PATH_LIMIT+1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3282 // A guard was added. If the added guard is taken, superc==subc.
a61af66fc99e Initial load
duke
parents:
diff changeset
3283 region->swap_edges(PATH_LIMIT, _prim_same_path);
a61af66fc99e Initial load
duke
parents:
diff changeset
3284 region->del_req(PATH_LIMIT);
a61af66fc99e Initial load
duke
parents:
diff changeset
3285 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3286 region->set_req(_prim_0_path, control()); // Not equal after all.
a61af66fc99e Initial load
duke
parents:
diff changeset
3287 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3288
a61af66fc99e Initial load
duke
parents:
diff changeset
3289 // these are the only paths that produce 'true':
a61af66fc99e Initial load
duke
parents:
diff changeset
3290 phi->set_req(_prim_same_path, intcon(1));
a61af66fc99e Initial load
duke
parents:
diff changeset
3291 phi->set_req(_ref_subtype_path, intcon(1));
a61af66fc99e Initial load
duke
parents:
diff changeset
3292
a61af66fc99e Initial load
duke
parents:
diff changeset
3293 // pull together the cases:
a61af66fc99e Initial load
duke
parents:
diff changeset
3294 assert(region->req() == PATH_LIMIT, "sane region");
a61af66fc99e Initial load
duke
parents:
diff changeset
3295 for (uint i = 1; i < region->req(); i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3296 Node* ctl = region->in(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
3297 if (ctl == NULL || ctl == top()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3298 region->set_req(i, top());
a61af66fc99e Initial load
duke
parents:
diff changeset
3299 phi ->set_req(i, top());
a61af66fc99e Initial load
duke
parents:
diff changeset
3300 } else if (phi->in(i) == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3301 phi->set_req(i, intcon(0)); // all other paths produce 'false'
a61af66fc99e Initial load
duke
parents:
diff changeset
3302 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3303 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3304
a61af66fc99e Initial load
duke
parents:
diff changeset
3305 set_control(_gvn.transform(region));
a61af66fc99e Initial load
duke
parents:
diff changeset
3306 push(_gvn.transform(phi));
a61af66fc99e Initial load
duke
parents:
diff changeset
3307
a61af66fc99e Initial load
duke
parents:
diff changeset
3308 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3309 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3310
a61af66fc99e Initial load
duke
parents:
diff changeset
3311 //---------------------generate_array_guard_common------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
3312 Node* LibraryCallKit::generate_array_guard_common(Node* kls, RegionNode* region,
a61af66fc99e Initial load
duke
parents:
diff changeset
3313 bool obj_array, bool not_array) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3314 // If obj_array/non_array==false/false:
a61af66fc99e Initial load
duke
parents:
diff changeset
3315 // Branch around if the given klass is in fact an array (either obj or prim).
a61af66fc99e Initial load
duke
parents:
diff changeset
3316 // If obj_array/non_array==false/true:
a61af66fc99e Initial load
duke
parents:
diff changeset
3317 // Branch around if the given klass is not an array klass of any kind.
a61af66fc99e Initial load
duke
parents:
diff changeset
3318 // If obj_array/non_array==true/true:
a61af66fc99e Initial load
duke
parents:
diff changeset
3319 // Branch around if the kls is not an oop array (kls is int[], String, etc.)
a61af66fc99e Initial load
duke
parents:
diff changeset
3320 // If obj_array/non_array==true/false:
a61af66fc99e Initial load
duke
parents:
diff changeset
3321 // Branch around if the kls is an oop array (Object[] or subtype)
a61af66fc99e Initial load
duke
parents:
diff changeset
3322 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3323 // Like generate_guard, adds a new path onto the region.
a61af66fc99e Initial load
duke
parents:
diff changeset
3324 jint layout_con = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
3325 Node* layout_val = get_layout_helper(kls, layout_con);
a61af66fc99e Initial load
duke
parents:
diff changeset
3326 if (layout_val == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3327 bool query = (obj_array
a61af66fc99e Initial load
duke
parents:
diff changeset
3328 ? Klass::layout_helper_is_objArray(layout_con)
a61af66fc99e Initial load
duke
parents:
diff changeset
3329 : Klass::layout_helper_is_javaArray(layout_con));
a61af66fc99e Initial load
duke
parents:
diff changeset
3330 if (query == not_array) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3331 return NULL; // never a branch
a61af66fc99e Initial load
duke
parents:
diff changeset
3332 } else { // always a branch
a61af66fc99e Initial load
duke
parents:
diff changeset
3333 Node* always_branch = control();
a61af66fc99e Initial load
duke
parents:
diff changeset
3334 if (region != NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
3335 region->add_req(always_branch);
a61af66fc99e Initial load
duke
parents:
diff changeset
3336 set_control(top());
a61af66fc99e Initial load
duke
parents:
diff changeset
3337 return always_branch;
a61af66fc99e Initial load
duke
parents:
diff changeset
3338 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3339 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3340 // Now test the correct condition.
a61af66fc99e Initial load
duke
parents:
diff changeset
3341 jint nval = (obj_array
a61af66fc99e Initial load
duke
parents:
diff changeset
3342 ? ((jint)Klass::_lh_array_tag_type_value
a61af66fc99e Initial load
duke
parents:
diff changeset
3343 << Klass::_lh_array_tag_shift)
a61af66fc99e Initial load
duke
parents:
diff changeset
3344 : Klass::_lh_neutral_value);
a61af66fc99e Initial load
duke
parents:
diff changeset
3345 Node* cmp = _gvn.transform( new(C, 3) CmpINode(layout_val, intcon(nval)) );
a61af66fc99e Initial load
duke
parents:
diff changeset
3346 BoolTest::mask btest = BoolTest::lt; // correct for testing is_[obj]array
a61af66fc99e Initial load
duke
parents:
diff changeset
3347 // invert the test if we are looking for a non-array
a61af66fc99e Initial load
duke
parents:
diff changeset
3348 if (not_array) btest = BoolTest(btest).negate();
a61af66fc99e Initial load
duke
parents:
diff changeset
3349 Node* bol = _gvn.transform( new(C, 2) BoolNode(cmp, btest) );
a61af66fc99e Initial load
duke
parents:
diff changeset
3350 return generate_fair_guard(bol, region);
a61af66fc99e Initial load
duke
parents:
diff changeset
3351 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3352
a61af66fc99e Initial load
duke
parents:
diff changeset
3353
a61af66fc99e Initial load
duke
parents:
diff changeset
3354 //-----------------------inline_native_newArray--------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
3355 bool LibraryCallKit::inline_native_newArray() {
a61af66fc99e Initial load
duke
parents:
diff changeset
3356 int nargs = 2;
a61af66fc99e Initial load
duke
parents:
diff changeset
3357 Node* mirror = argument(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
3358 Node* count_val = argument(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
3359
a61af66fc99e Initial load
duke
parents:
diff changeset
3360 _sp += nargs; // set original stack for use by uncommon_trap
a61af66fc99e Initial load
duke
parents:
diff changeset
3361 mirror = do_null_check(mirror, T_OBJECT);
a61af66fc99e Initial load
duke
parents:
diff changeset
3362 _sp -= nargs;
163
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 113
diff changeset
3363 // If mirror or obj is dead, only null-path is taken.
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 113
diff changeset
3364 if (stopped()) return true;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3365
a61af66fc99e Initial load
duke
parents:
diff changeset
3366 enum { _normal_path = 1, _slow_path = 2, PATH_LIMIT };
a61af66fc99e Initial load
duke
parents:
diff changeset
3367 RegionNode* result_reg = new(C, PATH_LIMIT) RegionNode(PATH_LIMIT);
a61af66fc99e Initial load
duke
parents:
diff changeset
3368 PhiNode* result_val = new(C, PATH_LIMIT) PhiNode(result_reg,
a61af66fc99e Initial load
duke
parents:
diff changeset
3369 TypeInstPtr::NOTNULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
3370 PhiNode* result_io = new(C, PATH_LIMIT) PhiNode(result_reg, Type::ABIO);
a61af66fc99e Initial load
duke
parents:
diff changeset
3371 PhiNode* result_mem = new(C, PATH_LIMIT) PhiNode(result_reg, Type::MEMORY,
a61af66fc99e Initial load
duke
parents:
diff changeset
3372 TypePtr::BOTTOM);
a61af66fc99e Initial load
duke
parents:
diff changeset
3373
a61af66fc99e Initial load
duke
parents:
diff changeset
3374 bool never_see_null = !too_many_traps(Deoptimization::Reason_null_check);
a61af66fc99e Initial load
duke
parents:
diff changeset
3375 Node* klass_node = load_array_klass_from_mirror(mirror, never_see_null,
a61af66fc99e Initial load
duke
parents:
diff changeset
3376 nargs,
a61af66fc99e Initial load
duke
parents:
diff changeset
3377 result_reg, _slow_path);
a61af66fc99e Initial load
duke
parents:
diff changeset
3378 Node* normal_ctl = control();
a61af66fc99e Initial load
duke
parents:
diff changeset
3379 Node* no_array_ctl = result_reg->in(_slow_path);
a61af66fc99e Initial load
duke
parents:
diff changeset
3380
a61af66fc99e Initial load
duke
parents:
diff changeset
3381 // Generate code for the slow case. We make a call to newArray().
a61af66fc99e Initial load
duke
parents:
diff changeset
3382 set_control(no_array_ctl);
a61af66fc99e Initial load
duke
parents:
diff changeset
3383 if (!stopped()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3384 // Either the input type is void.class, or else the
a61af66fc99e Initial load
duke
parents:
diff changeset
3385 // array klass has not yet been cached. Either the
a61af66fc99e Initial load
duke
parents:
diff changeset
3386 // ensuing call will throw an exception, or else it
a61af66fc99e Initial load
duke
parents:
diff changeset
3387 // will cache the array klass for next time.
a61af66fc99e Initial load
duke
parents:
diff changeset
3388 PreserveJVMState pjvms(this);
a61af66fc99e Initial load
duke
parents:
diff changeset
3389 CallJavaNode* slow_call = generate_method_call_static(vmIntrinsics::_newArray);
a61af66fc99e Initial load
duke
parents:
diff changeset
3390 Node* slow_result = set_results_for_java_call(slow_call);
a61af66fc99e Initial load
duke
parents:
diff changeset
3391 // this->control() comes from set_results_for_java_call
a61af66fc99e Initial load
duke
parents:
diff changeset
3392 result_reg->set_req(_slow_path, control());
a61af66fc99e Initial load
duke
parents:
diff changeset
3393 result_val->set_req(_slow_path, slow_result);
a61af66fc99e Initial load
duke
parents:
diff changeset
3394 result_io ->set_req(_slow_path, i_o());
a61af66fc99e Initial load
duke
parents:
diff changeset
3395 result_mem->set_req(_slow_path, reset_memory());
a61af66fc99e Initial load
duke
parents:
diff changeset
3396 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3397
a61af66fc99e Initial load
duke
parents:
diff changeset
3398 set_control(normal_ctl);
a61af66fc99e Initial load
duke
parents:
diff changeset
3399 if (!stopped()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3400 // Normal case: The array type has been cached in the java.lang.Class.
a61af66fc99e Initial load
duke
parents:
diff changeset
3401 // The following call works fine even if the array type is polymorphic.
a61af66fc99e Initial load
duke
parents:
diff changeset
3402 // It could be a dynamic mix of int[], boolean[], Object[], etc.
730
9c6be3edf0dc 6589834: deoptimization problem with -XX:+DeoptimizeALot
cfang
parents: 681
diff changeset
3403 Node* obj = new_array(klass_node, count_val, nargs);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3404 result_reg->init_req(_normal_path, control());
a61af66fc99e Initial load
duke
parents:
diff changeset
3405 result_val->init_req(_normal_path, obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
3406 result_io ->init_req(_normal_path, i_o());
a61af66fc99e Initial load
duke
parents:
diff changeset
3407 result_mem->init_req(_normal_path, reset_memory());
a61af66fc99e Initial load
duke
parents:
diff changeset
3408 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3409
a61af66fc99e Initial load
duke
parents:
diff changeset
3410 // Return the combined state.
a61af66fc99e Initial load
duke
parents:
diff changeset
3411 set_i_o( _gvn.transform(result_io) );
a61af66fc99e Initial load
duke
parents:
diff changeset
3412 set_all_memory( _gvn.transform(result_mem) );
a61af66fc99e Initial load
duke
parents:
diff changeset
3413 push_result(result_reg, result_val);
a61af66fc99e Initial load
duke
parents:
diff changeset
3414 C->set_has_split_ifs(true); // Has chance for split-if optimization
a61af66fc99e Initial load
duke
parents:
diff changeset
3415
a61af66fc99e Initial load
duke
parents:
diff changeset
3416 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3417 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3418
a61af66fc99e Initial load
duke
parents:
diff changeset
3419 //----------------------inline_native_getLength--------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
3420 bool LibraryCallKit::inline_native_getLength() {
a61af66fc99e Initial load
duke
parents:
diff changeset
3421 if (too_many_traps(Deoptimization::Reason_intrinsic)) return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
3422
a61af66fc99e Initial load
duke
parents:
diff changeset
3423 int nargs = 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
3424 Node* array = argument(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
3425
a61af66fc99e Initial load
duke
parents:
diff changeset
3426 _sp += nargs; // set original stack for use by uncommon_trap
a61af66fc99e Initial load
duke
parents:
diff changeset
3427 array = do_null_check(array, T_OBJECT);
a61af66fc99e Initial load
duke
parents:
diff changeset
3428 _sp -= nargs;
a61af66fc99e Initial load
duke
parents:
diff changeset
3429
a61af66fc99e Initial load
duke
parents:
diff changeset
3430 // If array is dead, only null-path is taken.
a61af66fc99e Initial load
duke
parents:
diff changeset
3431 if (stopped()) return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3432
a61af66fc99e Initial load
duke
parents:
diff changeset
3433 // Deoptimize if it is a non-array.
a61af66fc99e Initial load
duke
parents:
diff changeset
3434 Node* non_array = generate_non_array_guard(load_object_klass(array), NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
3435
a61af66fc99e Initial load
duke
parents:
diff changeset
3436 if (non_array != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3437 PreserveJVMState pjvms(this);
a61af66fc99e Initial load
duke
parents:
diff changeset
3438 set_control(non_array);
a61af66fc99e Initial load
duke
parents:
diff changeset
3439 _sp += nargs; // push the arguments back on the stack
a61af66fc99e Initial load
duke
parents:
diff changeset
3440 uncommon_trap(Deoptimization::Reason_intrinsic,
a61af66fc99e Initial load
duke
parents:
diff changeset
3441 Deoptimization::Action_maybe_recompile);
a61af66fc99e Initial load
duke
parents:
diff changeset
3442 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3443
a61af66fc99e Initial load
duke
parents:
diff changeset
3444 // If control is dead, only non-array-path is taken.
a61af66fc99e Initial load
duke
parents:
diff changeset
3445 if (stopped()) return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3446
a61af66fc99e Initial load
duke
parents:
diff changeset
3447 // The works fine even if the array type is polymorphic.
a61af66fc99e Initial load
duke
parents:
diff changeset
3448 // It could be a dynamic mix of int[], boolean[], Object[], etc.
a61af66fc99e Initial load
duke
parents:
diff changeset
3449 push( load_array_length(array) );
a61af66fc99e Initial load
duke
parents:
diff changeset
3450
a61af66fc99e Initial load
duke
parents:
diff changeset
3451 C->set_has_split_ifs(true); // Has chance for split-if optimization
a61af66fc99e Initial load
duke
parents:
diff changeset
3452
a61af66fc99e Initial load
duke
parents:
diff changeset
3453 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3454 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3455
a61af66fc99e Initial load
duke
parents:
diff changeset
3456 //------------------------inline_array_copyOf----------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
3457 bool LibraryCallKit::inline_array_copyOf(bool is_copyOfRange) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3458 if (too_many_traps(Deoptimization::Reason_intrinsic)) return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
3459
a61af66fc99e Initial load
duke
parents:
diff changeset
3460 // Restore the stack and pop off the arguments.
a61af66fc99e Initial load
duke
parents:
diff changeset
3461 int nargs = 3 + (is_copyOfRange? 1: 0);
a61af66fc99e Initial load
duke
parents:
diff changeset
3462 Node* original = argument(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
3463 Node* start = is_copyOfRange? argument(1): intcon(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
3464 Node* end = is_copyOfRange? argument(2): argument(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
3465 Node* array_type_mirror = is_copyOfRange? argument(3): argument(2);
a61af66fc99e Initial load
duke
parents:
diff changeset
3466
902
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3467 Node* newcopy;
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3468
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3469 //set the original stack and the reexecute bit for the interpreter to reexecute
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3470 //the bytecode that invokes Arrays.copyOf if deoptimization happens
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3471 { PreserveReexecuteState preexecs(this);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3472 _sp += nargs;
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3473 jvms()->set_should_reexecute(true);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3474
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3475 array_type_mirror = do_null_check(array_type_mirror, T_OBJECT);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3476 original = do_null_check(original, T_OBJECT);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3477
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3478 // Check if a null path was taken unconditionally.
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3479 if (stopped()) return true;
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3480
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3481 Node* orig_length = load_array_length(original);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3482
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3483 Node* klass_node = load_klass_from_mirror(array_type_mirror, false, 0,
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3484 NULL, 0);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3485 klass_node = do_null_check(klass_node, T_OBJECT);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3486
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3487 RegionNode* bailout = new (C, 1) RegionNode(1);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3488 record_for_igvn(bailout);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3489
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3490 // Despite the generic type of Arrays.copyOf, the mirror might be int, int[], etc.
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3491 // Bail out if that is so.
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3492 Node* not_objArray = generate_non_objArray_guard(klass_node, bailout);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3493 if (not_objArray != NULL) {
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3494 // Improve the klass node's type from the new optimistic assumption:
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3495 ciKlass* ak = ciArrayKlass::make(env()->Object_klass());
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3496 const Type* akls = TypeKlassPtr::make(TypePtr::NotNull, ak, 0/*offset*/);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3497 Node* cast = new (C, 2) CastPPNode(klass_node, akls);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3498 cast->init_req(0, control());
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3499 klass_node = _gvn.transform(cast);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3500 }
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3501
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3502 // Bail out if either start or end is negative.
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3503 generate_negative_guard(start, bailout, &start);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3504 generate_negative_guard(end, bailout, &end);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3505
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3506 Node* length = end;
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3507 if (_gvn.type(start) != TypeInt::ZERO) {
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3508 length = _gvn.transform( new (C, 3) SubINode(end, start) );
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3509 }
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3510
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3511 // Bail out if length is negative.
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3512 // ...Not needed, since the new_array will throw the right exception.
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3513 //generate_negative_guard(length, bailout, &length);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3514
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3515 if (bailout->req() > 1) {
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3516 PreserveJVMState pjvms(this);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3517 set_control( _gvn.transform(bailout) );
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3518 uncommon_trap(Deoptimization::Reason_intrinsic,
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3519 Deoptimization::Action_maybe_recompile);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3520 }
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3521
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3522 if (!stopped()) {
900
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
3523
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
3524 // How many elements will we copy from the original?
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
3525 // The answer is MinI(orig_length - start, length).
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
3526 Node* orig_tail = _gvn.transform( new(C, 3) SubINode(orig_length, start) );
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
3527 Node* moved = generate_min_max(vmIntrinsics::_min, orig_tail, length);
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
3528
3278
66b0e2371912 7026700: regression in 6u24-rev-b23: Crash in C2 compiler in PhaseIdealLoop::build_loop_late_post
kvn
parents: 2446
diff changeset
3529 newcopy = new_array(klass_node, length, 0);
900
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
3530
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
3531 // Generate a direct call to the right arraycopy function(s).
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
3532 // We know the copy is disjoint but we might not know if the
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
3533 // oop stores need checking.
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
3534 // Extreme case: Arrays.copyOf((Integer[])x, 10, String[].class).
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
3535 // This will fail a store-check if x contains any non-nulls.
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
3536 bool disjoint_bases = true;
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
3537 bool length_never_negative = true;
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
3538 generate_arraycopy(TypeAryPtr::OOPS, T_OBJECT,
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
3539 original, start, newcopy, intcon(0), moved,
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
3540 disjoint_bases, length_never_negative);
902
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3541 }
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3542 } //original reexecute and sp are set back here
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3543
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
3544 if(!stopped()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3545 push(newcopy);
a61af66fc99e Initial load
duke
parents:
diff changeset
3546 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3547
a61af66fc99e Initial load
duke
parents:
diff changeset
3548 C->set_has_split_ifs(true); // Has chance for split-if optimization
a61af66fc99e Initial load
duke
parents:
diff changeset
3549
a61af66fc99e Initial load
duke
parents:
diff changeset
3550 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3551 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3552
a61af66fc99e Initial load
duke
parents:
diff changeset
3553
a61af66fc99e Initial load
duke
parents:
diff changeset
3554 //----------------------generate_virtual_guard---------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
3555 // Helper for hashCode and clone. Peeks inside the vtable to avoid a call.
a61af66fc99e Initial load
duke
parents:
diff changeset
3556 Node* LibraryCallKit::generate_virtual_guard(Node* obj_klass,
a61af66fc99e Initial load
duke
parents:
diff changeset
3557 RegionNode* slow_region) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3558 ciMethod* method = callee();
a61af66fc99e Initial load
duke
parents:
diff changeset
3559 int vtable_index = method->vtable_index();
a61af66fc99e Initial load
duke
parents:
diff changeset
3560 // Get the methodOop out of the appropriate vtable entry.
a61af66fc99e Initial load
duke
parents:
diff changeset
3561 int entry_offset = (instanceKlass::vtable_start_offset() +
a61af66fc99e Initial load
duke
parents:
diff changeset
3562 vtable_index*vtableEntry::size()) * wordSize +
a61af66fc99e Initial load
duke
parents:
diff changeset
3563 vtableEntry::method_offset_in_bytes();
a61af66fc99e Initial load
duke
parents:
diff changeset
3564 Node* entry_addr = basic_plus_adr(obj_klass, entry_offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
3565 Node* target_call = make_load(NULL, entry_addr, TypeInstPtr::NOTNULL, T_OBJECT);
a61af66fc99e Initial load
duke
parents:
diff changeset
3566
a61af66fc99e Initial load
duke
parents:
diff changeset
3567 // Compare the target method with the expected method (e.g., Object.hashCode).
a61af66fc99e Initial load
duke
parents:
diff changeset
3568 const TypeInstPtr* native_call_addr = TypeInstPtr::make(method);
a61af66fc99e Initial load
duke
parents:
diff changeset
3569
a61af66fc99e Initial load
duke
parents:
diff changeset
3570 Node* native_call = makecon(native_call_addr);
a61af66fc99e Initial load
duke
parents:
diff changeset
3571 Node* chk_native = _gvn.transform( new(C, 3) CmpPNode(target_call, native_call) );
a61af66fc99e Initial load
duke
parents:
diff changeset
3572 Node* test_native = _gvn.transform( new(C, 2) BoolNode(chk_native, BoolTest::ne) );
a61af66fc99e Initial load
duke
parents:
diff changeset
3573
a61af66fc99e Initial load
duke
parents:
diff changeset
3574 return generate_slow_guard(test_native, slow_region);
a61af66fc99e Initial load
duke
parents:
diff changeset
3575 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3576
a61af66fc99e Initial load
duke
parents:
diff changeset
3577 //-----------------------generate_method_call----------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
3578 // Use generate_method_call to make a slow-call to the real
a61af66fc99e Initial load
duke
parents:
diff changeset
3579 // method if the fast path fails. An alternative would be to
a61af66fc99e Initial load
duke
parents:
diff changeset
3580 // use a stub like OptoRuntime::slow_arraycopy_Java.
a61af66fc99e Initial load
duke
parents:
diff changeset
3581 // This only works for expanding the current library call,
a61af66fc99e Initial load
duke
parents:
diff changeset
3582 // not another intrinsic. (E.g., don't use this for making an
a61af66fc99e Initial load
duke
parents:
diff changeset
3583 // arraycopy call inside of the copyOf intrinsic.)
a61af66fc99e Initial load
duke
parents:
diff changeset
3584 CallJavaNode*
a61af66fc99e Initial load
duke
parents:
diff changeset
3585 LibraryCallKit::generate_method_call(vmIntrinsics::ID method_id, bool is_virtual, bool is_static) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3586 // When compiling the intrinsic method itself, do not use this technique.
a61af66fc99e Initial load
duke
parents:
diff changeset
3587 guarantee(callee() != C->method(), "cannot make slow-call to self");
a61af66fc99e Initial load
duke
parents:
diff changeset
3588
a61af66fc99e Initial load
duke
parents:
diff changeset
3589 ciMethod* method = callee();
a61af66fc99e Initial load
duke
parents:
diff changeset
3590 // ensure the JVMS we have will be correct for this call
a61af66fc99e Initial load
duke
parents:
diff changeset
3591 guarantee(method_id == method->intrinsic_id(), "must match");
a61af66fc99e Initial load
duke
parents:
diff changeset
3592
a61af66fc99e Initial load
duke
parents:
diff changeset
3593 const TypeFunc* tf = TypeFunc::make(method);
a61af66fc99e Initial load
duke
parents:
diff changeset
3594 int tfdc = tf->domain()->cnt();
a61af66fc99e Initial load
duke
parents:
diff changeset
3595 CallJavaNode* slow_call;
a61af66fc99e Initial load
duke
parents:
diff changeset
3596 if (is_static) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3597 assert(!is_virtual, "");
a61af66fc99e Initial load
duke
parents:
diff changeset
3598 slow_call = new(C, tfdc) CallStaticJavaNode(tf,
a61af66fc99e Initial load
duke
parents:
diff changeset
3599 SharedRuntime::get_resolve_static_call_stub(),
a61af66fc99e Initial load
duke
parents:
diff changeset
3600 method, bci());
a61af66fc99e Initial load
duke
parents:
diff changeset
3601 } else if (is_virtual) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3602 null_check_receiver(method);
a61af66fc99e Initial load
duke
parents:
diff changeset
3603 int vtable_index = methodOopDesc::invalid_vtable_index;
a61af66fc99e Initial load
duke
parents:
diff changeset
3604 if (UseInlineCaches) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3605 // Suppress the vtable call
a61af66fc99e Initial load
duke
parents:
diff changeset
3606 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
3607 // hashCode and clone are not a miranda methods,
a61af66fc99e Initial load
duke
parents:
diff changeset
3608 // so the vtable index is fixed.
a61af66fc99e Initial load
duke
parents:
diff changeset
3609 // No need to use the linkResolver to get it.
a61af66fc99e Initial load
duke
parents:
diff changeset
3610 vtable_index = method->vtable_index();
a61af66fc99e Initial load
duke
parents:
diff changeset
3611 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3612 slow_call = new(C, tfdc) CallDynamicJavaNode(tf,
a61af66fc99e Initial load
duke
parents:
diff changeset
3613 SharedRuntime::get_resolve_virtual_call_stub(),
a61af66fc99e Initial load
duke
parents:
diff changeset
3614 method, vtable_index, bci());
a61af66fc99e Initial load
duke
parents:
diff changeset
3615 } else { // neither virtual nor static: opt_virtual
a61af66fc99e Initial load
duke
parents:
diff changeset
3616 null_check_receiver(method);
a61af66fc99e Initial load
duke
parents:
diff changeset
3617 slow_call = new(C, tfdc) CallStaticJavaNode(tf,
a61af66fc99e Initial load
duke
parents:
diff changeset
3618 SharedRuntime::get_resolve_opt_virtual_call_stub(),
a61af66fc99e Initial load
duke
parents:
diff changeset
3619 method, bci());
a61af66fc99e Initial load
duke
parents:
diff changeset
3620 slow_call->set_optimized_virtual(true);
a61af66fc99e Initial load
duke
parents:
diff changeset
3621 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3622 set_arguments_for_java_call(slow_call);
a61af66fc99e Initial load
duke
parents:
diff changeset
3623 set_edges_for_java_call(slow_call);
a61af66fc99e Initial load
duke
parents:
diff changeset
3624 return slow_call;
a61af66fc99e Initial load
duke
parents:
diff changeset
3625 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3626
a61af66fc99e Initial load
duke
parents:
diff changeset
3627
a61af66fc99e Initial load
duke
parents:
diff changeset
3628 //------------------------------inline_native_hashcode--------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
3629 // Build special case code for calls to hashCode on an object.
a61af66fc99e Initial load
duke
parents:
diff changeset
3630 bool LibraryCallKit::inline_native_hashcode(bool is_virtual, bool is_static) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3631 assert(is_static == callee()->is_static(), "correct intrinsic selection");
a61af66fc99e Initial load
duke
parents:
diff changeset
3632 assert(!(is_virtual && is_static), "either virtual, special, or static");
a61af66fc99e Initial load
duke
parents:
diff changeset
3633
a61af66fc99e Initial load
duke
parents:
diff changeset
3634 enum { _slow_path = 1, _fast_path, _null_path, PATH_LIMIT };
a61af66fc99e Initial load
duke
parents:
diff changeset
3635
a61af66fc99e Initial load
duke
parents:
diff changeset
3636 RegionNode* result_reg = new(C, PATH_LIMIT) RegionNode(PATH_LIMIT);
a61af66fc99e Initial load
duke
parents:
diff changeset
3637 PhiNode* result_val = new(C, PATH_LIMIT) PhiNode(result_reg,
a61af66fc99e Initial load
duke
parents:
diff changeset
3638 TypeInt::INT);
a61af66fc99e Initial load
duke
parents:
diff changeset
3639 PhiNode* result_io = new(C, PATH_LIMIT) PhiNode(result_reg, Type::ABIO);
a61af66fc99e Initial load
duke
parents:
diff changeset
3640 PhiNode* result_mem = new(C, PATH_LIMIT) PhiNode(result_reg, Type::MEMORY,
a61af66fc99e Initial load
duke
parents:
diff changeset
3641 TypePtr::BOTTOM);
a61af66fc99e Initial load
duke
parents:
diff changeset
3642 Node* obj = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
3643 if (!is_static) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3644 // Check for hashing null object
a61af66fc99e Initial load
duke
parents:
diff changeset
3645 obj = null_check_receiver(callee());
a61af66fc99e Initial load
duke
parents:
diff changeset
3646 if (stopped()) return true; // unconditionally null
a61af66fc99e Initial load
duke
parents:
diff changeset
3647 result_reg->init_req(_null_path, top());
a61af66fc99e Initial load
duke
parents:
diff changeset
3648 result_val->init_req(_null_path, top());
a61af66fc99e Initial load
duke
parents:
diff changeset
3649 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
3650 // Do a null check, and return zero if null.
a61af66fc99e Initial load
duke
parents:
diff changeset
3651 // System.identityHashCode(null) == 0
a61af66fc99e Initial load
duke
parents:
diff changeset
3652 obj = argument(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
3653 Node* null_ctl = top();
a61af66fc99e Initial load
duke
parents:
diff changeset
3654 obj = null_check_oop(obj, &null_ctl);
a61af66fc99e Initial load
duke
parents:
diff changeset
3655 result_reg->init_req(_null_path, null_ctl);
a61af66fc99e Initial load
duke
parents:
diff changeset
3656 result_val->init_req(_null_path, _gvn.intcon(0));
a61af66fc99e Initial load
duke
parents:
diff changeset
3657 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3658
a61af66fc99e Initial load
duke
parents:
diff changeset
3659 // Unconditionally null? Then return right away.
a61af66fc99e Initial load
duke
parents:
diff changeset
3660 if (stopped()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3661 set_control( result_reg->in(_null_path) );
a61af66fc99e Initial load
duke
parents:
diff changeset
3662 if (!stopped())
a61af66fc99e Initial load
duke
parents:
diff changeset
3663 push( result_val ->in(_null_path) );
a61af66fc99e Initial load
duke
parents:
diff changeset
3664 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3665 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3666
a61af66fc99e Initial load
duke
parents:
diff changeset
3667 // After null check, get the object's klass.
a61af66fc99e Initial load
duke
parents:
diff changeset
3668 Node* obj_klass = load_object_klass(obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
3669
a61af66fc99e Initial load
duke
parents:
diff changeset
3670 // This call may be virtual (invokevirtual) or bound (invokespecial).
a61af66fc99e Initial load
duke
parents:
diff changeset
3671 // For each case we generate slightly different code.
a61af66fc99e Initial load
duke
parents:
diff changeset
3672
a61af66fc99e Initial load
duke
parents:
diff changeset
3673 // We only go to the fast case code if we pass a number of guards. The
a61af66fc99e Initial load
duke
parents:
diff changeset
3674 // paths which do not pass are accumulated in the slow_region.
a61af66fc99e Initial load
duke
parents:
diff changeset
3675 RegionNode* slow_region = new (C, 1) RegionNode(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
3676 record_for_igvn(slow_region);
a61af66fc99e Initial load
duke
parents:
diff changeset
3677
a61af66fc99e Initial load
duke
parents:
diff changeset
3678 // If this is a virtual call, we generate a funny guard. We pull out
a61af66fc99e Initial load
duke
parents:
diff changeset
3679 // the vtable entry corresponding to hashCode() from the target object.
a61af66fc99e Initial load
duke
parents:
diff changeset
3680 // If the target method which we are calling happens to be the native
a61af66fc99e Initial load
duke
parents:
diff changeset
3681 // Object hashCode() method, we pass the guard. We do not need this
a61af66fc99e Initial load
duke
parents:
diff changeset
3682 // guard for non-virtual calls -- the caller is known to be the native
a61af66fc99e Initial load
duke
parents:
diff changeset
3683 // Object hashCode().
a61af66fc99e Initial load
duke
parents:
diff changeset
3684 if (is_virtual) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3685 generate_virtual_guard(obj_klass, slow_region);
a61af66fc99e Initial load
duke
parents:
diff changeset
3686 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3687
a61af66fc99e Initial load
duke
parents:
diff changeset
3688 // Get the header out of the object, use LoadMarkNode when available
a61af66fc99e Initial load
duke
parents:
diff changeset
3689 Node* header_addr = basic_plus_adr(obj, oopDesc::mark_offset_in_bytes());
1609
4311f23817fd 6959430: Make sure raw loads have control edge
kvn
parents: 1552
diff changeset
3690 Node* header = make_load(control(), header_addr, TypeX_X, TypeX_X->basic_type());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3691
a61af66fc99e Initial load
duke
parents:
diff changeset
3692 // Test the header to see if it is unlocked.
a61af66fc99e Initial load
duke
parents:
diff changeset
3693 Node *lock_mask = _gvn.MakeConX(markOopDesc::biased_lock_mask_in_place);
a61af66fc99e Initial load
duke
parents:
diff changeset
3694 Node *lmasked_header = _gvn.transform( new (C, 3) AndXNode(header, lock_mask) );
a61af66fc99e Initial load
duke
parents:
diff changeset
3695 Node *unlocked_val = _gvn.MakeConX(markOopDesc::unlocked_value);
a61af66fc99e Initial load
duke
parents:
diff changeset
3696 Node *chk_unlocked = _gvn.transform( new (C, 3) CmpXNode( lmasked_header, unlocked_val));
a61af66fc99e Initial load
duke
parents:
diff changeset
3697 Node *test_unlocked = _gvn.transform( new (C, 2) BoolNode( chk_unlocked, BoolTest::ne) );
a61af66fc99e Initial load
duke
parents:
diff changeset
3698
a61af66fc99e Initial load
duke
parents:
diff changeset
3699 generate_slow_guard(test_unlocked, slow_region);
a61af66fc99e Initial load
duke
parents:
diff changeset
3700
a61af66fc99e Initial load
duke
parents:
diff changeset
3701 // Get the hash value and check to see that it has been properly assigned.
a61af66fc99e Initial load
duke
parents:
diff changeset
3702 // We depend on hash_mask being at most 32 bits and avoid the use of
a61af66fc99e Initial load
duke
parents:
diff changeset
3703 // hash_mask_in_place because it could be larger than 32 bits in a 64-bit
a61af66fc99e Initial load
duke
parents:
diff changeset
3704 // vm: see markOop.hpp.
a61af66fc99e Initial load
duke
parents:
diff changeset
3705 Node *hash_mask = _gvn.intcon(markOopDesc::hash_mask);
a61af66fc99e Initial load
duke
parents:
diff changeset
3706 Node *hash_shift = _gvn.intcon(markOopDesc::hash_shift);
a61af66fc99e Initial load
duke
parents:
diff changeset
3707 Node *hshifted_header= _gvn.transform( new (C, 3) URShiftXNode(header, hash_shift) );
a61af66fc99e Initial load
duke
parents:
diff changeset
3708 // This hack lets the hash bits live anywhere in the mark object now, as long
605
98cb887364d3 6810672: Comment typos
twisti
parents: 420
diff changeset
3709 // as the shift drops the relevant bits into the low 32 bits. Note that
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3710 // Java spec says that HashCode is an int so there's no point in capturing
a61af66fc99e Initial load
duke
parents:
diff changeset
3711 // an 'X'-sized hashcode (32 in 32-bit build or 64 in 64-bit build).
a61af66fc99e Initial load
duke
parents:
diff changeset
3712 hshifted_header = ConvX2I(hshifted_header);
a61af66fc99e Initial load
duke
parents:
diff changeset
3713 Node *hash_val = _gvn.transform( new (C, 3) AndINode(hshifted_header, hash_mask) );
a61af66fc99e Initial load
duke
parents:
diff changeset
3714
a61af66fc99e Initial load
duke
parents:
diff changeset
3715 Node *no_hash_val = _gvn.intcon(markOopDesc::no_hash);
a61af66fc99e Initial load
duke
parents:
diff changeset
3716 Node *chk_assigned = _gvn.transform( new (C, 3) CmpINode( hash_val, no_hash_val));
a61af66fc99e Initial load
duke
parents:
diff changeset
3717 Node *test_assigned = _gvn.transform( new (C, 2) BoolNode( chk_assigned, BoolTest::eq) );
a61af66fc99e Initial load
duke
parents:
diff changeset
3718
a61af66fc99e Initial load
duke
parents:
diff changeset
3719 generate_slow_guard(test_assigned, slow_region);
a61af66fc99e Initial load
duke
parents:
diff changeset
3720
a61af66fc99e Initial load
duke
parents:
diff changeset
3721 Node* init_mem = reset_memory();
a61af66fc99e Initial load
duke
parents:
diff changeset
3722 // fill in the rest of the null path:
a61af66fc99e Initial load
duke
parents:
diff changeset
3723 result_io ->init_req(_null_path, i_o());
a61af66fc99e Initial load
duke
parents:
diff changeset
3724 result_mem->init_req(_null_path, init_mem);
a61af66fc99e Initial load
duke
parents:
diff changeset
3725
a61af66fc99e Initial load
duke
parents:
diff changeset
3726 result_val->init_req(_fast_path, hash_val);
a61af66fc99e Initial load
duke
parents:
diff changeset
3727 result_reg->init_req(_fast_path, control());
a61af66fc99e Initial load
duke
parents:
diff changeset
3728 result_io ->init_req(_fast_path, i_o());
a61af66fc99e Initial load
duke
parents:
diff changeset
3729 result_mem->init_req(_fast_path, init_mem);
a61af66fc99e Initial load
duke
parents:
diff changeset
3730
a61af66fc99e Initial load
duke
parents:
diff changeset
3731 // Generate code for the slow case. We make a call to hashCode().
a61af66fc99e Initial load
duke
parents:
diff changeset
3732 set_control(_gvn.transform(slow_region));
a61af66fc99e Initial load
duke
parents:
diff changeset
3733 if (!stopped()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3734 // No need for PreserveJVMState, because we're using up the present state.
a61af66fc99e Initial load
duke
parents:
diff changeset
3735 set_all_memory(init_mem);
a61af66fc99e Initial load
duke
parents:
diff changeset
3736 vmIntrinsics::ID hashCode_id = vmIntrinsics::_hashCode;
a61af66fc99e Initial load
duke
parents:
diff changeset
3737 if (is_static) hashCode_id = vmIntrinsics::_identityHashCode;
a61af66fc99e Initial load
duke
parents:
diff changeset
3738 CallJavaNode* slow_call = generate_method_call(hashCode_id, is_virtual, is_static);
a61af66fc99e Initial load
duke
parents:
diff changeset
3739 Node* slow_result = set_results_for_java_call(slow_call);
a61af66fc99e Initial load
duke
parents:
diff changeset
3740 // this->control() comes from set_results_for_java_call
a61af66fc99e Initial load
duke
parents:
diff changeset
3741 result_reg->init_req(_slow_path, control());
a61af66fc99e Initial load
duke
parents:
diff changeset
3742 result_val->init_req(_slow_path, slow_result);
a61af66fc99e Initial load
duke
parents:
diff changeset
3743 result_io ->set_req(_slow_path, i_o());
a61af66fc99e Initial load
duke
parents:
diff changeset
3744 result_mem ->set_req(_slow_path, reset_memory());
a61af66fc99e Initial load
duke
parents:
diff changeset
3745 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3746
a61af66fc99e Initial load
duke
parents:
diff changeset
3747 // Return the combined state.
a61af66fc99e Initial load
duke
parents:
diff changeset
3748 set_i_o( _gvn.transform(result_io) );
a61af66fc99e Initial load
duke
parents:
diff changeset
3749 set_all_memory( _gvn.transform(result_mem) );
a61af66fc99e Initial load
duke
parents:
diff changeset
3750 push_result(result_reg, result_val);
a61af66fc99e Initial load
duke
parents:
diff changeset
3751
a61af66fc99e Initial load
duke
parents:
diff changeset
3752 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3753 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3754
a61af66fc99e Initial load
duke
parents:
diff changeset
3755 //---------------------------inline_native_getClass----------------------------
605
98cb887364d3 6810672: Comment typos
twisti
parents: 420
diff changeset
3756 // Build special case code for calls to getClass on an object.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3757 bool LibraryCallKit::inline_native_getClass() {
a61af66fc99e Initial load
duke
parents:
diff changeset
3758 Node* obj = null_check_receiver(callee());
a61af66fc99e Initial load
duke
parents:
diff changeset
3759 if (stopped()) return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3760 push( load_mirror_from_klass(load_object_klass(obj)) );
a61af66fc99e Initial load
duke
parents:
diff changeset
3761 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3762 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3763
a61af66fc99e Initial load
duke
parents:
diff changeset
3764 //-----------------inline_native_Reflection_getCallerClass---------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
3765 // In the presence of deep enough inlining, getCallerClass() becomes a no-op.
a61af66fc99e Initial load
duke
parents:
diff changeset
3766 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3767 // NOTE that this code must perform the same logic as
a61af66fc99e Initial load
duke
parents:
diff changeset
3768 // vframeStream::security_get_caller_frame in that it must skip
a61af66fc99e Initial load
duke
parents:
diff changeset
3769 // Method.invoke() and auxiliary frames.
a61af66fc99e Initial load
duke
parents:
diff changeset
3770
a61af66fc99e Initial load
duke
parents:
diff changeset
3771
a61af66fc99e Initial load
duke
parents:
diff changeset
3772
a61af66fc99e Initial load
duke
parents:
diff changeset
3773
a61af66fc99e Initial load
duke
parents:
diff changeset
3774 bool LibraryCallKit::inline_native_Reflection_getCallerClass() {
a61af66fc99e Initial load
duke
parents:
diff changeset
3775 ciMethod* method = callee();
a61af66fc99e Initial load
duke
parents:
diff changeset
3776
a61af66fc99e Initial load
duke
parents:
diff changeset
3777 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
3778 if ((PrintIntrinsics || PrintInlining || PrintOptoInlining) && Verbose) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3779 tty->print_cr("Attempting to inline sun.reflect.Reflection.getCallerClass");
a61af66fc99e Initial load
duke
parents:
diff changeset
3780 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3781 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
3782
a61af66fc99e Initial load
duke
parents:
diff changeset
3783 debug_only(int saved_sp = _sp);
a61af66fc99e Initial load
duke
parents:
diff changeset
3784
a61af66fc99e Initial load
duke
parents:
diff changeset
3785 // Argument words: (int depth)
a61af66fc99e Initial load
duke
parents:
diff changeset
3786 int nargs = 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
3787
a61af66fc99e Initial load
duke
parents:
diff changeset
3788 _sp += nargs;
a61af66fc99e Initial load
duke
parents:
diff changeset
3789 Node* caller_depth_node = pop();
a61af66fc99e Initial load
duke
parents:
diff changeset
3790
a61af66fc99e Initial load
duke
parents:
diff changeset
3791 assert(saved_sp == _sp, "must have correct argument count");
a61af66fc99e Initial load
duke
parents:
diff changeset
3792
a61af66fc99e Initial load
duke
parents:
diff changeset
3793 // The depth value must be a constant in order for the runtime call
a61af66fc99e Initial load
duke
parents:
diff changeset
3794 // to be eliminated.
a61af66fc99e Initial load
duke
parents:
diff changeset
3795 const TypeInt* caller_depth_type = _gvn.type(caller_depth_node)->isa_int();
a61af66fc99e Initial load
duke
parents:
diff changeset
3796 if (caller_depth_type == NULL || !caller_depth_type->is_con()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3797 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
3798 if ((PrintIntrinsics || PrintInlining || PrintOptoInlining) && Verbose) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3799 tty->print_cr(" Bailing out because caller depth was not a constant");
a61af66fc99e Initial load
duke
parents:
diff changeset
3800 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3801 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
3802 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
3803 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3804 // Note that the JVM state at this point does not include the
a61af66fc99e Initial load
duke
parents:
diff changeset
3805 // getCallerClass() frame which we are trying to inline. The
a61af66fc99e Initial load
duke
parents:
diff changeset
3806 // semantics of getCallerClass(), however, are that the "first"
a61af66fc99e Initial load
duke
parents:
diff changeset
3807 // frame is the getCallerClass() frame, so we subtract one from the
a61af66fc99e Initial load
duke
parents:
diff changeset
3808 // requested depth before continuing. We don't inline requests of
a61af66fc99e Initial load
duke
parents:
diff changeset
3809 // getCallerClass(0).
a61af66fc99e Initial load
duke
parents:
diff changeset
3810 int caller_depth = caller_depth_type->get_con() - 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
3811 if (caller_depth < 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3812 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
3813 if ((PrintIntrinsics || PrintInlining || PrintOptoInlining) && Verbose) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3814 tty->print_cr(" Bailing out because caller depth was %d", caller_depth);
a61af66fc99e Initial load
duke
parents:
diff changeset
3815 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3816 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
3817 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
3818 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3819
a61af66fc99e Initial load
duke
parents:
diff changeset
3820 if (!jvms()->has_method()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3821 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
3822 if ((PrintIntrinsics || PrintInlining || PrintOptoInlining) && Verbose) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3823 tty->print_cr(" Bailing out because intrinsic was inlined at top level");
a61af66fc99e Initial load
duke
parents:
diff changeset
3824 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3825 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
3826 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
3827 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3828 int _depth = jvms()->depth(); // cache call chain depth
a61af66fc99e Initial load
duke
parents:
diff changeset
3829
a61af66fc99e Initial load
duke
parents:
diff changeset
3830 // Walk back up the JVM state to find the caller at the required
a61af66fc99e Initial load
duke
parents:
diff changeset
3831 // depth. NOTE that this code must perform the same logic as
a61af66fc99e Initial load
duke
parents:
diff changeset
3832 // vframeStream::security_get_caller_frame in that it must skip
a61af66fc99e Initial load
duke
parents:
diff changeset
3833 // Method.invoke() and auxiliary frames. Note also that depth is
a61af66fc99e Initial load
duke
parents:
diff changeset
3834 // 1-based (1 is the bottom of the inlining).
a61af66fc99e Initial load
duke
parents:
diff changeset
3835 int inlining_depth = _depth;
a61af66fc99e Initial load
duke
parents:
diff changeset
3836 JVMState* caller_jvms = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
3837
a61af66fc99e Initial load
duke
parents:
diff changeset
3838 if (inlining_depth > 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3839 caller_jvms = jvms();
a61af66fc99e Initial load
duke
parents:
diff changeset
3840 assert(caller_jvms = jvms()->of_depth(inlining_depth), "inlining_depth == our depth");
a61af66fc99e Initial load
duke
parents:
diff changeset
3841 do {
a61af66fc99e Initial load
duke
parents:
diff changeset
3842 // The following if-tests should be performed in this order
a61af66fc99e Initial load
duke
parents:
diff changeset
3843 if (is_method_invoke_or_aux_frame(caller_jvms)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3844 // Skip a Method.invoke() or auxiliary frame
a61af66fc99e Initial load
duke
parents:
diff changeset
3845 } else if (caller_depth > 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3846 // Skip real frame
a61af66fc99e Initial load
duke
parents:
diff changeset
3847 --caller_depth;
a61af66fc99e Initial load
duke
parents:
diff changeset
3848 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
3849 // We're done: reached desired caller after skipping.
a61af66fc99e Initial load
duke
parents:
diff changeset
3850 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3851 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3852 caller_jvms = caller_jvms->caller();
a61af66fc99e Initial load
duke
parents:
diff changeset
3853 --inlining_depth;
a61af66fc99e Initial load
duke
parents:
diff changeset
3854 } while (inlining_depth > 0);
a61af66fc99e Initial load
duke
parents:
diff changeset
3855 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3856
a61af66fc99e Initial load
duke
parents:
diff changeset
3857 if (inlining_depth == 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3858 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
3859 if ((PrintIntrinsics || PrintInlining || PrintOptoInlining) && Verbose) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3860 tty->print_cr(" Bailing out because caller depth (%d) exceeded inlining depth (%d)", caller_depth_type->get_con(), _depth);
a61af66fc99e Initial load
duke
parents:
diff changeset
3861 tty->print_cr(" JVM state at this point:");
a61af66fc99e Initial load
duke
parents:
diff changeset
3862 for (int i = _depth; i >= 1; i--) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3863 tty->print_cr(" %d) %s", i, jvms()->of_depth(i)->method()->name()->as_utf8());
a61af66fc99e Initial load
duke
parents:
diff changeset
3864 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3865 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3866 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
3867 return false; // Reached end of inlining
a61af66fc99e Initial load
duke
parents:
diff changeset
3868 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3869
a61af66fc99e Initial load
duke
parents:
diff changeset
3870 // Acquire method holder as java.lang.Class
a61af66fc99e Initial load
duke
parents:
diff changeset
3871 ciInstanceKlass* caller_klass = caller_jvms->method()->holder();
a61af66fc99e Initial load
duke
parents:
diff changeset
3872 ciInstance* caller_mirror = caller_klass->java_mirror();
a61af66fc99e Initial load
duke
parents:
diff changeset
3873 // Push this as a constant
a61af66fc99e Initial load
duke
parents:
diff changeset
3874 push(makecon(TypeInstPtr::make(caller_mirror)));
a61af66fc99e Initial load
duke
parents:
diff changeset
3875 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
3876 if ((PrintIntrinsics || PrintInlining || PrintOptoInlining) && Verbose) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3877 tty->print_cr(" Succeeded: caller = %s.%s, caller depth = %d, depth = %d", caller_klass->name()->as_utf8(), caller_jvms->method()->name()->as_utf8(), caller_depth_type->get_con(), _depth);
a61af66fc99e Initial load
duke
parents:
diff changeset
3878 tty->print_cr(" JVM state at this point:");
a61af66fc99e Initial load
duke
parents:
diff changeset
3879 for (int i = _depth; i >= 1; i--) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3880 tty->print_cr(" %d) %s", i, jvms()->of_depth(i)->method()->name()->as_utf8());
a61af66fc99e Initial load
duke
parents:
diff changeset
3881 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3882 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3883 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
3884 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3885 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3886
a61af66fc99e Initial load
duke
parents:
diff changeset
3887 // Helper routine for above
a61af66fc99e Initial load
duke
parents:
diff changeset
3888 bool LibraryCallKit::is_method_invoke_or_aux_frame(JVMState* jvms) {
1152
cd37471eaecc 6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents: 1027
diff changeset
3889 ciMethod* method = jvms->method();
cd37471eaecc 6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents: 1027
diff changeset
3890
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3891 // Is this the Method.invoke method itself?
1152
cd37471eaecc 6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents: 1027
diff changeset
3892 if (method->intrinsic_id() == vmIntrinsics::_invoke)
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3893 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3894
a61af66fc99e Initial load
duke
parents:
diff changeset
3895 // Is this a helper, defined somewhere underneath MethodAccessorImpl.
1152
cd37471eaecc 6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents: 1027
diff changeset
3896 ciKlass* k = method->holder();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3897 if (k->is_instance_klass()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3898 ciInstanceKlass* ik = k->as_instance_klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
3899 for (; ik != NULL; ik = ik->super()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3900 if (ik->name() == ciSymbol::sun_reflect_MethodAccessorImpl() &&
a61af66fc99e Initial load
duke
parents:
diff changeset
3901 ik == env()->find_system_klass(ik->name())) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3902 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3903 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3904 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3905 }
1152
cd37471eaecc 6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents: 1027
diff changeset
3906 else if (method->is_method_handle_adapter()) {
cd37471eaecc 6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents: 1027
diff changeset
3907 // This is an internal adapter frame from the MethodHandleCompiler -- skip it
cd37471eaecc 6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents: 1027
diff changeset
3908 return true;
cd37471eaecc 6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents: 1027
diff changeset
3909 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3910
a61af66fc99e Initial load
duke
parents:
diff changeset
3911 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
3912 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3913
a61af66fc99e Initial load
duke
parents:
diff changeset
3914 static int value_field_offset = -1; // offset of the "value" field of AtomicLongCSImpl. This is needed by
a61af66fc99e Initial load
duke
parents:
diff changeset
3915 // inline_native_AtomicLong_attemptUpdate() but it has no way of
a61af66fc99e Initial load
duke
parents:
diff changeset
3916 // computing it since there is no lookup field by name function in the
a61af66fc99e Initial load
duke
parents:
diff changeset
3917 // CI interface. This is computed and set by inline_native_AtomicLong_get().
a61af66fc99e Initial load
duke
parents:
diff changeset
3918 // Using a static variable here is safe even if we have multiple compilation
a61af66fc99e Initial load
duke
parents:
diff changeset
3919 // threads because the offset is constant. At worst the same offset will be
a61af66fc99e Initial load
duke
parents:
diff changeset
3920 // computed and stored multiple
a61af66fc99e Initial load
duke
parents:
diff changeset
3921
a61af66fc99e Initial load
duke
parents:
diff changeset
3922 bool LibraryCallKit::inline_native_AtomicLong_get() {
a61af66fc99e Initial load
duke
parents:
diff changeset
3923 // Restore the stack and pop off the argument
a61af66fc99e Initial load
duke
parents:
diff changeset
3924 _sp+=1;
a61af66fc99e Initial load
duke
parents:
diff changeset
3925 Node *obj = pop();
a61af66fc99e Initial load
duke
parents:
diff changeset
3926
a61af66fc99e Initial load
duke
parents:
diff changeset
3927 // get the offset of the "value" field. Since the CI interfaces
a61af66fc99e Initial load
duke
parents:
diff changeset
3928 // does not provide a way to look up a field by name, we scan the bytecodes
a61af66fc99e Initial load
duke
parents:
diff changeset
3929 // to get the field index. We expect the first 2 instructions of the method
a61af66fc99e Initial load
duke
parents:
diff changeset
3930 // to be:
a61af66fc99e Initial load
duke
parents:
diff changeset
3931 // 0 aload_0
a61af66fc99e Initial load
duke
parents:
diff changeset
3932 // 1 getfield "value"
a61af66fc99e Initial load
duke
parents:
diff changeset
3933 ciMethod* method = callee();
a61af66fc99e Initial load
duke
parents:
diff changeset
3934 if (value_field_offset == -1)
a61af66fc99e Initial load
duke
parents:
diff changeset
3935 {
a61af66fc99e Initial load
duke
parents:
diff changeset
3936 ciField* value_field;
a61af66fc99e Initial load
duke
parents:
diff changeset
3937 ciBytecodeStream iter(method);
a61af66fc99e Initial load
duke
parents:
diff changeset
3938 Bytecodes::Code bc = iter.next();
a61af66fc99e Initial load
duke
parents:
diff changeset
3939
a61af66fc99e Initial load
duke
parents:
diff changeset
3940 if ((bc != Bytecodes::_aload_0) &&
a61af66fc99e Initial load
duke
parents:
diff changeset
3941 ((bc != Bytecodes::_aload) || (iter.get_index() != 0)))
a61af66fc99e Initial load
duke
parents:
diff changeset
3942 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
3943 bc = iter.next();
a61af66fc99e Initial load
duke
parents:
diff changeset
3944 if (bc != Bytecodes::_getfield)
a61af66fc99e Initial load
duke
parents:
diff changeset
3945 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
3946 bool ignore;
a61af66fc99e Initial load
duke
parents:
diff changeset
3947 value_field = iter.get_field(ignore);
a61af66fc99e Initial load
duke
parents:
diff changeset
3948 value_field_offset = value_field->offset_in_bytes();
a61af66fc99e Initial load
duke
parents:
diff changeset
3949 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3950
a61af66fc99e Initial load
duke
parents:
diff changeset
3951 // Null check without removing any arguments.
a61af66fc99e Initial load
duke
parents:
diff changeset
3952 _sp++;
a61af66fc99e Initial load
duke
parents:
diff changeset
3953 obj = do_null_check(obj, T_OBJECT);
a61af66fc99e Initial load
duke
parents:
diff changeset
3954 _sp--;
a61af66fc99e Initial load
duke
parents:
diff changeset
3955 // Check for locking null object
a61af66fc99e Initial load
duke
parents:
diff changeset
3956 if (stopped()) return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3957
a61af66fc99e Initial load
duke
parents:
diff changeset
3958 Node *adr = basic_plus_adr(obj, obj, value_field_offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
3959 const TypePtr *adr_type = _gvn.type(adr)->is_ptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
3960 int alias_idx = C->get_alias_index(adr_type);
a61af66fc99e Initial load
duke
parents:
diff changeset
3961
a61af66fc99e Initial load
duke
parents:
diff changeset
3962 Node *result = _gvn.transform(new (C, 3) LoadLLockedNode(control(), memory(alias_idx), adr));
a61af66fc99e Initial load
duke
parents:
diff changeset
3963
a61af66fc99e Initial load
duke
parents:
diff changeset
3964 push_pair(result);
a61af66fc99e Initial load
duke
parents:
diff changeset
3965
a61af66fc99e Initial load
duke
parents:
diff changeset
3966 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3967 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3968
a61af66fc99e Initial load
duke
parents:
diff changeset
3969 bool LibraryCallKit::inline_native_AtomicLong_attemptUpdate() {
a61af66fc99e Initial load
duke
parents:
diff changeset
3970 // Restore the stack and pop off the arguments
a61af66fc99e Initial load
duke
parents:
diff changeset
3971 _sp+=5;
a61af66fc99e Initial load
duke
parents:
diff changeset
3972 Node *newVal = pop_pair();
a61af66fc99e Initial load
duke
parents:
diff changeset
3973 Node *oldVal = pop_pair();
a61af66fc99e Initial load
duke
parents:
diff changeset
3974 Node *obj = pop();
a61af66fc99e Initial load
duke
parents:
diff changeset
3975
a61af66fc99e Initial load
duke
parents:
diff changeset
3976 // we need the offset of the "value" field which was computed when
a61af66fc99e Initial load
duke
parents:
diff changeset
3977 // inlining the get() method. Give up if we don't have it.
a61af66fc99e Initial load
duke
parents:
diff changeset
3978 if (value_field_offset == -1)
a61af66fc99e Initial load
duke
parents:
diff changeset
3979 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
3980
a61af66fc99e Initial load
duke
parents:
diff changeset
3981 // Null check without removing any arguments.
a61af66fc99e Initial load
duke
parents:
diff changeset
3982 _sp+=5;
a61af66fc99e Initial load
duke
parents:
diff changeset
3983 obj = do_null_check(obj, T_OBJECT);
a61af66fc99e Initial load
duke
parents:
diff changeset
3984 _sp-=5;
a61af66fc99e Initial load
duke
parents:
diff changeset
3985 // Check for locking null object
a61af66fc99e Initial load
duke
parents:
diff changeset
3986 if (stopped()) return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3987
a61af66fc99e Initial load
duke
parents:
diff changeset
3988 Node *adr = basic_plus_adr(obj, obj, value_field_offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
3989 const TypePtr *adr_type = _gvn.type(adr)->is_ptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
3990 int alias_idx = C->get_alias_index(adr_type);
a61af66fc99e Initial load
duke
parents:
diff changeset
3991
420
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
3992 Node *cas = _gvn.transform(new (C, 5) StoreLConditionalNode(control(), memory(alias_idx), adr, newVal, oldVal));
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
3993 Node *store_proj = _gvn.transform( new (C, 1) SCMemProjNode(cas));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3994 set_memory(store_proj, alias_idx);
420
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
3995 Node *bol = _gvn.transform( new (C, 2) BoolNode( cas, BoolTest::eq ) );
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
3996
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
3997 Node *result;
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
3998 // CMove node is not used to be able fold a possible check code
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
3999 // after attemptUpdate() call. This code could be transformed
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
4000 // into CMove node by loop optimizations.
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
4001 {
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
4002 RegionNode *r = new (C, 3) RegionNode(3);
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
4003 result = new (C, 3) PhiNode(r, TypeInt::BOOL);
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
4004
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
4005 Node *iff = create_and_xform_if(control(), bol, PROB_FAIR, COUNT_UNKNOWN);
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
4006 Node *iftrue = opt_iff(r, iff);
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
4007 r->init_req(1, iftrue);
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
4008 result->init_req(1, intcon(1));
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
4009 result->init_req(2, intcon(0));
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
4010
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
4011 set_control(_gvn.transform(r));
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
4012 record_for_igvn(r);
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
4013
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
4014 C->set_has_split_ifs(true); // Has chance for split-if optimization
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
4015 }
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
4016
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 235
diff changeset
4017 push(_gvn.transform(result));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4018 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
4019 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4020
a61af66fc99e Initial load
duke
parents:
diff changeset
4021 bool LibraryCallKit::inline_fp_conversions(vmIntrinsics::ID id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4022 // restore the arguments
a61af66fc99e Initial load
duke
parents:
diff changeset
4023 _sp += arg_size();
a61af66fc99e Initial load
duke
parents:
diff changeset
4024
a61af66fc99e Initial load
duke
parents:
diff changeset
4025 switch (id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4026 case vmIntrinsics::_floatToRawIntBits:
a61af66fc99e Initial load
duke
parents:
diff changeset
4027 push(_gvn.transform( new (C, 2) MoveF2INode(pop())));
a61af66fc99e Initial load
duke
parents:
diff changeset
4028 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
4029
a61af66fc99e Initial load
duke
parents:
diff changeset
4030 case vmIntrinsics::_intBitsToFloat:
a61af66fc99e Initial load
duke
parents:
diff changeset
4031 push(_gvn.transform( new (C, 2) MoveI2FNode(pop())));
a61af66fc99e Initial load
duke
parents:
diff changeset
4032 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
4033
a61af66fc99e Initial load
duke
parents:
diff changeset
4034 case vmIntrinsics::_doubleToRawLongBits:
a61af66fc99e Initial load
duke
parents:
diff changeset
4035 push_pair(_gvn.transform( new (C, 2) MoveD2LNode(pop_pair())));
a61af66fc99e Initial load
duke
parents:
diff changeset
4036 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
4037
a61af66fc99e Initial load
duke
parents:
diff changeset
4038 case vmIntrinsics::_longBitsToDouble:
a61af66fc99e Initial load
duke
parents:
diff changeset
4039 push_pair(_gvn.transform( new (C, 2) MoveL2DNode(pop_pair())));
a61af66fc99e Initial load
duke
parents:
diff changeset
4040 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
4041
a61af66fc99e Initial load
duke
parents:
diff changeset
4042 case vmIntrinsics::_doubleToLongBits: {
a61af66fc99e Initial load
duke
parents:
diff changeset
4043 Node* value = pop_pair();
a61af66fc99e Initial load
duke
parents:
diff changeset
4044
a61af66fc99e Initial load
duke
parents:
diff changeset
4045 // two paths (plus control) merge in a wood
a61af66fc99e Initial load
duke
parents:
diff changeset
4046 RegionNode *r = new (C, 3) RegionNode(3);
a61af66fc99e Initial load
duke
parents:
diff changeset
4047 Node *phi = new (C, 3) PhiNode(r, TypeLong::LONG);
a61af66fc99e Initial load
duke
parents:
diff changeset
4048
a61af66fc99e Initial load
duke
parents:
diff changeset
4049 Node *cmpisnan = _gvn.transform( new (C, 3) CmpDNode(value, value));
a61af66fc99e Initial load
duke
parents:
diff changeset
4050 // Build the boolean node
a61af66fc99e Initial load
duke
parents:
diff changeset
4051 Node *bolisnan = _gvn.transform( new (C, 2) BoolNode( cmpisnan, BoolTest::ne ) );
a61af66fc99e Initial load
duke
parents:
diff changeset
4052
a61af66fc99e Initial load
duke
parents:
diff changeset
4053 // Branch either way.
a61af66fc99e Initial load
duke
parents:
diff changeset
4054 // NaN case is less traveled, which makes all the difference.
a61af66fc99e Initial load
duke
parents:
diff changeset
4055 IfNode *ifisnan = create_and_xform_if(control(), bolisnan, PROB_STATIC_FREQUENT, COUNT_UNKNOWN);
a61af66fc99e Initial load
duke
parents:
diff changeset
4056 Node *opt_isnan = _gvn.transform(ifisnan);
a61af66fc99e Initial load
duke
parents:
diff changeset
4057 assert( opt_isnan->is_If(), "Expect an IfNode");
a61af66fc99e Initial load
duke
parents:
diff changeset
4058 IfNode *opt_ifisnan = (IfNode*)opt_isnan;
a61af66fc99e Initial load
duke
parents:
diff changeset
4059 Node *iftrue = _gvn.transform( new (C, 1) IfTrueNode(opt_ifisnan) );
a61af66fc99e Initial load
duke
parents:
diff changeset
4060
a61af66fc99e Initial load
duke
parents:
diff changeset
4061 set_control(iftrue);
a61af66fc99e Initial load
duke
parents:
diff changeset
4062
a61af66fc99e Initial load
duke
parents:
diff changeset
4063 static const jlong nan_bits = CONST64(0x7ff8000000000000);
a61af66fc99e Initial load
duke
parents:
diff changeset
4064 Node *slow_result = longcon(nan_bits); // return NaN
a61af66fc99e Initial load
duke
parents:
diff changeset
4065 phi->init_req(1, _gvn.transform( slow_result ));
a61af66fc99e Initial load
duke
parents:
diff changeset
4066 r->init_req(1, iftrue);
a61af66fc99e Initial load
duke
parents:
diff changeset
4067
a61af66fc99e Initial load
duke
parents:
diff changeset
4068 // Else fall through
a61af66fc99e Initial load
duke
parents:
diff changeset
4069 Node *iffalse = _gvn.transform( new (C, 1) IfFalseNode(opt_ifisnan) );
a61af66fc99e Initial load
duke
parents:
diff changeset
4070 set_control(iffalse);
a61af66fc99e Initial load
duke
parents:
diff changeset
4071
a61af66fc99e Initial load
duke
parents:
diff changeset
4072 phi->init_req(2, _gvn.transform( new (C, 2) MoveD2LNode(value)));
a61af66fc99e Initial load
duke
parents:
diff changeset
4073 r->init_req(2, iffalse);
a61af66fc99e Initial load
duke
parents:
diff changeset
4074
a61af66fc99e Initial load
duke
parents:
diff changeset
4075 // Post merge
a61af66fc99e Initial load
duke
parents:
diff changeset
4076 set_control(_gvn.transform(r));
a61af66fc99e Initial load
duke
parents:
diff changeset
4077 record_for_igvn(r);
a61af66fc99e Initial load
duke
parents:
diff changeset
4078
a61af66fc99e Initial load
duke
parents:
diff changeset
4079 Node* result = _gvn.transform(phi);
a61af66fc99e Initial load
duke
parents:
diff changeset
4080 assert(result->bottom_type()->isa_long(), "must be");
a61af66fc99e Initial load
duke
parents:
diff changeset
4081 push_pair(result);
a61af66fc99e Initial load
duke
parents:
diff changeset
4082
a61af66fc99e Initial load
duke
parents:
diff changeset
4083 C->set_has_split_ifs(true); // Has chance for split-if optimization
a61af66fc99e Initial load
duke
parents:
diff changeset
4084
a61af66fc99e Initial load
duke
parents:
diff changeset
4085 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
4086 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4087
a61af66fc99e Initial load
duke
parents:
diff changeset
4088 case vmIntrinsics::_floatToIntBits: {
a61af66fc99e Initial load
duke
parents:
diff changeset
4089 Node* value = pop();
a61af66fc99e Initial load
duke
parents:
diff changeset
4090
a61af66fc99e Initial load
duke
parents:
diff changeset
4091 // two paths (plus control) merge in a wood
a61af66fc99e Initial load
duke
parents:
diff changeset
4092 RegionNode *r = new (C, 3) RegionNode(3);
a61af66fc99e Initial load
duke
parents:
diff changeset
4093 Node *phi = new (C, 3) PhiNode(r, TypeInt::INT);
a61af66fc99e Initial load
duke
parents:
diff changeset
4094
a61af66fc99e Initial load
duke
parents:
diff changeset
4095 Node *cmpisnan = _gvn.transform( new (C, 3) CmpFNode(value, value));
a61af66fc99e Initial load
duke
parents:
diff changeset
4096 // Build the boolean node
a61af66fc99e Initial load
duke
parents:
diff changeset
4097 Node *bolisnan = _gvn.transform( new (C, 2) BoolNode( cmpisnan, BoolTest::ne ) );
a61af66fc99e Initial load
duke
parents:
diff changeset
4098
a61af66fc99e Initial load
duke
parents:
diff changeset
4099 // Branch either way.
a61af66fc99e Initial load
duke
parents:
diff changeset
4100 // NaN case is less traveled, which makes all the difference.
a61af66fc99e Initial load
duke
parents:
diff changeset
4101 IfNode *ifisnan = create_and_xform_if(control(), bolisnan, PROB_STATIC_FREQUENT, COUNT_UNKNOWN);
a61af66fc99e Initial load
duke
parents:
diff changeset
4102 Node *opt_isnan = _gvn.transform(ifisnan);
a61af66fc99e Initial load
duke
parents:
diff changeset
4103 assert( opt_isnan->is_If(), "Expect an IfNode");
a61af66fc99e Initial load
duke
parents:
diff changeset
4104 IfNode *opt_ifisnan = (IfNode*)opt_isnan;
a61af66fc99e Initial load
duke
parents:
diff changeset
4105 Node *iftrue = _gvn.transform( new (C, 1) IfTrueNode(opt_ifisnan) );
a61af66fc99e Initial load
duke
parents:
diff changeset
4106
a61af66fc99e Initial load
duke
parents:
diff changeset
4107 set_control(iftrue);
a61af66fc99e Initial load
duke
parents:
diff changeset
4108
a61af66fc99e Initial load
duke
parents:
diff changeset
4109 static const jint nan_bits = 0x7fc00000;
a61af66fc99e Initial load
duke
parents:
diff changeset
4110 Node *slow_result = makecon(TypeInt::make(nan_bits)); // return NaN
a61af66fc99e Initial load
duke
parents:
diff changeset
4111 phi->init_req(1, _gvn.transform( slow_result ));
a61af66fc99e Initial load
duke
parents:
diff changeset
4112 r->init_req(1, iftrue);
a61af66fc99e Initial load
duke
parents:
diff changeset
4113
a61af66fc99e Initial load
duke
parents:
diff changeset
4114 // Else fall through
a61af66fc99e Initial load
duke
parents:
diff changeset
4115 Node *iffalse = _gvn.transform( new (C, 1) IfFalseNode(opt_ifisnan) );
a61af66fc99e Initial load
duke
parents:
diff changeset
4116 set_control(iffalse);
a61af66fc99e Initial load
duke
parents:
diff changeset
4117
a61af66fc99e Initial load
duke
parents:
diff changeset
4118 phi->init_req(2, _gvn.transform( new (C, 2) MoveF2INode(value)));
a61af66fc99e Initial load
duke
parents:
diff changeset
4119 r->init_req(2, iffalse);
a61af66fc99e Initial load
duke
parents:
diff changeset
4120
a61af66fc99e Initial load
duke
parents:
diff changeset
4121 // Post merge
a61af66fc99e Initial load
duke
parents:
diff changeset
4122 set_control(_gvn.transform(r));
a61af66fc99e Initial load
duke
parents:
diff changeset
4123 record_for_igvn(r);
a61af66fc99e Initial load
duke
parents:
diff changeset
4124
a61af66fc99e Initial load
duke
parents:
diff changeset
4125 Node* result = _gvn.transform(phi);
a61af66fc99e Initial load
duke
parents:
diff changeset
4126 assert(result->bottom_type()->isa_int(), "must be");
a61af66fc99e Initial load
duke
parents:
diff changeset
4127 push(result);
a61af66fc99e Initial load
duke
parents:
diff changeset
4128
a61af66fc99e Initial load
duke
parents:
diff changeset
4129 C->set_has_split_ifs(true); // Has chance for split-if optimization
a61af66fc99e Initial load
duke
parents:
diff changeset
4130
a61af66fc99e Initial load
duke
parents:
diff changeset
4131 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
4132 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4133
a61af66fc99e Initial load
duke
parents:
diff changeset
4134 default:
a61af66fc99e Initial load
duke
parents:
diff changeset
4135 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
4136 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4137
a61af66fc99e Initial load
duke
parents:
diff changeset
4138 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
4139 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4140
a61af66fc99e Initial load
duke
parents:
diff changeset
4141 #ifdef _LP64
a61af66fc99e Initial load
duke
parents:
diff changeset
4142 #define XTOP ,top() /*additional argument*/
a61af66fc99e Initial load
duke
parents:
diff changeset
4143 #else //_LP64
a61af66fc99e Initial load
duke
parents:
diff changeset
4144 #define XTOP /*no additional argument*/
a61af66fc99e Initial load
duke
parents:
diff changeset
4145 #endif //_LP64
a61af66fc99e Initial load
duke
parents:
diff changeset
4146
a61af66fc99e Initial load
duke
parents:
diff changeset
4147 //----------------------inline_unsafe_copyMemory-------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
4148 bool LibraryCallKit::inline_unsafe_copyMemory() {
a61af66fc99e Initial load
duke
parents:
diff changeset
4149 if (callee()->is_static()) return false; // caller must have the capability!
a61af66fc99e Initial load
duke
parents:
diff changeset
4150 int nargs = 1 + 5 + 3; // 5 args: (src: ptr,off, dst: ptr,off, size)
a61af66fc99e Initial load
duke
parents:
diff changeset
4151 assert(signature()->size() == nargs-1, "copy has 5 arguments");
a61af66fc99e Initial load
duke
parents:
diff changeset
4152 null_check_receiver(callee()); // check then ignore argument(0)
a61af66fc99e Initial load
duke
parents:
diff changeset
4153 if (stopped()) return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
4154
a61af66fc99e Initial load
duke
parents:
diff changeset
4155 C->set_has_unsafe_access(true); // Mark eventual nmethod as "unsafe".
a61af66fc99e Initial load
duke
parents:
diff changeset
4156
a61af66fc99e Initial load
duke
parents:
diff changeset
4157 Node* src_ptr = argument(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
4158 Node* src_off = ConvL2X(argument(2));
a61af66fc99e Initial load
duke
parents:
diff changeset
4159 assert(argument(3)->is_top(), "2nd half of long");
a61af66fc99e Initial load
duke
parents:
diff changeset
4160 Node* dst_ptr = argument(4);
a61af66fc99e Initial load
duke
parents:
diff changeset
4161 Node* dst_off = ConvL2X(argument(5));
a61af66fc99e Initial load
duke
parents:
diff changeset
4162 assert(argument(6)->is_top(), "2nd half of long");
a61af66fc99e Initial load
duke
parents:
diff changeset
4163 Node* size = ConvL2X(argument(7));
a61af66fc99e Initial load
duke
parents:
diff changeset
4164 assert(argument(8)->is_top(), "2nd half of long");
a61af66fc99e Initial load
duke
parents:
diff changeset
4165
a61af66fc99e Initial load
duke
parents:
diff changeset
4166 assert(Unsafe_field_offset_to_byte_offset(11) == 11,
a61af66fc99e Initial load
duke
parents:
diff changeset
4167 "fieldOffset must be byte-scaled");
a61af66fc99e Initial load
duke
parents:
diff changeset
4168
a61af66fc99e Initial load
duke
parents:
diff changeset
4169 Node* src = make_unsafe_address(src_ptr, src_off);
a61af66fc99e Initial load
duke
parents:
diff changeset
4170 Node* dst = make_unsafe_address(dst_ptr, dst_off);
a61af66fc99e Initial load
duke
parents:
diff changeset
4171
a61af66fc99e Initial load
duke
parents:
diff changeset
4172 // Conservatively insert a memory barrier on all memory slices.
a61af66fc99e Initial load
duke
parents:
diff changeset
4173 // Do not let writes of the copy source or destination float below the copy.
a61af66fc99e Initial load
duke
parents:
diff changeset
4174 insert_mem_bar(Op_MemBarCPUOrder);
a61af66fc99e Initial load
duke
parents:
diff changeset
4175
a61af66fc99e Initial load
duke
parents:
diff changeset
4176 // Call it. Note that the length argument is not scaled.
a61af66fc99e Initial load
duke
parents:
diff changeset
4177 make_runtime_call(RC_LEAF|RC_NO_FP,
a61af66fc99e Initial load
duke
parents:
diff changeset
4178 OptoRuntime::fast_arraycopy_Type(),
a61af66fc99e Initial load
duke
parents:
diff changeset
4179 StubRoutines::unsafe_arraycopy(),
a61af66fc99e Initial load
duke
parents:
diff changeset
4180 "unsafe_arraycopy",
a61af66fc99e Initial load
duke
parents:
diff changeset
4181 TypeRawPtr::BOTTOM,
a61af66fc99e Initial load
duke
parents:
diff changeset
4182 src, dst, size XTOP);
a61af66fc99e Initial load
duke
parents:
diff changeset
4183
a61af66fc99e Initial load
duke
parents:
diff changeset
4184 // Do not let reads of the copy destination float above the copy.
a61af66fc99e Initial load
duke
parents:
diff changeset
4185 insert_mem_bar(Op_MemBarCPUOrder);
a61af66fc99e Initial load
duke
parents:
diff changeset
4186
a61af66fc99e Initial load
duke
parents:
diff changeset
4187 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
4188 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4189
833
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4190 //------------------------clone_coping-----------------------------------
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4191 // Helper function for inline_native_clone.
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4192 void LibraryCallKit::copy_to_clone(Node* obj, Node* alloc_obj, Node* obj_size, bool is_array, bool card_mark) {
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4193 assert(obj_size != NULL, "");
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4194 Node* raw_obj = alloc_obj->in(1);
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4195 assert(alloc_obj->is_CheckCastPP() && raw_obj->is_Proj() && raw_obj->in(0)->is_Allocate(), "");
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4196
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4197 if (ReduceBulkZeroing) {
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4198 // We will be completely responsible for initializing this object -
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4199 // mark Initialize node as complete.
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4200 AllocateNode* alloc = AllocateNode::Ideal_allocation(alloc_obj, &_gvn);
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4201 // The object was just allocated - there should be no any stores!
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4202 guarantee(alloc != NULL && alloc->maybe_set_complete(&_gvn), "");
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4203 }
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4204
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4205 // Copy the fastest available way.
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4206 // TODO: generate fields copies for small objects instead.
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4207 Node* src = obj;
958
c7e94e8fff43 6880053: assert(alloc_obj->as_CheckCastPP()->type() != TypeInstPtr::NOTNULL)
kvn
parents: 950
diff changeset
4208 Node* dest = alloc_obj;
833
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4209 Node* size = _gvn.transform(obj_size);
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4210
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4211 // Exclude the header but include array length to copy by 8 bytes words.
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4212 // Can't use base_offset_in_bytes(bt) since basic type is unknown.
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4213 int base_off = is_array ? arrayOopDesc::length_offset_in_bytes() :
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4214 instanceOopDesc::base_offset_in_bytes();
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4215 // base_off:
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4216 // 8 - 32-bit VM
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4217 // 12 - 64-bit VM, compressed oops
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4218 // 16 - 64-bit VM, normal oops
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4219 if (base_off % BytesPerLong != 0) {
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4220 assert(UseCompressedOops, "");
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4221 if (is_array) {
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4222 // Exclude length to copy by 8 bytes words.
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4223 base_off += sizeof(int);
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4224 } else {
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4225 // Include klass to copy by 8 bytes words.
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4226 base_off = instanceOopDesc::klass_offset_in_bytes();
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4227 }
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4228 assert(base_off % BytesPerLong == 0, "expect 8 bytes alignment");
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4229 }
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4230 src = basic_plus_adr(src, base_off);
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4231 dest = basic_plus_adr(dest, base_off);
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4232
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4233 // Compute the length also, if needed:
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4234 Node* countx = size;
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4235 countx = _gvn.transform( new (C, 3) SubXNode(countx, MakeConX(base_off)) );
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4236 countx = _gvn.transform( new (C, 3) URShiftXNode(countx, intcon(LogBytesPerLong) ));
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4237
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4238 const TypePtr* raw_adr_type = TypeRawPtr::BOTTOM;
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4239 bool disjoint_bases = true;
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4240 generate_unchecked_arraycopy(raw_adr_type, T_LONG, disjoint_bases,
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
4241 src, NULL, dest, NULL, countx,
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
4242 /*dest_uninitialized*/true);
833
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4243
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4244 // If necessary, emit some card marks afterwards. (Non-arrays only.)
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4245 if (card_mark) {
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4246 assert(!is_array, "");
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4247 // Put in store barrier for any and all oops we are sticking
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4248 // into this object. (We could avoid this if we could prove
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4249 // that the object type contains no oop fields at all.)
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4250 Node* no_particular_value = NULL;
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4251 Node* no_particular_field = NULL;
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4252 int raw_adr_idx = Compile::AliasIdxRaw;
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4253 post_barrier(control(),
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4254 memory(raw_adr_type),
958
c7e94e8fff43 6880053: assert(alloc_obj->as_CheckCastPP()->type() != TypeInstPtr::NOTNULL)
kvn
parents: 950
diff changeset
4255 alloc_obj,
833
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4256 no_particular_field,
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4257 raw_adr_idx,
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4258 no_particular_value,
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4259 T_OBJECT,
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4260 false);
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4261 }
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4262
958
c7e94e8fff43 6880053: assert(alloc_obj->as_CheckCastPP()->type() != TypeInstPtr::NOTNULL)
kvn
parents: 950
diff changeset
4263 // Do not let reads from the cloned object float above the arraycopy.
c7e94e8fff43 6880053: assert(alloc_obj->as_CheckCastPP()->type() != TypeInstPtr::NOTNULL)
kvn
parents: 950
diff changeset
4264 insert_mem_bar(Op_MemBarCPUOrder);
833
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4265 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4266
a61af66fc99e Initial load
duke
parents:
diff changeset
4267 //------------------------inline_native_clone----------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
4268 // Here are the simple edge cases:
a61af66fc99e Initial load
duke
parents:
diff changeset
4269 // null receiver => normal trap
a61af66fc99e Initial load
duke
parents:
diff changeset
4270 // virtual and clone was overridden => slow path to out-of-line clone
a61af66fc99e Initial load
duke
parents:
diff changeset
4271 // not cloneable or finalizer => slow path to out-of-line Object.clone
a61af66fc99e Initial load
duke
parents:
diff changeset
4272 //
a61af66fc99e Initial load
duke
parents:
diff changeset
4273 // The general case has two steps, allocation and copying.
a61af66fc99e Initial load
duke
parents:
diff changeset
4274 // Allocation has two cases, and uses GraphKit::new_instance or new_array.
a61af66fc99e Initial load
duke
parents:
diff changeset
4275 //
a61af66fc99e Initial load
duke
parents:
diff changeset
4276 // Copying also has two cases, oop arrays and everything else.
a61af66fc99e Initial load
duke
parents:
diff changeset
4277 // Oop arrays use arrayof_oop_arraycopy (same as System.arraycopy).
a61af66fc99e Initial load
duke
parents:
diff changeset
4278 // Everything else uses the tight inline loop supplied by CopyArrayNode.
a61af66fc99e Initial load
duke
parents:
diff changeset
4279 //
a61af66fc99e Initial load
duke
parents:
diff changeset
4280 // These steps fold up nicely if and when the cloned object's klass
a61af66fc99e Initial load
duke
parents:
diff changeset
4281 // can be sharply typed as an object array, a type array, or an instance.
a61af66fc99e Initial load
duke
parents:
diff changeset
4282 //
a61af66fc99e Initial load
duke
parents:
diff changeset
4283 bool LibraryCallKit::inline_native_clone(bool is_virtual) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4284 int nargs = 1;
902
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4285 PhiNode* result_val;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4286
900
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4287 //set the original stack and the reexecute bit for the interpreter to reexecute
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4288 //the bytecode that invokes Object.clone if deoptimization happens
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4289 { PreserveReexecuteState preexecs(this);
902
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4290 jvms()->set_should_reexecute(true);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4291
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4292 //null_check_receiver will adjust _sp (push and pop)
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4293 Node* obj = null_check_receiver(callee());
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4294 if (stopped()) return true;
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4295
900
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4296 _sp += nargs;
902
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4297
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4298 Node* obj_klass = load_object_klass(obj);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4299 const TypeKlassPtr* tklass = _gvn.type(obj_klass)->isa_klassptr();
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4300 const TypeOopPtr* toop = ((tklass != NULL)
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4301 ? tklass->as_instance_type()
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4302 : TypeInstPtr::NOTNULL);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4303
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4304 // Conservatively insert a memory barrier on all memory slices.
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4305 // Do not let writes into the original float below the clone.
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4306 insert_mem_bar(Op_MemBarCPUOrder);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4307
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4308 // paths into result_reg:
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4309 enum {
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4310 _slow_path = 1, // out-of-line call to clone method (virtual or not)
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4311 _objArray_path, // plain array allocation, plus arrayof_oop_arraycopy
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4312 _array_path, // plain array allocation, plus arrayof_long_arraycopy
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4313 _instance_path, // plain instance allocation, plus arrayof_long_arraycopy
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4314 PATH_LIMIT
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4315 };
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4316 RegionNode* result_reg = new(C, PATH_LIMIT) RegionNode(PATH_LIMIT);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4317 result_val = new(C, PATH_LIMIT) PhiNode(result_reg,
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4318 TypeInstPtr::NOTNULL);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4319 PhiNode* result_i_o = new(C, PATH_LIMIT) PhiNode(result_reg, Type::ABIO);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4320 PhiNode* result_mem = new(C, PATH_LIMIT) PhiNode(result_reg, Type::MEMORY,
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4321 TypePtr::BOTTOM);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4322 record_for_igvn(result_reg);
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4323
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4324 const TypePtr* raw_adr_type = TypeRawPtr::BOTTOM;
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4325 int raw_adr_idx = Compile::AliasIdxRaw;
900
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4326
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4327 Node* array_ctl = generate_array_guard(obj_klass, (RegionNode*)NULL);
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4328 if (array_ctl != NULL) {
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4329 // It's an array.
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4330 PreserveJVMState pjvms(this);
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4331 set_control(array_ctl);
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4332 Node* obj_length = load_array_length(obj);
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4333 Node* obj_size = NULL;
3278
66b0e2371912 7026700: regression in 6u24-rev-b23: Crash in C2 compiler in PhaseIdealLoop::build_loop_late_post
kvn
parents: 2446
diff changeset
4334 Node* alloc_obj = new_array(obj_klass, obj_length, 0, &obj_size);
900
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4335
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4336 if (!use_ReduceInitialCardMarks()) {
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4337 // If it is an oop array, it requires very special treatment,
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4338 // because card marking is required on each card of the array.
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4339 Node* is_obja = generate_objArray_guard(obj_klass, (RegionNode*)NULL);
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4340 if (is_obja != NULL) {
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4341 PreserveJVMState pjvms2(this);
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4342 set_control(is_obja);
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4343 // Generate a direct call to the right arraycopy function(s).
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4344 bool disjoint_bases = true;
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4345 bool length_never_negative = true;
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4346 generate_arraycopy(TypeAryPtr::OOPS, T_OBJECT,
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4347 obj, intcon(0), alloc_obj, intcon(0),
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4348 obj_length,
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4349 disjoint_bases, length_never_negative);
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4350 result_reg->init_req(_objArray_path, control());
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4351 result_val->init_req(_objArray_path, alloc_obj);
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4352 result_i_o ->set_req(_objArray_path, i_o());
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4353 result_mem ->set_req(_objArray_path, reset_memory());
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4354 }
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4355 }
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4356 // Otherwise, there are no card marks to worry about.
1027
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 986
diff changeset
4357 // (We can dispense with card marks if we know the allocation
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 986
diff changeset
4358 // comes out of eden (TLAB)... In fact, ReduceInitialCardMarks
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 986
diff changeset
4359 // causes the non-eden paths to take compensating steps to
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 986
diff changeset
4360 // simulate a fresh allocation, so that no further
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 986
diff changeset
4361 // card marks are required in compiled code to initialize
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 986
diff changeset
4362 // the object.)
900
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4363
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4364 if (!stopped()) {
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4365 copy_to_clone(obj, alloc_obj, obj_size, true, false);
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4366
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4367 // Present the results of the copy.
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4368 result_reg->init_req(_array_path, control());
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4369 result_val->init_req(_array_path, alloc_obj);
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4370 result_i_o ->set_req(_array_path, i_o());
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4371 result_mem ->set_req(_array_path, reset_memory());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4372 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4373 }
900
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4374
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4375 // We only go to the instance fast case code if we pass a number of guards.
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4376 // The paths which do not pass are accumulated in the slow_region.
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4377 RegionNode* slow_region = new (C, 1) RegionNode(1);
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4378 record_for_igvn(slow_region);
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4379 if (!stopped()) {
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4380 // It's an instance (we did array above). Make the slow-path tests.
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4381 // If this is a virtual call, we generate a funny guard. We grab
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4382 // the vtable entry corresponding to clone() from the target object.
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4383 // If the target method which we are calling happens to be the
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4384 // Object clone() method, we pass the guard. We do not need this
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4385 // guard for non-virtual calls; the caller is known to be the native
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4386 // Object clone().
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4387 if (is_virtual) {
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4388 generate_virtual_guard(obj_klass, slow_region);
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4389 }
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4390
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4391 // The object must be cloneable and must not have a finalizer.
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4392 // Both of these conditions may be checked in a single test.
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4393 // We could optimize the cloneable test further, but we don't care.
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4394 generate_access_flags_guard(obj_klass,
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4395 // Test both conditions:
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4396 JVM_ACC_IS_CLONEABLE | JVM_ACC_HAS_FINALIZER,
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4397 // Must be cloneable but not finalizer:
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4398 JVM_ACC_IS_CLONEABLE,
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4399 slow_region);
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4400 }
833
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4401
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4402 if (!stopped()) {
900
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4403 // It's an instance, and it passed the slow-path tests.
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4404 PreserveJVMState pjvms(this);
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4405 Node* obj_size = NULL;
3278
66b0e2371912 7026700: regression in 6u24-rev-b23: Crash in C2 compiler in PhaseIdealLoop::build_loop_late_post
kvn
parents: 2446
diff changeset
4406 Node* alloc_obj = new_instance(obj_klass, NULL, &obj_size);
900
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4407
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4408 copy_to_clone(obj, alloc_obj, obj_size, false, !use_ReduceInitialCardMarks());
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4409
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4410 // Present the results of the slow call.
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4411 result_reg->init_req(_instance_path, control());
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4412 result_val->init_req(_instance_path, alloc_obj);
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4413 result_i_o ->set_req(_instance_path, i_o());
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4414 result_mem ->set_req(_instance_path, reset_memory());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4415 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4416
900
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4417 // Generate code for the slow case. We make a call to clone().
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4418 set_control(_gvn.transform(slow_region));
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4419 if (!stopped()) {
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4420 PreserveJVMState pjvms(this);
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4421 CallJavaNode* slow_call = generate_method_call(vmIntrinsics::_clone, is_virtual);
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4422 Node* slow_result = set_results_for_java_call(slow_call);
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4423 // this->control() comes from set_results_for_java_call
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4424 result_reg->init_req(_slow_path, control());
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4425 result_val->init_req(_slow_path, slow_result);
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4426 result_i_o ->set_req(_slow_path, i_o());
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4427 result_mem ->set_req(_slow_path, reset_memory());
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4428 }
902
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4429
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4430 // Return the combined state.
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4431 set_control( _gvn.transform(result_reg) );
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4432 set_i_o( _gvn.transform(result_i_o) );
fc2281ddce3c 6868269: CompileTheWorld assertion failure introduced by the reexecute bit implementation
cfang
parents: 900
diff changeset
4433 set_all_memory( _gvn.transform(result_mem) );
900
9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 896
diff changeset
4434 } //original reexecute and sp are set back here
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4435
833
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4436 push(_gvn.transform(result_val));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4437
a61af66fc99e Initial load
duke
parents:
diff changeset
4438 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
4439 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4440
a61af66fc99e Initial load
duke
parents:
diff changeset
4441 //------------------------------basictype2arraycopy----------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
4442 address LibraryCallKit::basictype2arraycopy(BasicType t,
a61af66fc99e Initial load
duke
parents:
diff changeset
4443 Node* src_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
4444 Node* dest_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
4445 bool disjoint_bases,
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
4446 const char* &name,
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
4447 bool dest_uninitialized) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4448 const TypeInt* src_offset_inttype = gvn().find_int_type(src_offset);;
a61af66fc99e Initial load
duke
parents:
diff changeset
4449 const TypeInt* dest_offset_inttype = gvn().find_int_type(dest_offset);;
a61af66fc99e Initial load
duke
parents:
diff changeset
4450
a61af66fc99e Initial load
duke
parents:
diff changeset
4451 bool aligned = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
4452 bool disjoint = disjoint_bases;
a61af66fc99e Initial load
duke
parents:
diff changeset
4453
a61af66fc99e Initial load
duke
parents:
diff changeset
4454 // if the offsets are the same, we can treat the memory regions as
a61af66fc99e Initial load
duke
parents:
diff changeset
4455 // disjoint, because either the memory regions are in different arrays,
a61af66fc99e Initial load
duke
parents:
diff changeset
4456 // or they are identical (which we can treat as disjoint.) We can also
a61af66fc99e Initial load
duke
parents:
diff changeset
4457 // treat a copy with a destination index less that the source index
a61af66fc99e Initial load
duke
parents:
diff changeset
4458 // as disjoint since a low->high copy will work correctly in this case.
a61af66fc99e Initial load
duke
parents:
diff changeset
4459 if (src_offset_inttype != NULL && src_offset_inttype->is_con() &&
a61af66fc99e Initial load
duke
parents:
diff changeset
4460 dest_offset_inttype != NULL && dest_offset_inttype->is_con()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4461 // both indices are constants
a61af66fc99e Initial load
duke
parents:
diff changeset
4462 int s_offs = src_offset_inttype->get_con();
a61af66fc99e Initial load
duke
parents:
diff changeset
4463 int d_offs = dest_offset_inttype->get_con();
29
d5fc211aea19 6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents: 0
diff changeset
4464 int element_size = type2aelembytes(t);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4465 aligned = ((arrayOopDesc::base_offset_in_bytes(t) + s_offs * element_size) % HeapWordSize == 0) &&
a61af66fc99e Initial load
duke
parents:
diff changeset
4466 ((arrayOopDesc::base_offset_in_bytes(t) + d_offs * element_size) % HeapWordSize == 0);
a61af66fc99e Initial load
duke
parents:
diff changeset
4467 if (s_offs >= d_offs) disjoint = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
4468 } else if (src_offset == dest_offset && src_offset != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4469 // This can occur if the offsets are identical non-constants.
a61af66fc99e Initial load
duke
parents:
diff changeset
4470 disjoint = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
4471 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4472
2446
13bc79b5c9c8 7033154: Improve C1 arraycopy performance
roland
parents: 2444
diff changeset
4473 return StubRoutines::select_arraycopy_function(t, aligned, disjoint, name, dest_uninitialized);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4474 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4475
a61af66fc99e Initial load
duke
parents:
diff changeset
4476
a61af66fc99e Initial load
duke
parents:
diff changeset
4477 //------------------------------inline_arraycopy-----------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
4478 bool LibraryCallKit::inline_arraycopy() {
a61af66fc99e Initial load
duke
parents:
diff changeset
4479 // Restore the stack and pop off the arguments.
a61af66fc99e Initial load
duke
parents:
diff changeset
4480 int nargs = 5; // 2 oops, 3 ints, no size_t or long
a61af66fc99e Initial load
duke
parents:
diff changeset
4481 assert(callee()->signature()->size() == nargs, "copy has 5 arguments");
a61af66fc99e Initial load
duke
parents:
diff changeset
4482
a61af66fc99e Initial load
duke
parents:
diff changeset
4483 Node *src = argument(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
4484 Node *src_offset = argument(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
4485 Node *dest = argument(2);
a61af66fc99e Initial load
duke
parents:
diff changeset
4486 Node *dest_offset = argument(3);
a61af66fc99e Initial load
duke
parents:
diff changeset
4487 Node *length = argument(4);
a61af66fc99e Initial load
duke
parents:
diff changeset
4488
a61af66fc99e Initial load
duke
parents:
diff changeset
4489 // Compile time checks. If any of these checks cannot be verified at compile time,
a61af66fc99e Initial load
duke
parents:
diff changeset
4490 // we do not make a fast path for this call. Instead, we let the call remain as it
a61af66fc99e Initial load
duke
parents:
diff changeset
4491 // is. The checks we choose to mandate at compile time are:
a61af66fc99e Initial load
duke
parents:
diff changeset
4492 //
a61af66fc99e Initial load
duke
parents:
diff changeset
4493 // (1) src and dest are arrays.
a61af66fc99e Initial load
duke
parents:
diff changeset
4494 const Type* src_type = src->Value(&_gvn);
a61af66fc99e Initial load
duke
parents:
diff changeset
4495 const Type* dest_type = dest->Value(&_gvn);
a61af66fc99e Initial load
duke
parents:
diff changeset
4496 const TypeAryPtr* top_src = src_type->isa_aryptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
4497 const TypeAryPtr* top_dest = dest_type->isa_aryptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
4498 if (top_src == NULL || top_src->klass() == NULL ||
a61af66fc99e Initial load
duke
parents:
diff changeset
4499 top_dest == NULL || top_dest->klass() == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4500 // Conservatively insert a memory barrier on all memory slices.
a61af66fc99e Initial load
duke
parents:
diff changeset
4501 // Do not let writes into the source float below the arraycopy.
a61af66fc99e Initial load
duke
parents:
diff changeset
4502 insert_mem_bar(Op_MemBarCPUOrder);
a61af66fc99e Initial load
duke
parents:
diff changeset
4503
a61af66fc99e Initial load
duke
parents:
diff changeset
4504 // Call StubRoutines::generic_arraycopy stub.
a61af66fc99e Initial load
duke
parents:
diff changeset
4505 generate_arraycopy(TypeRawPtr::BOTTOM, T_CONFLICT,
833
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4506 src, src_offset, dest, dest_offset, length);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4507
a61af66fc99e Initial load
duke
parents:
diff changeset
4508 // Do not let reads from the destination float above the arraycopy.
a61af66fc99e Initial load
duke
parents:
diff changeset
4509 // Since we cannot type the arrays, we don't know which slices
a61af66fc99e Initial load
duke
parents:
diff changeset
4510 // might be affected. We could restrict this barrier only to those
a61af66fc99e Initial load
duke
parents:
diff changeset
4511 // memory slices which pertain to array elements--but don't bother.
a61af66fc99e Initial load
duke
parents:
diff changeset
4512 if (!InsertMemBarAfterArraycopy)
a61af66fc99e Initial load
duke
parents:
diff changeset
4513 // (If InsertMemBarAfterArraycopy, there is already one in place.)
a61af66fc99e Initial load
duke
parents:
diff changeset
4514 insert_mem_bar(Op_MemBarCPUOrder);
a61af66fc99e Initial load
duke
parents:
diff changeset
4515 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
4516 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4517
a61af66fc99e Initial load
duke
parents:
diff changeset
4518 // (2) src and dest arrays must have elements of the same BasicType
a61af66fc99e Initial load
duke
parents:
diff changeset
4519 // Figure out the size and type of the elements we will be copying.
a61af66fc99e Initial load
duke
parents:
diff changeset
4520 BasicType src_elem = top_src->klass()->as_array_klass()->element_type()->basic_type();
a61af66fc99e Initial load
duke
parents:
diff changeset
4521 BasicType dest_elem = top_dest->klass()->as_array_klass()->element_type()->basic_type();
a61af66fc99e Initial load
duke
parents:
diff changeset
4522 if (src_elem == T_ARRAY) src_elem = T_OBJECT;
a61af66fc99e Initial load
duke
parents:
diff changeset
4523 if (dest_elem == T_ARRAY) dest_elem = T_OBJECT;
a61af66fc99e Initial load
duke
parents:
diff changeset
4524
a61af66fc99e Initial load
duke
parents:
diff changeset
4525 if (src_elem != dest_elem || dest_elem == T_VOID) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4526 // The component types are not the same or are not recognized. Punt.
a61af66fc99e Initial load
duke
parents:
diff changeset
4527 // (But, avoid the native method wrapper to JVM_ArrayCopy.)
a61af66fc99e Initial load
duke
parents:
diff changeset
4528 generate_slow_arraycopy(TypePtr::BOTTOM,
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
4529 src, src_offset, dest, dest_offset, length,
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
4530 /*dest_uninitialized*/false);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4531 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
4532 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4533
a61af66fc99e Initial load
duke
parents:
diff changeset
4534 //---------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
4535 // We will make a fast path for this call to arraycopy.
a61af66fc99e Initial load
duke
parents:
diff changeset
4536
a61af66fc99e Initial load
duke
parents:
diff changeset
4537 // We have the following tests left to perform:
a61af66fc99e Initial load
duke
parents:
diff changeset
4538 //
a61af66fc99e Initial load
duke
parents:
diff changeset
4539 // (3) src and dest must not be null.
a61af66fc99e Initial load
duke
parents:
diff changeset
4540 // (4) src_offset must not be negative.
a61af66fc99e Initial load
duke
parents:
diff changeset
4541 // (5) dest_offset must not be negative.
a61af66fc99e Initial load
duke
parents:
diff changeset
4542 // (6) length must not be negative.
a61af66fc99e Initial load
duke
parents:
diff changeset
4543 // (7) src_offset + length must not exceed length of src.
a61af66fc99e Initial load
duke
parents:
diff changeset
4544 // (8) dest_offset + length must not exceed length of dest.
a61af66fc99e Initial load
duke
parents:
diff changeset
4545 // (9) each element of an oop array must be assignable
a61af66fc99e Initial load
duke
parents:
diff changeset
4546
a61af66fc99e Initial load
duke
parents:
diff changeset
4547 RegionNode* slow_region = new (C, 1) RegionNode(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
4548 record_for_igvn(slow_region);
a61af66fc99e Initial load
duke
parents:
diff changeset
4549
a61af66fc99e Initial load
duke
parents:
diff changeset
4550 // (3) operands must not be null
a61af66fc99e Initial load
duke
parents:
diff changeset
4551 // We currently perform our null checks with the do_null_check routine.
a61af66fc99e Initial load
duke
parents:
diff changeset
4552 // This means that the null exceptions will be reported in the caller
a61af66fc99e Initial load
duke
parents:
diff changeset
4553 // rather than (correctly) reported inside of the native arraycopy call.
a61af66fc99e Initial load
duke
parents:
diff changeset
4554 // This should be corrected, given time. We do our null check with the
a61af66fc99e Initial load
duke
parents:
diff changeset
4555 // stack pointer restored.
a61af66fc99e Initial load
duke
parents:
diff changeset
4556 _sp += nargs;
a61af66fc99e Initial load
duke
parents:
diff changeset
4557 src = do_null_check(src, T_ARRAY);
a61af66fc99e Initial load
duke
parents:
diff changeset
4558 dest = do_null_check(dest, T_ARRAY);
a61af66fc99e Initial load
duke
parents:
diff changeset
4559 _sp -= nargs;
a61af66fc99e Initial load
duke
parents:
diff changeset
4560
a61af66fc99e Initial load
duke
parents:
diff changeset
4561 // (4) src_offset must not be negative.
a61af66fc99e Initial load
duke
parents:
diff changeset
4562 generate_negative_guard(src_offset, slow_region);
a61af66fc99e Initial load
duke
parents:
diff changeset
4563
a61af66fc99e Initial load
duke
parents:
diff changeset
4564 // (5) dest_offset must not be negative.
a61af66fc99e Initial load
duke
parents:
diff changeset
4565 generate_negative_guard(dest_offset, slow_region);
a61af66fc99e Initial load
duke
parents:
diff changeset
4566
a61af66fc99e Initial load
duke
parents:
diff changeset
4567 // (6) length must not be negative (moved to generate_arraycopy()).
a61af66fc99e Initial load
duke
parents:
diff changeset
4568 // generate_negative_guard(length, slow_region);
a61af66fc99e Initial load
duke
parents:
diff changeset
4569
a61af66fc99e Initial load
duke
parents:
diff changeset
4570 // (7) src_offset + length must not exceed length of src.
a61af66fc99e Initial load
duke
parents:
diff changeset
4571 generate_limit_guard(src_offset, length,
a61af66fc99e Initial load
duke
parents:
diff changeset
4572 load_array_length(src),
a61af66fc99e Initial load
duke
parents:
diff changeset
4573 slow_region);
a61af66fc99e Initial load
duke
parents:
diff changeset
4574
a61af66fc99e Initial load
duke
parents:
diff changeset
4575 // (8) dest_offset + length must not exceed length of dest.
a61af66fc99e Initial load
duke
parents:
diff changeset
4576 generate_limit_guard(dest_offset, length,
a61af66fc99e Initial load
duke
parents:
diff changeset
4577 load_array_length(dest),
a61af66fc99e Initial load
duke
parents:
diff changeset
4578 slow_region);
a61af66fc99e Initial load
duke
parents:
diff changeset
4579
a61af66fc99e Initial load
duke
parents:
diff changeset
4580 // (9) each element of an oop array must be assignable
a61af66fc99e Initial load
duke
parents:
diff changeset
4581 // The generate_arraycopy subroutine checks this.
a61af66fc99e Initial load
duke
parents:
diff changeset
4582
a61af66fc99e Initial load
duke
parents:
diff changeset
4583 // This is where the memory effects are placed:
a61af66fc99e Initial load
duke
parents:
diff changeset
4584 const TypePtr* adr_type = TypeAryPtr::get_array_body_type(dest_elem);
a61af66fc99e Initial load
duke
parents:
diff changeset
4585 generate_arraycopy(adr_type, dest_elem,
a61af66fc99e Initial load
duke
parents:
diff changeset
4586 src, src_offset, dest, dest_offset, length,
833
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4587 false, false, slow_region);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4588
a61af66fc99e Initial load
duke
parents:
diff changeset
4589 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
4590 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4591
a61af66fc99e Initial load
duke
parents:
diff changeset
4592 //-----------------------------generate_arraycopy----------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
4593 // Generate an optimized call to arraycopy.
a61af66fc99e Initial load
duke
parents:
diff changeset
4594 // Caller must guard against non-arrays.
a61af66fc99e Initial load
duke
parents:
diff changeset
4595 // Caller must determine a common array basic-type for both arrays.
a61af66fc99e Initial load
duke
parents:
diff changeset
4596 // Caller must validate offsets against array bounds.
a61af66fc99e Initial load
duke
parents:
diff changeset
4597 // The slow_region has already collected guard failure paths
a61af66fc99e Initial load
duke
parents:
diff changeset
4598 // (such as out of bounds length or non-conformable array types).
a61af66fc99e Initial load
duke
parents:
diff changeset
4599 // The generated code has this shape, in general:
a61af66fc99e Initial load
duke
parents:
diff changeset
4600 //
a61af66fc99e Initial load
duke
parents:
diff changeset
4601 // if (length == 0) return // via zero_path
a61af66fc99e Initial load
duke
parents:
diff changeset
4602 // slowval = -1
a61af66fc99e Initial load
duke
parents:
diff changeset
4603 // if (types unknown) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4604 // slowval = call generic copy loop
a61af66fc99e Initial load
duke
parents:
diff changeset
4605 // if (slowval == 0) return // via checked_path
a61af66fc99e Initial load
duke
parents:
diff changeset
4606 // } else if (indexes in bounds) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4607 // if ((is object array) && !(array type check)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4608 // slowval = call checked copy loop
a61af66fc99e Initial load
duke
parents:
diff changeset
4609 // if (slowval == 0) return // via checked_path
a61af66fc99e Initial load
duke
parents:
diff changeset
4610 // } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
4611 // call bulk copy loop
a61af66fc99e Initial load
duke
parents:
diff changeset
4612 // return // via fast_path
a61af66fc99e Initial load
duke
parents:
diff changeset
4613 // }
a61af66fc99e Initial load
duke
parents:
diff changeset
4614 // }
a61af66fc99e Initial load
duke
parents:
diff changeset
4615 // // adjust params for remaining work:
a61af66fc99e Initial load
duke
parents:
diff changeset
4616 // if (slowval != -1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4617 // n = -1^slowval; src_offset += n; dest_offset += n; length -= n
a61af66fc99e Initial load
duke
parents:
diff changeset
4618 // }
a61af66fc99e Initial load
duke
parents:
diff changeset
4619 // slow_region:
a61af66fc99e Initial load
duke
parents:
diff changeset
4620 // call slow arraycopy(src, src_offset, dest, dest_offset, length)
a61af66fc99e Initial load
duke
parents:
diff changeset
4621 // return // via slow_call_path
a61af66fc99e Initial load
duke
parents:
diff changeset
4622 //
a61af66fc99e Initial load
duke
parents:
diff changeset
4623 // This routine is used from several intrinsics: System.arraycopy,
a61af66fc99e Initial load
duke
parents:
diff changeset
4624 // Object.clone (the array subcase), and Arrays.copyOf[Range].
a61af66fc99e Initial load
duke
parents:
diff changeset
4625 //
a61af66fc99e Initial load
duke
parents:
diff changeset
4626 void
a61af66fc99e Initial load
duke
parents:
diff changeset
4627 LibraryCallKit::generate_arraycopy(const TypePtr* adr_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
4628 BasicType basic_elem_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
4629 Node* src, Node* src_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
4630 Node* dest, Node* dest_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
4631 Node* copy_length,
a61af66fc99e Initial load
duke
parents:
diff changeset
4632 bool disjoint_bases,
a61af66fc99e Initial load
duke
parents:
diff changeset
4633 bool length_never_negative,
a61af66fc99e Initial load
duke
parents:
diff changeset
4634 RegionNode* slow_region) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4635
a61af66fc99e Initial load
duke
parents:
diff changeset
4636 if (slow_region == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4637 slow_region = new(C,1) RegionNode(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
4638 record_for_igvn(slow_region);
a61af66fc99e Initial load
duke
parents:
diff changeset
4639 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4640
a61af66fc99e Initial load
duke
parents:
diff changeset
4641 Node* original_dest = dest;
a61af66fc99e Initial load
duke
parents:
diff changeset
4642 AllocateArrayNode* alloc = NULL; // used for zeroing, if needed
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
4643 bool dest_uninitialized = false;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4644
a61af66fc99e Initial load
duke
parents:
diff changeset
4645 // See if this is the initialization of a newly-allocated array.
a61af66fc99e Initial load
duke
parents:
diff changeset
4646 // If so, we will take responsibility here for initializing it to zero.
a61af66fc99e Initial load
duke
parents:
diff changeset
4647 // (Note: Because tightly_coupled_allocation performs checks on the
a61af66fc99e Initial load
duke
parents:
diff changeset
4648 // out-edges of the dest, we need to avoid making derived pointers
a61af66fc99e Initial load
duke
parents:
diff changeset
4649 // from it until we have checked its uses.)
a61af66fc99e Initial load
duke
parents:
diff changeset
4650 if (ReduceBulkZeroing
a61af66fc99e Initial load
duke
parents:
diff changeset
4651 && !ZeroTLAB // pointless if already zeroed
a61af66fc99e Initial load
duke
parents:
diff changeset
4652 && basic_elem_type != T_CONFLICT // avoid corner case
a61af66fc99e Initial load
duke
parents:
diff changeset
4653 && !_gvn.eqv_uncast(src, dest)
a61af66fc99e Initial load
duke
parents:
diff changeset
4654 && ((alloc = tightly_coupled_allocation(dest, slow_region))
a61af66fc99e Initial load
duke
parents:
diff changeset
4655 != NULL)
34
545c277a3ecf 6667581: Don't generate initialization (by 0) code for arrays with size 0
kvn
parents: 29
diff changeset
4656 && _gvn.find_int_con(alloc->in(AllocateNode::ALength), 1) > 0
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4657 && alloc->maybe_set_complete(&_gvn)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4658 // "You break it, you buy it."
a61af66fc99e Initial load
duke
parents:
diff changeset
4659 InitializeNode* init = alloc->initialization();
a61af66fc99e Initial load
duke
parents:
diff changeset
4660 assert(init->is_complete(), "we just did this");
3961
a92cdbac8b9e 7081933: Use zeroing elimination optimization for large array
kvn
parents: 3742
diff changeset
4661 init->set_complete_with_arraycopy();
833
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4662 assert(dest->is_CheckCastPP(), "sanity");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4663 assert(dest->in(0)->in(0) == init, "dest pinned");
a61af66fc99e Initial load
duke
parents:
diff changeset
4664 adr_type = TypeRawPtr::BOTTOM; // all initializations are into raw memory
a61af66fc99e Initial load
duke
parents:
diff changeset
4665 // From this point on, every exit path is responsible for
a61af66fc99e Initial load
duke
parents:
diff changeset
4666 // initializing any non-copied parts of the object to zero.
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
4667 // Also, if this flag is set we make sure that arraycopy interacts properly
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
4668 // with G1, eliding pre-barriers. See CR 6627983.
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
4669 dest_uninitialized = true;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4670 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
4671 // No zeroing elimination here.
a61af66fc99e Initial load
duke
parents:
diff changeset
4672 alloc = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
4673 //original_dest = dest;
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
4674 //dest_uninitialized = false;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4675 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4676
a61af66fc99e Initial load
duke
parents:
diff changeset
4677 // Results are placed here:
a61af66fc99e Initial load
duke
parents:
diff changeset
4678 enum { fast_path = 1, // normal void-returning assembly stub
a61af66fc99e Initial load
duke
parents:
diff changeset
4679 checked_path = 2, // special assembly stub with cleanup
a61af66fc99e Initial load
duke
parents:
diff changeset
4680 slow_call_path = 3, // something went wrong; call the VM
a61af66fc99e Initial load
duke
parents:
diff changeset
4681 zero_path = 4, // bypass when length of copy is zero
a61af66fc99e Initial load
duke
parents:
diff changeset
4682 bcopy_path = 5, // copy primitive array by 64-bit blocks
a61af66fc99e Initial load
duke
parents:
diff changeset
4683 PATH_LIMIT = 6
a61af66fc99e Initial load
duke
parents:
diff changeset
4684 };
a61af66fc99e Initial load
duke
parents:
diff changeset
4685 RegionNode* result_region = new(C, PATH_LIMIT) RegionNode(PATH_LIMIT);
a61af66fc99e Initial load
duke
parents:
diff changeset
4686 PhiNode* result_i_o = new(C, PATH_LIMIT) PhiNode(result_region, Type::ABIO);
a61af66fc99e Initial load
duke
parents:
diff changeset
4687 PhiNode* result_memory = new(C, PATH_LIMIT) PhiNode(result_region, Type::MEMORY, adr_type);
a61af66fc99e Initial load
duke
parents:
diff changeset
4688 record_for_igvn(result_region);
a61af66fc99e Initial load
duke
parents:
diff changeset
4689 _gvn.set_type_bottom(result_i_o);
a61af66fc99e Initial load
duke
parents:
diff changeset
4690 _gvn.set_type_bottom(result_memory);
a61af66fc99e Initial load
duke
parents:
diff changeset
4691 assert(adr_type != TypePtr::BOTTOM, "must be RawMem or a T[] slice");
a61af66fc99e Initial load
duke
parents:
diff changeset
4692
a61af66fc99e Initial load
duke
parents:
diff changeset
4693 // The slow_control path:
a61af66fc99e Initial load
duke
parents:
diff changeset
4694 Node* slow_control;
a61af66fc99e Initial load
duke
parents:
diff changeset
4695 Node* slow_i_o = i_o();
a61af66fc99e Initial load
duke
parents:
diff changeset
4696 Node* slow_mem = memory(adr_type);
a61af66fc99e Initial load
duke
parents:
diff changeset
4697 debug_only(slow_control = (Node*) badAddress);
a61af66fc99e Initial load
duke
parents:
diff changeset
4698
a61af66fc99e Initial load
duke
parents:
diff changeset
4699 // Checked control path:
a61af66fc99e Initial load
duke
parents:
diff changeset
4700 Node* checked_control = top();
a61af66fc99e Initial load
duke
parents:
diff changeset
4701 Node* checked_mem = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
4702 Node* checked_i_o = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
4703 Node* checked_value = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
4704
a61af66fc99e Initial load
duke
parents:
diff changeset
4705 if (basic_elem_type == T_CONFLICT) {
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
4706 assert(!dest_uninitialized, "");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4707 Node* cv = generate_generic_arraycopy(adr_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
4708 src, src_offset, dest, dest_offset,
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
4709 copy_length, dest_uninitialized);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4710 if (cv == NULL) cv = intcon(-1); // failure (no stub available)
a61af66fc99e Initial load
duke
parents:
diff changeset
4711 checked_control = control();
a61af66fc99e Initial load
duke
parents:
diff changeset
4712 checked_i_o = i_o();
a61af66fc99e Initial load
duke
parents:
diff changeset
4713 checked_mem = memory(adr_type);
a61af66fc99e Initial load
duke
parents:
diff changeset
4714 checked_value = cv;
a61af66fc99e Initial load
duke
parents:
diff changeset
4715 set_control(top()); // no fast path
a61af66fc99e Initial load
duke
parents:
diff changeset
4716 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4717
a61af66fc99e Initial load
duke
parents:
diff changeset
4718 Node* not_pos = generate_nonpositive_guard(copy_length, length_never_negative);
a61af66fc99e Initial load
duke
parents:
diff changeset
4719 if (not_pos != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4720 PreserveJVMState pjvms(this);
a61af66fc99e Initial load
duke
parents:
diff changeset
4721 set_control(not_pos);
a61af66fc99e Initial load
duke
parents:
diff changeset
4722
a61af66fc99e Initial load
duke
parents:
diff changeset
4723 // (6) length must not be negative.
a61af66fc99e Initial load
duke
parents:
diff changeset
4724 if (!length_never_negative) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4725 generate_negative_guard(copy_length, slow_region);
a61af66fc99e Initial load
duke
parents:
diff changeset
4726 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4727
836
4325cdaa78ad 6857661: 64-bit server VM: assert(is_Initialize(),"invalid node class")
kvn
parents: 833
diff changeset
4728 // copy_length is 0.
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
4729 if (!stopped() && dest_uninitialized) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4730 Node* dest_length = alloc->in(AllocateNode::ALength);
a61af66fc99e Initial load
duke
parents:
diff changeset
4731 if (_gvn.eqv_uncast(copy_length, dest_length)
a61af66fc99e Initial load
duke
parents:
diff changeset
4732 || _gvn.find_int_con(dest_length, 1) <= 0) {
836
4325cdaa78ad 6857661: 64-bit server VM: assert(is_Initialize(),"invalid node class")
kvn
parents: 833
diff changeset
4733 // There is no zeroing to do. No need for a secondary raw memory barrier.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4734 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
4735 // Clear the whole thing since there are no source elements to copy.
a61af66fc99e Initial load
duke
parents:
diff changeset
4736 generate_clear_array(adr_type, dest, basic_elem_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
4737 intcon(0), NULL,
a61af66fc99e Initial load
duke
parents:
diff changeset
4738 alloc->in(AllocateNode::AllocSize));
836
4325cdaa78ad 6857661: 64-bit server VM: assert(is_Initialize(),"invalid node class")
kvn
parents: 833
diff changeset
4739 // Use a secondary InitializeNode as raw memory barrier.
4325cdaa78ad 6857661: 64-bit server VM: assert(is_Initialize(),"invalid node class")
kvn
parents: 833
diff changeset
4740 // Currently it is needed only on this path since other
4325cdaa78ad 6857661: 64-bit server VM: assert(is_Initialize(),"invalid node class")
kvn
parents: 833
diff changeset
4741 // paths have stub or runtime calls as raw memory barriers.
4325cdaa78ad 6857661: 64-bit server VM: assert(is_Initialize(),"invalid node class")
kvn
parents: 833
diff changeset
4742 InitializeNode* init = insert_mem_bar_volatile(Op_Initialize,
4325cdaa78ad 6857661: 64-bit server VM: assert(is_Initialize(),"invalid node class")
kvn
parents: 833
diff changeset
4743 Compile::AliasIdxRaw,
4325cdaa78ad 6857661: 64-bit server VM: assert(is_Initialize(),"invalid node class")
kvn
parents: 833
diff changeset
4744 top())->as_Initialize();
4325cdaa78ad 6857661: 64-bit server VM: assert(is_Initialize(),"invalid node class")
kvn
parents: 833
diff changeset
4745 init->set_complete(&_gvn); // (there is no corresponding AllocateNode)
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4746 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4747 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4748
a61af66fc99e Initial load
duke
parents:
diff changeset
4749 // Present the results of the fast call.
a61af66fc99e Initial load
duke
parents:
diff changeset
4750 result_region->init_req(zero_path, control());
a61af66fc99e Initial load
duke
parents:
diff changeset
4751 result_i_o ->init_req(zero_path, i_o());
a61af66fc99e Initial load
duke
parents:
diff changeset
4752 result_memory->init_req(zero_path, memory(adr_type));
a61af66fc99e Initial load
duke
parents:
diff changeset
4753 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4754
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
4755 if (!stopped() && dest_uninitialized) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4756 // We have to initialize the *uncopied* part of the array to zero.
a61af66fc99e Initial load
duke
parents:
diff changeset
4757 // The copy destination is the slice dest[off..off+len]. The other slices
a61af66fc99e Initial load
duke
parents:
diff changeset
4758 // are dest_head = dest[0..off] and dest_tail = dest[off+len..dest.length].
a61af66fc99e Initial load
duke
parents:
diff changeset
4759 Node* dest_size = alloc->in(AllocateNode::AllocSize);
a61af66fc99e Initial load
duke
parents:
diff changeset
4760 Node* dest_length = alloc->in(AllocateNode::ALength);
a61af66fc99e Initial load
duke
parents:
diff changeset
4761 Node* dest_tail = _gvn.transform( new(C,3) AddINode(dest_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
4762 copy_length) );
a61af66fc99e Initial load
duke
parents:
diff changeset
4763
a61af66fc99e Initial load
duke
parents:
diff changeset
4764 // If there is a head section that needs zeroing, do it now.
a61af66fc99e Initial load
duke
parents:
diff changeset
4765 if (find_int_con(dest_offset, -1) != 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4766 generate_clear_array(adr_type, dest, basic_elem_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
4767 intcon(0), dest_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
4768 NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
4769 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4770
a61af66fc99e Initial load
duke
parents:
diff changeset
4771 // Next, perform a dynamic check on the tail length.
a61af66fc99e Initial load
duke
parents:
diff changeset
4772 // It is often zero, and we can win big if we prove this.
a61af66fc99e Initial load
duke
parents:
diff changeset
4773 // There are two wins: Avoid generating the ClearArray
a61af66fc99e Initial load
duke
parents:
diff changeset
4774 // with its attendant messy index arithmetic, and upgrade
a61af66fc99e Initial load
duke
parents:
diff changeset
4775 // the copy to a more hardware-friendly word size of 64 bits.
a61af66fc99e Initial load
duke
parents:
diff changeset
4776 Node* tail_ctl = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
4777 if (!stopped() && !_gvn.eqv_uncast(dest_tail, dest_length)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4778 Node* cmp_lt = _gvn.transform( new(C,3) CmpINode(dest_tail, dest_length) );
a61af66fc99e Initial load
duke
parents:
diff changeset
4779 Node* bol_lt = _gvn.transform( new(C,2) BoolNode(cmp_lt, BoolTest::lt) );
a61af66fc99e Initial load
duke
parents:
diff changeset
4780 tail_ctl = generate_slow_guard(bol_lt, NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
4781 assert(tail_ctl != NULL || !stopped(), "must be an outcome");
a61af66fc99e Initial load
duke
parents:
diff changeset
4782 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4783
a61af66fc99e Initial load
duke
parents:
diff changeset
4784 // At this point, let's assume there is no tail.
a61af66fc99e Initial load
duke
parents:
diff changeset
4785 if (!stopped() && alloc != NULL && basic_elem_type != T_OBJECT) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4786 // There is no tail. Try an upgrade to a 64-bit copy.
a61af66fc99e Initial load
duke
parents:
diff changeset
4787 bool didit = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
4788 { PreserveJVMState pjvms(this);
a61af66fc99e Initial load
duke
parents:
diff changeset
4789 didit = generate_block_arraycopy(adr_type, basic_elem_type, alloc,
a61af66fc99e Initial load
duke
parents:
diff changeset
4790 src, src_offset, dest, dest_offset,
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
4791 dest_size, dest_uninitialized);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4792 if (didit) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4793 // Present the results of the block-copying fast call.
a61af66fc99e Initial load
duke
parents:
diff changeset
4794 result_region->init_req(bcopy_path, control());
a61af66fc99e Initial load
duke
parents:
diff changeset
4795 result_i_o ->init_req(bcopy_path, i_o());
a61af66fc99e Initial load
duke
parents:
diff changeset
4796 result_memory->init_req(bcopy_path, memory(adr_type));
a61af66fc99e Initial load
duke
parents:
diff changeset
4797 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4798 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4799 if (didit)
a61af66fc99e Initial load
duke
parents:
diff changeset
4800 set_control(top()); // no regular fast path
a61af66fc99e Initial load
duke
parents:
diff changeset
4801 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4802
a61af66fc99e Initial load
duke
parents:
diff changeset
4803 // Clear the tail, if any.
a61af66fc99e Initial load
duke
parents:
diff changeset
4804 if (tail_ctl != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4805 Node* notail_ctl = stopped() ? NULL : control();
a61af66fc99e Initial load
duke
parents:
diff changeset
4806 set_control(tail_ctl);
a61af66fc99e Initial load
duke
parents:
diff changeset
4807 if (notail_ctl == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4808 generate_clear_array(adr_type, dest, basic_elem_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
4809 dest_tail, NULL,
a61af66fc99e Initial load
duke
parents:
diff changeset
4810 dest_size);
a61af66fc99e Initial load
duke
parents:
diff changeset
4811 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
4812 // Make a local merge.
a61af66fc99e Initial load
duke
parents:
diff changeset
4813 Node* done_ctl = new(C,3) RegionNode(3);
a61af66fc99e Initial load
duke
parents:
diff changeset
4814 Node* done_mem = new(C,3) PhiNode(done_ctl, Type::MEMORY, adr_type);
a61af66fc99e Initial load
duke
parents:
diff changeset
4815 done_ctl->init_req(1, notail_ctl);
a61af66fc99e Initial load
duke
parents:
diff changeset
4816 done_mem->init_req(1, memory(adr_type));
a61af66fc99e Initial load
duke
parents:
diff changeset
4817 generate_clear_array(adr_type, dest, basic_elem_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
4818 dest_tail, NULL,
a61af66fc99e Initial load
duke
parents:
diff changeset
4819 dest_size);
a61af66fc99e Initial load
duke
parents:
diff changeset
4820 done_ctl->init_req(2, control());
a61af66fc99e Initial load
duke
parents:
diff changeset
4821 done_mem->init_req(2, memory(adr_type));
a61af66fc99e Initial load
duke
parents:
diff changeset
4822 set_control( _gvn.transform(done_ctl) );
a61af66fc99e Initial load
duke
parents:
diff changeset
4823 set_memory( _gvn.transform(done_mem), adr_type );
a61af66fc99e Initial load
duke
parents:
diff changeset
4824 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4825 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4826 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4827
a61af66fc99e Initial load
duke
parents:
diff changeset
4828 BasicType copy_type = basic_elem_type;
a61af66fc99e Initial load
duke
parents:
diff changeset
4829 assert(basic_elem_type != T_ARRAY, "caller must fix this");
a61af66fc99e Initial load
duke
parents:
diff changeset
4830 if (!stopped() && copy_type == T_OBJECT) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4831 // If src and dest have compatible element types, we can copy bits.
a61af66fc99e Initial load
duke
parents:
diff changeset
4832 // Types S[] and D[] are compatible if D is a supertype of S.
a61af66fc99e Initial load
duke
parents:
diff changeset
4833 //
a61af66fc99e Initial load
duke
parents:
diff changeset
4834 // If they are not, we will use checked_oop_disjoint_arraycopy,
a61af66fc99e Initial load
duke
parents:
diff changeset
4835 // which performs a fast optimistic per-oop check, and backs off
a61af66fc99e Initial load
duke
parents:
diff changeset
4836 // further to JVM_ArrayCopy on the first per-oop check that fails.
a61af66fc99e Initial load
duke
parents:
diff changeset
4837 // (Actually, we don't move raw bits only; the GC requires card marks.)
a61af66fc99e Initial load
duke
parents:
diff changeset
4838
a61af66fc99e Initial load
duke
parents:
diff changeset
4839 // Get the klassOop for both src and dest
a61af66fc99e Initial load
duke
parents:
diff changeset
4840 Node* src_klass = load_object_klass(src);
a61af66fc99e Initial load
duke
parents:
diff changeset
4841 Node* dest_klass = load_object_klass(dest);
a61af66fc99e Initial load
duke
parents:
diff changeset
4842
a61af66fc99e Initial load
duke
parents:
diff changeset
4843 // Generate the subtype check.
a61af66fc99e Initial load
duke
parents:
diff changeset
4844 // This might fold up statically, or then again it might not.
a61af66fc99e Initial load
duke
parents:
diff changeset
4845 //
a61af66fc99e Initial load
duke
parents:
diff changeset
4846 // Non-static example: Copying List<String>.elements to a new String[].
a61af66fc99e Initial load
duke
parents:
diff changeset
4847 // The backing store for a List<String> is always an Object[],
a61af66fc99e Initial load
duke
parents:
diff changeset
4848 // but its elements are always type String, if the generic types
a61af66fc99e Initial load
duke
parents:
diff changeset
4849 // are correct at the source level.
a61af66fc99e Initial load
duke
parents:
diff changeset
4850 //
a61af66fc99e Initial load
duke
parents:
diff changeset
4851 // Test S[] against D[], not S against D, because (probably)
a61af66fc99e Initial load
duke
parents:
diff changeset
4852 // the secondary supertype cache is less busy for S[] than S.
a61af66fc99e Initial load
duke
parents:
diff changeset
4853 // This usually only matters when D is an interface.
a61af66fc99e Initial load
duke
parents:
diff changeset
4854 Node* not_subtype_ctrl = gen_subtype_check(src_klass, dest_klass);
a61af66fc99e Initial load
duke
parents:
diff changeset
4855 // Plug failing path into checked_oop_disjoint_arraycopy
a61af66fc99e Initial load
duke
parents:
diff changeset
4856 if (not_subtype_ctrl != top()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4857 PreserveJVMState pjvms(this);
a61af66fc99e Initial load
duke
parents:
diff changeset
4858 set_control(not_subtype_ctrl);
a61af66fc99e Initial load
duke
parents:
diff changeset
4859 // (At this point we can assume disjoint_bases, since types differ.)
a61af66fc99e Initial load
duke
parents:
diff changeset
4860 int ek_offset = objArrayKlass::element_klass_offset_in_bytes() + sizeof(oopDesc);
a61af66fc99e Initial load
duke
parents:
diff changeset
4861 Node* p1 = basic_plus_adr(dest_klass, ek_offset);
164
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
4862 Node* n1 = LoadKlassNode::make(_gvn, immutable_memory(), p1, TypeRawPtr::BOTTOM);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4863 Node* dest_elem_klass = _gvn.transform(n1);
a61af66fc99e Initial load
duke
parents:
diff changeset
4864 Node* cv = generate_checkcast_arraycopy(adr_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
4865 dest_elem_klass,
a61af66fc99e Initial load
duke
parents:
diff changeset
4866 src, src_offset, dest, dest_offset,
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
4867 ConvI2X(copy_length), dest_uninitialized);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4868 if (cv == NULL) cv = intcon(-1); // failure (no stub available)
a61af66fc99e Initial load
duke
parents:
diff changeset
4869 checked_control = control();
a61af66fc99e Initial load
duke
parents:
diff changeset
4870 checked_i_o = i_o();
a61af66fc99e Initial load
duke
parents:
diff changeset
4871 checked_mem = memory(adr_type);
a61af66fc99e Initial load
duke
parents:
diff changeset
4872 checked_value = cv;
a61af66fc99e Initial load
duke
parents:
diff changeset
4873 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4874 // At this point we know we do not need type checks on oop stores.
a61af66fc99e Initial load
duke
parents:
diff changeset
4875
a61af66fc99e Initial load
duke
parents:
diff changeset
4876 // Let's see if we need card marks:
a61af66fc99e Initial load
duke
parents:
diff changeset
4877 if (alloc != NULL && use_ReduceInitialCardMarks()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4878 // If we do not need card marks, copy using the jint or jlong stub.
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 34
diff changeset
4879 copy_type = LP64_ONLY(UseCompressedOops ? T_INT : T_LONG) NOT_LP64(T_INT);
29
d5fc211aea19 6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents: 0
diff changeset
4880 assert(type2aelembytes(basic_elem_type) == type2aelembytes(copy_type),
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4881 "sizes agree");
a61af66fc99e Initial load
duke
parents:
diff changeset
4882 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4883 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4884
a61af66fc99e Initial load
duke
parents:
diff changeset
4885 if (!stopped()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4886 // Generate the fast path, if possible.
a61af66fc99e Initial load
duke
parents:
diff changeset
4887 PreserveJVMState pjvms(this);
a61af66fc99e Initial load
duke
parents:
diff changeset
4888 generate_unchecked_arraycopy(adr_type, copy_type, disjoint_bases,
a61af66fc99e Initial load
duke
parents:
diff changeset
4889 src, src_offset, dest, dest_offset,
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
4890 ConvI2X(copy_length), dest_uninitialized);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4891
a61af66fc99e Initial load
duke
parents:
diff changeset
4892 // Present the results of the fast call.
a61af66fc99e Initial load
duke
parents:
diff changeset
4893 result_region->init_req(fast_path, control());
a61af66fc99e Initial load
duke
parents:
diff changeset
4894 result_i_o ->init_req(fast_path, i_o());
a61af66fc99e Initial load
duke
parents:
diff changeset
4895 result_memory->init_req(fast_path, memory(adr_type));
a61af66fc99e Initial load
duke
parents:
diff changeset
4896 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4897
a61af66fc99e Initial load
duke
parents:
diff changeset
4898 // Here are all the slow paths up to this point, in one bundle:
a61af66fc99e Initial load
duke
parents:
diff changeset
4899 slow_control = top();
a61af66fc99e Initial load
duke
parents:
diff changeset
4900 if (slow_region != NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
4901 slow_control = _gvn.transform(slow_region);
a61af66fc99e Initial load
duke
parents:
diff changeset
4902 debug_only(slow_region = (RegionNode*)badAddress);
a61af66fc99e Initial load
duke
parents:
diff changeset
4903
a61af66fc99e Initial load
duke
parents:
diff changeset
4904 set_control(checked_control);
a61af66fc99e Initial load
duke
parents:
diff changeset
4905 if (!stopped()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4906 // Clean up after the checked call.
a61af66fc99e Initial load
duke
parents:
diff changeset
4907 // The returned value is either 0 or -1^K,
a61af66fc99e Initial load
duke
parents:
diff changeset
4908 // where K = number of partially transferred array elements.
a61af66fc99e Initial load
duke
parents:
diff changeset
4909 Node* cmp = _gvn.transform( new(C, 3) CmpINode(checked_value, intcon(0)) );
a61af66fc99e Initial load
duke
parents:
diff changeset
4910 Node* bol = _gvn.transform( new(C, 2) BoolNode(cmp, BoolTest::eq) );
a61af66fc99e Initial load
duke
parents:
diff changeset
4911 IfNode* iff = create_and_map_if(control(), bol, PROB_MAX, COUNT_UNKNOWN);
a61af66fc99e Initial load
duke
parents:
diff changeset
4912
a61af66fc99e Initial load
duke
parents:
diff changeset
4913 // If it is 0, we are done, so transfer to the end.
a61af66fc99e Initial load
duke
parents:
diff changeset
4914 Node* checks_done = _gvn.transform( new(C, 1) IfTrueNode(iff) );
a61af66fc99e Initial load
duke
parents:
diff changeset
4915 result_region->init_req(checked_path, checks_done);
a61af66fc99e Initial load
duke
parents:
diff changeset
4916 result_i_o ->init_req(checked_path, checked_i_o);
a61af66fc99e Initial load
duke
parents:
diff changeset
4917 result_memory->init_req(checked_path, checked_mem);
a61af66fc99e Initial load
duke
parents:
diff changeset
4918
a61af66fc99e Initial load
duke
parents:
diff changeset
4919 // If it is not zero, merge into the slow call.
a61af66fc99e Initial load
duke
parents:
diff changeset
4920 set_control( _gvn.transform( new(C, 1) IfFalseNode(iff) ));
a61af66fc99e Initial load
duke
parents:
diff changeset
4921 RegionNode* slow_reg2 = new(C, 3) RegionNode(3);
a61af66fc99e Initial load
duke
parents:
diff changeset
4922 PhiNode* slow_i_o2 = new(C, 3) PhiNode(slow_reg2, Type::ABIO);
a61af66fc99e Initial load
duke
parents:
diff changeset
4923 PhiNode* slow_mem2 = new(C, 3) PhiNode(slow_reg2, Type::MEMORY, adr_type);
a61af66fc99e Initial load
duke
parents:
diff changeset
4924 record_for_igvn(slow_reg2);
a61af66fc99e Initial load
duke
parents:
diff changeset
4925 slow_reg2 ->init_req(1, slow_control);
a61af66fc99e Initial load
duke
parents:
diff changeset
4926 slow_i_o2 ->init_req(1, slow_i_o);
a61af66fc99e Initial load
duke
parents:
diff changeset
4927 slow_mem2 ->init_req(1, slow_mem);
a61af66fc99e Initial load
duke
parents:
diff changeset
4928 slow_reg2 ->init_req(2, control());
833
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4929 slow_i_o2 ->init_req(2, checked_i_o);
acba6af809c8 6840775: Multiple JVM crashes seen with 1.6.0_10 through 1.6.0_14
kvn
parents: 827
diff changeset
4930 slow_mem2 ->init_req(2, checked_mem);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4931
a61af66fc99e Initial load
duke
parents:
diff changeset
4932 slow_control = _gvn.transform(slow_reg2);
a61af66fc99e Initial load
duke
parents:
diff changeset
4933 slow_i_o = _gvn.transform(slow_i_o2);
a61af66fc99e Initial load
duke
parents:
diff changeset
4934 slow_mem = _gvn.transform(slow_mem2);
a61af66fc99e Initial load
duke
parents:
diff changeset
4935
a61af66fc99e Initial load
duke
parents:
diff changeset
4936 if (alloc != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4937 // We'll restart from the very beginning, after zeroing the whole thing.
a61af66fc99e Initial load
duke
parents:
diff changeset
4938 // This can cause double writes, but that's OK since dest is brand new.
a61af66fc99e Initial load
duke
parents:
diff changeset
4939 // So we ignore the low 31 bits of the value returned from the stub.
a61af66fc99e Initial load
duke
parents:
diff changeset
4940 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
4941 // We must continue the copy exactly where it failed, or else
a61af66fc99e Initial load
duke
parents:
diff changeset
4942 // another thread might see the wrong number of writes to dest.
a61af66fc99e Initial load
duke
parents:
diff changeset
4943 Node* checked_offset = _gvn.transform( new(C, 3) XorINode(checked_value, intcon(-1)) );
a61af66fc99e Initial load
duke
parents:
diff changeset
4944 Node* slow_offset = new(C, 3) PhiNode(slow_reg2, TypeInt::INT);
a61af66fc99e Initial load
duke
parents:
diff changeset
4945 slow_offset->init_req(1, intcon(0));
a61af66fc99e Initial load
duke
parents:
diff changeset
4946 slow_offset->init_req(2, checked_offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
4947 slow_offset = _gvn.transform(slow_offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
4948
a61af66fc99e Initial load
duke
parents:
diff changeset
4949 // Adjust the arguments by the conditionally incoming offset.
a61af66fc99e Initial load
duke
parents:
diff changeset
4950 Node* src_off_plus = _gvn.transform( new(C, 3) AddINode(src_offset, slow_offset) );
a61af66fc99e Initial load
duke
parents:
diff changeset
4951 Node* dest_off_plus = _gvn.transform( new(C, 3) AddINode(dest_offset, slow_offset) );
a61af66fc99e Initial load
duke
parents:
diff changeset
4952 Node* length_minus = _gvn.transform( new(C, 3) SubINode(copy_length, slow_offset) );
a61af66fc99e Initial load
duke
parents:
diff changeset
4953
a61af66fc99e Initial load
duke
parents:
diff changeset
4954 // Tweak the node variables to adjust the code produced below:
a61af66fc99e Initial load
duke
parents:
diff changeset
4955 src_offset = src_off_plus;
a61af66fc99e Initial load
duke
parents:
diff changeset
4956 dest_offset = dest_off_plus;
a61af66fc99e Initial load
duke
parents:
diff changeset
4957 copy_length = length_minus;
a61af66fc99e Initial load
duke
parents:
diff changeset
4958 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4959 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4960
a61af66fc99e Initial load
duke
parents:
diff changeset
4961 set_control(slow_control);
a61af66fc99e Initial load
duke
parents:
diff changeset
4962 if (!stopped()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4963 // Generate the slow path, if needed.
a61af66fc99e Initial load
duke
parents:
diff changeset
4964 PreserveJVMState pjvms(this); // replace_in_map may trash the map
a61af66fc99e Initial load
duke
parents:
diff changeset
4965
a61af66fc99e Initial load
duke
parents:
diff changeset
4966 set_memory(slow_mem, adr_type);
a61af66fc99e Initial load
duke
parents:
diff changeset
4967 set_i_o(slow_i_o);
a61af66fc99e Initial load
duke
parents:
diff changeset
4968
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
4969 if (dest_uninitialized) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4970 generate_clear_array(adr_type, dest, basic_elem_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
4971 intcon(0), NULL,
a61af66fc99e Initial load
duke
parents:
diff changeset
4972 alloc->in(AllocateNode::AllocSize));
a61af66fc99e Initial load
duke
parents:
diff changeset
4973 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4974
a61af66fc99e Initial load
duke
parents:
diff changeset
4975 generate_slow_arraycopy(adr_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
4976 src, src_offset, dest, dest_offset,
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
4977 copy_length, /*dest_uninitialized*/false);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4978
a61af66fc99e Initial load
duke
parents:
diff changeset
4979 result_region->init_req(slow_call_path, control());
a61af66fc99e Initial load
duke
parents:
diff changeset
4980 result_i_o ->init_req(slow_call_path, i_o());
a61af66fc99e Initial load
duke
parents:
diff changeset
4981 result_memory->init_req(slow_call_path, memory(adr_type));
a61af66fc99e Initial load
duke
parents:
diff changeset
4982 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4983
a61af66fc99e Initial load
duke
parents:
diff changeset
4984 // Remove unused edges.
a61af66fc99e Initial load
duke
parents:
diff changeset
4985 for (uint i = 1; i < result_region->req(); i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
4986 if (result_region->in(i) == NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
4987 result_region->init_req(i, top());
a61af66fc99e Initial load
duke
parents:
diff changeset
4988 }
a61af66fc99e Initial load
duke
parents:
diff changeset
4989
a61af66fc99e Initial load
duke
parents:
diff changeset
4990 // Finished; return the combined state.
a61af66fc99e Initial load
duke
parents:
diff changeset
4991 set_control( _gvn.transform(result_region) );
a61af66fc99e Initial load
duke
parents:
diff changeset
4992 set_i_o( _gvn.transform(result_i_o) );
a61af66fc99e Initial load
duke
parents:
diff changeset
4993 set_memory( _gvn.transform(result_memory), adr_type );
a61af66fc99e Initial load
duke
parents:
diff changeset
4994
a61af66fc99e Initial load
duke
parents:
diff changeset
4995 // The memory edges above are precise in order to model effects around
605
98cb887364d3 6810672: Comment typos
twisti
parents: 420
diff changeset
4996 // array copies accurately to allow value numbering of field loads around
0
a61af66fc99e Initial load
duke
parents:
diff changeset
4997 // arraycopy. Such field loads, both before and after, are common in Java
a61af66fc99e Initial load
duke
parents:
diff changeset
4998 // collections and similar classes involving header/array data structures.
a61af66fc99e Initial load
duke
parents:
diff changeset
4999 //
a61af66fc99e Initial load
duke
parents:
diff changeset
5000 // But with low number of register or when some registers are used or killed
a61af66fc99e Initial load
duke
parents:
diff changeset
5001 // by arraycopy calls it causes registers spilling on stack. See 6544710.
a61af66fc99e Initial load
duke
parents:
diff changeset
5002 // The next memory barrier is added to avoid it. If the arraycopy can be
a61af66fc99e Initial load
duke
parents:
diff changeset
5003 // optimized away (which it can, sometimes) then we can manually remove
a61af66fc99e Initial load
duke
parents:
diff changeset
5004 // the membar also.
958
c7e94e8fff43 6880053: assert(alloc_obj->as_CheckCastPP()->type() != TypeInstPtr::NOTNULL)
kvn
parents: 950
diff changeset
5005 //
c7e94e8fff43 6880053: assert(alloc_obj->as_CheckCastPP()->type() != TypeInstPtr::NOTNULL)
kvn
parents: 950
diff changeset
5006 // Do not let reads from the cloned object float above the arraycopy.
c7e94e8fff43 6880053: assert(alloc_obj->as_CheckCastPP()->type() != TypeInstPtr::NOTNULL)
kvn
parents: 950
diff changeset
5007 if (InsertMemBarAfterArraycopy || alloc != NULL)
0
a61af66fc99e Initial load
duke
parents:
diff changeset
5008 insert_mem_bar(Op_MemBarCPUOrder);
a61af66fc99e Initial load
duke
parents:
diff changeset
5009 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5010
a61af66fc99e Initial load
duke
parents:
diff changeset
5011
a61af66fc99e Initial load
duke
parents:
diff changeset
5012 // Helper function which determines if an arraycopy immediately follows
a61af66fc99e Initial load
duke
parents:
diff changeset
5013 // an allocation, with no intervening tests or other escapes for the object.
a61af66fc99e Initial load
duke
parents:
diff changeset
5014 AllocateArrayNode*
a61af66fc99e Initial load
duke
parents:
diff changeset
5015 LibraryCallKit::tightly_coupled_allocation(Node* ptr,
a61af66fc99e Initial load
duke
parents:
diff changeset
5016 RegionNode* slow_region) {
a61af66fc99e Initial load
duke
parents:
diff changeset
5017 if (stopped()) return NULL; // no fast path
a61af66fc99e Initial load
duke
parents:
diff changeset
5018 if (C->AliasLevel() == 0) return NULL; // no MergeMems around
a61af66fc99e Initial load
duke
parents:
diff changeset
5019
a61af66fc99e Initial load
duke
parents:
diff changeset
5020 AllocateArrayNode* alloc = AllocateArrayNode::Ideal_array_allocation(ptr, &_gvn);
a61af66fc99e Initial load
duke
parents:
diff changeset
5021 if (alloc == NULL) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
5022
a61af66fc99e Initial load
duke
parents:
diff changeset
5023 Node* rawmem = memory(Compile::AliasIdxRaw);
a61af66fc99e Initial load
duke
parents:
diff changeset
5024 // Is the allocation's memory state untouched?
a61af66fc99e Initial load
duke
parents:
diff changeset
5025 if (!(rawmem->is_Proj() && rawmem->in(0)->is_Initialize())) {
a61af66fc99e Initial load
duke
parents:
diff changeset
5026 // Bail out if there have been raw-memory effects since the allocation.
a61af66fc99e Initial load
duke
parents:
diff changeset
5027 // (Example: There might have been a call or safepoint.)
a61af66fc99e Initial load
duke
parents:
diff changeset
5028 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
5029 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5030 rawmem = rawmem->in(0)->as_Initialize()->memory(Compile::AliasIdxRaw);
a61af66fc99e Initial load
duke
parents:
diff changeset
5031 if (!(rawmem->is_Proj() && rawmem->in(0) == alloc)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
5032 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
5033 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5034
a61af66fc99e Initial load
duke
parents:
diff changeset
5035 // There must be no unexpected observers of this allocation.
a61af66fc99e Initial load
duke
parents:
diff changeset
5036 for (DUIterator_Fast imax, i = ptr->fast_outs(imax); i < imax; i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
5037 Node* obs = ptr->fast_out(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
5038 if (obs != this->map()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
5039 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
5040 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5041 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5042
a61af66fc99e Initial load
duke
parents:
diff changeset
5043 // This arraycopy must unconditionally follow the allocation of the ptr.
a61af66fc99e Initial load
duke
parents:
diff changeset
5044 Node* alloc_ctl = ptr->in(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
5045 assert(just_allocated_object(alloc_ctl) == ptr, "most recent allo");
a61af66fc99e Initial load
duke
parents:
diff changeset
5046
a61af66fc99e Initial load
duke
parents:
diff changeset
5047 Node* ctl = control();
a61af66fc99e Initial load
duke
parents:
diff changeset
5048 while (ctl != alloc_ctl) {
a61af66fc99e Initial load
duke
parents:
diff changeset
5049 // There may be guards which feed into the slow_region.
a61af66fc99e Initial load
duke
parents:
diff changeset
5050 // Any other control flow means that we might not get a chance
a61af66fc99e Initial load
duke
parents:
diff changeset
5051 // to finish initializing the allocated object.
a61af66fc99e Initial load
duke
parents:
diff changeset
5052 if ((ctl->is_IfFalse() || ctl->is_IfTrue()) && ctl->in(0)->is_If()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
5053 IfNode* iff = ctl->in(0)->as_If();
a61af66fc99e Initial load
duke
parents:
diff changeset
5054 Node* not_ctl = iff->proj_out(1 - ctl->as_Proj()->_con);
a61af66fc99e Initial load
duke
parents:
diff changeset
5055 assert(not_ctl != NULL && not_ctl != ctl, "found alternate");
a61af66fc99e Initial load
duke
parents:
diff changeset
5056 if (slow_region != NULL && slow_region->find_edge(not_ctl) >= 1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
5057 ctl = iff->in(0); // This test feeds the known slow_region.
a61af66fc99e Initial load
duke
parents:
diff changeset
5058 continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
5059 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5060 // One more try: Various low-level checks bottom out in
a61af66fc99e Initial load
duke
parents:
diff changeset
5061 // uncommon traps. If the debug-info of the trap omits
a61af66fc99e Initial load
duke
parents:
diff changeset
5062 // any reference to the allocation, as we've already
a61af66fc99e Initial load
duke
parents:
diff changeset
5063 // observed, then there can be no objection to the trap.
a61af66fc99e Initial load
duke
parents:
diff changeset
5064 bool found_trap = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
5065 for (DUIterator_Fast jmax, j = not_ctl->fast_outs(jmax); j < jmax; j++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
5066 Node* obs = not_ctl->fast_out(j);
a61af66fc99e Initial load
duke
parents:
diff changeset
5067 if (obs->in(0) == not_ctl && obs->is_Call() &&
1748
3e8fbc61cee8 6978355: renaming for 6961697
twisti
parents: 1746
diff changeset
5068 (obs->as_Call()->entry_point() == SharedRuntime::uncommon_trap_blob()->entry_point())) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
5069 found_trap = true; break;
a61af66fc99e Initial load
duke
parents:
diff changeset
5070 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5071 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5072 if (found_trap) {
a61af66fc99e Initial load
duke
parents:
diff changeset
5073 ctl = iff->in(0); // This test feeds a harmless uncommon trap.
a61af66fc99e Initial load
duke
parents:
diff changeset
5074 continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
5075 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5076 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5077 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
5078 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5079
a61af66fc99e Initial load
duke
parents:
diff changeset
5080 // If we get this far, we have an allocation which immediately
a61af66fc99e Initial load
duke
parents:
diff changeset
5081 // precedes the arraycopy, and we can take over zeroing the new object.
a61af66fc99e Initial load
duke
parents:
diff changeset
5082 // The arraycopy will finish the initialization, and provide
a61af66fc99e Initial load
duke
parents:
diff changeset
5083 // a new control state to which we will anchor the destination pointer.
a61af66fc99e Initial load
duke
parents:
diff changeset
5084
a61af66fc99e Initial load
duke
parents:
diff changeset
5085 return alloc;
a61af66fc99e Initial load
duke
parents:
diff changeset
5086 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5087
a61af66fc99e Initial load
duke
parents:
diff changeset
5088 // Helper for initialization of arrays, creating a ClearArray.
a61af66fc99e Initial load
duke
parents:
diff changeset
5089 // It writes zero bits in [start..end), within the body of an array object.
a61af66fc99e Initial load
duke
parents:
diff changeset
5090 // The memory effects are all chained onto the 'adr_type' alias category.
a61af66fc99e Initial load
duke
parents:
diff changeset
5091 //
a61af66fc99e Initial load
duke
parents:
diff changeset
5092 // Since the object is otherwise uninitialized, we are free
a61af66fc99e Initial load
duke
parents:
diff changeset
5093 // to put a little "slop" around the edges of the cleared area,
a61af66fc99e Initial load
duke
parents:
diff changeset
5094 // as long as it does not go back into the array's header,
a61af66fc99e Initial load
duke
parents:
diff changeset
5095 // or beyond the array end within the heap.
a61af66fc99e Initial load
duke
parents:
diff changeset
5096 //
a61af66fc99e Initial load
duke
parents:
diff changeset
5097 // The lower edge can be rounded down to the nearest jint and the
a61af66fc99e Initial load
duke
parents:
diff changeset
5098 // upper edge can be rounded up to the nearest MinObjAlignmentInBytes.
a61af66fc99e Initial load
duke
parents:
diff changeset
5099 //
a61af66fc99e Initial load
duke
parents:
diff changeset
5100 // Arguments:
a61af66fc99e Initial load
duke
parents:
diff changeset
5101 // adr_type memory slice where writes are generated
a61af66fc99e Initial load
duke
parents:
diff changeset
5102 // dest oop of the destination array
a61af66fc99e Initial load
duke
parents:
diff changeset
5103 // basic_elem_type element type of the destination
a61af66fc99e Initial load
duke
parents:
diff changeset
5104 // slice_idx array index of first element to store
a61af66fc99e Initial load
duke
parents:
diff changeset
5105 // slice_len number of elements to store (or NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
5106 // dest_size total size in bytes of the array object
a61af66fc99e Initial load
duke
parents:
diff changeset
5107 //
a61af66fc99e Initial load
duke
parents:
diff changeset
5108 // Exactly one of slice_len or dest_size must be non-NULL.
a61af66fc99e Initial load
duke
parents:
diff changeset
5109 // If dest_size is non-NULL, zeroing extends to the end of the object.
a61af66fc99e Initial load
duke
parents:
diff changeset
5110 // If slice_len is non-NULL, the slice_idx value must be a constant.
a61af66fc99e Initial load
duke
parents:
diff changeset
5111 void
a61af66fc99e Initial load
duke
parents:
diff changeset
5112 LibraryCallKit::generate_clear_array(const TypePtr* adr_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
5113 Node* dest,
a61af66fc99e Initial load
duke
parents:
diff changeset
5114 BasicType basic_elem_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
5115 Node* slice_idx,
a61af66fc99e Initial load
duke
parents:
diff changeset
5116 Node* slice_len,
a61af66fc99e Initial load
duke
parents:
diff changeset
5117 Node* dest_size) {
a61af66fc99e Initial load
duke
parents:
diff changeset
5118 // one or the other but not both of slice_len and dest_size:
a61af66fc99e Initial load
duke
parents:
diff changeset
5119 assert((slice_len != NULL? 1: 0) + (dest_size != NULL? 1: 0) == 1, "");
a61af66fc99e Initial load
duke
parents:
diff changeset
5120 if (slice_len == NULL) slice_len = top();
a61af66fc99e Initial load
duke
parents:
diff changeset
5121 if (dest_size == NULL) dest_size = top();
a61af66fc99e Initial load
duke
parents:
diff changeset
5122
a61af66fc99e Initial load
duke
parents:
diff changeset
5123 // operate on this memory slice:
a61af66fc99e Initial load
duke
parents:
diff changeset
5124 Node* mem = memory(adr_type); // memory slice to operate on
a61af66fc99e Initial load
duke
parents:
diff changeset
5125
a61af66fc99e Initial load
duke
parents:
diff changeset
5126 // scaling and rounding of indexes:
29
d5fc211aea19 6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents: 0
diff changeset
5127 int scale = exact_log2(type2aelembytes(basic_elem_type));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
5128 int abase = arrayOopDesc::base_offset_in_bytes(basic_elem_type);
a61af66fc99e Initial load
duke
parents:
diff changeset
5129 int clear_low = (-1 << scale) & (BytesPerInt - 1);
a61af66fc99e Initial load
duke
parents:
diff changeset
5130 int bump_bit = (-1 << scale) & BytesPerInt;
a61af66fc99e Initial load
duke
parents:
diff changeset
5131
a61af66fc99e Initial load
duke
parents:
diff changeset
5132 // determine constant starts and ends
a61af66fc99e Initial load
duke
parents:
diff changeset
5133 const intptr_t BIG_NEG = -128;
a61af66fc99e Initial load
duke
parents:
diff changeset
5134 assert(BIG_NEG + 2*abase < 0, "neg enough");
a61af66fc99e Initial load
duke
parents:
diff changeset
5135 intptr_t slice_idx_con = (intptr_t) find_int_con(slice_idx, BIG_NEG);
a61af66fc99e Initial load
duke
parents:
diff changeset
5136 intptr_t slice_len_con = (intptr_t) find_int_con(slice_len, BIG_NEG);
a61af66fc99e Initial load
duke
parents:
diff changeset
5137 if (slice_len_con == 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
5138 return; // nothing to do here
a61af66fc99e Initial load
duke
parents:
diff changeset
5139 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5140 intptr_t start_con = (abase + (slice_idx_con << scale)) & ~clear_low;
a61af66fc99e Initial load
duke
parents:
diff changeset
5141 intptr_t end_con = find_intptr_t_con(dest_size, -1);
a61af66fc99e Initial load
duke
parents:
diff changeset
5142 if (slice_idx_con >= 0 && slice_len_con >= 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
5143 assert(end_con < 0, "not two cons");
a61af66fc99e Initial load
duke
parents:
diff changeset
5144 end_con = round_to(abase + ((slice_idx_con + slice_len_con) << scale),
a61af66fc99e Initial load
duke
parents:
diff changeset
5145 BytesPerLong);
a61af66fc99e Initial load
duke
parents:
diff changeset
5146 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5147
a61af66fc99e Initial load
duke
parents:
diff changeset
5148 if (start_con >= 0 && end_con >= 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
5149 // Constant start and end. Simple.
a61af66fc99e Initial load
duke
parents:
diff changeset
5150 mem = ClearArrayNode::clear_memory(control(), mem, dest,
a61af66fc99e Initial load
duke
parents:
diff changeset
5151 start_con, end_con, &_gvn);
a61af66fc99e Initial load
duke
parents:
diff changeset
5152 } else if (start_con >= 0 && dest_size != top()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
5153 // Constant start, pre-rounded end after the tail of the array.
a61af66fc99e Initial load
duke
parents:
diff changeset
5154 Node* end = dest_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
5155 mem = ClearArrayNode::clear_memory(control(), mem, dest,
a61af66fc99e Initial load
duke
parents:
diff changeset
5156 start_con, end, &_gvn);
a61af66fc99e Initial load
duke
parents:
diff changeset
5157 } else if (start_con >= 0 && slice_len != top()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
5158 // Constant start, non-constant end. End needs rounding up.
a61af66fc99e Initial load
duke
parents:
diff changeset
5159 // End offset = round_up(abase + ((slice_idx_con + slice_len) << scale), 8)
a61af66fc99e Initial load
duke
parents:
diff changeset
5160 intptr_t end_base = abase + (slice_idx_con << scale);
a61af66fc99e Initial load
duke
parents:
diff changeset
5161 int end_round = (-1 << scale) & (BytesPerLong - 1);
a61af66fc99e Initial load
duke
parents:
diff changeset
5162 Node* end = ConvI2X(slice_len);
a61af66fc99e Initial load
duke
parents:
diff changeset
5163 if (scale != 0)
a61af66fc99e Initial load
duke
parents:
diff changeset
5164 end = _gvn.transform( new(C,3) LShiftXNode(end, intcon(scale) ));
a61af66fc99e Initial load
duke
parents:
diff changeset
5165 end_base += end_round;
a61af66fc99e Initial load
duke
parents:
diff changeset
5166 end = _gvn.transform( new(C,3) AddXNode(end, MakeConX(end_base)) );
a61af66fc99e Initial load
duke
parents:
diff changeset
5167 end = _gvn.transform( new(C,3) AndXNode(end, MakeConX(~end_round)) );
a61af66fc99e Initial load
duke
parents:
diff changeset
5168 mem = ClearArrayNode::clear_memory(control(), mem, dest,
a61af66fc99e Initial load
duke
parents:
diff changeset
5169 start_con, end, &_gvn);
a61af66fc99e Initial load
duke
parents:
diff changeset
5170 } else if (start_con < 0 && dest_size != top()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
5171 // Non-constant start, pre-rounded end after the tail of the array.
a61af66fc99e Initial load
duke
parents:
diff changeset
5172 // This is almost certainly a "round-to-end" operation.
a61af66fc99e Initial load
duke
parents:
diff changeset
5173 Node* start = slice_idx;
a61af66fc99e Initial load
duke
parents:
diff changeset
5174 start = ConvI2X(start);
a61af66fc99e Initial load
duke
parents:
diff changeset
5175 if (scale != 0)
a61af66fc99e Initial load
duke
parents:
diff changeset
5176 start = _gvn.transform( new(C,3) LShiftXNode( start, intcon(scale) ));
a61af66fc99e Initial load
duke
parents:
diff changeset
5177 start = _gvn.transform( new(C,3) AddXNode(start, MakeConX(abase)) );
a61af66fc99e Initial load
duke
parents:
diff changeset
5178 if ((bump_bit | clear_low) != 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
5179 int to_clear = (bump_bit | clear_low);
a61af66fc99e Initial load
duke
parents:
diff changeset
5180 // Align up mod 8, then store a jint zero unconditionally
a61af66fc99e Initial load
duke
parents:
diff changeset
5181 // just before the mod-8 boundary.
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 34
diff changeset
5182 if (((abase + bump_bit) & ~to_clear) - bump_bit
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 34
diff changeset
5183 < arrayOopDesc::length_offset_in_bytes() + BytesPerInt) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 34
diff changeset
5184 bump_bit = 0;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 34
diff changeset
5185 assert((abase & to_clear) == 0, "array base must be long-aligned");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 34
diff changeset
5186 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 34
diff changeset
5187 // Bump 'start' up to (or past) the next jint boundary:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 34
diff changeset
5188 start = _gvn.transform( new(C,3) AddXNode(start, MakeConX(bump_bit)) );
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 34
diff changeset
5189 assert((abase & clear_low) == 0, "array base must be int-aligned");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 34
diff changeset
5190 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
5191 // Round bumped 'start' down to jlong boundary in body of array.
a61af66fc99e Initial load
duke
parents:
diff changeset
5192 start = _gvn.transform( new(C,3) AndXNode(start, MakeConX(~to_clear)) );
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 34
diff changeset
5193 if (bump_bit != 0) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 34
diff changeset
5194 // Store a zero to the immediately preceding jint:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 34
diff changeset
5195 Node* x1 = _gvn.transform( new(C,3) AddXNode(start, MakeConX(-bump_bit)) );
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 34
diff changeset
5196 Node* p1 = basic_plus_adr(dest, x1);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 34
diff changeset
5197 mem = StoreNode::make(_gvn, control(), mem, p1, adr_type, intcon(0), T_INT);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 34
diff changeset
5198 mem = _gvn.transform(mem);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 34
diff changeset
5199 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
5200 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5201 Node* end = dest_size; // pre-rounded
a61af66fc99e Initial load
duke
parents:
diff changeset
5202 mem = ClearArrayNode::clear_memory(control(), mem, dest,
a61af66fc99e Initial load
duke
parents:
diff changeset
5203 start, end, &_gvn);
a61af66fc99e Initial load
duke
parents:
diff changeset
5204 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
5205 // Non-constant start, unrounded non-constant end.
a61af66fc99e Initial load
duke
parents:
diff changeset
5206 // (Nobody zeroes a random midsection of an array using this routine.)
a61af66fc99e Initial load
duke
parents:
diff changeset
5207 ShouldNotReachHere(); // fix caller
a61af66fc99e Initial load
duke
parents:
diff changeset
5208 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5209
a61af66fc99e Initial load
duke
parents:
diff changeset
5210 // Done.
a61af66fc99e Initial load
duke
parents:
diff changeset
5211 set_memory(mem, adr_type);
a61af66fc99e Initial load
duke
parents:
diff changeset
5212 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5213
a61af66fc99e Initial load
duke
parents:
diff changeset
5214
a61af66fc99e Initial load
duke
parents:
diff changeset
5215 bool
a61af66fc99e Initial load
duke
parents:
diff changeset
5216 LibraryCallKit::generate_block_arraycopy(const TypePtr* adr_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
5217 BasicType basic_elem_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
5218 AllocateNode* alloc,
a61af66fc99e Initial load
duke
parents:
diff changeset
5219 Node* src, Node* src_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
5220 Node* dest, Node* dest_offset,
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
5221 Node* dest_size, bool dest_uninitialized) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
5222 // See if there is an advantage from block transfer.
29
d5fc211aea19 6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents: 0
diff changeset
5223 int scale = exact_log2(type2aelembytes(basic_elem_type));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
5224 if (scale >= LogBytesPerLong)
a61af66fc99e Initial load
duke
parents:
diff changeset
5225 return false; // it is already a block transfer
a61af66fc99e Initial load
duke
parents:
diff changeset
5226
a61af66fc99e Initial load
duke
parents:
diff changeset
5227 // Look at the alignment of the starting offsets.
a61af66fc99e Initial load
duke
parents:
diff changeset
5228 int abase = arrayOopDesc::base_offset_in_bytes(basic_elem_type);
3742
b2cb497dec28 7047069: Array can dynamically change size when assigned to an object field
kvn
parents: 3337
diff changeset
5229
b2cb497dec28 7047069: Array can dynamically change size when assigned to an object field
kvn
parents: 3337
diff changeset
5230 intptr_t src_off_con = (intptr_t) find_int_con(src_offset, -1);
b2cb497dec28 7047069: Array can dynamically change size when assigned to an object field
kvn
parents: 3337
diff changeset
5231 intptr_t dest_off_con = (intptr_t) find_int_con(dest_offset, -1);
b2cb497dec28 7047069: Array can dynamically change size when assigned to an object field
kvn
parents: 3337
diff changeset
5232 if (src_off_con < 0 || dest_off_con < 0)
0
a61af66fc99e Initial load
duke
parents:
diff changeset
5233 // At present, we can only understand constants.
a61af66fc99e Initial load
duke
parents:
diff changeset
5234 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
5235
3742
b2cb497dec28 7047069: Array can dynamically change size when assigned to an object field
kvn
parents: 3337
diff changeset
5236 intptr_t src_off = abase + (src_off_con << scale);
b2cb497dec28 7047069: Array can dynamically change size when assigned to an object field
kvn
parents: 3337
diff changeset
5237 intptr_t dest_off = abase + (dest_off_con << scale);
b2cb497dec28 7047069: Array can dynamically change size when assigned to an object field
kvn
parents: 3337
diff changeset
5238
0
a61af66fc99e Initial load
duke
parents:
diff changeset
5239 if (((src_off | dest_off) & (BytesPerLong-1)) != 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
5240 // Non-aligned; too bad.
a61af66fc99e Initial load
duke
parents:
diff changeset
5241 // One more chance: Pick off an initial 32-bit word.
a61af66fc99e Initial load
duke
parents:
diff changeset
5242 // This is a common case, since abase can be odd mod 8.
a61af66fc99e Initial load
duke
parents:
diff changeset
5243 if (((src_off | dest_off) & (BytesPerLong-1)) == BytesPerInt &&
a61af66fc99e Initial load
duke
parents:
diff changeset
5244 ((src_off ^ dest_off) & (BytesPerLong-1)) == 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
5245 Node* sptr = basic_plus_adr(src, src_off);
a61af66fc99e Initial load
duke
parents:
diff changeset
5246 Node* dptr = basic_plus_adr(dest, dest_off);
a61af66fc99e Initial load
duke
parents:
diff changeset
5247 Node* sval = make_load(control(), sptr, TypeInt::INT, T_INT, adr_type);
a61af66fc99e Initial load
duke
parents:
diff changeset
5248 store_to_memory(control(), dptr, sval, T_INT, adr_type);
a61af66fc99e Initial load
duke
parents:
diff changeset
5249 src_off += BytesPerInt;
a61af66fc99e Initial load
duke
parents:
diff changeset
5250 dest_off += BytesPerInt;
a61af66fc99e Initial load
duke
parents:
diff changeset
5251 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
5252 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
5253 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5254 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5255 assert(src_off % BytesPerLong == 0, "");
a61af66fc99e Initial load
duke
parents:
diff changeset
5256 assert(dest_off % BytesPerLong == 0, "");
a61af66fc99e Initial load
duke
parents:
diff changeset
5257
a61af66fc99e Initial load
duke
parents:
diff changeset
5258 // Do this copy by giant steps.
a61af66fc99e Initial load
duke
parents:
diff changeset
5259 Node* sptr = basic_plus_adr(src, src_off);
a61af66fc99e Initial load
duke
parents:
diff changeset
5260 Node* dptr = basic_plus_adr(dest, dest_off);
a61af66fc99e Initial load
duke
parents:
diff changeset
5261 Node* countx = dest_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
5262 countx = _gvn.transform( new (C, 3) SubXNode(countx, MakeConX(dest_off)) );
a61af66fc99e Initial load
duke
parents:
diff changeset
5263 countx = _gvn.transform( new (C, 3) URShiftXNode(countx, intcon(LogBytesPerLong)) );
a61af66fc99e Initial load
duke
parents:
diff changeset
5264
a61af66fc99e Initial load
duke
parents:
diff changeset
5265 bool disjoint_bases = true; // since alloc != NULL
a61af66fc99e Initial load
duke
parents:
diff changeset
5266 generate_unchecked_arraycopy(adr_type, T_LONG, disjoint_bases,
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
5267 sptr, NULL, dptr, NULL, countx, dest_uninitialized);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
5268
a61af66fc99e Initial load
duke
parents:
diff changeset
5269 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
5270 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5271
a61af66fc99e Initial load
duke
parents:
diff changeset
5272
a61af66fc99e Initial load
duke
parents:
diff changeset
5273 // Helper function; generates code for the slow case.
a61af66fc99e Initial load
duke
parents:
diff changeset
5274 // We make a call to a runtime method which emulates the native method,
a61af66fc99e Initial load
duke
parents:
diff changeset
5275 // but without the native wrapper overhead.
a61af66fc99e Initial load
duke
parents:
diff changeset
5276 void
a61af66fc99e Initial load
duke
parents:
diff changeset
5277 LibraryCallKit::generate_slow_arraycopy(const TypePtr* adr_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
5278 Node* src, Node* src_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
5279 Node* dest, Node* dest_offset,
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
5280 Node* copy_length, bool dest_uninitialized) {
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
5281 assert(!dest_uninitialized, "Invariant");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
5282 Node* call = make_runtime_call(RC_NO_LEAF | RC_UNCOMMON,
a61af66fc99e Initial load
duke
parents:
diff changeset
5283 OptoRuntime::slow_arraycopy_Type(),
a61af66fc99e Initial load
duke
parents:
diff changeset
5284 OptoRuntime::slow_arraycopy_Java(),
a61af66fc99e Initial load
duke
parents:
diff changeset
5285 "slow_arraycopy", adr_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
5286 src, src_offset, dest, dest_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
5287 copy_length);
a61af66fc99e Initial load
duke
parents:
diff changeset
5288
a61af66fc99e Initial load
duke
parents:
diff changeset
5289 // Handle exceptions thrown by this fellow:
a61af66fc99e Initial load
duke
parents:
diff changeset
5290 make_slow_call_ex(call, env()->Throwable_klass(), false);
a61af66fc99e Initial load
duke
parents:
diff changeset
5291 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5292
a61af66fc99e Initial load
duke
parents:
diff changeset
5293 // Helper function; generates code for cases requiring runtime checks.
a61af66fc99e Initial load
duke
parents:
diff changeset
5294 Node*
a61af66fc99e Initial load
duke
parents:
diff changeset
5295 LibraryCallKit::generate_checkcast_arraycopy(const TypePtr* adr_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
5296 Node* dest_elem_klass,
a61af66fc99e Initial load
duke
parents:
diff changeset
5297 Node* src, Node* src_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
5298 Node* dest, Node* dest_offset,
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
5299 Node* copy_length, bool dest_uninitialized) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
5300 if (stopped()) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
5301
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
5302 address copyfunc_addr = StubRoutines::checkcast_arraycopy(dest_uninitialized);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
5303 if (copyfunc_addr == NULL) { // Stub was not generated, go slow path.
a61af66fc99e Initial load
duke
parents:
diff changeset
5304 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
5305 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5306
a61af66fc99e Initial load
duke
parents:
diff changeset
5307 // Pick out the parameters required to perform a store-check
a61af66fc99e Initial load
duke
parents:
diff changeset
5308 // for the target array. This is an optimistic check. It will
a61af66fc99e Initial load
duke
parents:
diff changeset
5309 // look in each non-null element's class, at the desired klass's
a61af66fc99e Initial load
duke
parents:
diff changeset
5310 // super_check_offset, for the desired klass.
a61af66fc99e Initial load
duke
parents:
diff changeset
5311 int sco_offset = Klass::super_check_offset_offset_in_bytes() + sizeof(oopDesc);
a61af66fc99e Initial load
duke
parents:
diff changeset
5312 Node* p3 = basic_plus_adr(dest_elem_klass, sco_offset);
1609
4311f23817fd 6959430: Make sure raw loads have control edge
kvn
parents: 1552
diff changeset
5313 Node* n3 = new(C, 3) LoadINode(NULL, memory(p3), p3, _gvn.type(p3)->is_ptr());
1844
75588558f1bf 6980792: Crash "exception happened outside interpreter, nmethods and vtable stubs (1)"
never
parents: 1748
diff changeset
5314 Node* check_offset = ConvI2X(_gvn.transform(n3));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
5315 Node* check_value = dest_elem_klass;
a61af66fc99e Initial load
duke
parents:
diff changeset
5316
a61af66fc99e Initial load
duke
parents:
diff changeset
5317 Node* src_start = array_element_address(src, src_offset, T_OBJECT);
a61af66fc99e Initial load
duke
parents:
diff changeset
5318 Node* dest_start = array_element_address(dest, dest_offset, T_OBJECT);
a61af66fc99e Initial load
duke
parents:
diff changeset
5319
a61af66fc99e Initial load
duke
parents:
diff changeset
5320 // (We know the arrays are never conjoint, because their types differ.)
a61af66fc99e Initial load
duke
parents:
diff changeset
5321 Node* call = make_runtime_call(RC_LEAF|RC_NO_FP,
a61af66fc99e Initial load
duke
parents:
diff changeset
5322 OptoRuntime::checkcast_arraycopy_Type(),
a61af66fc99e Initial load
duke
parents:
diff changeset
5323 copyfunc_addr, "checkcast_arraycopy", adr_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
5324 // five arguments, of which two are
a61af66fc99e Initial load
duke
parents:
diff changeset
5325 // intptr_t (jlong in LP64)
a61af66fc99e Initial load
duke
parents:
diff changeset
5326 src_start, dest_start,
a61af66fc99e Initial load
duke
parents:
diff changeset
5327 copy_length XTOP,
a61af66fc99e Initial load
duke
parents:
diff changeset
5328 check_offset XTOP,
a61af66fc99e Initial load
duke
parents:
diff changeset
5329 check_value);
a61af66fc99e Initial load
duke
parents:
diff changeset
5330
a61af66fc99e Initial load
duke
parents:
diff changeset
5331 return _gvn.transform(new (C, 1) ProjNode(call, TypeFunc::Parms));
a61af66fc99e Initial load
duke
parents:
diff changeset
5332 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5333
a61af66fc99e Initial load
duke
parents:
diff changeset
5334
a61af66fc99e Initial load
duke
parents:
diff changeset
5335 // Helper function; generates code for cases requiring runtime checks.
a61af66fc99e Initial load
duke
parents:
diff changeset
5336 Node*
a61af66fc99e Initial load
duke
parents:
diff changeset
5337 LibraryCallKit::generate_generic_arraycopy(const TypePtr* adr_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
5338 Node* src, Node* src_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
5339 Node* dest, Node* dest_offset,
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
5340 Node* copy_length, bool dest_uninitialized) {
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
5341 assert(!dest_uninitialized, "Invariant");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
5342 if (stopped()) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
5343 address copyfunc_addr = StubRoutines::generic_arraycopy();
a61af66fc99e Initial load
duke
parents:
diff changeset
5344 if (copyfunc_addr == NULL) { // Stub was not generated, go slow path.
a61af66fc99e Initial load
duke
parents:
diff changeset
5345 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
5346 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5347
a61af66fc99e Initial load
duke
parents:
diff changeset
5348 Node* call = make_runtime_call(RC_LEAF|RC_NO_FP,
a61af66fc99e Initial load
duke
parents:
diff changeset
5349 OptoRuntime::generic_arraycopy_Type(),
a61af66fc99e Initial load
duke
parents:
diff changeset
5350 copyfunc_addr, "generic_arraycopy", adr_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
5351 src, src_offset, dest, dest_offset, copy_length);
a61af66fc99e Initial load
duke
parents:
diff changeset
5352
a61af66fc99e Initial load
duke
parents:
diff changeset
5353 return _gvn.transform(new (C, 1) ProjNode(call, TypeFunc::Parms));
a61af66fc99e Initial load
duke
parents:
diff changeset
5354 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5355
a61af66fc99e Initial load
duke
parents:
diff changeset
5356 // Helper function; generates the fast out-of-line call to an arraycopy stub.
a61af66fc99e Initial load
duke
parents:
diff changeset
5357 void
a61af66fc99e Initial load
duke
parents:
diff changeset
5358 LibraryCallKit::generate_unchecked_arraycopy(const TypePtr* adr_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
5359 BasicType basic_elem_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
5360 bool disjoint_bases,
a61af66fc99e Initial load
duke
parents:
diff changeset
5361 Node* src, Node* src_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
5362 Node* dest, Node* dest_offset,
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
5363 Node* copy_length, bool dest_uninitialized) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
5364 if (stopped()) return; // nothing to do
a61af66fc99e Initial load
duke
parents:
diff changeset
5365
a61af66fc99e Initial load
duke
parents:
diff changeset
5366 Node* src_start = src;
a61af66fc99e Initial load
duke
parents:
diff changeset
5367 Node* dest_start = dest;
a61af66fc99e Initial load
duke
parents:
diff changeset
5368 if (src_offset != NULL || dest_offset != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
5369 assert(src_offset != NULL && dest_offset != NULL, "");
a61af66fc99e Initial load
duke
parents:
diff changeset
5370 src_start = array_element_address(src, src_offset, basic_elem_type);
a61af66fc99e Initial load
duke
parents:
diff changeset
5371 dest_start = array_element_address(dest, dest_offset, basic_elem_type);
a61af66fc99e Initial load
duke
parents:
diff changeset
5372 }
a61af66fc99e Initial load
duke
parents:
diff changeset
5373
a61af66fc99e Initial load
duke
parents:
diff changeset
5374 // Figure out which arraycopy runtime method to call.
a61af66fc99e Initial load
duke
parents:
diff changeset
5375 const char* copyfunc_name = "arraycopy";
a61af66fc99e Initial load
duke
parents:
diff changeset
5376 address copyfunc_addr =
a61af66fc99e Initial load
duke
parents:
diff changeset
5377 basictype2arraycopy(basic_elem_type, src_offset, dest_offset,
2324
0ac769a57c64 6627983: G1: Bad oop deference during marking
iveresov
parents: 2320
diff changeset
5378 disjoint_bases, copyfunc_name, dest_uninitialized);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
5379
a61af66fc99e Initial load
duke
parents:
diff changeset
5380 // Call it. Note that the count_ix value is not scaled to a byte-size.
a61af66fc99e Initial load
duke
parents:
diff changeset
5381 make_runtime_call(RC_LEAF|RC_NO_FP,
a61af66fc99e Initial load
duke
parents:
diff changeset
5382 OptoRuntime::fast_arraycopy_Type(),
a61af66fc99e Initial load
duke
parents:
diff changeset
5383 copyfunc_addr, copyfunc_name, adr_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
5384 src_start, dest_start, copy_length XTOP);
a61af66fc99e Initial load
duke
parents:
diff changeset
5385 }
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5386
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5387 //----------------------------inline_reference_get----------------------------
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5388
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5389 bool LibraryCallKit::inline_reference_get() {
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5390 const int nargs = 1; // self
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5391
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5392 guarantee(java_lang_ref_Reference::referent_offset > 0,
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5393 "should have already been set");
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5394
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5395 int referent_offset = java_lang_ref_Reference::referent_offset;
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5396
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5397 // Restore the stack and pop off the argument
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5398 _sp += nargs;
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5399 Node *reference_obj = pop();
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5400
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5401 // Null check on self without removing any arguments.
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5402 _sp += nargs;
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5403 reference_obj = do_null_check(reference_obj, T_OBJECT);
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5404 _sp -= nargs;;
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5405
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5406 if (stopped()) return true;
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5407
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5408 Node *adr = basic_plus_adr(reference_obj, reference_obj, referent_offset);
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5409
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5410 ciInstanceKlass* klass = env()->Object_klass();
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5411 const TypeOopPtr* object_type = TypeOopPtr::make_from_klass(klass);
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5412
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5413 Node* no_ctrl = NULL;
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5414 Node *result = make_load(no_ctrl, adr, object_type, T_OBJECT);
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5415
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5416 // Use the pre-barrier to record the value in the referent field
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5417 pre_barrier(false /* do_load */,
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5418 control(),
3258
edd9b016deb6 7036021: G1: build failure on win64 and linux with hs21 in jdk6 build environment
johnc
parents: 3255
diff changeset
5419 NULL /* obj */, NULL /* adr */, max_juint /* alias_idx */, NULL /* val */, NULL /* val_type */,
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5420 result /* pre_val */,
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5421 T_OBJECT);
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5422
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5423 push(result);
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5424 return true;
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5425 }
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2385
diff changeset
5426