src/cpu/sparc/vm/c1_LIRGenerator_sparc.cpp

*** 1,7 ****
  /*
!  * Copyright (c) 2005, 2016, 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.
--- 1,7 ----
  /*
!  * Copyright (c) 2005, 2017, 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.
*** 213,229 ****
          __ move(LIR_OprFact::intptrConst(array_offset), base_opr);
          __ add(base_opr, array_opr, base_opr);
        }
      }
    } else {
- #ifdef _LP64
      if (index_opr->type() == T_INT) {
        LIR_Opr tmp = new_register(T_LONG);
        __ convert(Bytecodes::_i2l, index_opr, tmp);
        index_opr = tmp;
      }
- #endif
  
      base_opr = new_pointer_register();
      assert (index_opr->is_register(), "Must be register");
      if (shift > 0) {
        __ shift_left(index_opr, shift, base_opr);
--- 213,227 ----
*** 1308,1345 ****
  }
  
  
  void LIRGenerator::volatile_field_store(LIR_Opr value, LIR_Address* address,
                                          CodeEmitInfo* info) {
- #ifdef _LP64
    __ store(value, address, info);
- #else
-   __ volatile_store_mem_reg(value, address, info);
- #endif
  }
  
  void LIRGenerator::volatile_field_load(LIR_Address* address, LIR_Opr result,
                                         CodeEmitInfo* info) {
- #ifdef _LP64
    __ load(address, result, info);
- #else
-   __ volatile_load_mem_reg(address, result, info);
- #endif
  }
  
  
  void LIRGenerator::put_Object_unsafe(LIR_Opr src, LIR_Opr offset, LIR_Opr data,
                                       BasicType type, bool is_volatile) {
    LIR_Opr base_op = src;
    LIR_Opr index_op = offset;
  
    bool is_obj = (type == T_ARRAY || type == T_OBJECT);
- #ifndef _LP64
-   if (is_volatile && type == T_LONG) {
-     __ volatile_store_unsafe_reg(data, src, offset, type, NULL, lir_patch_none);
-   } else
- #endif
      {
        if (type == T_BOOLEAN) {
          type = T_BYTE;
        }
        LIR_Address* addr;
--- 1306,1330 ----
*** 1365,1379 ****
  }
  
  
  void LIRGenerator::get_Object_unsafe(LIR_Opr dst, LIR_Opr src, LIR_Opr offset,
                                       BasicType type, bool is_volatile) {
- #ifndef _LP64
-   if (is_volatile && type == T_LONG) {
-     __ volatile_load_unsafe_reg(src, offset, dst, type, NULL, lir_patch_none);
-   } else
- #endif
      {
      LIR_Address* addr = new LIR_Address(src, offset, type);
      __ load(addr, dst);
    }
  }
--- 1350,1359 ----
*** 1398,1414 ****
  
    assert (!x->is_add() && (type == T_INT || (is_obj LP64_ONLY(&& UseCompressedOops))), "unexpected type");
    LIR_Address* addr;
    if (offset->is_constant()) {
  
- #ifdef _LP64
      jlong l = offset->as_jlong();
      assert((jlong)((jint)l) == l, "offset too large for constant");
      jint c = (jint)l;
- #else
-     jint c = offset->as_jint();
- #endif
      addr = new LIR_Address(src.result(), c, type);
    } else {
      addr = new LIR_Address(src.result(), offset, type);
    }
  
--- 1378,1390 ----