/*

 * 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 TestFloatBoxing

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

 * -XX:CompileCommand=exclude,TestFloatBoxing.dummy -XX:CompileCommand=exclude,TestFloatBoxing.foo -XX:CompileCommand=exclude,TestFloatBoxing.foob TestFloatBoxing

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

 * -XX:CompileCommand=exclude,TestFloatBoxing.dummy -XX:CompileCommand=exclude,TestFloatBoxing.foo -XX:CompileCommand=exclude,TestFloatBoxing.foob TestFloatBoxing

 *

 */

public class TestFloatBoxing {

  static final Float ibc = new Float(1.f);

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

  // Non-inlined methods to test deoptimization info

  static void  dummy()       { }

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

  static Float foob(float i) { return Float.valueOf(i); }

  static float simple(float i) {

    Float ib = new Float(i);

    return ib;

  }

  static float simpleb(float i) {

    Float ib = Float.valueOf(i);

    return ib;

  }

  static float simplec() {

    Float ib = ibc;

    return ib;

  }

  static float simplef(float i) {

    Float ib = foob(i);

    return ib;

  }

  static float simplep(Float ib) {

    return ib;

  }

  static float simple2(float i) {

    Float ib1 = new Float(i);

    Float ib2 = new Float(i+1.f);

    return ib1 + ib2;

  }

  static float simpleb2(float i) {

    Float ib1 = Float.valueOf(i);

    Float ib2 = Float.valueOf(i+1.f);

    return ib1 + ib2;

  }

  static float simplem2(float i) {

    Float ib1 = new Float(i);

    Float ib2 = Float.valueOf(i+1.f);

    return ib1 + ib2;

  }

  static float simplep2(float i, Float ib1) {

    Float ib2 = Float.valueOf(i+1.f);

    return ib1 + ib2;

  }

  static float simplec2(float i) {

    Float ib1 = ibc;

    Float ib2 = Float.valueOf(i+1.f);

    return ib1 + ib2;

  }

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

  static float test(float f, int i) {

    Float ib = new Float(f);

    if ((i&1) == 0)

      ib = f+1.f;

    return ib;

  }

  static float testb(float f, int i) {

    Float ib = f;

    if ((i&1) == 0)

      ib = (f+1.f);

    return ib;

  }

  static float testm(float f, int i) {

    Float ib = f;

    if ((i&1) == 0)

      ib = new Float(f+1.f);

    return ib;

  }

  static float testp(float f, int i, Float ib) {

    if ((i&1) == 0)

      ib = new Float(f+1.f);

    return ib;

  }

  static float testc(float f, int i) {

    Float ib = ibc;

    if ((i&1) == 0)

      ib = new Float(f+1.f);

    return ib;

  }

  static float test2(float f, int i) {

    Float ib1 = new Float(f);

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

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

      ib1 = new Float(f+1.f);

      ib2 = new Float(f+2.f);

    }

    return ib1+ib2;

  }

  static float testb2(float f, int i) {

    Float ib1 = f;

    Float ib2 = f+1.f;

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

      ib1 = (f+1.f);

      ib2 = (f+2.f);

    }

    return ib1+ib2;

  }

  static float testm2(float f, int i) {

    Float ib1 = new Float(f);

    Float ib2 = f+1.f;

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

      ib1 = new Float(f+1.f);

      ib2 = (f+2.f);

    }

    return ib1+ib2;

  }

  static float testp2(float f, int i, Float ib1) {

    Float ib2 = f+1.f;

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

      ib1 = new Float(f+1.f);

      ib2 = (f+2.f);

    }

    return ib1+ib2;

  }

  static float testc2(float f, int i) {

    Float ib1 = ibc;

    Float ib2 = f+1.f;

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

      ib1 = (ibc+1.f);

      ib2 = (f+2.f);

    }

    return ib1+ib2;

  }

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

  static float sum(float[] a) {

    float result = 1.f;

    for (Float i : a)

        result += i;

    return result;

  }

  static float sumb(float[] a) {

    Float result = 1.f;

    for (Float i : a)

        result += i;

    return result;

  }

  static float sumc(float[] a) {

    Float result = ibc;

    for (Float i : a)

        result += i;

    return result;

  }

  static float sumf(float[] a) {

    Float result = foob(1.f);

    for (Float i : a)

        result += i;

    return result;

  }

  static float sump(float[] a, Float result) {

    for (Float i : a)

        result += i;

    return result;

  }

  static float sum2(float[] a) {

    float result1 = 1.f;

    float result2 = 1.f;

    for (Float i : a) {

        result1 += i;

        result2 += i + 1.f;

    }

    return result1 + result2;

  }

  static float sumb2(float[] a) {

    Float result1 = 1.f;

    Float result2 = 1.f;

    for (Float i : a) {

        result1 += i;

        result2 += i + 1.f;

    }

    return result1 + result2;

  }

  static float summ2(float[] a) {

    Float result1 = 1.f;

    Float result2 = new Float(1.f);

    for (Float i : a) {

        result1 += i;

        result2 += new Float(i + 1.f);

    }

    return result1 + result2;

  }

  static float sump2(float[] a, Float result2) {

    Float result1 = 1.f;

    for (Float i : a) {

        result1 += i;

        result2 += i + 1.f;

    }

    return result1 + result2;

  }

  static float sumc2(float[] a) {

    Float result1 = 1.f;

    Float result2 = ibc;

    for (Float i : a) {

        result1 += i;

        result2 += i + ibc;

    }

    return result1 + result2;

  }

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

  static float remi_sum() {

    Float j = new Float(1.f);

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

      j = new Float(j + 1.f);

    }

    return j;

  }

  static float remi_sumb() {

    Float j = Float.valueOf(1.f);

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

      j = j + 1.f;

    }

    return j;

  }

  static float remi_sumf() {

    Float j = foob(1.f);

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

      j = j + 1.f;

    }

    return j;

  }

  static float remi_sump(Float j) {

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

      j = new Float(j + 1.f);

    }

    return j;

  }

  static float remi_sumc() {

    Float j = ibc;

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

      j = j + ibc;

    }

    return j;

  }

  static float remi_sum2() {

    Float j1 = new Float(1.f);

    Float j2 = new Float(1.f);

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

      j1 = new Float(j1 + 1.f);

      j2 = new Float(j2 + 2.f);

    }

    return j1 + j2;

  }

  static float remi_sumb2() {

    Float j1 = Float.valueOf(1.f);

    Float j2 = Float.valueOf(1.f);

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

      j1 = j1 + 1.f;

      j2 = j2 + 2.f;

    }

    return j1 + j2;

  }

  static float remi_summ2() {

    Float j1 = new Float(1.f);

    Float j2 = Float.valueOf(1.f);

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

      j1 = new Float(j1 + 1.f);

      j2 = j2 + 2.f;

    }

    return j1 + j2;

  }

  static float remi_sump2(Float j1) {

    Float j2 = Float.valueOf(1.f);

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

      j1 = new Float(j1 + 1.f);

      j2 = j2 + 2.f;

    }

    return j1 + j2;

  }

  static float remi_sumc2() {

    Float j1 = ibc;

    Float j2 = Float.valueOf(1.f);

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

      j1 = j1 + ibc;

      j2 = j2 + 2.f;

    }

    return j1 + j2;

  }

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

  // Safepointa and debug info for deoptimization

  static float simple_deop(float i) {

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

    dummy();

    return ib;

  }

  static float simpleb_deop(float i) {

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

    dummy();

    return ib;

  }

  static float simplef_deop(float i) {

    Float ib = foob(i);

    dummy();

    return ib;

  }

  static float simplep_deop(Float ib) {

    dummy();

    return ib;

  }

  static float simplec_deop(float i) {

    Float ib = ibc;

    dummy();

    return ib;

  }

  static float test_deop(float f, int i) {

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

    if ((i&1) == 0)

      ib = foo(f+1.f);

    dummy();

    return ib;

  }

  static float testb_deop(float f, int i) {

    Float ib = foo(f);

    if ((i&1) == 0)

      ib = foo(f+1.f);

    dummy();

    return ib;

  }

  static float testf_deop(float f, int i) {

    Float ib = foob(f);

    if ((i&1) == 0)

      ib = foo(f+1.f);

    dummy();

    return ib;

  }

  static float testp_deop(float f, int i, Float ib) {

    if ((i&1) == 0)

      ib = foo(f+1.f);

    dummy();

    return ib;

  }

  static float testc_deop(float f, int i) {

    Float ib = ibc;

    if ((i&1) == 0)

      ib = foo(f+1.f);

    dummy();

    return ib;

  }

  static float sum_deop(float[] a) {

    float result = 1.f;

    for (Float i : a)

        result += foo(i);

    dummy();

    return result;

  }

  static float sumb_deop(float[] a) {

    Float result = 1.f;

    for (Float i : a)

        result += foo(i);

    dummy();

    return result;

  }

  static float sumf_deop(float[] a) {

    Float result = 1.f;

    for (Float i : a)

        result += foob(i);

    dummy();

    return result;

  }

  static float sump_deop(float[] a, Float result) {

    for (Float i : a)

        result += foob(i);

    dummy();

    return result;

  }

  static float sumc_deop(float[] a) {

    Float result = ibc;

    for (Float i : a)

        result += foo(i);

    dummy();

    return result;

  }

  static float remi_sum_deop() {

    Float j = new Float(foo(1.f));

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

      j = new Float(foo(j + 1.f));

    }

    dummy();

    return j;

  }

  static float remi_sumb_deop() {

    Float j = Float.valueOf(foo(1.f));

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

      j = foo(j + 1.f);

    }

    dummy();

    return j;

  }

  static float remi_sumf_deop() {

    Float j = foob(1.f);

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

      j = foo(j + 1.f);

    }

    dummy();

    return j;

  }

  static float remi_sump_deop(Float j) {

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

      j = foo(j + 1.f);

    }

    dummy();

    return j;

  }

  static float remi_sumc_deop() {

    Float j = ibc;

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

      j = foo(j + 1.f);

    }

    dummy();

    return j;

  }

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

  // Conditional increment

  static float remi_sum_cond() {

    Float j = new Float(1.f);

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

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

        j = new Float(j + 1.f);

      }

    }

    return j;

  }

  static float remi_sumb_cond() {

    Float j = Float.valueOf(1.f);

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

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

        j = j + 1.f;

      }

    }