/*

 * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/*

 * @test

 * @bug 6934604

 * @summary enable parts of EliminateAutoBox by default

 * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox

 * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-EliminateAutoBox

 */

public class TestDoubleBoxing {

  static final Double ibc = new Double(1.);

  //===============================================

  // Non-inlined methods to test deoptimization info

  static void   dummy()        { }

  static double foo(double i)  { return i; }

  static Double foob(double i) { return Double.valueOf(i); }

  static double simple(double i) {

    Double ib = new Double(i);

    return ib;

  }

  static double simpleb(double i) {

    Double ib = Double.valueOf(i);

    return ib;

  }

  static double simplec() {

    Double ib = ibc;

    return ib;

  }

  static double simplef(double i) {

    Double ib = foob(i);

    return ib;

  }

  static double simplep(Double ib) {

    return ib;

  }

  static double simple2(double i) {

    Double ib1 = new Double(i);

    Double ib2 = new Double(i+1.);

    return ib1 + ib2;

  }

  static double simpleb2(double i) {

    Double ib1 = Double.valueOf(i);

    Double ib2 = Double.valueOf(i+1.);

    return ib1 + ib2;

  }

  static double simplem2(double i) {

    Double ib1 = new Double(i);

    Double ib2 = Double.valueOf(i+1.);

    return ib1 + ib2;

  }

  static double simplep2(double i, Double ib1) {

    Double ib2 = Double.valueOf(i+1.);

    return ib1 + ib2;

  }

  static double simplec2(double i) {

    Double ib1 = ibc;

    Double ib2 = Double.valueOf(i+1.);

    return ib1 + ib2;

  }

  //===============================================

  static double test(double f, int i) {

    Double ib = new Double(f);

    if ((i&1) == 0)

      ib = f+1.;

    return ib;

  }

  static double testb(double f, int i) {

    Double ib = f;

    if ((i&1) == 0)

      ib = (f+1.);

    return ib;

  }

  static double testm(double f, int i) {

    Double ib = f;

    if ((i&1) == 0)

      ib = new Double(f+1.);

    return ib;

  }

  static double testp(double f, int i, Double ib) {

    if ((i&1) == 0)

      ib = new Double(f+1.);

    return ib;

  }

  static double testc(double f, int i) {

    Double ib = ibc;

    if ((i&1) == 0)

      ib = new Double(f+1.);

    return ib;

  }

  static double test2(double f, int i) {

    Double ib1 = new Double(f);

    Double ib2 = new Double(f+1.);

    if ((i&1) == 0) {

      ib1 = new Double(f+1.);

      ib2 = new Double(f+2.);

    }

    return ib1+ib2;

  }

  static double testb2(double f, int i) {

    Double ib1 = f;

    Double ib2 = f+1.;

    if ((i&1) == 0) {

      ib1 = (f+1.);

      ib2 = (f+2.);

    }

    return ib1+ib2;

  }

  static double testm2(double f, int i) {

    Double ib1 = new Double(f);

    Double ib2 = f+1.;

    if ((i&1) == 0) {

      ib1 = new Double(f+1.);

      ib2 = (f+2.);

    }

    return ib1+ib2;

  }

  static double testp2(double f, int i, Double ib1) {

    Double ib2 = f+1.;

    if ((i&1) == 0) {

      ib1 = new Double(f+1.);

      ib2 = (f+2.);

    }

    return ib1+ib2;

  }

  static double testc2(double f, int i) {

    Double ib1 = ibc;

    Double ib2 = f+1.;

    if ((i&1) == 0) {

      ib1 = (ibc+1.);

      ib2 = (f+2.);

    }

    return ib1+ib2;

  }

  //===============================================

  static double sum(double[] a) {

    double result = 1.;

    for (Double i : a)

        result += i;

    return result;

  }

  static double sumb(double[] a) {

    Double result = 1.;

    for (Double i : a)

        result += i;

    return result;

  }

  static double sumc(double[] a) {

    Double result = ibc;

    for (Double i : a)

        result += i;

    return result;

  }

  static double sumf(double[] a) {

    Double result = foob(1.);

    for (Double i : a)

        result += i;

    return result;

  }

  static double sump(double[] a, Double result) {

    for (Double i : a)

        result += i;

    return result;

  }

  static double sum2(double[] a) {

    double result1 = 1.;

    double result2 = 1.;

    for (Double i : a) {

        result1 += i;

        result2 += i + 1.;

    }

    return result1 + result2;

  }

  static double sumb2(double[] a) {

    Double result1 = 1.;

    Double result2 = 1.;

    for (Double i : a) {

        result1 += i;

        result2 += i + 1.;

    }

    return result1 + result2;

  }

  static double summ2(double[] a) {

    Double result1 = 1.;

    Double result2 = new Double(1.);

    for (Double i : a) {

        result1 += i;

        result2 += new Double(i + 1.);

    }

    return result1 + result2;

  }

  static double sump2(double[] a, Double result2) {

    Double result1 = 1.;

    for (Double i : a) {

        result1 += i;

        result2 += i + 1.;

    }

    return result1 + result2;

  }

  static double sumc2(double[] a) {

    Double result1 = 1.;

    Double result2 = ibc;

    for (Double i : a) {

        result1 += i;

        result2 += i + ibc;

    }

    return result1 + result2;

  }

  //===============================================

  static double remi_sum() {

    Double j = new Double(1.);

    for (int i = 0; i< 1000; i++) {

      j = new Double(j + 1.);

    }

    return j;

  }

  static double remi_sumb() {

    Double j = Double.valueOf(1.);

    for (int i = 0; i< 1000; i++) {

      j = j + 1.;

    }

    return j;

  }

  static double remi_sumf() {

    Double j = foob(1.);

    for (int i = 0; i< 1000; i++) {

      j = j + 1.;

    }

    return j;

  }

  static double remi_sump(Double j) {

    for (int i = 0; i< 1000; i++) {

      j = new Double(j + 1.);

    }

    return j;

  }

  static double remi_sumc() {

    Double j = ibc;

    for (int i = 0; i< 1000; i++) {

      j = j + ibc;

    }

    return j;

  }

  static double remi_sum2() {

    Double j1 = new Double(1.);

    Double j2 = new Double(1.);

    for (int i = 0; i< 1000; i++) {

      j1 = new Double(j1 + 1.);

      j2 = new Double(j2 + 2.);

    }

    return j1 + j2;

  }

  static double remi_sumb2() {

    Double j1 = Double.valueOf(1.);

    Double j2 = Double.valueOf(1.);

    for (int i = 0; i< 1000; i++) {

      j1 = j1 + 1.;

      j2 = j2 + 2.;

    }

    return j1 + j2;

  }

  static double remi_summ2() {

    Double j1 = new Double(1.);

    Double j2 = Double.valueOf(1.);

    for (int i = 0; i< 1000; i++) {

      j1 = new Double(j1 + 1.);

      j2 = j2 + 2.;

    }

    return j1 + j2;

  }

  static double remi_sump2(Double j1) {

    Double j2 = Double.valueOf(1.);

    for (int i = 0; i< 1000; i++) {

      j1 = new Double(j1 + 1.);

      j2 = j2 + 2.;

    }

    return j1 + j2;

  }

  static double remi_sumc2() {

    Double j1 = ibc;

    Double j2 = Double.valueOf(1.);

    for (int i = 0; i< 1000; i++) {

      j1 = j1 + ibc;

      j2 = j2 + 2.;

    }

    return j1 + j2;

  }

  //===============================================

  // Safepointa and debug info for deoptimization

  static double simple_deop(double i) {

    Double ib = new Double(foo(i));

    dummy();

    return ib;

  }

  static double simpleb_deop(double i) {

    Double ib = Double.valueOf(foo(i));

    dummy();

    return ib;

  }

  static double simplef_deop(double i) {

    Double ib = foob(i);

    dummy();

    return ib;

  }

  static double simplep_deop(Double ib) {

    dummy();

    return ib;

  }

  static double simplec_deop(double i) {

    Double ib = ibc;

    dummy();

    return ib;

  }

  static double test_deop(double f, int i) {

    Double ib = new Double(foo(f));

    if ((i&1) == 0)

      ib = foo(f+1.);

    dummy();

    return ib;

  }

  static double testb_deop(double f, int i) {

    Double ib = foo(f);

    if ((i&1) == 0)

      ib = foo(f+1.);

    dummy();

    return ib;

  }

  static double testf_deop(double f, int i) {

    Double ib = foob(f);

    if ((i&1) == 0)

      ib = foo(f+1.);

    dummy();

    return ib;

  }

  static double testp_deop(double f, int i, Double ib) {

    if ((i&1) == 0)

      ib = foo(f+1.);

    dummy();

    return ib;

  }

  static double testc_deop(double f, int i) {

    Double ib = ibc;

    if ((i&1) == 0)

      ib = foo(f+1.);

    dummy();

    return ib;

  }

  static double sum_deop(double[] a) {

    double result = 1.;

    for (Double i : a)

        result += foo(i);

    dummy();

    return result;

  }

  static double sumb_deop(double[] a) {

    Double result = 1.;

    for (Double i : a)

        result += foo(i);

    dummy();

    return result;

  }

  static double sumf_deop(double[] a) {

    Double result = 1.;

    for (Double i : a)

        result += foob(i);

    dummy();

    return result;

  }

  static double sump_deop(double[] a, Double result) {

    for (Double i : a)

        result += foob(i);

    dummy();

    return result;

  }

  static double sumc_deop(double[] a) {

    Double result = ibc;

    for (Double i : a)

        result += foo(i);

    dummy();

    return result;

  }

  static double remi_sum_deop() {

    Double j = new Double(foo(1.));

    for (int i = 0; i< 1000; i++) {

      j = new Double(foo(j + 1.));

    }

    dummy();

    return j;

  }

  static double remi_sumb_deop() {

    Double j = Double.valueOf(foo(1.));

    for (int i = 0; i< 1000; i++) {

      j = foo(j + 1.);

    }

    dummy();

    return j;

  }

  static double remi_sumf_deop() {

    Double j = foob(1.);

    for (int i = 0; i< 1000; i++) {

      j = foo(j + 1.);

    }

    dummy();

    return j;

  }

  static double remi_sump_deop(Double j) {

    for (int i = 0; i< 1000; i++) {

      j = foo(j + 1.);

    }

    dummy();

    return j;

  }

  static double remi_sumc_deop() {

    Double j = ibc;

    for (int i = 0; i< 1000; i++) {

      j = foo(j + 1.);

    }

    dummy();

    return j;

  }

  //===============================================

  // Conditional increment

  static double remi_sum_cond() {

    Double j = new Double(1.);

    for (int i = 0; i< 1000; i++) {

      if ((i&1) == 0) {

        j = new Double(j + 1.);

      }