Bug Summary

File:llvm/tools/llvm-exegesis/lib/Assembler.cpp
Warning:line 282, column 15
Dereference of null pointer (loaded from field 'CodeSize')

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name Assembler.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/llvm-exegesis/lib -I /build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/llvm/tools/llvm-exegesis/lib -I include -I /build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/llvm/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/= -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/= -O3 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-01-19-134126-35450-1 -x c++ /build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/llvm/tools/llvm-exegesis/lib/Assembler.cpp
1//===-- Assembler.cpp -------------------------------------------*- C++ -*-===//
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 "Assembler.h"
10
11#include "SnippetRepetitor.h"
12#include "Target.h"
13#include "llvm/Analysis/TargetLibraryInfo.h"
14#include "llvm/CodeGen/FunctionLoweringInfo.h"
15#include "llvm/CodeGen/GlobalISel/CallLowering.h"
16#include "llvm/CodeGen/GlobalISel/MachineIRBuilder.h"
17#include "llvm/CodeGen/MachineInstrBuilder.h"
18#include "llvm/CodeGen/MachineModuleInfo.h"
19#include "llvm/CodeGen/MachineRegisterInfo.h"
20#include "llvm/CodeGen/TargetInstrInfo.h"
21#include "llvm/CodeGen/TargetPassConfig.h"
22#include "llvm/CodeGen/TargetSubtargetInfo.h"
23#include "llvm/ExecutionEngine/SectionMemoryManager.h"
24#include "llvm/IR/LegacyPassManager.h"
25#include "llvm/MC/MCInstrInfo.h"
26#include "llvm/Support/Alignment.h"
27#include "llvm/Support/MemoryBuffer.h"
28
29namespace llvm {
30namespace exegesis {
31
32static constexpr const char ModuleID[] = "ExegesisInfoTest";
33static constexpr const char FunctionID[] = "foo";
34static const Align kFunctionAlignment(4096);
35
36// Fills the given basic block with register setup code, and returns true if
37// all registers could be setup correctly.
38static bool generateSnippetSetupCode(
39 const ExegesisTarget &ET, const MCSubtargetInfo *const MSI,
40 ArrayRef<RegisterValue> RegisterInitialValues, BasicBlockFiller &BBF) {
41 bool IsSnippetSetupComplete = true;
42 for (const RegisterValue &RV : RegisterInitialValues) {
43 // Load a constant in the register.
44 const auto SetRegisterCode = ET.setRegTo(*MSI, RV.Register, RV.Value);
45 if (SetRegisterCode.empty())
46 IsSnippetSetupComplete = false;
47 BBF.addInstructions(SetRegisterCode);
48 }
49 return IsSnippetSetupComplete;
50}
51
52// Small utility function to add named passes.
53static bool addPass(PassManagerBase &PM, StringRef PassName,
54 TargetPassConfig &TPC) {
55 const PassRegistry *PR = PassRegistry::getPassRegistry();
56 const PassInfo *PI = PR->getPassInfo(PassName);
57 if (!PI) {
58 errs() << " run-pass " << PassName << " is not registered.\n";
59 return true;
60 }
61
62 if (!PI->getNormalCtor()) {
63 errs() << " cannot create pass: " << PI->getPassName() << "\n";
64 return true;
65 }
66 Pass *P = PI->getNormalCtor()();
67 std::string Banner = std::string("After ") + std::string(P->getPassName());
68 PM.add(P);
69 TPC.printAndVerify(Banner);
70
71 return false;
72}
73
74MachineFunction &createVoidVoidPtrMachineFunction(StringRef FunctionName,
75 Module *Module,
76 MachineModuleInfo *MMI) {
77 Type *const ReturnType = Type::getInt32Ty(Module->getContext());
78 Type *const MemParamType = PointerType::get(
79 Type::getInt8Ty(Module->getContext()), 0 /*default address space*/);
80 FunctionType *FunctionType =
81 FunctionType::get(ReturnType, {MemParamType}, false);
82 Function *const F = Function::Create(
83 FunctionType, GlobalValue::InternalLinkage, FunctionName, Module);
84 // Making sure we can create a MachineFunction out of this Function even if it
85 // contains no IR.
86 F->setIsMaterializable(true);
87 return MMI->getOrCreateMachineFunction(*F);
88}
89
90BasicBlockFiller::BasicBlockFiller(MachineFunction &MF, MachineBasicBlock *MBB,
91 const MCInstrInfo *MCII)
92 : MF(MF), MBB(MBB), MCII(MCII) {}
93
94void BasicBlockFiller::addInstruction(const MCInst &Inst, const DebugLoc &DL) {
95 const unsigned Opcode = Inst.getOpcode();
96 const MCInstrDesc &MCID = MCII->get(Opcode);
97 MachineInstrBuilder Builder = BuildMI(MBB, DL, MCID);
98 for (unsigned OpIndex = 0, E = Inst.getNumOperands(); OpIndex < E;
99 ++OpIndex) {
100 const MCOperand &Op = Inst.getOperand(OpIndex);
101 if (Op.isReg()) {
102 const bool IsDef = OpIndex < MCID.getNumDefs();
103 unsigned Flags = 0;
104 const MCOperandInfo &OpInfo = MCID.operands().begin()[OpIndex];
105 if (IsDef && !OpInfo.isOptionalDef())
106 Flags |= RegState::Define;
107 Builder.addReg(Op.getReg(), Flags);
108 } else if (Op.isImm()) {
109 Builder.addImm(Op.getImm());
110 } else if (!Op.isValid()) {
111 llvm_unreachable("Operand is not set")::llvm::llvm_unreachable_internal("Operand is not set", "llvm/tools/llvm-exegesis/lib/Assembler.cpp"
, 111)
;
112 } else {
113 llvm_unreachable("Not yet implemented")::llvm::llvm_unreachable_internal("Not yet implemented", "llvm/tools/llvm-exegesis/lib/Assembler.cpp"
, 113)
;
114 }
115 }
116}
117
118void BasicBlockFiller::addInstructions(ArrayRef<MCInst> Insts,
119 const DebugLoc &DL) {
120 for (const MCInst &Inst : Insts)
121 addInstruction(Inst, DL);
122}
123
124void BasicBlockFiller::addReturn(const DebugLoc &DL) {
125 // Insert the return code.
126 const TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo();
127 if (TII->getReturnOpcode() < TII->getNumOpcodes()) {
128 BuildMI(MBB, DL, TII->get(TII->getReturnOpcode()));
129 } else {
130 MachineIRBuilder MIB(MF);
131 MIB.setMBB(*MBB);
132
133 FunctionLoweringInfo FuncInfo;
134 FuncInfo.CanLowerReturn = true;
135 MF.getSubtarget().getCallLowering()->lowerReturn(MIB, nullptr, {},
136 FuncInfo);
137 }
138}
139
140FunctionFiller::FunctionFiller(MachineFunction &MF,
141 std::vector<unsigned> RegistersSetUp)
142 : MF(MF), MCII(MF.getTarget().getMCInstrInfo()), Entry(addBasicBlock()),
143 RegistersSetUp(std::move(RegistersSetUp)) {}
144
145BasicBlockFiller FunctionFiller::addBasicBlock() {
146 MachineBasicBlock *MBB = MF.CreateMachineBasicBlock();
147 MF.push_back(MBB);
148 return BasicBlockFiller(MF, MBB, MCII);
149}
150
151ArrayRef<unsigned> FunctionFiller::getRegistersSetUp() const {
152 return RegistersSetUp;
153}
154
155static std::unique_ptr<Module>
156createModule(const std::unique_ptr<LLVMContext> &Context, const DataLayout &DL) {
157 auto Mod = std::make_unique<Module>(ModuleID, *Context);
158 Mod->setDataLayout(DL);
159 return Mod;
160}
161
162BitVector getFunctionReservedRegs(const TargetMachine &TM) {
163 std::unique_ptr<LLVMContext> Context = std::make_unique<LLVMContext>();
164 std::unique_ptr<Module> Module = createModule(Context, TM.createDataLayout());
165 // TODO: This only works for targets implementing LLVMTargetMachine.
166 const LLVMTargetMachine &LLVMTM = static_cast<const LLVMTargetMachine &>(TM);
167 std::unique_ptr<MachineModuleInfoWrapperPass> MMIWP =
168 std::make_unique<MachineModuleInfoWrapperPass>(&LLVMTM);
169 MachineFunction &MF = createVoidVoidPtrMachineFunction(
170 FunctionID, Module.get(), &MMIWP.get()->getMMI());
171 // Saving reserved registers for client.
172 return MF.getSubtarget().getRegisterInfo()->getReservedRegs(MF);
173}
174
175Error assembleToStream(const ExegesisTarget &ET,
176 std::unique_ptr<LLVMTargetMachine> TM,
177 ArrayRef<unsigned> LiveIns,
178 ArrayRef<RegisterValue> RegisterInitialValues,
179 const FillFunction &Fill, raw_pwrite_stream &AsmStream) {
180 auto Context = std::make_unique<LLVMContext>();
181 std::unique_ptr<Module> Module =
182 createModule(Context, TM->createDataLayout());
183 auto MMIWP = std::make_unique<MachineModuleInfoWrapperPass>(TM.get());
184 MachineFunction &MF = createVoidVoidPtrMachineFunction(
185 FunctionID, Module.get(), &MMIWP.get()->getMMI());
186 MF.ensureAlignment(kFunctionAlignment);
187
188 // We need to instruct the passes that we're done with SSA and virtual
189 // registers.
190 auto &Properties = MF.getProperties();
191 Properties.set(MachineFunctionProperties::Property::NoVRegs);
192 Properties.reset(MachineFunctionProperties::Property::IsSSA);
193 Properties.set(MachineFunctionProperties::Property::NoPHIs);
194
195 for (const unsigned Reg : LiveIns)
196 MF.getRegInfo().addLiveIn(Reg);
197
198 std::vector<unsigned> RegistersSetUp;
199 for (const auto &InitValue : RegisterInitialValues) {
200 RegistersSetUp.push_back(InitValue.Register);
201 }
202 FunctionFiller Sink(MF, std::move(RegistersSetUp));
203 auto Entry = Sink.getEntry();
204 for (const unsigned Reg : LiveIns)
205 Entry.MBB->addLiveIn(Reg);
206
207 const bool IsSnippetSetupComplete = generateSnippetSetupCode(
208 ET, TM->getMCSubtargetInfo(), RegisterInitialValues, Entry);
209
210 // If the snippet setup is not complete, we disable liveliness tracking. This
211 // means that we won't know what values are in the registers.
212 if (!IsSnippetSetupComplete)
213 Properties.reset(MachineFunctionProperties::Property::TracksLiveness);
214
215 Fill(Sink);
216
217 // prologue/epilogue pass needs the reserved registers to be frozen, this
218 // is usually done by the SelectionDAGISel pass.
219 MF.getRegInfo().freezeReservedRegs(MF);
220
221 // We create the pass manager, run the passes to populate AsmBuffer.
222 MCContext &MCContext = MMIWP->getMMI().getContext();
223 legacy::PassManager PM;
224
225 TargetLibraryInfoImpl TLII(Triple(Module->getTargetTriple()));
226 PM.add(new TargetLibraryInfoWrapperPass(TLII));
227
228 TargetPassConfig *TPC = TM->createPassConfig(PM);
229 PM.add(TPC);
230 PM.add(MMIWP.release());
231 TPC->printAndVerify("MachineFunctionGenerator::assemble");
232 // Add target-specific passes.
233 ET.addTargetSpecificPasses(PM);
234 TPC->printAndVerify("After ExegesisTarget::addTargetSpecificPasses");
235 // Adding the following passes:
236 // - postrapseudos: expands pseudo return instructions used on some targets.
237 // - machineverifier: checks that the MachineFunction is well formed.
238 // - prologepilog: saves and restore callee saved registers.
239 for (const char *PassName :
240 {"postrapseudos", "machineverifier", "prologepilog"})
241 if (addPass(PM, PassName, *TPC))
242 return make_error<Failure>("Unable to add a mandatory pass");
243 TPC->setInitialized();
244
245 // AsmPrinter is responsible for generating the assembly into AsmBuffer.
246 if (TM->addAsmPrinter(PM, AsmStream, nullptr, CGFT_ObjectFile, MCContext))
247 return make_error<Failure>("Cannot add AsmPrinter passes");
248
249 PM.run(*Module); // Run all the passes
250 return Error::success();
251}
252
253object::OwningBinary<object::ObjectFile>
254getObjectFromBuffer(StringRef InputData) {
255 // Storing the generated assembly into a MemoryBuffer that owns the memory.
256 std::unique_ptr<MemoryBuffer> Buffer =
257 MemoryBuffer::getMemBufferCopy(InputData);
258 // Create the ObjectFile from the MemoryBuffer.
259 std::unique_ptr<object::ObjectFile> Obj =
260 cantFail(object::ObjectFile::createObjectFile(Buffer->getMemBufferRef()));
261 // Returning both the MemoryBuffer and the ObjectFile.
262 return object::OwningBinary<object::ObjectFile>(std::move(Obj),
263 std::move(Buffer));
264}
265
266object::OwningBinary<object::ObjectFile> getObjectFromFile(StringRef Filename) {
267 return cantFail(object::ObjectFile::createObjectFile(Filename));
268}
269
270namespace {
271
272// Implementation of this class relies on the fact that a single object with a
273// single function will be loaded into memory.
274class TrackingSectionMemoryManager : public SectionMemoryManager {
275public:
276 explicit TrackingSectionMemoryManager(uintptr_t *CodeSize)
277 : CodeSize(CodeSize) {}
278
279 uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
280 unsigned SectionID,
281 StringRef SectionName) override {
282 *CodeSize = Size;
Dereference of null pointer (loaded from field 'CodeSize')
283 return SectionMemoryManager::allocateCodeSection(Size, Alignment, SectionID,
284 SectionName);
285 }
286
287private:
288 uintptr_t *const CodeSize = nullptr;
289};
290
291} // namespace
292
293ExecutableFunction::ExecutableFunction(
294 std::unique_ptr<LLVMTargetMachine> TM,
295 object::OwningBinary<object::ObjectFile> &&ObjectFileHolder)
296 : Context(std::make_unique<LLVMContext>()) {
297 assert(ObjectFileHolder.getBinary() && "cannot create object file")(static_cast <bool> (ObjectFileHolder.getBinary() &&
"cannot create object file") ? void (0) : __assert_fail ("ObjectFileHolder.getBinary() && \"cannot create object file\""
, "llvm/tools/llvm-exegesis/lib/Assembler.cpp", 297, __extension__
__PRETTY_FUNCTION__))
;
298 // Initializing the execution engine.
299 // We need to use the JIT EngineKind to be able to add an object file.
300 LLVMLinkInMCJIT();
301 uintptr_t CodeSize = 0;
302 std::string Error;
303 ExecEngine.reset(
304 EngineBuilder(createModule(Context, TM->createDataLayout()))
305 .setErrorStr(&Error)
306 .setMCPU(TM->getTargetCPU())
307 .setEngineKind(EngineKind::JIT)
308 .setMCJITMemoryManager(
309 std::make_unique<TrackingSectionMemoryManager>(&CodeSize))
310 .create(TM.release()));
311 if (!ExecEngine)
312 report_fatal_error(Twine(Error));
313 // Adding the generated object file containing the assembled function.
314 // The ExecutionEngine makes sure the object file is copied into an
315 // executable page.
316 ExecEngine->addObjectFile(std::move(ObjectFileHolder));
317 // Fetching function bytes.
318 const uint64_t FunctionAddress = ExecEngine->getFunctionAddress(FunctionID);
319 assert(isAligned(kFunctionAlignment, FunctionAddress) &&(static_cast <bool> (isAligned(kFunctionAlignment, FunctionAddress
) && "function is not properly aligned") ? void (0) :
__assert_fail ("isAligned(kFunctionAlignment, FunctionAddress) && \"function is not properly aligned\""
, "llvm/tools/llvm-exegesis/lib/Assembler.cpp", 320, __extension__
__PRETTY_FUNCTION__))
320 "function is not properly aligned")(static_cast <bool> (isAligned(kFunctionAlignment, FunctionAddress
) && "function is not properly aligned") ? void (0) :
__assert_fail ("isAligned(kFunctionAlignment, FunctionAddress) && \"function is not properly aligned\""
, "llvm/tools/llvm-exegesis/lib/Assembler.cpp", 320, __extension__
__PRETTY_FUNCTION__))
;
321 FunctionBytes =
322 StringRef(reinterpret_cast<const char *>(FunctionAddress), CodeSize);
323}
324
325} // namespace exegesis
326} // namespace llvm