//===-- Address.h - An aligned address -------------------------*- C++ -*-===//

//

// 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 class provides a simple wrapper for a pair of a pointer and an

// alignment.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_CLANG_LIB_CODEGEN_ADDRESS_H

#define LLVM_CLANG_LIB_CODEGEN_ADDRESS_H

#include "clang/AST/CharUnits.h"

#include "llvm/ADT/PointerIntPair.h"

#include "llvm/IR/Constants.h"

#include "llvm/Support/MathExtras.h"

namespace clang {

namespace CodeGen {

// We try to save some space by using 6 bits over two PointerIntPairs to store

// the alignment. However, some arches don't support 3 bits in a PointerIntPair

// so we fallback to storing the alignment separately.

template <typename T, bool = alignof(llvm::Value *) >= 8> class AddressImpl {};

template <typename T> class AddressImpl<T, false> {

  llvm::Value *Pointer;

  llvm::Type *ElementType;

  CharUnits Alignment;

public:

  AddressImpl(llvm::Value *Pointer, llvm::Type *ElementType,

              CharUnits Alignment)

      : Pointer(Pointer), ElementType(ElementType), Alignment(Alignment) {}

  llvm::Value *getPointer() const { return Pointer; }

  llvm::Type *getElementType() const { return ElementType; }

  CharUnits getAlignment() const { return Alignment; }

};

template <typename T> class AddressImpl<T, true> {

  // Int portion stores upper 3 bits of the log of the alignment.

  llvm::PointerIntPair<llvm::Value *, 3, unsigned> Pointer;

  // Int portion stores lower 3 bits of the log of the alignment.

  llvm::PointerIntPair<llvm::Type *, 3, unsigned> ElementType;

public:

  AddressImpl(llvm::Value *Pointer, llvm::Type *ElementType,

              CharUnits Alignment)

      : Pointer(Pointer), ElementType(ElementType) {

    if (Alignment.isZero())

      return;

    // Currently the max supported alignment is much less than 1 << 63 and is

    // guaranteed to be a power of 2, so we can store the log of the alignment

    // into 6 bits.

    assert(Alignment.isPowerOfTwo() && "Alignment cannot be zero");

    auto AlignLog = llvm::Log2_64(Alignment.getQuantity());

    assert(AlignLog < (1 << 6) && "cannot fit alignment into 6 bits");

    this->Pointer.setInt(AlignLog >> 3);

    this->ElementType.setInt(AlignLog & 7);

  }

  llvm::Value *getPointer() const { return Pointer.getPointer(); }

  llvm::Type *getElementType() const { return ElementType.getPointer(); }

  CharUnits getAlignment() const {

    unsigned AlignLog = (Pointer.getInt() << 3) | ElementType.getInt();

    return CharUnits::fromQuantity(CharUnits::QuantityType(1) << AlignLog);

  }

};

/// An aligned address.

class Address {

  AddressImpl<void> A;

protected:

  Address(std::nullptr_t) : A(nullptr, nullptr, CharUnits::Zero()) {}

public:

  Address(llvm::Value *Pointer, llvm::Type *ElementType, CharUnits Alignment)

      : A(Pointer, ElementType, Alignment) {

    assert(Pointer != nullptr && "Pointer cannot be null");

    assert(ElementType != nullptr && "Element type cannot be null");

    assert(llvm::cast<llvm::PointerType>(Pointer->getType())

               ->isOpaqueOrPointeeTypeMatches(ElementType) &&

           "Incorrect pointer element type");

  }

  static Address invalid() { return Address(nullptr); }

  bool isValid() const { return A.getPointer() != nullptr; }

  llvm::Value *getPointer() const {

    assert(isValid());

    return A.getPointer();

  }

  /// Return the type of the pointer value.

  llvm::PointerType *getType() const {

    return llvm::cast<llvm::PointerType>(getPointer()->getType());

  }

  /// Return the type of the values stored in this address.

  llvm::Type *getElementType() const {

    assert(isValid());

    return A.getElementType();

  }

  /// Return the address space that this address resides in.

  unsigned getAddressSpace() const {

    return getType()->getAddressSpace();

  }

  /// Return the IR name of the pointer value.

  llvm::StringRef getName() const {

    return getPointer()->getName();

  }

  /// Return the alignment of this pointer.

  CharUnits getAlignment() const {

    assert(isValid());

    return A.getAlignment();

  }

  /// Return address with different pointer, but same element type and

  /// alignment.

  Address withPointer(llvm::Value *NewPointer) const {

    return Address(NewPointer, getElementType(), getAlignment());

  }

  /// Return address with different alignment, but same pointer and element

  /// type.

  Address withAlignment(CharUnits NewAlignment) const {

    return Address(getPointer(), getElementType(), NewAlignment);

  }

};

/// A specialization of Address that requires the address to be an

/// LLVM Constant.

class ConstantAddress : public Address {

  ConstantAddress(std::nullptr_t) : Address(nullptr) {}

public:

  ConstantAddress(llvm::Constant *pointer, llvm::Type *elementType,

                  CharUnits alignment)

      : Address(pointer, elementType, alignment) {}

  static ConstantAddress invalid() {

    return ConstantAddress(nullptr);

  }

  llvm::Constant *getPointer() const {

    return llvm::cast<llvm::Constant>(Address::getPointer());

  }

  ConstantAddress getElementBitCast(llvm::Type *ElemTy) const {

    llvm::Constant *BitCast = llvm::ConstantExpr::getBitCast(

        getPointer(), ElemTy->getPointerTo(getAddressSpace()));

    return ConstantAddress(BitCast, ElemTy, getAlignment());

  }

  static bool isaImpl(Address addr) {

    return llvm::isa<llvm::Constant>(addr.getPointer());

  }

  static ConstantAddress castImpl(Address addr) {

    return ConstantAddress(llvm::cast<llvm::Constant>(addr.getPointer()),

                           addr.getElementType(), addr.getAlignment());

  }

};

}

// Present a minimal LLVM-like casting interface.

template <class U> inline U cast(CodeGen::Address addr) {

  return U::castImpl(addr);

}

template <class U> inline bool isa(CodeGen::Address addr) {

  return U::isaImpl(addr);

}

}

#endif