M68k.cpp

Go to the documentation of this file.

//===--- M68k.cpp - Implement M68k targets feature support-------------===//
//
// 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 M68k TargetInfo objects.
//
//===----------------------------------------------------------------------===//
 
#include "M68k.h"
#include "clang/Basic/Builtins.h"
#include "clang/Basic/Diagnostic.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/TargetParser/TargetParser.h"
#include <cstdint>
#include <cstring>
#include <limits>
#include <optional>
 
namespace clang {
namespace targets {
 
// Linux/m68k ("old") uses the ABI from Sun Microsystems a.out
// for m68k, and uses 16-bit alignments for int/long/pointers.
//
// NetBSD/m68k uses the ABI from SVR4 for m68k,
// which uses 32-bit alignments for int/long/pointers.
//
// Ref. https://github.com/M680x0/issues/issues/13 and
// https://github.com/llvm/llvm-project/issues/199826
//
// Arguably this ought to respect -malign-int, as suggested
// above, this code doesn't so far.
 
M68kTargetInfo::M68kTargetInfo(const llvm::Triple &Triple,
                               const TargetOptions &Opts)
    : TargetInfo(Triple), TargetOpts(Opts) {
  resetDataLayout();
 
  SizeType = UnsignedInt;
  PtrDiffType = SignedInt;
  IntPtrType = SignedInt;
  if (getTriple().isOSNetBSD()) {
    IntAlign = LongAlign = PointerAlign = 32;
  } else {
    IntAlign = LongAlign = PointerAlign = 16;
  }
}
 
bool M68kTargetInfo::setCPU(StringRef Name) {
  CPU = llvm::StringSwitch<CPUKind>(Name)
            .Case("generic", CK_68000)
            .Case("M68000", CK_68000)
            .Case("M68010", CK_68010)
            .Case("M68020", CK_68020)
            .Case("M68030", CK_68030)
            .Case("M68040", CK_68040)
            .Case("M68060", CK_68060)
            .Default(CK_Unknown);
  return CPU != CK_Unknown;
}
 
void M68kTargetInfo::getTargetDefines(const LangOptions &Opts,
                                      MacroBuilder &Builder) const {
  using llvm::Twine;
 
  Builder.defineMacro("__m68k__");
 
  DefineStd(Builder, "mc68000", Opts);
 
  // For sub-architecture
  switch (CPU) {
  case CK_68010:
    DefineStd(Builder, "mc68010", Opts);
    break;
  case CK_68020:
    DefineStd(Builder, "mc68020", Opts);
    break;
  case CK_68030:
    DefineStd(Builder, "mc68030", Opts);
    break;
  case CK_68040:
    DefineStd(Builder, "mc68040", Opts);
    break;
  case CK_68060:
    DefineStd(Builder, "mc68060", Opts);
    break;
  default:
    break;
  }
 
  if (CPU >= CK_68020) {
    Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
    Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
    Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
  }
 
  // Floating point
  if (TargetOpts.FeatureMap.lookup("isa-68881") ||
      TargetOpts.FeatureMap.lookup("isa-68882"))
    Builder.defineMacro("__HAVE_68881__");
}
 
llvm::SmallVector<Builtin::InfosShard>
M68kTargetInfo::getTargetBuiltins() const {
  // FIXME: Implement.
  return {};
}
 
bool M68kTargetInfo::hasFeature(StringRef Feature) const {
  // FIXME elaborate moar
  return Feature == "M68000";
}
 
const char *const M68kTargetInfo::GCCRegNames[] = {
    "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
    "a0", "a1", "a2", "a3", "a4", "a5", "a6", "sp",
    "pc"};
 
ArrayRef<const char *> M68kTargetInfo::getGCCRegNames() const {
  return llvm::ArrayRef(GCCRegNames);
}
 
const TargetInfo::GCCRegAlias M68kTargetInfo::GCCRegAliases[] = {
    {{"bp"}, "a5"},
    {{"fp"}, "a6"},
    {{"usp", "ssp", "isp", "a7"}, "sp"},
};
 
ArrayRef<TargetInfo::GCCRegAlias> M68kTargetInfo::getGCCRegAliases() const {
  return llvm::ArrayRef(GCCRegAliases);
}
 
bool M68kTargetInfo::validateAsmConstraint(
    const char *&Name, TargetInfo::ConstraintInfo &info) const {
  switch (*Name) {
  case 'a': // address register
  case 'd': // data register
    info.setAllowsRegister();
    return true;
  case 'I': // constant integer in the range [1,8]
    info.setRequiresImmediate(1, 8);
    return true;
  case 'J': // constant signed 16-bit integer
    info.setRequiresImmediate(std::numeric_limits<int16_t>::min(),
                              std::numeric_limits<int16_t>::max());
    return true;
  case 'K': // constant that is NOT in the range of [-0x80, 0x80)
    info.setRequiresImmediate();
    return true;
  case 'L': // constant integer in the range [-8,-1]
    info.setRequiresImmediate(-8, -1);
    return true;
  case 'M': // constant that is NOT in the range of [-0x100, 0x100]
    info.setRequiresImmediate();
    return true;
  case 'N': // constant integer in the range [24,31]
    info.setRequiresImmediate(24, 31);
    return true;
  case 'O': // constant integer 16
    info.setRequiresImmediate(16);
    return true;
  case 'P': // constant integer in the range [8,15]
    info.setRequiresImmediate(8, 15);
    return true;
  case 'C':
    ++Name;
    switch (*Name) {
    case '0': // constant integer 0
      info.setRequiresImmediate(0);
      return true;
    case 'i': // constant integer
    case 'j': // integer constant that doesn't fit in 16 bits
      info.setRequiresImmediate();
      return true;
    default:
      break;
    }
    break;
  case 'Q': // address register indirect addressing
  case 'U': // address register indirect w/ constant offset addressing
    // TODO: Handle 'S' (basically 'm' when pc-rel is enforced) when
    // '-mpcrel' flag is properly handled by the driver.
    info.setAllowsMemory();
    return true;
  default:
    break;
  }
  return false;
}
 
std::optional<std::string>
M68kTargetInfo::handleAsmEscapedChar(char EscChar) const {
  char C;
  switch (EscChar) {
  case '.':
  case '#':
    C = EscChar;
    break;
  case '/':
    C = '%';
    break;
  case '$':
    C = 's';
    break;
  case '&':
    C = 'd';
    break;
  default:
    return std::nullopt;
  }
 
  return std::string(1, C);
}
 
std::string M68kTargetInfo::convertConstraint(const char *&Constraint) const {
  if (*Constraint == 'C')
    // Two-character constraint; add "^" hint for later parsing
    return std::string("^") + std::string(Constraint++, 2);
 
  return std::string(1, *Constraint);
}
 
std::string_view M68kTargetInfo::getClobbers() const {
  // FIXME: Is this really right?
  return "";
}
 
TargetInfo::BuiltinVaListKind M68kTargetInfo::getBuiltinVaListKind() const {
  return TargetInfo::VoidPtrBuiltinVaList;
}
 
TargetInfo::CallingConvCheckResult
M68kTargetInfo::checkCallingConvention(CallingConv CC) const {
  switch (CC) {
  case CC_C:
  case CC_M68kRTD:
    return CCCR_OK;
  default:
    return TargetInfo::checkCallingConvention(CC);
  }
}
} // namespace targets
} // namespace clang