--- a/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotNodeLIRBuilder.java	Mon Jun 08 18:47:58 2015 +0200
+++ b/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotNodeLIRBuilder.java	Mon Jun 08 19:19:45 2015 +0200
@@ -22,31 +22,20 @@
  */
 package com.oracle.graal.hotspot.amd64;
 
-import static com.oracle.graal.asm.amd64.AMD64Assembler.AMD64BinaryArithmetic.*;
 import static com.oracle.graal.hotspot.HotSpotBackend.*;
 import static com.oracle.jvmci.amd64.AMD64.*;
 import static com.oracle.jvmci.code.ValueUtil.*;
 
-import com.oracle.graal.asm.*;
-import com.oracle.graal.asm.amd64.AMD64Assembler.*;
 import com.oracle.graal.compiler.amd64.*;
-import com.oracle.graal.compiler.common.calc.*;
-import com.oracle.graal.compiler.common.type.*;
 import com.oracle.graal.compiler.gen.*;
-import com.oracle.graal.compiler.match.*;
 import com.oracle.graal.graph.*;
 import com.oracle.graal.hotspot.*;
 import com.oracle.graal.hotspot.nodes.*;
-import com.oracle.graal.hotspot.nodes.type.*;
 import com.oracle.graal.lir.*;
-import com.oracle.graal.lir.amd64.*;
 import com.oracle.graal.lir.amd64.AMD64Move.CompareAndSwapOp;
 import com.oracle.graal.lir.gen.*;
 import com.oracle.graal.nodes.CallTargetNode.InvokeKind;
 import com.oracle.graal.nodes.*;
-import com.oracle.graal.nodes.calc.*;
-import com.oracle.graal.nodes.extended.*;
-import com.oracle.graal.nodes.memory.*;
 import com.oracle.jvmci.amd64.*;
 import com.oracle.jvmci.code.*;
 import com.oracle.jvmci.debug.*;
@@ -58,35 +47,8 @@
  */
 public class AMD64HotSpotNodeLIRBuilder extends AMD64NodeLIRBuilder implements HotSpotNodeLIRBuilder {
 
-    private static ValueNode filterCompression(ValueNode node) {
-        ValueNode result = node;
-        if (result instanceof PiNode) {
-            result = ((PiNode) result).getOriginalNode();
-        }
-        if (result instanceof CompressionNode) {
-            result = ((CompressionNode) result).getValue();
-        }
-        return result;
-    }
-
     private final HotSpotGraalRuntimeProvider runtime;
 
-    private void emitCompareCompressedMemory(Kind kind, IfNode ifNode, ValueNode valueNode, CompressionNode compress, ConstantLocationNode location, Access access, CompareNode compare) {
-        Value value = gen.load(operand(valueNode));
-        AMD64AddressValue address = makeCompressedAddress(compress, location);
-        Condition cond = compare.condition();
-        if (access == filterCompression(compare.getX())) {
-            cond = cond.mirror();
-        } else {
-            assert access == filterCompression(compare.getY());
-        }
-
-        LabelRef trueLabel = getLIRBlock(ifNode.trueSuccessor());
-        LabelRef falseLabel = getLIRBlock(ifNode.falseSuccessor());
-        double trueLabelProbability = ifNode.probability(ifNode.trueSuccessor());
-        getGen().emitCompareBranchMemory(kind, value, address, getState(access), cond, compare.unorderedIsTrue(), trueLabel, falseLabel, trueLabelProbability);
-    }
-
     public AMD64HotSpotNodeLIRBuilder(HotSpotGraalRuntimeProvider runtime, StructuredGraph graph, LIRGeneratorTool gen) {
         super(graph, gen);
         this.runtime = runtime;
@@ -197,169 +159,16 @@
         }
     }
 
-    public void emitPrefetchAllocate(ValueNode address, ValueNode distance) {
-        AMD64AddressValue addr = getGen().emitAddress(operand(address), 0, gen.loadNonConst(operand(distance)), 1);
-        append(new AMD64PrefetchOp(addr, getGen().config.allocatePrefetchInstr));
-    }
-
     @Override
     public void visitDirectCompareAndSwap(DirectCompareAndSwapNode x) {
         Value expected = gen.loadNonConst(operand(x.expectedValue()));
         Variable newVal = gen.load(operand(x.newValue()));
         assert expected.getLIRKind().equals(newVal.getLIRKind());
 
-        AMD64AddressValue address = getGen().emitAddress(operand(x.object()), 0, operand(x.offset()), 1);
-
         RegisterValue raxLocal = AMD64.rax.asValue(expected.getLIRKind());
         gen.emitMove(raxLocal, expected);
-        append(new CompareAndSwapOp(expected.getKind(), raxLocal, address, raxLocal, newVal));
+        append(new CompareAndSwapOp(expected.getKind(), raxLocal, getGen().asAddressValue(operand(x.getAddress())), raxLocal, newVal));
 
         setResult(x, gen.emitMove(raxLocal));
     }
-
-    boolean canFormCompressedMemory(CompressionNode compress, ConstantLocationNode location) {
-        HotSpotVMConfig config = runtime.getConfig();
-        if (config.useCompressedOops && compress.getEncoding().shift <= 3 && NumUtil.isInt(location.getDisplacement())) {
-            Stamp compressedStamp = compress.getValue().stamp();
-            if (compressedStamp instanceof NarrowOopStamp) {
-                return true;
-            } else if (compressedStamp instanceof KlassPointerStamp) {
-                assert ((KlassPointerStamp) compressedStamp).isCompressed();
-                return config.narrowKlassBase == config.narrowOopBase;
-            }
-        }
-        return false;
-    }
-
-    private AMD64AddressValue makeCompressedAddress(CompressionNode compress, ConstantLocationNode location) {
-        assert canFormCompressedMemory(compress, location);
-        AMD64AddressValue address = getGen().emitAddress(getGen().getProviders().getRegisters().getHeapBaseRegister().asValue(), location.getDisplacement(), operand(compress.getValue()),
-                        1 << compress.getEncoding().shift);
-        return address;
-    }
-
-    @MatchRule("(If (IntegerEquals=compare value (FloatingRead=access (Compression=compress object) ConstantLocation=location)))")
-    @MatchRule("(If (IntegerLessThan=compare value (FloatingRead=access (Compression=compress object) ConstantLocation=location)))")
-    @MatchRule("(If (IntegerBelow=compare value (FloatingRead=access (Compression=compress object) ConstantLocation=location)))")
-    @MatchRule("(If (FloatEquals=compare value (FloatingRead=access (Compression=compress object) ConstantLocation=location)))")
-    @MatchRule("(If (FloatLessThan=compare value (FloatingRead=access (Compression=compress object) ConstantLocation=location)))")
-    @MatchRule("(If (IntegerEquals=compare value (Read=access (Compression=compress object) ConstantLocation=location)))")
-    @MatchRule("(If (IntegerLessThan=compare value (Read=access (Compression=compress object) ConstantLocation=location)))")
-    @MatchRule("(If (IntegerBelow=compare value (Read=access (Compression=compress object) ConstantLocation=location)))")
-    @MatchRule("(If (FloatEquals=compare value (Read=access (Compression=compress object) ConstantLocation=location)))")
-    @MatchRule("(If (FloatLessThan=compare value (Read=access (Compression=compress object) ConstantLocation=location)))")
-    public ComplexMatchResult ifCompareCompressedMemory(IfNode root, CompareNode compare, CompressionNode compress, ValueNode value, ConstantLocationNode location, Access access) {
-        if (canFormCompressedMemory(compress, location)) {
-            PlatformKind cmpKind = gen.getLIRKind(compare.getX().stamp()).getPlatformKind();
-            if (cmpKind instanceof Kind) {
-                Kind kind = (Kind) cmpKind;
-                return builder -> {
-                    emitCompareCompressedMemory(kind, root, value, compress, location, access, compare);
-                    return null;
-                };
-            }
-        }
-        return null;
-    }
-
-    private ComplexMatchResult binaryReadCompressed(AMD64RMOp op, OperandSize size, ValueNode value, Access access, CompressionNode compress, ConstantLocationNode location) {
-        if (canFormCompressedMemory(compress, location)) {
-            return builder -> getLIRGeneratorTool().emitBinaryMemory(op, size, getLIRGeneratorTool().asAllocatable(operand(value)), makeCompressedAddress(compress, location), getState(access));
-        } else {
-            return null;
-        }
-    }
-
-    @MatchRule("(Add value (Read=access (Compression=compress object) ConstantLocation=location))")
-    @MatchRule("(Add value (FloatingRead=access (Compression=compress object) ConstantLocation=location))")
-    public ComplexMatchResult addMemoryCompressed(ValueNode value, Access access, CompressionNode compress, ConstantLocationNode location) {
-        OperandSize size = getMemorySize(access);
-        if (size.isXmmType()) {
-            return binaryReadCompressed(SSEOp.ADD, size, value, access, compress, location);
-        } else {
-            return binaryReadCompressed(ADD.getRMOpcode(size), size, value, access, compress, location);
-        }
-    }
-
-    @MatchRule("(Sub value (Read=access (Compression=compress object) ConstantLocation=location))")
-    @MatchRule("(Sub value (FloatingRead=access (Compression=compress object) ConstantLocation=location))")
-    public ComplexMatchResult subMemoryCompressed(ValueNode value, Access access, CompressionNode compress, ConstantLocationNode location) {
-        OperandSize size = getMemorySize(access);
-        if (size.isXmmType()) {
-            return binaryReadCompressed(SSEOp.SUB, size, value, access, compress, location);
-        } else {
-            return binaryReadCompressed(SUB.getRMOpcode(size), size, value, access, compress, location);
-        }
-    }
-
-    @MatchRule("(Mul value (Read=access (Compression=compress object) ConstantLocation=location))")
-    @MatchRule("(Mul value (FloatingRead=access (Compression=compress object) ConstantLocation=location))")
-    public ComplexMatchResult mulMemoryCompressed(ValueNode value, Access access, CompressionNode compress, ConstantLocationNode location) {
-        OperandSize size = getMemorySize(access);
-        if (size.isXmmType()) {
-            return binaryReadCompressed(SSEOp.MUL, size, value, access, compress, location);
-        } else {
-            return binaryReadCompressed(AMD64RMOp.IMUL, size, value, access, compress, location);
-        }
-    }
-
-    @MatchRule("(And value (Read=access (Compression=compress object) ConstantLocation=location))")
-    @MatchRule("(And value (FloatingRead=access (Compression=compress object) ConstantLocation=location))")
-    public ComplexMatchResult andMemoryCompressed(ValueNode value, Access access, CompressionNode compress, ConstantLocationNode location) {
-        OperandSize size = getMemorySize(access);
-        if (size.isXmmType()) {
-            return null;
-        } else {
-            return binaryReadCompressed(AND.getRMOpcode(size), size, value, access, compress, location);
-        }
-    }
-
-    @MatchRule("(Or value (Read=access (Compression=compress object) ConstantLocation=location))")
-    @MatchRule("(Or value (FloatingRead=access (Compression=compress object) ConstantLocation=location))")
-    public ComplexMatchResult orMemoryCompressed(ValueNode value, Access access, CompressionNode compress, ConstantLocationNode location) {
-        OperandSize size = getMemorySize(access);
-        if (size.isXmmType()) {
-            return null;
-        } else {
-            return binaryReadCompressed(OR.getRMOpcode(size), size, value, access, compress, location);
-        }
-    }
-
-    @MatchRule("(Xor value (Read=access (Compression=compress object) ConstantLocation=location))")
-    @MatchRule("(Xor value (FloatingRead=access (Compression=compress object) ConstantLocation=location))")
-    public ComplexMatchResult xorMemoryCompressed(ValueNode value, Access access, CompressionNode compress, ConstantLocationNode location) {
-        OperandSize size = getMemorySize(access);
-        if (size.isXmmType()) {
-            return null;
-        } else {
-            return binaryReadCompressed(XOR.getRMOpcode(size), size, value, access, compress, location);
-        }
-    }
-
-    @MatchRule("(Read (Compression=compress object) ConstantLocation=location)")
-    @MatchRule("(Read (Pi (Compression=compress object)) ConstantLocation=location)")
-    @MatchRule("(FloatingRead (Compression=compress object) ConstantLocation=location)")
-    @MatchRule("(FloatingRead (Pi (Compression=compress object)) ConstantLocation=location)")
-    public ComplexMatchResult readCompressed(Access root, CompressionNode compress, ConstantLocationNode location) {
-        if (canFormCompressedMemory(compress, location)) {
-            LIRKind readKind = getGen().getLIRKind(root.asNode().stamp());
-            return builder -> {
-                return getGen().emitLoad(readKind, makeCompressedAddress(compress, location), getState(root));
-            };
-        }
-        return null;
-    }
-
-    @MatchRule("(Write (Compression=compress object) ConstantLocation=location value)")
-    @MatchRule("(Write (Pi (Compression=compress object)) ConstantLocation=location value)")
-    public ComplexMatchResult writeCompressed(Access root, CompressionNode compress, ConstantLocationNode location, ValueNode value) {
-        if (canFormCompressedMemory(compress, location)) {
-            LIRKind readKind = getGen().getLIRKind(value.asNode().stamp());
-            return builder -> {
-                getGen().emitStore(readKind, makeCompressedAddress(compress, location), operand(value), getState(root));
-                return null;
-            };
-        }
-        return null;
-    }
 }