Constant.cpp | Explore in Territory

//===- Constant.cpp - The Constant classes of Sandbox IR ------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//

#include "llvm/SandboxIR/Constant.h"
#include "llvm/SandboxIR/Argument.h"
#include "llvm/SandboxIR/BasicBlock.h"
#include "llvm/SandboxIR/Context.h"
#include "llvm/SandboxIR/Function.h"

namespace llvm::sandboxir {

#ifndef NDEBUG
void Constant::dumpOS(raw_ostream &OS) const {
  dumpCommonPrefix(OS);
  dumpCommonSuffix(OS);
}
#endif // NDEBUG

ConstantInt *ConstantInt::getTrue(Context &Ctx) { … }
ConstantInt *ConstantInt::getFalse(Context &Ctx) { … }
ConstantInt *ConstantInt::getBool(Context &Ctx, bool V) { … }
Constant *ConstantInt::getTrue(Type *Ty) { … }
Constant *ConstantInt::getFalse(Type *Ty) { … }
Constant *ConstantInt::getBool(Type *Ty, bool V) { … }
ConstantInt *ConstantInt::get(Type *Ty, uint64_t V, bool IsSigned) { … }
ConstantInt *ConstantInt::get(IntegerType *Ty, uint64_t V, bool IsSigned) { … }
ConstantInt *ConstantInt::getSigned(IntegerType *Ty, int64_t V) { … }
Constant *ConstantInt::getSigned(Type *Ty, int64_t V) { … }
ConstantInt *ConstantInt::get(Context &Ctx, const APInt &V) { … }
ConstantInt *ConstantInt::get(IntegerType *Ty, StringRef Str, uint8_t Radix) { … }
Constant *ConstantInt::get(Type *Ty, const APInt &V) { … }
IntegerType *ConstantInt::getIntegerType() const { … }

bool ConstantInt::isValueValidForType(Type *Ty, uint64_t V) { … }
bool ConstantInt::isValueValidForType(Type *Ty, int64_t V) { … }

Constant *ConstantFP::get(Type *Ty, double V) { … }

Constant *ConstantFP::get(Type *Ty, const APFloat &V) { … }

Constant *ConstantFP::get(Type *Ty, StringRef Str) { … }

ConstantFP *ConstantFP::get(const APFloat &V, Context &Ctx) { … }

Constant *ConstantFP::getNaN(Type *Ty, bool Negative, uint64_t Payload) { … }
Constant *ConstantFP::getQNaN(Type *Ty, bool Negative, APInt *Payload) { … }
Constant *ConstantFP::getSNaN(Type *Ty, bool Negative, APInt *Payload) { … }
Constant *ConstantFP::getZero(Type *Ty, bool Negative) { … }
Constant *ConstantFP::getNegativeZero(Type *Ty) { … }
Constant *ConstantFP::getInfinity(Type *Ty, bool Negative) { … }
bool ConstantFP::isValueValidForType(Type *Ty, const APFloat &V) { … }

Constant *ConstantArray::get(ArrayType *T, ArrayRef<Constant *> V) { … }

ArrayType *ConstantArray::getType() const { … }

Constant *ConstantStruct::get(StructType *T, ArrayRef<Constant *> V) { … }

StructType *ConstantStruct::getTypeForElements(Context &Ctx,
                                               ArrayRef<Constant *> V,
                                               bool Packed) { … }

ConstantAggregateZero *ConstantAggregateZero::get(Type *Ty) { … }

Constant *ConstantAggregateZero::getSequentialElement() const { … }
Constant *ConstantAggregateZero::getStructElement(unsigned Elt) const { … }
Constant *ConstantAggregateZero::getElementValue(Constant *C) const { … }
Constant *ConstantAggregateZero::getElementValue(unsigned Idx) const { … }

ConstantPointerNull *ConstantPointerNull::get(PointerType *Ty) { … }

PointerType *ConstantPointerNull::getType() const { … }

UndefValue *UndefValue::get(Type *T) { … }

UndefValue *UndefValue::getSequentialElement() const { … }

UndefValue *UndefValue::getStructElement(unsigned Elt) const { … }

UndefValue *UndefValue::getElementValue(Constant *C) const { … }

UndefValue *UndefValue::getElementValue(unsigned Idx) const { … }

PoisonValue *PoisonValue::get(Type *T) { … }

PoisonValue *PoisonValue::getSequentialElement() const { … }

PoisonValue *PoisonValue::getStructElement(unsigned Elt) const { … }

PoisonValue *PoisonValue::getElementValue(Constant *C) const { … }

PoisonValue *PoisonValue::getElementValue(unsigned Idx) const { … }

void GlobalObject::setAlignment(MaybeAlign Align) { … }

void GlobalObject::setGlobalObjectSubClassData(unsigned V) { … }

void GlobalObject::setSection(StringRef S) { … }

template <typename GlobalT, typename LLVMGlobalT, typename ParentT,
          typename LLVMParentT>
GlobalT &GlobalWithNodeAPI<GlobalT, LLVMGlobalT, ParentT, LLVMParentT>::
    LLVMGVToGV::operator()(LLVMGlobalT &LLVMGV) const { … }

// Explicit instantiations.
template class GlobalWithNodeAPI<GlobalIFunc, llvm::GlobalIFunc, GlobalObject,
                                 llvm::GlobalObject>;
template class GlobalWithNodeAPI<Function, llvm::Function, GlobalObject,
                                 llvm::GlobalObject>;
template class GlobalWithNodeAPI<GlobalVariable, llvm::GlobalVariable,
                                 GlobalObject, llvm::GlobalObject>;
template class GlobalWithNodeAPI<GlobalAlias, llvm::GlobalAlias, GlobalValue,
                                 llvm::GlobalValue>;

void GlobalIFunc::setResolver(Constant *Resolver) { … }

Constant *GlobalIFunc::getResolver() const { … }

Function *GlobalIFunc::getResolverFunction() { … }

GlobalVariable &
GlobalVariable::LLVMGVToGV::operator()(llvm::GlobalVariable &LLVMGV) const { … }

Constant *GlobalVariable::getInitializer() const { … }

void GlobalVariable::setInitializer(Constant *InitVal) { … }

void GlobalVariable::setConstant(bool V) { … }

void GlobalVariable::setExternallyInitialized(bool V) { … }

void GlobalAlias::setAliasee(Constant *Aliasee) { … }

Constant *GlobalAlias::getAliasee() const { … }

const GlobalObject *GlobalAlias::getAliaseeObject() const { … }

void GlobalValue::setUnnamedAddr(UnnamedAddr V) { … }

void GlobalValue::setVisibility(VisibilityTypes V) { … }

NoCFIValue *NoCFIValue::get(GlobalValue *GV) { … }

GlobalValue *NoCFIValue::getGlobalValue() const { … }

PointerType *NoCFIValue::getType() const { … }

ConstantPtrAuth *ConstantPtrAuth::get(Constant *Ptr, ConstantInt *Key,
                                      ConstantInt *Disc, Constant *AddrDisc) { … }

Constant *ConstantPtrAuth::getPointer() const { … }

ConstantInt *ConstantPtrAuth::getKey() const { … }

ConstantInt *ConstantPtrAuth::getDiscriminator() const { … }

Constant *ConstantPtrAuth::getAddrDiscriminator() const { … }

ConstantPtrAuth *ConstantPtrAuth::getWithSameSchema(Constant *Pointer) const { … }

BlockAddress *BlockAddress::get(Function *F, BasicBlock *BB) { … }

BlockAddress *BlockAddress::get(BasicBlock *BB) { … }

BlockAddress *BlockAddress::lookup(const BasicBlock *BB) { … }

Function *BlockAddress::getFunction() const { … }

BasicBlock *BlockAddress::getBasicBlock() const { … }

DSOLocalEquivalent *DSOLocalEquivalent::get(GlobalValue *GV) { … }

GlobalValue *DSOLocalEquivalent::getGlobalValue() const { … }

} // namespace llvm::sandboxir
llvm/llvm/lib/SandboxIR/Constant.cpp
