Work around buggy break in List.sort and optimize constant folding of negative values.

dart/frog/leg/ssa/builder.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 1284 matching lines @@
 
   void visitUnary(Send node, Operator op) {
     assert(node.argumentsNode is Prefix);
     visit(node.receiver);
     assert(op.token.kind !== PLUS_TOKEN);
     HInstruction operand = pop();
     HInstruction target =
         new HStatic(interceptors.getPrefixOperatorInterceptor(op));
     add(target);
     switch (op.source.stringValue) {
-      case "-": push(new HNegate(target, operand)); break;
+      case "-":

[kasperl, 2012/03/01 06:13:00]

This could possible be dealt with in a faster way by not visiting the
node.receiver when it is a literal (thus not creating the initial HLiteral node
at all). That way we also don't have to use 'is double' and 'is int' to
distinguish. Feel free to throw in a TODO(kasperl) so I don't forget about this.

[ahe, 2012/03/01 06:54:15]

Done.

+        if ((operand is HLiteral) && (operand.value is double)) {
+          stack.add(graph.addNewLiteralDouble(-operand.value));
+        } else if ((operand is HLiteral) && (operand.value is int)) {
+          stack.add(graph.addNewLiteralInt(-operand.value));

[ngeoffray, 2012/02/29 20:36:26]

Why is that not done in the constant folder instead?

[ahe, 2012/02/29 20:41:24]

Because it is really slow at doing it.

[ngeoffray, 2012/03/01 08:15:51]

Why is that?

[floitsch, 2012/03/01 10:32:18]

The problem is not really the constant folding, but then replacing the
instruction with the folded one.
Currently we know in which instruction we are used, but not exactly at which
position. For arrays, which have hundreds of inputs, finding the old instruction
to replace it with the new folded one, boils down to doing a linear search.
The worst case is basically an array like: [-1, -2, -3....].
Then each input is replaced and searched for in a linear way yielding n^2
behavior.
This CL is a short-term fix, but we (kasper and I) have discussed better ways to
replace it.

+        } else {
+          push(new HNegate(target, operand));
+        }
+        break;
       case "~": push(new HBitNot(target, operand)); break;
       default: unreachable();
     }
   }
 
   void visitBinary(HInstruction left, Operator op, HInstruction right) {
     Element element = interceptors.getOperatorInterceptor(op);
     assert(element != null);
     HInstruction target = new HStatic(element);
     add(target);
@@ skipping 1042 matching lines @@
     // Normally, we would call [close] here. However, then we hit
     // another unimplemented feature: aborting loop body. Simply
     // calling [add] does not work as it asserts that the instruction
     // isn't a control flow instruction. So we inline parts of [add].
     current.addAfter(current.last, new HThrow(message));
     if (isExpression) {
       stack.add(graph.addNewLiteralNull());
     }
   }
 }