Mercurial > hg > truffle
changeset 121:86a689f680c5
Merge
| author | kamg |
|---|---|
| date | Fri, 18 Apr 2008 07:51:43 -0400 |
| parents | aab136449123 (diff) 018d5b58dd4f (current diff) |
| children | ec73d88d5b43 |
| files | |
| diffstat | 9 files changed, 242 insertions(+), 49 deletions(-) [+] |
line wrap: on
line diff
--- a/make/hotspot_version Thu Apr 17 22:18:15 2008 -0400 +++ b/make/hotspot_version Fri Apr 18 07:51:43 2008 -0400 @@ -31,11 +31,11 @@ # # Don't put quotes (fail windows build). -HOTSPOT_VM_COPYRIGHT=Copyright 2007 +HOTSPOT_VM_COPYRIGHT=Copyright 2008 -HS_MAJOR_VER=12 +HS_MAJOR_VER=13 HS_MINOR_VER=0 -HS_BUILD_NUMBER=02 +HS_BUILD_NUMBER=01 JDK_MAJOR_VER=1 JDK_MINOR_VER=7
--- a/make/linux/makefiles/cscope.make Thu Apr 17 22:18:15 2008 -0400 +++ b/make/linux/makefiles/cscope.make Fri Apr 18 07:51:43 2008 -0400 @@ -38,6 +38,7 @@ NAWK = awk RM = rm -f +HG = hg CS_TOP = ../.. CSDIRS = $(CS_TOP)/src $(CS_TOP)/build @@ -140,14 +141,17 @@ # .nametable.files and .nametable.files.tmp are used to determine if any files # were added to/deleted from/renamed in the workspace. If not, then there's -# normally no need to run find. To force a 'find': gmake nametable.clean. +# normally no need to rebuild the cscope database. To force a rebuild of +# the cscope database: gmake nametable.clean. .nametable.files: .nametable.files.tmp - cmp -s $@ $< || cp $< $@ + ( cmp -s $@ $< ) || ( cp $< $@ ) + -$(RM) $< -.nametable.files.tmp: $(CS_TOP)/Codemgr_wsdata/nametable - $(NAWK) \ - '{ if (sub("( [a-z0-9]{2,8}){4}$$", "")) print $$0; }' $< > $@ - +# `hg status' is slightly faster than `hg fstatus'. Both are +# quite a bit slower on an NFS mounted file system, so this is +# really geared towards repos on local file systems. +.nametable.files.tmp: + -$(HG) fstatus -acmn > $@ nametable.clean: -$(RM) .nametable.files .nametable.files.tmp
--- a/make/solaris/makefiles/cscope.make Thu Apr 17 22:18:15 2008 -0400 +++ b/make/solaris/makefiles/cscope.make Fri Apr 18 07:51:43 2008 -0400 @@ -38,6 +38,7 @@ NAWK = /usr/xpg4/bin/awk RM = rm -f +HG = hg CS_TOP = ../.. CSDIRS = $(CS_TOP)/src $(CS_TOP)/make @@ -141,13 +142,17 @@ # .nametable.files and .nametable.files.tmp are used to determine if any files # were added to/deleted from/renamed in the workspace. If not, then there's -# normally no need to run find. To force a 'find': gmake nametable.clean. +# normally no need to rebuild the cscope database. To force a rebuild of +# the cscope database: gmake nametable.clean. .nametable.files: .nametable.files.tmp - cmp -s $@ $< || cp $< $@ + ( cmp -s $@ $< ) || ( cp $< $@ ) + -$(RM) $< -.nametable.files.tmp: $(CS_TOP)/Codemgr_wsdata/nametable - $(NAWK) \ - '{ if (sub("( [a-z0-9]{2,8}){4}$$", "")) print $$0; }' $< > $@ +# `hg status' is slightly faster than `hg fstatus'. Both are +# quite a bit slower on an NFS mounted file system, so this is +# really geared towards repos on local file systems. +.nametable.files.tmp: + -$(HG) fstatus -acmn > $@ nametable.clean: -$(RM) .nametable.files .nametable.files.tmp
--- a/src/cpu/x86/vm/assembler_x86_32.cpp Thu Apr 17 22:18:15 2008 -0400 +++ b/src/cpu/x86/vm/assembler_x86_32.cpp Fri Apr 18 07:51:43 2008 -0400 @@ -3405,10 +3405,16 @@ assert(bs->kind() == BarrierSet::CardTableModRef, "Wrong barrier set kind"); CardTableModRefBS* ct = (CardTableModRefBS*)bs; assert(sizeof(*ct->byte_map_base) == sizeof(jbyte), "adjust this code"); - ExternalAddress cardtable((address)ct->byte_map_base); - Address index(noreg, obj, Address::times_1); - - movb(as_Address(ArrayAddress(cardtable, index)), 0); + + // The calculation for byte_map_base is as follows: + // byte_map_base = _byte_map - (uintptr_t(low_bound) >> card_shift); + // So this essentially converts an address to a displacement and + // it will never need to be relocated. On 64bit however the value may be too + // large for a 32bit displacement + + intptr_t disp = (intptr_t) ct->byte_map_base; + Address cardtable(noreg, obj, Address::times_1, disp); + movb(cardtable, 0); }
--- a/src/cpu/x86/vm/assembler_x86_64.cpp Thu Apr 17 22:18:15 2008 -0400 +++ b/src/cpu/x86/vm/assembler_x86_64.cpp Fri Apr 18 07:51:43 2008 -0400 @@ -4436,9 +4436,32 @@ assert(bs->kind() == BarrierSet::CardTableModRef, "Wrong barrier set kind"); CardTableModRefBS* ct = (CardTableModRefBS*)bs; assert(sizeof(*ct->byte_map_base) == sizeof(jbyte), "adjust this code"); - ExternalAddress cardtable((address)ct->byte_map_base); - Address index(noreg, obj, Address::times_1); - movb(as_Address(ArrayAddress(cardtable, index)), 0); + + // The calculation for byte_map_base is as follows: + // byte_map_base = _byte_map - (uintptr_t(low_bound) >> card_shift); + // So this essentially converts an address to a displacement and + // it will never need to be relocated. On 64bit however the value may be too + // large for a 32bit displacement + + intptr_t disp = (intptr_t) ct->byte_map_base; + if (is_simm32(disp)) { + Address cardtable(noreg, obj, Address::times_1, disp); + movb(cardtable, 0); + } else { + // By doing it as an ExternalAddress disp could be converted to a rip-relative + // displacement and done in a single instruction given favorable mapping and + // a smarter version of as_Address. Worst case it is two instructions which + // is no worse off then loading disp into a register and doing as a simple + // Address() as above. + // We can't do as ExternalAddress as the only style since if disp == 0 we'll + // assert since NULL isn't acceptable in a reloci (see 6644928). In any case + // in some cases we'll get a single instruction version. + + ExternalAddress cardtable((address)disp); + Address index(noreg, obj, Address::times_1); + movb(as_Address(ArrayAddress(cardtable, index)), 0); + } + } void MacroAssembler::c2bool(Register x) {
--- a/src/share/vm/opto/memnode.cpp Thu Apr 17 22:18:15 2008 -0400 +++ b/src/share/vm/opto/memnode.cpp Fri Apr 18 07:51:43 2008 -0400 @@ -241,36 +241,91 @@ } // Helper function for proving some simple control dominations. -// Attempt to prove that control input 'dom' dominates (or equals) 'sub'. +// Attempt to prove that all control inputs of 'dom' dominate 'sub'. // Already assumes that 'dom' is available at 'sub', and that 'sub' // is not a constant (dominated by the method's StartNode). // Used by MemNode::find_previous_store to prove that the // control input of a memory operation predates (dominates) // an allocation it wants to look past. -bool MemNode::detect_dominating_control(Node* dom, Node* sub) { - if (dom == NULL) return false; - if (dom->is_Proj()) dom = dom->in(0); - if (dom->is_Start()) return true; // anything inside the method - if (dom->is_Root()) return true; // dom 'controls' a constant - int cnt = 20; // detect cycle or too much effort - while (sub != NULL) { // walk 'sub' up the chain to 'dom' - if (--cnt < 0) return false; // in a cycle or too complex - if (sub == dom) return true; - if (sub->is_Start()) return false; - if (sub->is_Root()) return false; - Node* up = sub->in(0); - if (sub == up && sub->is_Region()) { - for (uint i = 1; i < sub->req(); i++) { - Node* in = sub->in(i); - if (in != NULL && !in->is_top() && in != sub) { - up = in; break; // take any path on the way up to 'dom' +bool MemNode::all_controls_dominate(Node* dom, Node* sub) { + if (dom == NULL || dom->is_top() || sub == NULL || sub->is_top()) + return false; // Conservative answer for dead code + + // Check 'dom'. + dom = dom->find_exact_control(dom); + if (dom == NULL || dom->is_top()) + return false; // Conservative answer for dead code + + if (dom->is_Start() || dom->is_Root() || dom == sub) + return true; + + // 'dom' dominates 'sub' if its control edge and control edges + // of all its inputs dominate or equal to sub's control edge. + + // Currently 'sub' is either Allocate, Initialize or Start nodes. + assert(sub->is_Allocate() || sub->is_Initialize() || sub->is_Start(), "expecting only these nodes"); + + // Get control edge of 'sub'. + sub = sub->find_exact_control(sub->in(0)); + if (sub == NULL || sub->is_top()) + return false; // Conservative answer for dead code + + assert(sub->is_CFG(), "expecting control"); + + if (sub == dom) + return true; + + if (sub->is_Start() || sub->is_Root()) + return false; + + { + // Check all control edges of 'dom'. + + ResourceMark rm; + Arena* arena = Thread::current()->resource_area(); + Node_List nlist(arena); + Unique_Node_List dom_list(arena); + + dom_list.push(dom); + bool only_dominating_controls = false; + + for (uint next = 0; next < dom_list.size(); next++) { + Node* n = dom_list.at(next); + if (!n->is_CFG() && n->pinned()) { + // Check only own control edge for pinned non-control nodes. + n = n->find_exact_control(n->in(0)); + if (n == NULL || n->is_top()) + return false; // Conservative answer for dead code + assert(n->is_CFG(), "expecting control"); + } + if (n->is_Start() || n->is_Root()) { + only_dominating_controls = true; + } else if (n->is_CFG()) { + if (n->dominates(sub, nlist)) + only_dominating_controls = true; + else + return false; + } else { + // First, own control edge. + Node* m = n->find_exact_control(n->in(0)); + if (m == NULL) + continue; + if (m->is_top()) + return false; // Conservative answer for dead code + dom_list.push(m); + + // Now, the rest of edges. + uint cnt = n->req(); + for (uint i = 1; i < cnt; i++) { + m = n->find_exact_control(n->in(i)); + if (m == NULL || m->is_top()) + continue; + dom_list.push(m); } } } - if (sub == up) return false; // some kind of tight cycle - sub = up; + return only_dominating_controls; } - return false; } //---------------------detect_ptr_independence--------------------------------- @@ -291,9 +346,9 @@ return (a1 != a2); } else if (a1 != NULL) { // one allocation a1 // (Note: p2->is_Con implies p2->in(0)->is_Root, which dominates.) - return detect_dominating_control(p2->in(0), a1->in(0)); + return all_controls_dominate(p2, a1); } else { //(a2 != NULL) // one allocation a2 - return detect_dominating_control(p1->in(0), a2->in(0)); + return all_controls_dominate(p1, a2); } return false; } @@ -379,8 +434,7 @@ known_identical = true; else if (alloc != NULL) known_independent = true; - else if (ctrl != NULL && - detect_dominating_control(ctrl, st_alloc->in(0))) + else if (all_controls_dominate(this, st_alloc)) known_independent = true; if (known_independent) { @@ -1093,7 +1147,7 @@ Node* base = AddPNode::Ideal_base_and_offset(address, phase, ignore); if (base != NULL && phase->type(base)->higher_equal(TypePtr::NOTNULL) - && detect_dominating_control(base->in(0), phase->C->start())) { + && all_controls_dominate(base, phase->C->start())) { // A method-invariant, non-null address (constant or 'this' argument). set_req(MemNode::Control, NULL); } @@ -2536,7 +2590,7 @@ // must have preceded the init, or else be equal to the init. // Even after loop optimizations (which might change control edges) // a store is never pinned *before* the availability of its inputs. - if (!MemNode::detect_dominating_control(ctl, this->in(0))) + if (!MemNode::all_controls_dominate(n, this)) return false; // failed to prove a good control }
--- a/src/share/vm/opto/memnode.hpp Thu Apr 17 22:18:15 2008 -0400 +++ b/src/share/vm/opto/memnode.hpp Fri Apr 18 07:51:43 2008 -0400 @@ -70,7 +70,7 @@ static Node *optimize_simple_memory_chain(Node *mchain, const TypePtr *t_adr, PhaseGVN *phase); static Node *optimize_memory_chain(Node *mchain, const TypePtr *t_adr, PhaseGVN *phase); // This one should probably be a phase-specific function: - static bool detect_dominating_control(Node* dom, Node* sub); + static bool all_controls_dominate(Node* dom, Node* sub); // Is this Node a MemNode or some descendent? Default is YES. virtual Node *Ideal_DU_postCCP( PhaseCCP *ccp );
--- a/src/share/vm/opto/node.cpp Thu Apr 17 22:18:15 2008 -0400 +++ b/src/share/vm/opto/node.cpp Fri Apr 18 07:51:43 2008 -0400 @@ -1017,6 +1017,101 @@ return false; }; +//--------------------------find_exact_control--------------------------------- +// Skip Proj and CatchProj nodes chains. Check for Null and Top. +Node* Node::find_exact_control(Node* ctrl) { + if (ctrl == NULL && this->is_Region()) + ctrl = this->as_Region()->is_copy(); + + if (ctrl != NULL && ctrl->is_CatchProj()) { + if (ctrl->as_CatchProj()->_con == CatchProjNode::fall_through_index) + ctrl = ctrl->in(0); + if (ctrl != NULL && !ctrl->is_top()) + ctrl = ctrl->in(0); + } + + if (ctrl != NULL && ctrl->is_Proj()) + ctrl = ctrl->in(0); + + return ctrl; +} + +//--------------------------dominates------------------------------------------ +// Helper function for MemNode::all_controls_dominate(). +// Check if 'this' control node dominates or equal to 'sub' control node. +bool Node::dominates(Node* sub, Node_List &nlist) { + assert(this->is_CFG(), "expecting control"); + assert(sub != NULL && sub->is_CFG(), "expecting control"); + + Node* orig_sub = sub; + nlist.clear(); + bool this_dominates = false; + uint region_input = 0; + while (sub != NULL) { // walk 'sub' up the chain to 'this' + if (sub == this) { + if (nlist.size() == 0) { + // No Region nodes except loops were visited before and the EntryControl + // path was taken for loops: it did not walk in a cycle. + return true; + } else if (!this_dominates) { + // Region nodes were visited. Continue walk up to Start or Root + // to make sure that it did not walk in a cycle. + this_dominates = true; // first time meet + } else { + return false; // already met before: walk in a cycle + } + } + if (sub->is_Start() || sub->is_Root()) + return this_dominates; + + Node* up = sub->find_exact_control(sub->in(0)); + if (up == NULL || up->is_top()) + return false; // Conservative answer for dead code + + if (sub == up && sub->is_Loop()) { + up = sub->in(0); // in(LoopNode::EntryControl); + } else if (sub == up && sub->is_Region()) { + uint i = 1; + if (nlist.size() == 0) { + // No Region nodes (except Loops) were visited before. + // Take first valid path on the way up to 'this'. + } else if (nlist.at(nlist.size() - 1) == sub) { + // This Region node was just visited. Take other path. + i = region_input + 1; + nlist.pop(); + } else { + // Was this Region node visited before? + uint size = nlist.size(); + for (uint j = 0; j < size; j++) { + if (nlist.at(j) == sub) { + return false; // The Region node was visited before. Give up. + } + } + // The Region node was not visited before. + // Take first valid path on the way up to 'this'. + } + for (; i < sub->req(); i++) { + Node* in = sub->in(i); + if (in != NULL && !in->is_top() && in != sub) { + break; + } + } + if (i < sub->req()) { + nlist.push(sub); + up = sub->in(i); + region_input = i; + } + } + if (sub == up) + return false; // some kind of tight cycle + if (orig_sub == up) + return false; // walk in a cycle + + sub = up; + } + return false; +} + //------------------------------remove_dead_region----------------------------- // This control node is dead. Follow the subgraph below it making everything // using it dead as well. This will happen normally via the usual IterGVN
--- a/src/share/vm/opto/node.hpp Thu Apr 17 22:18:15 2008 -0400 +++ b/src/share/vm/opto/node.hpp Fri Apr 18 07:51:43 2008 -0400 @@ -817,6 +817,12 @@ // for the transformations to happen. bool has_special_unique_user() const; + // Skip Proj and CatchProj nodes chains. Check for Null and Top. + Node* find_exact_control(Node* ctrl); + + // Check if 'this' node dominates or equal to 'sub'. + bool dominates(Node* sub, Node_List &nlist); + protected: bool remove_dead_region(PhaseGVN *phase, bool can_reshape); public: