CIRABIClassifierX86_64.cpp

Go to the documentation of this file.

//===- CIRABIClassifierX86_64.cpp - x86_64 System V classification --------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file implements the x86_64 System V classifier, which classifies with
// the LLVM ABI Lowering Library's SysV x86_64 target.
//
//===----------------------------------------------------------------------===//
 
#include "CIRABIClassifier.h"
 
#include "clang/CIR/Dialect/IR/CIRDialect.h"
#include "clang/CIR/MissingFeatures.h"
#include "llvm/ADT/StringExtras.h"
 
#include <algorithm>
#include <array>
 
using namespace mlir;
using namespace mlir::abi;
using namespace cir;
 
/// The AVX level to classify \p func at: \p base, raised if the function's own
/// recorded feature list enables a wider vector.
static llvm::abi::X86AVXABILevel funcAvxLevel(cir::FuncOp func,
                                              llvm::abi::X86AVXABILevel base) {
  // Only a `target` attribute may raise the level.  A multiversioned function
  // carries a raised feature list too, and must stay at the module's level.
  assert(!cir::MissingFeatures::opFuncMultiVersioning());
 
  auto features = func->getAttrOfType<mlir::StringAttr>("cir.target-features");
  if (!features)
    return base;
  // A '-' entry disables the feature, so match a whole '+' entry rather than
  // searching for the name.  avx512f implies avx, so both entries are present:
  // return on the wider name so one pass suffices.
  bool avx = false;
  for (llvm::StringRef feature : llvm::split(features.getValue(), ',')) {
    if (!feature.consume_front("+"))
      continue;
    if (feature == "avx512f")
      return std::max(base, llvm::abi::X86AVXABILevel::AVX512);
    avx |= feature == "avx";
  }
  return avx ? std::max(base, llvm::abi::X86AVXABILevel::AVX) : base;
}
 
namespace {
 
class X86_64ABIClassifier final : public CIRABIClassifierCommon {
public:
  X86_64ABIClassifier(const mlir::DataLayout &dl, mlir::ModuleOp modOp,
                      const ABIClassifierOptions &options)
      : CIRABIClassifierCommon(dl, modOp), baseAvxLevel(options.x86AvxAbiLevel),
        allowsTargetAttrAvx(options.allowsX86TargetAttrAvx),
        abiCompat(options.x86AbiCompat) {}
 
  /// cir.va_arg is expanded into the SysV register-save-area / overflow-area
  /// sequence, which reads the fetched type's classification as an unnamed
  /// argument, as classic's X86_64ABIInfo::EmitVAArg does.
  mlir::FailureOr<ArgClassification>
  classifyVAArg(cir::VAArgOp vaArg) override {
    return classifyVarArgType(
        vaArg.getType(), getTargetInfo(vaArg->getParentOfType<cir::FuncOp>()),
        [&]() { return vaArg->emitOpError(); });
  }
 
protected:
  /// The AVX level starts at the module's and may be raised by
  /// \p featureSource's recorded target features.
  const llvm::abi::TargetInfo &
  getTargetInfo(cir::FuncOp featureSource) override;
 
private:
  /// One library classifier per AVX level, built on first use.  A
  /// per-function target attribute can raise the level above the module's.
  static constexpr unsigned numAvxLevels =
      static_cast<unsigned>(llvm::abi::X86AVXABILevel::Last) + 1;
  std::array<std::unique_ptr<llvm::abi::TargetInfo>, numAvxLevels> targets;
 
  llvm::abi::X86AVXABILevel baseAvxLevel;
  bool allowsTargetAttrAvx;
 
  /// The x86_64 flags whose value depends on the target and the requested ABI
  /// compatibility version.
  llvm::abi::X86ABICompatInfo abiCompat;
};
 
const llvm::abi::TargetInfo &
X86_64ABIClassifier::getTargetInfo(cir::FuncOp featureSource) {
  llvm::abi::X86AVXABILevel level = baseAvxLevel;
  assert(featureSource && "function required for getTargetInfo");
  if (allowsTargetAttrAvx)
    level = funcAvxLevel(featureSource, baseAvxLevel);
  assert(static_cast<unsigned>(level) < numAvxLevels &&
         "a new X86AVXABILevel must move X86AVXABILevel::Last");
  std::unique_ptr<llvm::abi::TargetInfo> &slot =
      targets[static_cast<unsigned>(level)];
  if (!slot)
    slot =
        llvm::abi::createX86_64TargetInfo(typeMapper.getTypeBuilder(), level,
                                          /*Has64BitPointers=*/true, abiCompat);
  return *slot;
}
 
} // namespace
 
std::unique_ptr<CIRABIClassifier>
cir::createX86_64ABIClassifier(const mlir::DataLayout &dl, mlir::ModuleOp modOp,
                               const ABIClassifierOptions &options) {
  return std::make_unique<X86_64ABIClassifier>(dl, modOp, options);
}