Bug Summary

File:lib/Target/BPF/BPFISelDAGToDAG.cpp
Warning:line 307, 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 -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -fmath-errno -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~svn374877/build-llvm/lib/Target/BPF -I /build/llvm-toolchain-snapshot-10~svn374877/lib/Target/BPF -I /build/llvm-toolchain-snapshot-10~svn374877/build-llvm/include -I /build/llvm-toolchain-snapshot-10~svn374877/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~svn374877/build-llvm/lib/Target/BPF -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~svn374877=. -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-10-15-233810-7101-1 -x c++ /build/llvm-toolchain-snapshot-10~svn374877/lib/Target/BPF/BPFISelDAGToDAG.cpp

/build/llvm-toolchain-snapshot-10~svn374877/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 curr_func_ = nullptr;
50 }
51
52 StringRef getPassName() const override {
53 return "BPF DAG->DAG Pattern Instruction Selection";
54 }
55
56 bool runOnMachineFunction(MachineFunction &MF) override {
57 // Reset the subtarget each time through.
58 Subtarget = &MF.getSubtarget<BPFSubtarget>();
59 return SelectionDAGISel::runOnMachineFunction(MF);
60 }
61
62 void PreprocessISelDAG() override;
63
64 bool SelectInlineAsmMemoryOperand(const SDValue &Op, unsigned ConstraintCode,
65 std::vector<SDValue> &OutOps) override;
66
67
68private:
69// Include the pieces autogenerated from the target description.
70#include "BPFGenDAGISel.inc"
71
72 void Select(SDNode *N) override;
73
74 // Complex Pattern for address selection.
75 bool SelectAddr(SDValue Addr, SDValue &Base, SDValue &Offset);
76 bool SelectFIAddr(SDValue Addr, SDValue &Base, SDValue &Offset);
77
78 // Node preprocessing cases
79 void PreprocessLoad(SDNode *Node, SelectionDAG::allnodes_iterator &I);
80 void PreprocessCopyToReg(SDNode *Node);
81 void PreprocessTrunc(SDNode *Node, SelectionDAG::allnodes_iterator &I);
82
83 // Find constants from a constant structure
84 typedef std::vector<unsigned char> val_vec_type;
85 bool fillGenericConstant(const DataLayout &DL, const Constant *CV,
86 val_vec_type &Vals, uint64_t Offset);
87 bool fillConstantDataArray(const DataLayout &DL, const ConstantDataArray *CDA,
88 val_vec_type &Vals, int Offset);
89 bool fillConstantArray(const DataLayout &DL, const ConstantArray *CA,
90 val_vec_type &Vals, int Offset);
91 bool fillConstantStruct(const DataLayout &DL, const ConstantStruct *CS,
92 val_vec_type &Vals, int Offset);
93 bool getConstantFieldValue(const GlobalAddressSDNode *Node, uint64_t Offset,
94 uint64_t Size, unsigned char *ByteSeq);
95 bool checkLoadDef(unsigned DefReg, unsigned match_load_op);
96
97 // Mapping from ConstantStruct global value to corresponding byte-list values
98 std::map<const void *, val_vec_type> cs_vals_;
99 // Mapping from vreg to load memory opcode
100 std::map<unsigned, unsigned> load_to_vreg_;
101 // Current function
102 const Function *curr_func_;
103};
104} // namespace
105
106// ComplexPattern used on BPF Load/Store instructions
107bool BPFDAGToDAGISel::SelectAddr(SDValue Addr, SDValue &Base, SDValue &Offset) {
108 // if Address is FI, get the TargetFrameIndex.
109 SDLoc DL(Addr);
110 if (FrameIndexSDNode *FIN = dyn_cast<FrameIndexSDNode>(Addr)) {
111 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), MVT::i64);
112 Offset = CurDAG->getTargetConstant(0, DL, MVT::i64);
113 return true;
114 }
115
116 if (Addr.getOpcode() == ISD::TargetExternalSymbol ||
117 Addr.getOpcode() == ISD::TargetGlobalAddress)
118 return false;
119
120 // Addresses of the form Addr+const or Addr|const
121 if (CurDAG->isBaseWithConstantOffset(Addr)) {
122 ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Addr.getOperand(1));
123 if (isInt<16>(CN->getSExtValue())) {
124
125 // If the first operand is a FI, get the TargetFI Node
126 if (FrameIndexSDNode *FIN =
127 dyn_cast<FrameIndexSDNode>(Addr.getOperand(0)))
128 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), MVT::i64);
129 else
130 Base = Addr.getOperand(0);
131
132 Offset = CurDAG->getTargetConstant(CN->getSExtValue(), DL, MVT::i64);
133 return true;
134 }
135 }
136
137 Base = Addr;
138 Offset = CurDAG->getTargetConstant(0, DL, MVT::i64);
139 return true;
140}
141
142// ComplexPattern used on BPF FI instruction
143bool BPFDAGToDAGISel::SelectFIAddr(SDValue Addr, SDValue &Base,
144 SDValue &Offset) {
145 SDLoc DL(Addr);
146
147 if (!CurDAG->isBaseWithConstantOffset(Addr))
148 return false;
149
150 // Addresses of the form Addr+const or Addr|const
151 ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Addr.getOperand(1));
152 if (isInt<16>(CN->getSExtValue())) {
153
154 // If the first operand is a FI, get the TargetFI Node
155 if (FrameIndexSDNode *FIN = dyn_cast<FrameIndexSDNode>(Addr.getOperand(0)))
156 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), MVT::i64);
157 else
158 return false;
159
160 Offset = CurDAG->getTargetConstant(CN->getSExtValue(), DL, MVT::i64);
161 return true;
162 }
163
164 return false;
165}
166
167bool BPFDAGToDAGISel::SelectInlineAsmMemoryOperand(
168 const SDValue &Op, unsigned ConstraintCode, std::vector<SDValue> &OutOps) {
169 SDValue Op0, Op1;
170 switch (ConstraintCode) {
171 default:
172 return true;
173 case InlineAsm::Constraint_m: // memory
174 if (!SelectAddr(Op, Op0, Op1))
175 return true;
176 break;
177 }
178
179 SDLoc DL(Op);
180 SDValue AluOp = CurDAG->getTargetConstant(ISD::ADD, DL, MVT::i32);;
181 OutOps.push_back(Op0);
182 OutOps.push_back(Op1);
183 OutOps.push_back(AluOp);
184 return false;
185}
186
187void BPFDAGToDAGISel::Select(SDNode *Node) {
188 unsigned Opcode = Node->getOpcode();
189
190 // If we have a custom node, we already have selected!
191 if (Node->isMachineOpcode()) {
192 LLVM_DEBUG(dbgs() << "== "; Node->dump(CurDAG); dbgs() << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("bpf-isel")) { dbgs() << "== "; Node->dump(CurDAG);
dbgs() << '\n'; } } while (false)
;
193 return;
194 }
195
196 // tablegen selection should be handled here.
197 switch (Opcode) {
198 default:
199 break;
200 case ISD::SDIV: {
201 DebugLoc Empty;
202 const DebugLoc &DL = Node->getDebugLoc();
203 if (DL != Empty)
204 errs() << "Error at line " << DL.getLine() << ": ";
205 else
206 errs() << "Error: ";
207 errs() << "Unsupport signed division for DAG: ";
208 Node->print(errs(), CurDAG);
209 errs() << "Please convert to unsigned div/mod.\n";
210 break;
211 }
212 case ISD::INTRINSIC_W_CHAIN: {
213 unsigned IntNo = cast<ConstantSDNode>(Node->getOperand(1))->getZExtValue();
214 switch (IntNo) {
215 case Intrinsic::bpf_load_byte:
216 case Intrinsic::bpf_load_half:
217 case Intrinsic::bpf_load_word: {
218 SDLoc DL(Node);
219 SDValue Chain = Node->getOperand(0);
220 SDValue N1 = Node->getOperand(1);
221 SDValue Skb = Node->getOperand(2);
222 SDValue N3 = Node->getOperand(3);
223
224 SDValue R6Reg = CurDAG->getRegister(BPF::R6, MVT::i64);
225 Chain = CurDAG->getCopyToReg(Chain, DL, R6Reg, Skb, SDValue());
226 Node = CurDAG->UpdateNodeOperands(Node, Chain, N1, R6Reg, N3);
227 break;
228 }
229 }
230 break;
231 }
232
233 case ISD::FrameIndex: {
234 int FI = cast<FrameIndexSDNode>(Node)->getIndex();
235 EVT VT = Node->getValueType(0);
236 SDValue TFI = CurDAG->getTargetFrameIndex(FI, VT);
237 unsigned Opc = BPF::MOV_rr;
238 if (Node->hasOneUse()) {
239 CurDAG->SelectNodeTo(Node, Opc, VT, TFI);
240 return;
241 }
242 ReplaceNode(Node, CurDAG->getMachineNode(Opc, SDLoc(Node), VT, TFI));
243 return;
244 }
245 }
246
247 // Select the default instruction
248 SelectCode(Node);
249}
250
251void BPFDAGToDAGISel::PreprocessLoad(SDNode *Node,
252 SelectionDAG::allnodes_iterator &I) {
253 union {
254 uint8_t c[8];
255 uint16_t s;
256 uint32_t i;
257 uint64_t d;
258 } new_val; // hold up the constant values replacing loads.
259 bool to_replace = false;
260 SDLoc DL(Node);
261 const LoadSDNode *LD = cast<LoadSDNode>(Node);
9
'Node' is a 'LoadSDNode'
262 uint64_t size = LD->getMemOperand()->getSize();
263
264 if (!size || size > 8 || (size & (size - 1)))
10
Assuming 'size' is not equal to 0
11
Assuming 'size' is <= 8
12
Assuming the condition is false
13
Taking false branch
265 return;
266
267 SDNode *LDAddrNode = LD->getOperand(1).getNode();
268 // Match LDAddr against either global_addr or (global_addr + offset)
269 unsigned opcode = LDAddrNode->getOpcode();
270 if (opcode == ISD::ADD) {
14
Assuming 'opcode' is equal to ADD
15
Taking true branch
271 SDValue OP1 = LDAddrNode->getOperand(0);
272 SDValue OP2 = LDAddrNode->getOperand(1);
273
274 // We want to find the pattern global_addr + offset
275 SDNode *OP1N = OP1.getNode();
276 if (OP1N->getOpcode() <= ISD::BUILTIN_OP_END || OP1N->getNumOperands() == 0)
16
Assuming the condition is false
17
Assuming the condition is false
18
Taking false branch
277 return;
278
279 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)
;
19
Assuming 'DebugFlag' is false
20
Loop condition is false. Exiting loop
280
281 const GlobalAddressSDNode *GADN =
282 dyn_cast<GlobalAddressSDNode>(OP1N->getOperand(0).getNode());
21
Assuming the object is a 'GlobalAddressSDNode'
283 const ConstantSDNode *CDN = dyn_cast<ConstantSDNode>(OP2.getNode());
22
Assuming the object is a 'ConstantSDNode'
284 if (GADN
22.1
'GADN' is non-null
22.1
'GADN' is non-null
&& CDN
22.2
'CDN' is non-null
22.2
'CDN' is non-null
)
23
Taking true branch
285 to_replace =
286 getConstantFieldValue(GADN, CDN->getZExtValue(), size, new_val.c);
24
Calling 'BPFDAGToDAGISel::getConstantFieldValue'
43
Returning from 'BPFDAGToDAGISel::getConstantFieldValue'
287 } else if (LDAddrNode->getOpcode() > ISD::BUILTIN_OP_END &&
288 LDAddrNode->getNumOperands() > 0) {
289 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)
;
290
291 SDValue OP1 = LDAddrNode->getOperand(0);
292 if (const GlobalAddressSDNode *GADN =
293 dyn_cast<GlobalAddressSDNode>(OP1.getNode()))
294 to_replace = getConstantFieldValue(GADN, 0, size, new_val.c);
295 }
296
297 if (!to_replace
43.1
'to_replace' is true
43.1
'to_replace' is true
)
44
Taking false branch
298 return;
299
300 // replacing the old with a new value
301 uint64_t val;
302 if (size == 1)
45
Assuming 'size' is not equal to 1
46
Taking false branch
303 val = new_val.c[0];
304 else if (size == 2)
47
Assuming 'size' is not equal to 2
48
Taking false branch
305 val = new_val.s;
306 else if (size == 4)
49
Assuming 'size' is equal to 4
50
Taking true branch
307 val = new_val.i;
51
Assigned value is garbage or undefined
308 else {
309 val = new_val.d;
310 }
311
312 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)
313 << val << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("bpf-isel")) { dbgs() << "Replacing load of size " <<
size << " with constant " << val << '\n'; }
} while (false)
;
314 SDValue NVal = CurDAG->getConstant(val, DL, MVT::i64);
315
316 // After replacement, the current node is dead, we need to
317 // go backward one step to make iterator still work
318 I--;
319 SDValue From[] = {SDValue(Node, 0), SDValue(Node, 1)};
320 SDValue To[] = {NVal, NVal};
321 CurDAG->ReplaceAllUsesOfValuesWith(From, To, 2);
322 I++;
323 // It is safe to delete node now
324 CurDAG->DeleteNode(Node);
325}
326
327void BPFDAGToDAGISel::PreprocessISelDAG() {
328 // Iterate through all nodes, interested in the following cases:
329 //
330 // . loads from ConstantStruct or ConstantArray of constructs
331 // which can be turns into constant itself, with this we can
332 // avoid reading from read-only section at runtime.
333 //
334 // . reg truncating is often the result of 8/16/32bit->64bit or
335 // 8/16bit->32bit conversion. If the reg value is loaded with
336 // masked byte width, the AND operation can be removed since
337 // BPF LOAD already has zero extension.
338 //
339 // This also solved a correctness issue.
340 // In BPF socket-related program, e.g., __sk_buff->{data, data_end}
341 // are 32-bit registers, but later on, kernel verifier will rewrite
342 // it with 64-bit value. Therefore, truncating the value after the
343 // load will result in incorrect code.
344
345 // clear the load_to_vreg_ map so that we have a clean start
346 // for this function.
347 if (!curr_func_) {
1
Assuming field 'curr_func_' is non-null
2
Taking false branch
348 curr_func_ = FuncInfo->Fn;
349 } else if (curr_func_ != FuncInfo->Fn) {
3
Assuming field 'curr_func_' is equal to field 'Fn'
4
Taking false branch
350 load_to_vreg_.clear();
351 curr_func_ = FuncInfo->Fn;
352 }
353
354 for (SelectionDAG::allnodes_iterator I = CurDAG->allnodes_begin(),
5
Loop condition is true. Entering loop body
355 E = CurDAG->allnodes_end();
356 I != E;) {
357 SDNode *Node = &*I++;
358 unsigned Opcode = Node->getOpcode();
359 if (Opcode == ISD::LOAD)
6
Assuming 'Opcode' is equal to LOAD
7
Taking true branch
360 PreprocessLoad(Node, I);
8
Calling 'BPFDAGToDAGISel::PreprocessLoad'
361 else if (Opcode == ISD::CopyToReg)
362 PreprocessCopyToReg(Node);
363 else if (Opcode == ISD::AND)
364 PreprocessTrunc(Node, I);
365 }
366}
367
368bool BPFDAGToDAGISel::getConstantFieldValue(const GlobalAddressSDNode *Node,
369 uint64_t Offset, uint64_t Size,
370 unsigned char *ByteSeq) {
371 const GlobalVariable *V = dyn_cast<GlobalVariable>(Node->getGlobal());
25
Assuming the object is a 'GlobalVariable'
372
373 if (!V
25.1
'V' is non-null, which participates in a condition later
25.1
'V' is non-null, which participates in a condition later
|| !V->hasInitializer())
26
Calling 'GlobalVariable::hasInitializer'
29
Returning from 'GlobalVariable::hasInitializer'
30
Taking false branch
374 return false;
375
376 const Constant *Init = V->getInitializer();
377 const DataLayout &DL = CurDAG->getDataLayout();
378 val_vec_type TmpVal;
379
380 auto it = cs_vals_.find(static_cast<const void *>(Init));
381 if (it != cs_vals_.end()) {
31
Assuming the condition is false
32
Taking false branch
382 TmpVal = it->second;
383 } else {
384 uint64_t total_size = 0;
385 if (const ConstantStruct *CS
33.1
'CS' is null
33.1
'CS' is null
= dyn_cast<ConstantStruct>(Init))
33
Assuming 'Init' is not a 'ConstantStruct'
34
Taking false branch
386 total_size =
387 DL.getStructLayout(cast<StructType>(CS->getType()))->getSizeInBytes();
388 else if (const ConstantArray *CA
35.1
'CA' is non-null
35.1
'CA' is non-null
= dyn_cast<ConstantArray>(Init))
35
Assuming 'Init' is a 'ConstantArray'
36
Taking true branch
389 total_size = DL.getTypeAllocSize(CA->getType()->getElementType()) *
390 CA->getNumOperands();
391 else
392 return false;
393
394 val_vec_type Vals(total_size, 0);
395 if (fillGenericConstant(DL, Init, Vals, 0) == false)
37
Taking false branch
396 return false;
397 cs_vals_[static_cast<const void *>(Init)] = Vals;
398 TmpVal = std::move(Vals);
399 }
400
401 // test whether host endianness matches target
402 union {
403 uint8_t c[2];
404 uint16_t s;
405 } test_buf;
406 uint16_t test_val = 0x2345;
407 if (DL.isLittleEndian())
38
Taking false branch
408 support::endian::write16le(test_buf.c, test_val);
409 else
410 support::endian::write16be(test_buf.c, test_val);
411
412 bool endian_match = test_buf.s == test_val;
39
Assuming 'test_val' is not equal to field 's'
413 for (uint64_t i = Offset, j = 0; i < Offset + Size; i++, j++)
40
Assuming the condition is false
41
Loop condition is false. Execution continues on line 416
414 ByteSeq[j] = endian_match ? TmpVal[i] : TmpVal[Offset + Size - 1 - j];
415
416 return true;
42
Returning the value 1, which participates in a condition later
417}
418
419bool BPFDAGToDAGISel::fillGenericConstant(const DataLayout &DL,
420 const Constant *CV,
421 val_vec_type &Vals, uint64_t Offset) {
422 uint64_t Size = DL.getTypeAllocSize(CV->getType());
423
424 if (isa<ConstantAggregateZero>(CV) || isa<UndefValue>(CV))
425 return true; // already done
426
427 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
428 uint64_t val = CI->getZExtValue();
429 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)
430 << val << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("bpf-isel")) { dbgs() << "Byte array at offset " <<
Offset << " with value " << val << '\n'; }
} while (false)
;
431
432 if (Size > 8 || (Size & (Size - 1)))
433 return false;
434
435 // Store based on target endian
436 for (uint64_t i = 0; i < Size; ++i) {
437 Vals[Offset + i] = DL.isLittleEndian()
438 ? ((val >> (i * 8)) & 0xFF)
439 : ((val >> ((Size - i - 1) * 8)) & 0xFF);
440 }
441 return true;
442 }
443
444 if (const ConstantDataArray *CDA = dyn_cast<ConstantDataArray>(CV))
445 return fillConstantDataArray(DL, CDA, Vals, Offset);
446
447 if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV))
448 return fillConstantArray(DL, CA, Vals, Offset);
449
450 if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV))
451 return fillConstantStruct(DL, CVS, Vals, Offset);
452
453 return false;
454}
455
456bool BPFDAGToDAGISel::fillConstantDataArray(const DataLayout &DL,
457 const ConstantDataArray *CDA,
458 val_vec_type &Vals, int Offset) {
459 for (unsigned i = 0, e = CDA->getNumElements(); i != e; ++i) {
460 if (fillGenericConstant(DL, CDA->getElementAsConstant(i), Vals, Offset) ==
461 false)
462 return false;
463 Offset += DL.getTypeAllocSize(CDA->getElementAsConstant(i)->getType());
464 }
465
466 return true;
467}
468
469bool BPFDAGToDAGISel::fillConstantArray(const DataLayout &DL,
470 const ConstantArray *CA,
471 val_vec_type &Vals, int Offset) {
472 for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i) {
473 if (fillGenericConstant(DL, CA->getOperand(i), Vals, Offset) == false)
474 return false;
475 Offset += DL.getTypeAllocSize(CA->getOperand(i)->getType());
476 }
477
478 return true;
479}
480
481bool BPFDAGToDAGISel::fillConstantStruct(const DataLayout &DL,
482 const ConstantStruct *CS,
483 val_vec_type &Vals, int Offset) {
484 const StructLayout *Layout = DL.getStructLayout(CS->getType());
485 for (unsigned i = 0, e = CS->getNumOperands(); i != e; ++i) {
486 const Constant *Field = CS->getOperand(i);
487 uint64_t SizeSoFar = Layout->getElementOffset(i);
488 if (fillGenericConstant(DL, Field, Vals, Offset + SizeSoFar) == false)
489 return false;
490 }
491 return true;
492}
493
494void BPFDAGToDAGISel::PreprocessCopyToReg(SDNode *Node) {
495 const RegisterSDNode *RegN = dyn_cast<RegisterSDNode>(Node->getOperand(1));
496 if (!RegN || !Register::isVirtualRegister(RegN->getReg()))
497 return;
498
499 const LoadSDNode *LD = dyn_cast<LoadSDNode>(Node->getOperand(2));
500 if (!LD)
501 return;
502
503 // Assign a load value to a virtual register. record its load width
504 unsigned mem_load_op = 0;
505 switch (LD->getMemOperand()->getSize()) {
506 default:
507 return;
508 case 4:
509 mem_load_op = BPF::LDW;
510 break;
511 case 2:
512 mem_load_op = BPF::LDH;
513 break;
514 case 1:
515 mem_load_op = BPF::LDB;
516 break;
517 }
518
519 LLVM_DEBUG(dbgs() << "Find Load Value to VReg "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("bpf-isel")) { dbgs() << "Find Load Value to VReg " <<
Register::virtReg2Index(RegN->getReg()) << '\n'; } }
while (false)
520 << Register::virtReg2Index(RegN->getReg()) << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("bpf-isel")) { dbgs() << "Find Load Value to VReg " <<
Register::virtReg2Index(RegN->getReg()) << '\n'; } }
while (false)
;
521 load_to_vreg_[RegN->getReg()] = mem_load_op;
522}
523
524void BPFDAGToDAGISel::PreprocessTrunc(SDNode *Node,
525 SelectionDAG::allnodes_iterator &I) {
526 ConstantSDNode *MaskN = dyn_cast<ConstantSDNode>(Node->getOperand(1));
527 if (!MaskN)
528 return;
529
530 // The Reg operand should be a virtual register, which is defined
531 // outside the current basic block. DAG combiner has done a pretty
532 // good job in removing truncating inside a single basic block except
533 // when the Reg operand comes from bpf_load_[byte | half | word] for
534 // which the generic optimizer doesn't understand their results are
535 // zero extended.
536 SDValue BaseV = Node->getOperand(0);
537 if (BaseV.getOpcode() == ISD::INTRINSIC_W_CHAIN) {
538 unsigned IntNo = cast<ConstantSDNode>(BaseV->getOperand(1))->getZExtValue();
539 uint64_t MaskV = MaskN->getZExtValue();
540
541 if (!((IntNo == Intrinsic::bpf_load_byte && MaskV == 0xFF) ||
542 (IntNo == Intrinsic::bpf_load_half && MaskV == 0xFFFF) ||
543 (IntNo == Intrinsic::bpf_load_word && MaskV == 0xFFFFFFFF)))
544 return;
545
546 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)
547 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)
;
548
549 I--;
550 CurDAG->ReplaceAllUsesWith(SDValue(Node, 0), BaseV);
551 I++;
552 CurDAG->DeleteNode(Node);
553
554 return;
555 }
556
557 // Multiple basic blocks case.
558 if (BaseV.getOpcode() != ISD::CopyFromReg)
559 return;
560
561 unsigned match_load_op = 0;
562 switch (MaskN->getZExtValue()) {
563 default:
564 return;
565 case 0xFFFFFFFF:
566 match_load_op = BPF::LDW;
567 break;
568 case 0xFFFF:
569 match_load_op = BPF::LDH;
570 break;
571 case 0xFF:
572 match_load_op = BPF::LDB;
573 break;
574 }
575
576 const RegisterSDNode *RegN =
577 dyn_cast<RegisterSDNode>(BaseV.getNode()->getOperand(1));
578 if (!RegN || !Register::isVirtualRegister(RegN->getReg()))
579 return;
580 unsigned AndOpReg = RegN->getReg();
581 LLVM_DEBUG(dbgs() << "Examine " << printReg(AndOpReg) << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("bpf-isel")) { dbgs() << "Examine " << printReg(
AndOpReg) << '\n'; } } while (false)
;
582
583 // Examine the PHI insns in the MachineBasicBlock to found out the
584 // definitions of this virtual register. At this stage (DAG2DAG
585 // transformation), only PHI machine insns are available in the machine basic
586 // block.
587 MachineBasicBlock *MBB = FuncInfo->MBB;
588 MachineInstr *MII = nullptr;
589 for (auto &MI : *MBB) {
590 for (unsigned i = 0; i < MI.getNumOperands(); ++i) {
591 const MachineOperand &MOP = MI.getOperand(i);
592 if (!MOP.isReg() || !MOP.isDef())
593 continue;
594 Register Reg = MOP.getReg();
595 if (Register::isVirtualRegister(Reg) && Reg == AndOpReg) {
596 MII = &MI;
597 break;
598 }
599 }
600 }
601
602 if (MII == nullptr) {
603 // No phi definition in this block.
604 if (!checkLoadDef(AndOpReg, match_load_op))
605 return;
606 } else {
607 // The PHI node looks like:
608 // %2 = PHI %0, <%bb.1>, %1, <%bb.3>
609 // Trace each incoming definition, e.g., (%0, %bb.1) and (%1, %bb.3)
610 // The AND operation can be removed if both %0 in %bb.1 and %1 in
611 // %bb.3 are defined with a load matching the MaskN.
612 LLVM_DEBUG(dbgs() << "Check PHI Insn: "; MII->dump(); dbgs() << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("bpf-isel")) { dbgs() << "Check PHI Insn: "; MII->dump
(); dbgs() << '\n'; } } while (false)
;
613 unsigned PrevReg = -1;
614 for (unsigned i = 0; i < MII->getNumOperands(); ++i) {
615 const MachineOperand &MOP = MII->getOperand(i);
616 if (MOP.isReg()) {
617 if (MOP.isDef())
618 continue;
619 PrevReg = MOP.getReg();
620 if (!Register::isVirtualRegister(PrevReg))
621 return;
622 if (!checkLoadDef(PrevReg, match_load_op))
623 return;
624 }
625 }
626 }
627
628 LLVM_DEBUG(dbgs() << "Remove the redundant AND operation in: "; Node->dump();do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("bpf-isel")) { dbgs() << "Remove the redundant AND operation in: "
; Node->dump(); dbgs() << '\n'; } } while (false)
629 dbgs() << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("bpf-isel")) { dbgs() << "Remove the redundant AND operation in: "
; Node->dump(); dbgs() << '\n'; } } while (false)
;
630
631 I--;
632 CurDAG->ReplaceAllUsesWith(SDValue(Node, 0), BaseV);
633 I++;
634 CurDAG->DeleteNode(Node);
635}
636
637bool BPFDAGToDAGISel::checkLoadDef(unsigned DefReg, unsigned match_load_op) {
638 auto it = load_to_vreg_.find(DefReg);
639 if (it == load_to_vreg_.end())
640 return false; // The definition of register is not exported yet.
641
642 return it->second == match_load_op;
643}
644
645FunctionPass *llvm::createBPFISelDag(BPFTargetMachine &TM) {
646 return new BPFDAGToDAGISel(TM);
647}

/build/llvm-toolchain-snapshot-10~svn374877/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~svn374877/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(); }
27
Assuming the condition is true
28
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~svn374877/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~svn374877/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("rodata-section");
247 }
248
249 // Methods for support type inquiry through isa, cast, and dyn_cast:
250 static bool classof(const Value *V) {
251 return V->getValueID() == Value::GlobalVariableVal;
252 }
253};
254
255template <>
256struct OperandTraits<GlobalVariable> :
257 public OptionalOperandTraits<GlobalVariable> {
258};
259
260DEFINE_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~svn374877/include/llvm/IR/GlobalVariable.h"
, 260, __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~svn374877/include/llvm/IR/GlobalVariable.h"
, 260, __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); }
261
262} // end namespace llvm
263
264#endif // LLVM_IR_GLOBALVARIABLE_H