Revert r291903 and r291898. Reason: they break check-lld on the bots.

[krasin]

Summary

Revert [ARM] Fix ubig32_t read in ARMAttributeParser

Now using support functions to read data instead of trying to

perform casts.

Revert [ARM] Enable objdump to construct triple for ARM

Now that The ARMAttributeParser has been moved into the library,
it has been modified so that it can parse the attributes without
printing them and stores them in a map. ELFObjectFile now queries
the attributes to fill out the architecture details of a provided
triple for 'arm' and 'thumb' targets. llvm-objdump uses this new
functionality.

[krasin]

For the record, check-lld failures can be observed here:
http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-fast/builds/2078

Testing: 0 .. 10.
FAIL: lld :: ELF/arm-data-relocs.s (165 of 1011)
******************** TEST 'lld :: ELF/arm-data-relocs.s' FAILED ********************
Script:
--
/mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm_build_asan/./bin/llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/lld/test/ELF/arm-data-relocs.s -o /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm_build_asan/tools/lld/test/ELF/Output/arm-data-relocs.s.tmp
/mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm_build_asan/./bin/llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/lld/test/ELF/Inputs/abs256.s -o /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm_build_asan/tools/lld/test/ELF/Output/arm-data-relocs.s.tmp256.o
/mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm_build_asan/./bin/ld.lld --full-shutdown /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm_build_asan/tools/lld/test/ELF/Output/arm-data-relocs.s.tmp /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm_build_asan/tools/lld/test/ELF/Output/arm-data-relocs.s.tmp256.o -o /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm_build_asan/tools/lld/test/ELF/Output/arm-data-relocs.s.tmp2
/mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm_build_asan/./bin/llvm-objdump -d /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm_build_asan/tools/lld/test/ELF/Output/arm-data-relocs.s.tmp2 | /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm_build_asan/./bin/FileCheck /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/lld/test/ELF/arm-data-relocs.s
--
Exit Code: 2

Command Output (stderr):
--
=================================================================
==32435==ERROR: AddressSanitizer: stack-buffer-overflow on address 0x7f5c9250a650 at pc 0x000000ee1eff bp 0x7fff39799670 sp 0x7fff39799668
READ of size 4 at 0x7f5c9250a650 thread T0
    #0 0xee1efe in getAttributeValue /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/include/llvm/Support/ARMAttributeParser.h:133:34
    #1 0xee1efe in llvm::object::ELFObjectFileBase::setARMSubArch(llvm::Triple&) const /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/lib/Object/ELFObjectFile.cpp:143
    #2 0x60ffff in getTarget /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/llvm-objdump/llvm-objdump.cpp:367:14
    #3 0x60ffff in DisassembleObject(llvm::object::ObjectFile const*, bool) /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/llvm-objdump/llvm-objdump.cpp:1115
    #4 0x60d270 in DumpObject(llvm::object::ObjectFile const*, llvm::object::Archive const*) /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/llvm-objdump/llvm-objdump.cpp:1977:5
    #5 0x5c7ef4 in DumpInput /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/llvm-objdump/llvm-objdump.cpp:2066:5
    #6 0x5c7ef4 in for_each<std::__1::__wrap_iter<std::__1::basic_string<char> *>, void (*)(llvm::StringRef)> /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/libcxx_build_asan/include/c++/v1/algorithm:879
    #7 0x5c7ef4 in main /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/llvm-objdump/llvm-objdump.cpp:2126
    #8 0x7f5c9568782f in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2082f)
    #9 0x4c55c8 in _start (/mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm_build_asan/bin/llvm-objdump+0x4c55c8)

Address 0x7f5c9250a650 is located in stack of thread T0 at offset 80 in frame
    #0 0xee19af in llvm::object::ELFObjectFileBase::setARMSubArch(llvm::Triple&) const /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/lib/Object/ELFObjectFile.cpp:126

  This frame has 2 object(s):
    [32, 64) 'Attributes:130'
    [96, 120) 'Triple:135' <== Memory access at offset 80 underflows this variable
HINT: this may be a false positive if your program uses some custom stack unwind mechanism or swapcontext
      (longjmp and C++ exceptions *are* supported)
SUMMARY: AddressSanitizer: stack-buffer-overflow /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/include/llvm/Support/ARMAttributeParser.h:133:34 in getAttributeValue
Shadow bytes around the buggy address:
  0x0fec12499470: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
  0x0fec12499480: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
  0x0fec12499490: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
  0x0fec124994a0: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
  0x0fec124994b0: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
=>0x0fec124994c0: f1 f1 f1 f1 00 00 00 00 f2 f2[f2]f2 00 00 00 f3
  0x0fec124994d0: f3 f3 f3 f3 00 00 00 00 00 00 00 00 00 00 00 00
  0x0fec124994e0: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
  0x0fec124994f0: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
  0x0fec12499500: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  0x0fec12499510: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
Shadow byte legend (one shadow byte represents 8 application bytes):
  Addressable:           00
  Partially addressable: 01 02 03 04 05 06 07 
  Heap left redzone:       fa
  Freed heap region:       fd
  Stack left redzone:      f1
  Stack mid redzone:       f2
  Stack right redzone:     f3
  Stack after return:      f5
  Stack use after scope:   f8
  Global redzone:          f9
  Global init order:       f6
  Poisoned by user:        f7
  Container overflow:      fc
  Array cookie:            ac
  Intra object redzone:    bb
  ASan internal:           fe
  Left alloca redzone:     ca
  Right alloca redzone:    cb
==32435==ABORTING
FileCheck error: '-' is empty.
FileCheck command line:  /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm_build_asan/./bin/FileCheck /mnt/b/sanitizer-buildbot3/sanitizer-x86_64-linux-fast/build/llvm/tools/lld/test/ELF/arm-data-relocs.s

llvm/trunk/include/llvm/Object/ELFObjectFile.h

 #include "llvm/ADT/iterator_range.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Object/ELFTypes.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/SymbolicFile.h"
-#include "llvm/Support/ARMAttributeParser.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <cassert>
public:
   typedef iterator_range<elf_symbol_iterator> elf_symbol_iterator_range;
   virtual elf_symbol_iterator_range getDynamicSymbolIterators() const = 0;
 
   elf_symbol_iterator_range symbols() const;
 
   static inline bool classof(const Binary *v) { return v->isELF(); }
 
   SubtargetFeatures getFeatures() const override;
-
-  void setARMSubArch(Triple &TheTriple) const override;
 };
 
 class ELFSectionRef : public SectionRef {
 public:
   ELFSectionRef(const SectionRef &B) : SectionRef(B) {
     assert(isa<ELFObjectFileBase>(SectionRef::getObject()));
   }
 
public:
   StringRef getFileFormatName() const override;
   unsigned getArch() const override;
 
   std::error_code getPlatformFlags(unsigned &Result) const override {
     Result = EF.getHeader()->e_flags;
     return std::error_code();
   }
 
-  std::error_code getBuildAttributes(ARMAttributeParser &Attributes) const override {
-    auto SectionsOrErr = EF.sections();
-    if (!SectionsOrErr)
-      return errorToErrorCode(SectionsOrErr.takeError());
-
-    for (const Elf_Shdr &Sec : *SectionsOrErr) {
-      if (Sec.sh_type == ELF::SHT_ARM_ATTRIBUTES) {
-        auto ErrorOrContents = EF.getSectionContents(&Sec);
-        if (!ErrorOrContents)
-          return errorToErrorCode(ErrorOrContents.takeError());
-
-        auto Contents = ErrorOrContents.get();
-        if (Contents[0] != ARMBuildAttrs::Format_Version || Contents.size() == 1)
-          return std::error_code();
-
-        Attributes.Parse(Contents, ELFT::TargetEndianness == support::little);
-        break;
-      }
-    }
-    return std::error_code();
-  }
-
   const ELFFile<ELFT> *getELFFile() const { return &EF; }
 
   bool isDyldType() const { return isDyldELFObject; }
   static inline bool classof(const Binary *v) {
     return v->getType() == getELFType(ELFT::TargetEndianness == support::little,
                                       ELFT::Is64Bits);
   }
 

llvm/trunk/include/llvm/Object/ObjectFile.h

 #include "llvm/Object/SymbolicFile.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <cstring>
 
 namespace llvm {
-class ARMAttributeParser;
-
 namespace object {
 
 class ObjectFile;
 class COFFObjectFile;
 class MachOObjectFile;
 class WasmObjectFile;
 
 class SymbolRef;
public:
 
   /// @brief The number of bytes used to represent an address in this object
   ///        file format.
   virtual uint8_t getBytesInAddress() const = 0;
 
   virtual StringRef getFileFormatName() const = 0;
   virtual /* Triple::ArchType */ unsigned getArch() const = 0;
   virtual SubtargetFeatures getFeatures() const = 0;
-  virtual void setARMSubArch(Triple &TheTriple) const { }
 
   /// Returns platform-specific object flags, if any.
   virtual std::error_code getPlatformFlags(unsigned &Result) const {
     Result = 0;
     return object_error::invalid_file_type;
   }
 
-  virtual std::error_code
-    getBuildAttributes(ARMAttributeParser &Attributes) const {
-      return std::error_code();
-    }
-
   /// True if this is a relocatable object (.o/.obj).
   virtual bool isRelocatableObject() const = 0;
 
   /// @returns Pointer to ObjectFile subclass to handle this type of object.
   /// @param ObjectPath The path to the object file. ObjectPath.isObject must
   ///        return true.
   /// @brief Create ObjectFile from path.
   static Expected<OwningBinary<ObjectFile>>

llvm/trunk/include/llvm/Support/ARMAttributeParser.h

 //===--- ARMAttributeParser.h - ARM Attribute Information Printer ---------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_ARMATTRIBUTEPARSER_H
 #define LLVM_SUPPORT_ARMATTRIBUTEPARSER_H
 
 #include "ARMBuildAttributes.h"
 #include "ScopedPrinter.h"
 
-#include <map>
-
 namespace llvm {
 class StringRef;
 
 class ARMAttributeParser {
-  ScopedPrinter *SW;
-
-  std::map<unsigned, unsigned> Attributes;
+  ScopedPrinter &SW;
 
   struct DisplayHandler {
     ARMBuildAttrs::AttrType Attribute;
     void (ARMAttributeParser::*Routine)(ARMBuildAttrs::AttrType,
                                         const uint8_t *, uint32_t &);
   };
   static const DisplayHandler DisplayRoutines[];
 
void nodefaults(ARMBuildAttrs::AttrType Tag, const uint8_t *Data,
                   uint32_t &Offset);
 
   void ParseAttributeList(const uint8_t *Data, uint32_t &Offset,
                           uint32_t Length);
   void ParseIndexList(const uint8_t *Data, uint32_t &Offset,
                       SmallVectorImpl<uint8_t> &IndexList);
   void ParseSubsection(const uint8_t *Data, uint32_t Length);
 public:
-  ARMAttributeParser(ScopedPrinter *SW) : SW(SW) {}
-
-  ARMAttributeParser() : SW(nullptr) { }
-
-  void Parse(ArrayRef<uint8_t> Section, bool isLittle);
+  ARMAttributeParser(ScopedPrinter &SW) : SW(SW) {}
 
-  bool hasAttribute(unsigned Tag) const {
-    return Attributes.count(Tag);
-  }
-
-  unsigned getAttributeValue(unsigned Tag) const {
-    return Attributes.find(Tag)->second;
-  }
+  void Parse(ArrayRef<uint8_t> Section);
 };
 
 }
 
 #endif
 

llvm/trunk/include/llvm/Support/ARMBuildAttributes.h

enum {
   AddressDirect = 1, // Address imported data directly
   AddressGOT = 2, // Address imported data indirectly (via GOT)
 
   // Tag_ABI_PCS_wchar_t, (=18), uleb128
   WCharProhibited = 0,  // wchar_t is not used
   WCharWidth2Bytes = 2, // sizeof(wchar_t) == 2
   WCharWidth4Bytes = 4, // sizeof(wchar_t) == 4
 
-  // Tag_ABI_align_needed, (=24), uleb128
-  Align8Byte = 1,
-  Align4Byte = 2,
-  AlignReserved = 3,
-
-  // Tag_ABI_align_needed, (=25), uleb128
-  AlignNotPreserved = 0,
-  AlignPreserve8Byte = 1,
-  AlignPreserveAll = 2,
-
   // Tag_ABI_FP_denormal, (=20), uleb128
   PositiveZero = 0,
   IEEEDenormals = 1,
   PreserveFPSign = 2, // sign when flushed-to-zero is preserved
 
   // Tag_ABI_FP_number_model, (=23), uleb128
-  AllowIEEENormal = 1,
   AllowRTABI = 2,  // numbers, infinities, and one quiet NaN (see [RTABI])
-  AllowIEEE754 = 3, // this code to use all the IEEE 754-defined FP encodings
+  AllowIEE754 = 3, // this code to use all the IEEE 754-defined FP encodings
 
   // Tag_ABI_enum_size, (=26), uleb128
   EnumProhibited = 0, // The user prohibited the use of enums when building
                       // this entity.
   EnumSmallest = 1,   // Enum is smallest container big enough to hold all
                       // values.
   Enum32Bit = 2,      // Enum is at least 32 bits.
   Enum32BitABI = 3,   // Every enumeration visible across an ABI-complying
                       // interface contains a value needing 32 bits to encode
                       // it; other enums can be containerized.
 
   // Tag_ABI_HardFP_use, (=27), uleb128
   HardFPImplied = 0,          // FP use should be implied by Tag_FP_arch
   HardFPSinglePrecision = 1,  // Single-precision only
 
   // Tag_ABI_VFP_args, (=28), uleb128
   BaseAAPCS = 0,
   HardFPAAPCS = 1,
 
   // Tag_FP_HP_extension, (=36), uleb128
   AllowHPFP = 1, // Allow use of Half Precision FP
 
   // Tag_FP_16bit_format, (=38), uleb128
   FP16FormatIEEE = 1,
-  FP16VFP3 = 2,
 
   // Tag_MPextension_use, (=42), uleb128
   AllowMP = 1, // Allow use of MP extensions
 
   // Tag_DIV_use, (=44), uleb128
   // Note: AllowDIVExt must be emitted if and only if the permission to use
   // hardware divide cannot be conveyed using AllowDIVIfExists or DisallowDIV
   AllowDIVIfExists = 0, // Allow hardware divide if available in arch, or no

llvm/trunk/lib/Object/ELFObjectFile.cpp

case ELF::EM_MIPS: {
 
     return Features;
   }
   default:
     return SubtargetFeatures();
   }
 }
 
-// FIXME Encode from a tablegen description or target parser.
-void ELFObjectFileBase::setARMSubArch(Triple &TheTriple) const {
-  if (TheTriple.getSubArch() != Triple::NoSubArch)
-    return;
-
-  ARMAttributeParser Attributes;
-  std::error_code EC = getBuildAttributes(Attributes);
-  if (EC)
-    return;
-
-  std::string Triple;
-  // Default to ARM, but use the triple if it's been set.
-  if (TheTriple.getArch() == Triple::thumb ||
-      TheTriple.getArch() == Triple::thumbeb)
-    Triple = "thumb";
-  else
-    Triple = "arm";
-
-  switch(Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch)) {
-  case ARMBuildAttrs::v4:
-    Triple += "v4";
-    break;
-  case ARMBuildAttrs::v4T:
-    Triple += "v4t";
-    break;
-  case ARMBuildAttrs::v5T:
-    Triple += "v5t";
-    break;
-  case ARMBuildAttrs::v5TE:
-    Triple += "v5te";
-    break;
-  case ARMBuildAttrs::v5TEJ:
-    Triple += "v5tej";
-    break;
-  case ARMBuildAttrs::v6:
-    Triple += "v6";
-    break;
-  case ARMBuildAttrs::v6KZ:
-    Triple += "v6kz";
-    break;
-  case ARMBuildAttrs::v6T2:
-    Triple += "v6t2";
-    break;
-  case ARMBuildAttrs::v6K:
-    Triple += "v6k";
-    break;
-  case ARMBuildAttrs::v7:
-    Triple += "v7";
-    break;
-  case ARMBuildAttrs::v6_M:
-    Triple += "v6m";
-    break;
-  case ARMBuildAttrs::v6S_M:
-    Triple += "v6sm";
-    break;
-  case ARMBuildAttrs::v7E_M:
-    Triple += "v7em";
-    break;
-  }
-  if (!isLittleEndian())
-    Triple += "eb";
-
-  TheTriple.setArchName(Triple);
-}
-
 } // end namespace llvm

llvm/trunk/lib/Support/ARMAttributeParser.cpp

StringRef ARMAttributeParser::ParseString(const uint8_t *Data,
   const char *String = reinterpret_cast<const char*>(Data + Offset);
   size_t Length = std::strlen(String);
   Offset = Offset + Length + 1;
   return StringRef(String, Length);
 }
 
 void ARMAttributeParser::IntegerAttribute(AttrType Tag, const uint8_t *Data,
                                           uint32_t &Offset) {
-
-  uint64_t Value = ParseInteger(Data, Offset);
-  Attributes.insert(std::make_pair(Tag, Value));
-
-  if (SW)
-    SW->printNumber(ARMBuildAttrs::AttrTypeAsString(Tag), Value);
+  SW.printNumber(ARMBuildAttrs::AttrTypeAsString(Tag),
+                 ParseInteger(Data, Offset));
 }
 
 void ARMAttributeParser::StringAttribute(AttrType Tag, const uint8_t *Data,
                                          uint32_t &Offset) {
   StringRef TagName = ARMBuildAttrs::AttrTypeAsString(Tag, /*TagPrefix*/false);
-  StringRef ValueDesc = ParseString(Data, Offset);
 
-  if (SW) {
-    DictScope AS(*SW, "Attribute");
-    SW->printNumber("Tag", Tag);
-    if (!TagName.empty())
-      SW->printString("TagName", TagName);
-    SW->printString("Value", ValueDesc);
-  }
+  DictScope AS(SW, "Attribute");
+  SW.printNumber("Tag", Tag);
+    SW.printString("TagName", TagName);
+  SW.printString("Value", ParseString(Data, Offset));
 }
 
 void ARMAttributeParser::PrintAttribute(unsigned Tag, unsigned Value,
                                         StringRef ValueDesc) {
-  Attributes.insert(std::make_pair(Tag, Value));
+  StringRef TagName = ARMBuildAttrs::AttrTypeAsString(Tag, /*TagPrefix*/false);
 
-  if (SW) {
-    StringRef TagName = ARMBuildAttrs::AttrTypeAsString(Tag,
-                                                        /*TagPrefix*/false);
-    DictScope AS(*SW, "Attribute");
-    SW->printNumber("Tag", Tag);
-    SW->printNumber("Value", Value);
-    if (!TagName.empty())
-      SW->printString("TagName", TagName);
-    if (!ValueDesc.empty())
-      SW->printString("Description", ValueDesc);
-  }
+  DictScope AS(SW, "Attribute");
+  SW.printNumber("Tag", Tag);
+  SW.printNumber("Value", Value);
+    SW.printString("TagName", TagName);
+    SW.printString("Description", ValueDesc);
 }
 
 void ARMAttributeParser::CPU_arch(AttrType Tag, const uint8_t *Data,
                                   uint32_t &Offset) {
   static const char *const Strings[] = {
     "Pre-v4", "ARM v4", "ARM v4T", "ARM v5T", "ARM v5TE", "ARM v5TEJ", "ARM v6",
     "ARM v6KZ", "ARM v6T2", "ARM v6K", "ARM v7", "ARM v6-M", "ARM v6S-M",
     "ARM v7E-M", "ARM v8"
void ARMAttributeParser::ABI_FP_optimization_goals(AttrType Tag,
   PrintAttribute(Tag, Value, ValueDesc);
 }
 
 void ARMAttributeParser::compatibility(AttrType Tag, const uint8_t *Data,
                                        uint32_t &Offset) {
   uint64_t Integer = ParseInteger(Data, Offset);
   StringRef String = ParseString(Data, Offset);
 
-  if (SW) {
-    DictScope AS(*SW, "Attribute");
-    SW->printNumber("Tag", Tag);
-    SW->startLine() << "Value: " << Integer << ", " << String << '\n';
-    SW->printString("TagName", AttrTypeAsString(Tag, /*TagPrefix*/false));
-    switch (Integer) {
-    case 0:
-      SW->printString("Description", StringRef("No Specific Requirements"));
-      break;
-    case 1:
-      SW->printString("Description", StringRef("AEABI Conformant"));
-      break;
-    default:
-      SW->printString("Description", StringRef("AEABI Non-Conformant"));
-      break;
-    }
-  }
-}
+  DictScope AS(SW, "Attribute");
+  SW.printNumber("Tag", Tag);
+  SW.startLine() << "Value: " << Integer << ", " << String << '\n';
+  SW.printString("TagName", AttrTypeAsString(Tag, /*TagPrefix*/false));
+    SW.printString("Description", StringRef("No Specific Requirements"));
+    SW.printString("Description", StringRef("AEABI Conformant"));
+    SW.printString("Description", StringRef("AEABI Non-Conformant"));
 
 void ARMAttributeParser::CPU_unaligned_access(AttrType Tag, const uint8_t *Data,
                                               uint32_t &Offset) {
   static const char *const Strings[] = { "Not Permitted", "v6-style" };
 
   uint64_t Value = ParseInteger(Data, Offset);
   StringRef ValueDesc =
     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
if (!Handled) {
         StringAttribute(ARMBuildAttrs::AttrType(Tag), Data, Offset);
     }
   }
 }
 
 void ARMAttributeParser::ParseSubsection(const uint8_t *Data, uint32_t Length) {
   uint32_t Offset = sizeof(uint32_t); /* SectionLength */
 
+  SW.printNumber("SectionLength", Length);
+
   const char *VendorName = reinterpret_cast<const char*>(Data + Offset);
   size_t VendorNameLength = std::strlen(VendorName);
+  SW.printString("Vendor", StringRef(VendorName, VendorNameLength));
   Offset = Offset + VendorNameLength + 1;
 
-  if (SW) {
-    SW->printNumber("SectionLength", Length);
-    SW->printString("Vendor", StringRef(VendorName, VendorNameLength));
-  }
-
-  if (StringRef(VendorName, VendorNameLength).lower() != "aeabi") {
+  if (StringRef(VendorName, VendorNameLength).lower() != "aeabi")
     return;
-  }
 
   while (Offset < Length) {
     /// Tag_File | Tag_Section | Tag_Symbol   uleb128:byte-size
     uint8_t Tag = Data[Offset];
+    SW.printEnum("Tag", Tag, makeArrayRef(TagNames));
     Offset = Offset + sizeof(Tag);
 
     uint32_t Size =
       *reinterpret_cast<const support::ulittle32_t*>(Data + Offset);
+    SW.printNumber("Size", Size);
     Offset = Offset + sizeof(Size);
 
-    if (SW) {
-      SW->printEnum("Tag", Tag, makeArrayRef(TagNames));
-      SW->printNumber("Size", Size);
-    }
-
     if (Size > Length) {
       errs() << "subsection length greater than section length\n";
       return;
     }
 
     StringRef ScopeName, IndexName;
     SmallVector<uint8_t, 8> Indicies;
     switch (Tag) {
case ARMBuildAttrs::Symbol:
       IndexName = "Symbols";
       ParseIndexList(Data, Offset, Indicies);
       break;
     default:
       errs() << "unrecognised tag: 0x" << utohexstr(Tag) << '\n';
       return;
     }
 
-    if (SW) {
-      DictScope ASS(*SW, ScopeName);
-      if (!Indicies.empty())
-        SW->printList(IndexName, Indicies);
-    }
+    DictScope ASS(SW, ScopeName);
+
+      SW.printList(IndexName, Indicies);
 
     ParseAttributeList(Data, Offset, Length);
   }
 }
 
-void ARMAttributeParser::Parse(ArrayRef<uint8_t> Section, bool isLittle) {
+void ARMAttributeParser::Parse(ArrayRef<uint8_t> Section) {
   size_t Offset = 1;
   unsigned SectionNumber = 0;
 
   while (Offset < Section.size()) {
     uint32_t SectionLength =
-        isLittle ? support::endian::read32le(Section.data() + Offset)
-                 : support::endian::read32be(Section.data() + Offset);
+      *reinterpret_cast<const support::ulittle32_t*>(Section.data() + Offset);
 
-    if (SW) {
-      SW->startLine() << "Section " << ++SectionNumber << " {\n";
-      SW->indent();
-    }
+    SW.startLine() << "Section " << ++SectionNumber << " {\n";
+    SW.indent();
 
     ParseSubsection(Section.data() + Offset, SectionLength);
     Offset = Offset + SectionLength;
 
-    if (SW) {
-      SW->unindent();
-      SW->startLine() << "}\n";
-    }
+    SW.unindent();
+    SW.startLine() << "}\n";
   }
 }
 }
 

llvm/trunk/lib/Target/ARM/ARMAsmPrinter.cpp

void ARMAsmPrinter::emitAttributes() {
 
   // TM.Options.NoInfsFPMath && TM.Options.NoNaNsFPMath is the
   // equivalent of GCC's -ffinite-math-only flag.
   if (TM.Options.NoInfsFPMath && TM.Options.NoNaNsFPMath)
     ATS.emitAttribute(ARMBuildAttrs::ABI_FP_number_model,
                       ARMBuildAttrs::Allowed);
   else
     ATS.emitAttribute(ARMBuildAttrs::ABI_FP_number_model,
-                      ARMBuildAttrs::AllowIEEE754);
+                      ARMBuildAttrs::AllowIEE754);
 
   if (STI.allowsUnalignedMem())
     ATS.emitAttribute(ARMBuildAttrs::CPU_unaligned_access,
                       ARMBuildAttrs::Allowed);
   else
     ATS.emitAttribute(ARMBuildAttrs::CPU_unaligned_access,
                       ARMBuildAttrs::Not_Allowed);
 

llvm/trunk/test/tools/llvm-objdump/ARM/v5t-subarch.s

-@ RUN: llvm-mc < %s -triple armv5t-elf -filetype=obj | llvm-objdump -triple=arm -d - | FileCheck %s
-
-.arch armv5t
-
-clz:
-clz r0, r1
-
-@ CHECK-LABEL: clz
-@ CHECK: 11 0f 6f e1
-

llvm/trunk/test/tools/llvm-objdump/ARM/v5te-subarch.s

-@ RUN: llvm-mc < %s -triple armv5te-elf -filetype=obj | llvm-objdump -triple=arm -d - | FileCheck %s
-
-.arch armv5te
-
-strd:
-strd r0, r1, [r2, +r3]
-
-@ CHECK-LABEL strd
-@ CHECK: f3 00 82 e1 strd r0, r1, [r2, r3]
-

llvm/trunk/test/tools/llvm-objdump/ARM/v5tej-subarch.s

-@ RUN: llvm-mc < %s -triple armv5tej-elf -filetype=obj | llvm-objdump -triple=arm -d - | FileCheck %s
-
-bxj:
-bxj r0
-
-@ CHECK-LABEL: bxj
-@ CHECK: 20 ff 2f e1 bxj r0

llvm/trunk/test/tools/llvm-objdump/ARM/v6-subarch.s

-@ RUN: llvm-mc < %s -triple armv6-elf -filetype=obj | llvm-objdump -triple=arm -d - | FileCheck %s
-
-.arch armv6
-
-umaal:
-umaal r0, r1, r2, r3
-
-@ CHECK-LABEL:umaal
-@ CHECK: 92 03 41 e0 umaal r0, r1, r2, r3

llvm/trunk/test/tools/llvm-objdump/ARM/v6k-subarch.s

-@ RUN: llvm-mc < %s -triple armv6k-elf -filetype=obj | llvm-objdump -triple=arm -d - | FileCheck %s
-
-.arch armv6k
-
-clrex:
-clrex
-
-@ CHECK-LABEL: clrex
-@ CHECK: 1f f0 7f f5 clrex

llvm/trunk/test/tools/llvm-objdump/ARM/v6m-subarch.s

-@ RUN: llvm-mc < %s -triple armv6m-elf -filetype=obj | llvm-objdump -triple=thumb -d - | FileCheck %s
-
-.arch armv6m
-
-dmb:
-dmb
-
-@ CHECK-LABEL: dmb
-@ CHECK: bf f3 5f 8f dmb sy

llvm/trunk/test/tools/llvm-objdump/ARM/v6t2-subarch.s

-@ RUN: llvm-mc < %s -triple armv6t2-elf -filetype=obj | llvm-objdump -triple=thumb -d - | FileCheck %s
-
-.arch armv6t2
-
-.thumb
-umaalt2:
-umaal r0, r1, r2, r3
-
-@ CHECK-LABEL: umaalt2
-@ CHECK: e2 fb 63 01 umaal r0, r1, r2, r3

llvm/trunk/test/tools/llvm-objdump/ARM/v7m-subarch.s

-@ RUN: llvm-mc < %s -triple armv7m-elf -filetype=obj | llvm-objdump -triple=thumb -d - | FileCheck %s
-
-.arch armv7m
-
-umlal:
-umlal r0, r1, r2, r3
-
-@ CHECK-LABEL: umlal
-@ CHECK: e2 fb 03 01 umlal r0, r1, r2, r3
-

llvm/trunk/tools/llvm-objdump/llvm-objdump.cpp

llvm::report_error(ArchiveName, NameOrErr.get(), std::move(E),
                        ArchitectureName);
 }
 
 static const Target *getTarget(const ObjectFile *Obj = nullptr) {
   // Figure out the target triple.
   llvm::Triple TheTriple("unknown-unknown-unknown");
   if (TripleName.empty()) {
     if (Obj) {
-      auto Arch = Obj->getArch();
-      TheTriple.setArch(Triple::ArchType(Arch));
-
-      // For ARM targets, try to use the build attributes to build determine
-      // the build target. Target features are also added, but later during
-      // disassembly.
-      if (Arch == Triple::arm || Arch == Triple::armeb) {
-        Obj->setARMSubArch(TheTriple);
-      }
-
+      TheTriple.setArch(Triple::ArchType(Obj->getArch()));
       // TheTriple defaults to ELF, and COFF doesn't have an environment:
       // the best we can do here is indicate that it is mach-o.
       if (Obj->isMachO())
         TheTriple.setObjectFormat(Triple::MachO);
 
       if (Obj->isCOFF()) {
         const auto COFFObj = dyn_cast<COFFObjectFile>(Obj);
         if (COFFObj->getArch() == Triple::thumb)
           TheTriple.setTriple("thumbv7-windows");
       }
     }
-  } else {
+  } else
     TheTriple.setTriple(Triple::normalize(TripleName));
-    // Use the triple, but also try to combine with ARM build attributes.
-    if (Obj) {
-      auto Arch = Obj->getArch();
-      if (Arch == Triple::arm || Arch == Triple::armeb) {
-        Obj->setARMSubArch(TheTriple);
-      }
-    }
-  }
 
   // Get the target specific parser.
   std::string Error;
   const Target *TheTarget = TargetRegistry::lookupTarget(ArchName, TheTriple,
                                                          Error);
   if (!TheTarget) {
     if (Obj)
       report_error(Obj->getFileName(), "can't find target: " + Error);

llvm/trunk/tools/llvm-readobj/ELFDumper.cpp

if (Contents[0] != ARMBuildAttrs::Format_Version) {
              << '\n';
       continue;
     }
 
     W.printHex("FormatVersion", Contents[0]);
     if (Contents.size() == 1)
       continue;
 
-    ARMAttributeParser(&W).Parse(Contents, true);
+    ARMAttributeParser(W).Parse(Contents);
   }
 }
 }
 
 namespace {
 template <class ELFT> class MipsGOTParser {
 public:
   TYPEDEF_ELF_TYPES(ELFT)

llvm/trunk/unittests/Support/ARMAttributeParser.cpp

-#include "llvm/Support/ARMBuildAttributes.h"
-#include "llvm/Support/ARMAttributeParser.h"
-#include "llvm/Support/LEB128.h"
-#include "gtest/gtest.h"
-#include <string>
-
-using namespace llvm;
-
-struct AttributeSection {
-  unsigned Tag;
-  unsigned Value;
-
-  AttributeSection(unsigned tag, unsigned value) : Tag(tag), Value(value) { }
-
-  void write(raw_ostream &OS) {
-    OS.flush();
-    // length = length + "aeabi\0" + TagFile + ByteSize + Tag + Value;
-    // length = 17 bytes
-
-    OS << 'A' << (uint8_t)17 << (uint8_t)0 << (uint8_t)0 << (uint8_t)0;
-    OS << "aeabi" << '\0';
-    OS << (uint8_t)1 << (uint8_t)7 << (uint8_t)0 << (uint8_t)0 << (uint8_t)0;
-    OS << (uint8_t)Tag << (uint8_t)Value;
-
-  }
-};
-
-bool testBuildAttr(unsigned Tag, unsigned Value,
-                      unsigned ExpectedTag, unsigned ExpectedValue) {
-  std::string buffer;
-  raw_string_ostream OS(buffer);
-  AttributeSection Section(Tag, Value);
-  Section.write(OS);
-  ArrayRef<uint8_t> Bytes((uint8_t*)OS.str().c_str(), OS.str().size());
-
-  ARMAttributeParser Parser;
-  Parser.Parse(Bytes, true);
-
-  return (Parser.hasAttribute(ExpectedTag) &&
-    Parser.getAttributeValue(ExpectedTag) == ExpectedValue);
-}
-
-bool testTagString(unsigned Tag, const char *name) {
-  return ARMBuildAttrs::AttrTypeAsString(Tag).str() == name;
-}
-
-TEST(CPUArchBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(6, "Tag_CPU_arch"));
-
-  EXPECT_TRUE(testBuildAttr(6, 0, ARMBuildAttrs::CPU_arch,
-                            ARMBuildAttrs::Pre_v4));
-  EXPECT_TRUE(testBuildAttr(6, 1, ARMBuildAttrs::CPU_arch,
-                            ARMBuildAttrs::v4));
-  EXPECT_TRUE(testBuildAttr(6, 2, ARMBuildAttrs::CPU_arch,
-                               ARMBuildAttrs::v4T));
-  EXPECT_TRUE(testBuildAttr(6, 3, ARMBuildAttrs::CPU_arch,
-                               ARMBuildAttrs::v5T));
-  EXPECT_TRUE(testBuildAttr(6, 4, ARMBuildAttrs::CPU_arch,
-                               ARMBuildAttrs::v5TE));
-  EXPECT_TRUE(testBuildAttr(6, 5, ARMBuildAttrs::CPU_arch,
-                               ARMBuildAttrs::v5TEJ));
-  EXPECT_TRUE(testBuildAttr(6, 6, ARMBuildAttrs::CPU_arch,
-                               ARMBuildAttrs::v6));
-  EXPECT_TRUE(testBuildAttr(6, 7, ARMBuildAttrs::CPU_arch,
-                               ARMBuildAttrs::v6KZ));
-  EXPECT_TRUE(testBuildAttr(6, 8, ARMBuildAttrs::CPU_arch,
-                               ARMBuildAttrs::v6T2));
-  EXPECT_TRUE(testBuildAttr(6, 9, ARMBuildAttrs::CPU_arch,
-                               ARMBuildAttrs::v6K));
-  EXPECT_TRUE(testBuildAttr(6, 10, ARMBuildAttrs::CPU_arch,
-                               ARMBuildAttrs::v7));
-  EXPECT_TRUE(testBuildAttr(6, 11, ARMBuildAttrs::CPU_arch,
-                               ARMBuildAttrs::v6_M));
-  EXPECT_TRUE(testBuildAttr(6, 12, ARMBuildAttrs::CPU_arch,
-                               ARMBuildAttrs::v6S_M));
-  EXPECT_TRUE(testBuildAttr(6, 13, ARMBuildAttrs::CPU_arch,
-                               ARMBuildAttrs::v7E_M));
-}
-
-TEST(CPUArchProfileBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(7, "Tag_CPU_arch_profile"));
-  EXPECT_TRUE(testBuildAttr(7, 'A', ARMBuildAttrs::CPU_arch_profile,
-                               ARMBuildAttrs::ApplicationProfile));
-  EXPECT_TRUE(testBuildAttr(7, 'R', ARMBuildAttrs::CPU_arch_profile,
-                               ARMBuildAttrs::RealTimeProfile));
-  EXPECT_TRUE(testBuildAttr(7, 'M', ARMBuildAttrs::CPU_arch_profile,
-                               ARMBuildAttrs::MicroControllerProfile));
-  EXPECT_TRUE(testBuildAttr(7, 'S', ARMBuildAttrs::CPU_arch_profile,
-                               ARMBuildAttrs::SystemProfile));
-}
-
-TEST(ARMISABuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(8, "Tag_ARM_ISA_use"));
-  EXPECT_TRUE(testBuildAttr(8, 0, ARMBuildAttrs::ARM_ISA_use,
-                               ARMBuildAttrs::Not_Allowed));
-  EXPECT_TRUE(testBuildAttr(8, 1, ARMBuildAttrs::ARM_ISA_use,
-                               ARMBuildAttrs::Allowed));
-}
-
-TEST(ThumbISABuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(9, "Tag_THUMB_ISA_use"));
-  EXPECT_TRUE(testBuildAttr(9, 0, ARMBuildAttrs::THUMB_ISA_use,
-                               ARMBuildAttrs::Not_Allowed));
-  EXPECT_TRUE(testBuildAttr(9, 1, ARMBuildAttrs::THUMB_ISA_use,
-                               ARMBuildAttrs::Allowed));
-}
-
-TEST(FPArchBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(10, "Tag_FP_arch"));
-  EXPECT_TRUE(testBuildAttr(10, 0, ARMBuildAttrs::FP_arch,
-                               ARMBuildAttrs::Not_Allowed));
-  EXPECT_TRUE(testBuildAttr(10, 1, ARMBuildAttrs::FP_arch,
-                               ARMBuildAttrs::Allowed));
-  EXPECT_TRUE(testBuildAttr(10, 2, ARMBuildAttrs::FP_arch,
-                               ARMBuildAttrs::AllowFPv2));
-  EXPECT_TRUE(testBuildAttr(10, 3, ARMBuildAttrs::FP_arch,
-                               ARMBuildAttrs::AllowFPv3A));
-  EXPECT_TRUE(testBuildAttr(10, 4, ARMBuildAttrs::FP_arch,
-                               ARMBuildAttrs::AllowFPv3B));
-  EXPECT_TRUE(testBuildAttr(10, 5, ARMBuildAttrs::FP_arch,
-                               ARMBuildAttrs::AllowFPv4A));
-  EXPECT_TRUE(testBuildAttr(10, 6, ARMBuildAttrs::FP_arch,
-                               ARMBuildAttrs::AllowFPv4B));
-  EXPECT_TRUE(testBuildAttr(10, 7, ARMBuildAttrs::FP_arch,
-                               ARMBuildAttrs::AllowFPARMv8A));
-  EXPECT_TRUE(testBuildAttr(10, 8, ARMBuildAttrs::FP_arch,
-                               ARMBuildAttrs::AllowFPARMv8B));
-}
-
-TEST(WMMXBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(11, "Tag_WMMX_arch"));
-  EXPECT_TRUE(testBuildAttr(11, 0, ARMBuildAttrs::WMMX_arch,
-                            ARMBuildAttrs::Not_Allowed));
-  EXPECT_TRUE(testBuildAttr(11, 1, ARMBuildAttrs::WMMX_arch,
-                            ARMBuildAttrs::AllowWMMXv1));
-  EXPECT_TRUE(testBuildAttr(11, 2, ARMBuildAttrs::WMMX_arch,
-                            ARMBuildAttrs::AllowWMMXv2));
-}
-
-TEST(SIMDBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(12, "Tag_Advanced_SIMD_arch"));
-  EXPECT_TRUE(testBuildAttr(12, 0, ARMBuildAttrs::Advanced_SIMD_arch,
-                            ARMBuildAttrs::Not_Allowed));
-  EXPECT_TRUE(testBuildAttr(12, 1, ARMBuildAttrs::Advanced_SIMD_arch,
-                            ARMBuildAttrs::AllowNeon));
-  EXPECT_TRUE(testBuildAttr(12, 2, ARMBuildAttrs::Advanced_SIMD_arch,
-                            ARMBuildAttrs::AllowNeon2));
-  EXPECT_TRUE(testBuildAttr(12, 3, ARMBuildAttrs::Advanced_SIMD_arch,
-                            ARMBuildAttrs::AllowNeonARMv8));
-  EXPECT_TRUE(testBuildAttr(12, 4, ARMBuildAttrs::Advanced_SIMD_arch,
-                            ARMBuildAttrs::AllowNeonARMv8_1a));
-}
-
-TEST(FPHPBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(36, "Tag_FP_HP_extension"));
-  EXPECT_TRUE(testBuildAttr(36, 0, ARMBuildAttrs::FP_HP_extension,
-                            ARMBuildAttrs::Not_Allowed));
-  EXPECT_TRUE(testBuildAttr(36, 1, ARMBuildAttrs::FP_HP_extension,
-                            ARMBuildAttrs::AllowHPFP));
-}
-
-TEST(CPUAlignBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(34, "Tag_CPU_unaligned_access"));
-  EXPECT_TRUE(testBuildAttr(34, 0, ARMBuildAttrs::CPU_unaligned_access,
-                            ARMBuildAttrs::Not_Allowed));
-  EXPECT_TRUE(testBuildAttr(34, 1, ARMBuildAttrs::CPU_unaligned_access,
-                            ARMBuildAttrs::Allowed));
-}
-
-TEST(T2EEBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(66, "Tag_T2EE_use"));
-  EXPECT_TRUE(testBuildAttr(66, 0, ARMBuildAttrs::T2EE_use,
-                            ARMBuildAttrs::Not_Allowed));
-  EXPECT_TRUE(testBuildAttr(66, 1, ARMBuildAttrs::T2EE_use,
-                            ARMBuildAttrs::Allowed));
-}
-
-TEST(VirtualizationBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(68, "Tag_Virtualization_use"));
-  EXPECT_TRUE(testBuildAttr(68, 0, ARMBuildAttrs::Virtualization_use,
-                            ARMBuildAttrs::Not_Allowed));
-  EXPECT_TRUE(testBuildAttr(68, 1, ARMBuildAttrs::Virtualization_use,
-                            ARMBuildAttrs::AllowTZ));
-  EXPECT_TRUE(testBuildAttr(68, 2, ARMBuildAttrs::Virtualization_use,
-                            ARMBuildAttrs::AllowVirtualization));
-  EXPECT_TRUE(testBuildAttr(68, 3, ARMBuildAttrs::Virtualization_use,
-                            ARMBuildAttrs::AllowTZVirtualization));
-}
-
-TEST(MPBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(42, "Tag_MPextension_use"));
-  EXPECT_TRUE(testBuildAttr(42, 0, ARMBuildAttrs::MPextension_use,
-                            ARMBuildAttrs::Not_Allowed));
-  EXPECT_TRUE(testBuildAttr(42, 1, ARMBuildAttrs::MPextension_use,
-                            ARMBuildAttrs::AllowMP));
-}
-
-TEST(DivBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(44, "Tag_DIV_use"));
-  EXPECT_TRUE(testBuildAttr(44, 0, ARMBuildAttrs::DIV_use,
-                            ARMBuildAttrs::AllowDIVIfExists));
-  EXPECT_TRUE(testBuildAttr(44, 1, ARMBuildAttrs::DIV_use,
-                            ARMBuildAttrs::DisallowDIV));
-  EXPECT_TRUE(testBuildAttr(44, 2, ARMBuildAttrs::DIV_use,
-                            ARMBuildAttrs::AllowDIVExt));
-}
-
-TEST(PCS_ConfigBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(13, "Tag_PCS_config"));
-  EXPECT_TRUE(testBuildAttr(13, 0, ARMBuildAttrs::PCS_config, 0));
-  EXPECT_TRUE(testBuildAttr(13, 1, ARMBuildAttrs::PCS_config, 1));
-  EXPECT_TRUE(testBuildAttr(13, 2, ARMBuildAttrs::PCS_config, 2));
-  EXPECT_TRUE(testBuildAttr(13, 3, ARMBuildAttrs::PCS_config, 3));
-  EXPECT_TRUE(testBuildAttr(13, 4, ARMBuildAttrs::PCS_config, 4));
-  EXPECT_TRUE(testBuildAttr(13, 5, ARMBuildAttrs::PCS_config, 5));
-  EXPECT_TRUE(testBuildAttr(13, 6, ARMBuildAttrs::PCS_config, 6));
-  EXPECT_TRUE(testBuildAttr(13, 7, ARMBuildAttrs::PCS_config, 7));
-}
-
-TEST(PCS_R9BuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(14, "Tag_ABI_PCS_R9_use"));
-  EXPECT_TRUE(testBuildAttr(14, 0, ARMBuildAttrs::ABI_PCS_R9_use,
-                            ARMBuildAttrs::R9IsGPR));
-  EXPECT_TRUE(testBuildAttr(14, 1, ARMBuildAttrs::ABI_PCS_R9_use,
-                            ARMBuildAttrs::R9IsSB));
-  EXPECT_TRUE(testBuildAttr(14, 2, ARMBuildAttrs::ABI_PCS_R9_use,
-                            ARMBuildAttrs::R9IsTLSPointer));
-  EXPECT_TRUE(testBuildAttr(14, 3, ARMBuildAttrs::ABI_PCS_R9_use,
-                            ARMBuildAttrs::R9Reserved));
-}
-
-TEST(PCS_RWBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(15, "Tag_ABI_PCS_RW_data"));
-  EXPECT_TRUE(testBuildAttr(15, 0, ARMBuildAttrs::ABI_PCS_RW_data,
-                            ARMBuildAttrs::Not_Allowed));
-  EXPECT_TRUE(testBuildAttr(15, 1, ARMBuildAttrs::ABI_PCS_RW_data,
-                            ARMBuildAttrs::AddressRWPCRel));
-  EXPECT_TRUE(testBuildAttr(15, 2, ARMBuildAttrs::ABI_PCS_RW_data,
-                            ARMBuildAttrs::AddressRWSBRel));
-  EXPECT_TRUE(testBuildAttr(15, 3, ARMBuildAttrs::ABI_PCS_RW_data,
-                            ARMBuildAttrs::AddressRWNone));
-}
-
-TEST(PCS_ROBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(16, "Tag_ABI_PCS_RO_data"));
-  EXPECT_TRUE(testBuildAttr(16, 0, ARMBuildAttrs::ABI_PCS_RO_data,
-                            ARMBuildAttrs::Not_Allowed));
-  EXPECT_TRUE(testBuildAttr(16, 1, ARMBuildAttrs::ABI_PCS_RO_data,
-                            ARMBuildAttrs::AddressROPCRel));
-  EXPECT_TRUE(testBuildAttr(16, 2, ARMBuildAttrs::ABI_PCS_RO_data,
-                            ARMBuildAttrs::AddressRONone));
-}
-
-TEST(PCS_GOTBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(17, "Tag_ABI_PCS_GOT_use"));
-  EXPECT_TRUE(testBuildAttr(17, 0, ARMBuildAttrs::ABI_PCS_GOT_use,
-                            ARMBuildAttrs::Not_Allowed));
-  EXPECT_TRUE(testBuildAttr(17, 1, ARMBuildAttrs::ABI_PCS_GOT_use,
-                            ARMBuildAttrs::AddressDirect));
-  EXPECT_TRUE(testBuildAttr(17, 2, ARMBuildAttrs::ABI_PCS_GOT_use,
-                            ARMBuildAttrs::AddressGOT));
-}
-
-TEST(PCS_WCharBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(18, "Tag_ABI_PCS_wchar_t"));
-  EXPECT_TRUE(testBuildAttr(18, 0, ARMBuildAttrs::ABI_PCS_wchar_t,
-                            ARMBuildAttrs::WCharProhibited));
-  EXPECT_TRUE(testBuildAttr(18, 2, ARMBuildAttrs::ABI_PCS_wchar_t,
-                            ARMBuildAttrs::WCharWidth2Bytes));
-  EXPECT_TRUE(testBuildAttr(18, 4, ARMBuildAttrs::ABI_PCS_wchar_t,
-                            ARMBuildAttrs::WCharWidth4Bytes));
-}
-
-TEST(EnumSizeBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(26, "Tag_ABI_enum_size"));
-  EXPECT_TRUE(testBuildAttr(26, 0, ARMBuildAttrs::ABI_enum_size,
-                            ARMBuildAttrs::EnumProhibited));
-  EXPECT_TRUE(testBuildAttr(26, 1, ARMBuildAttrs::ABI_enum_size,
-                            ARMBuildAttrs::EnumSmallest));
-  EXPECT_TRUE(testBuildAttr(26, 2, ARMBuildAttrs::ABI_enum_size,
-                            ARMBuildAttrs::Enum32Bit));
-  EXPECT_TRUE(testBuildAttr(26, 3, ARMBuildAttrs::ABI_enum_size,
-                            ARMBuildAttrs::Enum32BitABI));
-}
-
-TEST(AlignNeededBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(24, "Tag_ABI_align_needed"));
-  EXPECT_TRUE(testBuildAttr(24, 0, ARMBuildAttrs::ABI_align_needed,
-                            ARMBuildAttrs::Not_Allowed));
-  EXPECT_TRUE(testBuildAttr(24, 1, ARMBuildAttrs::ABI_align_needed,
-                            ARMBuildAttrs::Align8Byte));
-  EXPECT_TRUE(testBuildAttr(24, 2, ARMBuildAttrs::ABI_align_needed,
-                            ARMBuildAttrs::Align4Byte));
-  EXPECT_TRUE(testBuildAttr(24, 3, ARMBuildAttrs::ABI_align_needed,
-                            ARMBuildAttrs::AlignReserved));
-}
-
-TEST(AlignPreservedBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(25, "Tag_ABI_align_preserved"));
-  EXPECT_TRUE(testBuildAttr(25, 0, ARMBuildAttrs::ABI_align_preserved,
-                            ARMBuildAttrs::AlignNotPreserved));
-  EXPECT_TRUE(testBuildAttr(25, 1, ARMBuildAttrs::ABI_align_preserved,
-                            ARMBuildAttrs::AlignPreserve8Byte));
-  EXPECT_TRUE(testBuildAttr(25, 2, ARMBuildAttrs::ABI_align_preserved,
-                            ARMBuildAttrs::AlignPreserveAll));
-  EXPECT_TRUE(testBuildAttr(25, 3, ARMBuildAttrs::ABI_align_preserved,
-                            ARMBuildAttrs::AlignReserved));
-}
-
-TEST(FPRoundingBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(19, "Tag_ABI_FP_rounding"));
-  EXPECT_TRUE(testBuildAttr(19, 0, ARMBuildAttrs::ABI_FP_rounding, 0));
-  EXPECT_TRUE(testBuildAttr(19, 1, ARMBuildAttrs::ABI_FP_rounding, 1));
-}
-
-TEST(FPDenormalBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(20, "Tag_ABI_FP_denormal"));
-  EXPECT_TRUE(testBuildAttr(20, 0, ARMBuildAttrs::ABI_FP_denormal,
-                            ARMBuildAttrs::PositiveZero));
-  EXPECT_TRUE(testBuildAttr(20, 1, ARMBuildAttrs::ABI_FP_denormal,
-                            ARMBuildAttrs::IEEEDenormals));
-  EXPECT_TRUE(testBuildAttr(20, 2, ARMBuildAttrs::ABI_FP_denormal,
-                            ARMBuildAttrs::PreserveFPSign));
-}
-
-TEST(FPExceptionsBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(21, "Tag_ABI_FP_exceptions"));
-  EXPECT_TRUE(testBuildAttr(21, 0, ARMBuildAttrs::ABI_FP_exceptions, 0));
-  EXPECT_TRUE(testBuildAttr(21, 1, ARMBuildAttrs::ABI_FP_exceptions, 1));
-}
-
-TEST(FPUserExceptionsBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(22, "Tag_ABI_FP_user_exceptions"));
-  EXPECT_TRUE(testBuildAttr(22, 0, ARMBuildAttrs::ABI_FP_user_exceptions, 0));
-  EXPECT_TRUE(testBuildAttr(22, 1, ARMBuildAttrs::ABI_FP_user_exceptions, 1));
-}
-
-TEST(FPNumberModelBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(23, "Tag_ABI_FP_number_model"));
-  EXPECT_TRUE(testBuildAttr(23, 0, ARMBuildAttrs::ABI_FP_number_model,
-                            ARMBuildAttrs::Not_Allowed));
-  EXPECT_TRUE(testBuildAttr(23, 1, ARMBuildAttrs::ABI_FP_number_model,
-                            ARMBuildAttrs::AllowIEEENormal));
-  EXPECT_TRUE(testBuildAttr(23, 2, ARMBuildAttrs::ABI_FP_number_model,
-                            ARMBuildAttrs::AllowRTABI));
-  EXPECT_TRUE(testBuildAttr(23, 3, ARMBuildAttrs::ABI_FP_number_model,
-                            ARMBuildAttrs::AllowIEEE754));
-}
-
-TEST(FP16BuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(38, "Tag_ABI_FP_16bit_format"));
-  EXPECT_TRUE(testBuildAttr(38, 0, ARMBuildAttrs::ABI_FP_16bit_format,
-                            ARMBuildAttrs::Not_Allowed));
-  EXPECT_TRUE(testBuildAttr(38, 1, ARMBuildAttrs::ABI_FP_16bit_format,
-                            ARMBuildAttrs::FP16FormatIEEE));
-  EXPECT_TRUE(testBuildAttr(38, 2, ARMBuildAttrs::ABI_FP_16bit_format,
-                            ARMBuildAttrs::FP16VFP3));
-}
-
-TEST(HardFPBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(27, "Tag_ABI_HardFP_use"));
-  EXPECT_TRUE(testBuildAttr(27, 0, ARMBuildAttrs::ABI_HardFP_use,
-                            ARMBuildAttrs::HardFPImplied));
-  EXPECT_TRUE(testBuildAttr(27, 1, ARMBuildAttrs::ABI_HardFP_use,
-                            ARMBuildAttrs::HardFPSinglePrecision));
-  EXPECT_TRUE(testBuildAttr(27, 2, ARMBuildAttrs::ABI_HardFP_use, 2));
-}
-
-TEST(VFPArgsBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(28, "Tag_ABI_VFP_args"));
-  EXPECT_TRUE(testBuildAttr(28, 0, ARMBuildAttrs::ABI_VFP_args,
-                            ARMBuildAttrs::BaseAAPCS));
-  EXPECT_TRUE(testBuildAttr(28, 1, ARMBuildAttrs::ABI_VFP_args,
-                            ARMBuildAttrs::HardFPAAPCS));
-  EXPECT_TRUE(testBuildAttr(28, 2, ARMBuildAttrs::ABI_VFP_args, 2));
-  EXPECT_TRUE(testBuildAttr(28, 3, ARMBuildAttrs::ABI_VFP_args, 3));
-}
-
-TEST(WMMXArgsBuildAttr, testBuildAttr) {
-  EXPECT_TRUE(testTagString(29, "Tag_ABI_WMMX_args"));
-  EXPECT_TRUE(testBuildAttr(29, 0, ARMBuildAttrs::ABI_WMMX_args, 0));
-  EXPECT_TRUE(testBuildAttr(29, 1, ARMBuildAttrs::ABI_WMMX_args, 1));
-  EXPECT_TRUE(testBuildAttr(29, 2, ARMBuildAttrs::ABI_WMMX_args, 2));
-}

llvm/trunk/unittests/Support/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_llvm_unittest(SupportTests
   AlignOfTest.cpp
   AllocatorTest.cpp
-  ARMAttributeParser.cpp
   ArrayRecyclerTest.cpp
   BlockFrequencyTest.cpp
   BranchProbabilityTest.cpp
   Casting.cpp
   Chrono.cpp
   CommandLineTest.cpp
   CompressionTest.cpp
   ConvertUTFTest.cpp