Unify 64bit int constant definitions.

LL and ULL prefixes are word size dependent, use the INT64_C and UINT64_C
macros instead.

Change-Id: I5b70027651898814fc0b3e9e22a18a1047e76cb9

10 files changed, 78 insertions, 75 deletions

diff --git a/compiler/dex/mir_graph.h b/compiler/dex/mir_graph.h
index 8a3341464f..2abc0cc39c 100644
--- a/compiler/dex/mir_graph.h
+++ b/compiler/dex/mir_graph.h
@@ -17,6 +17,8 @@
 #ifndef ART_COMPILER_DEX_MIR_GRAPH_H_
 #define ART_COMPILER_DEX_MIR_GRAPH_H_
 
+#include <stdint.h>
+
 #include "dex_file.h"
 #include "dex_instruction.h"
 #include "compiler_ir.h"
@@ -99,40 +101,40 @@ enum DataFlowAttributePos {
   kDoLVN,                // Worth computing local value numbers.
 };
 
-#define DF_NOP                  0ULL
-#define DF_UA                   (1ULL << kUA)
-#define DF_UB                   (1ULL << kUB)
-#define DF_UC                   (1ULL << kUC)
-#define DF_A_WIDE               (1ULL << kAWide)
-#define DF_B_WIDE               (1ULL << kBWide)
-#define DF_C_WIDE               (1ULL << kCWide)
-#define DF_DA                   (1ULL << kDA)
-#define DF_IS_MOVE              (1ULL << kIsMove)
-#define DF_SETS_CONST           (1ULL << kSetsConst)
-#define DF_FORMAT_35C           (1ULL << kFormat35c)
-#define DF_FORMAT_3RC           (1ULL << kFormat3rc)
-#define DF_NULL_CHK_0           (1ULL << kNullCheckSrc0)
-#define DF_NULL_CHK_1           (1ULL << kNullCheckSrc1)
-#define DF_NULL_CHK_2           (1ULL << kNullCheckSrc2)
-#define DF_NULL_CHK_OUT0        (1ULL << kNullCheckOut0)
-#define DF_NON_NULL_DST         (1ULL << kDstNonNull)
-#define DF_NON_NULL_RET         (1ULL << kRetNonNull)
-#define DF_NULL_TRANSFER_0      (1ULL << kNullTransferSrc0)
-#define DF_NULL_TRANSFER_N      (1ULL << kNullTransferSrcN)
-#define DF_RANGE_CHK_1          (1ULL << kRangeCheckSrc1)
-#define DF_RANGE_CHK_2          (1ULL << kRangeCheckSrc2)
-#define DF_RANGE_CHK_3          (1ULL << kRangeCheckSrc3)
-#define DF_FP_A                 (1ULL << kFPA)
-#define DF_FP_B                 (1ULL << kFPB)
-#define DF_FP_C                 (1ULL << kFPC)
-#define DF_CORE_A               (1ULL << kCoreA)
-#define DF_CORE_B               (1ULL << kCoreB)
-#define DF_CORE_C               (1ULL << kCoreC)
-#define DF_REF_A                (1ULL << kRefA)
-#define DF_REF_B                (1ULL << kRefB)
-#define DF_REF_C                (1ULL << kRefC)
-#define DF_UMS                  (1ULL << kUsesMethodStar)
-#define DF_LVN                  (1ULL << kDoLVN)
+#define DF_NOP                  UINT64_C(0)
+#define DF_UA                   (UINT64_C(1) << kUA)
+#define DF_UB                   (UINT64_C(1) << kUB)
+#define DF_UC                   (UINT64_C(1) << kUC)
+#define DF_A_WIDE               (UINT64_C(1) << kAWide)
+#define DF_B_WIDE               (UINT64_C(1) << kBWide)
+#define DF_C_WIDE               (UINT64_C(1) << kCWide)
+#define DF_DA                   (UINT64_C(1) << kDA)
+#define DF_IS_MOVE              (UINT64_C(1) << kIsMove)
+#define DF_SETS_CONST           (UINT64_C(1) << kSetsConst)
+#define DF_FORMAT_35C           (UINT64_C(1) << kFormat35c)
+#define DF_FORMAT_3RC           (UINT64_C(1) << kFormat3rc)
+#define DF_NULL_CHK_0           (UINT64_C(1) << kNullCheckSrc0)
+#define DF_NULL_CHK_1           (UINT64_C(1) << kNullCheckSrc1)
+#define DF_NULL_CHK_2           (UINT64_C(1) << kNullCheckSrc2)
+#define DF_NULL_CHK_OUT0        (UINT64_C(1) << kNullCheckOut0)
+#define DF_NON_NULL_DST         (UINT64_C(1) << kDstNonNull)
+#define DF_NON_NULL_RET         (UINT64_C(1) << kRetNonNull)
+#define DF_NULL_TRANSFER_0      (UINT64_C(1) << kNullTransferSrc0)
+#define DF_NULL_TRANSFER_N      (UINT64_C(1) << kNullTransferSrcN)
+#define DF_RANGE_CHK_1          (UINT64_C(1) << kRangeCheckSrc1)
+#define DF_RANGE_CHK_2          (UINT64_C(1) << kRangeCheckSrc2)
+#define DF_RANGE_CHK_3          (UINT64_C(1) << kRangeCheckSrc3)
+#define DF_FP_A                 (UINT64_C(1) << kFPA)
+#define DF_FP_B                 (UINT64_C(1) << kFPB)
+#define DF_FP_C                 (UINT64_C(1) << kFPC)
+#define DF_CORE_A               (UINT64_C(1) << kCoreA)
+#define DF_CORE_B               (UINT64_C(1) << kCoreB)
+#define DF_CORE_C               (UINT64_C(1) << kCoreC)
+#define DF_REF_A                (UINT64_C(1) << kRefA)
+#define DF_REF_B                (UINT64_C(1) << kRefB)
+#define DF_REF_C                (UINT64_C(1) << kRefC)
+#define DF_UMS                  (UINT64_C(1) << kUsesMethodStar)
+#define DF_LVN                  (UINT64_C(1) << kDoLVN)
 
 #define DF_HAS_USES             (DF_UA | DF_UB | DF_UC)
 
diff --git a/compiler/dex/quick/arm/fp_arm.cc b/compiler/dex/quick/arm/fp_arm.cc
index cdbfa35d08..6868f6fdbb 100644
--- a/compiler/dex/quick/arm/fp_arm.cc
+++ b/compiler/dex/quick/arm/fp_arm.cc
@@ -151,7 +151,7 @@ void ArmMir2Lir::GenConversion(Instruction::Code opcode,
 
       NewLIR2(kThumb2VcvtF64S32, tmp1 | ARM_FP_DOUBLE, (src_reg & ~ARM_FP_DOUBLE) + 1);
       NewLIR2(kThumb2VcvtF64U32, S2d(rl_result.reg.GetReg(), rl_result.reg.GetHighReg()), (src_reg & ~ARM_FP_DOUBLE));
-      LoadConstantWide(tmp2, tmp2 + 1, 0x41f0000000000000LL);
+      LoadConstantWide(tmp2, tmp2 + 1, INT64_C(0x41f0000000000000));
       NewLIR3(kThumb2VmlaF64, S2d(rl_result.reg.GetReg(), rl_result.reg.GetHighReg()), tmp1 | ARM_FP_DOUBLE,
               tmp2 | ARM_FP_DOUBLE);
       FreeTemp(tmp1);
@@ -173,7 +173,7 @@ void ArmMir2Lir::GenConversion(Instruction::Code opcode,
       // Long to double.
       NewLIR2(kThumb2VcvtF64S32, high_val | ARM_FP_DOUBLE, (src_reg & ~ARM_FP_DOUBLE) + 1);
       NewLIR2(kThumb2VcvtF64U32, low_val | ARM_FP_DOUBLE, (src_reg & ~ARM_FP_DOUBLE));
-      LoadConstantWide(const_val, const_val + 1, 0x41f0000000000000LL);
+      LoadConstantWide(const_val, const_val + 1, INT64_C(0x41f0000000000000));
       NewLIR3(kThumb2VmlaF64, low_val | ARM_FP_DOUBLE, high_val | ARM_FP_DOUBLE,
           const_val | ARM_FP_DOUBLE);
       // Double to float.
diff --git a/compiler/dex/quick/arm/utility_arm.cc b/compiler/dex/quick/arm/utility_arm.cc
index c2cfb4dbc1..8b02a42356 100644
--- a/compiler/dex/quick/arm/utility_arm.cc
+++ b/compiler/dex/quick/arm/utility_arm.cc
@@ -49,12 +49,12 @@ static int32_t EncodeImmSingle(int32_t value) {
  */
 static int32_t EncodeImmDouble(int64_t value) {
   int32_t res;
-  int32_t bit_a = (value & 0x8000000000000000ll) >> 63;
-  int32_t not_bit_b = (value & 0x4000000000000000ll) >> 62;
-  int32_t bit_b = (value & 0x2000000000000000ll) >> 61;
-  int32_t b_smear = (value & 0x3fc0000000000000ll) >> 54;
-  int32_t slice =  (value & 0x003f000000000000ll) >> 48;
-  uint64_t zeroes = (value & 0x0000ffffffffffffll);
+  int32_t bit_a = (value & INT64_C(0x8000000000000000)) >> 63;
+  int32_t not_bit_b = (value & INT64_C(0x4000000000000000)) >> 62;
+  int32_t bit_b = (value & INT64_C(0x2000000000000000)) >> 61;
+  int32_t b_smear = (value & INT64_C(0x3fc0000000000000)) >> 54;
+  int32_t slice =  (value & INT64_C(0x003f000000000000)) >> 48;
+  uint64_t zeroes = (value & INT64_C(0x0000ffffffffffff));
   if (zeroes != 0ull)
     return -1;
   if (bit_b) {
diff --git a/compiler/jni/jni_compiler_test.cc b/compiler/jni/jni_compiler_test.cc
index 3a51d87f6a..df5afa223a 100644
--- a/compiler/jni/jni_compiler_test.cc
+++ b/compiler/jni/jni_compiler_test.cc
@@ -252,8 +252,8 @@ TEST_F(JniCompilerTest, CompileAndRunLongLongMethod) {
                reinterpret_cast<void*>(&Java_MyClassNatives_fooJJ));
 
   EXPECT_EQ(0, gJava_MyClassNatives_fooJJ_calls);
-  jlong a = 0x1234567890ABCDEFll;
-  jlong b = 0xFEDCBA0987654321ll;
+  jlong a = INT64_C(0x1234567890ABCDEF);
+  jlong b = INT64_C(0xFEDCBA0987654321);
   jlong result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, a, b);
   EXPECT_EQ(a - b, result);
   EXPECT_EQ(1, gJava_MyClassNatives_fooJJ_calls);
@@ -681,7 +681,7 @@ TEST_F(JniCompilerTest, JavaLangSystemArrayCopy) {
 jboolean my_casi(JNIEnv* env, jobject unsafe, jobject obj, jlong offset, jint expected, jint newval) {
   EXPECT_TRUE(env->IsSameObject(JniCompilerTest::jobj_, unsafe));
   EXPECT_TRUE(env->IsSameObject(JniCompilerTest::jobj_, obj));
-  EXPECT_EQ(0x12345678ABCDEF88ll, offset);
+  EXPECT_EQ(INT64_C(0x12345678ABCDEF88), offset);
   EXPECT_EQ(static_cast<jint>(0xCAFEF00D), expected);
   EXPECT_EQ(static_cast<jint>(0xEBADF00D), newval);
   return JNI_TRUE;
@@ -691,7 +691,8 @@ TEST_F(JniCompilerTest, CompareAndSwapInt) {
   TEST_DISABLED_FOR_PORTABLE();
   SetUpForTest(false, "compareAndSwapInt", "(Ljava/lang/Object;JII)Z",
                reinterpret_cast<void*>(&my_casi));
-  jboolean result = env_->CallBooleanMethod(jobj_, jmethod_, jobj_, 0x12345678ABCDEF88ll, 0xCAFEF00D, 0xEBADF00D);
+  jboolean result = env_->CallBooleanMethod(jobj_, jmethod_, jobj_, INT64_C(0x12345678ABCDEF88),
+                                            0xCAFEF00D, 0xEBADF00D);
   EXPECT_EQ(result, JNI_TRUE);
 }
 
@@ -709,7 +710,7 @@ TEST_F(JniCompilerTest, GetText) {
   SetUpForTest(true, "getText", "(JLjava/lang/Object;JLjava/lang/Object;)I",
                reinterpret_cast<void*>(&my_gettext));
   jint result = env_->CallStaticIntMethod(jklass_, jmethod_, 0x12345678ABCDEF88ll, jobj_,
-                                          0x7FEDCBA987654321ll, jobj_);
+                                          INT64_C(0x7FEDCBA987654321), jobj_);
   EXPECT_EQ(result, 42);
 }
 
@@ -827,7 +828,7 @@ void Java_MyClassNatives_checkParameterAlign(JNIEnv* env, jobject thisObj, jint
   ScopedObjectAccess soa(Thread::Current());
   EXPECT_EQ(1U, Thread::Current()->NumStackReferences());*/
   EXPECT_EQ(i1, 1234);
-  EXPECT_EQ(l1, 5678);
+  EXPECT_EQ(l1, INT64_C(0x12345678ABCDEF0));
 }
 
 TEST_F(JniCompilerTest, CheckParameterAlign) {
@@ -835,7 +836,7 @@ TEST_F(JniCompilerTest, CheckParameterAlign) {
   SetUpForTest(false, "checkParameterAlign", "(IJ)V",
                reinterpret_cast<void*>(&Java_MyClassNatives_checkParameterAlign));
 
-  env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_, 1234, 5678LLU);
+  env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_, 1234, INT64_C(0x12345678ABCDEF0));
 }
 
 void Java_MyClassNatives_maxParamNumber(JNIEnv* env, jobject thisObj,
diff --git a/runtime/class_linker_test.cc b/runtime/class_linker_test.cc
index e6aa9c2cc1..d0555fff0f 100644
--- a/runtime/class_linker_test.cc
+++ b/runtime/class_linker_test.cc
@@ -918,7 +918,7 @@ TEST_F(ClassLinkerTest, StaticFields) {
   fh.ChangeField(s5);
   EXPECT_TRUE(fh.GetTypeAsPrimitiveType() == Primitive::kPrimLong);
   EXPECT_EQ(0x1234567890abcdefLL, s5->GetLong(statics.get()));
-  s5->SetLong<false>(statics.get(), 0x34567890abcdef12LL);
+  s5->SetLong<false>(statics.get(), INT64_C(0x34567890abcdef12));
 
   mirror::ArtField* s6 = statics->FindStaticField("s6", "F");
   fh.ChangeField(s6);
@@ -946,7 +946,7 @@ TEST_F(ClassLinkerTest, StaticFields) {
   EXPECT_EQ('b', s2->GetChar(statics.get()));
   EXPECT_EQ(-535, s3->GetShort(statics.get()));
   EXPECT_EQ(2000000001, s4->GetInt(statics.get()));
-  EXPECT_EQ(0x34567890abcdef12LL, s5->GetLong(statics.get()));
+  EXPECT_EQ(INT64_C(0x34567890abcdef12), s5->GetLong(statics.get()));
   EXPECT_EQ(0.75, s6->GetFloat(statics.get()));
   EXPECT_EQ(16777219, s7->GetDouble(statics.get()));
   EXPECT_TRUE(s8->GetObject(statics.get())->AsString()->Equals("robot"));
diff --git a/runtime/entrypoints/math_entrypoints_test.cc b/runtime/entrypoints/math_entrypoints_test.cc
index b69aeb441a..f70a2da2f5 100644
--- a/runtime/entrypoints/math_entrypoints_test.cc
+++ b/runtime/entrypoints/math_entrypoints_test.cc
@@ -27,25 +27,25 @@ class MathEntrypointsTest : public CommonRuntimeTest {};
 TEST_F(MathEntrypointsTest, DoubleToLong) {
   EXPECT_EQ(std::numeric_limits<int64_t>::max(), art_d2l(1.85e19));
   EXPECT_EQ(std::numeric_limits<int64_t>::min(), art_d2l(-1.85e19));
-  EXPECT_EQ(0LL, art_d2l(0));
-  EXPECT_EQ(1LL, art_d2l(1.0));
-  EXPECT_EQ(10LL, art_d2l(10.0));
-  EXPECT_EQ(100LL, art_d2l(100.0));
-  EXPECT_EQ(-1LL, art_d2l(-1.0));
-  EXPECT_EQ(-10LL, art_d2l(-10.0));
-  EXPECT_EQ(-100LL, art_d2l(-100.0));
+  EXPECT_EQ(INT64_C(0), art_d2l(0));
+  EXPECT_EQ(INT64_C(1), art_d2l(1.0));
+  EXPECT_EQ(INT64_C(10), art_d2l(10.0));
+  EXPECT_EQ(INT64_C(100), art_d2l(100.0));
+  EXPECT_EQ(INT64_C(-1), art_d2l(-1.0));
+  EXPECT_EQ(INT64_C(-10), art_d2l(-10.0));
+  EXPECT_EQ(INT64_C(-100), art_d2l(-100.0));
 }
 
 TEST_F(MathEntrypointsTest, FloatToLong) {
   EXPECT_EQ(std::numeric_limits<int64_t>::max(), art_f2l(1.85e19));
   EXPECT_EQ(std::numeric_limits<int64_t>::min(), art_f2l(-1.85e19));
-  EXPECT_EQ(0LL, art_f2l(0));
-  EXPECT_EQ(1LL, art_f2l(1.0));
-  EXPECT_EQ(10LL, art_f2l(10.0));
-  EXPECT_EQ(100LL, art_f2l(100.0));
-  EXPECT_EQ(-1LL, art_f2l(-1.0));
-  EXPECT_EQ(-10LL, art_f2l(-10.0));
-  EXPECT_EQ(-100LL, art_f2l(-100.0));
+  EXPECT_EQ(INT64_C(0), art_f2l(0));
+  EXPECT_EQ(INT64_C(1), art_f2l(1.0));
+  EXPECT_EQ(INT64_C(10), art_f2l(10.0));
+  EXPECT_EQ(INT64_C(100), art_f2l(100.0));
+  EXPECT_EQ(INT64_C(-1), art_f2l(-1.0));
+  EXPECT_EQ(INT64_C(-10), art_f2l(-10.0));
+  EXPECT_EQ(INT64_C(-100), art_f2l(-100.0));
 }
 
 TEST_F(MathEntrypointsTest, DoubleToInt) {
diff --git a/runtime/native/java_lang_reflect_Field.cc b/runtime/native/java_lang_reflect_Field.cc
index 40aebfa7da..694f5e42ca 100644
--- a/runtime/native/java_lang_reflect_Field.cc
+++ b/runtime/native/java_lang_reflect_Field.cc
@@ -30,7 +30,7 @@ namespace art {
 static bool GetFieldValue(const ScopedFastNativeObjectAccess& soa, mirror::Object* o,
                           mirror::ArtField* f, JValue& value, bool allow_references)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  DCHECK_EQ(value.GetJ(), 0LL);
+  DCHECK_EQ(value.GetJ(), INT64_C(0));
   CHECK(!kMovingFields);
   SirtRef<mirror::Object> sirt_obj(soa.Self(), o);
   SirtRef<mirror::Class> sirt_klass(soa.Self(), f->GetDeclaringClass());
diff --git a/runtime/profiler.cc b/runtime/profiler.cc
index da989381eb..4770a54e89 100644
--- a/runtime/profiler.cc
+++ b/runtime/profiler.cc
@@ -163,7 +163,7 @@ void* BackgroundMethodSamplingProfiler::RunProfilerThread(void* arg) {
 
 
     uint64_t start_us = MicroTime();
-    uint64_t end_us = start_us + profiler->duration_s_ * 1000000LL;
+    uint64_t end_us = start_us + profiler->duration_s_ * UINT64_C(1000000);
     uint64_t now_us = start_us;
 
     LOG(DEBUG) << "Starting profiling run now for " << PrettyDuration((end_us - start_us) * 1000);
diff --git a/runtime/thread.cc b/runtime/thread.cc
index 680d26987e..fbdf95f0e1 100644
--- a/runtime/thread.cc
+++ b/runtime/thread.cc
@@ -518,7 +518,7 @@ uint64_t Thread::GetCpuMicroTime() const {
   pthread_getcpuclockid(pthread_self_, &cpu_clock_id);
   timespec now;
   clock_gettime(cpu_clock_id, &now);
-  return static_cast<uint64_t>(now.tv_sec) * 1000000LL + now.tv_nsec / 1000LL;
+  return static_cast<uint64_t>(now.tv_sec) * UINT64_C(1000000) + now.tv_nsec / UINT64_C(1000);
 #else
   UNIMPLEMENTED(WARNING);
   return -1;
diff --git a/runtime/utils.cc b/runtime/utils.cc
index 2b577785a8..afbcbb7582 100644
--- a/runtime/utils.cc
+++ b/runtime/utils.cc
@@ -136,11 +136,11 @@ uint64_t MilliTime() {
 #if defined(HAVE_POSIX_CLOCKS)
   timespec now;
   clock_gettime(CLOCK_MONOTONIC, &now);
-  return static_cast<uint64_t>(now.tv_sec) * 1000LL + now.tv_nsec / 1000000LL;
+  return static_cast<uint64_t>(now.tv_sec) * UINT64_C(1000) + now.tv_nsec / UINT64_C(1000000);
 #else
   timeval now;
   gettimeofday(&now, NULL);
-  return static_cast<uint64_t>(now.tv_sec) * 1000LL + now.tv_usec / 1000LL;
+  return static_cast<uint64_t>(now.tv_sec) * UINT64_C(1000) + now.tv_usec / UINT64_C(1000);
 #endif
 }
 
@@ -148,11 +148,11 @@ uint64_t MicroTime() {
 #if defined(HAVE_POSIX_CLOCKS)
   timespec now;
   clock_gettime(CLOCK_MONOTONIC, &now);
-  return static_cast<uint64_t>(now.tv_sec) * 1000000LL + now.tv_nsec / 1000LL;
+  return static_cast<uint64_t>(now.tv_sec) * UINT64_C(1000000) + now.tv_nsec / UINT64_C(1000);
 #else
   timeval now;
   gettimeofday(&now, NULL);
-  return static_cast<uint64_t>(now.tv_sec) * 1000000LL + now.tv_usec;
+  return static_cast<uint64_t>(now.tv_sec) * UINT64_C(1000000) + now.tv_usec;
 #endif
 }
 
@@ -160,11 +160,11 @@ uint64_t NanoTime() {
 #if defined(HAVE_POSIX_CLOCKS)
   timespec now;
   clock_gettime(CLOCK_MONOTONIC, &now);
-  return static_cast<uint64_t>(now.tv_sec) * 1000000000LL + now.tv_nsec;
+  return static_cast<uint64_t>(now.tv_sec) * UINT64_C(1000000000) + now.tv_nsec;
 #else
   timeval now;
   gettimeofday(&now, NULL);
-  return static_cast<uint64_t>(now.tv_sec) * 1000000000LL + now.tv_usec * 1000LL;
+  return static_cast<uint64_t>(now.tv_sec) * UINT64_C(1000000000) + now.tv_usec * UINT64_C(1000);
 #endif
 }
 
@@ -172,7 +172,7 @@ uint64_t ThreadCpuNanoTime() {
 #if defined(HAVE_POSIX_CLOCKS)
   timespec now;
   clock_gettime(CLOCK_THREAD_CPUTIME_ID, &now);
-  return static_cast<uint64_t>(now.tv_sec) * 1000000000LL + now.tv_nsec;
+  return static_cast<uint64_t>(now.tv_sec) * UINT64_C(1000000000) + now.tv_nsec;
 #else
   UNIMPLEMENTED(WARNING);
   return -1;