truffle: src/share/vm/opto/compile.cpp comparison

comparison src/share/vm/opto/compile.cpp @ 17474:6fa574bfd32a

Merge

author	chegar
date	Thu, 03 Oct 2013 19:13:12 +0100
parents	1b64d46620a3
children	4a2acfb16e97

comparison

equal deleted inserted replaced

-:9b4ce069642e
+:6fa574bfd32a
 _late_inlines_pos(0),
 _number_of_mh_late_inlines(0),
 _inlining_progress(false),
 _inlining_incrementally(false),
 _print_inlining_list(NULL),
-_print_inlining(0) {
+_print_inlining_idx(0) {
 C = this;
 CompileWrapper cw(this);
 #ifndef PRODUCT
 if (TimeCompiler2) {
 }
 }
 set_print_assembly(print_opto_assembly);
 set_parsed_irreducible_loop(false);
 #endif
+set_print_inlining(PrintInlining || method()->has_option("PrintInlining") NOT_PRODUCT( || PrintOptoInlining));
+set_print_intrinsics(PrintIntrinsics || method()->has_option("PrintIntrinsics"));
 if (ProfileTraps) {
 // Make sure the method being compiled gets its own MDO,
 // so we can at least track the decompile_count().
 method()->ensure_method_data();
 uint estimated_size = method()->code_size()*4+64;
 estimated_size = (estimated_size < MINIMUM_NODE_HASH ? MINIMUM_NODE_HASH : estimated_size);
 PhaseGVN gvn(node_arena(), estimated_size);
 set_initial_gvn(&gvn);
-if (PrintInlining  || PrintIntrinsics NOT_PRODUCT( || PrintOptoInlining)) {
+if (print_inlining() || print_intrinsics()) {
 _print_inlining_list = new (comp_arena())GrowableArray<PrintInliningBuffer>(comp_arena(), 1, 1, PrintInliningBuffer());
 }
 { // Scope for timing the parser
 TracePhase t3("parse", &_t_parser, true);
 _congraph(NULL),
 _number_of_mh_late_inlines(0),
 _inlining_progress(false),
 _inlining_incrementally(false),
 _print_inlining_list(NULL),
-_print_inlining(0) {
+_print_inlining_idx(0) {
 C = this;
 #ifndef PRODUCT
 TraceTime t1(NULL, &_t_totalCompilation, TimeCompiler, false);
 TraceTime t2(NULL, &_t_stubCompilation, TimeCompiler, false);
 offset = tj->offset();
 }
 // Array pointers need some flattening
 const TypeAryPtr *ta = tj->isa_aryptr();
+if (ta && ta->is_stable()) {
+// Erase stability property for alias analysis.
+tj = ta = ta->cast_to_stable(false);
+}
 if( ta && is_known_inst ) {
 if ( offset != Type::OffsetBot &&
 offset > arrayOopDesc::length_offset_in_bytes() ) {
 offset = Type::OffsetBot; // Flatten constant access into array body only
 tj = ta = TypeAryPtr::make(ptr, ta->ary(), ta->klass(), true, offset, ta->instance_id());
 void Compile::AliasType::Init(int i, const TypePtr* at) {
 _index = i;
 _adr_type = at;
 _field = NULL;
+_element = NULL;
 _is_rewritable = true; // default
 const TypeOopPtr *atoop = (at != NULL) ? at->isa_oopptr() : NULL;
 if (atoop != NULL && atoop->is_known_instance()) {
 const TypeOopPtr *gt = atoop->cast_to_instance_id(TypeOopPtr::InstanceBot);
 _general_index = Compile::current()->get_alias_index(gt);
 if (flat->isa_instptr()) {
 if (flat->offset() == java_lang_Class::klass_offset_in_bytes()
 && flat->is_instptr()->klass() == env()->Class_klass())
 alias_type(idx)->set_rewritable(false);
 }
+if (flat->isa_aryptr()) {
+#ifdef ASSERT
+const int header_size_min  = arrayOopDesc::base_offset_in_bytes(T_BYTE);
+// (T_BYTE has the weakest alignment and size restrictions...)
+assert(flat->offset() < header_size_min, "array body reference must be OffsetBot");
+#endif
+if (flat->offset() == TypePtr::OffsetBot) {
+alias_type(idx)->set_element(flat->is_aryptr()->elem());
+}
+}
 if (flat->isa_klassptr()) {
 if (flat->offset() == in_bytes(Klass::super_check_offset_offset()))
 alias_type(idx)->set_rewritable(false);
 if (flat->offset() == in_bytes(Klass::modifier_flags_offset()))
 alias_type(idx)->set_rewritable(false);
 if (field->is_static())
 t = TypeInstPtr::make(field->holder()->java_mirror());
 else
 t = TypeOopPtr::make_from_klass_raw(field->holder());
 AliasType* atp = alias_type(t->add_offset(field->offset_in_bytes()), field);
-assert(field->is_final() == !atp->is_rewritable(), "must get the rewritable bits correct");
+assert((field->is_final() || field->is_stable()) == !atp->is_rewritable(), "must get the rewritable bits correct");
 return atp;
 }
 //------------------------------have_alias_type--------------------------------
 assert( !addp->is_AddP() ||
 addp->in(AddPNode::Base)->is_top() || // Top OK for allocation
 addp->in(AddPNode::Base) == n->in(AddPNode::Base),
 "Base pointers must match" );
 #ifdef _LP64
-if ((UseCompressedOops || UseCompressedKlassPointers) &&
+if ((UseCompressedOops || UseCompressedClassPointers) &&
 addp->Opcode() == Op_ConP &&
 addp == n->in(AddPNode::Base) &&
 n->in(AddPNode::Offset)->is_Con()) {
 // Use addressing with narrow klass to load with offset on x86.
 // On sparc loading 32-bits constant and decoding it have less
 }
 }
 // Skip next transformation if compressed oops are not used.
 if ((UseCompressedOops && !Matcher::gen_narrow_oop_implicit_null_checks()) ||
-(!UseCompressedOops && !UseCompressedKlassPointers))
+(!UseCompressedOops && !UseCompressedClassPointers))
 return;
 // Go over safepoints nodes to skip DecodeN/DecodeNKlass nodes for debug edges.
 // It could be done for an uncommon traps or any safepoints/calls
 // if the DecodeN/DecodeNKlass node is referenced only in a debug info.
 cb.consts()->relocate((address) constant_addr, relocInfo::internal_word_type);
 }
 }
 void Compile::dump_inlining() {
-if (PrintInlining || PrintIntrinsics NOT_PRODUCT( || PrintOptoInlining)) {
+if (print_inlining() || print_intrinsics()) {
 // Print inlining message for candidates that we couldn't inline
 // for lack of space or non constant receiver
 for (int i = 0; i < _late_inlines.length(); i++) {
 CallGenerator* cg = _late_inlines.at(i);
 cg->print_inlining_late("live nodes > LiveNodeCountInliningCutoff");
 if ( m == NULL ) continue;
 useful.push(m);
 }
 }
 for (int i = 0; i < _print_inlining_list->length(); i++) {
-tty->print(_print_inlining_list->at(i).ss()->as_string());
+tty->print(_print_inlining_list->adr_at(i)->ss()->as_string());
 }
 }
 }
 int Compile::cmp_expensive_nodes(Node* n1, Node* n2) {

Mercurial > hg > truffle

comparison src/share/vm/opto/compile.cpp @ 17474:6fa574bfd32a