Mercurial > hg > graal-compiler

comparison graal/GraalCompiler/src/com/sun/c1x/graph/GraphBuilder.java @ 2533:c480605ef068

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Removed canonicalizer.
author Thomas Wuerthinger <thomas@wuerthinger.net>
date Wed, 27 Apr 2011 19:05:35 +0200
parents 2f271a85d104
children 4af63190ee3d
comparison
equal deleted inserted replaced
2532:3fca504f28ba 2533:c480605ef068
74 /** 74 /**
75 * Map used for local load elimination (i.e. within the current block). 75 * Map used for local load elimination (i.e. within the current block).
76 */ 76 */
77 final MemoryMap memoryMap; 77 final MemoryMap memoryMap;
78 78
79 final Canonicalizer canonicalizer; // canonicalizer which does strength reduction + constant folding
80 ScopeData scopeData; // Per-scope data; used for inlining 79 ScopeData scopeData; // Per-scope data; used for inlining
81 BlockBegin curBlock; // the current block 80 BlockBegin curBlock; // the current block
82 MutableFrameState curState; // the current execution state 81 MutableFrameState curState; // the current execution state
83 Instruction lastInstr; // the last instruction added 82 Instruction lastInstr; // the last instruction added
84 final LogStream log; 83 final LogStream log;
96 this.compilation = compilation; 95 this.compilation = compilation;
97 this.ir = ir; 96 this.ir = ir;
98 this.stats = compilation.stats; 97 this.stats = compilation.stats;
99 this.memoryMap = C1XOptions.OptLocalLoadElimination ? new MemoryMap() : null; 98 this.memoryMap = C1XOptions.OptLocalLoadElimination ? new MemoryMap() : null;
100 this.localValueMap = C1XOptions.OptLocalValueNumbering ? new ValueMap() : null; 99 this.localValueMap = C1XOptions.OptLocalValueNumbering ? new ValueMap() : null;
101 this.canonicalizer = C1XOptions.OptCanonicalize ? new Canonicalizer(compilation.runtime, compilation.method, compilation.target) : null;
102 log = C1XOptions.TraceBytecodeParserLevel > 0 ? new LogStream(TTY.out()) : null; 100 log = C1XOptions.TraceBytecodeParserLevel > 0 ? new LogStream(TTY.out()) : null;
103 } 101 }
104 102
105 /** 103 /**
106 * Builds the graph for a the specified {@code IRScope}. 104 * Builds the graph for a the specified {@code IRScope}.
752 750
753 void genGetStatic(int cpi, RiField field) { 751 void genGetStatic(int cpi, RiField field) {
754 RiType holder = field.holder(); 752 RiType holder = field.holder();
755 boolean isInitialized = !C1XOptions.TestPatching && field.isResolved() && holder.isResolved() && holder.isInitialized(); 753 boolean isInitialized = !C1XOptions.TestPatching && field.isResolved() && holder.isResolved() && holder.isInitialized();
756 CiConstant constantValue = null; 754 CiConstant constantValue = null;
757 if (isInitialized && C1XOptions.CanonicalizeConstantFields) { 755 if (isInitialized) {
758 constantValue = field.constantValue(null); 756 constantValue = field.constantValue(null);
759 } 757 }
760 if (constantValue != null) { 758 if (constantValue != null) {
761 push(constantValue.kind.stackKind(), appendConstant(constantValue)); 759 push(constantValue.kind.stackKind(), appendConstant(constantValue));
762 } else { 760 } else {
823 // of initialization is required), it can be commoned with static field accesses. 821 // of initialization is required), it can be commoned with static field accesses.
824 genResolveClass(RiType.Representation.StaticFields, holder, isInitialized, cpi); 822 genResolveClass(RiType.Representation.StaticFields, holder, isInitialized, cpi);
825 } 823 }
826 824
827 Value[] args = curState.popArguments(target.signature().argumentSlots(false)); 825 Value[] args = curState.popArguments(target.signature().argumentSlots(false));
828 if (!tryRemoveCall(target, args, true)) { 826 if (!tryInline(target, args)) {
829 if (!tryInline(target, args)) { 827 appendInvoke(INVOKESTATIC, target, args, true, cpi, constantPool);
830 appendInvoke(INVOKESTATIC, target, args, true, cpi, constantPool);
831 }
832 } 828 }
833 } 829 }
834 830
835 void genInvokeInterface(RiMethod target, int cpi, RiConstantPool constantPool) { 831 void genInvokeInterface(RiMethod target, int cpi, RiConstantPool constantPool) {
836 Value[] args = curState.popArguments(target.signature().argumentSlots(true)); 832 Value[] args = curState.popArguments(target.signature().argumentSlots(true));
837 if (!tryRemoveCall(target, args, false)) { 833
838 genInvokeIndirect(INVOKEINTERFACE, target, args, cpi, constantPool); 834 genInvokeIndirect(INVOKEINTERFACE, target, args, cpi, constantPool);
839 } 835
840 } 836 }
841 837
842 void genInvokeVirtual(RiMethod target, int cpi, RiConstantPool constantPool) { 838 void genInvokeVirtual(RiMethod target, int cpi, RiConstantPool constantPool) {
843 Value[] args = curState.popArguments(target.signature().argumentSlots(true)); 839 Value[] args = curState.popArguments(target.signature().argumentSlots(true));
844 if (!tryRemoveCall(target, args, false)) { 840 genInvokeIndirect(INVOKEVIRTUAL, target, args, cpi, constantPool);
845 genInvokeIndirect(INVOKEVIRTUAL, target, args, cpi, constantPool); 841
846 }
847 } 842 }
848 843
849 void genInvokeSpecial(RiMethod target, RiType knownHolder, int cpi, RiConstantPool constantPool) { 844 void genInvokeSpecial(RiMethod target, RiType knownHolder, int cpi, RiConstantPool constantPool) {
850 Value[] args = curState.popArguments(target.signature().argumentSlots(true)); 845 Value[] args = curState.popArguments(target.signature().argumentSlots(true));
851 if (!tryRemoveCall(target, args, false)) { 846 invokeDirect(target, args, knownHolder, cpi, constantPool);
852 invokeDirect(target, args, knownHolder, cpi, constantPool); 847
853 }
854 } 848 }
855 849
856 /** 850 /**
857 * Temporary work-around to support the @ACCESSOR Maxine annotation. 851 * Temporary work-around to support the @ACCESSOR Maxine annotation.
858 */ 852 */
1236 } 1230 }
1237 return false; 1231 return false;
1238 } 1232 }
1239 1233
1240 private Value appendConstant(CiConstant type) { 1234 private Value appendConstant(CiConstant type) {
1241 return appendWithBCI(new Constant(type), bci(), false); 1235 return appendWithBCI(new Constant(type), bci());
1242 } 1236 }
1243 1237
1244 private Value append(Instruction x) { 1238 private Value append(Instruction x) {
1245 return appendWithBCI(x, bci(), C1XOptions.OptCanonicalize); 1239 return appendWithBCI(x, bci());
1246 } 1240 }
1247 1241
1248 private Value appendWithoutOptimization(Instruction x, int bci) { 1242 private Value appendWithoutOptimization(Instruction x, int bci) {
1249 return appendWithBCI(x, bci, false); 1243 return appendWithBCI(x, bci);
1250 } 1244 }
1251 1245
1252 private Value appendWithBCI(Instruction x, int bci, boolean canonicalize) { 1246 private Value appendWithBCI(Instruction x, int bci) {
1253 if (canonicalize) {
1254 // attempt simple constant folding and strength reduction
1255 Value r = canonicalizer.canonicalize(x);
1256 List<Instruction> extra = canonicalizer.extra();
1257 if (extra != null) {
1258 // the canonicalization introduced instructions that should be added before this
1259 for (Instruction i : extra) {
1260 appendWithBCI(i, bci, false); // don't try to canonicalize the new instructions
1261 }
1262 }
1263 if (r instanceof Instruction) {
1264 // the result is an instruction that may need to be appended
1265 x = (Instruction) r;
1266 } else {
1267 // the result is not an instruction (and thus cannot be appended)
1268 return r;
1269 }
1270 }
1271 if (x.isAppended()) { 1247 if (x.isAppended()) {
1272 // the instruction has already been added 1248 // the instruction has already been added
1273 return x; 1249 return x;
1274 } 1250 }
1275 if (localValueMap != null) { 1251 if (localValueMap != null) {
1420 } 1396 }
1421 state.storeLocal(index, local); 1397 state.storeLocal(index, local);
1422 index += kind.sizeInSlots(); 1398 index += kind.sizeInSlots();
1423 } 1399 }
1424 return state; 1400 return state;
1425 }
1426
1427 boolean tryRemoveCall(RiMethod target, Value[] args, boolean isStatic) {
1428 if (target.isResolved()) {
1429 if (C1XOptions.CanonicalizeFoldableMethods) {
1430 // next try to fold the method call
1431 if (tryFoldable(target, args)) {
1432 return true;
1433 }
1434 }
1435 }
1436 return false;
1437 }
1438
1439 private boolean tryFoldable(RiMethod target, Value[] args) {
1440 CiConstant result = Canonicalizer.foldInvocation(compilation.runtime, target, args);
1441 if (result != null) {
1442 if (C1XOptions.TraceBytecodeParserLevel > 0) {
1443 log.println("|");
1444 log.println("| [folded " + target + " --> " + result + "]");
1445 log.println("|");
1446 }
1447
1448 pushReturn(returnKind(target), append(new Constant(result)));
1449 return true;
1450 }
1451 return false;
1452 } 1401 }
1453 1402
1454 private boolean tryInline(RiMethod target, Value[] args) { 1403 private boolean tryInline(RiMethod target, Value[] args) {
1455 boolean forcedInline = compilation.runtime.mustInline(target); 1404 boolean forcedInline = compilation.runtime.mustInline(target);
1456 if (forcedInline) { 1405 if (forcedInline) {