S390: Use macro to declare rx format assember function

src/s390/constants-s390.h

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_S390_CONSTANTS_S390_H_
 #define V8_S390_CONSTANTS_S390_H_
 
 // Get the standard printf format macros for C99 stdint types.
 #ifndef __STDC_FORMAT_MACROS
 #define __STDC_FORMAT_MACROS
@@ skipping 1124 matching lines @@
   V(tabort, TABORT, 0xB2FC) /* type = S     TRANSACTION ABORT  */              \
   V(trap4, TRAP4, 0xB2FF)   /* type = S     TRAP  */
 
 #define S390_RX_A_OPCODE_LIST(V)                                            \
   V(la, LA, 0x41)     /* type = RX_A  LOAD ADDRESS  */                      \
   V(stc, STC, 0x42)   /* type = RX_A  STORE CHARACTER  */                   \
   V(ic_z, IC_z, 0x43) /* type = RX_A  INSERT CHARACTER  */                  \
   V(ex, EX, 0x44)     /* type = RX_A  EXECUTE  */                           \
   V(bal, BAL, 0x45)   /* type = RX_A  BRANCH AND LINK  */                   \
   V(bct, BCT, 0x46)   /* type = RX_A  BRANCH ON COUNT (32)  */              \
-  V(bc, BC, 0x47)     /* type = RX_A  BRANCH ON CONDITION  */               \
+  V(lh, LH, 0x48)     /* type = RX_A  LOAD HALFWORD (32<-16)  */            \
   V(ch, CH, 0x49)     /* type = RX_A  COMPARE HALFWORD (32<-16)  */         \
   V(ah, AH, 0x4A)     /* type = RX_A  ADD HALFWORD (32<-16)  */             \
   V(sh, SH, 0x4B)     /* type = RX_A  SUBTRACT HALFWORD (32<-16)  */        \
   V(mh, MH, 0x4C)     /* type = RX_A  MULTIPLY HALFWORD (32<-16)  */        \
   V(bas, BAS, 0x4D)   /* type = RX_A  BRANCH AND SAVE  */                   \
   V(cvd, CVD, 0x4E)   /* type = RX_A  CONVERT TO DECIMAL (32)  */           \
   V(cvb, CVB, 0x4F)   /* type = RX_A  CONVERT TO BINARY (32)  */            \
   V(st, ST, 0x50)     /* type = RX_A  STORE (32)  */                        \
   V(lae, LAE, 0x51)   /* type = RX_A  LOAD ADDRESS EXTENDED  */             \
   V(n, N, 0x54)       /* type = RX_A  AND (32)  */                          \
   V(cl, CL, 0x55)     /* type = RX_A  COMPARE LOGICAL (32)  */              \
   V(o, O, 0x56)       /* type = RX_A  OR (32)  */                           \
   V(x, X, 0x57)       /* type = RX_A  EXCLUSIVE OR (32)  */                 \
   V(l, L, 0x58)       /* type = RX_A  LOAD (32)  */                         \
   V(c, C, 0x59)       /* type = RX_A  COMPARE (32)  */                      \
   V(a, A, 0x5A)       /* type = RX_A  ADD (32)  */                          \
   V(s, S, 0x5B)       /* type = RX_A  SUBTRACT (32)  */                     \
   V(m, M, 0x5C)       /* type = RX_A  MULTIPLY (64<-32)  */                 \
   V(d, D, 0x5D)       /* type = RX_A  DIVIDE (32<-64)  */                   \
-  V(al, AL, 0x5E)     /* type = RX_A  ADD LOGICAL (32)  */                  \
+  V(al_z, AL, 0x5E)   /* type = RX_A  ADD LOGICAL (32)  */                  \
   V(sl, SL, 0x5F)     /* type = RX_A  SUBTRACT LOGICAL (32)  */             \
   V(std, STD, 0x60)   /* type = RX_A  STORE (long)  */                      \
   V(mxd, MXD, 0x67)   /* type = RX_A  MULTIPLY (long to extended HFP)  */   \
   V(ld, LD, 0x68)     /* type = RX_A  LOAD (long)  */                       \
   V(cd, CD, 0x69)     /* type = RX_A  COMPARE (long HFP)  */                \
   V(ad, AD, 0x6A)     /* type = RX_A  ADD NORMALIZED (long HFP)  */         \
   V(sd, SD, 0x6B)     /* type = RX_A  SUBTRACT NORMALIZED (long HFP)  */    \
   V(md, MD, 0x6C)     /* type = RX_A  MULTIPLY (long HFP)  */               \
   V(dd, DD, 0x6D)     /* type = RX_A  DIVIDE (long HFP)  */                 \
   V(aw, AW, 0x6E)     /* type = RX_A  ADD UNNORMALIZED (long HFP)  */       \
   V(sw, SW, 0x6F)     /* type = RX_A  SUBTRACT UNNORMALIZED (long HFP)  */  \
   V(ste, STE, 0x70)   /* type = RX_A  STORE (short)  */                     \
   V(ms, MS, 0x71)     /* type = RX_A  MULTIPLY SINGLE (32)  */              \
-  V(le, LE, 0x78)     /* type = RX_A  LOAD (short)  */                      \
+  V(le_z, LE, 0x78)   /* type = RX_A  LOAD (short)  */                      \
   V(ce, CE, 0x79)     /* type = RX_A  COMPARE (short HFP)  */               \
   V(ae, AE, 0x7A)     /* type = RX_A  ADD NORMALIZED (short HFP)  */        \
   V(se, SE, 0x7B)     /* type = RX_A  SUBTRACT NORMALIZED (short HFP)  */   \
   V(mde, MDE, 0x7C)   /* type = RX_A  MULTIPLY (short to long HFP)  */      \
   V(me, ME, 0x7C)     /* type = RX_A  MULTIPLY (short to long HFP)  */      \
   V(de, DE, 0x7D)     /* type = RX_A  DIVIDE (short HFP)  */                \
   V(au, AU, 0x7E)     /* type = RX_A  ADD UNNORMALIZED (short HFP)  */      \
   V(su, SU, 0x7F)     /* type = RX_A  SUBTRACT UNNORMALIZED (short HFP)  */ \
   V(ssm, SSM, 0x80)   /* type = RX_A  SET SYSTEM MASK  */                   \
-  V(lra, LRA, 0xB1)   /* type = RX_A  LOAD REAL ADDRESS (32)  */
+  V(lra, LRA, 0xB1)   /* type = RX_A  LOAD REAL ADDRESS (32)  */            \
+  V(sth, STH, 0x40)   /* type = RX_A  STORE HALFWORD (16)  */
 
 #define S390_RX_B_OPCODE_LIST(V) \
-  V(lh, LH, 0x48) /* type = RX_B  LOAD HALFWORD (32<-16)  */
+  V(bc, BC, 0x47)     /* type = RX_B  BRANCH ON CONDITION  */
 
 #define S390_RIE_A_OPCODE_LIST(V)                                              \
   V(cgit, CGIT, 0xEC70) /* type = RIE_A COMPARE IMMEDIATE AND TRAP (64<-16) */ \
   V(clgit, CLGIT,                                                              \
     0xEC71) /* type = RIE_A COMPARE LOGICAL IMMEDIATE AND TRAP (64<-16)  */    \
   V(cit, CIT, 0xEC72) /* type = RIE_A COMPARE IMMEDIATE AND TRAP (32<-16)  */  \
   V(clfit, CLFIT,                                                              \
     0xEC73) /* type = RIE_A COMPARE LOGICAL IMMEDIATE AND TRAP (32<-16)  */
 
 #define S390_RRD_OPCODE_LIST(V)                                                \
@@ skipping 375 matching lines @@
   V(axr, AXR, 0x36)     /* type = RR    ADD NORMALIZED (extended HFP)  */      \
   V(sxr, SXR, 0x37)     /* type = RR    SUBTRACT NORMALIZED (extended HFP)  */ \
   V(ler, LER, 0x38)     /* type = RR    LOAD (short)  */                       \
   V(cer, CER, 0x39)     /* type = RR    COMPARE (short HFP)  */                \
   V(aer, AER, 0x3A)     /* type = RR    ADD NORMALIZED (short HFP)  */         \
   V(ser, SER, 0x3B)     /* type = RR    SUBTRACT NORMALIZED (short HFP)  */    \
   V(mder, MDER, 0x3C)   /* type = RR    MULTIPLY (short to long HFP)  */       \
   V(mer, MER, 0x3C)     /* type = RR    MULTIPLY (short to long HFP)  */       \
   V(der, DER, 0x3D)     /* type = RR    DIVIDE (short HFP)  */                 \
   V(aur, AUR, 0x3E)     /* type = RR    ADD UNNORMALIZED (short HFP)  */       \
-  V(sur, SUR, 0x3F)     /* type = RR    SUBTRACT UNNORMALIZED (short HFP)  */  \
-  V(sth, STH, 0x40)     /* type = RR    STORE HALFWORD (16)  */
+  V(sur, SUR, 0x3F)     /* type = RR    SUBTRACT UNNORMALIZED (short HFP)  */
 
 #define S390_RIE_F_OPCODE_LIST(V)                                              \
   V(risblg, RISBLG,                                                            \
     0xEC51) /* type = RIE_F ROTATE THEN INSERT SELECTED BITS LOW (64)  */      \
   V(rnsbg, RNSBG,                                                              \
     0xEC54) /* type = RIE_F ROTATE THEN AND SELECTED BITS (64)  */             \
   V(risbg, RISBG,                                                              \
     0xEC55) /* type = RIE_F ROTATE THEN INSERT SELECTED BITS (64)  */          \
   V(rosbg, ROSBG, 0xEC56) /* type = RIE_F ROTATE THEN OR SELECTED BITS (64) */ \
   V(rxsbg, RXSBG,                                                              \
@@ skipping 771 matching lines @@
   static int Number(const char* name);
 
  private:
   static const char* names_[kNumDoubleRegisters];
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_S390_CONSTANTS_S390_H_