Add missing LLVM_ABI annotations (llvm#167718)

This patch updates various LLVM headers to properly add the `LLVM_ABI`
and `LLVM_ABI_FOR_TEST` annotations to build LLVM as a DLL on Windows.

This effort is tracked in llvm#109483.

Author: Steelskin

llvm/include/llvm/ADT/APFloat.h

@@ -1471,7 +1471,7 @@ class APFloat : public APFloatBase {
 
   /// If this value is normal and has an exact, normal, multiplicative inverse,
   /// store it in inv and return true.
-  bool getExactInverse(APFloat *Inv) const;
+  LLVM_ABI bool getExactInverse(APFloat *Inv) const;
 
   // If this is an exact power of two, return the exponent while ignoring the
   // sign bit. If it's not an exact power of 2, return INT_MIN

llvm/include/llvm/Analysis/IR2Vec.h

@@ -164,7 +164,7 @@ class VocabStorage {
   VocabStorage() = default;
 
   /// Create a VocabStorage with pre-organized section data
-  VocabStorage(std::vector<std::vector<Embedding>> &&SectionData);
+  LLVM_ABI VocabStorage(std::vector<std::vector<Embedding>> &&SectionData);
 
   VocabStorage(VocabStorage &&) = default;
   VocabStorage &operator=(VocabStorage &&) = default;

llvm/include/llvm/AsmParser/AsmParserContext.h

@@ -34,9 +34,12 @@ class AsmParserContext {
   DenseMap<Instruction *, FileLocRange> Instructions;
 
 public:
-  std::optional<FileLocRange> getFunctionLocation(const Function *) const;
-  std::optional<FileLocRange> getBlockLocation(const BasicBlock *) const;
-  std::optional<FileLocRange> getInstructionLocation(const Instruction *) const;
+  LLVM_ABI std::optional<FileLocRange>
+  getFunctionLocation(const Function *) const;
+  LLVM_ABI std::optional<FileLocRange>
+  getBlockLocation(const BasicBlock *) const;
+  LLVM_ABI std::optional<FileLocRange>
+  getInstructionLocation(const Instruction *) const;
   /// Get the function at the requested location range.
   /// If no single function occupies the queried range, or the record is
   /// missing, a nullptr is returned.

llvm/include/llvm/BinaryFormat/DXContainer.h

@@ -201,7 +201,7 @@ enum class RootParameterType : uint32_t {
 
 LLVM_ABI ArrayRef<EnumEntry<RootParameterType>> getRootParameterTypes();
 
-bool isValidParameterType(uint32_t V);
+LLVM_ABI_FOR_TEST bool isValidParameterType(uint32_t V);
 
 bool isValidRangeType(uint32_t V);
 

llvm/include/llvm/CAS/ActionCache.h

@@ -34,7 +34,7 @@ class CacheKey {
   StringRef getKey() const { return Key; }
 
   CacheKey(const CASID &ID);
-  CacheKey(const ObjectProxy &Proxy);
+  LLVM_ABI_FOR_TEST CacheKey(const ObjectProxy &Proxy);
   CacheKey(const ObjectStore &CAS, const ObjectRef &Ref);
 
 private:
@@ -98,10 +98,11 @@ class ActionCache {
 };
 
 /// Create an action cache in memory.
-std::unique_ptr<ActionCache> createInMemoryActionCache();
+LLVM_ABI std::unique_ptr<ActionCache> createInMemoryActionCache();
 
 /// Create an action cache on disk.
-Expected<std::unique_ptr<ActionCache>> createOnDiskActionCache(StringRef Path);
+LLVM_ABI Expected<std::unique_ptr<ActionCache>>
+createOnDiskActionCache(StringRef Path);
 
 } // end namespace llvm::cas
 

llvm/include/llvm/CAS/BuiltinUnifiedCASDatabases.h

@@ -18,6 +18,7 @@ class ObjectStore;
 
 /// Create on-disk \c ObjectStore and \c ActionCache instances based on
 /// \c ondisk::UnifiedOnDiskCache, with built-in hashing.
+LLVM_ABI
 Expected<std::pair<std::unique_ptr<ObjectStore>, std::unique_ptr<ActionCache>>>
 createOnDiskUnifiedCASDatabases(StringRef Path);
 

llvm/include/llvm/CAS/CASID.h

@@ -70,7 +70,7 @@ class CASID {
   }
 
   /// Return a printable string for CASID.
-  std::string toString() const;
+  LLVM_ABI std::string toString() const;
 
   ArrayRef<uint8_t> getHash() const {
     return arrayRefFromStringRef<uint8_t>(Hash);

llvm/include/llvm/CAS/MappedFileRegionArena.h

@@ -61,7 +61,7 @@ class MappedFileRegionArena {
   /// that information can be stored before the header, like a file magic.
   /// \param NewFileConstructor is for constructing new files. It has exclusive
   /// access to the file. Must call \c initializeBumpPtr.
-  static Expected<MappedFileRegionArena>
+  LLVM_ABI_FOR_TEST static Expected<MappedFileRegionArena>
   create(const Twine &Path, uint64_t Capacity, uint64_t HeaderOffset,
          function_ref<Error(MappedFileRegionArena &)> NewFileConstructor);
 
@@ -81,7 +81,7 @@ class MappedFileRegionArena {
     return data() + *Offset;
   }
   /// Allocate, returning the offset from \a data() instead of a pointer.
-  Expected<int64_t> allocateOffset(uint64_t AllocSize);
+  LLVM_ABI_FOR_TEST Expected<int64_t> allocateOffset(uint64_t AllocSize);
 
   char *data() const { return Region.data(); }
   uint64_t size() const { return H->BumpPtr; }
@@ -106,7 +106,7 @@ class MappedFileRegionArena {
   // initialize header from offset.
   void initializeHeader(uint64_t HeaderOffset);
 
-  void destroyImpl();
+  LLVM_ABI_FOR_TEST void destroyImpl();
   void moveImpl(MappedFileRegionArena &RHS) {
     std::swap(Region, RHS.Region);
     std::swap(H, RHS.H);

llvm/include/llvm/CAS/ObjectStore.h

@@ -179,7 +179,8 @@ class ObjectStore {
 
 public:
   /// Helper functions to store object and returns a ObjectProxy.
-  Expected<ObjectProxy> createProxy(ArrayRef<ObjectRef> Refs, StringRef Data);
+  LLVM_ABI_FOR_TEST Expected<ObjectProxy> createProxy(ArrayRef<ObjectRef> Refs,
+                                                      StringRef Data);
 
   /// Store object from StringRef.
   Expected<ObjectRef> storeFromString(ArrayRef<ObjectRef> Refs,
@@ -205,10 +206,10 @@ class ObjectStore {
   static Error createUnknownObjectError(const CASID &ID);
 
   /// Create ObjectProxy from CASID. If the object doesn't exist, get an error.
-  Expected<ObjectProxy> getProxy(const CASID &ID);
+  LLVM_ABI Expected<ObjectProxy> getProxy(const CASID &ID);
   /// Create ObjectProxy from ObjectRef. If the object can't be loaded, get an
   /// error.
-  Expected<ObjectProxy> getProxy(ObjectRef Ref);
+  LLVM_ABI Expected<ObjectProxy> getProxy(ObjectRef Ref);
 
   /// \returns \c std::nullopt if the object is missing from the CAS.
   Expected<std::optional<ObjectProxy>> getProxyIfExists(ObjectRef Ref);
@@ -329,13 +330,14 @@ class ObjectProxy {
 };
 
 /// Create an in memory CAS.
-std::unique_ptr<ObjectStore> createInMemoryCAS();
+LLVM_ABI std::unique_ptr<ObjectStore> createInMemoryCAS();
 
 /// \returns true if \c LLVM_ENABLE_ONDISK_CAS configuration was enabled.
 bool isOnDiskCASEnabled();
 
 /// Create a persistent on-disk path at \p Path.
-Expected<std::unique_ptr<ObjectStore>> createOnDiskCAS(const Twine &Path);
+LLVM_ABI Expected<std::unique_ptr<ObjectStore>>
+createOnDiskCAS(const Twine &Path);
 
 } // namespace cas
 } // namespace llvm

llvm/include/llvm/CAS/OnDiskDataAllocator.h

@@ -57,32 +57,33 @@ class OnDiskDataAllocator {
   /// Get the data of \p Size stored at the given \p Offset. Note the allocator
   /// doesn't keep track of the allocation size, thus \p Size doesn't need to
   /// match the size of allocation but needs to be smaller.
-  Expected<ArrayRef<char>> get(FileOffset Offset, size_t Size) const;
+  LLVM_ABI_FOR_TEST Expected<ArrayRef<char>> get(FileOffset Offset,
+                                                 size_t Size) const;
 
   /// Allocate at least \p Size with 8-byte alignment.
-  Expected<OnDiskPtr> allocate(size_t Size);
+  LLVM_ABI_FOR_TEST Expected<OnDiskPtr> allocate(size_t Size);
 
   /// \returns the buffer that was allocated at \p create time, with size
   /// \p UserHeaderSize.
   MutableArrayRef<uint8_t> getUserHeader() const;
 
-  size_t size() const;
-  size_t capacity() const;
+  LLVM_ABI_FOR_TEST size_t size() const;
+  LLVM_ABI_FOR_TEST size_t capacity() const;
 
-  static Expected<OnDiskDataAllocator>
+  LLVM_ABI_FOR_TEST static Expected<OnDiskDataAllocator>
   create(const Twine &Path, const Twine &TableName, uint64_t MaxFileSize,
          std::optional<uint64_t> NewFileInitialSize,
          uint32_t UserHeaderSize = 0,
          function_ref<void(void *)> UserHeaderInit = nullptr);
 
-  OnDiskDataAllocator(OnDiskDataAllocator &&RHS);
-  OnDiskDataAllocator &operator=(OnDiskDataAllocator &&RHS);
+  LLVM_ABI_FOR_TEST OnDiskDataAllocator(OnDiskDataAllocator &&RHS);
+  LLVM_ABI_FOR_TEST OnDiskDataAllocator &operator=(OnDiskDataAllocator &&RHS);
 
   // No copy. Just call \a create() again.
   OnDiskDataAllocator(const OnDiskDataAllocator &) = delete;
   OnDiskDataAllocator &operator=(const OnDiskDataAllocator &) = delete;
 
-  ~OnDiskDataAllocator();
+  LLVM_ABI_FOR_TEST ~OnDiskDataAllocator();
 
 private:
   struct ImplType;