MIPS: use DAHI/DATH for li macro on mips64r6.

src/mips64/macro-assembler-mips64.cc

Index: src/mips64/macro-assembler-mips64.cc
diff --git a/src/mips64/macro-assembler-mips64.cc b/src/mips64/macro-assembler-mips64.cc
index 99daa1b00a447407e24f30bb434cf26881c9cdc6..6e4dbc230a2cd5fd1b4189cc4501aa5514b68a58 100644
--- a/src/mips64/macro-assembler-mips64.cc
+++ b/src/mips64/macro-assembler-mips64.cc
@@ -1294,39 +1294,62 @@ void MacroAssembler::li(Register rd, Operand j, LiFlags mode) {
         ori(rd, rd, (j.imm64_ & kImm16Mask));
       }
     } else {
-      if (is_int48(j.imm64_)) {
-        if ((j.imm64_ >> 32) & kImm16Mask) {
-          lui(rd, (j.imm64_ >> 32) & kImm16Mask);
-          if ((j.imm64_ >> 16) & kImm16Mask) {
-            ori(rd, rd, (j.imm64_ >> 16) & kImm16Mask);
-          }
+      if (kArchVariant == kMips64r6) {
+        int64_t imm = j.imm64_;

[ivica.bogosavljevic, 2015/12/21 16:15:55]

This is the optimized case, so we need to get here with the least possible
number of instruction. This code will emit two instructions (lui and dahi)
regardless of the constant, but we can do better than that.
I suggest you take a look at this implementation:
https://android.googlesource.com/platform/art/+/master/compiler/utils/mips64/...

[Alan Li, 2016/01/20 14:26:59]

Done.

+        lui(rd, (imm >> kLuiShift) & kImm16Mask);
+        if (imm & kImm16Mask) {
+          ori(rd, rd, (imm & kImm16Mask));
+        }
+        if ((imm >> 31) & 0x1) {

[ivica.bogosavljevic, 2015/12/21 16:15:56]

Personally, I don't like this shifting bit magic since it is very complicated
for me to understand. Look at the link from previous comment, you can see that
instead of shifting the immediate values, they are adding constants to them. It
is simpler to understand, and there are no complicated expressions like the one
below:
 if (!((j.imm64_ >> 48 == 0xffff && (j.imm64_ > 47) & 0x1) ||              
(j.imm64_ >> 48 == 0x0000 && ((j.imm64_ > 47) & 0x1) == 0x0))) {

Consider using this approach

[Alan Li, 2016/01/20 14:26:59]

Done.

+          imm = (imm >> 32) + 1;
         } else {
-          ori(rd, zero_reg, (j.imm64_ >> 16) & kImm16Mask);
+          imm = imm >> 32;
         }
-        dsll(rd, rd, 16);
-        if (j.imm64_ & kImm16Mask) {
-          ori(rd, rd, j.imm64_ & kImm16Mask);
+        dahi(rd, imm & kImm16Mask);
+        if (!((j.imm64_ >> 48 == 0xffff && (j.imm64_ > 47) & 0x1) ||
+              (j.imm64_ >> 48 == 0x0000 && ((j.imm64_ > 47) & 0x1) == 0x0))) {
+          if ((imm >> 15) & 0x1) {
+            imm = (imm >> 16) + 1;
+          } else {
+            imm = imm >> 16;
+          }
+          dati(rd, imm & kImm16Mask);
         }
       } else {
-        lui(rd, (j.imm64_ >> 48) & kImm16Mask);
-        if ((j.imm64_ >> 32) & kImm16Mask) {
-          ori(rd, rd, (j.imm64_ >> 32) & kImm16Mask);
-        }
-        if ((j.imm64_ >> 16) & kImm16Mask) {
+        if (is_int48(j.imm64_)) {
+          if ((j.imm64_ >> 32) & kImm16Mask) {
+            lui(rd, (j.imm64_ >> 32) & kImm16Mask);
+            if ((j.imm64_ >> 16) & kImm16Mask) {
+              ori(rd, rd, (j.imm64_ >> 16) & kImm16Mask);
+            }
+          } else {
+            ori(rd, zero_reg, (j.imm64_ >> 16) & kImm16Mask);
+          }
           dsll(rd, rd, 16);
-          ori(rd, rd, (j.imm64_ >> 16) & kImm16Mask);
           if (j.imm64_ & kImm16Mask) {
-            dsll(rd, rd, 16);
             ori(rd, rd, j.imm64_ & kImm16Mask);
-          } else {
-            dsll(rd, rd, 16);
           }
         } else {
-          if (j.imm64_ & kImm16Mask) {
-            dsll32(rd, rd, 0);
-            ori(rd, rd, j.imm64_ & kImm16Mask);
+          lui(rd, (j.imm64_ >> 48) & kImm16Mask);
+          if ((j.imm64_ >> 32) & kImm16Mask) {
+            ori(rd, rd, (j.imm64_ >> 32) & kImm16Mask);
+          }
+          if ((j.imm64_ >> 16) & kImm16Mask) {
+            dsll(rd, rd, 16);
+            ori(rd, rd, (j.imm64_ >> 16) & kImm16Mask);
+            if (j.imm64_ & kImm16Mask) {
+              dsll(rd, rd, 16);
+              ori(rd, rd, j.imm64_ & kImm16Mask);
+            } else {
+              dsll(rd, rd, 16);
+            }
           } else {
-            dsll32(rd, rd, 0);
+            if (j.imm64_ & kImm16Mask) {
+              dsll32(rd, rd, 0);
+              ori(rd, rd, j.imm64_ & kImm16Mask);
+            } else {
+              dsll32(rd, rd, 0);
+            }
           }
         }
       }
@@ -1345,12 +1368,32 @@ void MacroAssembler::li(Register rd, Operand j, LiFlags mode) {
     dsll(rd, rd, 16);
     ori(rd, rd, j.imm64_ & kImm16Mask);
   } else {
-    lui(rd, (j.imm64_ >> 48) & kImm16Mask);
-    ori(rd, rd, (j.imm64_ >> 32) & kImm16Mask);
-    dsll(rd, rd, 16);
-    ori(rd, rd, (j.imm64_ >> 16) & kImm16Mask);
-    dsll(rd, rd, 16);
-    ori(rd, rd, j.imm64_ & kImm16Mask);
+    if (kArchVariant == kMips64r6) {
+      int64_t imm = j.imm64_;
+      lui(rd, (imm >> kLuiShift) & kImm16Mask);
+      if (imm & kImm16Mask) {

[ivica.bogosavljevic, 2015/12/21 16:15:56]

Looks good

[Alan Li, 2016/01/20 14:26:59]

Acknowledged.

+        ori(rd, rd, (imm & kImm16Mask));
+      }
+      if ((imm >> 31) & 0x1) {
+        imm = (imm >> 32) + 1;
+      } else {
+        imm = imm >> 32;
+      }
+      dahi(rd, imm & kImm16Mask);
+      if ((imm >> 15) & 0x1) {
+        imm = (imm >> 16) + 1;
+      } else {
+        imm = imm >> 16;
+      }
+      dati(rd, imm & kImm16Mask);
+    } else {
+      lui(rd, (j.imm64_ >> 48) & kImm16Mask);

[ivica.bogosavljevic, 2015/12/21 16:15:55]

This is the old code, nothing is changed here except for indentation.

[Alan Li, 2016/01/20 14:26:59]

The old code is used in non-r6 architecture.

On 2015/12/21 16:15:55, ivica.bogosavljevic wrote:

+      ori(rd, rd, (j.imm64_ >> 32) & kImm16Mask);
+      dsll(rd, rd, 16);
+      ori(rd, rd, (j.imm64_ >> 16) & kImm16Mask);
+      dsll(rd, rd, 16);
+      ori(rd, rd, j.imm64_ & kImm16Mask);
+    }
   }
 }