84 lines · cpp
1//===--- PatternInit.cpp - Pattern Initialization -------------------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9#include "PatternInit.h"10#include "CodeGenModule.h"11#include "clang/Basic/TargetInfo.h"12#include "llvm/IR/Constant.h"13#include "llvm/IR/Type.h"14 15llvm::Constant *clang::CodeGen::initializationPatternFor(CodeGenModule &CGM,16 llvm::Type *Ty) {17 // The following value is a guaranteed unmappable pointer value and has a18 // repeated byte-pattern which makes it easier to synthesize. We use it for19 // pointers as well as integers so that aggregates are likely to be20 // initialized with this repeated value.21 // For 32-bit platforms it's a bit trickier because, across systems, only the22 // zero page can reasonably be expected to be unmapped. We use max 0xFFFFFFFF23 // assuming that memory access will overlap into zero page.24 const uint64_t IntValue =25 CGM.getContext().getTargetInfo().getMaxPointerWidth() < 6426 ? 0xFFFFFFFFFFFFFFFFull27 : 0xAAAAAAAAAAAAAAAAull;28 // Floating-point values are initialized as NaNs because they propagate. Using29 // a repeated byte pattern means that it will be easier to initialize30 // all-floating-point aggregates and arrays with memset. Further, aggregates31 // which mix integral and a few floats might also initialize with memset32 // followed by a handful of stores for the floats. Using fairly unique NaNs33 // also means they'll be easier to distinguish in a crash.34 constexpr bool NegativeNaN = true;35 constexpr uint64_t NaNPayload = 0xFFFFFFFFFFFFFFFFull;36 if (Ty->isIntOrIntVectorTy()) {37 unsigned BitWidth =38 cast<llvm::IntegerType>(Ty->getScalarType())->getBitWidth();39 if (BitWidth <= 64)40 return llvm::ConstantInt::get(Ty, IntValue);41 return llvm::ConstantInt::get(42 Ty, llvm::APInt::getSplat(BitWidth, llvm::APInt(64, IntValue)));43 }44 if (Ty->isPtrOrPtrVectorTy()) {45 auto *PtrTy = cast<llvm::PointerType>(Ty->getScalarType());46 unsigned PtrWidth =47 CGM.getDataLayout().getPointerSizeInBits(PtrTy->getAddressSpace());48 if (PtrWidth > 64)49 llvm_unreachable("pattern initialization of unsupported pointer width");50 llvm::Type *IntTy = llvm::IntegerType::get(CGM.getLLVMContext(), PtrWidth);51 auto *Int = llvm::ConstantInt::get(IntTy, IntValue);52 return llvm::ConstantExpr::getIntToPtr(Int, PtrTy);53 }54 if (Ty->isFPOrFPVectorTy()) {55 unsigned BitWidth = llvm::APFloat::semanticsSizeInBits(56 Ty->getScalarType()->getFltSemantics());57 llvm::APInt Payload(64, NaNPayload);58 if (BitWidth >= 64)59 Payload = llvm::APInt::getSplat(BitWidth, Payload);60 return llvm::ConstantFP::getQNaN(Ty, NegativeNaN, &Payload);61 }62 if (Ty->isArrayTy()) {63 // Note: this doesn't touch tail padding (at the end of an object, before64 // the next array object). It is instead handled by replaceUndef.65 auto *ArrTy = cast<llvm::ArrayType>(Ty);66 llvm::SmallVector<llvm::Constant *, 8> Element(67 ArrTy->getNumElements(),68 initializationPatternFor(CGM, ArrTy->getElementType()));69 return llvm::ConstantArray::get(ArrTy, Element);70 }71 72 // Note: this doesn't touch struct padding. It will initialize as much union73 // padding as is required for the largest type in the union. Padding is74 // instead handled by replaceUndef. Stores to structs with volatile members75 // don't have a volatile qualifier when initialized according to C++. This is76 // fine because stack-based volatiles don't really have volatile semantics77 // anyways, and the initialization shouldn't be observable.78 auto *StructTy = cast<llvm::StructType>(Ty);79 llvm::SmallVector<llvm::Constant *, 8> Struct(StructTy->getNumElements());80 for (unsigned El = 0; El != Struct.size(); ++El)81 Struct[El] = initializationPatternFor(CGM, StructTy->getElementType(El));82 return llvm::ConstantStruct::get(StructTy, Struct);83}84