123         allowInvokedynamic = target.hasInvokedynamic() || options.isSet("invokedynamic");

   129 

   130         // by default, avoid jsr's for simple finalizers

   131         int setjsrlimit = 50;

   132         String jsrlimitString = options.get("jsrlimit");

   133         if (jsrlimitString != null) {

   134             try {

   135                 setjsrlimit = Integer.parseInt(jsrlimitString);

   136             } catch (NumberFormatException ex) {

   137                 // ignore ill-formed numbers for jsrlimit

   138             }

   139         }

   140         this.jsrlimit = setjsrlimit;

   141         this.useJsrLocally = false; // reset in visitTry

   151     private final boolean allowInvokedynamic;

   153 

   154     /** Default limit of (approximate) size of finalizer to inline.

   155      *  Zero means always use jsr.  100 or greater means never use

   156      *  jsr.

   157      */

   158     private final int jsrlimit;

   159 

   160     /** True if jsr is used.

   161      */

   162     private boolean useJsrLocally;

  1342         if (!useJsrLocally) {

  1343             useJsrLocally =

  1344                 (stackMap == StackMapFormat.NONE) &&

  1345                 (jsrlimit <= 0 ||

  1346                 jsrlimit < 100 &&

  1347                 estimateCodeComplexity(tree.finalizer)>jsrlimit);

  1348         }

  1570 

  1571     /** Very roughly estimate the number of instructions needed for

  1572      *  the given tree.

  1573      */

  1574     int estimateCodeComplexity(JCTree tree) {

  1575         if (tree == null) return 0;

  1576         class ComplexityScanner extends TreeScanner {

  1577             int complexity = 0;

  1578             public void scan(JCTree tree) {

  1579                 if (complexity > jsrlimit) return;

  1580                 super.scan(tree);

  1581             }

  1582             public void visitClassDef(JCClassDecl tree) {}

  1583             public void visitDoLoop(JCDoWhileLoop tree)

  1584                 { super.visitDoLoop(tree); complexity++; }

  1585             public void visitWhileLoop(JCWhileLoop tree)

  1586                 { super.visitWhileLoop(tree); complexity++; }

  1587             public void visitForLoop(JCForLoop tree)

  1588                 { super.visitForLoop(tree); complexity++; }

  1589             public void visitSwitch(JCSwitch tree)

  1590                 { super.visitSwitch(tree); complexity+=5; }

  1591             public void visitCase(JCCase tree)

  1592                 { super.visitCase(tree); complexity++; }

  1593             public void visitSynchronized(JCSynchronized tree)

  1594                 { super.visitSynchronized(tree); complexity+=6; }

  1595             public void visitTry(JCTry tree)

  1596                 { super.visitTry(tree);

  1597                   if (tree.finalizer != null) complexity+=6; }

  1598             public void visitCatch(JCCatch tree)

  1599                 { super.visitCatch(tree); complexity+=2; }

  1600             public void visitConditional(JCConditional tree)

  1601                 { super.visitConditional(tree); complexity+=2; }

  1602             public void visitIf(JCIf tree)

  1603                 { super.visitIf(tree); complexity+=2; }

  1604             // note: for break, continue, and return we don't take unwind() into account.

  1605             public void visitBreak(JCBreak tree)

  1606                 { super.visitBreak(tree); complexity+=1; }

  1607             public void visitContinue(JCContinue tree)

  1608                 { super.visitContinue(tree); complexity+=1; }

  1609             public void visitReturn(JCReturn tree)

  1610                 { super.visitReturn(tree); complexity+=1; }

  1611             public void visitThrow(JCThrow tree)

  1612                 { super.visitThrow(tree); complexity+=1; }

  1613             public void visitAssert(JCAssert tree)

  1614                 { super.visitAssert(tree); complexity+=5; }

  1615             public void visitApply(JCMethodInvocation tree)

  1616                 { super.visitApply(tree); complexity+=2; }

  1617             public void visitNewClass(JCNewClass tree)

  1618                 { scan(tree.encl); scan(tree.args); complexity+=2; }

  1619             public void visitNewArray(JCNewArray tree)

  1620                 { super.visitNewArray(tree); complexity+=5; }

  1621             public void visitAssign(JCAssign tree)

  1622                 { super.visitAssign(tree); complexity+=1; }

  1623             public void visitAssignop(JCAssignOp tree)

  1624                 { super.visitAssignop(tree); complexity+=2; }

  1625             public void visitUnary(JCUnary tree)

  1626                 { complexity+=1;

  1627                   if (tree.type.constValue() == null) super.visitUnary(tree); }

  1628             public void visitBinary(JCBinary tree)

  1629                 { complexity+=1;

  1630                   if (tree.type.constValue() == null) super.visitBinary(tree); }

  1631             public void visitTypeTest(JCInstanceOf tree)

  1632                 { super.visitTypeTest(tree); complexity+=1; }

  1633             public void visitIndexed(JCArrayAccess tree)

  1634                 { super.visitIndexed(tree); complexity+=1; }

  1635             public void visitSelect(JCFieldAccess tree)

  1636                 { super.visitSelect(tree);

  1637                   if (tree.sym.kind == VAR) complexity+=1; }

  1638             public void visitIdent(JCIdent tree) {

  1639                 if (tree.sym.kind == VAR) {

  1640                     complexity+=1;

  1641                     if (tree.type.constValue() == null &&

  1642                         tree.sym.owner.kind == TYP)

  1643                         complexity+=1;

  1644                 }

  1645             }

  1646             public void visitLiteral(JCLiteral tree)

  1647                 { complexity+=1; }

  1648             public void visitTree(JCTree tree) {}

  1649             public void visitWildcard(JCWildcard tree) {

  1650                 throw new AssertionError(this.getClass().getName());

  1651             }

  1652         }

  1653         ComplexityScanner scanner = new ComplexityScanner();

  1654         tree.accept(scanner);

  1655         return scanner.complexity;

  1656     }