| //===--- PatternInit.cpp - Pattern Initialization -------------------------===// | |
| // | |
| // 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 "PatternInit.h" | |
| #include "CodeGenModule.h" | |
| #include "clang/Basic/TargetInfo.h" | |
| #include "llvm/IR/Constant.h" | |
| #include "llvm/IR/Type.h" | |
| llvm::Constant *clang::CodeGen::initializationPatternFor(CodeGenModule &CGM, | |
| llvm::Type *Ty) { | |
| // The following value is a guaranteed unmappable pointer value and has a | |
| // repeated byte-pattern which makes it easier to synthesize. We use it for | |
| // pointers as well as integers so that aggregates are likely to be | |
| // initialized with this repeated value. | |
| // For 32-bit platforms it's a bit trickier because, across systems, only the | |
| // zero page can reasonably be expected to be unmapped. We use max 0xFFFFFFFF | |
| // assuming that memory access will overlap into zero page. | |
| const uint64_t IntValue = | |
| CGM.getContext().getTargetInfo().getMaxPointerWidth() < 64 | |
| ? 0xFFFFFFFFFFFFFFFFull | |
| : 0xAAAAAAAAAAAAAAAAull; | |
| // Floating-point values are initialized as NaNs because they propagate. Using | |
| // a repeated byte pattern means that it will be easier to initialize | |
| // all-floating-point aggregates and arrays with memset. Further, aggregates | |
| // which mix integral and a few floats might also initialize with memset | |
| // followed by a handful of stores for the floats. Using fairly unique NaNs | |
| // also means they'll be easier to distinguish in a crash. | |
| constexpr bool NegativeNaN = true; | |
| constexpr uint64_t NaNPayload = 0xFFFFFFFFFFFFFFFFull; | |
| if (Ty->isIntOrIntVectorTy()) { | |
| unsigned BitWidth = | |
| cast<llvm::IntegerType>(Ty->getScalarType())->getBitWidth(); | |
| if (BitWidth <= 64) | |
| return llvm::ConstantInt::get(Ty, IntValue, /*IsSigned=*/false, | |
| /*ImplicitTrunc=*/true); | |
| return llvm::ConstantInt::get( | |
| Ty, llvm::APInt::getSplat(BitWidth, llvm::APInt(64, IntValue))); | |
| } | |
| if (Ty->isPtrOrPtrVectorTy()) { | |
| auto *PtrTy = cast<llvm::PointerType>(Ty->getScalarType()); | |
| unsigned PtrWidth = | |
| CGM.getDataLayout().getPointerSizeInBits(PtrTy->getAddressSpace()); | |
| if (PtrWidth > 64) | |
| llvm_unreachable("pattern initialization of unsupported pointer width"); | |
| llvm::Type *IntTy = llvm::IntegerType::get(CGM.getLLVMContext(), PtrWidth); | |
| auto *Int = llvm::ConstantInt::get(IntTy, IntValue, /*IsSigned=*/false, | |
| /*ImplicitTrunc=*/true); | |
| return llvm::ConstantExpr::getIntToPtr(Int, PtrTy); | |
| } | |
| if (Ty->isFPOrFPVectorTy()) { | |
| unsigned BitWidth = llvm::APFloat::semanticsSizeInBits( | |
| Ty->getScalarType()->getFltSemantics()); | |
| llvm::APInt Payload(64, NaNPayload); | |
| if (BitWidth >= 64) | |
| Payload = llvm::APInt::getSplat(BitWidth, Payload); | |
| return llvm::ConstantFP::getQNaN(Ty, NegativeNaN, &Payload); | |
| } | |
| if (Ty->isArrayTy()) { | |
| // Note: this doesn't touch tail padding (at the end of an object, before | |
| // the next array object). It is instead handled by replaceUndef. | |
| auto *ArrTy = cast<llvm::ArrayType>(Ty); | |
| llvm::SmallVector<llvm::Constant *, 8> Element( | |
| ArrTy->getNumElements(), | |
| initializationPatternFor(CGM, ArrTy->getElementType())); | |
| return llvm::ConstantArray::get(ArrTy, Element); | |
| } | |
| // Note: this doesn't touch struct padding. It will initialize as much union | |
| // padding as is required for the largest type in the union. Padding is | |
| // instead handled by replaceUndef. Stores to structs with volatile members | |
| // don't have a volatile qualifier when initialized according to C++. This is | |
| // fine because stack-based volatiles don't really have volatile semantics | |
| // anyways, and the initialization shouldn't be observable. | |
| auto *StructTy = cast<llvm::StructType>(Ty); | |
| llvm::SmallVector<llvm::Constant *, 8> Struct(StructTy->getNumElements()); | |
| for (unsigned El = 0; El != Struct.size(); ++El) | |
| Struct[El] = initializationPatternFor(CGM, StructTy->getElementType(El)); | |
| return llvm::ConstantStruct::get(StructTy, Struct); | |
| } |