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
15llvm::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>(Val: Ty->getScalarType())->getBitWidth();
39 if (BitWidth <= 64)
40 return llvm::ConstantInt::get(Ty, V: IntValue);
41 return llvm::ConstantInt::get(
42 Ty, V: llvm::APInt::getSplat(NewLen: BitWidth, V: llvm::APInt(64, IntValue)));
43 }
44 if (Ty->isPtrOrPtrVectorTy()) {
45 auto *PtrTy = cast<llvm::PointerType>(Val: Ty->getScalarType());
46 unsigned PtrWidth =
47 CGM.getDataLayout().getPointerSizeInBits(AS: PtrTy->getAddressSpace());
48 if (PtrWidth > 64)
49 llvm_unreachable("pattern initialization of unsupported pointer width");
50 llvm::Type *IntTy = llvm::IntegerType::get(C&: CGM.getLLVMContext(), NumBits: PtrWidth);
51 auto *Int = llvm::ConstantInt::get(Ty: IntTy, V: IntValue);
52 return llvm::ConstantExpr::getIntToPtr(C: Int, Ty: 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(NewLen: BitWidth, V: Payload);
60 return llvm::ConstantFP::getQNaN(Ty, Negative: NegativeNaN, Payload: &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>(Val: Ty);
66 llvm::SmallVector<llvm::Constant *, 8> Element(
67 ArrTy->getNumElements(),
68 initializationPatternFor(CGM, Ty: ArrTy->getElementType()));
69 return llvm::ConstantArray::get(T: ArrTy, V: 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>(Val: Ty);
79 llvm::SmallVector<llvm::Constant *, 8> Struct(StructTy->getNumElements());
80 for (unsigned El = 0; El != Struct.size(); ++El)
81 Struct[El] = initializationPatternFor(CGM, Ty: StructTy->getElementType(N: El));
82 return llvm::ConstantStruct::get(T: StructTy, V: Struct);
83}
84

source code of clang/lib/CodeGen/PatternInit.cpp