truffle: src/share/vm/opto/library

comparison src/share/vm/opto/library_call.cpp @ 2468:6c97c830fb6f

Merge

author	jrose
date	Sat, 09 Apr 2011 21:16:12 -0700
parents	13bc79b5c9c8
children	5d046bf49ce7 66b0e2371912

comparison

equal deleted inserted replaced

-:0930dc920c18
+:6c97c830fb6f
 Node* target = _gvn.transform( makecon(TypeOopPtr::make_from_constant(target_array, true)) );
 jint target_length = target_array->length();
 const TypeAry* target_array_type = TypeAry::make(TypeInt::CHAR, TypeInt::make(0, target_length, Type::WidenMin));
 const TypeAryPtr* target_type = TypeAryPtr::make(TypePtr::BotPTR, target_array_type, target_array->klass(), true, Type::OffsetBot);
-IdealKit kit(gvn(), control(), merged_memory(), false, true);
+IdealKit kit(this, false, true);
 #define __ kit.
 Node* zero             = __ ConI(0);
 Node* one              = __ ConI(1);
 Node* cache            = __ ConI(cache_i);
 Node* md2              = __ ConI(md2_i);
 __ bind(outer_loop);
 }__ end_loop(); __ dead(i);
 __ bind(return_);
 // Final sync IdealKit and GraphKit.
-sync_kit(kit);
+final_sync(kit);
 Node* result = __ value(rtn);
 #undef __
 C->set_has_loops(true);
 return result;
 }
 } else {
 // We can't tell at compile time if we are storing in the Java heap or outside
 // of it. So we need to emit code to conditionally do the proper type of
 // store.
-IdealKit ideal(gvn(), control(),  merged_memory());
+IdealKit ideal(this);
 #define __ ideal.
 // QQQ who knows what probability is here??
 __ if_then(heap_base_oop, BoolTest::ne, null(), PROB_UNLIKELY(0.999)); {
 // Sync IdealKit and graphKit.
-set_all_memory( __ merged_memory());
+sync_kit(ideal);
-set_control(__ ctrl());
 Node* st = store_oop_to_unknown(control(), heap_base_oop, adr, adr_type, val, type);
 // Update IdealKit memory.
-__ set_all_memory(merged_memory());
+__ sync_kit(this);
-__ set_ctrl(control());
 } __ else_(); {
 __ store(__ ctrl(), adr, val, type, alias_type->index(), is_volatile);
 } __ end_if();
 // Final sync IdealKit and GraphKit.
-sync_kit(ideal);
+final_sync(ideal);
 #undef __
 }
 }
 }
 push(_gvn.transform(result_val));
 return true;
 }
-// constants for computing the copy function
-enum {
-COPYFUNC_UNALIGNED = 0,
-COPYFUNC_ALIGNED = 1,                 // src, dest aligned to HeapWordSize
-COPYFUNC_CONJOINT = 0,
-COPYFUNC_DISJOINT = 2                 // src != dest, or transfer can descend
-};
-// Note:  The condition "disjoint" applies also for overlapping copies
-// where an descending copy is permitted (i.e., dest_offset <= src_offset).
-static address
-select_arraycopy_function(BasicType t, bool aligned, bool disjoint, const char* &name, bool dest_uninitialized) {
-int selector =
-(aligned  ? COPYFUNC_ALIGNED  : COPYFUNC_UNALIGNED) +
-(disjoint ? COPYFUNC_DISJOINT : COPYFUNC_CONJOINT);
-#define RETURN_STUB(xxx_arraycopy) { \
-name = #xxx_arraycopy; \
-return StubRoutines::xxx_arraycopy(); }
-#define RETURN_STUB_PARM(xxx_arraycopy, parm) {           \
-name = #xxx_arraycopy; \
-return StubRoutines::xxx_arraycopy(parm); }
-switch (t) {
-case T_BYTE:
-case T_BOOLEAN:
-switch (selector) {
-case COPYFUNC_CONJOINT | COPYFUNC_UNALIGNED:  RETURN_STUB(jbyte_arraycopy);
-case COPYFUNC_CONJOINT | COPYFUNC_ALIGNED:    RETURN_STUB(arrayof_jbyte_arraycopy);
-case COPYFUNC_DISJOINT | COPYFUNC_UNALIGNED:  RETURN_STUB(jbyte_disjoint_arraycopy);
-case COPYFUNC_DISJOINT | COPYFUNC_ALIGNED:    RETURN_STUB(arrayof_jbyte_disjoint_arraycopy);
-}
-case T_CHAR:
-case T_SHORT:
-switch (selector) {
-case COPYFUNC_CONJOINT | COPYFUNC_UNALIGNED:  RETURN_STUB(jshort_arraycopy);
-case COPYFUNC_CONJOINT | COPYFUNC_ALIGNED:    RETURN_STUB(arrayof_jshort_arraycopy);
-case COPYFUNC_DISJOINT | COPYFUNC_UNALIGNED:  RETURN_STUB(jshort_disjoint_arraycopy);
-case COPYFUNC_DISJOINT | COPYFUNC_ALIGNED:    RETURN_STUB(arrayof_jshort_disjoint_arraycopy);
-}
-case T_INT:
-case T_FLOAT:
-switch (selector) {
-case COPYFUNC_CONJOINT | COPYFUNC_UNALIGNED:  RETURN_STUB(jint_arraycopy);
-case COPYFUNC_CONJOINT | COPYFUNC_ALIGNED:    RETURN_STUB(arrayof_jint_arraycopy);
-case COPYFUNC_DISJOINT | COPYFUNC_UNALIGNED:  RETURN_STUB(jint_disjoint_arraycopy);
-case COPYFUNC_DISJOINT | COPYFUNC_ALIGNED:    RETURN_STUB(arrayof_jint_disjoint_arraycopy);
-}
-case T_DOUBLE:
-case T_LONG:
-switch (selector) {
-case COPYFUNC_CONJOINT | COPYFUNC_UNALIGNED:  RETURN_STUB(jlong_arraycopy);
-case COPYFUNC_CONJOINT | COPYFUNC_ALIGNED:    RETURN_STUB(arrayof_jlong_arraycopy);
-case COPYFUNC_DISJOINT | COPYFUNC_UNALIGNED:  RETURN_STUB(jlong_disjoint_arraycopy);
-case COPYFUNC_DISJOINT | COPYFUNC_ALIGNED:    RETURN_STUB(arrayof_jlong_disjoint_arraycopy);
-}
-case T_ARRAY:
-case T_OBJECT:
-switch (selector) {
-case COPYFUNC_CONJOINT | COPYFUNC_UNALIGNED:  RETURN_STUB_PARM(oop_arraycopy, dest_uninitialized);
-case COPYFUNC_CONJOINT | COPYFUNC_ALIGNED:    RETURN_STUB_PARM(arrayof_oop_arraycopy, dest_uninitialized);
-case COPYFUNC_DISJOINT | COPYFUNC_UNALIGNED:  RETURN_STUB_PARM(oop_disjoint_arraycopy, dest_uninitialized);
-case COPYFUNC_DISJOINT | COPYFUNC_ALIGNED:    RETURN_STUB_PARM(arrayof_oop_disjoint_arraycopy, dest_uninitialized);
-}
-default:
-ShouldNotReachHere();
-return NULL;
-}
-#undef RETURN_STUB
-#undef RETURN_STUB_PARM
-}
 //------------------------------basictype2arraycopy----------------------------
 address LibraryCallKit::basictype2arraycopy(BasicType t,
 Node* src_offset,
 Node* dest_offset,
 bool disjoint_bases,
 } else if (src_offset == dest_offset && src_offset != NULL) {
 // This can occur if the offsets are identical non-constants.
 disjoint = true;
 }
-return select_arraycopy_function(t, aligned, disjoint, name, dest_uninitialized);
+return StubRoutines::select_arraycopy_function(t, aligned, disjoint, name, dest_uninitialized);
 }
 //------------------------------inline_arraycopy-----------------------
 bool LibraryCallKit::inline_arraycopy() {

Mercurial > hg > truffle

comparison src/share/vm/opto/library_call.cpp @ 2468:6c97c830fb6f