• remove lldb changes

• fix extra bytes when compressing for 32bit objcopy
• fix lldb compressed section zstd test File Size

Looks like my concerns about the enum coupling and none vs unsupported semantics are addressed, one nit though.
LGTM, however, @dblaikie may want to take a pass as well. (Though I think this should be fine with him, because even if the final state of compression api in llvm is more OO, this regardless moves it closer in that direction than the original api.)

• delete line

• change to LLVM_USE_STATIC_ZSTD (default FALSE)

• remove nit

• add LLVM_PREFER_STATIC_ZSTD (default TRUE)

• omit uneeded line

• shorten compression related variable names

@dblaikie I've handled most of your comments, can you take another look?

• CompressionImplementation member on Decompressor instead of Spec

• fix static initialization skip errors in getCompressionSpec

• small compression test cleanup

• remove Compression{Spec,Impl}Ref typedef

• remove CompressionSpecRefs::{Zlib,ZStd}

• remove extra includes of ADT/Optional

• compression: remove some usage sugar from

• move compression level members from spec to impl

• remove Supported member of CompressionSpec

In D130516#3703691, @dblaikie wrote:

This is looking pretty close to what I've been picturing - the only thing remaining is that I think we could get rid of CompressionKind and access the CompressionAlgorithm directly - basically the contents of CompressionKind::operator-> could be a free/public function const CompressionAlgorithm &getCompressionAlgorithm(enum class CompressionKind); - and have it return a reference to the local static implementation, with a none implementation (for those profile cases where you want to pass in an algorithm if it's available, or none) and one implementation for each of zlib/zstd?

• address review comments

• Merge remote-tracking branch 'origin/main' into ckissane.compression-class-simple

• fix InputSection decompress issue

• format error string

• remove OptionalCompressionKind noneIfUnsupported

• cleanup some compression nits

• move if into switch

• Merge remote-tracking branch 'origin/ckissane.compression-class-simple' into ckissane.compression-class
• remove erroneous declation of operator StringRef()

• Merge branch 'ckissane.compression-class' of github.com:ckissane/llvm-project into ckissane.compression-class
• Merge remote-tracking branch 'origin/ckissane.compression-class-simple' into ckissane.compression-class
• Merge remote-tracking branch 'origin/ckissane.compression-class-simple' into ckissane.compression-class
• Merge remote-tracking branch 'origin/ckissane.compression-class-simple' into ckissane.compression-class

• fix some nits in Compression.h

@dblaikie @MaskRay I would like it if you could all take another look.

• remove compression kind || && overload

• remove uppercase Compress, Decompress

compression api: greatly simplify implementation
+ cuts around 100 lines of code from compression.h and compression.cpp

In D130516#3694422, @dblaikie wrote:

The current code here still seems more complicated than I'd prefer - looks like currently the size/speed/default levels are currently unused, so maybe we can omit those for now, knowing they will be added?
And the CompressionKind with all its operator overloads seems like a lot of surface area that is pretty non-obvious for usage - boolean testable, logical operator overloads, etc.
Could we have only one decompress/compress function each, for now?
& maybe leave out the name/enum from the base class for now, add it in later (& I think I mentionted in another comment those properties can be non-virtual, maybe even direct const members - passed into the base through the ctor from the derived class)

@dblaikie, @MaskRay I think I have worked out something that is the best of both worlds:
none compression is represented simply as a none type for use cases that will use Optional<CompressionKind>.
once you have a CompressionKind itself you can pass it around as a value (because a CompressionKind is just a struct containing one uint8_t (a fake "enum")).
due to my operator overloading, you can do stuff like this:

llvm::compression::OptionalCompressionKind OptionalCompressionScheme =
          llvm::compression::getOptionalCompressionKind(CompressionSchemeId);
      if (!OptionalCompressionScheme) {
        return llvm::MemoryBuffer::getMemBuffer(Blob, Name, true);
      }
      llvm::compression::CompressionKind CompressionScheme =
          *OptionalCompressionScheme;
      if (!CompressionScheme) {
        Error("compression class " +
              (CompressionScheme->getName() + " is not available").str());
        return nullptr;
      }
      SmallVector<uint8_t, 0> Uncompressed;
      if (llvm::Error E = CompressionScheme->decompress(
              llvm::arrayRefFromStringRef(Blob), Uncompressed, Record[0])) {
        Error("could not decompress embedded file contents: " +
              llvm::toString(std::move(E)));
        return nullptr;
      }
      return llvm::MemoryBuffer::getMemBufferCopy(
          llvm::toStringRef(Uncompressed), Name);

(excerpt from ASTReader.cpp)

• CompressionKind: clean up param names to == op

• trim down compression api: remove supported()

• make a zlib corruption check specific

• feat compression "enum" with methods

• fix usage of CompressionAlgorithmFromId

• make compression singletons

marked outdated comments as done

• use CompressionScheme->notNone() in InstrProf