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-exception 6 // 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 15 llvm::Constant *clang::CodeGen::initializationPatternFor(CodeGenModule &CGM, 16 llvm::Type *Ty) { 17 // The following value is a guaranteed unmappable pointer value and has a 18 // repeated byte-pattern which makes it easier to synthesize. We use it for 19 // pointers as well as integers so that aggregates are likely to be 20 // initialized with this repeated value. 21 // For 32-bit platforms it's a bit trickier because, across systems, only the 22 // zero page can reasonably be expected to be unmapped. We use max 0xFFFFFFFF 23 // assuming that memory access will overlap into zero page. 24 const uint64_t IntValue = 25 CGM.getContext().getTargetInfo().getMaxPointerWidth() < 64 26 ? 0xFFFFFFFFFFFFFFFFull 27 : 0xAAAAAAAAAAAAAAAAull; 28 // Floating-point values are initialized as NaNs because they propagate. Using 29 // a repeated byte pattern means that it will be easier to initialize 30 // all-floating-point aggregates and arrays with memset. Further, aggregates 31 // which mix integral and a few floats might also initialize with memset 32 // followed by a handful of stores for the floats. Using fairly unique NaNs 33 // 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 = CGM.getContext().getTargetInfo().getPointerWidth( 47 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, before 64 // 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 union 73 // padding as is required for the largest type in the union. Padding is 74 // instead handled by replaceUndef. Stores to structs with volatile members 75 // don't have a volatile qualifier when initialized according to C++. This is 76 // fine because stack-based volatiles don't really have volatile semantics 77 // 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