Fix many -Wsign-compare and -Wtautological-constant-compare warnings in clang-cl.

[zturner]

Summary

The latter class of warnings triggers on x86 builds where size_t is 4 bytes, so x > numeric_limits<unsigned>::max() is always false. The former class of warnings mostly involves comparing enums to unsigned values, since enums are signed by default in the MSVC ABI.

[rnk]

lgtm

clang/lib/CodeGen/CGExpr.cpp

 
 void CodeGenFunction::EmitCheck(
     ArrayRef<std::pair<llvm::Value *, SanitizerMask>> Checked,
     SanitizerHandler CheckHandler, ArrayRef<llvm::Constant *> StaticArgs,
     ArrayRef<llvm::Value *> DynamicArgs) {
   assert(IsSanitizerScope);
   assert(Checked.size() > 0);
   assert(CheckHandler >= 0 &&
-         CheckHandler < sizeof(SanitizerHandlers) / sizeof(*SanitizerHandlers));
+         size_t(CheckHandler) < llvm::array_lengthof(SanitizerHandlers));
   const StringRef CheckName = SanitizerHandlers[CheckHandler].Name;
 
   llvm::Value *FatalCond = nullptr;
   llvm::Value *RecoverableCond = nullptr;
   llvm::Value *TrapCond = nullptr;
   for (int i = 0, n = Checked.size(); i < n; ++i) {
     llvm::Value *Check = Checked[i].first;
     // -fsanitize-trap= overrides -fsanitize-recover=.

llvm/include/llvm/BinaryFormat/COFF.h

struct BigObjHeader {
   uint32_t unused2;
   uint32_t unused3;
   uint32_t unused4;
   uint32_t NumberOfSections;
   uint32_t PointerToSymbolTable;
   uint32_t NumberOfSymbols;
 };
 
-enum MachineTypes {
+enum MachineTypes : unsigned {
   MT_Invalid = 0xffff,
 
   IMAGE_FILE_MACHINE_UNKNOWN = 0x0,
   IMAGE_FILE_MACHINE_AM33 = 0x13,
   IMAGE_FILE_MACHINE_AMD64 = 0x8664,
   IMAGE_FILE_MACHINE_ARM = 0x1C0,
   IMAGE_FILE_MACHINE_ARMNT = 0x1C4,
   IMAGE_FILE_MACHINE_ARM64 = 0xAA64,
enum MachineTypes : unsigned {
   IMAGE_FILE_MACHINE_SH3 = 0x1A2,
   IMAGE_FILE_MACHINE_SH3DSP = 0x1A3,
   IMAGE_FILE_MACHINE_SH4 = 0x1A6,
   IMAGE_FILE_MACHINE_SH5 = 0x1A8,
   IMAGE_FILE_MACHINE_THUMB = 0x1C2,
   IMAGE_FILE_MACHINE_WCEMIPSV2 = 0x169
 };
 
-enum Characteristics {
+enum Characteristics : unsigned {
   C_Invalid = 0,
 
   /// The file does not contain base relocations and must be loaded at its
   /// preferred base. If this cannot be done, the loader will error.
   IMAGE_FILE_RELOCS_STRIPPED = 0x0001,
   /// The file is valid and can be run.
   IMAGE_FILE_EXECUTABLE_IMAGE = 0x0002,
   /// COFF line numbers have been stripped. This is deprecated and should be
enum Characteristics : unsigned {
   IMAGE_FILE_DLL = 0x2000,
   /// This file should only be run on a uniprocessor machine.
   IMAGE_FILE_UP_SYSTEM_ONLY = 0x4000,
   /// Big endian: the MSB precedes the LSB in memory. This is deprecated
   /// and should be 0.
   IMAGE_FILE_BYTES_REVERSED_HI = 0x8000
 };
 
-enum ResourceTypeID {
+enum ResourceTypeID : unsigned {
   RID_Cursor = 1,
   RID_Bitmap = 2,
   RID_Icon = 3,
   RID_Menu = 4,
   RID_Dialog = 5,
   RID_String = 6,
   RID_FontDir = 7,
   RID_Font = 8,
enum SymbolStorageClass {
   IMAGE_SYM_CLASS_FILE = 103,          ///< File name
   /// Line number, reformatted as symbol
   IMAGE_SYM_CLASS_SECTION = 104,
   IMAGE_SYM_CLASS_WEAK_EXTERNAL = 105, ///< Duplicate tag
   /// External symbol in dmert public lib
   IMAGE_SYM_CLASS_CLR_TOKEN = 107
 };
 
-enum SymbolBaseType {
+enum SymbolBaseType : unsigned {
   IMAGE_SYM_TYPE_NULL = 0,   ///< No type information or unknown base type.
   IMAGE_SYM_TYPE_VOID = 1,   ///< Used with void pointers and functions.
   IMAGE_SYM_TYPE_CHAR = 2,   ///< A character (signed byte).
   IMAGE_SYM_TYPE_SHORT = 3,  ///< A 2-byte signed integer.
   IMAGE_SYM_TYPE_INT = 4,    ///< A natural integer type on the target.
   IMAGE_SYM_TYPE_LONG = 5,   ///< A 4-byte signed integer.
   IMAGE_SYM_TYPE_FLOAT = 6,  ///< A 4-byte floating-point number.
   IMAGE_SYM_TYPE_DOUBLE = 7, ///< An 8-byte floating-point number.
   IMAGE_SYM_TYPE_STRUCT = 8, ///< A structure.
   IMAGE_SYM_TYPE_UNION = 9,  ///< An union.
   IMAGE_SYM_TYPE_ENUM = 10,  ///< An enumerated type.
   IMAGE_SYM_TYPE_MOE = 11,   ///< A member of enumeration (a specific value).
   IMAGE_SYM_TYPE_BYTE = 12,  ///< A byte; unsigned 1-byte integer.
   IMAGE_SYM_TYPE_WORD = 13,  ///< A word; unsigned 2-byte integer.
   IMAGE_SYM_TYPE_UINT = 14,  ///< An unsigned integer of natural size.
   IMAGE_SYM_TYPE_DWORD = 15  ///< An unsigned 4-byte integer.
 };
 
-enum SymbolComplexType {
+enum SymbolComplexType : unsigned {
   IMAGE_SYM_DTYPE_NULL = 0,     ///< No complex type; simple scalar variable.
   IMAGE_SYM_DTYPE_POINTER = 1,  ///< A pointer to base type.
   IMAGE_SYM_DTYPE_FUNCTION = 2, ///< A function that returns a base type.
   IMAGE_SYM_DTYPE_ARRAY = 3,    ///< An array of base type.
 
   /// Type is formed as (base + (derived << SCT_COMPLEX_TYPE_SHIFT))
   SCT_COMPLEX_TYPE_SHIFT = 4
 };

 };
 
 struct relocation {
   uint32_t VirtualAddress;
   uint32_t SymbolTableIndex;
   uint16_t Type;
 };
 
-enum RelocationTypeI386 {
+enum RelocationTypeI386 : unsigned {
   IMAGE_REL_I386_ABSOLUTE = 0x0000,
   IMAGE_REL_I386_DIR16 = 0x0001,
   IMAGE_REL_I386_REL16 = 0x0002,
   IMAGE_REL_I386_DIR32 = 0x0006,
   IMAGE_REL_I386_DIR32NB = 0x0007,
   IMAGE_REL_I386_SEG12 = 0x0009,
   IMAGE_REL_I386_SECTION = 0x000A,
   IMAGE_REL_I386_SECREL = 0x000B,
   IMAGE_REL_I386_TOKEN = 0x000C,
   IMAGE_REL_I386_SECREL7 = 0x000D,
   IMAGE_REL_I386_REL32 = 0x0014
 };
 
-enum RelocationTypeAMD64 {
+enum RelocationTypeAMD64 : unsigned {
   IMAGE_REL_AMD64_ABSOLUTE = 0x0000,
   IMAGE_REL_AMD64_ADDR64 = 0x0001,
   IMAGE_REL_AMD64_ADDR32 = 0x0002,
   IMAGE_REL_AMD64_ADDR32NB = 0x0003,
   IMAGE_REL_AMD64_REL32 = 0x0004,
   IMAGE_REL_AMD64_REL32_1 = 0x0005,
   IMAGE_REL_AMD64_REL32_2 = 0x0006,
   IMAGE_REL_AMD64_REL32_3 = 0x0007,
   IMAGE_REL_AMD64_REL32_4 = 0x0008,
   IMAGE_REL_AMD64_REL32_5 = 0x0009,
   IMAGE_REL_AMD64_SECTION = 0x000A,
   IMAGE_REL_AMD64_SECREL = 0x000B,
   IMAGE_REL_AMD64_SECREL7 = 0x000C,
   IMAGE_REL_AMD64_TOKEN = 0x000D,
   IMAGE_REL_AMD64_SREL32 = 0x000E,
   IMAGE_REL_AMD64_PAIR = 0x000F,
   IMAGE_REL_AMD64_SSPAN32 = 0x0010
 };
 
-enum RelocationTypesARM {
+enum RelocationTypesARM : unsigned {
   IMAGE_REL_ARM_ABSOLUTE = 0x0000,
   IMAGE_REL_ARM_ADDR32 = 0x0001,
   IMAGE_REL_ARM_ADDR32NB = 0x0002,
   IMAGE_REL_ARM_BRANCH24 = 0x0003,
   IMAGE_REL_ARM_BRANCH11 = 0x0004,
   IMAGE_REL_ARM_TOKEN = 0x0005,
   IMAGE_REL_ARM_BLX24 = 0x0008,
   IMAGE_REL_ARM_BLX11 = 0x0009,
   IMAGE_REL_ARM_SECTION = 0x000E,
   IMAGE_REL_ARM_SECREL = 0x000F,
   IMAGE_REL_ARM_MOV32A = 0x0010,
   IMAGE_REL_ARM_MOV32T = 0x0011,
   IMAGE_REL_ARM_BRANCH20T = 0x0012,
   IMAGE_REL_ARM_BRANCH24T = 0x0014,
   IMAGE_REL_ARM_BLX23T = 0x0015
 };
 
-enum RelocationTypesARM64 {
+enum RelocationTypesARM64 : unsigned {
   IMAGE_REL_ARM64_ABSOLUTE = 0x0000,
   IMAGE_REL_ARM64_ADDR32 = 0x0001,
   IMAGE_REL_ARM64_ADDR32NB = 0x0002,
   IMAGE_REL_ARM64_BRANCH26 = 0x0003,
   IMAGE_REL_ARM64_PAGEBASE_REL21 = 0x0004,
   IMAGE_REL_ARM64_REL21 = 0x0005,
   IMAGE_REL_ARM64_PAGEOFFSET_12A = 0x0006,
   IMAGE_REL_ARM64_PAGEOFFSET_12L = 0x0007,
   IMAGE_REL_ARM64_SECREL = 0x0008,
   IMAGE_REL_ARM64_SECREL_LOW12A = 0x0009,
   IMAGE_REL_ARM64_SECREL_HIGH12A = 0x000A,
   IMAGE_REL_ARM64_SECREL_LOW12L = 0x000B,
   IMAGE_REL_ARM64_TOKEN = 0x000C,
   IMAGE_REL_ARM64_SECTION = 0x000D,
   IMAGE_REL_ARM64_ADDR64 = 0x000E,
   IMAGE_REL_ARM64_BRANCH19 = 0x000F,
   IMAGE_REL_ARM64_BRANCH14 = 0x0010,
 };
 
-enum COMDATType {
+enum COMDATType : unsigned {
   IMAGE_COMDAT_SELECT_NODUPLICATES = 1,
   IMAGE_COMDAT_SELECT_ANY,
   IMAGE_COMDAT_SELECT_SAME_SIZE,
   IMAGE_COMDAT_SELECT_EXACT_MATCH,
   IMAGE_COMDAT_SELECT_ASSOCIATIVE,
   IMAGE_COMDAT_SELECT_LARGEST,
   IMAGE_COMDAT_SELECT_NEWEST
 };

 };
 
 struct AuxiliaryWeakExternal {
   uint32_t TagIndex;
   uint32_t Characteristics;
   uint8_t unused[10];
 };
 
-enum WeakExternalCharacteristics {
+enum WeakExternalCharacteristics : unsigned {
   IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY = 1,
   IMAGE_WEAK_EXTERN_SEARCH_LIBRARY = 2,
   IMAGE_WEAK_EXTERN_SEARCH_ALIAS = 3
 };
 
 struct AuxiliarySectionDefinition {
   uint32_t Length;
   uint16_t NumberOfRelocations;
struct PE32Header {
   uint32_t NumberOfRvaAndSize;
 };
 
 struct DataDirectory {
   uint32_t RelativeVirtualAddress;
   uint32_t Size;
 };
 
-enum DataDirectoryIndex {
+enum DataDirectoryIndex : unsigned {
   EXPORT_TABLE = 0,
   IMPORT_TABLE,
   RESOURCE_TABLE,
   EXCEPTION_TABLE,
   CERTIFICATE_TABLE,
   BASE_RELOCATION_TABLE,
   DEBUG_DIRECTORY,
   ARCHITECTURE,
   GLOBAL_PTR,
   TLS_TABLE,
   LOAD_CONFIG_TABLE,
   BOUND_IMPORT,
   IAT,
   DELAY_IMPORT_DESCRIPTOR,
   CLR_RUNTIME_HEADER,
 
   NUM_DATA_DIRECTORIES
 };
 
-enum WindowsSubsystem {
+enum WindowsSubsystem : unsigned {
   IMAGE_SUBSYSTEM_UNKNOWN = 0, ///< An unknown subsystem.
   IMAGE_SUBSYSTEM_NATIVE = 1,  ///< Device drivers and native Windows processes
   IMAGE_SUBSYSTEM_WINDOWS_GUI = 2,      ///< The Windows GUI subsystem.
   IMAGE_SUBSYSTEM_WINDOWS_CUI = 3,      ///< The Windows character subsystem.
   IMAGE_SUBSYSTEM_OS2_CUI = 5,          ///< The OS/2 character subsytem.
   IMAGE_SUBSYSTEM_POSIX_CUI = 7,        ///< The POSIX character subsystem.
   IMAGE_SUBSYSTEM_NATIVE_WINDOWS = 8,   ///< Native Windows 9x driver.
   IMAGE_SUBSYSTEM_WINDOWS_CE_GUI = 9,   ///< Windows CE.
   IMAGE_SUBSYSTEM_EFI_APPLICATION = 10, ///< An EFI application.
   IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER = 11, ///< An EFI driver with boot
                                                 ///  services.
   IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER = 12,      ///< An EFI driver with run-time
                                                 ///  services.
   IMAGE_SUBSYSTEM_EFI_ROM = 13,                 ///< An EFI ROM image.
   IMAGE_SUBSYSTEM_XBOX = 14,                    ///< XBOX.
   IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION = 16 ///< A BCD application.
 };
 
-enum DLLCharacteristics {
+enum DLLCharacteristics : unsigned {
   /// ASLR with 64 bit address space.
   IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA = 0x0020,
   /// DLL can be relocated at load time.
   IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE = 0x0040,
   /// Code integrity checks are enforced.
   IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY = 0x0080,
   ///< Image is NX compatible.
   IMAGE_DLL_CHARACTERISTICS_NX_COMPAT = 0x0100,
enum DLLCharacteristics : unsigned {
   ///< A WDM driver.
   IMAGE_DLL_CHARACTERISTICS_WDM_DRIVER = 0x2000,
   ///< Image supports Control Flow Guard.
   IMAGE_DLL_CHARACTERISTICS_GUARD_CF = 0x4000,
   /// Terminal Server aware.
   IMAGE_DLL_CHARACTERISTICS_TERMINAL_SERVER_AWARE = 0x8000
 };
 
-enum DebugType {
+enum DebugType : unsigned {
   IMAGE_DEBUG_TYPE_UNKNOWN = 0,
   IMAGE_DEBUG_TYPE_COFF = 1,
   IMAGE_DEBUG_TYPE_CODEVIEW = 2,
   IMAGE_DEBUG_TYPE_FPO = 3,
   IMAGE_DEBUG_TYPE_MISC = 4,
   IMAGE_DEBUG_TYPE_EXCEPTION = 5,
   IMAGE_DEBUG_TYPE_FIXUP = 6,
   IMAGE_DEBUG_TYPE_OMAP_TO_SRC = 7,
   IMAGE_DEBUG_TYPE_OMAP_FROM_SRC = 8,
   IMAGE_DEBUG_TYPE_BORLAND = 9,
   IMAGE_DEBUG_TYPE_RESERVED10 = 10,
   IMAGE_DEBUG_TYPE_CLSID = 11,
   IMAGE_DEBUG_TYPE_VC_FEATURE = 12,
   IMAGE_DEBUG_TYPE_POGO = 13,
   IMAGE_DEBUG_TYPE_ILTCG = 14,
   IMAGE_DEBUG_TYPE_MPX = 15,
   IMAGE_DEBUG_TYPE_REPRO = 16,
 };
 
-enum BaseRelocationType {
+enum BaseRelocationType : unsigned {
   IMAGE_REL_BASED_ABSOLUTE = 0,
   IMAGE_REL_BASED_HIGH = 1,
   IMAGE_REL_BASED_LOW = 2,
   IMAGE_REL_BASED_HIGHLOW = 3,
   IMAGE_REL_BASED_HIGHADJ = 4,
   IMAGE_REL_BASED_MIPS_JMPADDR = 5,
   IMAGE_REL_BASED_ARM_MOV32A = 5,
   IMAGE_REL_BASED_ARM_MOV32T = 7,
   IMAGE_REL_BASED_MIPS_JMPADDR16 = 9,
   IMAGE_REL_BASED_DIR64 = 10
 };
 
-enum ImportType { IMPORT_CODE = 0, IMPORT_DATA = 1, IMPORT_CONST = 2 };
+enum ImportType : unsigned {
+  IMPORT_CODE = 0,
+  IMPORT_DATA = 1,
+  IMPORT_CONST = 2
+};
 
-enum ImportNameType {
+enum ImportNameType : unsigned {
   /// Import is by ordinal. This indicates that the value in the Ordinal/Hint
   /// field of the import header is the import's ordinal. If this constant is
   /// not specified, then the Ordinal/Hint field should always be interpreted
   /// as the import's hint.
   IMPORT_ORDINAL = 0,
   /// The import name is identical to the public symbol name
   IMPORT_NAME = 1,
   /// The import name is the public symbol name, but skipping the leading ?,

llvm/include/llvm/Object/COFF.h

public:
   COFFSymbolRef getCOFFSymbol(const DataRefImpl &Ref) const;
   COFFSymbolRef getCOFFSymbol(const SymbolRef &Symbol) const;
   const coff_relocation *getCOFFRelocation(const RelocationRef &Reloc) const;
   unsigned getSectionID(SectionRef Sec) const;
   unsigned getSymbolSectionID(SymbolRef Sym) const;
 
   uint8_t getBytesInAddress() const override;
   StringRef getFileFormatName() const override;
-  unsigned getArch() const override;
+  Triple::ArchType getArch() const override;
   SubtargetFeatures getFeatures() const override { return SubtargetFeatures(); }
 
   import_directory_iterator import_directory_begin() const;
   import_directory_iterator import_directory_end() const;
   delay_import_directory_iterator delay_import_directory_begin() const;
   delay_import_directory_iterator delay_import_directory_end() const;
   export_directory_iterator export_directory_begin() const;
   export_directory_iterator export_directory_end() const;

llvm/include/llvm/Object/ELFObjectFile.h

public:
 
   section_iterator section_begin() const override;
   section_iterator section_end() const override;
 
   Expected<int64_t> getRelocationAddend(DataRefImpl Rel) const override;
 
   uint8_t getBytesInAddress() const override;
   StringRef getFileFormatName() const override;
-  unsigned getArch() const override;
+  Triple::ArchType 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();
default:
       return "ELF64-unknown";
     }
   default:
     // FIXME: Proper error handling.
     report_fatal_error("Invalid ELFCLASS!");
   }
 }
 
-template <class ELFT>
-unsigned ELFObjectFile<ELFT>::getArch() const {
+template <class ELFT> Triple::ArchType ELFObjectFile<ELFT>::getArch() const {
   bool IsLittleEndian = ELFT::TargetEndianness == support::little;
   switch (EF.getHeader()->e_machine) {
   case ELF::EM_386:
   case ELF::EM_IAMCU:
     return Triple::x86;
   case ELF::EM_X86_64:
     return Triple::x86_64;
   case ELF::EM_AARCH64:

llvm/include/llvm/Object/MachO.h

public:
   uint64_t getSymbolIndex(DataRefImpl Symb) const;
 
   section_iterator section_begin() const override;
   section_iterator section_end() const override;
 
   uint8_t getBytesInAddress() const override;
 
   StringRef getFileFormatName() const override;
-  unsigned getArch() const override;
+  Triple::ArchType getArch() const override;
   SubtargetFeatures getFeatures() const override { return SubtargetFeatures(); }
   Triple getArchTriple(const char **McpuDefault = nullptr) const;
 
   relocation_iterator section_rel_begin(unsigned Index) const;
   relocation_iterator section_rel_end(unsigned Index) const;
 
   dice_iterator begin_dices() const;
   dice_iterator end_dices() const;

llvm/include/llvm/Object/ObjectFile.h

 // This file declares a file format independent ObjectFile class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OBJECT_OBJECTFILE_H
 #define LLVM_OBJECT_OBJECTFILE_H
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Triple.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/BinaryFormat/Magic.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Object/SymbolicFile.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Error.h"
section_iterator_range sections() const {
     return section_iterator_range(section_begin(), section_end());
   }
 
   /// @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 Triple::ArchType getArch() const = 0;
   virtual SubtargetFeatures getFeatures() const = 0;
   virtual void setARMSubArch(Triple &TheTriple) const { }
 
   /// @brief Create a triple from the data in this object file.
   Triple makeTriple() const;
 
   /// Returns platform-specific object flags, if any.
   virtual std::error_code getPlatformFlags(unsigned &Result) const {

llvm/include/llvm/Object/RelocVisitor.h

uint64_t visitCOFF(uint32_t Rel, RelocationRef R, uint64_t Value) {
     case Triple::x86_64:
       switch (Rel) {
       case COFF::IMAGE_REL_AMD64_SECREL:
         return static_cast<uint32_t>(Value);
       case COFF::IMAGE_REL_AMD64_ADDR64:
         return Value;
       }
       break;
+    default:
+      break;
     }
     HasError = true;
     return 0;
   }
 
   uint64_t visitMachO(uint32_t Rel, RelocationRef R, uint64_t Value) {
     if (ObjToVisit.getArch() == Triple::x86_64 &&
         Rel == MachO::X86_64_RELOC_UNSIGNED)

llvm/include/llvm/Object/Wasm.h

public:
   uint64_t getRelocationType(DataRefImpl Rel) const override;
   void getRelocationTypeName(DataRefImpl Rel,
                              SmallVectorImpl<char> &Result) const override;
 
   section_iterator section_begin() const override;
   section_iterator section_end() const override;
   uint8_t getBytesInAddress() const override;
   StringRef getFileFormatName() const override;
-  unsigned getArch() const override;
+  Triple::ArchType getArch() const override;
   SubtargetFeatures getFeatures() const override;
   bool isRelocatableObject() const override;
 
 private:
   const WasmSection &getWasmSection(DataRefImpl Ref) const;
   const wasm::WasmRelocation &getWasmRelocation(DataRefImpl Ref) const;
 
   WasmSection* findCustomSectionByName(StringRef Name);

llvm/lib/Analysis/InstructionSimplify.cpp

static Value *ThreadBinOpOverSelect(Instruction::BinaryOps Opcode, Value *LHS,
 
   // If one branch simplified and the other did not, and the simplified
   // value is equal to the unsimplified one, return the simplified value.
   // For example, select (cond, X, X & Z) & Z -> X & Z.
   if ((FV && !TV) || (TV && !FV)) {
     // Check that the simplified value has the form "X op Y" where "op" is the
     // same as the original operation.
     Instruction *Simplified = dyn_cast<Instruction>(FV ? FV : TV);
-    if (Simplified && Simplified->getOpcode() == Opcode) {
+    if (Simplified && Simplified->getOpcode() == unsigned(Opcode)) {
       // The value that didn't simplify is "UnsimplifiedLHS op UnsimplifiedRHS".
       // We already know that "op" is the same as for the simplified value.  See
       // if the operands match too.  If so, return the simplified value.
       Value *UnsimplifiedBranch = FV ? SI->getTrueValue() : SI->getFalseValue();
       Value *UnsimplifiedLHS = SI == LHS ? UnsimplifiedBranch : LHS;
       Value *UnsimplifiedRHS = SI == LHS ? RHS : UnsimplifiedBranch;
       if (Simplified->getOperand(0) == UnsimplifiedLHS &&
           Simplified->getOperand(1) == UnsimplifiedRHS)

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

if (InvertCond) {
         BOpc = Instruction::Or;
       else if (BOpc == Instruction::Or)
         BOpc = Instruction::And;
     }
   }
 
   // If this node is not part of the or/and tree, emit it as a branch.
   if (!BOp || !(isa<BinaryOperator>(BOp) || isa<CmpInst>(BOp)) ||
-      BOpc != Opc || !BOp->hasOneUse() ||
+      BOpc != unsigned(Opc) || !BOp->hasOneUse() ||
       BOp->getParent() != CurBB->getBasicBlock() ||
       !InBlock(BOp->getOperand(0), CurBB->getBasicBlock()) ||
       !InBlock(BOp->getOperand(1), CurBB->getBasicBlock())) {
     EmitBranchForMergedCondition(Cond, TBB, FBB, CurBB, SwitchBB,
                                  TProb, FProb, InvertCond);
     return;
   }
 

llvm/lib/Object/COFFObjectFile.cpp

case COFF::IMAGE_FILE_MACHINE_ARMNT:
     return "COFF-ARM";
   case COFF::IMAGE_FILE_MACHINE_ARM64:
     return "COFF-ARM64";
   default:
     return "COFF-<unknown arch>";
   }
 }
 
-unsigned COFFObjectFile::getArch() const {
+Triple::ArchType COFFObjectFile::getArch() const {
   switch (getMachine()) {
   case COFF::IMAGE_FILE_MACHINE_I386:
     return Triple::x86;
   case COFF::IMAGE_FILE_MACHINE_AMD64:
     return Triple::x86_64;
   case COFF::IMAGE_FILE_MACHINE_ARMNT:
     return Triple::thumb;
   case COFF::IMAGE_FILE_MACHINE_ARM64:

llvm/lib/Object/MachOObjectFile.cpp

return StringSwitch<bool>(ArchFlag)
       .Case("armv7m", true)
       .Case("armv7s", true)
       .Case("arm64", true)
       .Case("ppc", true)
       .Case("ppc64", true)
       .Default(false);
 }
 
-unsigned MachOObjectFile::getArch() const {
+Triple::ArchType MachOObjectFile::getArch() const {
   return getArch(getCPUType(*this));
 }
 
 Triple MachOObjectFile::getArchTriple(const char **McpuDefault) const {
   return getArchTriple(Header.cputype, Header.cpusubtype, McpuDefault);
 }
 
 relocation_iterator MachOObjectFile::section_rel_begin(unsigned Index) const {

llvm/lib/Object/WasmObjectFile.cpp

section_iterator WasmObjectFile::section_end() const {
   Ref.d.a = Sections.size();
   return section_iterator(SectionRef(Ref, this));
 }
 
 uint8_t WasmObjectFile::getBytesInAddress() const { return 4; }
 
 StringRef WasmObjectFile::getFileFormatName() const { return "WASM"; }
 
-unsigned WasmObjectFile::getArch() const { return Triple::wasm32; }
+Triple::ArchType WasmObjectFile::getArch() const { return Triple::wasm32; }
 
 SubtargetFeatures WasmObjectFile::getFeatures() const {
   return SubtargetFeatures();
 }
 
 bool WasmObjectFile::isRelocatableObject() const {
   return HasLinkingSection;
 }

llvm/lib/ProfileData/InstrProfReader.cpp

InstrProfReader::create(const Twine &Path) {
   if (Error E = BufferOrError.takeError())
     return std::move(E);
   return InstrProfReader::create(std::move(BufferOrError.get()));
 }
 
 Expected<std::unique_ptr<InstrProfReader>>
 InstrProfReader::create(std::unique_ptr<MemoryBuffer> Buffer) {
   // Sanity check the buffer.
-  if (Buffer->getBufferSize() > std::numeric_limits<unsigned>::max())
+  if (uint64_t(Buffer->getBufferSize()) > std::numeric_limits<unsigned>::max())
     return make_error<InstrProfError>(instrprof_error::too_large);
 
   if (Buffer->getBufferSize() == 0)
     return make_error<InstrProfError>(instrprof_error::empty_raw_profile);
 
   std::unique_ptr<InstrProfReader> Result;
   // Create the reader.
   if (IndexedInstrProfReader::hasFormat(*Buffer))
IndexedInstrProfReader::create(const Twine &Path) {
   if (Error E = BufferOrError.takeError())
     return std::move(E);
   return IndexedInstrProfReader::create(std::move(BufferOrError.get()));
 }
 
 Expected<std::unique_ptr<IndexedInstrProfReader>>
 IndexedInstrProfReader::create(std::unique_ptr<MemoryBuffer> Buffer) {
   // Sanity check the buffer.
-  if (Buffer->getBufferSize() > std::numeric_limits<unsigned>::max())
+  if (uint64_t(Buffer->getBufferSize()) > std::numeric_limits<unsigned>::max())
     return make_error<InstrProfError>(instrprof_error::too_large);
 
   // Create the reader.
   if (!IndexedInstrProfReader::hasFormat(*Buffer))
     return make_error<InstrProfError>(instrprof_error::bad_magic);
   auto Result = llvm::make_unique<IndexedInstrProfReader>(std::move(Buffer));
 
   // Initialize the reader and return the result.

llvm/lib/ProfileData/SampleProfReader.cpp

 static ErrorOr<std::unique_ptr<MemoryBuffer>>
 setupMemoryBuffer(const Twine &Filename) {
   auto BufferOrErr = MemoryBuffer::getFileOrSTDIN(Filename);
   if (std::error_code EC = BufferOrErr.getError())
     return EC;
   auto Buffer = std::move(BufferOrErr.get());
 
   // Sanity check the file.
-  if (Buffer->getBufferSize() > std::numeric_limits<uint32_t>::max())
+  if (uint64_t(Buffer->getBufferSize()) > std::numeric_limits<uint32_t>::max())
     return sampleprof_error::too_large;
 
   return std::move(Buffer);
 }
 
 /// \brief Create a sample profile reader based on the format of the input file.
 ///
 /// \param Filename The file to open.

llvm/lib/Support/ARMAttributeParser.cpp

void ARMAttributeParser::ParseAttributeList(const uint8_t *Data,
   while (Offset < Length) {
     unsigned Length;
     uint64_t Tag = decodeULEB128(Data + Offset, &Length);
     Offset += Length;
 
     bool Handled = false;
     for (unsigned AHI = 0, AHE = array_lengthof(DisplayRoutines);
          AHI != AHE && !Handled; ++AHI) {
-      if (DisplayRoutines[AHI].Attribute == Tag) {
+      if (uint64_t(DisplayRoutines[AHI].Attribute) == Tag) {
         (this->*DisplayRoutines[AHI].Routine)(ARMBuildAttrs::AttrType(Tag),
                                               Data, Offset);
         Handled = true;
         break;
       }
     }
     if (!Handled) {
       if (Tag < 32) {

llvm/lib/Target/X86/X86ISelLowering.cpp

if ((Extract->getOpcode() != ISD::EXTRACT_VECTOR_ELT) ||
       !isNullConstant(Extract->getOperand(1)))
     return SDValue();
 
   SDValue Op = Extract->getOperand(0);
   unsigned Stages = Log2_32(Op.getValueType().getVectorNumElements());
 
   // Match against one of the candidate binary ops.
   if (llvm::none_of(CandidateBinOps, [Op](ISD::NodeType BinOp) {
-        return Op.getOpcode() == BinOp;
+        return Op.getOpcode() == unsigned(BinOp);
       }))
     return SDValue();
 
   // At each stage, we're looking for something that looks like:
   // %s = shufflevector <8 x i32> %op, <8 x i32> undef,
   //                    <8 x i32> <i32 2, i32 3, i32 undef, i32 undef,
   //                               i32 undef, i32 undef, i32 undef, i32 undef>
   // %a = binop <8 x i32> %op, %s