1 /* 2 * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package jdk.nashorn.internal.codegen; 27 28 import static jdk.nashorn.internal.codegen.ClassEmitter.Flag.PRIVATE; 29 import static jdk.nashorn.internal.codegen.ClassEmitter.Flag.STATIC; 30 import static jdk.nashorn.internal.codegen.CompilerConstants.ARGUMENTS; 31 import static jdk.nashorn.internal.codegen.CompilerConstants.CALLEE; 32 import static jdk.nashorn.internal.codegen.CompilerConstants.GET_MAP; 33 import static jdk.nashorn.internal.codegen.CompilerConstants.GET_STRING; 34 import static jdk.nashorn.internal.codegen.CompilerConstants.QUICK_PREFIX; 35 import static jdk.nashorn.internal.codegen.CompilerConstants.REGEX_PREFIX; 36 import static jdk.nashorn.internal.codegen.CompilerConstants.RETURN; 37 import static jdk.nashorn.internal.codegen.CompilerConstants.SCOPE; 38 import static jdk.nashorn.internal.codegen.CompilerConstants.SPLIT_ARRAY_ARG; 39 import static jdk.nashorn.internal.codegen.CompilerConstants.SPLIT_PREFIX; 40 import static jdk.nashorn.internal.codegen.CompilerConstants.THIS; 41 import static jdk.nashorn.internal.codegen.CompilerConstants.VARARGS; 42 import static jdk.nashorn.internal.codegen.CompilerConstants.constructorNoLookup; 43 import static jdk.nashorn.internal.codegen.CompilerConstants.interfaceCallNoLookup; 44 import static jdk.nashorn.internal.codegen.CompilerConstants.methodDescriptor; 45 import static jdk.nashorn.internal.codegen.CompilerConstants.staticCallNoLookup; 46 import static jdk.nashorn.internal.codegen.CompilerConstants.staticField; 47 import static jdk.nashorn.internal.codegen.CompilerConstants.typeDescriptor; 48 import static jdk.nashorn.internal.ir.Symbol.IS_INTERNAL; 49 import static jdk.nashorn.internal.ir.Symbol.IS_TEMP; 50 import static jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor.CALLSITE_FAST_SCOPE; 51 import static jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor.CALLSITE_SCOPE; 52 import static jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor.CALLSITE_STRICT; 53 54 import java.io.PrintWriter; 55 import java.util.ArrayList; 56 import java.util.Arrays; 57 import java.util.EnumSet; 58 import java.util.Iterator; 59 import java.util.LinkedList; 60 import java.util.List; 61 import java.util.TreeMap; 62 63 import jdk.nashorn.internal.codegen.ClassEmitter.Flag; 64 import jdk.nashorn.internal.codegen.CompilerConstants.Call; 65 import jdk.nashorn.internal.codegen.RuntimeCallSite.SpecializedRuntimeNode; 66 import jdk.nashorn.internal.codegen.types.ArrayType; 67 import jdk.nashorn.internal.codegen.types.Type; 68 import jdk.nashorn.internal.ir.AccessNode; 69 import jdk.nashorn.internal.ir.BaseNode; 70 import jdk.nashorn.internal.ir.BinaryNode; 71 import jdk.nashorn.internal.ir.Block; 72 import jdk.nashorn.internal.ir.BreakNode; 73 import jdk.nashorn.internal.ir.BreakableNode; 74 import jdk.nashorn.internal.ir.CallNode; 75 import jdk.nashorn.internal.ir.CaseNode; 76 import jdk.nashorn.internal.ir.CatchNode; 77 import jdk.nashorn.internal.ir.ContinueNode; 78 import jdk.nashorn.internal.ir.EmptyNode; 79 import jdk.nashorn.internal.ir.ExecuteNode; 80 import jdk.nashorn.internal.ir.ForNode; 81 import jdk.nashorn.internal.ir.FunctionNode; 82 import jdk.nashorn.internal.ir.LexicalContext; 83 import jdk.nashorn.internal.ir.FunctionNode.CompilationState; 84 import jdk.nashorn.internal.ir.IdentNode; 85 import jdk.nashorn.internal.ir.IfNode; 86 import jdk.nashorn.internal.ir.IndexNode; 87 import jdk.nashorn.internal.ir.LexicalContextNode; 88 import jdk.nashorn.internal.ir.LiteralNode; 89 import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode; 90 import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode.ArrayUnit; 91 import jdk.nashorn.internal.ir.LoopNode; 92 import jdk.nashorn.internal.ir.Node; 93 import jdk.nashorn.internal.ir.ObjectNode; 94 import jdk.nashorn.internal.ir.PropertyNode; 95 import jdk.nashorn.internal.ir.ReturnNode; 96 import jdk.nashorn.internal.ir.RuntimeNode; 97 import jdk.nashorn.internal.ir.RuntimeNode.Request; 98 import jdk.nashorn.internal.ir.SplitNode; 99 import jdk.nashorn.internal.ir.Statement; 100 import jdk.nashorn.internal.ir.SwitchNode; 101 import jdk.nashorn.internal.ir.Symbol; 102 import jdk.nashorn.internal.ir.TernaryNode; 103 import jdk.nashorn.internal.ir.ThrowNode; 104 import jdk.nashorn.internal.ir.TryNode; 105 import jdk.nashorn.internal.ir.UnaryNode; 106 import jdk.nashorn.internal.ir.VarNode; 107 import jdk.nashorn.internal.ir.WhileNode; 108 import jdk.nashorn.internal.ir.WithNode; 109 import jdk.nashorn.internal.ir.debug.ASTWriter; 110 import jdk.nashorn.internal.ir.visitor.NodeOperatorVisitor; 111 import jdk.nashorn.internal.ir.visitor.NodeVisitor; 112 import jdk.nashorn.internal.parser.Lexer.RegexToken; 113 import jdk.nashorn.internal.parser.TokenType; 114 import jdk.nashorn.internal.runtime.Context; 115 import jdk.nashorn.internal.runtime.Debug; 116 import jdk.nashorn.internal.runtime.DebugLogger; 117 import jdk.nashorn.internal.runtime.ECMAException; 118 import jdk.nashorn.internal.runtime.JSType; 119 import jdk.nashorn.internal.runtime.Property; 120 import jdk.nashorn.internal.runtime.PropertyMap; 121 import jdk.nashorn.internal.runtime.RecompilableScriptFunctionData; 122 import jdk.nashorn.internal.runtime.Scope; 123 import jdk.nashorn.internal.runtime.ScriptFunction; 124 import jdk.nashorn.internal.runtime.ScriptObject; 125 import jdk.nashorn.internal.runtime.ScriptRuntime; 126 import jdk.nashorn.internal.runtime.Source; 127 import jdk.nashorn.internal.runtime.Undefined; 128 import jdk.nashorn.internal.runtime.linker.LinkerCallSite; 129 130 /** 131 * This is the lowest tier of the code generator. It takes lowered ASTs emitted 132 * from Lower and emits Java byte code. The byte code emission logic is broken 133 * out into MethodEmitter. MethodEmitter works internally with a type stack, and 134 * keeps track of the contents of the byte code stack. This way we avoid a large 135 * number of special cases on the form 136 * <pre> 137 * if (type == INT) { 138 * visitInsn(ILOAD, slot); 139 * } else if (type == DOUBLE) { 140 * visitInsn(DOUBLE, slot); 141 * } 142 * </pre> 143 * This quickly became apparent when the code generator was generalized to work 144 * with all types, and not just numbers or objects. 145 * <p> 146 * The CodeGenerator visits nodes only once, tags them as resolved and emits 147 * bytecode for them. 148 */ 149 final class CodeGenerator extends NodeOperatorVisitor<CodeGeneratorLexicalContext> { 150 151 /** Name of the Global object, cannot be referred to as .class, @see CodeGenerator */ 152 private static final String GLOBAL_OBJECT = Compiler.OBJECTS_PACKAGE + '/' + "Global"; 153 154 /** Name of the ScriptFunctionImpl, cannot be referred to as .class @see FunctionObjectCreator */ 155 private static final String SCRIPTFUNCTION_IMPL_OBJECT = Compiler.OBJECTS_PACKAGE + '/' + "ScriptFunctionImpl"; 156 157 /** Constant data & installation. The only reason the compiler keeps this is because it is assigned 158 * by reflection in class installation */ 159 private final Compiler compiler; 160 161 /** Call site flags given to the code generator to be used for all generated call sites */ 162 private final int callSiteFlags; 163 164 /** How many regexp fields have been emitted */ 165 private int regexFieldCount; 166 167 /** Line number for last statement. If we encounter a new line number, line number bytecode information 168 * needs to be generated */ 169 private int lastLineNumber = -1; 170 171 /** When should we stop caching regexp expressions in fields to limit bytecode size? */ 172 private static final int MAX_REGEX_FIELDS = 2 * 1024; 173 174 /** Current method emitter */ 175 private MethodEmitter method; 176 177 /** Current compile unit */ 178 private CompileUnit unit; 179 180 private static final DebugLogger LOG = new DebugLogger("codegen", "nashorn.codegen.debug"); 181 182 183 /** 184 * Constructor. 185 * 186 * @param compiler 187 */ 188 CodeGenerator(final Compiler compiler) { 189 super(new CodeGeneratorLexicalContext()); 190 this.compiler = compiler; 191 this.callSiteFlags = compiler.getEnv()._callsite_flags; 192 } 193 194 /** 195 * Gets the call site flags, adding the strict flag if the current function 196 * being generated is in strict mode 197 * 198 * @return the correct flags for a call site in the current function 199 */ 200 int getCallSiteFlags() { 201 return lc.getCurrentFunction().isStrict() ? callSiteFlags | CALLSITE_STRICT : callSiteFlags; 202 } 203 204 /** 205 * Load an identity node 206 * 207 * @param identNode an identity node to load 208 * @return the method generator used 209 */ 210 private MethodEmitter loadIdent(final IdentNode identNode) { 211 final Symbol symbol = identNode.getSymbol(); 212 213 if (!symbol.isScope()) { 214 assert symbol.hasSlot() || symbol.isParam(); 215 return method.load(symbol); 216 } 217 218 final String name = symbol.getName(); 219 final Source source = lc.getCurrentFunction().getSource(); 220 221 if (CompilerConstants.__FILE__.name().equals(name)) { 222 return method.load(source.getName()); 223 } else if (CompilerConstants.__DIR__.name().equals(name)) { 224 return method.load(source.getBase()); 225 } else if (CompilerConstants.__LINE__.name().equals(name)) { 226 return method.load(source.getLine(identNode.position())).convert(Type.OBJECT); 227 } else { 228 assert identNode.getSymbol().isScope() : identNode + " is not in scope!"; 229 230 final int flags = CALLSITE_SCOPE | getCallSiteFlags(); 231 method.loadCompilerConstant(SCOPE); 232 233 if (isFastScope(symbol)) { 234 // Only generate shared scope getter for fast-scope symbols so we know we can dial in correct scope. 235 if (symbol.getUseCount() > SharedScopeCall.FAST_SCOPE_GET_THRESHOLD) { 236 return loadSharedScopeVar(identNode.getType(), symbol, flags); 237 } 238 return loadFastScopeVar(identNode.getType(), symbol, flags, identNode.isFunction()); 239 } 240 return method.dynamicGet(identNode.getType(), identNode.getName(), flags, identNode.isFunction()); 241 } 242 } 243 244 /** 245 * Check if this symbol can be accessed directly with a putfield or getfield or dynamic load 246 * 247 * @param function function to check for fast scope 248 * @return true if fast scope 249 */ 250 private boolean isFastScope(final Symbol symbol) { 251 if (!symbol.isScope()) { 252 return false; 253 } 254 255 if (!lc.inDynamicScope()) { 256 // If there's no with or eval in context, and the symbol is marked as scoped, it is fast scoped. Such a 257 // symbol must either be global, or its defining block must need scope. 258 assert symbol.isGlobal() || lc.getDefiningBlock(symbol).needsScope() : symbol.getName(); 259 return true; 260 } 261 262 if (symbol.isGlobal()) { 263 // Shortcut: if there's a with or eval in context, globals can't be fast scoped 264 return false; 265 } 266 267 // Otherwise, check if there's a dynamic scope between use of the symbol and its definition 268 final String name = symbol.getName(); 269 boolean previousWasBlock = false; 270 for (final Iterator<LexicalContextNode> it = lc.getAllNodes(); it.hasNext();) { 271 final LexicalContextNode node = it.next(); 272 if (node instanceof Block) { 273 // If this block defines the symbol, then we can fast scope the symbol. 274 final Block block = (Block)node; 275 if (block.getExistingSymbol(name) == symbol) { 276 assert block.needsScope(); 277 return true; 278 } 279 previousWasBlock = true; 280 } else { 281 if ((node instanceof WithNode && previousWasBlock) || (node instanceof FunctionNode && CodeGeneratorLexicalContext.isFunctionDynamicScope((FunctionNode)node))) { 282 // If we hit a scope that can have symbols introduced into it at run time before finding the defining 283 // block, the symbol can't be fast scoped. A WithNode only counts if we've immediately seen a block 284 // before - its block. Otherwise, we are currently processing the WithNode's expression, and that's 285 // obviously not subjected to introducing new symbols. 286 return false; 287 } 288 previousWasBlock = false; 289 } 290 } 291 // Should've found the symbol defined in a block 292 throw new AssertionError(); 293 } 294 295 private MethodEmitter loadSharedScopeVar(final Type valueType, final Symbol symbol, final int flags) { 296 method.load(isFastScope(symbol) ? getScopeProtoDepth(lc.getCurrentBlock(), symbol) : -1); 297 final SharedScopeCall scopeCall = lc.getScopeGet(unit, valueType, symbol, flags | CALLSITE_FAST_SCOPE); 298 return scopeCall.generateInvoke(method); 299 } 300 301 private MethodEmitter loadFastScopeVar(final Type valueType, final Symbol symbol, final int flags, final boolean isMethod) { 302 loadFastScopeProto(symbol, false); 303 return method.dynamicGet(valueType, symbol.getName(), flags | CALLSITE_FAST_SCOPE, isMethod); 304 } 305 306 private MethodEmitter storeFastScopeVar(final Type valueType, final Symbol symbol, final int flags) { 307 loadFastScopeProto(symbol, true); 308 method.dynamicSet(valueType, symbol.getName(), flags | CALLSITE_FAST_SCOPE); 309 return method; 310 } 311 312 private int getScopeProtoDepth(final Block startingBlock, final Symbol symbol) { 313 int depth = 0; 314 final String name = symbol.getName(); 315 for(final Iterator<Block> blocks = lc.getBlocks(startingBlock); blocks.hasNext();) { 316 final Block currentBlock = blocks.next(); 317 if (currentBlock.getExistingSymbol(name) == symbol) { 318 return depth; 319 } 320 if (currentBlock.needsScope()) { 321 ++depth; 322 } 323 } 324 return -1; 325 } 326 327 private void loadFastScopeProto(final Symbol symbol, final boolean swap) { 328 final int depth = getScopeProtoDepth(lc.getCurrentBlock(), symbol); 329 assert depth != -1; 330 if (depth > 0) { 331 if (swap) { 332 method.swap(); 333 } 334 for (int i = 0; i < depth; i++) { 335 method.invoke(ScriptObject.GET_PROTO); 336 } 337 if (swap) { 338 method.swap(); 339 } 340 } 341 } 342 343 /** 344 * Generate code that loads this node to the stack. This method is only 345 * public to be accessible from the maps sub package. Do not call externally 346 * 347 * @param node node to load 348 * 349 * @return the method emitter used 350 */ 351 MethodEmitter load(final Node node) { 352 return load(node, false); 353 } 354 355 private MethodEmitter load(final Node node, final boolean baseAlreadyOnStack) { 356 final Symbol symbol = node.getSymbol(); 357 358 // If we lack symbols, we just generate what we see. 359 if (symbol == null) { 360 node.accept(this); 361 return method; 362 } 363 364 /* 365 * The load may be of type IdentNode, e.g. "x", AccessNode, e.g. "x.y" 366 * or IndexNode e.g. "x[y]". Both AccessNodes and IndexNodes are 367 * BaseNodes and the logic for loading the base object is reused 368 */ 369 final CodeGenerator codegen = this; 370 371 node.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) { 372 @Override 373 public boolean enterIdentNode(final IdentNode identNode) { 374 loadIdent(identNode); 375 return false; 376 } 377 378 @Override 379 public boolean enterAccessNode(final AccessNode accessNode) { 380 if (!baseAlreadyOnStack) { 381 load(accessNode.getBase()).convert(Type.OBJECT); 382 } 383 assert method.peekType().isObject(); 384 method.dynamicGet(node.getType(), accessNode.getProperty().getName(), getCallSiteFlags(), accessNode.isFunction()); 385 return false; 386 } 387 388 @Override 389 public boolean enterIndexNode(final IndexNode indexNode) { 390 if (!baseAlreadyOnStack) { 391 load(indexNode.getBase()).convert(Type.OBJECT); 392 load(indexNode.getIndex()); 393 } 394 method.dynamicGetIndex(node.getType(), getCallSiteFlags(), indexNode.isFunction()); 395 return false; 396 } 397 398 @Override 399 public boolean enterFunctionNode(FunctionNode functionNode) { 400 // function nodes will always leave a constructed function object on stack, no need to load the symbol 401 // separately as in enterDefault() 402 functionNode.accept(codegen); 403 return false; 404 } 405 406 @Override 407 public boolean enterDefault(final Node otherNode) { 408 otherNode.accept(codegen); // generate code for whatever we are looking at. 409 method.load(symbol); // load the final symbol to the stack (or nop if no slot, then result is already there) 410 return false; 411 } 412 }); 413 414 return method; 415 } 416 417 @Override 418 public boolean enterAccessNode(final AccessNode accessNode) { 419 load(accessNode); 420 return false; 421 } 422 423 /** 424 * Initialize a specific set of vars to undefined. This has to be done at 425 * the start of each method for local variables that aren't passed as 426 * parameters. 427 * 428 * @param symbols list of symbols. 429 */ 430 private void initSymbols(final Iterable<Symbol> symbols) { 431 final LinkedList<Symbol> numbers = new LinkedList<>(); 432 final LinkedList<Symbol> objects = new LinkedList<>(); 433 434 for (final Symbol symbol : symbols) { 435 /* 436 * The following symbols are guaranteed to be defined and thus safe 437 * from having undefined written to them: parameters internals this 438 * 439 * Otherwise we must, unless we perform control/escape analysis, 440 * assign them undefined. 441 */ 442 final boolean isInternal = symbol.isParam() || symbol.isInternal() || symbol.isThis() || !symbol.canBeUndefined(); 443 444 if (symbol.hasSlot() && !isInternal) { 445 assert symbol.getSymbolType().isNumber() || symbol.getSymbolType().isObject() : "no potentially undefined narrower local vars than doubles are allowed: " + symbol + " in " + lc.getCurrentFunction(); 446 if (symbol.getSymbolType().isNumber()) { 447 numbers.add(symbol); 448 } else if (symbol.getSymbolType().isObject()) { 449 objects.add(symbol); 450 } 451 } 452 } 453 454 initSymbols(numbers, Type.NUMBER); 455 initSymbols(objects, Type.OBJECT); 456 } 457 458 private void initSymbols(final LinkedList<Symbol> symbols, final Type type) { 459 if (symbols.isEmpty()) { 460 return; 461 } 462 463 method.loadUndefined(type); 464 while (!symbols.isEmpty()) { 465 final Symbol symbol = symbols.removeFirst(); 466 if (!symbols.isEmpty()) { 467 method.dup(); 468 } 469 method.store(symbol); 470 } 471 } 472 473 /** 474 * Create symbol debug information. 475 * 476 * @param block block containing symbols. 477 */ 478 private void symbolInfo(final Block block) { 479 for (final Symbol symbol : block.getSymbols()) { 480 if (symbol.hasSlot()) { 481 method.localVariable(symbol, block.getEntryLabel(), block.getBreakLabel()); 482 } 483 } 484 } 485 486 @Override 487 public boolean enterBlock(final Block block) { 488 method.label(block.getEntryLabel()); 489 initLocals(block); 490 491 return true; 492 } 493 494 @Override 495 public Node leaveBlock(final Block block) { 496 method.label(block.getBreakLabel()); 497 symbolInfo(block); 498 499 if (block.needsScope() && !block.isTerminal()) { 500 popBlockScope(block); 501 } 502 return block; 503 } 504 505 private void popBlockScope(final Block block) { 506 final Label exitLabel = new Label("block_exit"); 507 final Label recoveryLabel = new Label("block_catch"); 508 final Label skipLabel = new Label("skip_catch"); 509 510 /* pop scope a la try-finally */ 511 method.loadCompilerConstant(SCOPE); 512 method.invoke(ScriptObject.GET_PROTO); 513 method.storeCompilerConstant(SCOPE); 514 method._goto(skipLabel); 515 method.label(exitLabel); 516 517 method._catch(recoveryLabel); 518 method.loadCompilerConstant(SCOPE); 519 method.invoke(ScriptObject.GET_PROTO); 520 method.storeCompilerConstant(SCOPE); 521 method.athrow(); 522 method.label(skipLabel); 523 method._try(block.getEntryLabel(), exitLabel, recoveryLabel, Throwable.class); 524 } 525 526 @Override 527 public boolean enterBreakNode(final BreakNode breakNode) { 528 lineNumber(breakNode); 529 530 final BreakableNode breakFrom = lc.getBreakable(breakNode.getLabel()); 531 for (int i = 0; i < lc.getScopeNestingLevelTo(breakFrom); i++) { 532 closeWith(); 533 } 534 method.splitAwareGoto(lc, breakFrom.getBreakLabel()); 535 536 return false; 537 } 538 539 private int loadArgs(final List<Node> args) { 540 return loadArgs(args, null, false, args.size()); 541 } 542 543 private int loadArgs(final List<Node> args, final String signature, final boolean isVarArg, final int argCount) { 544 // arg have already been converted to objects here. 545 if (isVarArg || argCount > LinkerCallSite.ARGLIMIT) { 546 loadArgsArray(args); 547 return 1; 548 } 549 550 // pad with undefined if size is too short. argCount is the real number of args 551 int n = 0; 552 final Type[] params = signature == null ? null : Type.getMethodArguments(signature); 553 for (final Node arg : args) { 554 assert arg != null; 555 load(arg); 556 if (n >= argCount) { 557 method.pop(); // we had to load the arg for its side effects 558 } else if (params != null) { 559 method.convert(params[n]); 560 } 561 n++; 562 } 563 564 while (n < argCount) { 565 method.loadUndefined(Type.OBJECT); 566 n++; 567 } 568 569 return argCount; 570 } 571 572 @Override 573 public boolean enterCallNode(final CallNode callNode) { 574 lineNumber(callNode); 575 576 final List<Node> args = callNode.getArgs(); 577 final Node function = callNode.getFunction(); 578 final Block currentBlock = lc.getCurrentBlock(); 579 final CodeGeneratorLexicalContext codegenLexicalContext = lc; 580 581 function.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) { 582 583 private MethodEmitter sharedScopeCall(final IdentNode identNode, final int flags) { 584 final Symbol symbol = identNode.getSymbol(); 585 int scopeCallFlags = flags; 586 method.loadCompilerConstant(SCOPE); 587 if (isFastScope(symbol)) { 588 method.load(getScopeProtoDepth(currentBlock, symbol)); 589 scopeCallFlags |= CALLSITE_FAST_SCOPE; 590 } else { 591 method.load(-1); // Bypass fast-scope code in shared callsite 592 } 593 loadArgs(args); 594 final Type[] paramTypes = method.getTypesFromStack(args.size()); 595 final SharedScopeCall scopeCall = codegenLexicalContext.getScopeCall(unit, symbol, identNode.getType(), callNode.getType(), paramTypes, scopeCallFlags); 596 return scopeCall.generateInvoke(method); 597 } 598 599 private void scopeCall(final IdentNode node, final int flags) { 600 load(node); 601 method.convert(Type.OBJECT); // foo() makes no sense if foo == 3 602 // ScriptFunction will see CALLSITE_SCOPE and will bind scope accordingly. 603 method.loadNull(); //the 'this' 604 method.dynamicCall(callNode.getType(), 2 + loadArgs(args), flags); 605 } 606 607 private void evalCall(final IdentNode node, final int flags) { 608 load(node); 609 method.convert(Type.OBJECT); // foo() makes no sense if foo == 3 610 611 final Label not_eval = new Label("not_eval"); 612 final Label eval_done = new Label("eval_done"); 613 614 // check if this is the real built-in eval 615 method.dup(); 616 globalIsEval(); 617 618 method.ifeq(not_eval); 619 // We don't need ScriptFunction object for 'eval' 620 method.pop(); 621 622 method.loadCompilerConstant(SCOPE); // Load up self (scope). 623 624 final CallNode.EvalArgs evalArgs = callNode.getEvalArgs(); 625 // load evaluated code 626 load(evalArgs.getCode()); 627 method.convert(Type.OBJECT); 628 // special/extra 'eval' arguments 629 load(evalArgs.getThis()); 630 method.load(evalArgs.getLocation()); 631 method.load(evalArgs.getStrictMode()); 632 method.convert(Type.OBJECT); 633 634 // direct call to Global.directEval 635 globalDirectEval(); 636 method.convert(callNode.getType()); 637 method._goto(eval_done); 638 639 method.label(not_eval); 640 // This is some scope 'eval' or global eval replaced by user 641 // but not the built-in ECMAScript 'eval' function call 642 method.loadNull(); 643 method.dynamicCall(callNode.getType(), 2 + loadArgs(args), flags); 644 645 method.label(eval_done); 646 } 647 648 @Override 649 public boolean enterIdentNode(final IdentNode node) { 650 final Symbol symbol = node.getSymbol(); 651 652 if (symbol.isScope()) { 653 final int flags = getCallSiteFlags() | CALLSITE_SCOPE; 654 final int useCount = symbol.getUseCount(); 655 656 // Threshold for generating shared scope callsite is lower for fast scope symbols because we know 657 // we can dial in the correct scope. However, we also need to enable it for non-fast scopes to 658 // support huge scripts like mandreel.js. 659 if (callNode.isEval()) { 660 evalCall(node, flags); 661 } else if (useCount <= SharedScopeCall.FAST_SCOPE_CALL_THRESHOLD 662 || (!isFastScope(symbol) && useCount <= SharedScopeCall.SLOW_SCOPE_CALL_THRESHOLD) 663 || CodeGenerator.this.lc.inDynamicScope()) { 664 scopeCall(node, flags); 665 } else { 666 sharedScopeCall(node, flags); 667 } 668 assert method.peekType().equals(callNode.getType()) : method.peekType() + "!=" + callNode.getType(); 669 } else { 670 enterDefault(node); 671 } 672 673 return false; 674 } 675 676 @Override 677 public boolean enterAccessNode(final AccessNode node) { 678 load(node.getBase()); 679 method.convert(Type.OBJECT); 680 method.dup(); 681 method.dynamicGet(node.getType(), node.getProperty().getName(), getCallSiteFlags(), true); 682 method.swap(); 683 method.dynamicCall(callNode.getType(), 2 + loadArgs(args), getCallSiteFlags()); 684 assert method.peekType().equals(callNode.getType()); 685 686 return false; 687 } 688 689 @Override 690 public boolean enterFunctionNode(final FunctionNode origCallee) { 691 // NOTE: visiting the callee will leave a constructed ScriptFunction object on the stack if 692 // callee.needsCallee() == true 693 final FunctionNode callee = (FunctionNode)origCallee.accept(CodeGenerator.this); 694 695 final boolean isVarArg = callee.isVarArg(); 696 final int argCount = isVarArg ? -1 : callee.getParameters().size(); 697 698 final String signature = new FunctionSignature(true, callee.needsCallee(), callee.getReturnType(), isVarArg ? null : callee.getParameters()).toString(); 699 700 if (callee.isStrict()) { // self is undefined 701 method.loadUndefined(Type.OBJECT); 702 } else { // get global from scope (which is the self) 703 globalInstance(); 704 } 705 loadArgs(args, signature, isVarArg, argCount); 706 assert callee.getCompileUnit() != null : "no compile unit for " + callee.getName() + " " + Debug.id(callee) + " " + callNode; 707 method.invokestatic(callee.getCompileUnit().getUnitClassName(), callee.getName(), signature); 708 assert method.peekType().equals(callee.getReturnType()) : method.peekType() + " != " + callee.getReturnType(); 709 return false; 710 } 711 712 @Override 713 public boolean enterIndexNode(final IndexNode node) { 714 load(node.getBase()); 715 method.convert(Type.OBJECT); 716 method.dup(); 717 load(node.getIndex()); 718 final Type indexType = node.getIndex().getType(); 719 if (indexType.isObject() || indexType.isBoolean()) { 720 method.convert(Type.OBJECT); //TODO 721 } 722 method.dynamicGetIndex(node.getType(), getCallSiteFlags(), true); 723 method.swap(); 724 method.dynamicCall(callNode.getType(), 2 + loadArgs(args), getCallSiteFlags()); 725 assert method.peekType().equals(callNode.getType()); 726 727 return false; 728 } 729 730 @Override 731 protected boolean enterDefault(final Node node) { 732 // Load up function. 733 load(function); 734 method.convert(Type.OBJECT); //TODO, e.g. booleans can be used as functions 735 method.loadNull(); // ScriptFunction will figure out the correct this when it sees CALLSITE_SCOPE 736 method.dynamicCall(callNode.getType(), 2 + loadArgs(args), getCallSiteFlags() | CALLSITE_SCOPE); 737 assert method.peekType().equals(callNode.getType()); 738 739 return false; 740 } 741 }); 742 743 method.store(callNode.getSymbol()); 744 745 return false; 746 } 747 748 @Override 749 public boolean enterContinueNode(final ContinueNode continueNode) { 750 lineNumber(continueNode); 751 752 final LoopNode continueTo = lc.getContinueTo(continueNode.getLabel()); 753 for (int i = 0; i < lc.getScopeNestingLevelTo(continueTo); i++) { 754 closeWith(); 755 } 756 method.splitAwareGoto(lc, continueTo.getContinueLabel()); 757 758 return false; 759 } 760 761 @Override 762 public boolean enterEmptyNode(final EmptyNode emptyNode) { 763 lineNumber(emptyNode); 764 765 return false; 766 } 767 768 @Override 769 public boolean enterExecuteNode(final ExecuteNode executeNode) { 770 lineNumber(executeNode); 771 772 final Node expression = executeNode.getExpression(); 773 expression.accept(this); 774 775 return false; 776 } 777 778 @Override 779 public boolean enterForNode(final ForNode forNode) { 780 lineNumber(forNode); 781 782 if (forNode.isForIn()) { 783 enterForIn(forNode); 784 } else { 785 enterFor(forNode); 786 } 787 788 return false; 789 } 790 791 private void enterFor(final ForNode forNode) { 792 final Node init = forNode.getInit(); 793 final Node test = forNode.getTest(); 794 final Block body = forNode.getBody(); 795 final Node modify = forNode.getModify(); 796 797 if (init != null) { 798 init.accept(this); 799 } 800 801 final Label loopLabel = new Label("loop"); 802 final Label testLabel = new Label("test"); 803 804 method._goto(testLabel); 805 method.label(loopLabel); 806 body.accept(this); 807 method.label(forNode.getContinueLabel()); 808 809 if (!body.isTerminal() && modify != null) { 810 load(modify); 811 } 812 813 method.label(testLabel); 814 if (test != null) { 815 new BranchOptimizer(this, method).execute(test, loopLabel, true); 816 } else { 817 method._goto(loopLabel); 818 } 819 820 method.label(forNode.getBreakLabel()); 821 } 822 823 private void enterForIn(final ForNode forNode) { 824 final Block body = forNode.getBody(); 825 final Node modify = forNode.getModify(); 826 827 final Symbol iter = forNode.getIterator(); 828 final Label loopLabel = new Label("loop"); 829 830 Node init = forNode.getInit(); 831 832 // We have to evaluate the optional initializer expression 833 // of the iterator variable of the for-in statement. 834 if (init instanceof VarNode) { 835 init.accept(this); 836 init = ((VarNode)init).getName(); 837 } 838 839 load(modify); 840 assert modify.getType().isObject(); 841 method.invoke(forNode.isForEach() ? ScriptRuntime.TO_VALUE_ITERATOR : ScriptRuntime.TO_PROPERTY_ITERATOR); 842 method.store(iter); 843 method._goto(forNode.getContinueLabel()); 844 method.label(loopLabel); 845 846 new Store<Node>(init) { 847 @Override 848 protected void storeNonDiscard() { 849 return; 850 } 851 @Override 852 protected void evaluate() { 853 method.load(iter); 854 method.invoke(interfaceCallNoLookup(Iterator.class, "next", Object.class)); 855 } 856 }.store(); 857 858 body.accept(this); 859 860 method.label(forNode.getContinueLabel()); 861 method.load(iter); 862 method.invoke(interfaceCallNoLookup(Iterator.class, "hasNext", boolean.class)); 863 method.ifne(loopLabel); 864 method.label(forNode.getBreakLabel()); 865 } 866 867 /** 868 * Initialize the slots in a frame to undefined. 869 * 870 * @param block block with local vars. 871 */ 872 private void initLocals(final Block block) { 873 lc.nextFreeSlot(block); 874 875 final boolean isFunctionBody = lc.isFunctionBody(); 876 877 final FunctionNode function = lc.getCurrentFunction(); 878 if (isFunctionBody) { 879 /* Fix the predefined slots so they have numbers >= 0, like varargs. */ 880 if (function.needsParentScope()) { 881 initParentScope(); 882 } 883 if (function.needsArguments()) { 884 initArguments(function); 885 } 886 } 887 888 /* 889 * Determine if block needs scope, if not, just do initSymbols for this block. 890 */ 891 if (block.needsScope()) { 892 /* 893 * Determine if function is varargs and consequently variables have to 894 * be in the scope. 895 */ 896 final boolean varsInScope = function.allVarsInScope(); 897 898 // TODO for LET we can do better: if *block* does not contain any eval/with, we don't need its vars in scope. 899 900 final List<String> nameList = new ArrayList<>(); 901 final List<Symbol> locals = new ArrayList<>(); 902 903 // Initalize symbols and values 904 final List<Symbol> newSymbols = new ArrayList<>(); 905 final List<Symbol> values = new ArrayList<>(); 906 907 final boolean hasArguments = function.needsArguments(); 908 909 for (final Symbol symbol : block.getSymbols()) { 910 911 if (symbol.isInternal() || symbol.isThis() || symbol.isTemp()) { 912 continue; 913 } 914 915 if (symbol.isVar()) { 916 if (varsInScope || symbol.isScope()) { 917 nameList.add(symbol.getName()); 918 newSymbols.add(symbol); 919 values.add(null); 920 assert symbol.isScope() : "scope for " + symbol + " should have been set in Lower already " + function.getName(); 921 assert !symbol.hasSlot() : "slot for " + symbol + " should have been removed in Lower already" + function.getName(); 922 } else { 923 assert symbol.hasSlot() : symbol + " should have a slot only, no scope"; 924 locals.add(symbol); 925 } 926 } else if (symbol.isParam() && (varsInScope || hasArguments || symbol.isScope())) { 927 nameList.add(symbol.getName()); 928 newSymbols.add(symbol); 929 values.add(hasArguments ? null : symbol); 930 assert symbol.isScope() : "scope for " + symbol + " should have been set in Lower already " + function.getName() + " varsInScope="+varsInScope+" hasArguments="+hasArguments+" symbol.isScope()=" + symbol.isScope(); 931 assert !(hasArguments && symbol.hasSlot()) : "slot for " + symbol + " should have been removed in Lower already " + function.getName(); 932 } 933 } 934 935 // we may have locals that need to be initialized 936 initSymbols(locals); 937 938 /* 939 * Create a new object based on the symbols and values, generate 940 * bootstrap code for object 941 */ 942 final FieldObjectCreator<Symbol> foc = new FieldObjectCreator<Symbol>(this, nameList, newSymbols, values, true, hasArguments) { 943 @Override 944 protected Type getValueType(final Symbol value) { 945 return value.getSymbolType(); 946 } 947 948 @Override 949 protected void loadValue(final Symbol value) { 950 method.load(value); 951 } 952 953 @Override 954 protected void loadScope(MethodEmitter m) { 955 if (function.needsParentScope()) { 956 m.loadCompilerConstant(SCOPE); 957 } else { 958 m.loadNull(); 959 } 960 } 961 }; 962 foc.makeObject(method); 963 964 // runScript(): merge scope into global 965 if (isFunctionBody && function.isProgram()) { 966 method.invoke(ScriptRuntime.MERGE_SCOPE); 967 } 968 969 method.storeCompilerConstant(SCOPE); 970 } else { 971 // Since we don't have a scope, parameters didn't get assigned array indices by the FieldObjectCreator, so 972 // we need to assign them separately here. 973 int nextParam = 0; 974 if (isFunctionBody && function.isVarArg()) { 975 for (final IdentNode param : function.getParameters()) { 976 param.getSymbol().setFieldIndex(nextParam++); 977 } 978 } 979 980 initSymbols(block.getSymbols()); 981 } 982 983 // Debugging: print symbols? @see --print-symbols flag 984 printSymbols(block, (isFunctionBody ? "Function " : "Block in ") + (function.getIdent() == null ? "<anonymous>" : function.getIdent().getName())); 985 } 986 987 private void initArguments(final FunctionNode function) { 988 method.loadCompilerConstant(VARARGS); 989 if (function.needsCallee()) { 990 method.loadCompilerConstant(CALLEE); 991 } else { 992 // If function is strict mode, "arguments.callee" is not populated, so we don't necessarily need the 993 // caller. 994 assert function.isStrict(); 995 method.loadNull(); 996 } 997 method.load(function.getParameters().size()); 998 globalAllocateArguments(); 999 method.storeCompilerConstant(ARGUMENTS); 1000 } 1001 1002 private void initParentScope() { 1003 method.loadCompilerConstant(CALLEE); 1004 method.invoke(ScriptFunction.GET_SCOPE); 1005 method.storeCompilerConstant(SCOPE); 1006 } 1007 1008 @Override 1009 public boolean enterFunctionNode(final FunctionNode functionNode) { 1010 if (functionNode.isLazy()) { 1011 // Must do it now; can't postpone it until leaveFunctionNode() 1012 newFunctionObject(functionNode, functionNode); 1013 return false; 1014 } 1015 1016 LOG.info("=== BEGIN ", functionNode.getName()); 1017 1018 assert functionNode.getCompileUnit() != null : "no compile unit for " + functionNode.getName() + " " + Debug.id(functionNode); 1019 unit = lc.pushCompileUnit(functionNode.getCompileUnit()); 1020 assert lc.hasCompileUnits(); 1021 1022 method = lc.pushMethodEmitter(unit.getClassEmitter().method(functionNode)); 1023 // Mark end for variable tables. 1024 method.begin(); 1025 1026 return true; 1027 } 1028 1029 @Override 1030 public Node leaveFunctionNode(final FunctionNode functionNode) { 1031 try { 1032 method.end(); // wrap up this method 1033 unit = lc.popCompileUnit(functionNode.getCompileUnit()); 1034 method = lc.popMethodEmitter(method); 1035 LOG.info("=== END ", functionNode.getName()); 1036 1037 final FunctionNode newFunctionNode = functionNode.setState(lc, CompilationState.EMITTED); 1038 1039 newFunctionObject(newFunctionNode, functionNode); 1040 return newFunctionNode; 1041 } catch (final Throwable t) { 1042 Context.printStackTrace(t); 1043 final VerifyError e = new VerifyError("Code generation bug in \"" + functionNode.getName() + "\": likely stack misaligned: " + t + " " + functionNode.getSource().getName()); 1044 e.initCause(t); 1045 throw e; 1046 } 1047 } 1048 1049 @Override 1050 public boolean enterIdentNode(final IdentNode identNode) { 1051 return false; 1052 } 1053 1054 @Override 1055 public boolean enterIfNode(final IfNode ifNode) { 1056 lineNumber(ifNode); 1057 1058 final Node test = ifNode.getTest(); 1059 final Block pass = ifNode.getPass(); 1060 final Block fail = ifNode.getFail(); 1061 1062 final Label failLabel = new Label("if_fail"); 1063 final Label afterLabel = fail == null ? failLabel : new Label("if_done"); 1064 1065 new BranchOptimizer(this, method).execute(test, failLabel, false); 1066 1067 boolean passTerminal = false; 1068 boolean failTerminal = false; 1069 1070 pass.accept(this); 1071 if (!pass.hasTerminalFlags()) { 1072 method._goto(afterLabel); //don't fallthru to fail block 1073 } else { 1074 passTerminal = pass.isTerminal(); 1075 } 1076 1077 if (fail != null) { 1078 method.label(failLabel); 1079 fail.accept(this); 1080 failTerminal = fail.isTerminal(); 1081 } 1082 1083 //if if terminates, put the after label there 1084 if (!passTerminal || !failTerminal) { 1085 method.label(afterLabel); 1086 } 1087 1088 return false; 1089 } 1090 1091 @Override 1092 public boolean enterIndexNode(final IndexNode indexNode) { 1093 load(indexNode); 1094 return false; 1095 } 1096 1097 private void lineNumber(final Statement statement) { 1098 final int lineNumber = statement.getLineNumber(); 1099 if (lineNumber != lastLineNumber) { 1100 method.lineNumber(statement.getLineNumber()); 1101 } 1102 lastLineNumber = lineNumber; 1103 } 1104 1105 /** 1106 * Load a list of nodes as an array of a specific type 1107 * The array will contain the visited nodes. 1108 * 1109 * @param arrayLiteralNode the array of contents 1110 * @param arrayType the type of the array, e.g. ARRAY_NUMBER or ARRAY_OBJECT 1111 * 1112 * @return the method generator that was used 1113 */ 1114 private MethodEmitter loadArray(final ArrayLiteralNode arrayLiteralNode, final ArrayType arrayType) { 1115 assert arrayType == Type.INT_ARRAY || arrayType == Type.NUMBER_ARRAY || arrayType == Type.OBJECT_ARRAY; 1116 1117 final Node[] nodes = arrayLiteralNode.getValue(); 1118 final Object presets = arrayLiteralNode.getPresets(); 1119 final int[] postsets = arrayLiteralNode.getPostsets(); 1120 final Class<?> type = arrayType.getTypeClass(); 1121 final List<ArrayUnit> units = arrayLiteralNode.getUnits(); 1122 1123 loadConstant(presets); 1124 1125 final Type elementType = arrayType.getElementType(); 1126 1127 if (units != null) { 1128 final MethodEmitter savedMethod = method; 1129 1130 for (final ArrayUnit arrayUnit : units) { 1131 unit = lc.pushCompileUnit(arrayUnit.getCompileUnit()); 1132 1133 final String className = unit.getUnitClassName(); 1134 final String name = lc.getCurrentFunction().uniqueName(SPLIT_PREFIX.symbolName()); 1135 final String signature = methodDescriptor(type, Object.class, ScriptFunction.class, ScriptObject.class, type); 1136 1137 final MethodEmitter me = unit.getClassEmitter().method(EnumSet.of(Flag.PUBLIC, Flag.STATIC), name, signature); 1138 method = lc.pushMethodEmitter(me); 1139 1140 method.setFunctionNode(lc.getCurrentFunction()); 1141 method.begin(); 1142 1143 fixScopeSlot(); 1144 1145 method.load(arrayType, SPLIT_ARRAY_ARG.slot()); 1146 1147 for (int i = arrayUnit.getLo(); i < arrayUnit.getHi(); i++) { 1148 storeElement(nodes, elementType, postsets[i]); 1149 } 1150 1151 method._return(); 1152 method.end(); 1153 method = lc.popMethodEmitter(me); 1154 1155 assert method == savedMethod; 1156 method.loadCompilerConstant(THIS); 1157 method.swap(); 1158 method.loadCompilerConstant(CALLEE); 1159 method.swap(); 1160 method.loadCompilerConstant(SCOPE); 1161 method.swap(); 1162 method.invokestatic(className, name, signature); 1163 1164 unit = lc.popCompileUnit(unit); 1165 } 1166 1167 return method; 1168 } 1169 1170 for (final int postset : postsets) { 1171 storeElement(nodes, elementType, postset); 1172 } 1173 1174 return method; 1175 } 1176 1177 private void storeElement(final Node[] nodes, final Type elementType, final int index) { 1178 method.dup(); 1179 method.load(index); 1180 1181 final Node element = nodes[index]; 1182 1183 if (element == null) { 1184 method.loadEmpty(elementType); 1185 } else { 1186 assert elementType.isEquivalentTo(element.getType()) : "array element type doesn't match array type"; 1187 load(element); 1188 } 1189 1190 method.arraystore(); 1191 } 1192 1193 private MethodEmitter loadArgsArray(final List<Node> args) { 1194 final Object[] array = new Object[args.size()]; 1195 loadConstant(array); 1196 1197 for (int i = 0; i < args.size(); i++) { 1198 method.dup(); 1199 method.load(i); 1200 load(args.get(i)).convert(Type.OBJECT); //has to be upcast to object or we fail 1201 method.arraystore(); 1202 } 1203 1204 return method; 1205 } 1206 1207 /** 1208 * Load a constant from the constant array. This is only public to be callable from the objects 1209 * subpackage. Do not call directly. 1210 * 1211 * @param string string to load 1212 */ 1213 void loadConstant(final String string) { 1214 final String unitClassName = unit.getUnitClassName(); 1215 final ClassEmitter classEmitter = unit.getClassEmitter(); 1216 final int index = compiler.getConstantData().add(string); 1217 1218 method.load(index); 1219 method.invokestatic(unitClassName, GET_STRING.symbolName(), methodDescriptor(String.class, int.class)); 1220 classEmitter.needGetConstantMethod(String.class); 1221 } 1222 1223 /** 1224 * Load a constant from the constant array. This is only public to be callable from the objects 1225 * subpackage. Do not call directly. 1226 * 1227 * @param object object to load 1228 */ 1229 void loadConstant(final Object object) { 1230 final String unitClassName = unit.getUnitClassName(); 1231 final ClassEmitter classEmitter = unit.getClassEmitter(); 1232 final int index = compiler.getConstantData().add(object); 1233 final Class<?> cls = object.getClass(); 1234 1235 if (cls == PropertyMap.class) { 1236 method.load(index); 1237 method.invokestatic(unitClassName, GET_MAP.symbolName(), methodDescriptor(PropertyMap.class, int.class)); 1238 classEmitter.needGetConstantMethod(PropertyMap.class); 1239 } else if (cls.isArray()) { 1240 method.load(index); 1241 final String methodName = ClassEmitter.getArrayMethodName(cls); 1242 method.invokestatic(unitClassName, methodName, methodDescriptor(cls, int.class)); 1243 classEmitter.needGetConstantMethod(cls); 1244 } else { 1245 method.loadConstants().load(index).arrayload(); 1246 if (cls != Object.class) { 1247 method.checkcast(cls); 1248 } 1249 } 1250 } 1251 1252 // literal values 1253 private MethodEmitter load(final LiteralNode<?> node) { 1254 final Object value = node.getValue(); 1255 1256 if (value == null) { 1257 method.loadNull(); 1258 } else if (value instanceof Undefined) { 1259 method.loadUndefined(Type.OBJECT); 1260 } else if (value instanceof String) { 1261 final String string = (String)value; 1262 1263 if (string.length() > (MethodEmitter.LARGE_STRING_THRESHOLD / 3)) { // 3 == max bytes per encoded char 1264 loadConstant(string); 1265 } else { 1266 method.load(string); 1267 } 1268 } else if (value instanceof RegexToken) { 1269 loadRegex((RegexToken)value); 1270 } else if (value instanceof Boolean) { 1271 method.load((Boolean)value); 1272 } else if (value instanceof Integer) { 1273 method.load((Integer)value); 1274 } else if (value instanceof Long) { 1275 method.load((Long)value); 1276 } else if (value instanceof Double) { 1277 method.load((Double)value); 1278 } else if (node instanceof ArrayLiteralNode) { 1279 final ArrayType type = (ArrayType)node.getType(); 1280 loadArray((ArrayLiteralNode)node, type); 1281 globalAllocateArray(type); 1282 } else { 1283 assert false : "Unknown literal for " + node.getClass() + " " + value.getClass() + " " + value; 1284 } 1285 1286 return method; 1287 } 1288 1289 private MethodEmitter loadRegexToken(final RegexToken value) { 1290 method.load(value.getExpression()); 1291 method.load(value.getOptions()); 1292 return globalNewRegExp(); 1293 } 1294 1295 private MethodEmitter loadRegex(final RegexToken regexToken) { 1296 if (regexFieldCount > MAX_REGEX_FIELDS) { 1297 return loadRegexToken(regexToken); 1298 } 1299 // emit field 1300 final String regexName = lc.getCurrentFunction().uniqueName(REGEX_PREFIX.symbolName()); 1301 final ClassEmitter classEmitter = unit.getClassEmitter(); 1302 1303 classEmitter.field(EnumSet.of(PRIVATE, STATIC), regexName, Object.class); 1304 regexFieldCount++; 1305 1306 // get field, if null create new regex, finally clone regex object 1307 method.getStatic(unit.getUnitClassName(), regexName, typeDescriptor(Object.class)); 1308 method.dup(); 1309 final Label cachedLabel = new Label("cached"); 1310 method.ifnonnull(cachedLabel); 1311 1312 method.pop(); 1313 loadRegexToken(regexToken); 1314 method.dup(); 1315 method.putStatic(unit.getUnitClassName(), regexName, typeDescriptor(Object.class)); 1316 1317 method.label(cachedLabel); 1318 globalRegExpCopy(); 1319 1320 return method; 1321 } 1322 1323 @SuppressWarnings("rawtypes") 1324 @Override 1325 public boolean enterLiteralNode(final LiteralNode literalNode) { 1326 assert literalNode.getSymbol() != null : literalNode + " has no symbol"; 1327 load(literalNode).store(literalNode.getSymbol()); 1328 return false; 1329 } 1330 1331 @Override 1332 public boolean enterObjectNode(final ObjectNode objectNode) { 1333 final List<Node> elements = objectNode.getElements(); 1334 final int size = elements.size(); 1335 1336 final List<String> keys = new ArrayList<>(); 1337 final List<Symbol> symbols = new ArrayList<>(); 1338 final List<Node> values = new ArrayList<>(); 1339 1340 boolean hasGettersSetters = false; 1341 1342 for (int i = 0; i < size; i++) { 1343 final PropertyNode propertyNode = (PropertyNode)elements.get(i); 1344 final Node value = propertyNode.getValue(); 1345 final String key = propertyNode.getKeyName(); 1346 final Symbol symbol = value == null ? null : propertyNode.getSymbol(); 1347 1348 if (value == null) { 1349 hasGettersSetters = true; 1350 } 1351 1352 keys.add(key); 1353 symbols.add(symbol); 1354 values.add(value); 1355 } 1356 1357 new FieldObjectCreator<Node>(this, keys, symbols, values) { 1358 @Override 1359 protected Type getValueType(final Node node) { 1360 return node.getType(); 1361 } 1362 1363 @Override 1364 protected void loadValue(final Node node) { 1365 load(node); 1366 } 1367 1368 /** 1369 * Ensure that the properties start out as object types so that 1370 * we can do putfield initializations instead of dynamicSetIndex 1371 * which would be the case to determine initial property type 1372 * otherwise. 1373 * 1374 * Use case, it's very expensive to do a million var x = {a:obj, b:obj} 1375 * just to have to invalidate them immediately on initialization 1376 * 1377 * see NASHORN-594 1378 */ 1379 @Override 1380 protected MapCreator newMapCreator(final Class<?> fieldObjectClass) { 1381 return new MapCreator(fieldObjectClass, keys, symbols) { 1382 @Override 1383 protected int getPropertyFlags(final Symbol symbol, final boolean isVarArg) { 1384 return super.getPropertyFlags(symbol, isVarArg) | Property.IS_ALWAYS_OBJECT; 1385 } 1386 }; 1387 } 1388 1389 }.makeObject(method); 1390 1391 method.dup(); 1392 globalObjectPrototype(); 1393 method.invoke(ScriptObject.SET_PROTO); 1394 1395 if (!hasGettersSetters) { 1396 method.store(objectNode.getSymbol()); 1397 return false; 1398 } 1399 1400 for (final Node element : elements) { 1401 final PropertyNode propertyNode = (PropertyNode)element; 1402 final Object key = propertyNode.getKey(); 1403 final FunctionNode getter = propertyNode.getGetter(); 1404 final FunctionNode setter = propertyNode.getSetter(); 1405 1406 if (getter == null && setter == null) { 1407 continue; 1408 } 1409 1410 method.dup().loadKey(key); 1411 1412 if (getter == null) { 1413 method.loadNull(); 1414 } else { 1415 getter.accept(this); 1416 } 1417 1418 if (setter == null) { 1419 method.loadNull(); 1420 } else { 1421 setter.accept(this); 1422 } 1423 1424 method.invoke(ScriptObject.SET_USER_ACCESSORS); 1425 } 1426 1427 method.store(objectNode.getSymbol()); 1428 1429 return false; 1430 } 1431 1432 @Override 1433 public boolean enterReturnNode(final ReturnNode returnNode) { 1434 lineNumber(returnNode); 1435 1436 method.registerReturn(); 1437 1438 final Type returnType = lc.getCurrentFunction().getReturnType(); 1439 1440 final Node expression = returnNode.getExpression(); 1441 if (expression != null) { 1442 load(expression); 1443 } else { 1444 method.loadUndefined(returnType); 1445 } 1446 1447 method._return(returnType); 1448 1449 return false; 1450 } 1451 1452 private static boolean isNullLiteral(final Node node) { 1453 return node instanceof LiteralNode<?> && ((LiteralNode<?>) node).isNull(); 1454 } 1455 1456 private boolean nullCheck(final RuntimeNode runtimeNode, final List<Node> args, final String signature) { 1457 final Request request = runtimeNode.getRequest(); 1458 1459 if (!Request.isEQ(request) && !Request.isNE(request)) { 1460 return false; 1461 } 1462 1463 assert args.size() == 2 : "EQ or NE or TYPEOF need two args"; 1464 1465 Node lhs = args.get(0); 1466 Node rhs = args.get(1); 1467 1468 if (isNullLiteral(lhs)) { 1469 final Node tmp = lhs; 1470 lhs = rhs; 1471 rhs = tmp; 1472 } 1473 1474 if (isNullLiteral(rhs)) { 1475 final Label trueLabel = new Label("trueLabel"); 1476 final Label falseLabel = new Label("falseLabel"); 1477 final Label endLabel = new Label("end"); 1478 1479 load(lhs); 1480 method.dup(); 1481 if (Request.isEQ(request)) { 1482 method.ifnull(trueLabel); 1483 } else if (Request.isNE(request)) { 1484 method.ifnonnull(trueLabel); 1485 } else { 1486 assert false : "Invalid request " + request; 1487 } 1488 1489 method.label(falseLabel); 1490 load(rhs); 1491 method.invokestatic(CompilerConstants.className(ScriptRuntime.class), request.toString(), signature); 1492 method._goto(endLabel); 1493 1494 method.label(trueLabel); 1495 // if NE (not strict) this can be "undefined != null" which is supposed to be false 1496 if (request == Request.NE) { 1497 method.loadUndefined(Type.OBJECT); 1498 final Label isUndefined = new Label("isUndefined"); 1499 final Label afterUndefinedCheck = new Label("afterUndefinedCheck"); 1500 method.if_acmpeq(isUndefined); 1501 // not undefined 1502 method.load(true); 1503 method._goto(afterUndefinedCheck); 1504 method.label(isUndefined); 1505 method.load(false); 1506 method.label(afterUndefinedCheck); 1507 } else { 1508 method.pop(); 1509 method.load(true); 1510 } 1511 method.label(endLabel); 1512 method.convert(runtimeNode.getType()); 1513 method.store(runtimeNode.getSymbol()); 1514 1515 return true; 1516 } 1517 1518 return false; 1519 } 1520 1521 private boolean specializationCheck(final RuntimeNode.Request request, final Node node, final List<Node> args) { 1522 if (!request.canSpecialize()) { 1523 return false; 1524 } 1525 1526 assert args.size() == 2; 1527 final Type returnType = node.getType(); 1528 1529 load(args.get(0)); 1530 load(args.get(1)); 1531 1532 Request finalRequest = request; 1533 1534 //if the request is a comparison, i.e. one that can be reversed 1535 //it keeps its semantic, but make sure that the object comes in 1536 //last 1537 final Request reverse = Request.reverse(request); 1538 if (method.peekType().isObject() && reverse != null) { //rhs is object 1539 if (!method.peekType(1).isObject()) { //lhs is not object 1540 method.swap(); //prefer object as lhs 1541 finalRequest = reverse; 1542 } 1543 } 1544 1545 method.dynamicRuntimeCall( 1546 new SpecializedRuntimeNode( 1547 finalRequest, 1548 new Type[] { 1549 method.peekType(1), 1550 method.peekType() 1551 }, 1552 returnType).getInitialName(), 1553 returnType, 1554 finalRequest); 1555 1556 method.convert(node.getType()); 1557 method.store(node.getSymbol()); 1558 1559 return true; 1560 } 1561 1562 private static boolean isReducible(final Request request) { 1563 return Request.isComparison(request) || request == Request.ADD; 1564 } 1565 1566 @Override 1567 public boolean enterRuntimeNode(final RuntimeNode runtimeNode) { 1568 /* 1569 * First check if this should be something other than a runtime node 1570 * AccessSpecializer might have changed the type 1571 * 1572 * TODO - remove this - Access Specializer will always know after Attr/Lower 1573 */ 1574 if (runtimeNode.isPrimitive() && !runtimeNode.isFinal() && isReducible(runtimeNode.getRequest())) { 1575 final Node lhs = runtimeNode.getArgs().get(0); 1576 assert runtimeNode.getArgs().size() > 1 : runtimeNode + " must have two args"; 1577 final Node rhs = runtimeNode.getArgs().get(1); 1578 1579 final Type type = runtimeNode.getType(); 1580 final Symbol symbol = runtimeNode.getSymbol(); 1581 1582 switch (runtimeNode.getRequest()) { 1583 case EQ: 1584 case EQ_STRICT: 1585 return enterCmp(lhs, rhs, Condition.EQ, type, symbol); 1586 case NE: 1587 case NE_STRICT: 1588 return enterCmp(lhs, rhs, Condition.NE, type, symbol); 1589 case LE: 1590 return enterCmp(lhs, rhs, Condition.LE, type, symbol); 1591 case LT: 1592 return enterCmp(lhs, rhs, Condition.LT, type, symbol); 1593 case GE: 1594 return enterCmp(lhs, rhs, Condition.GE, type, symbol); 1595 case GT: 1596 return enterCmp(lhs, rhs, Condition.GT, type, symbol); 1597 case ADD: 1598 Type widest = Type.widest(lhs.getType(), rhs.getType()); 1599 load(lhs); 1600 method.convert(widest); 1601 load(rhs); 1602 method.convert(widest); 1603 method.add(); 1604 method.convert(type); 1605 method.store(symbol); 1606 return false; 1607 default: 1608 // it's ok to send this one on with only primitive arguments, maybe INSTANCEOF(true, true) or similar 1609 // assert false : runtimeNode + " has all primitive arguments. This is an inconsistent state"; 1610 break; 1611 } 1612 } 1613 1614 // Get the request arguments. 1615 final List<Node> args = runtimeNode.getArgs(); 1616 1617 if (nullCheck(runtimeNode, args, new FunctionSignature(false, false, runtimeNode.getType(), args).toString())) { 1618 return false; 1619 } 1620 1621 if (!runtimeNode.isFinal() && specializationCheck(runtimeNode.getRequest(), runtimeNode, args)) { 1622 return false; 1623 } 1624 1625 for (final Node arg : runtimeNode.getArgs()) { 1626 load(arg).convert(Type.OBJECT); //TODO this should not be necessary below Lower 1627 } 1628 1629 method.invokestatic( 1630 CompilerConstants.className(ScriptRuntime.class), 1631 runtimeNode.getRequest().toString(), 1632 new FunctionSignature( 1633 false, 1634 false, 1635 runtimeNode.getType(), 1636 runtimeNode.getArgs().size()).toString()); 1637 method.convert(runtimeNode.getType()); 1638 method.store(runtimeNode.getSymbol()); 1639 1640 return false; 1641 } 1642 1643 @Override 1644 public boolean enterSplitNode(final SplitNode splitNode) { 1645 lineNumber(splitNode); 1646 1647 final CompileUnit splitCompileUnit = splitNode.getCompileUnit(); 1648 1649 final FunctionNode fn = lc.getCurrentFunction(); 1650 final String className = splitCompileUnit.getUnitClassName(); 1651 final String name = splitNode.getName(); 1652 1653 final Class<?> rtype = fn.getReturnType().getTypeClass(); 1654 final boolean needsArguments = fn.needsArguments(); 1655 final Class<?>[] ptypes = needsArguments ? 1656 new Class<?>[] {ScriptFunction.class, Object.class, ScriptObject.class, Object.class} : 1657 new Class<?>[] {ScriptFunction.class, Object.class, ScriptObject.class}; 1658 1659 final MethodEmitter caller = method; 1660 unit = lc.pushCompileUnit(splitCompileUnit); 1661 1662 final Call splitCall = staticCallNoLookup( 1663 className, 1664 name, 1665 methodDescriptor(rtype, ptypes)); 1666 1667 final MethodEmitter splitEmitter = 1668 splitCompileUnit.getClassEmitter().method( 1669 splitNode, 1670 name, 1671 rtype, 1672 ptypes); 1673 1674 method = lc.pushMethodEmitter(splitEmitter); 1675 method.setFunctionNode(fn); 1676 1677 if (fn.needsCallee()) { 1678 caller.loadCompilerConstant(CALLEE); 1679 } else { 1680 caller.loadNull(); 1681 } 1682 caller.loadCompilerConstant(THIS); 1683 caller.loadCompilerConstant(SCOPE); 1684 if (needsArguments) { 1685 caller.loadCompilerConstant(ARGUMENTS); 1686 } 1687 caller.invoke(splitCall); 1688 caller.storeCompilerConstant(RETURN); 1689 1690 method.begin(); 1691 1692 method.loadUndefined(fn.getReturnType()); 1693 method.storeCompilerConstant(RETURN); 1694 1695 fixScopeSlot(); 1696 1697 return true; 1698 } 1699 1700 private void fixScopeSlot() { 1701 if (lc.getCurrentFunction().compilerConstant(SCOPE).getSlot() != SCOPE.slot()) { 1702 // TODO hack to move the scope to the expected slot (that's needed because split methods reuse the same slots as the root method) 1703 method.load(Type.typeFor(ScriptObject.class), SCOPE.slot()); 1704 method.storeCompilerConstant(SCOPE); 1705 } 1706 } 1707 1708 @Override 1709 public Node leaveSplitNode(final SplitNode splitNode) { 1710 assert method instanceof SplitMethodEmitter; 1711 final boolean hasReturn = method.hasReturn(); 1712 final List<Label> targets = method.getExternalTargets(); 1713 1714 try { 1715 // Wrap up this method. 1716 1717 method.loadCompilerConstant(RETURN); 1718 method._return(lc.getCurrentFunction().getReturnType()); 1719 method.end(); 1720 1721 unit = lc.popCompileUnit(splitNode.getCompileUnit()); 1722 method = lc.popMethodEmitter(method); 1723 1724 } catch (final Throwable t) { 1725 Context.printStackTrace(t); 1726 final VerifyError e = new VerifyError("Code generation bug in \"" + splitNode.getName() + "\": likely stack misaligned: " + t + " " + lc.getCurrentFunction().getSource().getName()); 1727 e.initCause(t); 1728 throw e; 1729 } 1730 1731 // Handle return from split method if there was one. 1732 final MethodEmitter caller = method; 1733 final int targetCount = targets.size(); 1734 1735 //no external jump targets or return in switch node 1736 if (!hasReturn && targets.isEmpty()) { 1737 return splitNode; 1738 } 1739 1740 caller.loadCompilerConstant(SCOPE); 1741 caller.checkcast(Scope.class); 1742 caller.invoke(Scope.GET_SPLIT_STATE); 1743 1744 final Label breakLabel = new Label("no_split_state"); 1745 // Split state is -1 for no split state, 0 for return, 1..n+1 for break/continue 1746 1747 //the common case is that we don't need a switch 1748 if (targetCount == 0) { 1749 assert hasReturn; 1750 caller.ifne(breakLabel); 1751 //has to be zero 1752 caller.label(new Label("split_return")); 1753 method.loadCompilerConstant(RETURN); 1754 caller._return(lc.getCurrentFunction().getReturnType()); 1755 caller.label(breakLabel); 1756 } else { 1757 assert !targets.isEmpty(); 1758 1759 final int low = hasReturn ? 0 : 1; 1760 final int labelCount = targetCount + 1 - low; 1761 final Label[] labels = new Label[labelCount]; 1762 1763 for (int i = 0; i < labelCount; i++) { 1764 labels[i] = new Label(i == 0 ? "split_return" : "split_" + targets.get(i - 1)); 1765 } 1766 caller.tableswitch(low, targetCount, breakLabel, labels); 1767 for (int i = low; i <= targetCount; i++) { 1768 caller.label(labels[i - low]); 1769 if (i == 0) { 1770 caller.loadCompilerConstant(RETURN); 1771 caller._return(lc.getCurrentFunction().getReturnType()); 1772 } else { 1773 // Clear split state. 1774 caller.loadCompilerConstant(SCOPE); 1775 caller.checkcast(Scope.class); 1776 caller.load(-1); 1777 caller.invoke(Scope.SET_SPLIT_STATE); 1778 caller.splitAwareGoto(lc, targets.get(i - 1)); 1779 } 1780 } 1781 caller.label(breakLabel); 1782 } 1783 1784 return splitNode; 1785 } 1786 1787 @Override 1788 public boolean enterSwitchNode(final SwitchNode switchNode) { 1789 lineNumber(switchNode); 1790 1791 final Node expression = switchNode.getExpression(); 1792 final Symbol tag = switchNode.getTag(); 1793 final boolean allInteger = tag.getSymbolType().isInteger(); 1794 final List<CaseNode> cases = switchNode.getCases(); 1795 final CaseNode defaultCase = switchNode.getDefaultCase(); 1796 final Label breakLabel = switchNode.getBreakLabel(); 1797 1798 Label defaultLabel = breakLabel; 1799 boolean hasDefault = false; 1800 1801 if (defaultCase != null) { 1802 defaultLabel = defaultCase.getEntry(); 1803 hasDefault = true; 1804 } 1805 1806 if (cases.isEmpty()) { 1807 method.label(breakLabel); 1808 return false; 1809 } 1810 1811 if (allInteger) { 1812 // Tree for sorting values. 1813 final TreeMap<Integer, Label> tree = new TreeMap<>(); 1814 1815 // Build up sorted tree. 1816 for (final CaseNode caseNode : cases) { 1817 final Node test = caseNode.getTest(); 1818 1819 if (test != null) { 1820 final Integer value = (Integer)((LiteralNode<?>)test).getValue(); 1821 final Label entry = caseNode.getEntry(); 1822 1823 // Take first duplicate. 1824 if (!(tree.containsKey(value))) { 1825 tree.put(value, entry); 1826 } 1827 } 1828 } 1829 1830 // Copy values and labels to arrays. 1831 final int size = tree.size(); 1832 final Integer[] values = tree.keySet().toArray(new Integer[size]); 1833 final Label[] labels = tree.values().toArray(new Label[size]); 1834 1835 // Discern low, high and range. 1836 final int lo = values[0]; 1837 final int hi = values[size - 1]; 1838 final int range = hi - lo + 1; 1839 1840 // Find an unused value for default. 1841 int deflt = Integer.MIN_VALUE; 1842 for (final int value : values) { 1843 if (deflt == value) { 1844 deflt++; 1845 } else if (deflt < value) { 1846 break; 1847 } 1848 } 1849 1850 // Load switch expression. 1851 load(expression); 1852 final Type type = expression.getType(); 1853 1854 // If expression not int see if we can convert, if not use deflt to trigger default. 1855 if (!type.isInteger()) { 1856 method.load(deflt); 1857 method.invoke(staticCallNoLookup(ScriptRuntime.class, "switchTagAsInt", int.class, type.getTypeClass(), int.class)); 1858 } 1859 1860 // If reasonable size and not too sparse (80%), use table otherwise use lookup. 1861 if (range > 0 && range < 4096 && range < (size * 5 / 4)) { 1862 final Label[] table = new Label[range]; 1863 Arrays.fill(table, defaultLabel); 1864 1865 for (int i = 0; i < size; i++) { 1866 final int value = values[i]; 1867 table[value - lo] = labels[i]; 1868 } 1869 1870 method.tableswitch(lo, hi, defaultLabel, table); 1871 } else { 1872 final int[] ints = new int[size]; 1873 for (int i = 0; i < size; i++) { 1874 ints[i] = values[i]; 1875 } 1876 1877 method.lookupswitch(defaultLabel, ints, labels); 1878 } 1879 } else { 1880 load(expression); 1881 1882 if (expression.getType().isInteger()) { 1883 method.convert(Type.NUMBER).dup(); 1884 method.store(tag); 1885 method.conditionalJump(Condition.NE, true, defaultLabel); 1886 } else { 1887 method.store(tag); 1888 } 1889 1890 for (final CaseNode caseNode : cases) { 1891 final Node test = caseNode.getTest(); 1892 1893 if (test != null) { 1894 method.load(tag); 1895 load(test); 1896 method.invoke(ScriptRuntime.EQ_STRICT); 1897 method.ifne(caseNode.getEntry()); 1898 } 1899 } 1900 1901 method._goto(hasDefault ? defaultLabel : breakLabel); 1902 } 1903 1904 for (final CaseNode caseNode : cases) { 1905 method.label(caseNode.getEntry()); 1906 caseNode.getBody().accept(this); 1907 } 1908 1909 if (!switchNode.isTerminal()) { 1910 method.label(breakLabel); 1911 } 1912 1913 return false; 1914 } 1915 1916 @Override 1917 public boolean enterThrowNode(final ThrowNode throwNode) { 1918 lineNumber(throwNode); 1919 1920 if (throwNode.isSyntheticRethrow()) { 1921 //do not wrap whatever this is in an ecma exception, just rethrow it 1922 load(throwNode.getExpression()); 1923 method.athrow(); 1924 return false; 1925 } 1926 1927 method._new(ECMAException.class).dup(); 1928 1929 final Source source = lc.getCurrentFunction().getSource(); 1930 1931 final Node expression = throwNode.getExpression(); 1932 final int position = throwNode.position(); 1933 final int line = source.getLine(position); 1934 final int column = source.getColumn(position); 1935 1936 load(expression); 1937 assert expression.getType().isObject(); 1938 1939 method.load(source.getName()); 1940 method.load(line); 1941 method.load(column); 1942 method.invoke(ECMAException.THROW_INIT); 1943 1944 method.athrow(); 1945 1946 return false; 1947 } 1948 1949 @Override 1950 public boolean enterTryNode(final TryNode tryNode) { 1951 lineNumber(tryNode); 1952 1953 final Block body = tryNode.getBody(); 1954 final List<Block> catchBlocks = tryNode.getCatchBlocks(); 1955 final Symbol symbol = tryNode.getException(); 1956 final Label entry = new Label("try"); 1957 final Label recovery = new Label("catch"); 1958 final Label exit = tryNode.getExit(); 1959 final Label skip = new Label("skip"); 1960 1961 method.label(entry); 1962 1963 body.accept(this); 1964 1965 if (!body.hasTerminalFlags()) { 1966 method._goto(skip); 1967 } 1968 1969 method.label(exit); 1970 1971 method._catch(recovery); 1972 method.store(symbol); 1973 1974 for (int i = 0; i < catchBlocks.size(); i++) { 1975 final Block catchBlock = catchBlocks.get(i); 1976 1977 //TODO this is very ugly - try not to call enter/leave methods directly 1978 //better to use the implicit lexical context scoping given by the visitor's 1979 //accept method. 1980 lc.push(catchBlock); 1981 enterBlock(catchBlock); 1982 1983 final CatchNode catchNode = (CatchNode)catchBlocks.get(i).getStatements().get(0); 1984 final IdentNode exception = catchNode.getException(); 1985 final Node exceptionCondition = catchNode.getExceptionCondition(); 1986 final Block catchBody = catchNode.getBody(); 1987 1988 new Store<IdentNode>(exception) { 1989 @Override 1990 protected void storeNonDiscard() { 1991 return; 1992 } 1993 1994 @Override 1995 protected void evaluate() { 1996 if (catchNode.isSyntheticRethrow()) { 1997 method.load(symbol); 1998 return; 1999 } 2000 /* 2001 * If caught object is an instance of ECMAException, then 2002 * bind obj.thrown to the script catch var. Or else bind the 2003 * caught object itself to the script catch var. 2004 */ 2005 final Label notEcmaException = new Label("no_ecma_exception"); 2006 method.load(symbol).dup()._instanceof(ECMAException.class).ifeq(notEcmaException); 2007 method.checkcast(ECMAException.class); //TODO is this necessary? 2008 method.getField(ECMAException.THROWN); 2009 method.label(notEcmaException); 2010 } 2011 }.store(); 2012 2013 final Label next; 2014 2015 if (exceptionCondition != null) { 2016 next = new Label("next"); 2017 load(exceptionCondition).convert(Type.BOOLEAN).ifeq(next); 2018 } else { 2019 next = null; 2020 } 2021 2022 catchBody.accept(this); 2023 2024 if (i + 1 != catchBlocks.size() && !catchBody.hasTerminalFlags()) { 2025 method._goto(skip); 2026 } 2027 2028 if (next != null) { 2029 if (i + 1 == catchBlocks.size()) { 2030 // no next catch block - rethrow if condition failed 2031 method._goto(skip); 2032 method.label(next); 2033 method.load(symbol).athrow(); 2034 } else { 2035 method.label(next); 2036 } 2037 } 2038 2039 leaveBlock(catchBlock); 2040 lc.pop(catchBlock); 2041 } 2042 2043 method.label(skip); 2044 method._try(entry, exit, recovery, Throwable.class); 2045 2046 // Finally body is always inlined elsewhere so it doesn't need to be emitted 2047 2048 return false; 2049 } 2050 2051 @Override 2052 public boolean enterVarNode(final VarNode varNode) { 2053 2054 final Node init = varNode.getInit(); 2055 2056 if (init == null) { 2057 return false; 2058 } 2059 2060 lineNumber(varNode); 2061 2062 final Symbol varSymbol = varNode.getSymbol(); 2063 assert varSymbol != null : "variable node " + varNode + " requires a symbol"; 2064 2065 assert method != null; 2066 2067 final boolean needsScope = varSymbol.isScope(); 2068 if (needsScope) { 2069 method.loadCompilerConstant(SCOPE); 2070 } 2071 load(init); 2072 2073 if (needsScope) { 2074 int flags = CALLSITE_SCOPE | getCallSiteFlags(); 2075 final IdentNode identNode = varNode.getName(); 2076 final Type type = identNode.getType(); 2077 if (isFastScope(varSymbol)) { 2078 storeFastScopeVar(type, varSymbol, flags); 2079 } else { 2080 method.dynamicSet(type, identNode.getName(), flags); 2081 } 2082 } else { 2083 assert varNode.getType() == varNode.getName().getType() : "varNode type=" + varNode.getType() + " nametype=" + varNode.getName().getType() + " inittype=" + init.getType(); 2084 2085 method.convert(varNode.getType()); // aw: convert moved here 2086 method.store(varSymbol); 2087 } 2088 2089 return false; 2090 } 2091 2092 @Override 2093 public boolean enterWhileNode(final WhileNode whileNode) { 2094 lineNumber(whileNode); 2095 2096 final Node test = whileNode.getTest(); 2097 final Block body = whileNode.getBody(); 2098 final Label breakLabel = whileNode.getBreakLabel(); 2099 final Label continueLabel = whileNode.getContinueLabel(); 2100 final Label loopLabel = new Label("loop"); 2101 2102 if (!whileNode.isDoWhile()) { 2103 method._goto(continueLabel); 2104 } 2105 2106 method.label(loopLabel); 2107 body.accept(this); 2108 if (!whileNode.isTerminal()) { 2109 method.label(continueLabel); 2110 new BranchOptimizer(this, method).execute(test, loopLabel, true); 2111 method.label(breakLabel); 2112 } 2113 2114 return false; 2115 } 2116 2117 private void closeWith() { 2118 if (method.hasScope()) { 2119 method.loadCompilerConstant(SCOPE); 2120 method.invoke(ScriptRuntime.CLOSE_WITH); 2121 method.storeCompilerConstant(SCOPE); 2122 } 2123 } 2124 2125 @Override 2126 public boolean enterWithNode(final WithNode withNode) { 2127 final Node expression = withNode.getExpression(); 2128 final Node body = withNode.getBody(); 2129 2130 // It is possible to have a "pathological" case where the with block does not reference *any* identifiers. It's 2131 // pointless, but legal. In that case, if nothing else in the method forced the assignment of a slot to the 2132 // scope object, its' possible that it won't have a slot assigned. In this case we'll only evaluate expression 2133 // for its side effect and visit the body, and not bother opening and closing a WithObject. 2134 final boolean hasScope = method.hasScope(); 2135 2136 final Label tryLabel; 2137 if (hasScope) { 2138 tryLabel = new Label("with_try"); 2139 method.label(tryLabel); 2140 method.loadCompilerConstant(SCOPE); 2141 } else { 2142 tryLabel = null; 2143 } 2144 2145 load(expression); 2146 assert expression.getType().isObject() : "with expression needs to be object: " + expression; 2147 2148 if (hasScope) { 2149 // Construct a WithObject if we have a scope 2150 method.invoke(ScriptRuntime.OPEN_WITH); 2151 method.storeCompilerConstant(SCOPE); 2152 } else { 2153 // We just loaded the expression for its side effect; discard it 2154 method.pop(); 2155 } 2156 2157 2158 // Always process body 2159 body.accept(this); 2160 2161 if (hasScope) { 2162 // Ensure we always close the WithObject 2163 final Label endLabel = new Label("with_end"); 2164 final Label catchLabel = new Label("with_catch"); 2165 final Label exitLabel = new Label("with_exit"); 2166 2167 if (!body.isTerminal()) { 2168 closeWith(); 2169 method._goto(exitLabel); 2170 } 2171 2172 method.label(endLabel); 2173 2174 method._catch(catchLabel); 2175 closeWith(); 2176 method.athrow(); 2177 2178 method.label(exitLabel); 2179 2180 method._try(tryLabel, endLabel, catchLabel); 2181 } 2182 return false; 2183 } 2184 2185 @Override 2186 public boolean enterADD(final UnaryNode unaryNode) { 2187 load(unaryNode.rhs()); 2188 assert unaryNode.rhs().getType().isNumber() : unaryNode.rhs().getType() + " "+ unaryNode.getSymbol(); 2189 method.store(unaryNode.getSymbol()); 2190 2191 return false; 2192 } 2193 2194 @Override 2195 public boolean enterBIT_NOT(final UnaryNode unaryNode) { 2196 load(unaryNode.rhs()).convert(Type.INT).load(-1).xor().store(unaryNode.getSymbol()); 2197 return false; 2198 } 2199 2200 // do this better with convert calls to method. TODO 2201 @Override 2202 public boolean enterCONVERT(final UnaryNode unaryNode) { 2203 final Node rhs = unaryNode.rhs(); 2204 final Type to = unaryNode.getType(); 2205 2206 if (to.isObject() && rhs instanceof LiteralNode) { 2207 final LiteralNode<?> literalNode = (LiteralNode<?>)rhs; 2208 final Object value = literalNode.getValue(); 2209 2210 if (value instanceof Number) { 2211 assert !to.isArray() : "type hygiene - cannot convert number to array: (" + to.getTypeClass().getSimpleName() + ')' + value; 2212 if (value instanceof Integer) { 2213 method.load((Integer)value); 2214 } else if (value instanceof Long) { 2215 method.load((Long)value); 2216 } else if (value instanceof Double) { 2217 method.load((Double)value); 2218 } else { 2219 assert false; 2220 } 2221 method.convert(Type.OBJECT); 2222 } else if (value instanceof Boolean) { 2223 method.getField(staticField(Boolean.class, value.toString().toUpperCase(), Boolean.class)); 2224 } else { 2225 load(rhs); 2226 method.convert(unaryNode.getType()); 2227 } 2228 } else { 2229 load(rhs); 2230 method.convert(unaryNode.getType()); 2231 } 2232 2233 method.store(unaryNode.getSymbol()); 2234 2235 return false; 2236 } 2237 2238 @Override 2239 public boolean enterDECINC(final UnaryNode unaryNode) { 2240 final Node rhs = unaryNode.rhs(); 2241 final Type type = unaryNode.getType(); 2242 final TokenType tokenType = unaryNode.tokenType(); 2243 final boolean isPostfix = tokenType == TokenType.DECPOSTFIX || tokenType == TokenType.INCPOSTFIX; 2244 final boolean isIncrement = tokenType == TokenType.INCPREFIX || tokenType == TokenType.INCPOSTFIX; 2245 2246 assert !type.isObject(); 2247 2248 new SelfModifyingStore<UnaryNode>(unaryNode, rhs) { 2249 2250 @Override 2251 protected void evaluate() { 2252 load(rhs, true); 2253 2254 method.convert(type); 2255 if (!isPostfix) { 2256 if (type.isInteger()) { 2257 method.load(isIncrement ? 1 : -1); 2258 } else if (type.isLong()) { 2259 method.load(isIncrement ? 1L : -1L); 2260 } else { 2261 method.load(isIncrement ? 1.0 : -1.0); 2262 } 2263 method.add(); 2264 } 2265 } 2266 2267 @Override 2268 protected void storeNonDiscard() { 2269 super.storeNonDiscard(); 2270 if (isPostfix) { 2271 if (type.isInteger()) { 2272 method.load(isIncrement ? 1 : -1); 2273 } else if (type.isLong()) { 2274 method.load(isIncrement ? 1L : 1L); 2275 } else { 2276 method.load(isIncrement ? 1.0 : -1.0); 2277 } 2278 method.add(); 2279 } 2280 } 2281 }.store(); 2282 2283 return false; 2284 } 2285 2286 @Override 2287 public boolean enterDISCARD(final UnaryNode unaryNode) { 2288 final Node rhs = unaryNode.rhs(); 2289 2290 lc.pushDiscard(rhs); 2291 load(rhs); 2292 2293 if (lc.getCurrentDiscard() == rhs) { 2294 assert !rhs.isAssignment(); 2295 method.pop(); 2296 lc.popDiscard(); 2297 } 2298 2299 return false; 2300 } 2301 2302 @Override 2303 public boolean enterNEW(final UnaryNode unaryNode) { 2304 final CallNode callNode = (CallNode)unaryNode.rhs(); 2305 final List<Node> args = callNode.getArgs(); 2306 2307 // Load function reference. 2308 load(callNode.getFunction()).convert(Type.OBJECT); // must detect type error 2309 2310 method.dynamicNew(1 + loadArgs(args), getCallSiteFlags()); 2311 method.store(unaryNode.getSymbol()); 2312 2313 return false; 2314 } 2315 2316 @Override 2317 public boolean enterNOT(final UnaryNode unaryNode) { 2318 final Node rhs = unaryNode.rhs(); 2319 2320 load(rhs); 2321 2322 final Label trueLabel = new Label("true"); 2323 final Label afterLabel = new Label("after"); 2324 2325 method.convert(Type.BOOLEAN); 2326 method.ifne(trueLabel); 2327 method.load(true); 2328 method._goto(afterLabel); 2329 method.label(trueLabel); 2330 method.load(false); 2331 method.label(afterLabel); 2332 method.store(unaryNode.getSymbol()); 2333 2334 return false; 2335 } 2336 2337 @Override 2338 public boolean enterSUB(final UnaryNode unaryNode) { 2339 load(unaryNode.rhs()).neg().store(unaryNode.getSymbol()); 2340 2341 return false; 2342 } 2343 2344 private Node enterNumericAdd(final Node lhs, final Node rhs, final Type type, final Symbol symbol) { 2345 assert lhs.getType().equals(rhs.getType()) && lhs.getType().equals(type) : lhs.getType() + " != " + rhs.getType() + " != " + type + " " + new ASTWriter(lhs) + " " + new ASTWriter(rhs); 2346 load(lhs); 2347 load(rhs); 2348 method.add(); //if the symbol is optimistic, it always needs to be written, not on the stack? 2349 method.store(symbol); 2350 return null; 2351 } 2352 2353 @Override 2354 public boolean enterADD(final BinaryNode binaryNode) { 2355 final Node lhs = binaryNode.lhs(); 2356 final Node rhs = binaryNode.rhs(); 2357 2358 final Type type = binaryNode.getType(); 2359 if (type.isNumeric()) { 2360 enterNumericAdd(lhs, rhs, type, binaryNode.getSymbol()); 2361 } else { 2362 load(lhs).convert(Type.OBJECT); 2363 load(rhs).convert(Type.OBJECT); 2364 method.add(); 2365 method.store(binaryNode.getSymbol()); 2366 } 2367 2368 return false; 2369 } 2370 2371 private boolean enterAND_OR(final BinaryNode binaryNode) { 2372 final Node lhs = binaryNode.lhs(); 2373 final Node rhs = binaryNode.rhs(); 2374 2375 final Label skip = new Label("skip"); 2376 2377 load(lhs).convert(Type.OBJECT).dup().convert(Type.BOOLEAN); 2378 2379 if (binaryNode.tokenType() == TokenType.AND) { 2380 method.ifeq(skip); 2381 } else { 2382 method.ifne(skip); 2383 } 2384 2385 method.pop(); 2386 load(rhs).convert(Type.OBJECT); 2387 method.label(skip); 2388 method.store(binaryNode.getSymbol()); 2389 2390 return false; 2391 } 2392 2393 @Override 2394 public boolean enterAND(final BinaryNode binaryNode) { 2395 return enterAND_OR(binaryNode); 2396 } 2397 2398 @Override 2399 public boolean enterASSIGN(final BinaryNode binaryNode) { 2400 final Node lhs = binaryNode.lhs(); 2401 final Node rhs = binaryNode.rhs(); 2402 2403 final Type lhsType = lhs.getType(); 2404 final Type rhsType = rhs.getType(); 2405 2406 if (!lhsType.isEquivalentTo(rhsType)) { 2407 //this is OK if scoped, only locals are wrong 2408 assert !(lhs instanceof IdentNode) || lhs.getSymbol().isScope() : new ASTWriter(binaryNode); 2409 } 2410 2411 new Store<BinaryNode>(binaryNode, lhs) { 2412 @Override 2413 protected void evaluate() { 2414 load(rhs); 2415 } 2416 }.store(); 2417 2418 return false; 2419 } 2420 2421 /** 2422 * Helper class for assignment ops, e.g. *=, += and so on.. 2423 */ 2424 private abstract class AssignOp extends SelfModifyingStore<BinaryNode> { 2425 2426 /** The type of the resulting operation */ 2427 private final Type opType; 2428 2429 /** 2430 * Constructor 2431 * 2432 * @param node the assign op node 2433 */ 2434 AssignOp(final BinaryNode node) { 2435 this(node.getType(), node); 2436 } 2437 2438 /** 2439 * Constructor 2440 * 2441 * @param opType type of the computation - overriding the type of the node 2442 * @param node the assign op node 2443 */ 2444 AssignOp(final Type opType, final BinaryNode node) { 2445 super(node, node.lhs()); 2446 this.opType = opType; 2447 } 2448 2449 protected abstract void op(); 2450 2451 @Override 2452 protected void evaluate() { 2453 load(assignNode.lhs(), true).convert(opType); 2454 load(assignNode.rhs()).convert(opType); 2455 op(); 2456 method.convert(assignNode.getType()); 2457 } 2458 } 2459 2460 @Override 2461 public boolean enterASSIGN_ADD(final BinaryNode binaryNode) { 2462 assert RuntimeNode.Request.ADD.canSpecialize(); 2463 final Type lhsType = binaryNode.lhs().getType(); 2464 final Type rhsType = binaryNode.rhs().getType(); 2465 final boolean specialize = binaryNode.getType() == Type.OBJECT; 2466 2467 new AssignOp(binaryNode) { 2468 2469 @Override 2470 protected void op() { 2471 if (specialize) { 2472 method.dynamicRuntimeCall( 2473 new SpecializedRuntimeNode( 2474 Request.ADD, 2475 new Type[] { 2476 lhsType, 2477 rhsType, 2478 }, 2479 Type.OBJECT).getInitialName(), 2480 Type.OBJECT, 2481 Request.ADD); 2482 } else { 2483 method.add(); 2484 } 2485 } 2486 2487 @Override 2488 protected void evaluate() { 2489 super.evaluate(); 2490 } 2491 }.store(); 2492 2493 return false; 2494 } 2495 2496 @Override 2497 public boolean enterASSIGN_BIT_AND(final BinaryNode binaryNode) { 2498 new AssignOp(Type.INT, binaryNode) { 2499 @Override 2500 protected void op() { 2501 method.and(); 2502 } 2503 }.store(); 2504 2505 return false; 2506 } 2507 2508 @Override 2509 public boolean enterASSIGN_BIT_OR(final BinaryNode binaryNode) { 2510 new AssignOp(Type.INT, binaryNode) { 2511 @Override 2512 protected void op() { 2513 method.or(); 2514 } 2515 }.store(); 2516 2517 return false; 2518 } 2519 2520 @Override 2521 public boolean enterASSIGN_BIT_XOR(final BinaryNode binaryNode) { 2522 new AssignOp(Type.INT, binaryNode) { 2523 @Override 2524 protected void op() { 2525 method.xor(); 2526 } 2527 }.store(); 2528 2529 return false; 2530 } 2531 2532 @Override 2533 public boolean enterASSIGN_DIV(final BinaryNode binaryNode) { 2534 new AssignOp(binaryNode) { 2535 @Override 2536 protected void op() { 2537 method.div(); 2538 } 2539 }.store(); 2540 2541 return false; 2542 } 2543 2544 @Override 2545 public boolean enterASSIGN_MOD(final BinaryNode binaryNode) { 2546 new AssignOp(binaryNode) { 2547 @Override 2548 protected void op() { 2549 method.rem(); 2550 } 2551 }.store(); 2552 2553 return false; 2554 } 2555 2556 @Override 2557 public boolean enterASSIGN_MUL(final BinaryNode binaryNode) { 2558 new AssignOp(binaryNode) { 2559 @Override 2560 protected void op() { 2561 method.mul(); 2562 } 2563 }.store(); 2564 2565 return false; 2566 } 2567 2568 @Override 2569 public boolean enterASSIGN_SAR(final BinaryNode binaryNode) { 2570 new AssignOp(Type.INT, binaryNode) { 2571 @Override 2572 protected void op() { 2573 method.sar(); 2574 } 2575 }.store(); 2576 2577 return false; 2578 } 2579 2580 @Override 2581 public boolean enterASSIGN_SHL(final BinaryNode binaryNode) { 2582 new AssignOp(Type.INT, binaryNode) { 2583 @Override 2584 protected void op() { 2585 method.shl(); 2586 } 2587 }.store(); 2588 2589 return false; 2590 } 2591 2592 @Override 2593 public boolean enterASSIGN_SHR(final BinaryNode binaryNode) { 2594 new AssignOp(Type.INT, binaryNode) { 2595 @Override 2596 protected void op() { 2597 method.shr(); 2598 method.convert(Type.LONG).load(JSType.MAX_UINT).and(); 2599 } 2600 }.store(); 2601 2602 return false; 2603 } 2604 2605 @Override 2606 public boolean enterASSIGN_SUB(final BinaryNode binaryNode) { 2607 new AssignOp(binaryNode) { 2608 @Override 2609 protected void op() { 2610 method.sub(); 2611 } 2612 }.store(); 2613 2614 return false; 2615 } 2616 2617 /** 2618 * Helper class for binary arithmetic ops 2619 */ 2620 private abstract class BinaryArith { 2621 2622 protected abstract void op(); 2623 2624 protected void evaluate(final BinaryNode node) { 2625 load(node.lhs()); 2626 load(node.rhs()); 2627 op(); 2628 method.store(node.getSymbol()); 2629 } 2630 } 2631 2632 @Override 2633 public boolean enterBIT_AND(final BinaryNode binaryNode) { 2634 new BinaryArith() { 2635 @Override 2636 protected void op() { 2637 method.and(); 2638 } 2639 }.evaluate(binaryNode); 2640 2641 return false; 2642 } 2643 2644 @Override 2645 public boolean enterBIT_OR(final BinaryNode binaryNode) { 2646 new BinaryArith() { 2647 @Override 2648 protected void op() { 2649 method.or(); 2650 } 2651 }.evaluate(binaryNode); 2652 2653 return false; 2654 } 2655 2656 @Override 2657 public boolean enterBIT_XOR(final BinaryNode binaryNode) { 2658 new BinaryArith() { 2659 @Override 2660 protected void op() { 2661 method.xor(); 2662 } 2663 }.evaluate(binaryNode); 2664 2665 return false; 2666 } 2667 2668 private boolean enterComma(final BinaryNode binaryNode) { 2669 final Node lhs = binaryNode.lhs(); 2670 final Node rhs = binaryNode.rhs(); 2671 2672 load(lhs); 2673 load(rhs); 2674 method.store(binaryNode.getSymbol()); 2675 2676 return false; 2677 } 2678 2679 @Override 2680 public boolean enterCOMMARIGHT(final BinaryNode binaryNode) { 2681 return enterComma(binaryNode); 2682 } 2683 2684 @Override 2685 public boolean enterCOMMALEFT(final BinaryNode binaryNode) { 2686 return enterComma(binaryNode); 2687 } 2688 2689 @Override 2690 public boolean enterDIV(final BinaryNode binaryNode) { 2691 new BinaryArith() { 2692 @Override 2693 protected void op() { 2694 method.div(); 2695 } 2696 }.evaluate(binaryNode); 2697 2698 return false; 2699 } 2700 2701 private boolean enterCmp(final Node lhs, final Node rhs, final Condition cond, final Type type, final Symbol symbol) { 2702 final Type lhsType = lhs.getType(); 2703 final Type rhsType = rhs.getType(); 2704 2705 final Type widest = Type.widest(lhsType, rhsType); 2706 assert widest.isNumeric() || widest.isBoolean() : widest; 2707 2708 load(lhs); 2709 method.convert(widest); 2710 load(rhs); 2711 method.convert(widest); 2712 2713 final Label trueLabel = new Label("trueLabel"); 2714 final Label afterLabel = new Label("skip"); 2715 2716 method.conditionalJump(cond, trueLabel); 2717 2718 method.load(Boolean.FALSE); 2719 method._goto(afterLabel); 2720 method.label(trueLabel); 2721 method.load(Boolean.TRUE); 2722 method.label(afterLabel); 2723 2724 method.convert(type); 2725 method.store(symbol); 2726 2727 return false; 2728 } 2729 2730 private boolean enterCmp(final BinaryNode binaryNode, final Condition cond) { 2731 return enterCmp(binaryNode.lhs(), binaryNode.rhs(), cond, binaryNode.getType(), binaryNode.getSymbol()); 2732 } 2733 2734 @Override 2735 public boolean enterEQ(final BinaryNode binaryNode) { 2736 return enterCmp(binaryNode, Condition.EQ); 2737 } 2738 2739 @Override 2740 public boolean enterEQ_STRICT(final BinaryNode binaryNode) { 2741 return enterCmp(binaryNode, Condition.EQ); 2742 } 2743 2744 @Override 2745 public boolean enterGE(final BinaryNode binaryNode) { 2746 return enterCmp(binaryNode, Condition.GE); 2747 } 2748 2749 @Override 2750 public boolean enterGT(final BinaryNode binaryNode) { 2751 return enterCmp(binaryNode, Condition.GT); 2752 } 2753 2754 @Override 2755 public boolean enterLE(final BinaryNode binaryNode) { 2756 return enterCmp(binaryNode, Condition.LE); 2757 } 2758 2759 @Override 2760 public boolean enterLT(final BinaryNode binaryNode) { 2761 return enterCmp(binaryNode, Condition.LT); 2762 } 2763 2764 @Override 2765 public boolean enterMOD(final BinaryNode binaryNode) { 2766 new BinaryArith() { 2767 @Override 2768 protected void op() { 2769 method.rem(); 2770 } 2771 }.evaluate(binaryNode); 2772 2773 return false; 2774 } 2775 2776 @Override 2777 public boolean enterMUL(final BinaryNode binaryNode) { 2778 new BinaryArith() { 2779 @Override 2780 protected void op() { 2781 method.mul(); 2782 } 2783 }.evaluate(binaryNode); 2784 2785 return false; 2786 } 2787 2788 @Override 2789 public boolean enterNE(final BinaryNode binaryNode) { 2790 return enterCmp(binaryNode, Condition.NE); 2791 } 2792 2793 @Override 2794 public boolean enterNE_STRICT(final BinaryNode binaryNode) { 2795 return enterCmp(binaryNode, Condition.NE); 2796 } 2797 2798 @Override 2799 public boolean enterOR(final BinaryNode binaryNode) { 2800 return enterAND_OR(binaryNode); 2801 } 2802 2803 @Override 2804 public boolean enterSAR(final BinaryNode binaryNode) { 2805 new BinaryArith() { 2806 @Override 2807 protected void op() { 2808 method.sar(); 2809 } 2810 }.evaluate(binaryNode); 2811 2812 return false; 2813 } 2814 2815 @Override 2816 public boolean enterSHL(final BinaryNode binaryNode) { 2817 new BinaryArith() { 2818 @Override 2819 protected void op() { 2820 method.shl(); 2821 } 2822 }.evaluate(binaryNode); 2823 2824 return false; 2825 } 2826 2827 @Override 2828 public boolean enterSHR(final BinaryNode binaryNode) { 2829 new BinaryArith() { 2830 @Override 2831 protected void op() { 2832 method.shr(); 2833 method.convert(Type.LONG).load(JSType.MAX_UINT).and(); 2834 } 2835 }.evaluate(binaryNode); 2836 2837 return false; 2838 } 2839 2840 @Override 2841 public boolean enterSUB(final BinaryNode binaryNode) { 2842 new BinaryArith() { 2843 @Override 2844 protected void op() { 2845 method.sub(); 2846 } 2847 }.evaluate(binaryNode); 2848 2849 return false; 2850 } 2851 2852 @Override 2853 public boolean enterTernaryNode(final TernaryNode ternaryNode) { 2854 final Node lhs = ternaryNode.lhs(); 2855 final Node rhs = ternaryNode.rhs(); 2856 final Node third = ternaryNode.third(); 2857 2858 final Symbol symbol = ternaryNode.getSymbol(); 2859 final Label falseLabel = new Label("ternary_false"); 2860 final Label exitLabel = new Label("ternary_exit"); 2861 2862 Type widest = Type.widest(rhs.getType(), third.getType()); 2863 if (rhs.getType().isArray() || third.getType().isArray()) { //loadArray creates a Java array type on the stack, calls global allocate, which creates a native array type 2864 widest = Type.OBJECT; 2865 } 2866 2867 load(lhs); 2868 assert lhs.getType().isBoolean() : "lhs in ternary must be boolean"; 2869 2870 // we still keep the conversion here as the AccessSpecializer can have separated the types, e.g. var y = x ? x=55 : 17 2871 // will left as (Object)x=55 : (Object)17 by Lower. Then the first term can be {I}x=55 of type int, which breaks the 2872 // symmetry for the temporary slot for this TernaryNode. This is evidence that we assign types and explicit conversions 2873 // to early, or Apply the AccessSpecializer too late. We are mostly probably looking for a separate type pass to 2874 // do this property. Then we never need any conversions in CodeGenerator 2875 method.ifeq(falseLabel); 2876 load(rhs); 2877 method.convert(widest); 2878 method._goto(exitLabel); 2879 method.label(falseLabel); 2880 load(third); 2881 method.convert(widest); 2882 method.label(exitLabel); 2883 method.store(symbol); 2884 2885 return false; 2886 } 2887 2888 /** 2889 * Generate all shared scope calls generated during codegen. 2890 */ 2891 protected void generateScopeCalls() { 2892 for (final SharedScopeCall scopeAccess : lc.getScopeCalls()) { 2893 scopeAccess.generateScopeCall(); 2894 } 2895 } 2896 2897 /** 2898 * Debug code used to print symbols 2899 * 2900 * @param block the block we are in 2901 * @param ident identifier for block or function where applicable 2902 */ 2903 @SuppressWarnings("resource") 2904 private void printSymbols(final Block block, final String ident) { 2905 if (!compiler.getEnv()._print_symbols) { 2906 return; 2907 } 2908 2909 final PrintWriter out = compiler.getEnv().getErr(); 2910 out.println("[BLOCK in '" + ident + "']"); 2911 if (!block.printSymbols(out)) { 2912 out.println("<no symbols>"); 2913 } 2914 out.println(); 2915 } 2916 2917 2918 /** 2919 * The difference between a store and a self modifying store is that 2920 * the latter may load part of the target on the stack, e.g. the base 2921 * of an AccessNode or the base and index of an IndexNode. These are used 2922 * both as target and as an extra source. Previously it was problematic 2923 * for self modifying stores if the target/lhs didn't belong to one 2924 * of three trivial categories: IdentNode, AcessNodes, IndexNodes. In that 2925 * case it was evaluated and tagged as "resolved", which meant at the second 2926 * time the lhs of this store was read (e.g. in a = a (second) + b for a += b, 2927 * it would be evaluated to a nop in the scope and cause stack underflow 2928 * 2929 * see NASHORN-703 2930 * 2931 * @param <T> 2932 */ 2933 private abstract class SelfModifyingStore<T extends Node> extends Store<T> { 2934 protected SelfModifyingStore(final T assignNode, final Node target) { 2935 super(assignNode, target); 2936 } 2937 2938 @Override 2939 protected boolean isSelfModifying() { 2940 return true; 2941 } 2942 } 2943 2944 /** 2945 * Helper class to generate stores 2946 */ 2947 private abstract class Store<T extends Node> { 2948 2949 /** An assignment node, e.g. x += y */ 2950 protected final T assignNode; 2951 2952 /** The target node to store to, e.g. x */ 2953 private final Node target; 2954 2955 /** How deep on the stack do the arguments go if this generates an indy call */ 2956 private int depth; 2957 2958 /** If we have too many arguments, we need temporary storage, this is stored in 'quick' */ 2959 private Symbol quick; 2960 2961 /** 2962 * Constructor 2963 * 2964 * @param assignNode the node representing the whole assignment 2965 * @param target the target node of the assignment (destination) 2966 */ 2967 protected Store(final T assignNode, final Node target) { 2968 this.assignNode = assignNode; 2969 this.target = target; 2970 } 2971 2972 /** 2973 * Constructor 2974 * 2975 * @param assignNode the node representing the whole assignment 2976 */ 2977 protected Store(final T assignNode) { 2978 this(assignNode, assignNode); 2979 } 2980 2981 /** 2982 * Is this a self modifying store operation, e.g. *= or ++ 2983 * @return true if self modifying store 2984 */ 2985 protected boolean isSelfModifying() { 2986 return false; 2987 } 2988 2989 private void prologue() { 2990 final Symbol targetSymbol = target.getSymbol(); 2991 final Symbol scopeSymbol = lc.getCurrentFunction().compilerConstant(SCOPE); 2992 2993 /** 2994 * This loads the parts of the target, e.g base and index. they are kept 2995 * on the stack throughout the store and used at the end to execute it 2996 */ 2997 2998 target.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) { 2999 @Override 3000 public boolean enterIdentNode(final IdentNode node) { 3001 if (targetSymbol.isScope()) { 3002 method.load(scopeSymbol); 3003 depth++; 3004 } 3005 return false; 3006 } 3007 3008 private void enterBaseNode() { 3009 assert target instanceof BaseNode : "error - base node " + target + " must be instanceof BaseNode"; 3010 final BaseNode baseNode = (BaseNode)target; 3011 final Node base = baseNode.getBase(); 3012 3013 load(base); 3014 method.convert(Type.OBJECT); 3015 depth += Type.OBJECT.getSlots(); 3016 3017 if (isSelfModifying()) { 3018 method.dup(); 3019 } 3020 } 3021 3022 @Override 3023 public boolean enterAccessNode(final AccessNode node) { 3024 enterBaseNode(); 3025 return false; 3026 } 3027 3028 @Override 3029 public boolean enterIndexNode(final IndexNode node) { 3030 enterBaseNode(); 3031 3032 final Node index = node.getIndex(); 3033 // could be boolean here as well 3034 load(index); 3035 if (!index.getType().isNumeric()) { 3036 method.convert(Type.OBJECT); 3037 } 3038 depth += index.getType().getSlots(); 3039 3040 if (isSelfModifying()) { 3041 //convert "base base index" to "base index base index" 3042 method.dup(1); 3043 } 3044 3045 return false; 3046 } 3047 3048 }); 3049 } 3050 3051 private Symbol quickSymbol(final Type type) { 3052 return quickSymbol(type, QUICK_PREFIX.symbolName()); 3053 } 3054 3055 /** 3056 * Quick symbol generates an extra local variable, always using the same 3057 * slot, one that is available after the end of the frame. 3058 * 3059 * @param type the type of the symbol 3060 * @param prefix the prefix for the variable name for the symbol 3061 * 3062 * @return the quick symbol 3063 */ 3064 private Symbol quickSymbol(final Type type, final String prefix) { 3065 final String name = lc.getCurrentFunction().uniqueName(prefix); 3066 final Symbol symbol = new Symbol(name, IS_TEMP | IS_INTERNAL); 3067 3068 symbol.setType(type); 3069 3070 symbol.setSlot(lc.quickSlot(symbol)); 3071 3072 return symbol; 3073 } 3074 3075 // store the result that "lives on" after the op, e.g. "i" in i++ postfix. 3076 protected void storeNonDiscard() { 3077 if (lc.getCurrentDiscard() == assignNode) { 3078 assert assignNode.isAssignment(); 3079 lc.popDiscard(); 3080 return; 3081 } 3082 3083 final Symbol symbol = assignNode.getSymbol(); 3084 if (symbol.hasSlot()) { 3085 method.dup().store(symbol); 3086 return; 3087 } 3088 3089 if (method.dup(depth) == null) { 3090 method.dup(); 3091 this.quick = quickSymbol(method.peekType()); 3092 method.store(quick); 3093 } 3094 } 3095 3096 private void epilogue() { 3097 /** 3098 * Take the original target args from the stack and use them 3099 * together with the value to be stored to emit the store code 3100 * 3101 * The case that targetSymbol is in scope (!hasSlot) and we actually 3102 * need to do a conversion on non-equivalent types exists, but is 3103 * very rare. See for example test/script/basic/access-specializer.js 3104 */ 3105 method.convert(target.getType()); 3106 3107 target.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) { 3108 @Override 3109 protected boolean enterDefault(Node node) { 3110 throw new AssertionError("Unexpected node " + node + " in store epilogue"); 3111 } 3112 3113 @Override 3114 public boolean enterUnaryNode(final UnaryNode node) { 3115 if (node.tokenType() == TokenType.CONVERT && node.getSymbol() != null) { 3116 method.convert(node.rhs().getType()); 3117 } 3118 return true; 3119 } 3120 3121 @Override 3122 public boolean enterIdentNode(final IdentNode node) { 3123 final Symbol symbol = node.getSymbol(); 3124 assert symbol != null; 3125 if (symbol.isScope()) { 3126 if (isFastScope(symbol)) { 3127 storeFastScopeVar(node.getType(), symbol, CALLSITE_SCOPE | getCallSiteFlags()); 3128 } else { 3129 method.dynamicSet(node.getType(), node.getName(), CALLSITE_SCOPE | getCallSiteFlags()); 3130 } 3131 } else { 3132 method.store(symbol); 3133 } 3134 return false; 3135 3136 } 3137 3138 @Override 3139 public boolean enterAccessNode(final AccessNode node) { 3140 method.dynamicSet(node.getProperty().getType(), node.getProperty().getName(), getCallSiteFlags()); 3141 return false; 3142 } 3143 3144 @Override 3145 public boolean enterIndexNode(final IndexNode node) { 3146 method.dynamicSetIndex(getCallSiteFlags()); 3147 return false; 3148 } 3149 }); 3150 3151 3152 // whatever is on the stack now is the final answer 3153 } 3154 3155 protected abstract void evaluate(); 3156 3157 void store() { 3158 prologue(); 3159 evaluate(); // leaves an operation of whatever the operationType was on the stack 3160 storeNonDiscard(); 3161 epilogue(); 3162 if (quick != null) { 3163 method.load(quick); 3164 } 3165 } 3166 } 3167 3168 private void newFunctionObject(final FunctionNode functionNode, final FunctionNode originalFunctionNode) { 3169 assert lc.peek() == functionNode; 3170 // We don't emit a ScriptFunction on stack for: 3171 // 1. the outermost compiled function (as there's no code being generated in its outer context that'd need it 3172 // as a callee), and 3173 // 2. for functions that are immediately called upon definition and they don't need a callee, e.g. (function(){})(). 3174 // Such immediately-called functions are invoked using INVOKESTATIC (see enterFunctionNode() of the embedded 3175 // visitor of enterCallNode() for details), and if they don't need a callee, they don't have it on their 3176 // static method's parameter list. 3177 if (lc.getOutermostFunction() == functionNode || 3178 (!functionNode.needsCallee()) && lc.isFunctionDefinedInCurrentCall(originalFunctionNode)) { 3179 return; 3180 } 3181 3182 final boolean isLazy = functionNode.isLazy(); 3183 3184 new ObjectCreator(this, new ArrayList<String>(), new ArrayList<Symbol>(), false, false) { 3185 @Override 3186 protected void makeObject(final MethodEmitter m) { 3187 final String className = SCRIPTFUNCTION_IMPL_OBJECT; 3188 3189 m._new(className).dup(); 3190 loadConstant(new RecompilableScriptFunctionData(functionNode, compiler.getCodeInstaller(), Compiler.binaryName(getClassName()), makeMap())); 3191 3192 if (isLazy || functionNode.needsParentScope()) { 3193 m.loadCompilerConstant(SCOPE); 3194 } else { 3195 m.loadNull(); 3196 } 3197 m.invoke(constructorNoLookup(className, RecompilableScriptFunctionData.class, ScriptObject.class)); 3198 } 3199 }.makeObject(method); 3200 } 3201 3202 /* 3203 * Globals are special. We cannot refer to any Global (or NativeObject) class by .class, as they are different 3204 * for different contexts. As far as I can tell, the only NativeObject that we need to deal with like this 3205 * is from the code pipeline is Global 3206 */ 3207 private MethodEmitter globalInstance() { 3208 return method.invokestatic(GLOBAL_OBJECT, "instance", "()L" + GLOBAL_OBJECT + ';'); 3209 } 3210 3211 private MethodEmitter globalObjectPrototype() { 3212 return method.invokestatic(GLOBAL_OBJECT, "objectPrototype", methodDescriptor(ScriptObject.class)); 3213 } 3214 3215 private MethodEmitter globalAllocateArguments() { 3216 return method.invokestatic(GLOBAL_OBJECT, "allocateArguments", methodDescriptor(ScriptObject.class, Object[].class, Object.class, int.class)); 3217 } 3218 3219 private MethodEmitter globalNewRegExp() { 3220 return method.invokestatic(GLOBAL_OBJECT, "newRegExp", methodDescriptor(Object.class, String.class, String.class)); 3221 } 3222 3223 private MethodEmitter globalRegExpCopy() { 3224 return method.invokestatic(GLOBAL_OBJECT, "regExpCopy", methodDescriptor(Object.class, Object.class)); 3225 } 3226 3227 private MethodEmitter globalAllocateArray(final ArrayType type) { 3228 //make sure the native array is treated as an array type 3229 return method.invokestatic(GLOBAL_OBJECT, "allocate", "(" + type.getDescriptor() + ")Ljdk/nashorn/internal/objects/NativeArray;"); 3230 } 3231 3232 private MethodEmitter globalIsEval() { 3233 return method.invokestatic(GLOBAL_OBJECT, "isEval", methodDescriptor(boolean.class, Object.class)); 3234 } 3235 3236 private MethodEmitter globalDirectEval() { 3237 return method.invokestatic(GLOBAL_OBJECT, "directEval", 3238 methodDescriptor(Object.class, Object.class, Object.class, Object.class, Object.class, Object.class)); 3239 } 3240 }