Fix wrong unsigned to signed conversions.

The HIntConstant node takes an int32_t, so we have to keep things signed.

Change-Id: Ib3fa50e87f99118d320cbb381f619d5be9287530

diff --git a/compiler/optimizing/builder.cc b/compiler/optimizing/builder.cc
index 0ab7782..e4dee46 100644 (file)
--- a/compiler/optimizing/builder.cc
+++ b/compiler/optimizing/builder.cc
@@ -550,7 +550,7 @@ void HGraphBuilder::BuildFillArrayData(HInstruction* object,
 }
 
 void HGraphBuilder::BuildFillWideArrayData(HInstruction* object,
-                                           const uint64_t* data,
+                                           const int64_t* data,
                                            uint32_t element_count,
                                            uint32_t dex_offset) {
   for (uint32_t i = 0; i < element_count; ++i) {
@@ -964,25 +964,29 @@ bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32
 
       switch (payload->element_width) {
         case 1:
-          BuildFillArrayData(null_check, data, element_count, Primitive::kPrimByte, dex_offset);
+          BuildFillArrayData(null_check,
+                             reinterpret_cast<const int8_t*>(data),
+                             element_count,
+                             Primitive::kPrimByte,
+                             dex_offset);
           break;
         case 2:
           BuildFillArrayData(null_check,
-                             reinterpret_cast<const uint16_t*>(data),
+                             reinterpret_cast<const int16_t*>(data),
                              element_count,
                              Primitive::kPrimShort,
                              dex_offset);
           break;
         case 4:
           BuildFillArrayData(null_check,
-                             reinterpret_cast<const uint32_t*>(data),
+                             reinterpret_cast<const int32_t*>(data),
                              element_count,
                              Primitive::kPrimInt,
                              dex_offset);
           break;
         case 8:
           BuildFillWideArrayData(null_check,
-                                 reinterpret_cast<const uint64_t*>(data),
+                                 reinterpret_cast<const int64_t*>(data),
                                  element_count,
                                  dex_offset);
           break;

diff --git a/compiler/optimizing/builder.h b/compiler/optimizing/builder.h
index c5e02db..b55ef07 100644 (file)
--- a/compiler/optimizing/builder.h
+++ b/compiler/optimizing/builder.h
@@ -154,7 +154,7 @@ class HGraphBuilder : public ValueObject {
   // Fills the given object with data as specified in the fill-array-data
   // instruction. The data must be for long and double arrays.
   void BuildFillWideArrayData(HInstruction* object,
-                              const uint64_t* data,
+                              const int64_t* data,
                               uint32_t element_count,
                               uint32_t dex_offset);
 

diff --git a/test/412-new-array/src/Main.java b/test/412-new-array/src/Main.java
index 3c74275..168420c 100644 (file)
--- a/test/412-new-array/src/Main.java
+++ b/test/412-new-array/src/Main.java
@@ -24,6 +24,8 @@ public class Main extends TestCase {
   public static void main(String[] args) throws Exception {
     $opt$TestAllocations();
     $opt$TestWithInitializations();
+    $opt$TestNegativeValueNewByteArray();
+    $opt$TestNegativeValueNewCharArray();
     testSmaliFilledNewArray();
     testSmaliFillArrayData();
     testSmaliVerifyError();
@@ -109,6 +111,24 @@ public class Main extends TestCase {
     assertEquals(obj2, i[1]);
   }
 
+  static void $opt$TestNegativeValueNewByteArray() {
+    // Use an array initializer to hint the use of filled-new-array.
+    byte[] a = { (byte)0xa0, (byte)0xa1, (byte)0xa2, (byte)0xa3,
+                 (byte)0xa4, (byte)0xa5, (byte)0xa6, (byte)0xa7 };
+    for (int i = 0; i < a.length; i++) {
+      assertEquals((byte)0xa0 + i, a[i]);
+    }
+  }
+
+  static void $opt$TestNegativeValueNewCharArray() {
+    // Use an array initializer to hint the use of filled-new-array.
+    char[] a = { (char)0xa000, (char)0xa001, (char)0xa002, (char)0xa003,
+                 (char)0xa004, (char)0xa005, (char)0xa006, (char)0xa007 };
+    for (int i = 0; i < a.length; i++) {
+      assertEquals((char)0xa000 + i, a[i]);
+    }
+  }
+
   public static void testSmaliFilledNewArray() throws Exception {
     Class<?> c = Class.forName("FilledNewArray");