Add various forms of LDREX/STREX to ARM integrated assembler.

src/IceAssemblerARM32.cpp

 //===- subzero/src/IceAssemblerARM32.cpp - Assembler for ARM32 --*- C++ -*-===//
 //
 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // Modified by the Subzero authors.
 //
 //===----------------------------------------------------------------------===//
 //
@@ skipping 23 matching lines @@
 
 // The following define individual bits.
 static constexpr IValueT B0 = 1;
 static constexpr IValueT B1 = 1 << 1;
 static constexpr IValueT B2 = 1 << 2;
 static constexpr IValueT B3 = 1 << 3;
 static constexpr IValueT B4 = 1 << 4;
 static constexpr IValueT B5 = 1 << 5;
 static constexpr IValueT B6 = 1 << 6;
 static constexpr IValueT B7 = 1 << 7;
+static constexpr IValueT B8 = 1 << 8;
+static constexpr IValueT B9 = 1 << 9;
+static constexpr IValueT B10 = 1 << 10;
+static constexpr IValueT B11 = 1 << 11;
 static constexpr IValueT B12 = 1 << 12;
 static constexpr IValueT B13 = 1 << 13;
 static constexpr IValueT B14 = 1 << 14;
 static constexpr IValueT B15 = 1 << 15;
 static constexpr IValueT B16 = 1 << 16;
 static constexpr IValueT B17 = 1 << 17;
 static constexpr IValueT B18 = 1 << 18;
 static constexpr IValueT B19 = 1 << 19;
 static constexpr IValueT B20 = 1 << 20;
 static constexpr IValueT B21 = 1 << 21;
@@ skipping 35 matching lines @@
 // Shift instruction register fields encodings.
 static constexpr IValueT kShiftImmShift = 7;
 static constexpr IValueT kShiftImmBits = 5;
 static constexpr IValueT kShiftShift = 5;
 static constexpr IValueT kImmed12Bits = 12;
 static constexpr IValueT kImm12Shift = 0;
 
 // Rotation instructions (uxtb etc.).
 static constexpr IValueT kRotationShift = 10;
 
+// MemEx instructions.
+static constexpr IValueT kMemExOpcodeShift = 20;
+
 // Div instruction register field encodings.
 static constexpr IValueT kDivRdShift = 16;
 static constexpr IValueT kDivRmShift = 8;
 static constexpr IValueT kDivRnShift = 0;
 
 // Type of instruction encoding (bits 25-27). See ARM section A5.1
 static constexpr IValueT kInstTypeDataRegister = 0;  // i.e. 000
 static constexpr IValueT kInstTypeDataRegShift = 0;  // i.e. 000
 static constexpr IValueT kInstTypeDataImmediate = 1; // i.e. 001
 static constexpr IValueT kInstTypeMemImmediate = 2;  // i.e. 010
@@ skipping 57 matching lines @@
 }
 
 // Extract out a Bit in Value.
 bool isBitSet(IValueT Bit, IValueT Value) { return (Value & Bit) == Bit; }
 
 // Returns the GPR register at given Shift in Value.
 RegARM32::GPRRegister getGPRReg(IValueT Shift, IValueT Value) {
   return decodeGPRRegister((Value >> Shift) & 0xF);
 }
 
+// Defines alternate layouts of instruction operands, should the (common)
+// default pattern not be used.
+enum OpEncoding {
+  // No alternate layout specified.
+  DefaultOpEncoding,
+  // Alternate encoding 3 for memory operands (like in strb, strh, ldrb, and
+  // ldrh.
+  OpEncoding3,
+  // Alternate encoding for memory operands for ldrex and strex, which only
+  // actually expect a register.
+  OpEncodingMemEx
+};
+
+IValueT getVarRegNum(const Variable *Var) {

[Jim Stichnoth, 2015/12/11 17:24:57]

This function name should be changed, to reflect that fact that it is returning
an encoded register number.

Maybe getEncodedReg or getEncodedRegNum ?

[Karl, 2015/12/11 18:05:08]

Changed to getEncodedGPRegNum.

+  int32_t Reg = Var->getRegNum();
+  return llvm::isa<Variable64On32>(Var) ? RegARM32::getI64PairFirstGPRNum(Reg)
+                                        : RegARM32::getEncodedGPR(Reg);
+}
+
 // The way an operand is encoded into a sequence of bits in functions
 // encodeOperand and encodeAddress below.
 enum EncodedOperand {
   // Unable to encode, value left undefined.
   CantEncode = 0,
   // Value is register found.
   EncodedAsRegister,
   // Value=rrrriiiiiiii where rrrr is the rotation, and iiiiiiii is the imm8
   // value.
   EncodedAsRotatedImm8,
+  // EncodedAsImmRegOffset is a memory operand that can take three forms, based
+  // on OpEncoding:
+  //
+  // case DefaultOpEncoding:

[Jim Stichnoth, 2015/12/11 17:24:57]

This style of comment made me think you had some stray commented code lying
around.  What do you think of this style:

// *** DefaultOpEncoding ***
// Value=...
//
// **** OpEncoding3 ***
// Value=...

or something along those lines?

[Karl, 2015/12/11 18:05:08]

Ok. Done.

+  //
   // Value=0000000pu0w0nnnn0000iiiiiiiiiiii where nnnn is the base register Rn,
   // p=1 if pre-indexed addressing, u=1 if offset positive, w=1 if writeback to
   // Rn should be used, and iiiiiiiiiiii defines the rotated Imm8 value.
-  EncodedAsImmRegOffset,
+  //
+  // case OpEncoding3:
+  //
   // Value=00000000pu0w0nnnn0000iiii0000jjjj where nnnn=Rn, iiiijjjj=Imm8, p=1
   // if pre-indexed addressing, u=1 if offset positive, and w=1 if writeback to
   // Rn.
-  EncodedAsImmRegOffsetEnc3,
+  //
+  // case OpEncodingMemEx:
+  //
+  // Value=000000000000nnnn0000000000000000 where nnnn=Rn.
+  EncodedAsImmRegOffset,
   // Value=0000000pu0w00nnnnttttiiiiiss0mmmm where nnnn is the base register Rn,
   // mmmm is the index register Rm, iiiii is the shift amount, ss is the shift
   // kind, p=1 if pre-indexed addressing, u=1 if offset positive, and w=1 if
   // writeback to Rn.
   EncodedAsShiftRotateImm5,
   // Value=000000000000000000000iiiii0000000 where iiii defines the Imm5 value
   // to shift.
   EncodedAsShiftImm5,
   // i.e. iiiiiss0mmmm where mmmm is the register to rotate, ss is the shift
   // kind, and iiiii is the shift amount.
@@ skipping 23 matching lines @@
 IValueT encodeShiftRotateReg(IValueT Rm, OperandARM32::ShiftKind Shift,
                              IValueT Rs) {
   return (Rs << kRsShift) | (encodeShift(Shift) << kShiftShift) | B4 |
          (Rm << kRmShift);
 }
 
 EncodedOperand encodeOperand(const Operand *Opnd, IValueT &Value) {
   Value = 0; // Make sure initialized.
   if (const auto *Var = llvm::dyn_cast<Variable>(Opnd)) {
     if (Var->hasReg()) {
-      Value = Var->getRegNum();
+      Value = getVarRegNum(Var);
       return EncodedAsRegister;
     }
     return CantEncode;
   }
   if (const auto *FlexImm = llvm::dyn_cast<OperandARM32FlexImm>(Opnd)) {
     const IValueT Immed8 = FlexImm->getImm();
     const IValueT Rotate = FlexImm->getRotateAmt();
     if (!((Rotate < (1 << kRotateBits)) && (Immed8 < (1 << kImmed8Bits))))
       return CantEncode;
     Value = (Rotate << kRotateShift) | (Immed8 << kImmed8Shift);
@@ skipping 41 matching lines @@
   IValueT Value = Mode | (Rn << kRnShift);
   if (Imm8 < 0) {
     Imm8 = -Imm8;
     Value = (Value ^ U);
   }
   assert(Imm8 < (1 << 8));
   Value = Value | B22 | ((Imm8 & 0xf0) << 4) | (Imm8 & 0x0f);
   return Value;
 }
 
-// Defines alternate layouts of instruction operands, should the (common)
-// default pattern not be used.
-enum OpEncoding {
-  // No alternate layout specified.
-  DefaultOpEncoding,
-  // Alternate encoding 3.
-  OpEncoding3
-};
+IValueT encodeImmRegOffset(OpEncoding AddressEncoding, IValueT Reg,
+                           IOffsetT Offset, OperandARM32Mem::AddrMode Mode) {
+  switch (AddressEncoding) {
+  case DefaultOpEncoding:
+    return encodeImmRegOffset(Reg, Offset, Mode);
+  case OpEncoding3:
+    return encodeImmRegOffsetEnc3(Reg, Offset, Mode);
+  case OpEncodingMemEx:
+    assert(Offset == 0);
+    assert(Mode == OperandARM32Mem::Offset);
+    return Reg << kRnShift;
+  }
+}
 
 // Encodes memory address Opnd, and encodes that information into Value, based
 // on how ARM represents the address. Returns how the value was encoded.
 EncodedOperand encodeAddress(const Operand *Opnd, IValueT &Value,
                              const AssemblerARM32::TargetInfo &TInfo,
                              OpEncoding AddressEncoding = DefaultOpEncoding) {
   Value = 0; // Make sure initialized.
   if (const auto *Var = llvm::dyn_cast<Variable>(Opnd)) {
     // Should be a stack variable, with an offset.
     if (Var->hasReg())
       return CantEncode;
     IOffsetT Offset = Var->getStackOffset();
     if (!Utils::IsAbsoluteUint(12, Offset))
       return CantEncode;
     int32_t BaseRegNum = Var->getBaseRegNum();
     if (BaseRegNum == Variable::NoRegister)
       BaseRegNum = TInfo.FrameOrStackReg;
-    Value = encodeImmRegOffset(BaseRegNum, Offset, OperandARM32Mem::Offset);
+    Value = encodeImmRegOffset(AddressEncoding, BaseRegNum, Offset,
+                               OperandARM32Mem::Offset);
     return EncodedAsImmRegOffset;
   }
   if (const auto *Mem = llvm::dyn_cast<OperandARM32Mem>(Opnd)) {
     Variable *Var = Mem->getBase();
     if (!Var->hasReg())
       return CantEncode;
-    IValueT Rn = Var->getRegNum();
+    IValueT Rn = getVarRegNum(Var);
     if (Mem->isRegReg()) {
       const Variable *Index = Mem->getIndex();
       if (Var == nullptr)
         return CantEncode;
       Value = (Rn << kRnShift) | Mem->getAddrMode() |
-              encodeShiftRotateImm5(Index->getRegNum(), Mem->getShiftOp(),
+              encodeShiftRotateImm5(getVarRegNum(Index), Mem->getShiftOp(),
                                     Mem->getShiftAmt());
       return EncodedAsShiftRotateImm5;
     }
     // Encoded as immediate register offset.
     ConstantInteger32 *Offset = Mem->getOffset();
-    switch (AddressEncoding) {
-    case DefaultOpEncoding:
-      Value = encodeImmRegOffset(Rn, Offset->getValue(), Mem->getAddrMode());
-      return EncodedAsImmRegOffset;
-    case OpEncoding3:
-      Value =
-          encodeImmRegOffsetEnc3(Rn, Offset->getValue(), Mem->getAddrMode());
-      return EncodedAsImmRegOffsetEnc3;
-    }
+    Value = encodeImmRegOffset(AddressEncoding, Rn, Offset->getValue(),
+                               Mem->getAddrMode());
+    return EncodedAsImmRegOffset;
   }
   return CantEncode;
 }
 
 // Checks that Offset can fit in imm24 constant of branch (b) instruction.
 bool canEncodeBranchOffset(IOffsetT Offset) {
   return Utils::IsAligned(Offset, 4) &&
          Utils::IsInt(kBranchOffsetBits, Offset >> 2);
 }
 
@@ skipping 399 matching lines @@
 
 void AssemblerARM32::emitMemOpEnc3(CondARM32::Cond Cond, IValueT Opcode,
                                    IValueT Rt, const Operand *OpAddress,
                                    const TargetInfo &TInfo,
                                    const char *InstName) {
   IValueT Address;
   switch (encodeAddress(OpAddress, Address, TInfo, OpEncoding3)) {
   default:
     llvm::report_fatal_error(std::string(InstName) +
                              ": Memory address not understood");
-  case EncodedAsImmRegOffsetEnc3: {
+  case EncodedAsImmRegOffset: {
     // XXXH (immediate)
     //   xxxh<c> <Rt>, [<Rn>{, #+-<Imm8>}]
     //   xxxh<c> <Rt>, [<Rn>, #+/-<Imm8>]
     //   xxxh<c> <Rt>, [<Rn>, #+/-<Imm8>]!
     //
     // cccc000pu0wxnnnnttttiiiiyyyyjjjj where cccc=Cond, nnnn=Rn, tttt=Rt,
     // iiiijjjj=Imm8, pu0w<<21 is a BlockAddr, x000000000000yyyy0000=Opcode,
     // and pu0w0nnnn0000iiii0000jjjj=Address.
     verifyRegDefined(Rt, "Rt", InstName);
     verifyCondDefined(Cond, InstName);
@@ skipping 350 matching lines @@
   constexpr bool IsLoad = true;
   IValueT Rt = encodeRegister(OpRt, "Rt", LdrName);
   const Type Ty = OpRt->getType();
   switch (typeWidthInBytesLog2(Ty)) {
   case 3:
   // LDRD is not implemented because target lowering handles i64 and double by
   // using two (32-bit) load instructions. Note: Intenionally drop to default
   // case.
   default:
     llvm::report_fatal_error(std::string("ldr : Type ") + typeString(Ty) +
-                             " not implementable\n");
+                             " not implementable");
   case 0: {
     // Handles i1 and i8 loads.
     //
     // LDRB (immediate) - ARM section A8.8.68, encoding A1:
     //   ldrb<c> <Rt>, [<Rn>{, #+/-<imm12>}]     ; p=1, w=0
     //   ldrb<c> <Rt>, [<Rn>], #+/-<imm12>       ; p=1, w=1
     //   ldrb<c> <Rt>, [<Rn>, #+/-<imm12>]!      ; p=0, w=1
     //
     // cccc010pu1w1nnnnttttiiiiiiiiiiii where cccc=Cond, tttt=Rt, nnnn=Rn,
     // iiiiiiiiiiii=imm12, u=1 if +, pu0w is a BlockAddr, and
@@ skipping 42 matching lines @@
     //
     // cccc011pu0w1nnnnttttiiiiiss0mmmm where cccc=Cond, tttt=Rt, U=1 if +, pu0b
     // is a BlockAddr, and pu0w0nnnn0000iiiiiss0mmmm=Address.
     constexpr bool IsByte = false;
     emitMemOp(Cond, IsLoad, IsByte, Rt, OpAddress, TInfo, LdrName);
     return;
   }
   }
 }
 
+void AssemblerARM32::emitMemExOp(CondARM32::Cond Cond, Type Ty, bool IsLoad,
+                                 const Operand *OpRd, IValueT Rt,
+                                 const Operand *OpAddress,
+                                 const TargetInfo &TInfo,
+                                 const char *InstName) {
+  IValueT Rd = encodeRegister(OpRd, "Rd", InstName);
+  IValueT MemExOpcode = IsLoad ? B0 : 0;
+  switch (typeWidthInBytesLog2(Ty)) {

[John, 2015/12/11 16:59:09]

Why did you switch on the type width? can you switch (Ty) instead?

[Karl, 2015/12/11 18:05:08]

I did it this way for the following reasons:

1) I wanted only one source of type width (for each type), so that if it
changes, no other code needs fixing.

2) Using the log2 form, there is a simple contiguous switch selection (allowing
possible optimization of the switch).

[John, 2015/12/11 18:10:46]

IceType_i[8|16|32|64] are declared sequentially in the enum, so the compiler
should be able to optimize this.

Please, switch on Ty. It will make the code explicit (i.e., ldrex/strex operate
on integer types.) anything other than i8, i16, i32, or i64 here is a mistake
and should be reported.

[Karl, 2015/12/11 21:00:12]

OK, I'll change it, but you are slightly incorrect. type i1 uses the "b" form
also.

We should also be consistent, so I'm fixing the other cases where
typeWidthInBits is used.

+  default:
+    llvm::report_fatal_error(std::string(InstName) + ": Type " +
+                             typeString(Ty) + " not implementable");
+  case 0:
+    MemExOpcode |= B2;
+    break;
+  case 1:
+    MemExOpcode |= B2 | B1;
+    break;
+  case 2:
+    break;
+  case 3:
+    MemExOpcode |= B1;
+  }
+  // emitMemExOp(Cond, MemExOpcode, Rd, Rt, OpAddress, TInfo, InstName);

[Jim Stichnoth, 2015/12/11 17:24:57]

Remove this comment?

[Karl, 2015/12/11 18:05:08]

Really? I like useless comments. Removing...

+  IValueT AddressRn;
+  if (encodeAddress(OpAddress, AddressRn, TInfo, OpEncodingMemEx) !=
+      EncodedAsImmRegOffset)
+    llvm::report_fatal_error(std::string(InstName) +
+                             ": Can't extract Rn from address");
+  assert(Utils::IsAbsoluteUint(3, MemExOpcode));
+  verifyRegDefined(Rd, "Rd", InstName);
+  verifyRegDefined(Rt, "Rt", InstName);
+  verifyCondDefined(Cond, InstName);
+  AssemblerBuffer::EnsureCapacity ensured(&Buffer);
+  IValueT Encoding = (Cond << kConditionShift) | B24 | B23 | B11 | B10 | B9 |
+                     B8 | B7 | B4 | (MemExOpcode << kMemExOpcodeShift) |
+                     AddressRn | (Rd << kRdShift) | (Rt << kRmShift);
+  emitInst(Encoding);
+  return;
+}
+
+void AssemblerARM32::ldrex(const Operand *OpRt, const Operand *OpAddress,
+                           CondARM32::Cond Cond, const TargetInfo &TInfo) {
+  // LDREXB - ARM section A8.8.76, encoding A1:
+  //   ldrexb<c> <Rt>, [<Rn>]
+  //
+  // cccc00011101nnnntttt111110011111 where cccc=Cond, tttt=Rt, and nnnn=Rn.
+  //
+  // LDREXH - ARM section A8.8.78, encoding A1:
+  //   ldrexh<c> <Rt>, [<Rn>]
+  //
+  // cccc00011111nnnntttt111110011111 where cccc=Cond, tttt=Rt, and nnnn=Rn.
+  //
+  // LDREX - ARM section A8.8.75, encoding A1:
+  //   ldrex<c> <Rt>, [<Rn>]
+  //
+  // cccc00011001nnnntttt111110011111 where cccc=Cond, tttt=Rt, and nnnn=Rn.
+  //
+  // LDREXD - ARM section A8.
+  //   ldrexd<c> <Rt>, [<Rn>]
+  //
+  // cccc00011001nnnntttt111110011111 where cccc=Cond, tttt=Rt, and nnnn=Rn.
+  constexpr const char *LdrexName = "ldrex";
+  const Type Ty = OpRt->getType();
+  constexpr bool IsLoad = true;
+  constexpr IValueT Rm = RegARM32::Encoded_Reg_pc;
+  emitMemExOp(Cond, Ty, IsLoad, OpRt, Rm, OpAddress, TInfo, LdrexName);
+}
+
 void AssemblerARM32::emitShift(const CondARM32::Cond Cond,
                                const OperandARM32::ShiftKind Shift,
                                const Operand *OpRd, const Operand *OpRm,
                                const Operand *OpSrc1, const bool SetFlags,
                                const char *InstName) {
   constexpr IValueT ShiftOpcode = B3 | B2 | B0; // 1101
   IValueT Rd = encodeRegister(OpRd, "Rd", InstName);
   IValueT Rm = encodeRegister(OpRm, "Rm", InstName);
   IValueT Value;
   switch (encodeOperand(OpSrc1, Value)) {
@@ skipping 249 matching lines @@
     //
     // cccc010pu1w0nnnnttttiiiiiiiiiiii where cccc=Cond, tttt=Rt, nnnn=Rn,
     // iiiiiiiiiiii=imm12, u=1 if +.
     constexpr bool IsByte = false;
     emitMemOp(Cond, IsLoad, IsByte, Rt, OpAddress, TInfo, StrName);
     return;
   }
   }
 }
 
+void AssemblerARM32::strex(const Operand *OpRd, const Operand *OpRt,
+                           const Operand *OpAddress, CondARM32::Cond Cond,
+                           const TargetInfo &TInfo) {
+  // STREXB - ARM section A8.8.213, encoding A1:
+  //   strexb<c> <Rd>, <Rt>, [<Rn>]
+  //
+  // cccc00011100nnnndddd11111001tttt where cccc=Cond, dddd=Rd, tttt=Rt, and
+  // nnnn=Rn.
+  //
+  // STREXH - ARM section A8.8.215, encoding A1:
+  //   strexh<c> <Rd>, <Rt>, [<Rn>]
+  //
+  // cccc00011110nnnndddd11111001tttt where cccc=Cond, dddd=Rd, tttt=Rt, and
+  // nnnn=Rn.
+  //
+  // STREX - ARM section A8.8.212, encoding A1:
+  //   strex<c> <Rd>, <Rt>, [<Rn>]
+  //
+  // cccc00011000nnnndddd11111001tttt where cccc=Cond, dddd=Rd, tttt=Rt, and
+  // nnnn=Rn.
+  //
+  // STREXD - ARM section A8.8.214, encoding A1:
+  //   strexd<c> <Rd>, <Rt>, [<Rn>]
+  //
+  // cccc00011010nnnndddd11111001tttt where cccc=Cond, dddd=Rd, tttt=Rt, and
+  // nnnn=Rn.
+  constexpr const char *StrexName = "strex";
+  // Note: Rt uses Rm shift in encoding.
+  IValueT Rt = encodeRegister(OpRt, "Rt", StrexName);
+  const Type Ty = OpRt->getType();
+  constexpr bool IsLoad = true;
+  emitMemExOp(Cond, Ty, !IsLoad, OpRd, Rt, OpAddress, TInfo, StrexName);
+  return;

[Jim Stichnoth, 2015/12/11 17:24:57]

Remove this explicit return.

[Karl, 2015/12/11 18:05:08]

Done.

+}
+
 void AssemblerARM32::orr(const Operand *OpRd, const Operand *OpRn,
                          const Operand *OpSrc1, bool SetFlags,
                          CondARM32::Cond Cond) {
   // ORR (register) - ARM Section A8.8.123, encoding A1:
   //   orr{s}<c> <Rd>, <Rn>, <Rm>
   //
   // cccc0001100snnnnddddiiiiitt0mmmm where cccc=Cond, dddd=Rd, nnnn=Rn,
   // mmmm=Rm, iiiii=shift, tt=ShiftKind,, and s=SetFlags.
   //
   // ORR (register) - ARM Section A8.8.123, encoding A1:
@@ skipping 220 matching lines @@
 
 void AssemblerARM32::uxt(const Operand *OpRd, const Operand *OpSrc0,
                          CondARM32::Cond Cond) {
   constexpr const char *UxtName = "uxt";
   constexpr IValueT UxtOpcode = B26 | B25 | B23 | B22 | B21;
   emitSignExtend(Cond, UxtOpcode, OpRd, OpSrc0, UxtName);
 }
 
 } // end of namespace ARM32
 } // end of namespace Ice