Bug Summary

File:llvm/lib/Target/BPF/BPFISelDAGToDAG.cpp
Warning:line 295, column 9
Assigned value is garbage or undefined

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name BPFISelDAGToDAG.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 -mthread-model posix -mframe-pointer=none -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/build-llvm/lib/Target/BPF -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Target/BPF -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/build-llvm/include -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/build-llvm/lib/Target/BPF -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2019-12-07-102640-14763-1 -x c++ /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Target/BPF/BPFISelDAGToDAG.cpp

/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Target/BPF/BPFISelDAGToDAG.cpp

1//===-- BPFISelDAGToDAG.cpp - A dag to dag inst selector for BPF ----------===//
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// This file defines a DAG pattern matching instruction selector for BPF,
10// converting from a legalized dag to a BPF dag.
11//
12//===----------------------------------------------------------------------===//
13
14#include "BPF.h"
15#include "BPFRegisterInfo.h"
16#include "BPFSubtarget.h"
17#include "BPFTargetMachine.h"
18#include "llvm/CodeGen/FunctionLoweringInfo.h"
19#include "llvm/CodeGen/MachineConstantPool.h"
20#include "llvm/CodeGen/MachineFrameInfo.h"
21#include "llvm/CodeGen/MachineFunction.h"
22#include "llvm/CodeGen/MachineInstrBuilder.h"
23#include "llvm/CodeGen/MachineRegisterInfo.h"
24#include "llvm/CodeGen/SelectionDAGISel.h"
25#include "llvm/IR/Constants.h"
26#include "llvm/IR/IntrinsicInst.h"
27#include "llvm/Support/Debug.h"
28#include "llvm/Support/Endian.h"
29#include "llvm/Support/ErrorHandling.h"
30#include "llvm/Support/raw_ostream.h"
31#include "llvm/Target/TargetMachine.h"
32
33using namespace llvm;
34
35#define DEBUG_TYPE"bpf-isel" "bpf-isel"
36
37// Instruction Selector Implementation
38namespace {
39
40class BPFDAGToDAGISel : public SelectionDAGISel {
41
42 /// Subtarget - Keep a pointer to the BPFSubtarget around so that we can
43 /// make the right decision when generating code for different subtargets.
44 const BPFSubtarget *Subtarget;
45
46public:
47 explicit BPFDAGToDAGISel(BPFTargetMachine &TM)
48 : SelectionDAGISel(TM), Subtarget(nullptr) {}
49
50 StringRef getPassName() const override {
51 return "BPF DAG->DAG Pattern Instruction Selection";
52 }
53
54 bool runOnMachineFunction(MachineFunction &MF) override {
55 // Reset the subtarget each time through.
56 Subtarget = &MF.getSubtarget<BPFSubtarget>();
57 return SelectionDAGISel::runOnMachineFunction(MF);
58 }
59
60 void PreprocessISelDAG() override;
61
62 bool SelectInlineAsmMemoryOperand(const SDValue &Op, unsigned ConstraintCode,
63 std::vector<SDValue> &OutOps) override;
64
65
66private:
67// Include the pieces autogenerated from the target description.
68#include "BPFGenDAGISel.inc"
69
70 void Select(SDNode *N) override;
71
72 // Complex Pattern for address selection.
73 bool SelectAddr(SDValue Addr, SDValue &Base, SDValue &Offset);
74 bool SelectFIAddr(SDValue Addr, SDValue &Base, SDValue &Offset);
75
76 // Node preprocessing cases
77 void PreprocessLoad(SDNode *Node, SelectionDAG::allnodes_iterator &I);
78 void PreprocessCopyToReg(SDNode *Node);
79 void PreprocessTrunc(SDNode *Node, SelectionDAG::allnodes_iterator &I);
80
81 // Find constants from a constant structure
82 typedef std::vector<unsigned char> val_vec_type;
83 bool fillGenericConstant(const DataLayout &DL, const Constant *CV,
84 val_vec_type &Vals, uint64_t Offset);
85 bool fillConstantDataArray(const DataLayout &DL, const ConstantDataArray *CDA,
86 val_vec_type &Vals, int Offset);
87 bool fillConstantArray(const DataLayout &DL, const ConstantArray *CA,
88 val_vec_type &Vals, int Offset);
89 bool fillConstantStruct(const DataLayout &DL, const ConstantStruct *CS,
90 val_vec_type &Vals, int Offset);
91 bool getConstantFieldValue(const GlobalAddressSDNode *Node, uint64_t Offset,
92 uint64_t Size, unsigned char *ByteSeq);
93 // Mapping from ConstantStruct global value to corresponding byte-list values
94 std::map<const void *, val_vec_type> cs_vals_;
95};
96} // namespace
97
98// ComplexPattern used on BPF Load/Store instructions
99bool BPFDAGToDAGISel::SelectAddr(SDValue Addr, SDValue &Base, SDValue &Offset) {
100 // if Address is FI, get the TargetFrameIndex.
101 SDLoc DL(Addr);
102 if (FrameIndexSDNode *FIN = dyn_cast<FrameIndexSDNode>(Addr)) {
103 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), MVT::i64);
104 Offset = CurDAG->getTargetConstant(0, DL, MVT::i64);
105 return true;
106 }
107
108 if (Addr.getOpcode() == ISD::TargetExternalSymbol ||
109 Addr.getOpcode() == ISD::TargetGlobalAddress)
110 return false;
111
112 // Addresses of the form Addr+const or Addr|const
113 if (CurDAG->isBaseWithConstantOffset(Addr)) {
114 ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Addr.getOperand(1));
115 if (isInt<16>(CN->getSExtValue())) {
116
117 // If the first operand is a FI, get the TargetFI Node
118 if (FrameIndexSDNode *FIN =
119 dyn_cast<FrameIndexSDNode>(Addr.getOperand(0)))
120 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), MVT::i64);
121 else
122 Base = Addr.getOperand(0);
123
124 Offset = CurDAG->getTargetConstant(CN->getSExtValue(), DL, MVT::i64);
125 return true;
126 }
127 }
128
129 Base = Addr;
130 Offset = CurDAG->getTargetConstant(0, DL, MVT::i64);
131 return true;
132}
133
134// ComplexPattern used on BPF FI instruction
135bool BPFDAGToDAGISel::SelectFIAddr(SDValue Addr, SDValue &Base,
136 SDValue &Offset) {
137 SDLoc DL(Addr);
138
139 if (!CurDAG->isBaseWithConstantOffset(Addr))
140 return false;
141
142 // Addresses of the form Addr+const or Addr|const
143 ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Addr.getOperand(1));
144 if (isInt<16>(CN->getSExtValue())) {
145
146 // If the first operand is a FI, get the TargetFI Node
147 if (FrameIndexSDNode *FIN = dyn_cast<FrameIndexSDNode>(Addr.getOperand(0)))
148 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), MVT::i64);
149 else
150 return false;
151
152 Offset = CurDAG->getTargetConstant(CN->getSExtValue(), DL, MVT::i64);
153 return true;
154 }
155
156 return false;
157}
158
159bool BPFDAGToDAGISel::SelectInlineAsmMemoryOperand(
160 const SDValue &Op, unsigned ConstraintCode, std::vector<SDValue> &OutOps) {
161 SDValue Op0, Op1;
162 switch (ConstraintCode) {
163 default:
164 return true;
165 case InlineAsm::Constraint_m: // memory
166 if (!SelectAddr(Op, Op0, Op1))
167 return true;
168 break;
169 }
170
171 SDLoc DL(Op);
172 SDValue AluOp = CurDAG->getTargetConstant(ISD::ADD, DL, MVT::i32);;
173 OutOps.push_back(Op0);
174 OutOps.push_back(Op1);
175 OutOps.push_back(AluOp);
176 return false;
177}
178
179void BPFDAGToDAGISel::Select(SDNode *Node) {
180 unsigned Opcode = Node->getOpcode();
181
182 // If we have a custom node, we already have selected!
183 if (Node->isMachineOpcode()) {
184 LLVM_DEBUG(dbgs() << "== "; Node->dump(CurDAG); dbgs() << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("bpf-isel")) { dbgs() << "== "; Node->dump(CurDAG);
dbgs() << '\n'; } } while (false)
;
185 return;
186 }
187
188 // tablegen selection should be handled here.
189 switch (Opcode) {
190 default:
191 break;
192 case ISD::SDIV: {
193 DebugLoc Empty;
194 const DebugLoc &DL = Node->getDebugLoc();
195 if (DL != Empty)
196 errs() << "Error at line " << DL.getLine() << ": ";
197 else
198 errs() << "Error: ";
199 errs() << "Unsupport signed division for DAG: ";
200 Node->print(errs(), CurDAG);
201 errs() << "Please convert to unsigned div/mod.\n";
202 break;
203 }
204 case ISD::INTRINSIC_W_CHAIN: {
205 unsigned IntNo = cast<ConstantSDNode>(Node->getOperand(1))->getZExtValue();
206 switch (IntNo) {
207 case Intrinsic::bpf_load_byte:
208 case Intrinsic::bpf_load_half:
209 case Intrinsic::bpf_load_word: {
210 SDLoc DL(Node);
211 SDValue Chain = Node->getOperand(0);
212 SDValue N1 = Node->getOperand(1);
213 SDValue Skb = Node->getOperand(2);
214 SDValue N3 = Node->getOperand(3);
215
216 SDValue R6Reg = CurDAG->getRegister(BPF::R6, MVT::i64);
217 Chain = CurDAG->getCopyToReg(Chain, DL, R6Reg, Skb, SDValue());
218 Node = CurDAG->UpdateNodeOperands(Node, Chain, N1, R6Reg, N3);
219 break;
220 }
221 }
222 break;
223 }
224
225 case ISD::FrameIndex: {
226 int FI = cast<FrameIndexSDNode>(Node)->getIndex();
227 EVT VT = Node->getValueType(0);
228 SDValue TFI = CurDAG->getTargetFrameIndex(FI, VT);
229 unsigned Opc = BPF::MOV_rr;
230 if (Node->hasOneUse()) {
231 CurDAG->SelectNodeTo(Node, Opc, VT, TFI);
232 return;
233 }
234 ReplaceNode(Node, CurDAG->getMachineNode(Opc, SDLoc(Node), VT, TFI));
235 return;
236 }
237 }
238
239 // Select the default instruction
240 SelectCode(Node);
241}
242
243void BPFDAGToDAGISel::PreprocessLoad(SDNode *Node,
244 SelectionDAG::allnodes_iterator &I) {
245 union {
246 uint8_t c[8];
247 uint16_t s;
248 uint32_t i;
249 uint64_t d;
250 } new_val; // hold up the constant values replacing loads.
251 bool to_replace = false;
252 SDLoc DL(Node);
253 const LoadSDNode *LD = cast<LoadSDNode>(Node);
5
'Node' is a 'LoadSDNode'
254 uint64_t size = LD->getMemOperand()->getSize();
255
256 if (!size || size > 8 || (size & (size - 1)))
6
Assuming 'size' is not equal to 0
7
Assuming 'size' is <= 8
8
Assuming the condition is false
9
Taking false branch
257 return;
258
259 SDNode *LDAddrNode = LD->getOperand(1).getNode();
260 // Match LDAddr against either global_addr or (global_addr + offset)
261 unsigned opcode = LDAddrNode->getOpcode();
262 if (opcode == ISD::ADD) {
10
Assuming 'opcode' is equal to ADD
11
Taking true branch
263 SDValue OP1 = LDAddrNode->getOperand(0);
264 SDValue OP2 = LDAddrNode->getOperand(1);
265
266 // We want to find the pattern global_addr + offset
267 SDNode *OP1N = OP1.getNode();
268 if (OP1N->getOpcode() <= ISD::BUILTIN_OP_END || OP1N->getNumOperands() == 0)
12
Assuming the condition is false
13
Assuming the condition is false
14
Taking false branch
269 return;
270
271 LLVM_DEBUG(dbgs() << "Check candidate load: "; LD->dump(); dbgs() << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("bpf-isel")) { dbgs() << "Check candidate load: "; LD->
dump(); dbgs() << '\n'; } } while (false)
;
15
Assuming 'DebugFlag' is false
16
Loop condition is false. Exiting loop
272
273 const GlobalAddressSDNode *GADN =
274 dyn_cast<GlobalAddressSDNode>(OP1N->getOperand(0).getNode());
17
Assuming the object is a 'GlobalAddressSDNode'
275 const ConstantSDNode *CDN = dyn_cast<ConstantSDNode>(OP2.getNode());
18
Assuming the object is a 'ConstantSDNode'
276 if (GADN
18.1
'GADN' is non-null
18.1
'GADN' is non-null
&& CDN
18.2
'CDN' is non-null
18.2
'CDN' is non-null
)
19
Taking true branch
277 to_replace =
278 getConstantFieldValue(GADN, CDN->getZExtValue(), size, new_val.c);
20
Calling 'BPFDAGToDAGISel::getConstantFieldValue'
39
Returning from 'BPFDAGToDAGISel::getConstantFieldValue'
279 } else if (LDAddrNode->getOpcode() > ISD::BUILTIN_OP_END &&
280 LDAddrNode->getNumOperands() > 0) {
281 LLVM_DEBUG(dbgs() << "Check candidate load: "; LD->dump(); dbgs() << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("bpf-isel")) { dbgs() << "Check candidate load: "; LD->
dump(); dbgs() << '\n'; } } while (false)
;
282
283 SDValue OP1 = LDAddrNode->getOperand(0);
284 if (const GlobalAddressSDNode *GADN =
285 dyn_cast<GlobalAddressSDNode>(OP1.getNode()))
286 to_replace = getConstantFieldValue(GADN, 0, size, new_val.c);
287 }
288
289 if (!to_replace
39.1
'to_replace' is true
39.1
'to_replace' is true
)
40
Taking false branch
290 return;
291
292 // replacing the old with a new value
293 uint64_t val;
294 if (size == 1)
41
Assuming 'size' is equal to 1
42
Taking true branch
295 val = new_val.c[0];
43
Assigned value is garbage or undefined
296 else if (size == 2)
297 val = new_val.s;
298 else if (size == 4)
299 val = new_val.i;
300 else {
301 val = new_val.d;
302 }
303
304 LLVM_DEBUG(dbgs() << "Replacing load of size " << size << " with constant "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("bpf-isel")) { dbgs() << "Replacing load of size " <<
size << " with constant " << val << '\n'; }
} while (false)
305 << val << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("bpf-isel")) { dbgs() << "Replacing load of size " <<
size << " with constant " << val << '\n'; }
} while (false)
;
306 SDValue NVal = CurDAG->getConstant(val, DL, MVT::i64);
307
308 // After replacement, the current node is dead, we need to
309 // go backward one step to make iterator still work
310 I--;
311 SDValue From[] = {SDValue(Node, 0), SDValue(Node, 1)};
312 SDValue To[] = {NVal, NVal};
313 CurDAG->ReplaceAllUsesOfValuesWith(From, To, 2);
314 I++;
315 // It is safe to delete node now
316 CurDAG->DeleteNode(Node);
317}
318
319void BPFDAGToDAGISel::PreprocessISelDAG() {
320 // Iterate through all nodes, interested in the following case:
321 //
322 // . loads from ConstantStruct or ConstantArray of constructs
323 // which can be turns into constant itself, with this we can
324 // avoid reading from read-only section at runtime.
325 //
326 // . Removing redundant AND for intrinsic narrow loads.
327 for (SelectionDAG::allnodes_iterator I = CurDAG->allnodes_begin(),
1
Loop condition is true. Entering loop body
328 E = CurDAG->allnodes_end();
329 I != E;) {
330 SDNode *Node = &*I++;
331 unsigned Opcode = Node->getOpcode();
332 if (Opcode == ISD::LOAD)
2
Assuming 'Opcode' is equal to LOAD
3
Taking true branch
333 PreprocessLoad(Node, I);
4
Calling 'BPFDAGToDAGISel::PreprocessLoad'
334 else if (Opcode == ISD::AND)
335 PreprocessTrunc(Node, I);
336 }
337}
338
339bool BPFDAGToDAGISel::getConstantFieldValue(const GlobalAddressSDNode *Node,
340 uint64_t Offset, uint64_t Size,
341 unsigned char *ByteSeq) {
342 const GlobalVariable *V = dyn_cast<GlobalVariable>(Node->getGlobal());
21
Assuming the object is a 'GlobalVariable'
343
344 if (!V
21.1
'V' is non-null, which participates in a condition later
21.1
'V' is non-null, which participates in a condition later
|| !V->hasInitializer())
22
Calling 'GlobalVariable::hasInitializer'
25
Returning from 'GlobalVariable::hasInitializer'
26
Taking false branch
345 return false;
346
347 const Constant *Init = V->getInitializer();
348 const DataLayout &DL = CurDAG->getDataLayout();
349 val_vec_type TmpVal;
350
351 auto it = cs_vals_.find(static_cast<const void *>(Init));
352 if (it != cs_vals_.end()) {
27
Assuming the condition is false
28
Taking false branch
353 TmpVal = it->second;
354 } else {
355 uint64_t total_size = 0;
356 if (const ConstantStruct *CS
29.1
'CS' is null
29.1
'CS' is null
= dyn_cast<ConstantStruct>(Init))
29
Assuming 'Init' is not a 'ConstantStruct'
30
Taking false branch
357 total_size =
358 DL.getStructLayout(cast<StructType>(CS->getType()))->getSizeInBytes();
359 else if (const ConstantArray *CA
31.1
'CA' is non-null
31.1
'CA' is non-null
= dyn_cast<ConstantArray>(Init))
31
Assuming 'Init' is a 'ConstantArray'
32
Taking true branch
360 total_size = DL.getTypeAllocSize(CA->getType()->getElementType()) *
361 CA->getNumOperands();
362 else
363 return false;
364
365 val_vec_type Vals(total_size, 0);
366 if (fillGenericConstant(DL, Init, Vals, 0) == false)
33
Taking false branch
367 return false;
368 cs_vals_[static_cast<const void *>(Init)] = Vals;
369 TmpVal = std::move(Vals);
370 }
371
372 // test whether host endianness matches target
373 union {
374 uint8_t c[2];
375 uint16_t s;
376 } test_buf;
377 uint16_t test_val = 0x2345;
378 if (DL.isLittleEndian())
34
Taking false branch
379 support::endian::write16le(test_buf.c, test_val);
380 else
381 support::endian::write16be(test_buf.c, test_val);
382
383 bool endian_match = test_buf.s == test_val;
35
Assuming 'test_val' is not equal to field 's'
384 for (uint64_t i = Offset, j = 0; i < Offset + Size; i++, j++)
36
Assuming the condition is false
37
Loop condition is false. Execution continues on line 387
385 ByteSeq[j] = endian_match ? TmpVal[i] : TmpVal[Offset + Size - 1 - j];
386
387 return true;
38
Returning the value 1, which participates in a condition later
388}
389
390bool BPFDAGToDAGISel::fillGenericConstant(const DataLayout &DL,
391 const Constant *CV,
392 val_vec_type &Vals, uint64_t Offset) {
393 uint64_t Size = DL.getTypeAllocSize(CV->getType());
394
395 if (isa<ConstantAggregateZero>(CV) || isa<UndefValue>(CV))
396 return true; // already done
397
398 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
399 uint64_t val = CI->getZExtValue();
400 LLVM_DEBUG(dbgs() << "Byte array at offset " << Offset << " with value "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("bpf-isel")) { dbgs() << "Byte array at offset " <<
Offset << " with value " << val << '\n'; }
} while (false)
401 << val << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("bpf-isel")) { dbgs() << "Byte array at offset " <<
Offset << " with value " << val << '\n'; }
} while (false)
;
402
403 if (Size > 8 || (Size & (Size - 1)))
404 return false;
405
406 // Store based on target endian
407 for (uint64_t i = 0; i < Size; ++i) {
408 Vals[Offset + i] = DL.isLittleEndian()
409 ? ((val >> (i * 8)) & 0xFF)
410 : ((val >> ((Size - i - 1) * 8)) & 0xFF);
411 }
412 return true;
413 }
414
415 if (const ConstantDataArray *CDA = dyn_cast<ConstantDataArray>(CV))
416 return fillConstantDataArray(DL, CDA, Vals, Offset);
417
418 if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV))
419 return fillConstantArray(DL, CA, Vals, Offset);
420
421 if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV))
422 return fillConstantStruct(DL, CVS, Vals, Offset);
423
424 return false;
425}
426
427bool BPFDAGToDAGISel::fillConstantDataArray(const DataLayout &DL,
428 const ConstantDataArray *CDA,
429 val_vec_type &Vals, int Offset) {
430 for (unsigned i = 0, e = CDA->getNumElements(); i != e; ++i) {
431 if (fillGenericConstant(DL, CDA->getElementAsConstant(i), Vals, Offset) ==
432 false)
433 return false;
434 Offset += DL.getTypeAllocSize(CDA->getElementAsConstant(i)->getType());
435 }
436
437 return true;
438}
439
440bool BPFDAGToDAGISel::fillConstantArray(const DataLayout &DL,
441 const ConstantArray *CA,
442 val_vec_type &Vals, int Offset) {
443 for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i) {
444 if (fillGenericConstant(DL, CA->getOperand(i), Vals, Offset) == false)
445 return false;
446 Offset += DL.getTypeAllocSize(CA->getOperand(i)->getType());
447 }
448
449 return true;
450}
451
452bool BPFDAGToDAGISel::fillConstantStruct(const DataLayout &DL,
453 const ConstantStruct *CS,
454 val_vec_type &Vals, int Offset) {
455 const StructLayout *Layout = DL.getStructLayout(CS->getType());
456 for (unsigned i = 0, e = CS->getNumOperands(); i != e; ++i) {
457 const Constant *Field = CS->getOperand(i);
458 uint64_t SizeSoFar = Layout->getElementOffset(i);
459 if (fillGenericConstant(DL, Field, Vals, Offset + SizeSoFar) == false)
460 return false;
461 }
462 return true;
463}
464
465void BPFDAGToDAGISel::PreprocessTrunc(SDNode *Node,
466 SelectionDAG::allnodes_iterator &I) {
467 ConstantSDNode *MaskN = dyn_cast<ConstantSDNode>(Node->getOperand(1));
468 if (!MaskN)
469 return;
470
471 // The Reg operand should be a virtual register, which is defined
472 // outside the current basic block. DAG combiner has done a pretty
473 // good job in removing truncating inside a single basic block except
474 // when the Reg operand comes from bpf_load_[byte | half | word] for
475 // which the generic optimizer doesn't understand their results are
476 // zero extended.
477 SDValue BaseV = Node->getOperand(0);
478 if (BaseV.getOpcode() != ISD::INTRINSIC_W_CHAIN)
479 return;
480
481 unsigned IntNo = cast<ConstantSDNode>(BaseV->getOperand(1))->getZExtValue();
482 uint64_t MaskV = MaskN->getZExtValue();
483
484 if (!((IntNo == Intrinsic::bpf_load_byte && MaskV == 0xFF) ||
485 (IntNo == Intrinsic::bpf_load_half && MaskV == 0xFFFF) ||
486 (IntNo == Intrinsic::bpf_load_word && MaskV == 0xFFFFFFFF)))
487 return;
488
489 LLVM_DEBUG(dbgs() << "Remove the redundant AND operation in: ";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("bpf-isel")) { dbgs() << "Remove the redundant AND operation in: "
; Node->dump(); dbgs() << '\n'; } } while (false)
490 Node->dump(); dbgs() << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("bpf-isel")) { dbgs() << "Remove the redundant AND operation in: "
; Node->dump(); dbgs() << '\n'; } } while (false)
;
491
492 I--;
493 CurDAG->ReplaceAllUsesWith(SDValue(Node, 0), BaseV);
494 I++;
495 CurDAG->DeleteNode(Node);
496
497 return;
498}
499
500FunctionPass *llvm::createBPFISelDag(BPFTargetMachine &TM) {
501 return new BPFDAGToDAGISel(TM);
502}

/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/IR/GlobalVariable.h

1//===-- llvm/GlobalVariable.h - GlobalVariable class ------------*- 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// This file contains the declaration of the GlobalVariable class, which
10// represents a single global variable (or constant) in the VM.
11//
12// Global variables are constant pointers that refer to hunks of space that are
13// allocated by either the VM, or by the linker in a static compiler. A global
14// variable may have an initial value, which is copied into the executables .data
15// area. Global Constants are required to have initializers.
16//
17//===----------------------------------------------------------------------===//
18
19#ifndef LLVM_IR_GLOBALVARIABLE_H
20#define LLVM_IR_GLOBALVARIABLE_H
21
22#include "llvm/ADT/PointerUnion.h"
23#include "llvm/ADT/Twine.h"
24#include "llvm/ADT/ilist_node.h"
25#include "llvm/IR/Attributes.h"
26#include "llvm/IR/GlobalObject.h"
27#include "llvm/IR/OperandTraits.h"
28#include "llvm/IR/Value.h"
29#include <cassert>
30#include <cstddef>
31
32namespace llvm {
33
34class Constant;
35class Module;
36
37template <typename ValueSubClass> class SymbolTableListTraits;
38class DIGlobalVariable;
39class DIGlobalVariableExpression;
40
41class GlobalVariable : public GlobalObject, public ilist_node<GlobalVariable> {
42 friend class SymbolTableListTraits<GlobalVariable>;
43
44 AttributeSet Attrs;
45 bool isConstantGlobal : 1; // Is this a global constant?
46 bool isExternallyInitializedConstant : 1; // Is this a global whose value
47 // can change from its initial
48 // value before global
49 // initializers are run?
50
51public:
52 /// GlobalVariable ctor - If a parent module is specified, the global is
53 /// automatically inserted into the end of the specified modules global list.
54 GlobalVariable(Type *Ty, bool isConstant, LinkageTypes Linkage,
55 Constant *Initializer = nullptr, const Twine &Name = "",
56 ThreadLocalMode = NotThreadLocal, unsigned AddressSpace = 0,
57 bool isExternallyInitialized = false);
58 /// GlobalVariable ctor - This creates a global and inserts it before the
59 /// specified other global.
60 GlobalVariable(Module &M, Type *Ty, bool isConstant,
61 LinkageTypes Linkage, Constant *Initializer,
62 const Twine &Name = "", GlobalVariable *InsertBefore = nullptr,
63 ThreadLocalMode = NotThreadLocal, unsigned AddressSpace = 0,
64 bool isExternallyInitialized = false);
65 GlobalVariable(const GlobalVariable &) = delete;
66 GlobalVariable &operator=(const GlobalVariable &) = delete;
67
68 ~GlobalVariable() {
69 dropAllReferences();
70 }
71
72 // allocate space for exactly one operand
73 void *operator new(size_t s) {
74 return User::operator new(s, 1);
75 }
76
77 // delete space for exactly one operand as created in the corresponding new operator
78 void operator delete(void *ptr){
79 assert(ptr != nullptr && "must not be nullptr")((ptr != nullptr && "must not be nullptr") ? static_cast
<void> (0) : __assert_fail ("ptr != nullptr && \"must not be nullptr\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/IR/GlobalVariable.h"
, 79, __PRETTY_FUNCTION__))
;
80 User *Obj = static_cast<User *>(ptr);
81 // Number of operands can be set to 0 after construction and initialization. Make sure
82 // that number of operands is reset to 1, as this is needed in User::operator delete
83 Obj->setGlobalVariableNumOperands(1);
84 User::operator delete(Obj);
85 }
86
87 /// Provide fast operand accessors
88 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
setOperand(unsigned, Value*); inline op_iterator op_begin();
inline const_op_iterator op_begin() const; inline op_iterator
op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
getNumOperands() const
;
89
90 /// Definitions have initializers, declarations don't.
91 ///
92 inline bool hasInitializer() const { return !isDeclaration(); }
23
Assuming the condition is true
24
Returning the value 1, which participates in a condition later
93
94 /// hasDefinitiveInitializer - Whether the global variable has an initializer,
95 /// and any other instances of the global (this can happen due to weak
96 /// linkage) are guaranteed to have the same initializer.
97 ///
98 /// Note that if you want to transform a global, you must use
99 /// hasUniqueInitializer() instead, because of the *_odr linkage type.
100 ///
101 /// Example:
102 ///
103 /// @a = global SomeType* null - Initializer is both definitive and unique.
104 ///
105 /// @b = global weak SomeType* null - Initializer is neither definitive nor
106 /// unique.
107 ///
108 /// @c = global weak_odr SomeType* null - Initializer is definitive, but not
109 /// unique.
110 inline bool hasDefinitiveInitializer() const {
111 return hasInitializer() &&
112 // The initializer of a global variable may change to something arbitrary
113 // at link time.
114 !isInterposable() &&
115 // The initializer of a global variable with the externally_initialized
116 // marker may change at runtime before C++ initializers are evaluated.
117 !isExternallyInitialized();
118 }
119
120 /// hasUniqueInitializer - Whether the global variable has an initializer, and
121 /// any changes made to the initializer will turn up in the final executable.
122 inline bool hasUniqueInitializer() const {
123 return
124 // We need to be sure this is the definition that will actually be used
125 isStrongDefinitionForLinker() &&
126 // It is not safe to modify initializers of global variables with the
127 // external_initializer marker since the value may be changed at runtime
128 // before C++ initializers are evaluated.
129 !isExternallyInitialized();
130 }
131
132 /// getInitializer - Return the initializer for this global variable. It is
133 /// illegal to call this method if the global is external, because we cannot
134 /// tell what the value is initialized to!
135 ///
136 inline const Constant *getInitializer() const {
137 assert(hasInitializer() && "GV doesn't have initializer!")((hasInitializer() && "GV doesn't have initializer!")
? static_cast<void> (0) : __assert_fail ("hasInitializer() && \"GV doesn't have initializer!\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/IR/GlobalVariable.h"
, 137, __PRETTY_FUNCTION__))
;
138 return static_cast<Constant*>(Op<0>().get());
139 }
140 inline Constant *getInitializer() {
141 assert(hasInitializer() && "GV doesn't have initializer!")((hasInitializer() && "GV doesn't have initializer!")
? static_cast<void> (0) : __assert_fail ("hasInitializer() && \"GV doesn't have initializer!\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/IR/GlobalVariable.h"
, 141, __PRETTY_FUNCTION__))
;
142 return static_cast<Constant*>(Op<0>().get());
143 }
144 /// setInitializer - Sets the initializer for this global variable, removing
145 /// any existing initializer if InitVal==NULL. If this GV has type T*, the
146 /// initializer must have type T.
147 void setInitializer(Constant *InitVal);
148
149 /// If the value is a global constant, its value is immutable throughout the
150 /// runtime execution of the program. Assigning a value into the constant
151 /// leads to undefined behavior.
152 ///
153 bool isConstant() const { return isConstantGlobal; }
154 void setConstant(bool Val) { isConstantGlobal = Val; }
155
156 bool isExternallyInitialized() const {
157 return isExternallyInitializedConstant;
158 }
159 void setExternallyInitialized(bool Val) {
160 isExternallyInitializedConstant = Val;
161 }
162
163 /// copyAttributesFrom - copy all additional attributes (those not needed to
164 /// create a GlobalVariable) from the GlobalVariable Src to this one.
165 void copyAttributesFrom(const GlobalVariable *Src);
166
167 /// removeFromParent - This method unlinks 'this' from the containing module,
168 /// but does not delete it.
169 ///
170 void removeFromParent();
171
172 /// eraseFromParent - This method unlinks 'this' from the containing module
173 /// and deletes it.
174 ///
175 void eraseFromParent();
176
177 /// Drop all references in preparation to destroy the GlobalVariable. This
178 /// drops not only the reference to the initializer but also to any metadata.
179 void dropAllReferences();
180
181 /// Attach a DIGlobalVariableExpression.
182 void addDebugInfo(DIGlobalVariableExpression *GV);
183
184 /// Fill the vector with all debug info attachements.
185 void getDebugInfo(SmallVectorImpl<DIGlobalVariableExpression *> &GVs) const;
186
187 /// Add attribute to this global.
188 void addAttribute(Attribute::AttrKind Kind) {
189 Attrs = Attrs.addAttribute(getContext(), Kind);
190 }
191
192 /// Add attribute to this global.
193 void addAttribute(StringRef Kind, StringRef Val = StringRef()) {
194 Attrs = Attrs.addAttribute(getContext(), Kind, Val);
195 }
196
197 /// Return true if the attribute exists.
198 bool hasAttribute(Attribute::AttrKind Kind) const {
199 return Attrs.hasAttribute(Kind);
200 }
201
202 /// Return true if the attribute exists.
203 bool hasAttribute(StringRef Kind) const {
204 return Attrs.hasAttribute(Kind);
205 }
206
207 /// Return true if any attributes exist.
208 bool hasAttributes() const {
209 return Attrs.hasAttributes();
210 }
211
212 /// Return the attribute object.
213 Attribute getAttribute(Attribute::AttrKind Kind) const {
214 return Attrs.getAttribute(Kind);
215 }
216
217 /// Return the attribute object.
218 Attribute getAttribute(StringRef Kind) const {
219 return Attrs.getAttribute(Kind);
220 }
221
222 /// Return the attribute set for this global
223 AttributeSet getAttributes() const {
224 return Attrs;
225 }
226
227 /// Return attribute set as list with index.
228 /// FIXME: This may not be required once ValueEnumerators
229 /// in bitcode-writer can enumerate attribute-set.
230 AttributeList getAttributesAsList(unsigned index) const {
231 if (!hasAttributes())
232 return AttributeList();
233 std::pair<unsigned, AttributeSet> AS[1] = {{index, Attrs}};
234 return AttributeList::get(getContext(), AS);
235 }
236
237 /// Set attribute list for this global
238 void setAttributes(AttributeSet A) {
239 Attrs = A;
240 }
241
242 /// Check if section name is present
243 bool hasImplicitSection() const {
244 return getAttributes().hasAttribute("bss-section") ||
245 getAttributes().hasAttribute("data-section") ||
246 getAttributes().hasAttribute("relro-section") ||
247 getAttributes().hasAttribute("rodata-section");
248 }
249
250 // Methods for support type inquiry through isa, cast, and dyn_cast:
251 static bool classof(const Value *V) {
252 return V->getValueID() == Value::GlobalVariableVal;
253 }
254};
255
256template <>
257struct OperandTraits<GlobalVariable> :
258 public OptionalOperandTraits<GlobalVariable> {
259};
260
261DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GlobalVariable, Value)GlobalVariable::op_iterator GlobalVariable::op_begin() { return
OperandTraits<GlobalVariable>::op_begin(this); } GlobalVariable
::const_op_iterator GlobalVariable::op_begin() const { return
OperandTraits<GlobalVariable>::op_begin(const_cast<
GlobalVariable*>(this)); } GlobalVariable::op_iterator GlobalVariable
::op_end() { return OperandTraits<GlobalVariable>::op_end
(this); } GlobalVariable::const_op_iterator GlobalVariable::op_end
() const { return OperandTraits<GlobalVariable>::op_end
(const_cast<GlobalVariable*>(this)); } Value *GlobalVariable
::getOperand(unsigned i_nocapture) const { ((i_nocapture <
OperandTraits<GlobalVariable>::operands(this) &&
"getOperand() out of range!") ? static_cast<void> (0) :
__assert_fail ("i_nocapture < OperandTraits<GlobalVariable>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/IR/GlobalVariable.h"
, 261, __PRETTY_FUNCTION__)); return cast_or_null<Value>
( OperandTraits<GlobalVariable>::op_begin(const_cast<
GlobalVariable*>(this))[i_nocapture].get()); } void GlobalVariable
::setOperand(unsigned i_nocapture, Value *Val_nocapture) { ((
i_nocapture < OperandTraits<GlobalVariable>::operands
(this) && "setOperand() out of range!") ? static_cast
<void> (0) : __assert_fail ("i_nocapture < OperandTraits<GlobalVariable>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/IR/GlobalVariable.h"
, 261, __PRETTY_FUNCTION__)); OperandTraits<GlobalVariable
>::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned
GlobalVariable::getNumOperands() const { return OperandTraits
<GlobalVariable>::operands(this); } template <int Idx_nocapture
> Use &GlobalVariable::Op() { return this->OpFrom<
Idx_nocapture>(this); } template <int Idx_nocapture>
const Use &GlobalVariable::Op() const { return this->
OpFrom<Idx_nocapture>(this); }
262
263} // end namespace llvm
264
265#endif // LLVM_IR_GLOBALVARIABLE_H