Add trap (an UDF instruction) to the 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 1855 matching lines @@
   //    sub{s}<c> sp, <Rn>, #<RotatedImm8>
   //
   // cccc0010010snnnnddddiiiiiiiiiiii where cccc=Cond, dddd=Rd, nnnn=Rn,
   // s=SetFlags and iiiiiiiiiiii=Src1Value defining RotatedImm8
   constexpr const char *SubName = "sub";
   constexpr IValueT SubOpcode = B1; // 0010
   emitType01(Cond, SubOpcode, OpRd, OpRn, OpSrc1, SetFlags, RdIsPcAndSetFlags,
              SubName);
 }
 
+// Use a particular UDF encoding -- TRAPNaCl in LLVM: 0xE7FEDEF0
+// http://llvm.org/viewvc/llvm-project?view=revision&revision=173943
+const uint8_t AssemblerARM32::TrapInst[] = {0xE7, 0xFE, 0xDE, 0xF0};
+
+llvm::ArrayRef<uint8_t> AssemblerARM32::getNonExecBundlePadding() const {
+  return llvm::ArrayRef<uint8_t>(TrapInst, llvm::array_lengthof(TrapInst));
+}
+
+void AssemblerARM32::trap() {
+  AssemblerBuffer::EnsureCapacity ensured(&Buffer);
+  for (size_t i = llvm::array_lengthof(TrapInst); i > 0; --i) {

[Jim Stichnoth, 2015/12/17 16:41:00]

Actually, one more (optional) idea that adds a lot more clarity, I think (though
at the cost of minor efficiency):

  auto Bytes = getNonExecBundlePadding();
  for (const uint8_t &Byte : reverse_range(Bytes)) {
    Buffer.emit<uint8_t>(Byte);
  }

To address the efficiency issue, here's another version that could probably use
a bit more cleanup:

namespace {
const uint8_t TrapBytesRaw[] = {0xE7, 0xFE, 0xDE, 0xF0};
const auto TrapBytes =
  llvm::ArrayRef<uint8_t>(TrapBytesRaw, llvm::array_lengthof(TrapBytesRaw));
} // end of anonymous namespace

llvm::ArrayRef<uint8_t> AssemblerARM32::getNonExecBundlePadding() const {
  return TrapBytes;
}

void AssemblerARM32::trap() {
  AssemblerBuffer::EnsureCapacity ensured(&Buffer);
  for (const uint8_t &Byte : reverse_range(TrapBytes)) {
    Buffer.emit<uint8_t>(Byte);
  }
}

[Karl, 2015/12/17 16:55:28]

Done.

+    Buffer.emit<uint8_t>(TrapInst[i - 1]);
+  }
+}
+
 void AssemblerARM32::tst(const Operand *OpRn, const Operand *OpSrc1,
                          CondARM32::Cond Cond) {
   // TST (register) - ARM section A8.8.241, encoding A1:
   //   tst<c> <Rn>, <Rm>(, <shift>}
   //
   // cccc00010001nnnn0000iiiiitt0mmmm where cccc=Cond, nnnn=Rn, mmmm=Rm,
   // iiiii=Shift, and tt=ShiftKind.
   //
   // TST (immediate) - ARM section A8.8.240, encoding A1:
   //   tst<c> <Rn>, #<RotatedImm8>
@@ skipping 49 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