target.h

// This file if part of the llir-opt project.
// Licensing information can be found in the LICENSE file.
// (C) 2018 Nandor Licker. All rights reserved.
 
#pragma once
 
#include <llvm/ADT/Triple.h>
 
#include "core/type.h"
 
 
 
class X86Target;
class PPCTarget;
class AArch64Target;
class RISCVTarget;
 
 
 
class Target {
public:
  enum class Kind {
    X86,
    PPC,
    AARCH64,
    RISCV
  };
 
public:
  Target(
      Kind kind,
      const llvm::Triple &triple,
      const std::string &cpu,
      const std::string &tuneCPU,
      const std::string &fs,
      const std::string &abi,
      bool shared)
    : kind_(kind)
    , triple_(triple)
    , cpu_(cpu)
    , tuneCPU_(tuneCPU)
    , fs_(fs)
    , abi_(abi)
    , shared_(shared)
  {
  }
 
  template<typename T>
  T *As()
  {
    return T::kKind == kind_ ? static_cast<T *>(this) : nullptr;
  }
 
  template<typename T>
  const T *As() const
  {
    return T::kKind == kind_ ? static_cast<const T *>(this) : nullptr;
  }
 
  bool IsShared() const { return shared_; }
  const llvm::Triple &GetTriple() const { return triple_; }
  llvm::StringRef getCPU() const { return cpu_; }
  llvm::StringRef getTuneCPU() const { return tuneCPU_; }
  llvm::StringRef getFS() const { return fs_; }
  llvm::StringRef getABI() const { return abi_; }
 
  Type GetPointerType() const;
 
  Kind GetKind() const { return kind_; }
 
  virtual bool IsLittleEndian() const { return true; }
  virtual bool AllowsUnalignedStores() const { return false; }
 
protected:
  Kind kind_;
  llvm::Triple triple_;
  std::string cpu_;
  std::string tuneCPU_;
  std::string fs_;
  std::string abi_;
  bool shared_;
};