clang  13.0.0git
PatternInit.cpp
Go to the documentation of this file.
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 
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 =
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);
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 }
clang::interp::APInt
llvm::APInt APInt
Definition: Integral.h:27
llvm::SmallVector
Definition: LLVM.h:38
TargetInfo.h
clang::CodeGen::CodeGenModule::getContext
ASTContext & getContext() const
Definition: CodeGenModule.h:702
clang::TargetInfo::getMaxPointerWidth
virtual uint64_t getMaxPointerWidth() const
Return the maximum width of pointers on this target.
Definition: TargetInfo.h:420
CodeGenModule.h
clang::CodeGen::initializationPatternFor
llvm::Constant * initializationPatternFor(CodeGenModule &, llvm::Type *)
Definition: PatternInit.cpp:15
PatternInit.h
clang::CodeGen::CodeGenModule
This class organizes the cross-function state that is used while generating LLVM code.
Definition: CodeGenModule.h:284
clang::ASTContext::getTargetInfo
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:693
clang::TargetInfo::getPointerWidth
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
Definition: TargetInfo.h:412
clang::CodeGen::CodeGenModule::getLLVMContext
llvm::LLVMContext & getLLVMContext()
Definition: CodeGenModule.h:720