Bug Summary

File:lib/CodeGen/MIRParser/MIParser.cpp
Warning:line 1614, column 15
The left operand of '>' is a garbage value

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 MIParser.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -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 -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/lib/CodeGen/MIRParser -I /build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn326246/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.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++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/lib/CodeGen/MIRParser -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-02-28-041547-14988-1 -x c++ /build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp

/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp

1//===- MIParser.cpp - Machine instructions parser implementation ----------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the parsing of machine instructions.
11//
12//===----------------------------------------------------------------------===//
13
14#include "MIParser.h"
15#include "MILexer.h"
16#include "llvm/ADT/APInt.h"
17#include "llvm/ADT/APSInt.h"
18#include "llvm/ADT/ArrayRef.h"
19#include "llvm/ADT/DenseMap.h"
20#include "llvm/ADT/None.h"
21#include "llvm/ADT/Optional.h"
22#include "llvm/ADT/SmallVector.h"
23#include "llvm/ADT/StringMap.h"
24#include "llvm/ADT/StringRef.h"
25#include "llvm/ADT/StringSwitch.h"
26#include "llvm/ADT/Twine.h"
27#include "llvm/AsmParser/Parser.h"
28#include "llvm/AsmParser/SlotMapping.h"
29#include "llvm/CodeGen/MIRPrinter.h"
30#include "llvm/CodeGen/MachineBasicBlock.h"
31#include "llvm/CodeGen/MachineFrameInfo.h"
32#include "llvm/CodeGen/MachineFunction.h"
33#include "llvm/CodeGen/MachineInstr.h"
34#include "llvm/CodeGen/MachineInstrBuilder.h"
35#include "llvm/CodeGen/MachineMemOperand.h"
36#include "llvm/CodeGen/MachineOperand.h"
37#include "llvm/CodeGen/MachineRegisterInfo.h"
38#include "llvm/CodeGen/TargetInstrInfo.h"
39#include "llvm/CodeGen/TargetRegisterInfo.h"
40#include "llvm/CodeGen/TargetSubtargetInfo.h"
41#include "llvm/IR/BasicBlock.h"
42#include "llvm/IR/Constants.h"
43#include "llvm/IR/DataLayout.h"
44#include "llvm/IR/DebugInfoMetadata.h"
45#include "llvm/IR/DebugLoc.h"
46#include "llvm/IR/Function.h"
47#include "llvm/IR/InstrTypes.h"
48#include "llvm/IR/Instructions.h"
49#include "llvm/IR/Intrinsics.h"
50#include "llvm/IR/Metadata.h"
51#include "llvm/IR/Module.h"
52#include "llvm/IR/ModuleSlotTracker.h"
53#include "llvm/IR/Type.h"
54#include "llvm/IR/Value.h"
55#include "llvm/IR/ValueSymbolTable.h"
56#include "llvm/MC/LaneBitmask.h"
57#include "llvm/MC/MCDwarf.h"
58#include "llvm/MC/MCInstrDesc.h"
59#include "llvm/MC/MCRegisterInfo.h"
60#include "llvm/Support/AtomicOrdering.h"
61#include "llvm/Support/BranchProbability.h"
62#include "llvm/Support/Casting.h"
63#include "llvm/Support/ErrorHandling.h"
64#include "llvm/Support/LowLevelTypeImpl.h"
65#include "llvm/Support/MemoryBuffer.h"
66#include "llvm/Support/SMLoc.h"
67#include "llvm/Support/SourceMgr.h"
68#include "llvm/Support/raw_ostream.h"
69#include "llvm/Target/TargetIntrinsicInfo.h"
70#include "llvm/Target/TargetMachine.h"
71#include <algorithm>
72#include <cassert>
73#include <cctype>
74#include <cstddef>
75#include <cstdint>
76#include <limits>
77#include <string>
78#include <utility>
79
80using namespace llvm;
81
82PerFunctionMIParsingState::PerFunctionMIParsingState(MachineFunction &MF,
83 SourceMgr &SM, const SlotMapping &IRSlots,
84 const Name2RegClassMap &Names2RegClasses,
85 const Name2RegBankMap &Names2RegBanks)
86 : MF(MF), SM(&SM), IRSlots(IRSlots), Names2RegClasses(Names2RegClasses),
87 Names2RegBanks(Names2RegBanks) {
88}
89
90VRegInfo &PerFunctionMIParsingState::getVRegInfo(unsigned Num) {
91 auto I = VRegInfos.insert(std::make_pair(Num, nullptr));
92 if (I.second) {
93 MachineRegisterInfo &MRI = MF.getRegInfo();
94 VRegInfo *Info = new (Allocator) VRegInfo;
95 Info->VReg = MRI.createIncompleteVirtualRegister();
96 I.first->second = Info;
97 }
98 return *I.first->second;
99}
100
101namespace {
102
103/// A wrapper struct around the 'MachineOperand' struct that includes a source
104/// range and other attributes.
105struct ParsedMachineOperand {
106 MachineOperand Operand;
107 StringRef::iterator Begin;
108 StringRef::iterator End;
109 Optional<unsigned> TiedDefIdx;
110
111 ParsedMachineOperand(const MachineOperand &Operand, StringRef::iterator Begin,
112 StringRef::iterator End, Optional<unsigned> &TiedDefIdx)
113 : Operand(Operand), Begin(Begin), End(End), TiedDefIdx(TiedDefIdx) {
114 if (TiedDefIdx)
115 assert(Operand.isReg() && Operand.isUse() &&(static_cast <bool> (Operand.isReg() && Operand
.isUse() && "Only used register operands can be tied"
) ? void (0) : __assert_fail ("Operand.isReg() && Operand.isUse() && \"Only used register operands can be tied\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 116, __extension__ __PRETTY_FUNCTION__))
116 "Only used register operands can be tied")(static_cast <bool> (Operand.isReg() && Operand
.isUse() && "Only used register operands can be tied"
) ? void (0) : __assert_fail ("Operand.isReg() && Operand.isUse() && \"Only used register operands can be tied\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 116, __extension__ __PRETTY_FUNCTION__))
;
117 }
118};
119
120class MIParser {
121 MachineFunction &MF;
122 SMDiagnostic &Error;
123 StringRef Source, CurrentSource;
124 MIToken Token;
125 PerFunctionMIParsingState &PFS;
126 /// Maps from instruction names to op codes.
127 StringMap<unsigned> Names2InstrOpCodes;
128 /// Maps from register names to registers.
129 StringMap<unsigned> Names2Regs;
130 /// Maps from register mask names to register masks.
131 StringMap<const uint32_t *> Names2RegMasks;
132 /// Maps from subregister names to subregister indices.
133 StringMap<unsigned> Names2SubRegIndices;
134 /// Maps from slot numbers to function's unnamed basic blocks.
135 DenseMap<unsigned, const BasicBlock *> Slots2BasicBlocks;
136 /// Maps from slot numbers to function's unnamed values.
137 DenseMap<unsigned, const Value *> Slots2Values;
138 /// Maps from target index names to target indices.
139 StringMap<int> Names2TargetIndices;
140 /// Maps from direct target flag names to the direct target flag values.
141 StringMap<unsigned> Names2DirectTargetFlags;
142 /// Maps from direct target flag names to the bitmask target flag values.
143 StringMap<unsigned> Names2BitmaskTargetFlags;
144 /// Maps from MMO target flag names to MMO target flag values.
145 StringMap<MachineMemOperand::Flags> Names2MMOTargetFlags;
146
147public:
148 MIParser(PerFunctionMIParsingState &PFS, SMDiagnostic &Error,
149 StringRef Source);
150
151 /// \p SkipChar gives the number of characters to skip before looking
152 /// for the next token.
153 void lex(unsigned SkipChar = 0);
154
155 /// Report an error at the current location with the given message.
156 ///
157 /// This function always return true.
158 bool error(const Twine &Msg);
159
160 /// Report an error at the given location with the given message.
161 ///
162 /// This function always return true.
163 bool error(StringRef::iterator Loc, const Twine &Msg);
164
165 bool
166 parseBasicBlockDefinitions(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
167 bool parseBasicBlocks();
168 bool parse(MachineInstr *&MI);
169 bool parseStandaloneMBB(MachineBasicBlock *&MBB);
170 bool parseStandaloneNamedRegister(unsigned &Reg);
171 bool parseStandaloneVirtualRegister(VRegInfo *&Info);
172 bool parseStandaloneRegister(unsigned &Reg);
173 bool parseStandaloneStackObject(int &FI);
174 bool parseStandaloneMDNode(MDNode *&Node);
175
176 bool
177 parseBasicBlockDefinition(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
178 bool parseBasicBlock(MachineBasicBlock &MBB,
179 MachineBasicBlock *&AddFalthroughFrom);
180 bool parseBasicBlockLiveins(MachineBasicBlock &MBB);
181 bool parseBasicBlockSuccessors(MachineBasicBlock &MBB);
182
183 bool parseNamedRegister(unsigned &Reg);
184 bool parseVirtualRegister(VRegInfo *&Info);
185 bool parseRegister(unsigned &Reg, VRegInfo *&VRegInfo);
186 bool parseRegisterFlag(unsigned &Flags);
187 bool parseRegisterClassOrBank(VRegInfo &RegInfo);
188 bool parseSubRegisterIndex(unsigned &SubReg);
189 bool parseRegisterTiedDefIndex(unsigned &TiedDefIdx);
190 bool parseRegisterOperand(MachineOperand &Dest,
191 Optional<unsigned> &TiedDefIdx, bool IsDef = false);
192 bool parseImmediateOperand(MachineOperand &Dest);
193 bool parseIRConstant(StringRef::iterator Loc, StringRef Source,
194 const Constant *&C);
195 bool parseIRConstant(StringRef::iterator Loc, const Constant *&C);
196 bool parseLowLevelType(StringRef::iterator Loc, LLT &Ty);
197 bool parseTypedImmediateOperand(MachineOperand &Dest);
198 bool parseFPImmediateOperand(MachineOperand &Dest);
199 bool parseMBBReference(MachineBasicBlock *&MBB);
200 bool parseMBBOperand(MachineOperand &Dest);
201 bool parseStackFrameIndex(int &FI);
202 bool parseStackObjectOperand(MachineOperand &Dest);
203 bool parseFixedStackFrameIndex(int &FI);
204 bool parseFixedStackObjectOperand(MachineOperand &Dest);
205 bool parseGlobalValue(GlobalValue *&GV);
206 bool parseGlobalAddressOperand(MachineOperand &Dest);
207 bool parseConstantPoolIndexOperand(MachineOperand &Dest);
208 bool parseSubRegisterIndexOperand(MachineOperand &Dest);
209 bool parseJumpTableIndexOperand(MachineOperand &Dest);
210 bool parseExternalSymbolOperand(MachineOperand &Dest);
211 bool parseMDNode(MDNode *&Node);
212 bool parseDIExpression(MDNode *&Node);
213 bool parseMetadataOperand(MachineOperand &Dest);
214 bool parseCFIOffset(int &Offset);
215 bool parseCFIRegister(unsigned &Reg);
216 bool parseCFIEscapeValues(std::string& Values);
217 bool parseCFIOperand(MachineOperand &Dest);
218 bool parseIRBlock(BasicBlock *&BB, const Function &F);
219 bool parseBlockAddressOperand(MachineOperand &Dest);
220 bool parseIntrinsicOperand(MachineOperand &Dest);
221 bool parsePredicateOperand(MachineOperand &Dest);
222 bool parseTargetIndexOperand(MachineOperand &Dest);
223 bool parseCustomRegisterMaskOperand(MachineOperand &Dest);
224 bool parseLiveoutRegisterMaskOperand(MachineOperand &Dest);
225 bool parseMachineOperand(MachineOperand &Dest,
226 Optional<unsigned> &TiedDefIdx);
227 bool parseMachineOperandAndTargetFlags(MachineOperand &Dest,
228 Optional<unsigned> &TiedDefIdx);
229 bool parseOffset(int64_t &Offset);
230 bool parseAlignment(unsigned &Alignment);
231 bool parseAddrspace(unsigned &Addrspace);
232 bool parseOperandsOffset(MachineOperand &Op);
233 bool parseIRValue(const Value *&V);
234 bool parseMemoryOperandFlag(MachineMemOperand::Flags &Flags);
235 bool parseMemoryPseudoSourceValue(const PseudoSourceValue *&PSV);
236 bool parseMachinePointerInfo(MachinePointerInfo &Dest);
237 bool parseOptionalScope(LLVMContext &Context, SyncScope::ID &SSID);
238 bool parseOptionalAtomicOrdering(AtomicOrdering &Order);
239 bool parseMachineMemoryOperand(MachineMemOperand *&Dest);
240
241private:
242 /// Convert the integer literal in the current token into an unsigned integer.
243 ///
244 /// Return true if an error occurred.
245 bool getUnsigned(unsigned &Result);
246
247 /// Convert the integer literal in the current token into an uint64.
248 ///
249 /// Return true if an error occurred.
250 bool getUint64(uint64_t &Result);
251
252 /// Convert the hexadecimal literal in the current token into an unsigned
253 /// APInt with a minimum bitwidth required to represent the value.
254 ///
255 /// Return true if the literal does not represent an integer value.
256 bool getHexUint(APInt &Result);
257
258 /// If the current token is of the given kind, consume it and return false.
259 /// Otherwise report an error and return true.
260 bool expectAndConsume(MIToken::TokenKind TokenKind);
261
262 /// If the current token is of the given kind, consume it and return true.
263 /// Otherwise return false.
264 bool consumeIfPresent(MIToken::TokenKind TokenKind);
265
266 void initNames2InstrOpCodes();
267
268 /// Try to convert an instruction name to an opcode. Return true if the
269 /// instruction name is invalid.
270 bool parseInstrName(StringRef InstrName, unsigned &OpCode);
271
272 bool parseInstruction(unsigned &OpCode, unsigned &Flags);
273
274 bool assignRegisterTies(MachineInstr &MI,
275 ArrayRef<ParsedMachineOperand> Operands);
276
277 bool verifyImplicitOperands(ArrayRef<ParsedMachineOperand> Operands,
278 const MCInstrDesc &MCID);
279
280 void initNames2Regs();
281
282 /// Try to convert a register name to a register number. Return true if the
283 /// register name is invalid.
284 bool getRegisterByName(StringRef RegName, unsigned &Reg);
285
286 void initNames2RegMasks();
287
288 /// Check if the given identifier is a name of a register mask.
289 ///
290 /// Return null if the identifier isn't a register mask.
291 const uint32_t *getRegMask(StringRef Identifier);
292
293 void initNames2SubRegIndices();
294
295 /// Check if the given identifier is a name of a subregister index.
296 ///
297 /// Return 0 if the name isn't a subregister index class.
298 unsigned getSubRegIndex(StringRef Name);
299
300 const BasicBlock *getIRBlock(unsigned Slot);
301 const BasicBlock *getIRBlock(unsigned Slot, const Function &F);
302
303 const Value *getIRValue(unsigned Slot);
304
305 void initNames2TargetIndices();
306
307 /// Try to convert a name of target index to the corresponding target index.
308 ///
309 /// Return true if the name isn't a name of a target index.
310 bool getTargetIndex(StringRef Name, int &Index);
311
312 void initNames2DirectTargetFlags();
313
314 /// Try to convert a name of a direct target flag to the corresponding
315 /// target flag.
316 ///
317 /// Return true if the name isn't a name of a direct flag.
318 bool getDirectTargetFlag(StringRef Name, unsigned &Flag);
319
320 void initNames2BitmaskTargetFlags();
321
322 /// Try to convert a name of a bitmask target flag to the corresponding
323 /// target flag.
324 ///
325 /// Return true if the name isn't a name of a bitmask target flag.
326 bool getBitmaskTargetFlag(StringRef Name, unsigned &Flag);
327
328 void initNames2MMOTargetFlags();
329
330 /// Try to convert a name of a MachineMemOperand target flag to the
331 /// corresponding target flag.
332 ///
333 /// Return true if the name isn't a name of a target MMO flag.
334 bool getMMOTargetFlag(StringRef Name, MachineMemOperand::Flags &Flag);
335
336 /// parseStringConstant
337 /// ::= StringConstant
338 bool parseStringConstant(std::string &Result);
339};
340
341} // end anonymous namespace
342
343MIParser::MIParser(PerFunctionMIParsingState &PFS, SMDiagnostic &Error,
344 StringRef Source)
345 : MF(PFS.MF), Error(Error), Source(Source), CurrentSource(Source), PFS(PFS)
346{}
347
348void MIParser::lex(unsigned SkipChar) {
349 CurrentSource = lexMIToken(
350 CurrentSource.data() + SkipChar, Token,
351 [this](StringRef::iterator Loc, const Twine &Msg) { error(Loc, Msg); });
352}
353
354bool MIParser::error(const Twine &Msg) { return error(Token.location(), Msg); }
63
Calling 'MIToken::location'
64
Returning from 'MIToken::location'
355
356bool MIParser::error(StringRef::iterator Loc, const Twine &Msg) {
357 const SourceMgr &SM = *PFS.SM;
358 assert(Loc >= Source.data() && Loc <= (Source.data() + Source.size()))(static_cast <bool> (Loc >= Source.data() &&
Loc <= (Source.data() + Source.size())) ? void (0) : __assert_fail
("Loc >= Source.data() && Loc <= (Source.data() + Source.size())"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 358, __extension__ __PRETTY_FUNCTION__))
;
359 const MemoryBuffer &Buffer = *SM.getMemoryBuffer(SM.getMainFileID());
360 if (Loc >= Buffer.getBufferStart() && Loc <= Buffer.getBufferEnd()) {
361 // Create an ordinary diagnostic when the source manager's buffer is the
362 // source string.
363 Error = SM.GetMessage(SMLoc::getFromPointer(Loc), SourceMgr::DK_Error, Msg);
364 return true;
365 }
366 // Create a diagnostic for a YAML string literal.
367 Error = SMDiagnostic(SM, SMLoc(), Buffer.getBufferIdentifier(), 1,
368 Loc - Source.data(), SourceMgr::DK_Error, Msg.str(),
369 Source, None, None);
370 return true;
371}
372
373static const char *toString(MIToken::TokenKind TokenKind) {
374 switch (TokenKind) {
375 case MIToken::comma:
376 return "','";
377 case MIToken::equal:
378 return "'='";
379 case MIToken::colon:
380 return "':'";
381 case MIToken::lparen:
382 return "'('";
383 case MIToken::rparen:
384 return "')'";
385 default:
386 return "<unknown token>";
387 }
388}
389
390bool MIParser::expectAndConsume(MIToken::TokenKind TokenKind) {
391 if (Token.isNot(TokenKind))
392 return error(Twine("expected ") + toString(TokenKind));
393 lex();
394 return false;
395}
396
397bool MIParser::consumeIfPresent(MIToken::TokenKind TokenKind) {
398 if (Token.isNot(TokenKind))
399 return false;
400 lex();
401 return true;
402}
403
404bool MIParser::parseBasicBlockDefinition(
405 DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
406 assert(Token.is(MIToken::MachineBasicBlockLabel))(static_cast <bool> (Token.is(MIToken::MachineBasicBlockLabel
)) ? void (0) : __assert_fail ("Token.is(MIToken::MachineBasicBlockLabel)"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 406, __extension__ __PRETTY_FUNCTION__))
;
407 unsigned ID = 0;
408 if (getUnsigned(ID))
409 return true;
410 auto Loc = Token.location();
411 auto Name = Token.stringValue();
412 lex();
413 bool HasAddressTaken = false;
414 bool IsLandingPad = false;
415 unsigned Alignment = 0;
416 BasicBlock *BB = nullptr;
417 if (consumeIfPresent(MIToken::lparen)) {
418 do {
419 // TODO: Report an error when multiple same attributes are specified.
420 switch (Token.kind()) {
421 case MIToken::kw_address_taken:
422 HasAddressTaken = true;
423 lex();
424 break;
425 case MIToken::kw_landing_pad:
426 IsLandingPad = true;
427 lex();
428 break;
429 case MIToken::kw_align:
430 if (parseAlignment(Alignment))
431 return true;
432 break;
433 case MIToken::IRBlock:
434 // TODO: Report an error when both name and ir block are specified.
435 if (parseIRBlock(BB, MF.getFunction()))
436 return true;
437 lex();
438 break;
439 default:
440 break;
441 }
442 } while (consumeIfPresent(MIToken::comma));
443 if (expectAndConsume(MIToken::rparen))
444 return true;
445 }
446 if (expectAndConsume(MIToken::colon))
447 return true;
448
449 if (!Name.empty()) {
450 BB = dyn_cast_or_null<BasicBlock>(
451 MF.getFunction().getValueSymbolTable()->lookup(Name));
452 if (!BB)
453 return error(Loc, Twine("basic block '") + Name +
454 "' is not defined in the function '" +
455 MF.getName() + "'");
456 }
457 auto *MBB = MF.CreateMachineBasicBlock(BB);
458 MF.insert(MF.end(), MBB);
459 bool WasInserted = MBBSlots.insert(std::make_pair(ID, MBB)).second;
460 if (!WasInserted)
461 return error(Loc, Twine("redefinition of machine basic block with id #") +
462 Twine(ID));
463 if (Alignment)
464 MBB->setAlignment(Alignment);
465 if (HasAddressTaken)
466 MBB->setHasAddressTaken();
467 MBB->setIsEHPad(IsLandingPad);
468 return false;
469}
470
471bool MIParser::parseBasicBlockDefinitions(
472 DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
473 lex();
474 // Skip until the first machine basic block.
475 while (Token.is(MIToken::Newline))
476 lex();
477 if (Token.isErrorOrEOF())
478 return Token.isError();
479 if (Token.isNot(MIToken::MachineBasicBlockLabel))
480 return error("expected a basic block definition before instructions");
481 unsigned BraceDepth = 0;
482 do {
483 if (parseBasicBlockDefinition(MBBSlots))
484 return true;
485 bool IsAfterNewline = false;
486 // Skip until the next machine basic block.
487 while (true) {
488 if ((Token.is(MIToken::MachineBasicBlockLabel) && IsAfterNewline) ||
489 Token.isErrorOrEOF())
490 break;
491 else if (Token.is(MIToken::MachineBasicBlockLabel))
492 return error("basic block definition should be located at the start of "
493 "the line");
494 else if (consumeIfPresent(MIToken::Newline)) {
495 IsAfterNewline = true;
496 continue;
497 }
498 IsAfterNewline = false;
499 if (Token.is(MIToken::lbrace))
500 ++BraceDepth;
501 if (Token.is(MIToken::rbrace)) {
502 if (!BraceDepth)
503 return error("extraneous closing brace ('}')");
504 --BraceDepth;
505 }
506 lex();
507 }
508 // Verify that we closed all of the '{' at the end of a file or a block.
509 if (!Token.isError() && BraceDepth)
510 return error("expected '}'"); // FIXME: Report a note that shows '{'.
511 } while (!Token.isErrorOrEOF());
512 return Token.isError();
513}
514
515bool MIParser::parseBasicBlockLiveins(MachineBasicBlock &MBB) {
516 assert(Token.is(MIToken::kw_liveins))(static_cast <bool> (Token.is(MIToken::kw_liveins)) ? void
(0) : __assert_fail ("Token.is(MIToken::kw_liveins)", "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 516, __extension__ __PRETTY_FUNCTION__))
;
517 lex();
518 if (expectAndConsume(MIToken::colon))
519 return true;
520 if (Token.isNewlineOrEOF()) // Allow an empty list of liveins.
521 return false;
522 do {
523 if (Token.isNot(MIToken::NamedRegister))
524 return error("expected a named register");
525 unsigned Reg = 0;
526 if (parseNamedRegister(Reg))
527 return true;
528 lex();
529 LaneBitmask Mask = LaneBitmask::getAll();
530 if (consumeIfPresent(MIToken::colon)) {
531 // Parse lane mask.
532 if (Token.isNot(MIToken::IntegerLiteral) &&
533 Token.isNot(MIToken::HexLiteral))
534 return error("expected a lane mask");
535 static_assert(sizeof(LaneBitmask::Type) == sizeof(unsigned),
536 "Use correct get-function for lane mask");
537 LaneBitmask::Type V;
538 if (getUnsigned(V))
539 return error("invalid lane mask value");
540 Mask = LaneBitmask(V);
541 lex();
542 }
543 MBB.addLiveIn(Reg, Mask);
544 } while (consumeIfPresent(MIToken::comma));
545 return false;
546}
547
548bool MIParser::parseBasicBlockSuccessors(MachineBasicBlock &MBB) {
549 assert(Token.is(MIToken::kw_successors))(static_cast <bool> (Token.is(MIToken::kw_successors)) ?
void (0) : __assert_fail ("Token.is(MIToken::kw_successors)"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 549, __extension__ __PRETTY_FUNCTION__))
;
550 lex();
551 if (expectAndConsume(MIToken::colon))
552 return true;
553 if (Token.isNewlineOrEOF()) // Allow an empty list of successors.
554 return false;
555 do {
556 if (Token.isNot(MIToken::MachineBasicBlock))
557 return error("expected a machine basic block reference");
558 MachineBasicBlock *SuccMBB = nullptr;
559 if (parseMBBReference(SuccMBB))
560 return true;
561 lex();
562 unsigned Weight = 0;
563 if (consumeIfPresent(MIToken::lparen)) {
564 if (Token.isNot(MIToken::IntegerLiteral) &&
565 Token.isNot(MIToken::HexLiteral))
566 return error("expected an integer literal after '('");
567 if (getUnsigned(Weight))
568 return true;
569 lex();
570 if (expectAndConsume(MIToken::rparen))
571 return true;
572 }
573 MBB.addSuccessor(SuccMBB, BranchProbability::getRaw(Weight));
574 } while (consumeIfPresent(MIToken::comma));
575 MBB.normalizeSuccProbs();
576 return false;
577}
578
579bool MIParser::parseBasicBlock(MachineBasicBlock &MBB,
580 MachineBasicBlock *&AddFalthroughFrom) {
581 // Skip the definition.
582 assert(Token.is(MIToken::MachineBasicBlockLabel))(static_cast <bool> (Token.is(MIToken::MachineBasicBlockLabel
)) ? void (0) : __assert_fail ("Token.is(MIToken::MachineBasicBlockLabel)"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 582, __extension__ __PRETTY_FUNCTION__))
;
583 lex();
584 if (consumeIfPresent(MIToken::lparen)) {
585 while (Token.isNot(MIToken::rparen) && !Token.isErrorOrEOF())
586 lex();
587 consumeIfPresent(MIToken::rparen);
588 }
589 consumeIfPresent(MIToken::colon);
590
591 // Parse the liveins and successors.
592 // N.B: Multiple lists of successors and liveins are allowed and they're
593 // merged into one.
594 // Example:
595 // liveins: %edi
596 // liveins: %esi
597 //
598 // is equivalent to
599 // liveins: %edi, %esi
600 bool ExplicitSuccessors = false;
601 while (true) {
602 if (Token.is(MIToken::kw_successors)) {
603 if (parseBasicBlockSuccessors(MBB))
604 return true;
605 ExplicitSuccessors = true;
606 } else if (Token.is(MIToken::kw_liveins)) {
607 if (parseBasicBlockLiveins(MBB))
608 return true;
609 } else if (consumeIfPresent(MIToken::Newline)) {
610 continue;
611 } else
612 break;
613 if (!Token.isNewlineOrEOF())
614 return error("expected line break at the end of a list");
615 lex();
616 }
617
618 // Parse the instructions.
619 bool IsInBundle = false;
620 MachineInstr *PrevMI = nullptr;
621 while (!Token.is(MIToken::MachineBasicBlockLabel) &&
622 !Token.is(MIToken::Eof)) {
623 if (consumeIfPresent(MIToken::Newline))
624 continue;
625 if (consumeIfPresent(MIToken::rbrace)) {
626 // The first parsing pass should verify that all closing '}' have an
627 // opening '{'.
628 assert(IsInBundle)(static_cast <bool> (IsInBundle) ? void (0) : __assert_fail
("IsInBundle", "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 628, __extension__ __PRETTY_FUNCTION__))
;
629 IsInBundle = false;
630 continue;
631 }
632 MachineInstr *MI = nullptr;
633 if (parse(MI))
634 return true;
635 MBB.insert(MBB.end(), MI);
636 if (IsInBundle) {
637 PrevMI->setFlag(MachineInstr::BundledSucc);
638 MI->setFlag(MachineInstr::BundledPred);
639 }
640 PrevMI = MI;
641 if (Token.is(MIToken::lbrace)) {
642 if (IsInBundle)
643 return error("nested instruction bundles are not allowed");
644 lex();
645 // This instruction is the start of the bundle.
646 MI->setFlag(MachineInstr::BundledSucc);
647 IsInBundle = true;
648 if (!Token.is(MIToken::Newline))
649 // The next instruction can be on the same line.
650 continue;
651 }
652 assert(Token.isNewlineOrEOF() && "MI is not fully parsed")(static_cast <bool> (Token.isNewlineOrEOF() && "MI is not fully parsed"
) ? void (0) : __assert_fail ("Token.isNewlineOrEOF() && \"MI is not fully parsed\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 652, __extension__ __PRETTY_FUNCTION__))
;
653 lex();
654 }
655
656 // Construct successor list by searching for basic block machine operands.
657 if (!ExplicitSuccessors) {
658 SmallVector<MachineBasicBlock*,4> Successors;
659 bool IsFallthrough;
660 guessSuccessors(MBB, Successors, IsFallthrough);
661 for (MachineBasicBlock *Succ : Successors)
662 MBB.addSuccessor(Succ);
663
664 if (IsFallthrough) {
665 AddFalthroughFrom = &MBB;
666 } else {
667 MBB.normalizeSuccProbs();
668 }
669 }
670
671 return false;
672}
673
674bool MIParser::parseBasicBlocks() {
675 lex();
676 // Skip until the first machine basic block.
677 while (Token.is(MIToken::Newline))
678 lex();
679 if (Token.isErrorOrEOF())
680 return Token.isError();
681 // The first parsing pass should have verified that this token is a MBB label
682 // in the 'parseBasicBlockDefinitions' method.
683 assert(Token.is(MIToken::MachineBasicBlockLabel))(static_cast <bool> (Token.is(MIToken::MachineBasicBlockLabel
)) ? void (0) : __assert_fail ("Token.is(MIToken::MachineBasicBlockLabel)"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 683, __extension__ __PRETTY_FUNCTION__))
;
684 MachineBasicBlock *AddFalthroughFrom = nullptr;
685 do {
686 MachineBasicBlock *MBB = nullptr;
687 if (parseMBBReference(MBB))
688 return true;
689 if (AddFalthroughFrom) {
690 if (!AddFalthroughFrom->isSuccessor(MBB))
691 AddFalthroughFrom->addSuccessor(MBB);
692 AddFalthroughFrom->normalizeSuccProbs();
693 AddFalthroughFrom = nullptr;
694 }
695 if (parseBasicBlock(*MBB, AddFalthroughFrom))
696 return true;
697 // The method 'parseBasicBlock' should parse the whole block until the next
698 // block or the end of file.
699 assert(Token.is(MIToken::MachineBasicBlockLabel) || Token.is(MIToken::Eof))(static_cast <bool> (Token.is(MIToken::MachineBasicBlockLabel
) || Token.is(MIToken::Eof)) ? void (0) : __assert_fail ("Token.is(MIToken::MachineBasicBlockLabel) || Token.is(MIToken::Eof)"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 699, __extension__ __PRETTY_FUNCTION__))
;
700 } while (Token.isNot(MIToken::Eof));
701 return false;
702}
703
704bool MIParser::parse(MachineInstr *&MI) {
705 // Parse any register operands before '='
706 MachineOperand MO = MachineOperand::CreateImm(0);
707 SmallVector<ParsedMachineOperand, 8> Operands;
708 while (Token.isRegister() || Token.isRegisterFlag()) {
709 auto Loc = Token.location();
710 Optional<unsigned> TiedDefIdx;
711 if (parseRegisterOperand(MO, TiedDefIdx, /*IsDef=*/true))
712 return true;
713 Operands.push_back(
714 ParsedMachineOperand(MO, Loc, Token.location(), TiedDefIdx));
715 if (Token.isNot(MIToken::comma))
716 break;
717 lex();
718 }
719 if (!Operands.empty() && expectAndConsume(MIToken::equal))
720 return true;
721
722 unsigned OpCode, Flags = 0;
723 if (Token.isError() || parseInstruction(OpCode, Flags))
724 return true;
725
726 // Parse the remaining machine operands.
727 while (!Token.isNewlineOrEOF() && Token.isNot(MIToken::kw_debug_location) &&
728 Token.isNot(MIToken::coloncolon) && Token.isNot(MIToken::lbrace)) {
729 auto Loc = Token.location();
730 Optional<unsigned> TiedDefIdx;
731 if (parseMachineOperandAndTargetFlags(MO, TiedDefIdx))
732 return true;
733 Operands.push_back(
734 ParsedMachineOperand(MO, Loc, Token.location(), TiedDefIdx));
735 if (Token.isNewlineOrEOF() || Token.is(MIToken::coloncolon) ||
736 Token.is(MIToken::lbrace))
737 break;
738 if (Token.isNot(MIToken::comma))
739 return error("expected ',' before the next machine operand");
740 lex();
741 }
742
743 DebugLoc DebugLocation;
744 if (Token.is(MIToken::kw_debug_location)) {
745 lex();
746 if (Token.isNot(MIToken::exclaim))
747 return error("expected a metadata node after 'debug-location'");
748 MDNode *Node = nullptr;
749 if (parseMDNode(Node))
750 return true;
751 DebugLocation = DebugLoc(Node);
752 }
753
754 // Parse the machine memory operands.
755 SmallVector<MachineMemOperand *, 2> MemOperands;
756 if (Token.is(MIToken::coloncolon)) {
757 lex();
758 while (!Token.isNewlineOrEOF()) {
759 MachineMemOperand *MemOp = nullptr;
760 if (parseMachineMemoryOperand(MemOp))
761 return true;
762 MemOperands.push_back(MemOp);
763 if (Token.isNewlineOrEOF())
764 break;
765 if (Token.isNot(MIToken::comma))
766 return error("expected ',' before the next machine memory operand");
767 lex();
768 }
769 }
770
771 const auto &MCID = MF.getSubtarget().getInstrInfo()->get(OpCode);
772 if (!MCID.isVariadic()) {
773 // FIXME: Move the implicit operand verification to the machine verifier.
774 if (verifyImplicitOperands(Operands, MCID))
775 return true;
776 }
777
778 // TODO: Check for extraneous machine operands.
779 MI = MF.CreateMachineInstr(MCID, DebugLocation, /*NoImplicit=*/true);
780 MI->setFlags(Flags);
781 for (const auto &Operand : Operands)
782 MI->addOperand(MF, Operand.Operand);
783 if (assignRegisterTies(*MI, Operands))
784 return true;
785 if (MemOperands.empty())
786 return false;
787 MachineInstr::mmo_iterator MemRefs =
788 MF.allocateMemRefsArray(MemOperands.size());
789 std::copy(MemOperands.begin(), MemOperands.end(), MemRefs);
790 MI->setMemRefs(MemRefs, MemRefs + MemOperands.size());
791 return false;
792}
793
794bool MIParser::parseStandaloneMBB(MachineBasicBlock *&MBB) {
795 lex();
796 if (Token.isNot(MIToken::MachineBasicBlock))
797 return error("expected a machine basic block reference");
798 if (parseMBBReference(MBB))
799 return true;
800 lex();
801 if (Token.isNot(MIToken::Eof))
802 return error(
803 "expected end of string after the machine basic block reference");
804 return false;
805}
806
807bool MIParser::parseStandaloneNamedRegister(unsigned &Reg) {
808 lex();
809 if (Token.isNot(MIToken::NamedRegister))
810 return error("expected a named register");
811 if (parseNamedRegister(Reg))
812 return true;
813 lex();
814 if (Token.isNot(MIToken::Eof))
815 return error("expected end of string after the register reference");
816 return false;
817}
818
819bool MIParser::parseStandaloneVirtualRegister(VRegInfo *&Info) {
820 lex();
821 if (Token.isNot(MIToken::VirtualRegister))
822 return error("expected a virtual register");
823 if (parseVirtualRegister(Info))
824 return true;
825 lex();
826 if (Token.isNot(MIToken::Eof))
827 return error("expected end of string after the register reference");
828 return false;
829}
830
831bool MIParser::parseStandaloneRegister(unsigned &Reg) {
832 lex();
833 if (Token.isNot(MIToken::NamedRegister) &&
834 Token.isNot(MIToken::VirtualRegister))
835 return error("expected either a named or virtual register");
836
837 VRegInfo *Info;
838 if (parseRegister(Reg, Info))
839 return true;
840
841 lex();
842 if (Token.isNot(MIToken::Eof))
843 return error("expected end of string after the register reference");
844 return false;
845}
846
847bool MIParser::parseStandaloneStackObject(int &FI) {
848 lex();
849 if (Token.isNot(MIToken::StackObject))
850 return error("expected a stack object");
851 if (parseStackFrameIndex(FI))
852 return true;
853 if (Token.isNot(MIToken::Eof))
854 return error("expected end of string after the stack object reference");
855 return false;
856}
857
858bool MIParser::parseStandaloneMDNode(MDNode *&Node) {
859 lex();
860 if (Token.is(MIToken::exclaim)) {
861 if (parseMDNode(Node))
862 return true;
863 } else if (Token.is(MIToken::md_diexpr)) {
864 if (parseDIExpression(Node))
865 return true;
866 } else
867 return error("expected a metadata node");
868 if (Token.isNot(MIToken::Eof))
869 return error("expected end of string after the metadata node");
870 return false;
871}
872
873static const char *printImplicitRegisterFlag(const MachineOperand &MO) {
874 assert(MO.isImplicit())(static_cast <bool> (MO.isImplicit()) ? void (0) : __assert_fail
("MO.isImplicit()", "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 874, __extension__ __PRETTY_FUNCTION__))
;
875 return MO.isDef() ? "implicit-def" : "implicit";
876}
877
878static std::string getRegisterName(const TargetRegisterInfo *TRI,
879 unsigned Reg) {
880 assert(TargetRegisterInfo::isPhysicalRegister(Reg) && "expected phys reg")(static_cast <bool> (TargetRegisterInfo::isPhysicalRegister
(Reg) && "expected phys reg") ? void (0) : __assert_fail
("TargetRegisterInfo::isPhysicalRegister(Reg) && \"expected phys reg\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 880, __extension__ __PRETTY_FUNCTION__))
;
881 return StringRef(TRI->getName(Reg)).lower();
882}
883
884/// Return true if the parsed machine operands contain a given machine operand.
885static bool isImplicitOperandIn(const MachineOperand &ImplicitOperand,
886 ArrayRef<ParsedMachineOperand> Operands) {
887 for (const auto &I : Operands) {
888 if (ImplicitOperand.isIdenticalTo(I.Operand))
889 return true;
890 }
891 return false;
892}
893
894bool MIParser::verifyImplicitOperands(ArrayRef<ParsedMachineOperand> Operands,
895 const MCInstrDesc &MCID) {
896 if (MCID.isCall())
897 // We can't verify call instructions as they can contain arbitrary implicit
898 // register and register mask operands.
899 return false;
900
901 // Gather all the expected implicit operands.
902 SmallVector<MachineOperand, 4> ImplicitOperands;
903 if (MCID.ImplicitDefs)
904 for (const MCPhysReg *ImpDefs = MCID.getImplicitDefs(); *ImpDefs; ++ImpDefs)
905 ImplicitOperands.push_back(
906 MachineOperand::CreateReg(*ImpDefs, true, true));
907 if (MCID.ImplicitUses)
908 for (const MCPhysReg *ImpUses = MCID.getImplicitUses(); *ImpUses; ++ImpUses)
909 ImplicitOperands.push_back(
910 MachineOperand::CreateReg(*ImpUses, false, true));
911
912 const auto *TRI = MF.getSubtarget().getRegisterInfo();
913 assert(TRI && "Expected target register info")(static_cast <bool> (TRI && "Expected target register info"
) ? void (0) : __assert_fail ("TRI && \"Expected target register info\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 913, __extension__ __PRETTY_FUNCTION__))
;
914 for (const auto &I : ImplicitOperands) {
915 if (isImplicitOperandIn(I, Operands))
916 continue;
917 return error(Operands.empty() ? Token.location() : Operands.back().End,
918 Twine("missing implicit register operand '") +
919 printImplicitRegisterFlag(I) + " %" +
920 getRegisterName(TRI, I.getReg()) + "'");
921 }
922 return false;
923}
924
925bool MIParser::parseInstruction(unsigned &OpCode, unsigned &Flags) {
926 if (Token.is(MIToken::kw_frame_setup)) {
927 Flags |= MachineInstr::FrameSetup;
928 lex();
929 } else if (Token.is(MIToken::kw_frame_destroy)) {
930 Flags |= MachineInstr::FrameDestroy;
931 lex();
932 }
933 if (Token.isNot(MIToken::Identifier))
934 return error("expected a machine instruction");
935 StringRef InstrName = Token.stringValue();
936 if (parseInstrName(InstrName, OpCode))
937 return error(Twine("unknown machine instruction name '") + InstrName + "'");
938 lex();
939 return false;
940}
941
942bool MIParser::parseNamedRegister(unsigned &Reg) {
943 assert(Token.is(MIToken::NamedRegister) && "Needs NamedRegister token")(static_cast <bool> (Token.is(MIToken::NamedRegister) &&
"Needs NamedRegister token") ? void (0) : __assert_fail ("Token.is(MIToken::NamedRegister) && \"Needs NamedRegister token\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 943, __extension__ __PRETTY_FUNCTION__))
;
944 StringRef Name = Token.stringValue();
945 if (getRegisterByName(Name, Reg))
946 return error(Twine("unknown register name '") + Name + "'");
947 return false;
948}
949
950bool MIParser::parseVirtualRegister(VRegInfo *&Info) {
951 assert(Token.is(MIToken::VirtualRegister) && "Needs VirtualRegister token")(static_cast <bool> (Token.is(MIToken::VirtualRegister)
&& "Needs VirtualRegister token") ? void (0) : __assert_fail
("Token.is(MIToken::VirtualRegister) && \"Needs VirtualRegister token\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 951, __extension__ __PRETTY_FUNCTION__))
;
952 unsigned ID;
953 if (getUnsigned(ID))
954 return true;
955 Info = &PFS.getVRegInfo(ID);
956 return false;
957}
958
959bool MIParser::parseRegister(unsigned &Reg, VRegInfo *&Info) {
960 switch (Token.kind()) {
961 case MIToken::underscore:
962 Reg = 0;
963 return false;
964 case MIToken::NamedRegister:
965 return parseNamedRegister(Reg);
966 case MIToken::VirtualRegister:
967 if (parseVirtualRegister(Info))
968 return true;
969 Reg = Info->VReg;
970 return false;
971 // TODO: Parse other register kinds.
972 default:
973 llvm_unreachable("The current token should be a register")::llvm::llvm_unreachable_internal("The current token should be a register"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 973)
;
974 }
975}
976
977bool MIParser::parseRegisterClassOrBank(VRegInfo &RegInfo) {
978 if (Token.isNot(MIToken::Identifier) && Token.isNot(MIToken::underscore))
979 return error("expected '_', register class, or register bank name");
980 StringRef::iterator Loc = Token.location();
981 StringRef Name = Token.stringValue();
982
983 // Was it a register class?
984 auto RCNameI = PFS.Names2RegClasses.find(Name);
985 if (RCNameI != PFS.Names2RegClasses.end()) {
986 lex();
987 const TargetRegisterClass &RC = *RCNameI->getValue();
988
989 switch (RegInfo.Kind) {
990 case VRegInfo::UNKNOWN:
991 case VRegInfo::NORMAL:
992 RegInfo.Kind = VRegInfo::NORMAL;
993 if (RegInfo.Explicit && RegInfo.D.RC != &RC) {
994 const TargetRegisterInfo &TRI = *MF.getSubtarget().getRegisterInfo();
995 return error(Loc, Twine("conflicting register classes, previously: ") +
996 Twine(TRI.getRegClassName(RegInfo.D.RC)));
997 }
998 RegInfo.D.RC = &RC;
999 RegInfo.Explicit = true;
1000 return false;
1001
1002 case VRegInfo::GENERIC:
1003 case VRegInfo::REGBANK:
1004 return error(Loc, "register class specification on generic register");
1005 }
1006 llvm_unreachable("Unexpected register kind")::llvm::llvm_unreachable_internal("Unexpected register kind",
"/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1006)
;
1007 }
1008
1009 // Should be a register bank or a generic register.
1010 const RegisterBank *RegBank = nullptr;
1011 if (Name != "_") {
1012 auto RBNameI = PFS.Names2RegBanks.find(Name);
1013 if (RBNameI == PFS.Names2RegBanks.end())
1014 return error(Loc, "expected '_', register class, or register bank name");
1015 RegBank = RBNameI->getValue();
1016 }
1017
1018 lex();
1019
1020 switch (RegInfo.Kind) {
1021 case VRegInfo::UNKNOWN:
1022 case VRegInfo::GENERIC:
1023 case VRegInfo::REGBANK:
1024 RegInfo.Kind = RegBank ? VRegInfo::REGBANK : VRegInfo::GENERIC;
1025 if (RegInfo.Explicit && RegInfo.D.RegBank != RegBank)
1026 return error(Loc, "conflicting generic register banks");
1027 RegInfo.D.RegBank = RegBank;
1028 RegInfo.Explicit = true;
1029 return false;
1030
1031 case VRegInfo::NORMAL:
1032 return error(Loc, "register bank specification on normal register");
1033 }
1034 llvm_unreachable("Unexpected register kind")::llvm::llvm_unreachable_internal("Unexpected register kind",
"/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1034)
;
1035}
1036
1037bool MIParser::parseRegisterFlag(unsigned &Flags) {
1038 const unsigned OldFlags = Flags;
1039 switch (Token.kind()) {
1040 case MIToken::kw_implicit:
1041 Flags |= RegState::Implicit;
1042 break;
1043 case MIToken::kw_implicit_define:
1044 Flags |= RegState::ImplicitDefine;
1045 break;
1046 case MIToken::kw_def:
1047 Flags |= RegState::Define;
1048 break;
1049 case MIToken::kw_dead:
1050 Flags |= RegState::Dead;
1051 break;
1052 case MIToken::kw_killed:
1053 Flags |= RegState::Kill;
1054 break;
1055 case MIToken::kw_undef:
1056 Flags |= RegState::Undef;
1057 break;
1058 case MIToken::kw_internal:
1059 Flags |= RegState::InternalRead;
1060 break;
1061 case MIToken::kw_early_clobber:
1062 Flags |= RegState::EarlyClobber;
1063 break;
1064 case MIToken::kw_debug_use:
1065 Flags |= RegState::Debug;
1066 break;
1067 case MIToken::kw_renamable:
1068 Flags |= RegState::Renamable;
1069 break;
1070 default:
1071 llvm_unreachable("The current token should be a register flag")::llvm::llvm_unreachable_internal("The current token should be a register flag"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1071)
;
1072 }
1073 if (OldFlags == Flags)
1074 // We know that the same flag is specified more than once when the flags
1075 // weren't modified.
1076 return error("duplicate '" + Token.stringValue() + "' register flag");
1077 lex();
1078 return false;
1079}
1080
1081bool MIParser::parseSubRegisterIndex(unsigned &SubReg) {
1082 assert(Token.is(MIToken::dot))(static_cast <bool> (Token.is(MIToken::dot)) ? void (0)
: __assert_fail ("Token.is(MIToken::dot)", "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1082, __extension__ __PRETTY_FUNCTION__))
;
1083 lex();
1084 if (Token.isNot(MIToken::Identifier))
1085 return error("expected a subregister index after '.'");
1086 auto Name = Token.stringValue();
1087 SubReg = getSubRegIndex(Name);
1088 if (!SubReg)
1089 return error(Twine("use of unknown subregister index '") + Name + "'");
1090 lex();
1091 return false;
1092}
1093
1094bool MIParser::parseRegisterTiedDefIndex(unsigned &TiedDefIdx) {
1095 if (!consumeIfPresent(MIToken::kw_tied_def))
1096 return true;
1097 if (Token.isNot(MIToken::IntegerLiteral))
1098 return error("expected an integer literal after 'tied-def'");
1099 if (getUnsigned(TiedDefIdx))
1100 return true;
1101 lex();
1102 if (expectAndConsume(MIToken::rparen))
1103 return true;
1104 return false;
1105}
1106
1107bool MIParser::assignRegisterTies(MachineInstr &MI,
1108 ArrayRef<ParsedMachineOperand> Operands) {
1109 SmallVector<std::pair<unsigned, unsigned>, 4> TiedRegisterPairs;
1110 for (unsigned I = 0, E = Operands.size(); I != E; ++I) {
1111 if (!Operands[I].TiedDefIdx)
1112 continue;
1113 // The parser ensures that this operand is a register use, so we just have
1114 // to check the tied-def operand.
1115 unsigned DefIdx = Operands[I].TiedDefIdx.getValue();
1116 if (DefIdx >= E)
1117 return error(Operands[I].Begin,
1118 Twine("use of invalid tied-def operand index '" +
1119 Twine(DefIdx) + "'; instruction has only ") +
1120 Twine(E) + " operands");
1121 const auto &DefOperand = Operands[DefIdx].Operand;
1122 if (!DefOperand.isReg() || !DefOperand.isDef())
1123 // FIXME: add note with the def operand.
1124 return error(Operands[I].Begin,
1125 Twine("use of invalid tied-def operand index '") +
1126 Twine(DefIdx) + "'; the operand #" + Twine(DefIdx) +
1127 " isn't a defined register");
1128 // Check that the tied-def operand wasn't tied elsewhere.
1129 for (const auto &TiedPair : TiedRegisterPairs) {
1130 if (TiedPair.first == DefIdx)
1131 return error(Operands[I].Begin,
1132 Twine("the tied-def operand #") + Twine(DefIdx) +
1133 " is already tied with another register operand");
1134 }
1135 TiedRegisterPairs.push_back(std::make_pair(DefIdx, I));
1136 }
1137 // FIXME: Verify that for non INLINEASM instructions, the def and use tied
1138 // indices must be less than tied max.
1139 for (const auto &TiedPair : TiedRegisterPairs)
1140 MI.tieOperands(TiedPair.first, TiedPair.second);
1141 return false;
1142}
1143
1144bool MIParser::parseRegisterOperand(MachineOperand &Dest,
1145 Optional<unsigned> &TiedDefIdx,
1146 bool IsDef) {
1147 unsigned Flags = IsDef ? RegState::Define : 0;
1148 while (Token.isRegisterFlag()) {
1149 if (parseRegisterFlag(Flags))
1150 return true;
1151 }
1152 if (!Token.isRegister())
1153 return error("expected a register after register flags");
1154 unsigned Reg;
1155 VRegInfo *RegInfo;
1156 if (parseRegister(Reg, RegInfo))
1157 return true;
1158 lex();
1159 unsigned SubReg = 0;
1160 if (Token.is(MIToken::dot)) {
1161 if (parseSubRegisterIndex(SubReg))
1162 return true;
1163 if (!TargetRegisterInfo::isVirtualRegister(Reg))
1164 return error("subregister index expects a virtual register");
1165 }
1166 if (Token.is(MIToken::colon)) {
1167 if (!TargetRegisterInfo::isVirtualRegister(Reg))
1168 return error("register class specification expects a virtual register");
1169 lex();
1170 if (parseRegisterClassOrBank(*RegInfo))
1171 return true;
1172 }
1173 MachineRegisterInfo &MRI = MF.getRegInfo();
1174 if ((Flags & RegState::Define) == 0) {
1175 if (consumeIfPresent(MIToken::lparen)) {
1176 unsigned Idx;
1177 if (!parseRegisterTiedDefIndex(Idx))
1178 TiedDefIdx = Idx;
1179 else {
1180 // Try a redundant low-level type.
1181 LLT Ty;
1182 if (parseLowLevelType(Token.location(), Ty))
1183 return error("expected tied-def or low-level type after '('");
1184
1185 if (expectAndConsume(MIToken::rparen))
1186 return true;
1187
1188 if (MRI.getType(Reg).isValid() && MRI.getType(Reg) != Ty)
1189 return error("inconsistent type for generic virtual register");
1190
1191 MRI.setType(Reg, Ty);
1192 }
1193 }
1194 } else if (consumeIfPresent(MIToken::lparen)) {
1195 // Virtual registers may have a tpe with GlobalISel.
1196 if (!TargetRegisterInfo::isVirtualRegister(Reg))
1197 return error("unexpected type on physical register");
1198
1199 LLT Ty;
1200 if (parseLowLevelType(Token.location(), Ty))
1201 return true;
1202
1203 if (expectAndConsume(MIToken::rparen))
1204 return true;
1205
1206 if (MRI.getType(Reg).isValid() && MRI.getType(Reg) != Ty)
1207 return error("inconsistent type for generic virtual register");
1208
1209 MRI.setType(Reg, Ty);
1210 } else if (TargetRegisterInfo::isVirtualRegister(Reg)) {
1211 // Generic virtual registers must have a type.
1212 // If we end up here this means the type hasn't been specified and
1213 // this is bad!
1214 if (RegInfo->Kind == VRegInfo::GENERIC ||
1215 RegInfo->Kind == VRegInfo::REGBANK)
1216 return error("generic virtual registers must have a type");
1217 }
1218 Dest = MachineOperand::CreateReg(
1219 Reg, Flags & RegState::Define, Flags & RegState::Implicit,
1220 Flags & RegState::Kill, Flags & RegState::Dead, Flags & RegState::Undef,
1221 Flags & RegState::EarlyClobber, SubReg, Flags & RegState::Debug,
1222 Flags & RegState::InternalRead, Flags & RegState::Renamable);
1223
1224 return false;
1225}
1226
1227bool MIParser::parseImmediateOperand(MachineOperand &Dest) {
1228 assert(Token.is(MIToken::IntegerLiteral))(static_cast <bool> (Token.is(MIToken::IntegerLiteral))
? void (0) : __assert_fail ("Token.is(MIToken::IntegerLiteral)"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1228, __extension__ __PRETTY_FUNCTION__))
;
1229 const APSInt &Int = Token.integerValue();
1230 if (Int.getMinSignedBits() > 64)
1231 return error("integer literal is too large to be an immediate operand");
1232 Dest = MachineOperand::CreateImm(Int.getExtValue());
1233 lex();
1234 return false;
1235}
1236
1237bool MIParser::parseIRConstant(StringRef::iterator Loc, StringRef StringValue,
1238 const Constant *&C) {
1239 auto Source = StringValue.str(); // The source has to be null terminated.
1240 SMDiagnostic Err;
1241 C = parseConstantValue(Source, Err, *MF.getFunction().getParent(),
1242 &PFS.IRSlots);
1243 if (!C)
1244 return error(Loc + Err.getColumnNo(), Err.getMessage());
1245 return false;
1246}
1247
1248bool MIParser::parseIRConstant(StringRef::iterator Loc, const Constant *&C) {
1249 if (parseIRConstant(Loc, StringRef(Loc, Token.range().end() - Loc), C))
1250 return true;
1251 lex();
1252 return false;
1253}
1254
1255bool MIParser::parseLowLevelType(StringRef::iterator Loc, LLT &Ty) {
1256 if (Token.is(MIToken::ScalarType)) {
1257 Ty = LLT::scalar(APSInt(Token.range().drop_front()).getZExtValue());
1258 lex();
1259 return false;
1260 } else if (Token.is(MIToken::PointerType)) {
1261 const DataLayout &DL = MF.getDataLayout();
1262 unsigned AS = APSInt(Token.range().drop_front()).getZExtValue();
1263 Ty = LLT::pointer(AS, DL.getPointerSizeInBits(AS));
1264 lex();
1265 return false;
1266 }
1267
1268 // Now we're looking for a vector.
1269 if (Token.isNot(MIToken::less))
1270 return error(Loc,
1271 "expected unsized, pN, sN or <N x sM> for GlobalISel type");
1272
1273 lex();
1274
1275 if (Token.isNot(MIToken::IntegerLiteral))
1276 return error(Loc, "expected <N x sM> for vctor type");
1277 uint64_t NumElements = Token.integerValue().getZExtValue();
1278 lex();
1279
1280 if (Token.isNot(MIToken::Identifier) || Token.stringValue() != "x")
1281 return error(Loc, "expected '<N x sM>' for vector type");
1282 lex();
1283
1284 if (Token.isNot(MIToken::ScalarType))
1285 return error(Loc, "expected '<N x sM>' for vector type");
1286 uint64_t ScalarSize = APSInt(Token.range().drop_front()).getZExtValue();
1287 lex();
1288
1289 if (Token.isNot(MIToken::greater))
1290 return error(Loc, "expected '<N x sM>' for vector type");
1291 lex();
1292
1293 Ty = LLT::vector(NumElements, ScalarSize);
1294 return false;
1295}
1296
1297bool MIParser::parseTypedImmediateOperand(MachineOperand &Dest) {
1298 assert(Token.is(MIToken::IntegerType))(static_cast <bool> (Token.is(MIToken::IntegerType)) ? void
(0) : __assert_fail ("Token.is(MIToken::IntegerType)", "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1298, __extension__ __PRETTY_FUNCTION__))
;
1299 auto Loc = Token.location();
1300 lex();
1301 if (Token.isNot(MIToken::IntegerLiteral))
1302 return error("expected an integer literal");
1303 const Constant *C = nullptr;
1304 if (parseIRConstant(Loc, C))
1305 return true;
1306 Dest = MachineOperand::CreateCImm(cast<ConstantInt>(C));
1307 return false;
1308}
1309
1310bool MIParser::parseFPImmediateOperand(MachineOperand &Dest) {
1311 auto Loc = Token.location();
1312 lex();
1313 if (Token.isNot(MIToken::FloatingPointLiteral) &&
1314 Token.isNot(MIToken::HexLiteral))
1315 return error("expected a floating point literal");
1316 const Constant *C = nullptr;
1317 if (parseIRConstant(Loc, C))
1318 return true;
1319 Dest = MachineOperand::CreateFPImm(cast<ConstantFP>(C));
1320 return false;
1321}
1322
1323bool MIParser::getUnsigned(unsigned &Result) {
1324 if (Token.hasIntegerValue()) {
9
Assuming the condition is false
10
Taking false branch
31
Assuming the condition is false
32
Taking false branch
54
Assuming the condition is true
55
Taking true branch
1325 const uint64_t Limit = uint64_t(std::numeric_limits<unsigned>::max()) + 1;
56
Calling 'numeric_limits::max'
57
Returning from 'numeric_limits::max'
1326 uint64_t Val64 = Token.integerValue().getLimitedValue(Limit);
58
Calling 'MIToken::integerValue'
59
Returning from 'MIToken::integerValue'
1327 if (Val64 == Limit)
60
Assuming 'Val64' is equal to 'Limit'
61
Taking true branch
1328 return error("expected 32-bit integer (too large)");
62
Calling 'MIParser::error'
65
Returning from 'MIParser::error'
1329 Result = Val64;
1330 return false;
1331 }
1332 if (Token.is(MIToken::HexLiteral)) {
11
Calling 'MIToken::is'
12
Returning from 'MIToken::is'
13
Taking true branch
33
Calling 'MIToken::is'
34
Returning from 'MIToken::is'
35
Taking true branch
1333 APInt A;
14
Calling default constructor for 'APInt'
17
Returning from default constructor for 'APInt'
36
Calling default constructor for 'APInt'
39
Returning from default constructor for 'APInt'
1334 if (getHexUint(A))
18
Assuming the condition is false
19
Taking false branch
40
Assuming the condition is false
41
Taking false branch
1335 return true;
1336 if (A.getBitWidth() > 32)
20
Calling 'APInt::getBitWidth'
21
Returning from 'APInt::getBitWidth'
22
Assuming the condition is false
23
Taking false branch
42
Calling 'APInt::getBitWidth'
43
Returning from 'APInt::getBitWidth'
44
Assuming the condition is false
45
Taking false branch
1337 return error("expected 32-bit integer (too large)");
1338 Result = A.getZExtValue();
1339 return false;
1340 }
1341 return true;
1342}
1343
1344bool MIParser::parseMBBReference(MachineBasicBlock *&MBB) {
1345 assert(Token.is(MIToken::MachineBasicBlock) ||(static_cast <bool> (Token.is(MIToken::MachineBasicBlock
) || Token.is(MIToken::MachineBasicBlockLabel)) ? void (0) : __assert_fail
("Token.is(MIToken::MachineBasicBlock) || Token.is(MIToken::MachineBasicBlockLabel)"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1346, __extension__ __PRETTY_FUNCTION__))
1346 Token.is(MIToken::MachineBasicBlockLabel))(static_cast <bool> (Token.is(MIToken::MachineBasicBlock
) || Token.is(MIToken::MachineBasicBlockLabel)) ? void (0) : __assert_fail
("Token.is(MIToken::MachineBasicBlock) || Token.is(MIToken::MachineBasicBlockLabel)"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1346, __extension__ __PRETTY_FUNCTION__))
;
1347 unsigned Number;
1348 if (getUnsigned(Number))
1349 return true;
1350 auto MBBInfo = PFS.MBBSlots.find(Number);
1351 if (MBBInfo == PFS.MBBSlots.end())
1352 return error(Twine("use of undefined machine basic block #") +
1353 Twine(Number));
1354 MBB = MBBInfo->second;
1355 // TODO: Only parse the name if it's a MachineBasicBlockLabel. Deprecate once
1356 // we drop the <irname> from the bb.<id>.<irname> format.
1357 if (!Token.stringValue().empty() && Token.stringValue() != MBB->getName())
1358 return error(Twine("the name of machine basic block #") + Twine(Number) +
1359 " isn't '" + Token.stringValue() + "'");
1360 return false;
1361}
1362
1363bool MIParser::parseMBBOperand(MachineOperand &Dest) {
1364 MachineBasicBlock *MBB;
1365 if (parseMBBReference(MBB))
1366 return true;
1367 Dest = MachineOperand::CreateMBB(MBB);
1368 lex();
1369 return false;
1370}
1371
1372bool MIParser::parseStackFrameIndex(int &FI) {
1373 assert(Token.is(MIToken::StackObject))(static_cast <bool> (Token.is(MIToken::StackObject)) ? void
(0) : __assert_fail ("Token.is(MIToken::StackObject)", "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1373, __extension__ __PRETTY_FUNCTION__))
;
1374 unsigned ID;
1375 if (getUnsigned(ID))
1376 return true;
1377 auto ObjectInfo = PFS.StackObjectSlots.find(ID);
1378 if (ObjectInfo == PFS.StackObjectSlots.end())
1379 return error(Twine("use of undefined stack object '%stack.") + Twine(ID) +
1380 "'");
1381 StringRef Name;
1382 if (const auto *Alloca =
1383 MF.getFrameInfo().getObjectAllocation(ObjectInfo->second))
1384 Name = Alloca->getName();
1385 if (!Token.stringValue().empty() && Token.stringValue() != Name)
1386 return error(Twine("the name of the stack object '%stack.") + Twine(ID) +
1387 "' isn't '" + Token.stringValue() + "'");
1388 lex();
1389 FI = ObjectInfo->second;
1390 return false;
1391}
1392
1393bool MIParser::parseStackObjectOperand(MachineOperand &Dest) {
1394 int FI;
1395 if (parseStackFrameIndex(FI))
1396 return true;
1397 Dest = MachineOperand::CreateFI(FI);
1398 return false;
1399}
1400
1401bool MIParser::parseFixedStackFrameIndex(int &FI) {
1402 assert(Token.is(MIToken::FixedStackObject))(static_cast <bool> (Token.is(MIToken::FixedStackObject
)) ? void (0) : __assert_fail ("Token.is(MIToken::FixedStackObject)"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1402, __extension__ __PRETTY_FUNCTION__))
;
1403 unsigned ID;
1404 if (getUnsigned(ID))
1405 return true;
1406 auto ObjectInfo = PFS.FixedStackObjectSlots.find(ID);
1407 if (ObjectInfo == PFS.FixedStackObjectSlots.end())
1408 return error(Twine("use of undefined fixed stack object '%fixed-stack.") +
1409 Twine(ID) + "'");
1410 lex();
1411 FI = ObjectInfo->second;
1412 return false;
1413}
1414
1415bool MIParser::parseFixedStackObjectOperand(MachineOperand &Dest) {
1416 int FI;
1417 if (parseFixedStackFrameIndex(FI))
1418 return true;
1419 Dest = MachineOperand::CreateFI(FI);
1420 return false;
1421}
1422
1423bool MIParser::parseGlobalValue(GlobalValue *&GV) {
1424 switch (Token.kind()) {
1425 case MIToken::NamedGlobalValue: {
1426 const Module *M = MF.getFunction().getParent();
1427 GV = M->getNamedValue(Token.stringValue());
1428 if (!GV)
1429 return error(Twine("use of undefined global value '") + Token.range() +
1430 "'");
1431 break;
1432 }
1433 case MIToken::GlobalValue: {
1434 unsigned GVIdx;
1435 if (getUnsigned(GVIdx))
1436 return true;
1437 if (GVIdx >= PFS.IRSlots.GlobalValues.size())
1438 return error(Twine("use of undefined global value '@") + Twine(GVIdx) +
1439 "'");
1440 GV = PFS.IRSlots.GlobalValues[GVIdx];
1441 break;
1442 }
1443 default:
1444 llvm_unreachable("The current token should be a global value")::llvm::llvm_unreachable_internal("The current token should be a global value"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1444)
;
1445 }
1446 return false;
1447}
1448
1449bool MIParser::parseGlobalAddressOperand(MachineOperand &Dest) {
1450 GlobalValue *GV = nullptr;
1451 if (parseGlobalValue(GV))
1452 return true;
1453 lex();
1454 Dest = MachineOperand::CreateGA(GV, /*Offset=*/0);
1455 if (parseOperandsOffset(Dest))
1456 return true;
1457 return false;
1458}
1459
1460bool MIParser::parseConstantPoolIndexOperand(MachineOperand &Dest) {
1461 assert(Token.is(MIToken::ConstantPoolItem))(static_cast <bool> (Token.is(MIToken::ConstantPoolItem
)) ? void (0) : __assert_fail ("Token.is(MIToken::ConstantPoolItem)"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1461, __extension__ __PRETTY_FUNCTION__))
;
1462 unsigned ID;
1463 if (getUnsigned(ID))
1464 return true;
1465 auto ConstantInfo = PFS.ConstantPoolSlots.find(ID);
1466 if (ConstantInfo == PFS.ConstantPoolSlots.end())
1467 return error("use of undefined constant '%const." + Twine(ID) + "'");
1468 lex();
1469 Dest = MachineOperand::CreateCPI(ID, /*Offset=*/0);
1470 if (parseOperandsOffset(Dest))
1471 return true;
1472 return false;
1473}
1474
1475bool MIParser::parseJumpTableIndexOperand(MachineOperand &Dest) {
1476 assert(Token.is(MIToken::JumpTableIndex))(static_cast <bool> (Token.is(MIToken::JumpTableIndex))
? void (0) : __assert_fail ("Token.is(MIToken::JumpTableIndex)"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1476, __extension__ __PRETTY_FUNCTION__))
;
1477 unsigned ID;
1478 if (getUnsigned(ID))
1479 return true;
1480 auto JumpTableEntryInfo = PFS.JumpTableSlots.find(ID);
1481 if (JumpTableEntryInfo == PFS.JumpTableSlots.end())
1482 return error("use of undefined jump table '%jump-table." + Twine(ID) + "'");
1483 lex();
1484 Dest = MachineOperand::CreateJTI(JumpTableEntryInfo->second);
1485 return false;
1486}
1487
1488bool MIParser::parseExternalSymbolOperand(MachineOperand &Dest) {
1489 assert(Token.is(MIToken::ExternalSymbol))(static_cast <bool> (Token.is(MIToken::ExternalSymbol))
? void (0) : __assert_fail ("Token.is(MIToken::ExternalSymbol)"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1489, __extension__ __PRETTY_FUNCTION__))
;
1490 const char *Symbol = MF.createExternalSymbolName(Token.stringValue());
1491 lex();
1492 Dest = MachineOperand::CreateES(Symbol);
1493 if (parseOperandsOffset(Dest))
1494 return true;
1495 return false;
1496}
1497
1498bool MIParser::parseSubRegisterIndexOperand(MachineOperand &Dest) {
1499 assert(Token.is(MIToken::SubRegisterIndex))(static_cast <bool> (Token.is(MIToken::SubRegisterIndex
)) ? void (0) : __assert_fail ("Token.is(MIToken::SubRegisterIndex)"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1499, __extension__ __PRETTY_FUNCTION__))
;
1500 StringRef Name = Token.stringValue();
1501 unsigned SubRegIndex = getSubRegIndex(Token.stringValue());
1502 if (SubRegIndex == 0)
1503 return error(Twine("unknown subregister index '") + Name + "'");
1504 lex();
1505 Dest = MachineOperand::CreateImm(SubRegIndex);
1506 return false;
1507}
1508
1509bool MIParser::parseMDNode(MDNode *&Node) {
1510 assert(Token.is(MIToken::exclaim))(static_cast <bool> (Token.is(MIToken::exclaim)) ? void
(0) : __assert_fail ("Token.is(MIToken::exclaim)", "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1510, __extension__ __PRETTY_FUNCTION__))
;
1511
1512 auto Loc = Token.location();
1513 lex();
1514 if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
1515 return error("expected metadata id after '!'");
1516 unsigned ID;
1517 if (getUnsigned(ID))
1518 return true;
1519 auto NodeInfo = PFS.IRSlots.MetadataNodes.find(ID);
1520 if (NodeInfo == PFS.IRSlots.MetadataNodes.end())
1521 return error(Loc, "use of undefined metadata '!" + Twine(ID) + "'");
1522 lex();
1523 Node = NodeInfo->second.get();
1524 return false;
1525}
1526
1527bool MIParser::parseDIExpression(MDNode *&Expr) {
1528 assert(Token.is(MIToken::md_diexpr))(static_cast <bool> (Token.is(MIToken::md_diexpr)) ? void
(0) : __assert_fail ("Token.is(MIToken::md_diexpr)", "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1528, __extension__ __PRETTY_FUNCTION__))
;
1529 lex();
1530
1531 // FIXME: Share this parsing with the IL parser.
1532 SmallVector<uint64_t, 8> Elements;
1533
1534 if (expectAndConsume(MIToken::lparen))
1535 return true;
1536
1537 if (Token.isNot(MIToken::rparen)) {
1538 do {
1539 if (Token.is(MIToken::Identifier)) {
1540 if (unsigned Op = dwarf::getOperationEncoding(Token.stringValue())) {
1541 lex();
1542 Elements.push_back(Op);
1543 continue;
1544 }
1545 return error(Twine("invalid DWARF op '") + Token.stringValue() + "'");
1546 }
1547
1548 if (Token.isNot(MIToken::IntegerLiteral) ||
1549 Token.integerValue().isSigned())
1550 return error("expected unsigned integer");
1551
1552 auto &U = Token.integerValue();
1553 if (U.ugt(UINT64_MAX(18446744073709551615UL)))
1554 return error("element too large, limit is " + Twine(UINT64_MAX(18446744073709551615UL)));
1555 Elements.push_back(U.getZExtValue());
1556 lex();
1557
1558 } while (consumeIfPresent(MIToken::comma));
1559 }
1560
1561 if (expectAndConsume(MIToken::rparen))
1562 return true;
1563
1564 Expr = DIExpression::get(MF.getFunction().getContext(), Elements);
1565 return false;
1566}
1567
1568bool MIParser::parseMetadataOperand(MachineOperand &Dest) {
1569 MDNode *Node = nullptr;
1570 if (Token.is(MIToken::exclaim)) {
1571 if (parseMDNode(Node))
1572 return true;
1573 } else if (Token.is(MIToken::md_diexpr)) {
1574 if (parseDIExpression(Node))
1575 return true;
1576 }
1577 Dest = MachineOperand::CreateMetadata(Node);
1578 return false;
1579}
1580
1581bool MIParser::parseCFIOffset(int &Offset) {
1582 if (Token.isNot(MIToken::IntegerLiteral))
1583 return error("expected a cfi offset");
1584 if (Token.integerValue().getMinSignedBits() > 32)
1585 return error("expected a 32 bit integer (the cfi offset is too large)");
1586 Offset = (int)Token.integerValue().getExtValue();
1587 lex();
1588 return false;
1589}
1590
1591bool MIParser::parseCFIRegister(unsigned &Reg) {
1592 if (Token.isNot(MIToken::NamedRegister))
1593 return error("expected a cfi register");
1594 unsigned LLVMReg;
1595 if (parseNamedRegister(LLVMReg))
1596 return true;
1597 const auto *TRI = MF.getSubtarget().getRegisterInfo();
1598 assert(TRI && "Expected target register info")(static_cast <bool> (TRI && "Expected target register info"
) ? void (0) : __assert_fail ("TRI && \"Expected target register info\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1598, __extension__ __PRETTY_FUNCTION__))
;
1599 int DwarfReg = TRI->getDwarfRegNum(LLVMReg, true);
1600 if (DwarfReg < 0)
1601 return error("invalid DWARF register");
1602 Reg = (unsigned)DwarfReg;
1603 lex();
1604 return false;
1605}
1606
1607bool MIParser::parseCFIEscapeValues(std::string &Values) {
1608 do {
28
Loop condition is true. Execution continues on line 1609
50
Loop condition is true. Execution continues on line 1609
1609 if (Token.isNot(MIToken::HexLiteral))
7
Taking false branch
29
Taking false branch
51
Taking false branch
1610 return error("expected a hexadecimal literal");
1611 unsigned Value;
52
'Value' declared without an initial value
1612 if (getUnsigned(Value))
8
Calling 'MIParser::getUnsigned'
24
Returning from 'MIParser::getUnsigned'
25
Taking false branch
30
Calling 'MIParser::getUnsigned'
46
Returning from 'MIParser::getUnsigned'
47
Taking false branch
53
Calling 'MIParser::getUnsigned'
66
Returning from 'MIParser::getUnsigned'
67
Assuming the condition is false
68
Taking false branch
1613 return true;
1614 if (Value > UINT8_MAX(255))
26
Assuming 'Value' is <= UINT8_MAX
27
Taking false branch
48
Assuming 'Value' is <= UINT8_MAX
49
Taking false branch
69
The left operand of '>' is a garbage value
1615 return error("expected a 8-bit integer (too large)");
1616 Values.push_back(static_cast<uint8_t>(Value));
1617 lex();
1618 } while (consumeIfPresent(MIToken::comma));
1619 return false;
1620}
1621
1622bool MIParser::parseCFIOperand(MachineOperand &Dest) {
1623 auto Kind = Token.kind();
1624 lex();
1625 int Offset;
1626 unsigned Reg;
1627 unsigned CFIIndex;
1628 switch (Kind) {
5
Control jumps to 'case kw_cfi_escape:' at line 1704
1629 case MIToken::kw_cfi_same_value:
1630 if (parseCFIRegister(Reg))
1631 return true;
1632 CFIIndex = MF.addFrameInst(MCCFIInstruction::createSameValue(nullptr, Reg));
1633 break;
1634 case MIToken::kw_cfi_offset:
1635 if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1636 parseCFIOffset(Offset))
1637 return true;
1638 CFIIndex =
1639 MF.addFrameInst(MCCFIInstruction::createOffset(nullptr, Reg, Offset));
1640 break;
1641 case MIToken::kw_cfi_rel_offset:
1642 if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1643 parseCFIOffset(Offset))
1644 return true;
1645 CFIIndex = MF.addFrameInst(
1646 MCCFIInstruction::createRelOffset(nullptr, Reg, Offset));
1647 break;
1648 case MIToken::kw_cfi_def_cfa_register:
1649 if (parseCFIRegister(Reg))
1650 return true;
1651 CFIIndex =
1652 MF.addFrameInst(MCCFIInstruction::createDefCfaRegister(nullptr, Reg));
1653 break;
1654 case MIToken::kw_cfi_def_cfa_offset:
1655 if (parseCFIOffset(Offset))
1656 return true;
1657 // NB: MCCFIInstruction::createDefCfaOffset negates the offset.
1658 CFIIndex = MF.addFrameInst(
1659 MCCFIInstruction::createDefCfaOffset(nullptr, -Offset));
1660 break;
1661 case MIToken::kw_cfi_adjust_cfa_offset:
1662 if (parseCFIOffset(Offset))
1663 return true;
1664 CFIIndex = MF.addFrameInst(
1665 MCCFIInstruction::createAdjustCfaOffset(nullptr, Offset));
1666 break;
1667 case MIToken::kw_cfi_def_cfa:
1668 if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1669 parseCFIOffset(Offset))
1670 return true;
1671 // NB: MCCFIInstruction::createDefCfa negates the offset.
1672 CFIIndex =
1673 MF.addFrameInst(MCCFIInstruction::createDefCfa(nullptr, Reg, -Offset));
1674 break;
1675 case MIToken::kw_cfi_remember_state:
1676 CFIIndex = MF.addFrameInst(MCCFIInstruction::createRememberState(nullptr));
1677 break;
1678 case MIToken::kw_cfi_restore:
1679 if (parseCFIRegister(Reg))
1680 return true;
1681 CFIIndex = MF.addFrameInst(MCCFIInstruction::createRestore(nullptr, Reg));
1682 break;
1683 case MIToken::kw_cfi_restore_state:
1684 CFIIndex = MF.addFrameInst(MCCFIInstruction::createRestoreState(nullptr));
1685 break;
1686 case MIToken::kw_cfi_undefined:
1687 if (parseCFIRegister(Reg))
1688 return true;
1689 CFIIndex = MF.addFrameInst(MCCFIInstruction::createUndefined(nullptr, Reg));
1690 break;
1691 case MIToken::kw_cfi_register: {
1692 unsigned Reg2;
1693 if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1694 parseCFIRegister(Reg2))
1695 return true;
1696
1697 CFIIndex =
1698 MF.addFrameInst(MCCFIInstruction::createRegister(nullptr, Reg, Reg2));
1699 break;
1700 }
1701 case MIToken::kw_cfi_window_save:
1702 CFIIndex = MF.addFrameInst(MCCFIInstruction::createWindowSave(nullptr));
1703 break;
1704 case MIToken::kw_cfi_escape: {
1705 std::string Values;
1706 if (parseCFIEscapeValues(Values))
6
Calling 'MIParser::parseCFIEscapeValues'
1707 return true;
1708 CFIIndex = MF.addFrameInst(MCCFIInstruction::createEscape(nullptr, Values));
1709 break;
1710 }
1711 default:
1712 // TODO: Parse the other CFI operands.
1713 llvm_unreachable("The current token should be a cfi operand")::llvm::llvm_unreachable_internal("The current token should be a cfi operand"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1713)
;
1714 }
1715 Dest = MachineOperand::CreateCFIIndex(CFIIndex);
1716 return false;
1717}
1718
1719bool MIParser::parseIRBlock(BasicBlock *&BB, const Function &F) {
1720 switch (Token.kind()) {
1721 case MIToken::NamedIRBlock: {
1722 BB = dyn_cast_or_null<BasicBlock>(
1723 F.getValueSymbolTable()->lookup(Token.stringValue()));
1724 if (!BB)
1725 return error(Twine("use of undefined IR block '") + Token.range() + "'");
1726 break;
1727 }
1728 case MIToken::IRBlock: {
1729 unsigned SlotNumber = 0;
1730 if (getUnsigned(SlotNumber))
1731 return true;
1732 BB = const_cast<BasicBlock *>(getIRBlock(SlotNumber, F));
1733 if (!BB)
1734 return error(Twine("use of undefined IR block '%ir-block.") +
1735 Twine(SlotNumber) + "'");
1736 break;
1737 }
1738 default:
1739 llvm_unreachable("The current token should be an IR block reference")::llvm::llvm_unreachable_internal("The current token should be an IR block reference"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1739)
;
1740 }
1741 return false;
1742}
1743
1744bool MIParser::parseBlockAddressOperand(MachineOperand &Dest) {
1745 assert(Token.is(MIToken::kw_blockaddress))(static_cast <bool> (Token.is(MIToken::kw_blockaddress)
) ? void (0) : __assert_fail ("Token.is(MIToken::kw_blockaddress)"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1745, __extension__ __PRETTY_FUNCTION__))
;
1746 lex();
1747 if (expectAndConsume(MIToken::lparen))
1748 return true;
1749 if (Token.isNot(MIToken::GlobalValue) &&
1750 Token.isNot(MIToken::NamedGlobalValue))
1751 return error("expected a global value");
1752 GlobalValue *GV = nullptr;
1753 if (parseGlobalValue(GV))
1754 return true;
1755 auto *F = dyn_cast<Function>(GV);
1756 if (!F)
1757 return error("expected an IR function reference");
1758 lex();
1759 if (expectAndConsume(MIToken::comma))
1760 return true;
1761 BasicBlock *BB = nullptr;
1762 if (Token.isNot(MIToken::IRBlock) && Token.isNot(MIToken::NamedIRBlock))
1763 return error("expected an IR block reference");
1764 if (parseIRBlock(BB, *F))
1765 return true;
1766 lex();
1767 if (expectAndConsume(MIToken::rparen))
1768 return true;
1769 Dest = MachineOperand::CreateBA(BlockAddress::get(F, BB), /*Offset=*/0);
1770 if (parseOperandsOffset(Dest))
1771 return true;
1772 return false;
1773}
1774
1775bool MIParser::parseIntrinsicOperand(MachineOperand &Dest) {
1776 assert(Token.is(MIToken::kw_intrinsic))(static_cast <bool> (Token.is(MIToken::kw_intrinsic)) ?
void (0) : __assert_fail ("Token.is(MIToken::kw_intrinsic)",
"/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1776, __extension__ __PRETTY_FUNCTION__))
;
1777 lex();
1778 if (expectAndConsume(MIToken::lparen))
1779 return error("expected syntax intrinsic(@llvm.whatever)");
1780
1781 if (Token.isNot(MIToken::NamedGlobalValue))
1782 return error("expected syntax intrinsic(@llvm.whatever)");
1783
1784 std::string Name = Token.stringValue();
1785 lex();
1786
1787 if (expectAndConsume(MIToken::rparen))
1788 return error("expected ')' to terminate intrinsic name");
1789
1790 // Find out what intrinsic we're dealing with, first try the global namespace
1791 // and then the target's private intrinsics if that fails.
1792 const TargetIntrinsicInfo *TII = MF.getTarget().getIntrinsicInfo();
1793 Intrinsic::ID ID = Function::lookupIntrinsicID(Name);
1794 if (ID == Intrinsic::not_intrinsic && TII)
1795 ID = static_cast<Intrinsic::ID>(TII->lookupName(Name));
1796
1797 if (ID == Intrinsic::not_intrinsic)
1798 return error("unknown intrinsic name");
1799 Dest = MachineOperand::CreateIntrinsicID(ID);
1800
1801 return false;
1802}
1803
1804bool MIParser::parsePredicateOperand(MachineOperand &Dest) {
1805 assert(Token.is(MIToken::kw_intpred) || Token.is(MIToken::kw_floatpred))(static_cast <bool> (Token.is(MIToken::kw_intpred) || Token
.is(MIToken::kw_floatpred)) ? void (0) : __assert_fail ("Token.is(MIToken::kw_intpred) || Token.is(MIToken::kw_floatpred)"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1805, __extension__ __PRETTY_FUNCTION__))
;
1806 bool IsFloat = Token.is(MIToken::kw_floatpred);
1807 lex();
1808
1809 if (expectAndConsume(MIToken::lparen))
1810 return error("expected syntax intpred(whatever) or floatpred(whatever");
1811
1812 if (Token.isNot(MIToken::Identifier))
1813 return error("whatever");
1814
1815 CmpInst::Predicate Pred;
1816 if (IsFloat) {
1817 Pred = StringSwitch<CmpInst::Predicate>(Token.stringValue())
1818 .Case("false", CmpInst::FCMP_FALSE)
1819 .Case("oeq", CmpInst::FCMP_OEQ)
1820 .Case("ogt", CmpInst::FCMP_OGT)
1821 .Case("oge", CmpInst::FCMP_OGE)
1822 .Case("olt", CmpInst::FCMP_OLT)
1823 .Case("ole", CmpInst::FCMP_OLE)
1824 .Case("one", CmpInst::FCMP_ONE)
1825 .Case("ord", CmpInst::FCMP_ORD)
1826 .Case("uno", CmpInst::FCMP_UNO)
1827 .Case("ueq", CmpInst::FCMP_UEQ)
1828 .Case("ugt", CmpInst::FCMP_UGT)
1829 .Case("uge", CmpInst::FCMP_UGE)
1830 .Case("ult", CmpInst::FCMP_ULT)
1831 .Case("ule", CmpInst::FCMP_ULE)
1832 .Case("une", CmpInst::FCMP_UNE)
1833 .Case("true", CmpInst::FCMP_TRUE)
1834 .Default(CmpInst::BAD_FCMP_PREDICATE);
1835 if (!CmpInst::isFPPredicate(Pred))
1836 return error("invalid floating-point predicate");
1837 } else {
1838 Pred = StringSwitch<CmpInst::Predicate>(Token.stringValue())
1839 .Case("eq", CmpInst::ICMP_EQ)
1840 .Case("ne", CmpInst::ICMP_NE)
1841 .Case("sgt", CmpInst::ICMP_SGT)
1842 .Case("sge", CmpInst::ICMP_SGE)
1843 .Case("slt", CmpInst::ICMP_SLT)
1844 .Case("sle", CmpInst::ICMP_SLE)
1845 .Case("ugt", CmpInst::ICMP_UGT)
1846 .Case("uge", CmpInst::ICMP_UGE)
1847 .Case("ult", CmpInst::ICMP_ULT)
1848 .Case("ule", CmpInst::ICMP_ULE)
1849 .Default(CmpInst::BAD_ICMP_PREDICATE);
1850 if (!CmpInst::isIntPredicate(Pred))
1851 return error("invalid integer predicate");
1852 }
1853
1854 lex();
1855 Dest = MachineOperand::CreatePredicate(Pred);
1856 if (expectAndConsume(MIToken::rparen))
1857 return error("predicate should be terminated by ')'.");
1858
1859 return false;
1860}
1861
1862bool MIParser::parseTargetIndexOperand(MachineOperand &Dest) {
1863 assert(Token.is(MIToken::kw_target_index))(static_cast <bool> (Token.is(MIToken::kw_target_index)
) ? void (0) : __assert_fail ("Token.is(MIToken::kw_target_index)"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1863, __extension__ __PRETTY_FUNCTION__))
;
1864 lex();
1865 if (expectAndConsume(MIToken::lparen))
1866 return true;
1867 if (Token.isNot(MIToken::Identifier))
1868 return error("expected the name of the target index");
1869 int Index = 0;
1870 if (getTargetIndex(Token.stringValue(), Index))
1871 return error("use of undefined target index '" + Token.stringValue() + "'");
1872 lex();
1873 if (expectAndConsume(MIToken::rparen))
1874 return true;
1875 Dest = MachineOperand::CreateTargetIndex(unsigned(Index), /*Offset=*/0);
1876 if (parseOperandsOffset(Dest))
1877 return true;
1878 return false;
1879}
1880
1881bool MIParser::parseCustomRegisterMaskOperand(MachineOperand &Dest) {
1882 assert(Token.stringValue() == "CustomRegMask" && "Expected a custom RegMask")(static_cast <bool> (Token.stringValue() == "CustomRegMask"
&& "Expected a custom RegMask") ? void (0) : __assert_fail
("Token.stringValue() == \"CustomRegMask\" && \"Expected a custom RegMask\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1882, __extension__ __PRETTY_FUNCTION__))
;
1883 const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
1884 assert(TRI && "Expected target register info")(static_cast <bool> (TRI && "Expected target register info"
) ? void (0) : __assert_fail ("TRI && \"Expected target register info\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1884, __extension__ __PRETTY_FUNCTION__))
;
1885 lex();
1886 if (expectAndConsume(MIToken::lparen))
1887 return true;
1888
1889 uint32_t *Mask = MF.allocateRegisterMask(TRI->getNumRegs());
1890 while (true) {
1891 if (Token.isNot(MIToken::NamedRegister))
1892 return error("expected a named register");
1893 unsigned Reg;
1894 if (parseNamedRegister(Reg))
1895 return true;
1896 lex();
1897 Mask[Reg / 32] |= 1U << (Reg % 32);
1898 // TODO: Report an error if the same register is used more than once.
1899 if (Token.isNot(MIToken::comma))
1900 break;
1901 lex();
1902 }
1903
1904 if (expectAndConsume(MIToken::rparen))
1905 return true;
1906 Dest = MachineOperand::CreateRegMask(Mask);
1907 return false;
1908}
1909
1910bool MIParser::parseLiveoutRegisterMaskOperand(MachineOperand &Dest) {
1911 assert(Token.is(MIToken::kw_liveout))(static_cast <bool> (Token.is(MIToken::kw_liveout)) ? void
(0) : __assert_fail ("Token.is(MIToken::kw_liveout)", "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1911, __extension__ __PRETTY_FUNCTION__))
;
1912 const auto *TRI = MF.getSubtarget().getRegisterInfo();
1913 assert(TRI && "Expected target register info")(static_cast <bool> (TRI && "Expected target register info"
) ? void (0) : __assert_fail ("TRI && \"Expected target register info\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 1913, __extension__ __PRETTY_FUNCTION__))
;
1914 uint32_t *Mask = MF.allocateRegisterMask(TRI->getNumRegs());
1915 lex();
1916 if (expectAndConsume(MIToken::lparen))
1917 return true;
1918 while (true) {
1919 if (Token.isNot(MIToken::NamedRegister))
1920 return error("expected a named register");
1921 unsigned Reg;
1922 if (parseNamedRegister(Reg))
1923 return true;
1924 lex();
1925 Mask[Reg / 32] |= 1U << (Reg % 32);
1926 // TODO: Report an error if the same register is used more than once.
1927 if (Token.isNot(MIToken::comma))
1928 break;
1929 lex();
1930 }
1931 if (expectAndConsume(MIToken::rparen))
1932 return true;
1933 Dest = MachineOperand::CreateRegLiveOut(Mask);
1934 return false;
1935}
1936
1937bool MIParser::parseMachineOperand(MachineOperand &Dest,
1938 Optional<unsigned> &TiedDefIdx) {
1939 switch (Token.kind()) {
3
Control jumps to 'case kw_cfi_escape:' at line 1991
1940 case MIToken::kw_implicit:
1941 case MIToken::kw_implicit_define:
1942 case MIToken::kw_def:
1943 case MIToken::kw_dead:
1944 case MIToken::kw_killed:
1945 case MIToken::kw_undef:
1946 case MIToken::kw_internal:
1947 case MIToken::kw_early_clobber:
1948 case MIToken::kw_debug_use:
1949 case MIToken::kw_renamable:
1950 case MIToken::underscore:
1951 case MIToken::NamedRegister:
1952 case MIToken::VirtualRegister:
1953 return parseRegisterOperand(Dest, TiedDefIdx);
1954 case MIToken::IntegerLiteral:
1955 return parseImmediateOperand(Dest);
1956 case MIToken::IntegerType:
1957 return parseTypedImmediateOperand(Dest);
1958 case MIToken::kw_half:
1959 case MIToken::kw_float:
1960 case MIToken::kw_double:
1961 case MIToken::kw_x86_fp80:
1962 case MIToken::kw_fp128:
1963 case MIToken::kw_ppc_fp128:
1964 return parseFPImmediateOperand(Dest);
1965 case MIToken::MachineBasicBlock:
1966 return parseMBBOperand(Dest);
1967 case MIToken::StackObject:
1968 return parseStackObjectOperand(Dest);
1969 case MIToken::FixedStackObject:
1970 return parseFixedStackObjectOperand(Dest);
1971 case MIToken::GlobalValue:
1972 case MIToken::NamedGlobalValue:
1973 return parseGlobalAddressOperand(Dest);
1974 case MIToken::ConstantPoolItem:
1975 return parseConstantPoolIndexOperand(Dest);
1976 case MIToken::JumpTableIndex:
1977 return parseJumpTableIndexOperand(Dest);
1978 case MIToken::ExternalSymbol:
1979 return parseExternalSymbolOperand(Dest);
1980 case MIToken::SubRegisterIndex:
1981 return parseSubRegisterIndexOperand(Dest);
1982 case MIToken::md_diexpr:
1983 case MIToken::exclaim:
1984 return parseMetadataOperand(Dest);
1985 case MIToken::kw_cfi_same_value:
1986 case MIToken::kw_cfi_offset:
1987 case MIToken::kw_cfi_rel_offset:
1988 case MIToken::kw_cfi_def_cfa_register:
1989 case MIToken::kw_cfi_def_cfa_offset:
1990 case MIToken::kw_cfi_adjust_cfa_offset:
1991 case MIToken::kw_cfi_escape:
1992 case MIToken::kw_cfi_def_cfa:
1993 case MIToken::kw_cfi_register:
1994 case MIToken::kw_cfi_remember_state:
1995 case MIToken::kw_cfi_restore:
1996 case MIToken::kw_cfi_restore_state:
1997 case MIToken::kw_cfi_undefined:
1998 case MIToken::kw_cfi_window_save:
1999 return parseCFIOperand(Dest);
4
Calling 'MIParser::parseCFIOperand'
2000 case MIToken::kw_blockaddress:
2001 return parseBlockAddressOperand(Dest);
2002 case MIToken::kw_intrinsic:
2003 return parseIntrinsicOperand(Dest);
2004 case MIToken::kw_target_index:
2005 return parseTargetIndexOperand(Dest);
2006 case MIToken::kw_liveout:
2007 return parseLiveoutRegisterMaskOperand(Dest);
2008 case MIToken::kw_floatpred:
2009 case MIToken::kw_intpred:
2010 return parsePredicateOperand(Dest);
2011 case MIToken::Error:
2012 return true;
2013 case MIToken::Identifier:
2014 if (const auto *RegMask = getRegMask(Token.stringValue())) {
2015 Dest = MachineOperand::CreateRegMask(RegMask);
2016 lex();
2017 break;
2018 } else
2019 return parseCustomRegisterMaskOperand(Dest);
2020 default:
2021 // FIXME: Parse the MCSymbol machine operand.
2022 return error("expected a machine operand");
2023 }
2024 return false;
2025}
2026
2027bool MIParser::parseMachineOperandAndTargetFlags(
2028 MachineOperand &Dest, Optional<unsigned> &TiedDefIdx) {
2029 unsigned TF = 0;
2030 bool HasTargetFlags = false;
2031 if (Token.is(MIToken::kw_target_flags)) {
1
Taking false branch
2032 HasTargetFlags = true;
2033 lex();
2034 if (expectAndConsume(MIToken::lparen))
2035 return true;
2036 if (Token.isNot(MIToken::Identifier))
2037 return error("expected the name of the target flag");
2038 if (getDirectTargetFlag(Token.stringValue(), TF)) {
2039 if (getBitmaskTargetFlag(Token.stringValue(), TF))
2040 return error("use of undefined target flag '" + Token.stringValue() +
2041 "'");
2042 }
2043 lex();
2044 while (Token.is(MIToken::comma)) {
2045 lex();
2046 if (Token.isNot(MIToken::Identifier))
2047 return error("expected the name of the target flag");
2048 unsigned BitFlag = 0;
2049 if (getBitmaskTargetFlag(Token.stringValue(), BitFlag))
2050 return error("use of undefined target flag '" + Token.stringValue() +
2051 "'");
2052 // TODO: Report an error when using a duplicate bit target flag.
2053 TF |= BitFlag;
2054 lex();
2055 }
2056 if (expectAndConsume(MIToken::rparen))
2057 return true;
2058 }
2059 auto Loc = Token.location();
2060 if (parseMachineOperand(Dest, TiedDefIdx))
2
Calling 'MIParser::parseMachineOperand'
2061 return true;
2062 if (!HasTargetFlags)
2063 return false;
2064 if (Dest.isReg())
2065 return error(Loc, "register operands can't have target flags");
2066 Dest.setTargetFlags(TF);
2067 return false;
2068}
2069
2070bool MIParser::parseOffset(int64_t &Offset) {
2071 if (Token.isNot(MIToken::plus) && Token.isNot(MIToken::minus))
2072 return false;
2073 StringRef Sign = Token.range();
2074 bool IsNegative = Token.is(MIToken::minus);
2075 lex();
2076 if (Token.isNot(MIToken::IntegerLiteral))
2077 return error("expected an integer literal after '" + Sign + "'");
2078 if (Token.integerValue().getMinSignedBits() > 64)
2079 return error("expected 64-bit integer (too large)");
2080 Offset = Token.integerValue().getExtValue();
2081 if (IsNegative)
2082 Offset = -Offset;
2083 lex();
2084 return false;
2085}
2086
2087bool MIParser::parseAlignment(unsigned &Alignment) {
2088 assert(Token.is(MIToken::kw_align))(static_cast <bool> (Token.is(MIToken::kw_align)) ? void
(0) : __assert_fail ("Token.is(MIToken::kw_align)", "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 2088, __extension__ __PRETTY_FUNCTION__))
;
2089 lex();
2090 if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
2091 return error("expected an integer literal after 'align'");
2092 if (getUnsigned(Alignment))
2093 return true;
2094 lex();
2095 return false;
2096}
2097
2098bool MIParser::parseAddrspace(unsigned &Addrspace) {
2099 assert(Token.is(MIToken::kw_addrspace))(static_cast <bool> (Token.is(MIToken::kw_addrspace)) ?
void (0) : __assert_fail ("Token.is(MIToken::kw_addrspace)",
"/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 2099, __extension__ __PRETTY_FUNCTION__))
;
2100 lex();
2101 if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
2102 return error("expected an integer literal after 'addrspace'");
2103 if (getUnsigned(Addrspace))
2104 return true;
2105 lex();
2106 return false;
2107}
2108
2109bool MIParser::parseOperandsOffset(MachineOperand &Op) {
2110 int64_t Offset = 0;
2111 if (parseOffset(Offset))
2112 return true;
2113 Op.setOffset(Offset);
2114 return false;
2115}
2116
2117bool MIParser::parseIRValue(const Value *&V) {
2118 switch (Token.kind()) {
2119 case MIToken::NamedIRValue: {
2120 V = MF.getFunction().getValueSymbolTable()->lookup(Token.stringValue());
2121 break;
2122 }
2123 case MIToken::IRValue: {
2124 unsigned SlotNumber = 0;
2125 if (getUnsigned(SlotNumber))
2126 return true;
2127 V = getIRValue(SlotNumber);
2128 break;
2129 }
2130 case MIToken::NamedGlobalValue:
2131 case MIToken::GlobalValue: {
2132 GlobalValue *GV = nullptr;
2133 if (parseGlobalValue(GV))
2134 return true;
2135 V = GV;
2136 break;
2137 }
2138 case MIToken::QuotedIRValue: {
2139 const Constant *C = nullptr;
2140 if (parseIRConstant(Token.location(), Token.stringValue(), C))
2141 return true;
2142 V = C;
2143 break;
2144 }
2145 default:
2146 llvm_unreachable("The current token should be an IR block reference")::llvm::llvm_unreachable_internal("The current token should be an IR block reference"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 2146)
;
2147 }
2148 if (!V)
2149 return error(Twine("use of undefined IR value '") + Token.range() + "'");
2150 return false;
2151}
2152
2153bool MIParser::getUint64(uint64_t &Result) {
2154 if (Token.hasIntegerValue()) {
2155 if (Token.integerValue().getActiveBits() > 64)
2156 return error("expected 64-bit integer (too large)");
2157 Result = Token.integerValue().getZExtValue();
2158 return false;
2159 }
2160 if (Token.is(MIToken::HexLiteral)) {
2161 APInt A;
2162 if (getHexUint(A))
2163 return true;
2164 if (A.getBitWidth() > 64)
2165 return error("expected 64-bit integer (too large)");
2166 Result = A.getZExtValue();
2167 return false;
2168 }
2169 return true;
2170}
2171
2172bool MIParser::getHexUint(APInt &Result) {
2173 assert(Token.is(MIToken::HexLiteral))(static_cast <bool> (Token.is(MIToken::HexLiteral)) ? void
(0) : __assert_fail ("Token.is(MIToken::HexLiteral)", "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 2173, __extension__ __PRETTY_FUNCTION__))
;
2174 StringRef S = Token.range();
2175 assert(S[0] == '0' && tolower(S[1]) == 'x')(static_cast <bool> (S[0] == '0' && tolower(S[1
]) == 'x') ? void (0) : __assert_fail ("S[0] == '0' && tolower(S[1]) == 'x'"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 2175, __extension__ __PRETTY_FUNCTION__))
;
2176 // This could be a floating point literal with a special prefix.
2177 if (!isxdigit(S[2]))
2178 return true;
2179 StringRef V = S.substr(2);
2180 APInt A(V.size()*4, V, 16);
2181
2182 // If A is 0, then A.getActiveBits() is 0. This isn't a valid bitwidth. Make
2183 // sure it isn't the case before constructing result.
2184 unsigned NumBits = (A == 0) ? 32 : A.getActiveBits();
2185 Result = APInt(NumBits, ArrayRef<uint64_t>(A.getRawData(), A.getNumWords()));
2186 return false;
2187}
2188
2189bool MIParser::parseMemoryOperandFlag(MachineMemOperand::Flags &Flags) {
2190 const auto OldFlags = Flags;
2191 switch (Token.kind()) {
2192 case MIToken::kw_volatile:
2193 Flags |= MachineMemOperand::MOVolatile;
2194 break;
2195 case MIToken::kw_non_temporal:
2196 Flags |= MachineMemOperand::MONonTemporal;
2197 break;
2198 case MIToken::kw_dereferenceable:
2199 Flags |= MachineMemOperand::MODereferenceable;
2200 break;
2201 case MIToken::kw_invariant:
2202 Flags |= MachineMemOperand::MOInvariant;
2203 break;
2204 case MIToken::StringConstant: {
2205 MachineMemOperand::Flags TF;
2206 if (getMMOTargetFlag(Token.stringValue(), TF))
2207 return error("use of undefined target MMO flag '" + Token.stringValue() +
2208 "'");
2209 Flags |= TF;
2210 break;
2211 }
2212 default:
2213 llvm_unreachable("The current token should be a memory operand flag")::llvm::llvm_unreachable_internal("The current token should be a memory operand flag"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 2213)
;
2214 }
2215 if (OldFlags == Flags)
2216 // We know that the same flag is specified more than once when the flags
2217 // weren't modified.
2218 return error("duplicate '" + Token.stringValue() + "' memory operand flag");
2219 lex();
2220 return false;
2221}
2222
2223bool MIParser::parseMemoryPseudoSourceValue(const PseudoSourceValue *&PSV) {
2224 switch (Token.kind()) {
2225 case MIToken::kw_stack:
2226 PSV = MF.getPSVManager().getStack();
2227 break;
2228 case MIToken::kw_got:
2229 PSV = MF.getPSVManager().getGOT();
2230 break;
2231 case MIToken::kw_jump_table:
2232 PSV = MF.getPSVManager().getJumpTable();
2233 break;
2234 case MIToken::kw_constant_pool:
2235 PSV = MF.getPSVManager().getConstantPool();
2236 break;
2237 case MIToken::FixedStackObject: {
2238 int FI;
2239 if (parseFixedStackFrameIndex(FI))
2240 return true;
2241 PSV = MF.getPSVManager().getFixedStack(FI);
2242 // The token was already consumed, so use return here instead of break.
2243 return false;
2244 }
2245 case MIToken::StackObject: {
2246 int FI;
2247 if (parseStackFrameIndex(FI))
2248 return true;
2249 PSV = MF.getPSVManager().getFixedStack(FI);
2250 // The token was already consumed, so use return here instead of break.
2251 return false;
2252 }
2253 case MIToken::kw_call_entry:
2254 lex();
2255 switch (Token.kind()) {
2256 case MIToken::GlobalValue:
2257 case MIToken::NamedGlobalValue: {
2258 GlobalValue *GV = nullptr;
2259 if (parseGlobalValue(GV))
2260 return true;
2261 PSV = MF.getPSVManager().getGlobalValueCallEntry(GV);
2262 break;
2263 }
2264 case MIToken::ExternalSymbol:
2265 PSV = MF.getPSVManager().getExternalSymbolCallEntry(
2266 MF.createExternalSymbolName(Token.stringValue()));
2267 break;
2268 default:
2269 return error(
2270 "expected a global value or an external symbol after 'call-entry'");
2271 }
2272 break;
2273 default:
2274 llvm_unreachable("The current token should be pseudo source value")::llvm::llvm_unreachable_internal("The current token should be pseudo source value"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 2274)
;
2275 }
2276 lex();
2277 return false;
2278}
2279
2280bool MIParser::parseMachinePointerInfo(MachinePointerInfo &Dest) {
2281 if (Token.is(MIToken::kw_constant_pool) || Token.is(MIToken::kw_stack) ||
2282 Token.is(MIToken::kw_got) || Token.is(MIToken::kw_jump_table) ||
2283 Token.is(MIToken::FixedStackObject) || Token.is(MIToken::StackObject) ||
2284 Token.is(MIToken::kw_call_entry)) {
2285 const PseudoSourceValue *PSV = nullptr;
2286 if (parseMemoryPseudoSourceValue(PSV))
2287 return true;
2288 int64_t Offset = 0;
2289 if (parseOffset(Offset))
2290 return true;
2291 Dest = MachinePointerInfo(PSV, Offset);
2292 return false;
2293 }
2294 if (Token.isNot(MIToken::NamedIRValue) && Token.isNot(MIToken::IRValue) &&
2295 Token.isNot(MIToken::GlobalValue) &&
2296 Token.isNot(MIToken::NamedGlobalValue) &&
2297 Token.isNot(MIToken::QuotedIRValue))
2298 return error("expected an IR value reference");
2299 const Value *V = nullptr;
2300 if (parseIRValue(V))
2301 return true;
2302 if (!V->getType()->isPointerTy())
2303 return error("expected a pointer IR value");
2304 lex();
2305 int64_t Offset = 0;
2306 if (parseOffset(Offset))
2307 return true;
2308 Dest = MachinePointerInfo(V, Offset);
2309 return false;
2310}
2311
2312bool MIParser::parseOptionalScope(LLVMContext &Context,
2313 SyncScope::ID &SSID) {
2314 SSID = SyncScope::System;
2315 if (Token.is(MIToken::Identifier) && Token.stringValue() == "syncscope") {
2316 lex();
2317 if (expectAndConsume(MIToken::lparen))
2318 return error("expected '(' in syncscope");
2319
2320 std::string SSN;
2321 if (parseStringConstant(SSN))
2322 return true;
2323
2324 SSID = Context.getOrInsertSyncScopeID(SSN);
2325 if (expectAndConsume(MIToken::rparen))
2326 return error("expected ')' in syncscope");
2327 }
2328
2329 return false;
2330}
2331
2332bool MIParser::parseOptionalAtomicOrdering(AtomicOrdering &Order) {
2333 Order = AtomicOrdering::NotAtomic;
2334 if (Token.isNot(MIToken::Identifier))
2335 return false;
2336
2337 Order = StringSwitch<AtomicOrdering>(Token.stringValue())
2338 .Case("unordered", AtomicOrdering::Unordered)
2339 .Case("monotonic", AtomicOrdering::Monotonic)
2340 .Case("acquire", AtomicOrdering::Acquire)
2341 .Case("release", AtomicOrdering::Release)
2342 .Case("acq_rel", AtomicOrdering::AcquireRelease)
2343 .Case("seq_cst", AtomicOrdering::SequentiallyConsistent)
2344 .Default(AtomicOrdering::NotAtomic);
2345
2346 if (Order != AtomicOrdering::NotAtomic) {
2347 lex();
2348 return false;
2349 }
2350
2351 return error("expected an atomic scope, ordering or a size integer literal");
2352}
2353
2354bool MIParser::parseMachineMemoryOperand(MachineMemOperand *&Dest) {
2355 if (expectAndConsume(MIToken::lparen))
2356 return true;
2357 MachineMemOperand::Flags Flags = MachineMemOperand::MONone;
2358 while (Token.isMemoryOperandFlag()) {
2359 if (parseMemoryOperandFlag(Flags))
2360 return true;
2361 }
2362 if (Token.isNot(MIToken::Identifier) ||
2363 (Token.stringValue() != "load" && Token.stringValue() != "store"))
2364 return error("expected 'load' or 'store' memory operation");
2365 if (Token.stringValue() == "load")
2366 Flags |= MachineMemOperand::MOLoad;
2367 else
2368 Flags |= MachineMemOperand::MOStore;
2369 lex();
2370
2371 // Optional 'store' for operands that both load and store.
2372 if (Token.is(MIToken::Identifier) && Token.stringValue() == "store") {
2373 Flags |= MachineMemOperand::MOStore;
2374 lex();
2375 }
2376
2377 // Optional synchronization scope.
2378 SyncScope::ID SSID;
2379 if (parseOptionalScope(MF.getFunction().getContext(), SSID))
2380 return true;
2381
2382 // Up to two atomic orderings (cmpxchg provides guarantees on failure).
2383 AtomicOrdering Order, FailureOrder;
2384 if (parseOptionalAtomicOrdering(Order))
2385 return true;
2386
2387 if (parseOptionalAtomicOrdering(FailureOrder))
2388 return true;
2389
2390 if (Token.isNot(MIToken::IntegerLiteral))
2391 return error("expected the size integer literal after memory operation");
2392 uint64_t Size;
2393 if (getUint64(Size))
2394 return true;
2395 lex();
2396
2397 MachinePointerInfo Ptr = MachinePointerInfo();
2398 if (Token.is(MIToken::Identifier)) {
2399 const char *Word =
2400 ((Flags & MachineMemOperand::MOLoad) &&
2401 (Flags & MachineMemOperand::MOStore))
2402 ? "on"
2403 : Flags & MachineMemOperand::MOLoad ? "from" : "into";
2404 if (Token.stringValue() != Word)
2405 return error(Twine("expected '") + Word + "'");
2406 lex();
2407
2408 if (parseMachinePointerInfo(Ptr))
2409 return true;
2410 }
2411 unsigned BaseAlignment = Size;
2412 AAMDNodes AAInfo;
2413 MDNode *Range = nullptr;
2414 while (consumeIfPresent(MIToken::comma)) {
2415 switch (Token.kind()) {
2416 case MIToken::kw_align:
2417 if (parseAlignment(BaseAlignment))
2418 return true;
2419 break;
2420 case MIToken::kw_addrspace:
2421 if (parseAddrspace(Ptr.AddrSpace))
2422 return true;
2423 break;
2424 case MIToken::md_tbaa:
2425 lex();
2426 if (parseMDNode(AAInfo.TBAA))
2427 return true;
2428 break;
2429 case MIToken::md_alias_scope:
2430 lex();
2431 if (parseMDNode(AAInfo.Scope))
2432 return true;
2433 break;
2434 case MIToken::md_noalias:
2435 lex();
2436 if (parseMDNode(AAInfo.NoAlias))
2437 return true;
2438 break;
2439 case MIToken::md_range:
2440 lex();
2441 if (parseMDNode(Range))
2442 return true;
2443 break;
2444 // TODO: Report an error on duplicate metadata nodes.
2445 default:
2446 return error("expected 'align' or '!tbaa' or '!alias.scope' or "
2447 "'!noalias' or '!range'");
2448 }
2449 }
2450 if (expectAndConsume(MIToken::rparen))
2451 return true;
2452 Dest = MF.getMachineMemOperand(Ptr, Flags, Size, BaseAlignment, AAInfo, Range,
2453 SSID, Order, FailureOrder);
2454 return false;
2455}
2456
2457void MIParser::initNames2InstrOpCodes() {
2458 if (!Names2InstrOpCodes.empty())
2459 return;
2460 const auto *TII = MF.getSubtarget().getInstrInfo();
2461 assert(TII && "Expected target instruction info")(static_cast <bool> (TII && "Expected target instruction info"
) ? void (0) : __assert_fail ("TII && \"Expected target instruction info\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 2461, __extension__ __PRETTY_FUNCTION__))
;
2462 for (unsigned I = 0, E = TII->getNumOpcodes(); I < E; ++I)
2463 Names2InstrOpCodes.insert(std::make_pair(StringRef(TII->getName(I)), I));
2464}
2465
2466bool MIParser::parseInstrName(StringRef InstrName, unsigned &OpCode) {
2467 initNames2InstrOpCodes();
2468 auto InstrInfo = Names2InstrOpCodes.find(InstrName);
2469 if (InstrInfo == Names2InstrOpCodes.end())
2470 return true;
2471 OpCode = InstrInfo->getValue();
2472 return false;
2473}
2474
2475void MIParser::initNames2Regs() {
2476 if (!Names2Regs.empty())
2477 return;
2478 // The '%noreg' register is the register 0.
2479 Names2Regs.insert(std::make_pair("noreg", 0));
2480 const auto *TRI = MF.getSubtarget().getRegisterInfo();
2481 assert(TRI && "Expected target register info")(static_cast <bool> (TRI && "Expected target register info"
) ? void (0) : __assert_fail ("TRI && \"Expected target register info\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 2481, __extension__ __PRETTY_FUNCTION__))
;
2482 for (unsigned I = 0, E = TRI->getNumRegs(); I < E; ++I) {
2483 bool WasInserted =
2484 Names2Regs.insert(std::make_pair(StringRef(TRI->getName(I)).lower(), I))
2485 .second;
2486 (void)WasInserted;
2487 assert(WasInserted && "Expected registers to be unique case-insensitively")(static_cast <bool> (WasInserted && "Expected registers to be unique case-insensitively"
) ? void (0) : __assert_fail ("WasInserted && \"Expected registers to be unique case-insensitively\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 2487, __extension__ __PRETTY_FUNCTION__))
;
2488 }
2489}
2490
2491bool MIParser::getRegisterByName(StringRef RegName, unsigned &Reg) {
2492 initNames2Regs();
2493 auto RegInfo = Names2Regs.find(RegName);
2494 if (RegInfo == Names2Regs.end())
2495 return true;
2496 Reg = RegInfo->getValue();
2497 return false;
2498}
2499
2500void MIParser::initNames2RegMasks() {
2501 if (!Names2RegMasks.empty())
2502 return;
2503 const auto *TRI = MF.getSubtarget().getRegisterInfo();
2504 assert(TRI && "Expected target register info")(static_cast <bool> (TRI && "Expected target register info"
) ? void (0) : __assert_fail ("TRI && \"Expected target register info\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 2504, __extension__ __PRETTY_FUNCTION__))
;
2505 ArrayRef<const uint32_t *> RegMasks = TRI->getRegMasks();
2506 ArrayRef<const char *> RegMaskNames = TRI->getRegMaskNames();
2507 assert(RegMasks.size() == RegMaskNames.size())(static_cast <bool> (RegMasks.size() == RegMaskNames.size
()) ? void (0) : __assert_fail ("RegMasks.size() == RegMaskNames.size()"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 2507, __extension__ __PRETTY_FUNCTION__))
;
2508 for (size_t I = 0, E = RegMasks.size(); I < E; ++I)
2509 Names2RegMasks.insert(
2510 std::make_pair(StringRef(RegMaskNames[I]).lower(), RegMasks[I]));
2511}
2512
2513const uint32_t *MIParser::getRegMask(StringRef Identifier) {
2514 initNames2RegMasks();
2515 auto RegMaskInfo = Names2RegMasks.find(Identifier);
2516 if (RegMaskInfo == Names2RegMasks.end())
2517 return nullptr;
2518 return RegMaskInfo->getValue();
2519}
2520
2521void MIParser::initNames2SubRegIndices() {
2522 if (!Names2SubRegIndices.empty())
2523 return;
2524 const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
2525 for (unsigned I = 1, E = TRI->getNumSubRegIndices(); I < E; ++I)
2526 Names2SubRegIndices.insert(
2527 std::make_pair(StringRef(TRI->getSubRegIndexName(I)).lower(), I));
2528}
2529
2530unsigned MIParser::getSubRegIndex(StringRef Name) {
2531 initNames2SubRegIndices();
2532 auto SubRegInfo = Names2SubRegIndices.find(Name);
2533 if (SubRegInfo == Names2SubRegIndices.end())
2534 return 0;
2535 return SubRegInfo->getValue();
2536}
2537
2538static void initSlots2BasicBlocks(
2539 const Function &F,
2540 DenseMap<unsigned, const BasicBlock *> &Slots2BasicBlocks) {
2541 ModuleSlotTracker MST(F.getParent(), /*ShouldInitializeAllMetadata=*/false);
2542 MST.incorporateFunction(F);
2543 for (auto &BB : F) {
2544 if (BB.hasName())
2545 continue;
2546 int Slot = MST.getLocalSlot(&BB);
2547 if (Slot == -1)
2548 continue;
2549 Slots2BasicBlocks.insert(std::make_pair(unsigned(Slot), &BB));
2550 }
2551}
2552
2553static const BasicBlock *getIRBlockFromSlot(
2554 unsigned Slot,
2555 const DenseMap<unsigned, const BasicBlock *> &Slots2BasicBlocks) {
2556 auto BlockInfo = Slots2BasicBlocks.find(Slot);
2557 if (BlockInfo == Slots2BasicBlocks.end())
2558 return nullptr;
2559 return BlockInfo->second;
2560}
2561
2562const BasicBlock *MIParser::getIRBlock(unsigned Slot) {
2563 if (Slots2BasicBlocks.empty())
2564 initSlots2BasicBlocks(MF.getFunction(), Slots2BasicBlocks);
2565 return getIRBlockFromSlot(Slot, Slots2BasicBlocks);
2566}
2567
2568const BasicBlock *MIParser::getIRBlock(unsigned Slot, const Function &F) {
2569 if (&F == &MF.getFunction())
2570 return getIRBlock(Slot);
2571 DenseMap<unsigned, const BasicBlock *> CustomSlots2BasicBlocks;
2572 initSlots2BasicBlocks(F, CustomSlots2BasicBlocks);
2573 return getIRBlockFromSlot(Slot, CustomSlots2BasicBlocks);
2574}
2575
2576static void mapValueToSlot(const Value *V, ModuleSlotTracker &MST,
2577 DenseMap<unsigned, const Value *> &Slots2Values) {
2578 int Slot = MST.getLocalSlot(V);
2579 if (Slot == -1)
2580 return;
2581 Slots2Values.insert(std::make_pair(unsigned(Slot), V));
2582}
2583
2584/// Creates the mapping from slot numbers to function's unnamed IR values.
2585static void initSlots2Values(const Function &F,
2586 DenseMap<unsigned, const Value *> &Slots2Values) {
2587 ModuleSlotTracker MST(F.getParent(), /*ShouldInitializeAllMetadata=*/false);
2588 MST.incorporateFunction(F);
2589 for (const auto &Arg : F.args())
2590 mapValueToSlot(&Arg, MST, Slots2Values);
2591 for (const auto &BB : F) {
2592 mapValueToSlot(&BB, MST, Slots2Values);
2593 for (const auto &I : BB)
2594 mapValueToSlot(&I, MST, Slots2Values);
2595 }
2596}
2597
2598const Value *MIParser::getIRValue(unsigned Slot) {
2599 if (Slots2Values.empty())
2600 initSlots2Values(MF.getFunction(), Slots2Values);
2601 auto ValueInfo = Slots2Values.find(Slot);
2602 if (ValueInfo == Slots2Values.end())
2603 return nullptr;
2604 return ValueInfo->second;
2605}
2606
2607void MIParser::initNames2TargetIndices() {
2608 if (!Names2TargetIndices.empty())
2609 return;
2610 const auto *TII = MF.getSubtarget().getInstrInfo();
2611 assert(TII && "Expected target instruction info")(static_cast <bool> (TII && "Expected target instruction info"
) ? void (0) : __assert_fail ("TII && \"Expected target instruction info\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 2611, __extension__ __PRETTY_FUNCTION__))
;
2612 auto Indices = TII->getSerializableTargetIndices();
2613 for (const auto &I : Indices)
2614 Names2TargetIndices.insert(std::make_pair(StringRef(I.second), I.first));
2615}
2616
2617bool MIParser::getTargetIndex(StringRef Name, int &Index) {
2618 initNames2TargetIndices();
2619 auto IndexInfo = Names2TargetIndices.find(Name);
2620 if (IndexInfo == Names2TargetIndices.end())
2621 return true;
2622 Index = IndexInfo->second;
2623 return false;
2624}
2625
2626void MIParser::initNames2DirectTargetFlags() {
2627 if (!Names2DirectTargetFlags.empty())
2628 return;
2629 const auto *TII = MF.getSubtarget().getInstrInfo();
2630 assert(TII && "Expected target instruction info")(static_cast <bool> (TII && "Expected target instruction info"
) ? void (0) : __assert_fail ("TII && \"Expected target instruction info\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 2630, __extension__ __PRETTY_FUNCTION__))
;
2631 auto Flags = TII->getSerializableDirectMachineOperandTargetFlags();
2632 for (const auto &I : Flags)
2633 Names2DirectTargetFlags.insert(
2634 std::make_pair(StringRef(I.second), I.first));
2635}
2636
2637bool MIParser::getDirectTargetFlag(StringRef Name, unsigned &Flag) {
2638 initNames2DirectTargetFlags();
2639 auto FlagInfo = Names2DirectTargetFlags.find(Name);
2640 if (FlagInfo == Names2DirectTargetFlags.end())
2641 return true;
2642 Flag = FlagInfo->second;
2643 return false;
2644}
2645
2646void MIParser::initNames2BitmaskTargetFlags() {
2647 if (!Names2BitmaskTargetFlags.empty())
2648 return;
2649 const auto *TII = MF.getSubtarget().getInstrInfo();
2650 assert(TII && "Expected target instruction info")(static_cast <bool> (TII && "Expected target instruction info"
) ? void (0) : __assert_fail ("TII && \"Expected target instruction info\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 2650, __extension__ __PRETTY_FUNCTION__))
;
2651 auto Flags = TII->getSerializableBitmaskMachineOperandTargetFlags();
2652 for (const auto &I : Flags)
2653 Names2BitmaskTargetFlags.insert(
2654 std::make_pair(StringRef(I.second), I.first));
2655}
2656
2657bool MIParser::getBitmaskTargetFlag(StringRef Name, unsigned &Flag) {
2658 initNames2BitmaskTargetFlags();
2659 auto FlagInfo = Names2BitmaskTargetFlags.find(Name);
2660 if (FlagInfo == Names2BitmaskTargetFlags.end())
2661 return true;
2662 Flag = FlagInfo->second;
2663 return false;
2664}
2665
2666void MIParser::initNames2MMOTargetFlags() {
2667 if (!Names2MMOTargetFlags.empty())
2668 return;
2669 const auto *TII = MF.getSubtarget().getInstrInfo();
2670 assert(TII && "Expected target instruction info")(static_cast <bool> (TII && "Expected target instruction info"
) ? void (0) : __assert_fail ("TII && \"Expected target instruction info\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/CodeGen/MIRParser/MIParser.cpp"
, 2670, __extension__ __PRETTY_FUNCTION__))
;
2671 auto Flags = TII->getSerializableMachineMemOperandTargetFlags();
2672 for (const auto &I : Flags)
2673 Names2MMOTargetFlags.insert(
2674 std::make_pair(StringRef(I.second), I.first));
2675}
2676
2677bool MIParser::getMMOTargetFlag(StringRef Name,
2678 MachineMemOperand::Flags &Flag) {
2679 initNames2MMOTargetFlags();
2680 auto FlagInfo = Names2MMOTargetFlags.find(Name);
2681 if (FlagInfo == Names2MMOTargetFlags.end())
2682 return true;
2683 Flag = FlagInfo->second;
2684 return false;
2685}
2686
2687bool MIParser::parseStringConstant(std::string &Result) {
2688 if (Token.isNot(MIToken::StringConstant))
2689 return error("expected string constant");
2690 Result = Token.stringValue();
2691 lex();
2692 return false;
2693}
2694
2695bool llvm::parseMachineBasicBlockDefinitions(PerFunctionMIParsingState &PFS,
2696 StringRef Src,
2697 SMDiagnostic &Error) {
2698 return MIParser(PFS, Error, Src).parseBasicBlockDefinitions(PFS.MBBSlots);
2699}
2700
2701bool llvm::parseMachineInstructions(PerFunctionMIParsingState &PFS,
2702 StringRef Src, SMDiagnostic &Error) {
2703 return MIParser(PFS, Error, Src).parseBasicBlocks();
2704}
2705
2706bool llvm::parseMBBReference(PerFunctionMIParsingState &PFS,
2707 MachineBasicBlock *&MBB, StringRef Src,
2708 SMDiagnostic &Error) {
2709 return MIParser(PFS, Error, Src).parseStandaloneMBB(MBB);
2710}
2711
2712bool llvm::parseRegisterReference(PerFunctionMIParsingState &PFS,
2713 unsigned &Reg, StringRef Src,
2714 SMDiagnostic &Error) {
2715 return MIParser(PFS, Error, Src).parseStandaloneRegister(Reg);
2716}
2717
2718bool llvm::parseNamedRegisterReference(PerFunctionMIParsingState &PFS,
2719 unsigned &Reg, StringRef Src,
2720 SMDiagnostic &Error) {
2721 return MIParser(PFS, Error, Src).parseStandaloneNamedRegister(Reg);
2722}
2723
2724bool llvm::parseVirtualRegisterReference(PerFunctionMIParsingState &PFS,
2725 VRegInfo *&Info, StringRef Src,
2726 SMDiagnostic &Error) {
2727 return MIParser(PFS, Error, Src).parseStandaloneVirtualRegister(Info);
2728}
2729
2730bool llvm::parseStackObjectReference(PerFunctionMIParsingState &PFS,
2731 int &FI, StringRef Src,
2732 SMDiagnostic &Error) {
2733 return MIParser(PFS, Error, Src).parseStandaloneStackObject(FI);
2734}
2735
2736bool llvm::parseMDNode(PerFunctionMIParsingState &PFS,
2737 MDNode *&Node, StringRef Src, SMDiagnostic &Error) {
2738 return MIParser(PFS, Error, Src).parseStandaloneMDNode(Node);
2739}

/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/APInt.h

1//===-- llvm/ADT/APInt.h - For Arbitrary Precision Integer -----*- C++ -*--===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9///
10/// \file
11/// \brief This file implements a class to represent arbitrary precision
12/// integral constant values and operations on them.
13///
14//===----------------------------------------------------------------------===//
15
16#ifndef LLVM_ADT_APINT_H
17#define LLVM_ADT_APINT_H
18
19#include "llvm/Support/Compiler.h"
20#include "llvm/Support/MathExtras.h"
21#include <cassert>
22#include <climits>
23#include <cstring>
24#include <string>
25
26namespace llvm {
27class FoldingSetNodeID;
28class StringRef;
29class hash_code;
30class raw_ostream;
31
32template <typename T> class SmallVectorImpl;
33template <typename T> class ArrayRef;
34
35class APInt;
36
37inline APInt operator-(APInt);
38
39//===----------------------------------------------------------------------===//
40// APInt Class
41//===----------------------------------------------------------------------===//
42
43/// \brief Class for arbitrary precision integers.
44///
45/// APInt is a functional replacement for common case unsigned integer type like
46/// "unsigned", "unsigned long" or "uint64_t", but also allows non-byte-width
47/// integer sizes and large integer value types such as 3-bits, 15-bits, or more
48/// than 64-bits of precision. APInt provides a variety of arithmetic operators
49/// and methods to manipulate integer values of any bit-width. It supports both
50/// the typical integer arithmetic and comparison operations as well as bitwise
51/// manipulation.
52///
53/// The class has several invariants worth noting:
54/// * All bit, byte, and word positions are zero-based.
55/// * Once the bit width is set, it doesn't change except by the Truncate,
56/// SignExtend, or ZeroExtend operations.
57/// * All binary operators must be on APInt instances of the same bit width.
58/// Attempting to use these operators on instances with different bit
59/// widths will yield an assertion.
60/// * The value is stored canonically as an unsigned value. For operations
61/// where it makes a difference, there are both signed and unsigned variants
62/// of the operation. For example, sdiv and udiv. However, because the bit
63/// widths must be the same, operations such as Mul and Add produce the same
64/// results regardless of whether the values are interpreted as signed or
65/// not.
66/// * In general, the class tries to follow the style of computation that LLVM
67/// uses in its IR. This simplifies its use for LLVM.
68///
69class LLVM_NODISCARD[[clang::warn_unused_result]] APInt {
70public:
71 typedef uint64_t WordType;
72
73 /// This enum is used to hold the constants we needed for APInt.
74 enum : unsigned {
75 /// Byte size of a word.
76 APINT_WORD_SIZE = sizeof(WordType),
77 /// Bits in a word.
78 APINT_BITS_PER_WORD = APINT_WORD_SIZE * CHAR_BIT8
79 };
80
81 static const WordType WORD_MAX = ~WordType(0);
82
83private:
84 /// This union is used to store the integer value. When the
85 /// integer bit-width <= 64, it uses VAL, otherwise it uses pVal.
86 union {
87 uint64_t VAL; ///< Used to store the <= 64 bits integer value.
88 uint64_t *pVal; ///< Used to store the >64 bits integer value.
89 } U;
90
91 unsigned BitWidth; ///< The number of bits in this APInt.
92
93 friend struct DenseMapAPIntKeyInfo;
94
95 friend class APSInt;
96
97 /// \brief Fast internal constructor
98 ///
99 /// This constructor is used only internally for speed of construction of
100 /// temporaries. It is unsafe for general use so it is not public.
101 APInt(uint64_t *val, unsigned bits) : BitWidth(bits) {
102 U.pVal = val;
103 }
104
105 /// \brief Determine if this APInt just has one word to store value.
106 ///
107 /// \returns true if the number of bits <= 64, false otherwise.
108 bool isSingleWord() const { return BitWidth <= APINT_BITS_PER_WORD; }
109
110 /// \brief Determine which word a bit is in.
111 ///
112 /// \returns the word position for the specified bit position.
113 static unsigned whichWord(unsigned bitPosition) {
114 return bitPosition / APINT_BITS_PER_WORD;
115 }
116
117 /// \brief Determine which bit in a word a bit is in.
118 ///
119 /// \returns the bit position in a word for the specified bit position
120 /// in the APInt.
121 static unsigned whichBit(unsigned bitPosition) {
122 return bitPosition % APINT_BITS_PER_WORD;
123 }
124
125 /// \brief Get a single bit mask.
126 ///
127 /// \returns a uint64_t with only bit at "whichBit(bitPosition)" set
128 /// This method generates and returns a uint64_t (word) mask for a single
129 /// bit at a specific bit position. This is used to mask the bit in the
130 /// corresponding word.
131 static uint64_t maskBit(unsigned bitPosition) {
132 return 1ULL << whichBit(bitPosition);
133 }
134
135 /// \brief Clear unused high order bits
136 ///
137 /// This method is used internally to clear the top "N" bits in the high order
138 /// word that are not used by the APInt. This is needed after the most
139 /// significant word is assigned a value to ensure that those bits are
140 /// zero'd out.
141 APInt &clearUnusedBits() {
142 // Compute how many bits are used in the final word
143 unsigned WordBits = ((BitWidth-1) % APINT_BITS_PER_WORD) + 1;
144
145 // Mask out the high bits.
146 uint64_t mask = WORD_MAX >> (APINT_BITS_PER_WORD - WordBits);
147 if (isSingleWord())
148 U.VAL &= mask;
149 else
150 U.pVal[getNumWords() - 1] &= mask;
151 return *this;
152 }
153
154 /// \brief Get the word corresponding to a bit position
155 /// \returns the corresponding word for the specified bit position.
156 uint64_t getWord(unsigned bitPosition) const {
157 return isSingleWord() ? U.VAL : U.pVal[whichWord(bitPosition)];
158 }
159
160 /// Utility method to change the bit width of this APInt to new bit width,
161 /// allocating and/or deallocating as necessary. There is no guarantee on the
162 /// value of any bits upon return. Caller should populate the bits after.
163 void reallocate(unsigned NewBitWidth);
164
165 /// \brief Convert a char array into an APInt
166 ///
167 /// \param radix 2, 8, 10, 16, or 36
168 /// Converts a string into a number. The string must be non-empty
169 /// and well-formed as a number of the given base. The bit-width
170 /// must be sufficient to hold the result.
171 ///
172 /// This is used by the constructors that take string arguments.
173 ///
174 /// StringRef::getAsInteger is superficially similar but (1) does
175 /// not assume that the string is well-formed and (2) grows the
176 /// result to hold the input.
177 void fromString(unsigned numBits, StringRef str, uint8_t radix);
178
179 /// \brief An internal division function for dividing APInts.
180 ///
181 /// This is used by the toString method to divide by the radix. It simply
182 /// provides a more convenient form of divide for internal use since KnuthDiv
183 /// has specific constraints on its inputs. If those constraints are not met
184 /// then it provides a simpler form of divide.
185 static void divide(const WordType *LHS, unsigned lhsWords,
186 const WordType *RHS, unsigned rhsWords, WordType *Quotient,
187 WordType *Remainder);
188
189 /// out-of-line slow case for inline constructor
190 void initSlowCase(uint64_t val, bool isSigned);
191
192 /// shared code between two array constructors
193 void initFromArray(ArrayRef<uint64_t> array);
194
195 /// out-of-line slow case for inline copy constructor
196 void initSlowCase(const APInt &that);
197
198 /// out-of-line slow case for shl
199 void shlSlowCase(unsigned ShiftAmt);
200
201 /// out-of-line slow case for lshr.
202 void lshrSlowCase(unsigned ShiftAmt);
203
204 /// out-of-line slow case for ashr.
205 void ashrSlowCase(unsigned ShiftAmt);
206
207 /// out-of-line slow case for operator=
208 void AssignSlowCase(const APInt &RHS);
209
210 /// out-of-line slow case for operator==
211 bool EqualSlowCase(const APInt &RHS) const LLVM_READONLY__attribute__((__pure__));
212
213 /// out-of-line slow case for countLeadingZeros
214 unsigned countLeadingZerosSlowCase() const LLVM_READONLY__attribute__((__pure__));
215
216 /// out-of-line slow case for countLeadingOnes.
217 unsigned countLeadingOnesSlowCase() const LLVM_READONLY__attribute__((__pure__));
218
219 /// out-of-line slow case for countTrailingZeros.
220 unsigned countTrailingZerosSlowCase() const LLVM_READONLY__attribute__((__pure__));
221
222 /// out-of-line slow case for countTrailingOnes
223 unsigned countTrailingOnesSlowCase() const LLVM_READONLY__attribute__((__pure__));
224
225 /// out-of-line slow case for countPopulation
226 unsigned countPopulationSlowCase() const LLVM_READONLY__attribute__((__pure__));
227
228 /// out-of-line slow case for intersects.
229 bool intersectsSlowCase(const APInt &RHS) const LLVM_READONLY__attribute__((__pure__));
230
231 /// out-of-line slow case for isSubsetOf.
232 bool isSubsetOfSlowCase(const APInt &RHS) const LLVM_READONLY__attribute__((__pure__));
233
234 /// out-of-line slow case for setBits.
235 void setBitsSlowCase(unsigned loBit, unsigned hiBit);
236
237 /// out-of-line slow case for flipAllBits.
238 void flipAllBitsSlowCase();
239
240 /// out-of-line slow case for operator&=.
241 void AndAssignSlowCase(const APInt& RHS);
242
243 /// out-of-line slow case for operator|=.
244 void OrAssignSlowCase(const APInt& RHS);
245
246 /// out-of-line slow case for operator^=.
247 void XorAssignSlowCase(const APInt& RHS);
248
249 /// Unsigned comparison. Returns -1, 0, or 1 if this APInt is less than, equal
250 /// to, or greater than RHS.
251 int compare(const APInt &RHS) const LLVM_READONLY__attribute__((__pure__));
252
253 /// Signed comparison. Returns -1, 0, or 1 if this APInt is less than, equal
254 /// to, or greater than RHS.
255 int compareSigned(const APInt &RHS) const LLVM_READONLY__attribute__((__pure__));
256
257public:
258 /// \name Constructors
259 /// @{
260
261 /// \brief Create a new APInt of numBits width, initialized as val.
262 ///
263 /// If isSigned is true then val is treated as if it were a signed value
264 /// (i.e. as an int64_t) and the appropriate sign extension to the bit width
265 /// will be done. Otherwise, no sign extension occurs (high order bits beyond
266 /// the range of val are zero filled).
267 ///
268 /// \param numBits the bit width of the constructed APInt
269 /// \param val the initial value of the APInt
270 /// \param isSigned how to treat signedness of val
271 APInt(unsigned numBits, uint64_t val, bool isSigned = false)
272 : BitWidth(numBits) {
273 assert(BitWidth && "bitwidth too small")(static_cast <bool> (BitWidth && "bitwidth too small"
) ? void (0) : __assert_fail ("BitWidth && \"bitwidth too small\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/APInt.h"
, 273, __extension__ __PRETTY_FUNCTION__))
;
274 if (isSingleWord()) {
275 U.VAL = val;
276 clearUnusedBits();
277 } else {
278 initSlowCase(val, isSigned);
279 }
280 }
281
282 /// \brief Construct an APInt of numBits width, initialized as bigVal[].
283 ///
284 /// Note that bigVal.size() can be smaller or larger than the corresponding
285 /// bit width but any extraneous bits will be dropped.
286 ///
287 /// \param numBits the bit width of the constructed APInt
288 /// \param bigVal a sequence of words to form the initial value of the APInt
289 APInt(unsigned numBits, ArrayRef<uint64_t> bigVal);
290
291 /// Equivalent to APInt(numBits, ArrayRef<uint64_t>(bigVal, numWords)), but
292 /// deprecated because this constructor is prone to ambiguity with the
293 /// APInt(unsigned, uint64_t, bool) constructor.
294 ///
295 /// If this overload is ever deleted, care should be taken to prevent calls
296 /// from being incorrectly captured by the APInt(unsigned, uint64_t, bool)
297 /// constructor.
298 APInt(unsigned numBits, unsigned numWords, const uint64_t bigVal[]);
299
300 /// \brief Construct an APInt from a string representation.
301 ///
302 /// This constructor interprets the string \p str in the given radix. The
303 /// interpretation stops when the first character that is not suitable for the
304 /// radix is encountered, or the end of the string. Acceptable radix values
305 /// are 2, 8, 10, 16, and 36. It is an error for the value implied by the
306 /// string to require more bits than numBits.
307 ///
308 /// \param numBits the bit width of the constructed APInt
309 /// \param str the string to be interpreted
310 /// \param radix the radix to use for the conversion
311 APInt(unsigned numBits, StringRef str, uint8_t radix);
312
313 /// Simply makes *this a copy of that.
314 /// @brief Copy Constructor.
315 APInt(const APInt &that) : BitWidth(that.BitWidth) {
316 if (isSingleWord())
317 U.VAL = that.U.VAL;
318 else
319 initSlowCase(that);
320 }
321
322 /// \brief Move Constructor.
323 APInt(APInt &&that) : BitWidth(that.BitWidth) {
324 memcpy(&U, &that.U, sizeof(U));
325 that.BitWidth = 0;
326 }
327
328 /// \brief Destructor.
329 ~APInt() {
330 if (needsCleanup())
331 delete[] U.pVal;
332 }
333
334 /// \brief Default constructor that creates an uninteresting APInt
335 /// representing a 1-bit zero value.
336 ///
337 /// This is useful for object deserialization (pair this with the static
338 /// method Read).
339 explicit APInt() : BitWidth(1) { U.VAL = 0; }
15
Calling implicit default constructor
16
Returning from default constructor
37
Calling implicit default constructor
38
Returning from default constructor
340
341 /// \brief Returns whether this instance allocated memory.
342 bool needsCleanup() const { return !isSingleWord(); }
343
344 /// Used to insert APInt objects, or objects that contain APInt objects, into
345 /// FoldingSets.
346 void Profile(FoldingSetNodeID &id) const;
347
348 /// @}
349 /// \name Value Tests
350 /// @{
351
352 /// \brief Determine sign of this APInt.
353 ///
354 /// This tests the high bit of this APInt to determine if it is set.
355 ///
356 /// \returns true if this APInt is negative, false otherwise
357 bool isNegative() const { return (*this)[BitWidth - 1]; }
358
359 /// \brief Determine if this APInt Value is non-negative (>= 0)
360 ///
361 /// This tests the high bit of the APInt to determine if it is unset.
362 bool isNonNegative() const { return !isNegative(); }
363
364 /// \brief Determine if sign bit of this APInt is set.
365 ///
366 /// This tests the high bit of this APInt to determine if it is set.
367 ///
368 /// \returns true if this APInt has its sign bit set, false otherwise.
369 bool isSignBitSet() const { return (*this)[BitWidth-1]; }
370
371 /// \brief Determine if sign bit of this APInt is clear.
372 ///
373 /// This tests the high bit of this APInt to determine if it is clear.
374 ///
375 /// \returns true if this APInt has its sign bit clear, false otherwise.
376 bool isSignBitClear() const { return !isSignBitSet(); }
377
378 /// \brief Determine if this APInt Value is positive.
379 ///
380 /// This tests if the value of this APInt is positive (> 0). Note
381 /// that 0 is not a positive value.
382 ///
383 /// \returns true if this APInt is positive.
384 bool isStrictlyPositive() const { return isNonNegative() && !isNullValue(); }
385
386 /// \brief Determine if all bits are set
387 ///
388 /// This checks to see if the value has all bits of the APInt are set or not.
389 bool isAllOnesValue() const {
390 if (isSingleWord())
391 return U.VAL == WORD_MAX >> (APINT_BITS_PER_WORD - BitWidth);
392 return countTrailingOnesSlowCase() == BitWidth;
393 }
394
395 /// \brief Determine if all bits are clear
396 ///
397 /// This checks to see if the value has all bits of the APInt are clear or
398 /// not.
399 bool isNullValue() const { return !*this; }
400
401 /// \brief Determine if this is a value of 1.
402 ///
403 /// This checks to see if the value of this APInt is one.
404 bool isOneValue() const {
405 if (isSingleWord())
406 return U.VAL == 1;
407 return countLeadingZerosSlowCase() == BitWidth - 1;
408 }
409
410 /// \brief Determine if this is the largest unsigned value.
411 ///
412 /// This checks to see if the value of this APInt is the maximum unsigned
413 /// value for the APInt's bit width.
414 bool isMaxValue() const { return isAllOnesValue(); }
415
416 /// \brief Determine if this is the largest signed value.
417 ///
418 /// This checks to see if the value of this APInt is the maximum signed
419 /// value for the APInt's bit width.
420 bool isMaxSignedValue() const {
421 if (isSingleWord())
422 return U.VAL == ((WordType(1) << (BitWidth - 1)) - 1);
423 return !isNegative() && countTrailingOnesSlowCase() == BitWidth - 1;
424 }
425
426 /// \brief Determine if this is the smallest unsigned value.
427 ///
428 /// This checks to see if the value of this APInt is the minimum unsigned
429 /// value for the APInt's bit width.
430 bool isMinValue() const { return isNullValue(); }
431
432 /// \brief Determine if this is the smallest signed value.
433 ///
434 /// This checks to see if the value of this APInt is the minimum signed
435 /// value for the APInt's bit width.
436 bool isMinSignedValue() const {
437 if (isSingleWord())
438 return U.VAL == (WordType(1) << (BitWidth - 1));
439 return isNegative() && countTrailingZerosSlowCase() == BitWidth - 1;
440 }
441
442 /// \brief Check if this APInt has an N-bits unsigned integer value.
443 bool isIntN(unsigned N) const {
444 assert(N && "N == 0 ???")(static_cast <bool> (N && "N == 0 ???") ? void (
0) : __assert_fail ("N && \"N == 0 ???\"", "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/APInt.h"
, 444, __extension__ __PRETTY_FUNCTION__))
;
445 return getActiveBits() <= N;
446 }
447
448 /// \brief Check if this APInt has an N-bits signed integer value.
449 bool isSignedIntN(unsigned N) const {
450 assert(N && "N == 0 ???")(static_cast <bool> (N && "N == 0 ???") ? void (
0) : __assert_fail ("N && \"N == 0 ???\"", "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/APInt.h"
, 450, __extension__ __PRETTY_FUNCTION__))
;
451 return getMinSignedBits() <= N;
452 }
453
454 /// \brief Check if this APInt's value is a power of two greater than zero.
455 ///
456 /// \returns true if the argument APInt value is a power of two > 0.
457 bool isPowerOf2() const {
458 if (isSingleWord())
459 return isPowerOf2_64(U.VAL);
460 return countPopulationSlowCase() == 1;
461 }
462
463 /// \brief Check if the APInt's value is returned by getSignMask.
464 ///
465 /// \returns true if this is the value returned by getSignMask.
466 bool isSignMask() const { return isMinSignedValue(); }
467
468 /// \brief Convert APInt to a boolean value.
469 ///
470 /// This converts the APInt to a boolean value as a test against zero.
471 bool getBoolValue() const { return !!*this; }
472
473 /// If this value is smaller than the specified limit, return it, otherwise
474 /// return the limit value. This causes the value to saturate to the limit.
475 uint64_t getLimitedValue(uint64_t Limit = UINT64_MAX(18446744073709551615UL)) const {
476 return ugt(Limit) ? Limit : getZExtValue();
477 }
478
479 /// \brief Check if the APInt consists of a repeated bit pattern.
480 ///
481 /// e.g. 0x01010101 satisfies isSplat(8).
482 /// \param SplatSizeInBits The size of the pattern in bits. Must divide bit
483 /// width without remainder.
484 bool isSplat(unsigned SplatSizeInBits) const;
485
486 /// \returns true if this APInt value is a sequence of \param numBits ones
487 /// starting at the least significant bit with the remainder zero.
488 bool isMask(unsigned numBits) const {
489 assert(numBits != 0 && "numBits must be non-zero")(static_cast <bool> (numBits != 0 && "numBits must be non-zero"
) ? void (0) : __assert_fail ("numBits != 0 && \"numBits must be non-zero\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/APInt.h"
, 489, __extension__ __PRETTY_FUNCTION__))
;
490 assert(numBits <= BitWidth && "numBits out of range")(static_cast <bool> (numBits <= BitWidth && "numBits out of range"
) ? void (0) : __assert_fail ("numBits <= BitWidth && \"numBits out of range\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/APInt.h"
, 490, __extension__ __PRETTY_FUNCTION__))
;
491 if (isSingleWord())
492 return U.VAL == (WORD_MAX >> (APINT_BITS_PER_WORD - numBits));
493 unsigned Ones = countTrailingOnesSlowCase();
494 return (numBits == Ones) &&
495 ((Ones + countLeadingZerosSlowCase()) == BitWidth);
496 }
497
498 /// \returns true if this APInt is a non-empty sequence of ones starting at
499 /// the least significant bit with the remainder zero.
500 /// Ex. isMask(0x0000FFFFU) == true.
501 bool isMask() const {
502 if (isSingleWord())
503 return isMask_64(U.VAL);
504 unsigned Ones = countTrailingOnesSlowCase();
505 return (Ones > 0) && ((Ones + countLeadingZerosSlowCase()) == BitWidth);
506 }
507
508 /// \brief Return true if this APInt value contains a sequence of ones with
509 /// the remainder zero.
510 bool isShiftedMask() const {
511 if (isSingleWord())
512 return isShiftedMask_64(U.VAL);
513 unsigned Ones = countPopulationSlowCase();
514 unsigned LeadZ = countLeadingZerosSlowCase();
515 return (Ones + LeadZ + countTrailingZeros()) == BitWidth;
516 }
517
518 /// @}
519 /// \name Value Generators
520 /// @{
521
522 /// \brief Gets maximum unsigned value of APInt for specific bit width.
523 static APInt getMaxValue(unsigned numBits) {
524 return getAllOnesValue(numBits);
525 }
526
527 /// \brief Gets maximum signed value of APInt for a specific bit width.
528 static APInt getSignedMaxValue(unsigned numBits) {
529 APInt API = getAllOnesValue(numBits);
530 API.clearBit(numBits - 1);
531 return API;
532 }
533
534 /// \brief Gets minimum unsigned value of APInt for a specific bit width.
535 static APInt getMinValue(unsigned numBits) { return APInt(numBits, 0); }
536
537 /// \brief Gets minimum signed value of APInt for a specific bit width.
538 static APInt getSignedMinValue(unsigned numBits) {
539 APInt API(numBits, 0);
540 API.setBit(numBits - 1);
541 return API;
542 }
543
544 /// \brief Get the SignMask for a specific bit width.
545 ///
546 /// This is just a wrapper function of getSignedMinValue(), and it helps code
547 /// readability when we want to get a SignMask.
548 static APInt getSignMask(unsigned BitWidth) {
549 return getSignedMinValue(BitWidth);
550 }
551
552 /// \brief Get the all-ones value.
553 ///
554 /// \returns the all-ones value for an APInt of the specified bit-width.
555 static APInt getAllOnesValue(unsigned numBits) {
556 return APInt(numBits, WORD_MAX, true);
557 }
558
559 /// \brief Get the '0' value.
560 ///
561 /// \returns the '0' value for an APInt of the specified bit-width.
562 static APInt getNullValue(unsigned numBits) { return APInt(numBits, 0); }
563
564 /// \brief Compute an APInt containing numBits highbits from this APInt.
565 ///
566 /// Get an APInt with the same BitWidth as this APInt, just zero mask
567 /// the low bits and right shift to the least significant bit.
568 ///
569 /// \returns the high "numBits" bits of this APInt.
570 APInt getHiBits(unsigned numBits) const;
571
572 /// \brief Compute an APInt containing numBits lowbits from this APInt.
573 ///
574 /// Get an APInt with the same BitWidth as this APInt, just zero mask
575 /// the high bits.
576 ///
577 /// \returns the low "numBits" bits of this APInt.
578 APInt getLoBits(unsigned numBits) const;
579
580 /// \brief Return an APInt with exactly one bit set in the result.
581 static APInt getOneBitSet(unsigned numBits, unsigned BitNo) {
582 APInt Res(numBits, 0);
583 Res.setBit(BitNo);
584 return Res;
585 }
586
587 /// \brief Get a value with a block of bits set.
588 ///
589 /// Constructs an APInt value that has a contiguous range of bits set. The
590 /// bits from loBit (inclusive) to hiBit (exclusive) will be set. All other
591 /// bits will be zero. For example, with parameters(32, 0, 16) you would get
592 /// 0x0000FFFF. If hiBit is less than loBit then the set bits "wrap". For
593 /// example, with parameters (32, 28, 4), you would get 0xF000000F.
594 ///
595 /// \param numBits the intended bit width of the result
596 /// \param loBit the index of the lowest bit set.
597 /// \param hiBit the index of the highest bit set.
598 ///
599 /// \returns An APInt value with the requested bits set.
600 static APInt getBitsSet(unsigned numBits, unsigned loBit, unsigned hiBit) {
601 APInt Res(numBits, 0);
602 Res.setBits(loBit, hiBit);
603 return Res;
604 }
605
606 /// \brief Get a value with upper bits starting at loBit set.
607 ///
608 /// Constructs an APInt value that has a contiguous range of bits set. The
609 /// bits from loBit (inclusive) to numBits (exclusive) will be set. All other
610 /// bits will be zero. For example, with parameters(32, 12) you would get
611 /// 0xFFFFF000.
612 ///
613 /// \param numBits the intended bit width of the result
614 /// \param loBit the index of the lowest bit to set.
615 ///
616 /// \returns An APInt value with the requested bits set.
617 static APInt getBitsSetFrom(unsigned numBits, unsigned loBit) {
618 APInt Res(numBits, 0);
619 Res.setBitsFrom(loBit);
620 return Res;
621 }
622
623 /// \brief Get a value with high bits set
624 ///
625 /// Constructs an APInt value that has the top hiBitsSet bits set.
626 ///
627 /// \param numBits the bitwidth of the result
628 /// \param hiBitsSet the number of high-order bits set in the result.
629 static APInt getHighBitsSet(unsigned numBits, unsigned hiBitsSet) {
630 APInt Res(numBits, 0);
631 Res.setHighBits(hiBitsSet);
632 return Res;
633 }
634
635 /// \brief Get a value with low bits set
636 ///
637 /// Constructs an APInt value that has the bottom loBitsSet bits set.
638 ///
639 /// \param numBits the bitwidth of the result
640 /// \param loBitsSet the number of low-order bits set in the result.
641 static APInt getLowBitsSet(unsigned numBits, unsigned loBitsSet) {
642 APInt Res(numBits, 0);
643 Res.setLowBits(loBitsSet);
644 return Res;
645 }
646
647 /// \brief Return a value containing V broadcasted over NewLen bits.
648 static APInt getSplat(unsigned NewLen, const APInt &V);
649
650 /// \brief Determine if two APInts have the same value, after zero-extending
651 /// one of them (if needed!) to ensure that the bit-widths match.
652 static bool isSameValue(const APInt &I1, const APInt &I2) {
653 if (I1.getBitWidth() == I2.getBitWidth())
654 return I1 == I2;
655
656 if (I1.getBitWidth() > I2.getBitWidth())
657 return I1 == I2.zext(I1.getBitWidth());
658
659 return I1.zext(I2.getBitWidth()) == I2;
660 }
661
662 /// \brief Overload to compute a hash_code for an APInt value.
663 friend hash_code hash_value(const APInt &Arg);
664
665 /// This function returns a pointer to the internal storage of the APInt.
666 /// This is useful for writing out the APInt in binary form without any
667 /// conversions.
668 const uint64_t *getRawData() const {
669 if (isSingleWord())
670 return &U.VAL;
671 return &U.pVal[0];
672 }
673
674 /// @}
675 /// \name Unary Operators
676 /// @{
677
678 /// \brief Postfix increment operator.
679 ///
680 /// Increments *this by 1.
681 ///
682 /// \returns a new APInt value representing the original value of *this.
683 const APInt operator++(int) {
684 APInt API(*this);
685 ++(*this);
686 return API;
687 }
688
689 /// \brief Prefix increment operator.
690 ///
691 /// \returns *this incremented by one
692 APInt &operator++();
693
694 /// \brief Postfix decrement operator.
695 ///
696 /// Decrements *this by 1.
697 ///
698 /// \returns a new APInt value representing the original value of *this.
699 const APInt operator--(int) {
700 APInt API(*this);
701 --(*this);
702 return API;
703 }
704
705 /// \brief Prefix decrement operator.
706 ///
707 /// \returns *this decremented by one.
708 APInt &operator--();
709
710 /// \brief Logical negation operator.
711 ///
712 /// Performs logical negation operation on this APInt.
713 ///
714 /// \returns true if *this is zero, false otherwise.
715 bool operator!() const {
716 if (isSingleWord())
717 return U.VAL == 0;
718 return countLeadingZerosSlowCase() == BitWidth;
719 }
720
721 /// @}
722 /// \name Assignment Operators
723 /// @{
724
725 /// \brief Copy assignment operator.
726 ///
727 /// \returns *this after assignment of RHS.
728 APInt &operator=(const APInt &RHS) {
729 // If the bitwidths are the same, we can avoid mucking with memory
730 if (isSingleWord() && RHS.isSingleWord()) {
731 U.VAL = RHS.U.VAL;
732 BitWidth = RHS.BitWidth;
733 return clearUnusedBits();
734 }
735
736 AssignSlowCase(RHS);
737 return *this;
738 }
739
740 /// @brief Move assignment operator.
741 APInt &operator=(APInt &&that) {
742 assert(this != &that && "Self-move not supported")(static_cast <bool> (this != &that && "Self-move not supported"
) ? void (0) : __assert_fail ("this != &that && \"Self-move not supported\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/APInt.h"
, 742, __extension__ __PRETTY_FUNCTION__))
;
743 if (!isSingleWord())
744 delete[] U.pVal;
745
746 // Use memcpy so that type based alias analysis sees both VAL and pVal
747 // as modified.
748 memcpy(&U, &that.U, sizeof(U));
749
750 BitWidth = that.BitWidth;
751 that.BitWidth = 0;
752
753 return *this;
754 }
755
756 /// \brief Assignment operator.
757 ///
758 /// The RHS value is assigned to *this. If the significant bits in RHS exceed
759 /// the bit width, the excess bits are truncated. If the bit width is larger
760 /// than 64, the value is zero filled in the unspecified high order bits.
761 ///
762 /// \returns *this after assignment of RHS value.
763 APInt &operator=(uint64_t RHS) {
764 if (isSingleWord()) {
765 U.VAL = RHS;
766 clearUnusedBits();
767 } else {
768 U.pVal[0] = RHS;
769 memset(U.pVal+1, 0, (getNumWords() - 1) * APINT_WORD_SIZE);
770 }
771 return *this;
772 }
773
774 /// \brief Bitwise AND assignment operator.
775 ///
776 /// Performs a bitwise AND operation on this APInt and RHS. The result is
777 /// assigned to *this.
778 ///
779 /// \returns *this after ANDing with RHS.
780 APInt &operator&=(const APInt &RHS) {
781 assert(BitWidth == RHS.BitWidth && "Bit widths must be the same")(static_cast <bool> (BitWidth == RHS.BitWidth &&
"Bit widths must be the same") ? void (0) : __assert_fail ("BitWidth == RHS.BitWidth && \"Bit widths must be the same\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/APInt.h"
, 781, __extension__ __PRETTY_FUNCTION__))
;
782 if (isSingleWord())
783 U.VAL &= RHS.U.VAL;
784 else
785 AndAssignSlowCase(RHS);
786 return *this;
787 }
788
789 /// \brief Bitwise AND assignment operator.
790 ///
791 /// Performs a bitwise AND operation on this APInt and RHS. RHS is
792 /// logically zero-extended or truncated to match the bit-width of
793 /// the LHS.
794 APInt &operator&=(uint64_t RHS) {
795 if (isSingleWord()) {
796 U.VAL &= RHS;
797 return *this;
798 }
799 U.pVal[0] &= RHS;
800 memset(U.pVal+1, 0, (getNumWords() - 1) * APINT_WORD_SIZE);
801 return *this;
802 }
803
804 /// \brief Bitwise OR assignment operator.
805 ///
806 /// Performs a bitwise OR operation on this APInt and RHS. The result is
807 /// assigned *this;
808 ///
809 /// \returns *this after ORing with RHS.
810 APInt &operator|=(const APInt &RHS) {
811 assert(BitWidth == RHS.BitWidth && "Bit widths must be the same")(static_cast <bool> (BitWidth == RHS.BitWidth &&
"Bit widths must be the same") ? void (0) : __assert_fail ("BitWidth == RHS.BitWidth && \"Bit widths must be the same\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/APInt.h"
, 811, __extension__ __PRETTY_FUNCTION__))
;
812 if (isSingleWord())
813 U.VAL |= RHS.U.VAL;
814 else
815 OrAssignSlowCase(RHS);
816 return *this;
817 }
818
819 /// \brief Bitwise OR assignment operator.
820 ///
821 /// Performs a bitwise OR operation on this APInt and RHS. RHS is
822 /// logically zero-extended or truncated to match the bit-width of
823 /// the LHS.
824 APInt &operator|=(uint64_t RHS) {
825 if (isSingleWord()) {
826 U.VAL |= RHS;
827 clearUnusedBits();
828 } else {
829 U.pVal[0] |= RHS;
830 }
831 return *this;
832 }
833
834 /// \brief Bitwise XOR assignment operator.
835 ///
836 /// Performs a bitwise XOR operation on this APInt and RHS. The result is
837 /// assigned to *this.
838 ///
839 /// \returns *this after XORing with RHS.
840 APInt &operator^=(const APInt &RHS) {
841 assert(BitWidth == RHS.BitWidth && "Bit widths must be the same")(static_cast <bool> (BitWidth == RHS.BitWidth &&
"Bit widths must be the same") ? void (0) : __assert_fail ("BitWidth == RHS.BitWidth && \"Bit widths must be the same\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/APInt.h"
, 841, __extension__ __PRETTY_FUNCTION__))
;
842 if (isSingleWord())
843 U.VAL ^= RHS.U.VAL;
844 else
845 XorAssignSlowCase(RHS);
846 return *this;
847 }
848
849 /// \brief Bitwise XOR assignment operator.
850 ///
851 /// Performs a bitwise XOR operation on this APInt and RHS. RHS is
852 /// logically zero-extended or truncated to match the bit-width of
853 /// the LHS.
854 APInt &operator^=(uint64_t RHS) {
855 if (isSingleWord()) {
856 U.VAL ^= RHS;
857 clearUnusedBits();
858 } else {
859 U.pVal[0] ^= RHS;
860 }
861 return *this;
862 }
863
864 /// \brief Multiplication assignment operator.
865 ///
866 /// Multiplies this APInt by RHS and assigns the result to *this.
867 ///
868 /// \returns *this
869 APInt &operator*=(const APInt &RHS);
870 APInt &operator*=(uint64_t RHS);
871
872 /// \brief Addition assignment operator.
873 ///
874 /// Adds RHS to *this and assigns the result to *this.
875 ///
876 /// \returns *this
877 APInt &operator+=(const APInt &RHS);
878 APInt &operator+=(uint64_t RHS);
879
880 /// \brief Subtraction assignment operator.
881 ///
882 /// Subtracts RHS from *this and assigns the result to *this.
883 ///
884 /// \returns *this
885 APInt &operator-=(const APInt &RHS);
886 APInt &operator-=(uint64_t RHS);
887
888 /// \brief Left-shift assignment function.
889 ///
890 /// Shifts *this left by shiftAmt and assigns the result to *this.
891 ///
892 /// \returns *this after shifting left by ShiftAmt
893 APInt &operator<<=(unsigned ShiftAmt) {
894 assert(ShiftAmt <= BitWidth && "Invalid shift amount")(static_cast <bool> (ShiftAmt <= BitWidth &&
"Invalid shift amount") ? void (0) : __assert_fail ("ShiftAmt <= BitWidth && \"Invalid shift amount\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/APInt.h"
, 894, __extension__ __PRETTY_FUNCTION__))
;
895 if (isSingleWord()) {
896 if (ShiftAmt == BitWidth)
897 U.VAL = 0;
898 else
899 U.VAL <<= ShiftAmt;
900 return clearUnusedBits();
901 }
902 shlSlowCase(ShiftAmt);
903 return *this;
904 }
905
906 /// \brief Left-shift assignment function.
907 ///
908 /// Shifts *this left by shiftAmt and assigns the result to *this.
909 ///
910 /// \returns *this after shifting left by ShiftAmt
911 APInt &operator<<=(const APInt &ShiftAmt);
912
913 /// @}
914 /// \name Binary Operators
915 /// @{
916
917 /// \brief Multiplication operator.
918 ///
919 /// Multiplies this APInt by RHS and returns the result.
920 APInt operator*(const APInt &RHS) const;
921
922 /// \brief Left logical shift operator.
923 ///
924 /// Shifts this APInt left by \p Bits and returns the result.
925 APInt operator<<(unsigned Bits) const { return shl(Bits); }
926
927 /// \brief Left logical shift operator.
928 ///
929 /// Shifts this APInt left by \p Bits and returns the result.
930 APInt operator<<(const APInt &Bits) const { return shl(Bits); }
931
932 /// \brief Arithmetic right-shift function.
933 ///
934 /// Arithmetic right-shift this APInt by shiftAmt.
935 APInt ashr(unsigned ShiftAmt) const {
936 APInt R(*this);
937 R.ashrInPlace(ShiftAmt);
938 return R;
939 }
940
941 /// Arithmetic right-shift this APInt by ShiftAmt in place.
942 void ashrInPlace(unsigned ShiftAmt) {
943 assert(ShiftAmt <= BitWidth && "Invalid shift amount")(static_cast <bool> (ShiftAmt <= BitWidth &&
"Invalid shift amount") ? void (0) : __assert_fail ("ShiftAmt <= BitWidth && \"Invalid shift amount\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/APInt.h"
, 943, __extension__ __PRETTY_FUNCTION__))
;
944 if (isSingleWord()) {
945 int64_t SExtVAL = SignExtend64(U.VAL, BitWidth);
946 if (ShiftAmt == BitWidth)
947 U.VAL = SExtVAL >> (APINT_BITS_PER_WORD - 1); // Fill with sign bit.
948 else
949 U.VAL = SExtVAL >> ShiftAmt;
950 clearUnusedBits();
951 return;
952 }
953 ashrSlowCase(ShiftAmt);
954 }
955
956 /// \brief Logical right-shift function.
957 ///
958 /// Logical right-shift this APInt by shiftAmt.
959 APInt lshr(unsigned shiftAmt) const {
960 APInt R(*this);
961 R.lshrInPlace(shiftAmt);
962 return R;
963 }
964
965 /// Logical right-shift this APInt by ShiftAmt in place.
966 void lshrInPlace(unsigned ShiftAmt) {
967 assert(ShiftAmt <= BitWidth && "Invalid shift amount")(static_cast <bool> (ShiftAmt <= BitWidth &&
"Invalid shift amount") ? void (0) : __assert_fail ("ShiftAmt <= BitWidth && \"Invalid shift amount\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/APInt.h"
, 967, __extension__ __PRETTY_FUNCTION__))
;
968 if (isSingleWord()) {
969 if (ShiftAmt == BitWidth)
970 U.VAL = 0;
971 else
972 U.VAL >>= ShiftAmt;
973 return;
974 }
975 lshrSlowCase(ShiftAmt);
976 }
977
978 /// \brief Left-shift function.
979 ///
980 /// Left-shift this APInt by shiftAmt.
981 APInt shl(unsigned shiftAmt) const {
982 APInt R(*this);
983 R <<= shiftAmt;
984 return R;
985 }
986
987 /// \brief Rotate left by rotateAmt.
988 APInt rotl(unsigned rotateAmt) const;
989
990 /// \brief Rotate right by rotateAmt.
991 APInt rotr(unsigned rotateAmt) const;
992
993 /// \brief Arithmetic right-shift function.
994 ///
995 /// Arithmetic right-shift this APInt by shiftAmt.
996 APInt ashr(const APInt &ShiftAmt) const {
997 APInt R(*this);
998 R.ashrInPlace(ShiftAmt);
999 return R;
1000 }
1001
1002 /// Arithmetic right-shift this APInt by shiftAmt in place.
1003 void ashrInPlace(const APInt &shiftAmt);
1004
1005 /// \brief Logical right-shift function.
1006 ///
1007 /// Logical right-shift this APInt by shiftAmt.
1008 APInt lshr(const APInt &ShiftAmt) const {
1009 APInt R(*this);
1010 R.lshrInPlace(ShiftAmt);
1011 return R;
1012 }
1013
1014 /// Logical right-shift this APInt by ShiftAmt in place.
1015 void lshrInPlace(const APInt &ShiftAmt);
1016
1017 /// \brief Left-shift function.
1018 ///
1019 /// Left-shift this APInt by shiftAmt.
1020 APInt shl(const APInt &ShiftAmt) const {
1021 APInt R(*this);
1022 R <<= ShiftAmt;
1023 return R;
1024 }
1025
1026 /// \brief Rotate left by rotateAmt.
1027 APInt rotl(const APInt &rotateAmt) const;
1028
1029 /// \brief Rotate right by rotateAmt.
1030 APInt rotr(const APInt &rotateAmt) const;
1031
1032 /// \brief Unsigned division operation.
1033 ///
1034 /// Perform an unsigned divide operation on this APInt by RHS. Both this and
1035 /// RHS are treated as unsigned quantities for purposes of this division.
1036 ///
1037 /// \returns a new APInt value containing the division result
1038 APInt udiv(const APInt &RHS) const;
1039 APInt udiv(uint64_t RHS) const;
1040
1041 /// \brief Signed division function for APInt.
1042 ///
1043 /// Signed divide this APInt by APInt RHS.
1044 APInt sdiv(const APInt &RHS) const;
1045 APInt sdiv(int64_t RHS) const;
1046
1047 /// \brief Unsigned remainder operation.
1048 ///
1049 /// Perform an unsigned remainder operation on this APInt with RHS being the
1050 /// divisor. Both this and RHS are treated as unsigned quantities for purposes
1051 /// of this operation. Note that this is a true remainder operation and not a
1052 /// modulo operation because the sign follows the sign of the dividend which
1053 /// is *this.
1054 ///
1055 /// \returns a new APInt value containing the remainder result
1056 APInt urem(const APInt &RHS) const;
1057 uint64_t urem(uint64_t RHS) const;
1058
1059 /// \brief Function for signed remainder operation.
1060 ///
1061 /// Signed remainder operation on APInt.
1062 APInt srem(const APInt &RHS) const;
1063 int64_t srem(int64_t RHS) const;
1064
1065 /// \brief Dual division/remainder interface.
1066 ///
1067 /// Sometimes it is convenient to divide two APInt values and obtain both the
1068 /// quotient and remainder. This function does both operations in the same
1069 /// computation making it a little more efficient. The pair of input arguments
1070 /// may overlap with the pair of output arguments. It is safe to call
1071 /// udivrem(X, Y, X, Y), for example.
1072 static void udivrem(const APInt &LHS, const APInt &RHS, APInt &Quotient,
1073 APInt &Remainder);
1074 static void udivrem(const APInt &LHS, uint64_t RHS, APInt &Quotient,
1075 uint64_t &Remainder);
1076
1077 static void sdivrem(const APInt &LHS, const APInt &RHS, APInt &Quotient,
1078 APInt &Remainder);
1079 static void sdivrem(const APInt &LHS, int64_t RHS, APInt &Quotient,
1080 int64_t &Remainder);
1081
1082 // Operations that return overflow indicators.
1083 APInt sadd_ov(const APInt &RHS, bool &Overflow) const;
1084 APInt uadd_ov(const APInt &RHS, bool &Overflow) const;
1085 APInt ssub_ov(const APInt &RHS, bool &Overflow) const;
1086 APInt usub_ov(const APInt &RHS, bool &Overflow) const;
1087 APInt sdiv_ov(const APInt &RHS, bool &Overflow) const;
1088 APInt smul_ov(const APInt &RHS, bool &Overflow) const;
1089 APInt umul_ov(const APInt &RHS, bool &Overflow) const;
1090 APInt sshl_ov(const APInt &Amt, bool &Overflow) const;
1091 APInt ushl_ov(const APInt &Amt, bool &Overflow) const;
1092
1093 /// \brief Array-indexing support.
1094 ///
1095 /// \returns the bit value at bitPosition
1096 bool operator[](unsigned bitPosition) const {
1097 assert(bitPosition < getBitWidth() && "Bit position out of bounds!")(static_cast <bool> (bitPosition < getBitWidth() &&
"Bit position out of bounds!") ? void (0) : __assert_fail ("bitPosition < getBitWidth() && \"Bit position out of bounds!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/APInt.h"
, 1097, __extension__ __PRETTY_FUNCTION__))
;
1098 return (maskBit(bitPosition) & getWord(bitPosition)) != 0;
1099 }
1100
1101 /// @}
1102 /// \name Comparison Operators
1103 /// @{
1104
1105 /// \brief Equality operator.
1106 ///
1107 /// Compares this APInt with RHS for the validity of the equality
1108 /// relationship.
1109 bool operator==(const APInt &RHS) const {
1110 assert(BitWidth == RHS.BitWidth && "Comparison requires equal bit widths")(static_cast <bool> (BitWidth == RHS.BitWidth &&
"Comparison requires equal bit widths") ? void (0) : __assert_fail
("BitWidth == RHS.BitWidth && \"Comparison requires equal bit widths\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/APInt.h"
, 1110, __extension__ __PRETTY_FUNCTION__))
;
1111 if (isSingleWord())
1112 return U.VAL == RHS.U.VAL;
1113 return EqualSlowCase(RHS);
1114 }
1115
1116 /// \brief Equality operator.
1117 ///
1118 /// Compares this APInt with a uint64_t for the validity of the equality
1119 /// relationship.
1120 ///
1121 /// \returns true if *this == Val
1122 bool operator==(uint64_t Val) const {
1123 return (isSingleWord() || getActiveBits() <= 64) && getZExtValue() == Val;
1124 }
1125
1126 /// \brief Equality comparison.
1127 ///
1128 /// Compares this APInt with RHS for the validity of the equality
1129 /// relationship.
1130 ///
1131 /// \returns true if *this == Val
1132 bool eq(const APInt &RHS) const { return (*this) == RHS; }
1133
1134 /// \brief Inequality operator.
1135 ///
1136 /// Compares this APInt with RHS for the validity of the inequality
1137 /// relationship.
1138 ///
1139 /// \returns true if *this != Val
1140 bool operator!=(const APInt &RHS) const { return !((*this) == RHS); }
1141
1142 /// \brief Inequality operator.
1143 ///
1144 /// Compares this APInt with a uint64_t for the validity of the inequality
1145 /// relationship.
1146 ///
1147 /// \returns true if *this != Val
1148 bool operator!=(uint64_t Val) const { return !((*this) == Val); }
1149
1150 /// \brief Inequality comparison
1151 ///
1152 /// Compares this APInt with RHS for the validity of the inequality
1153 /// relationship.
1154 ///
1155 /// \returns true if *this != Val
1156 bool ne(const APInt &RHS) const { return !((*this) == RHS); }
1157
1158 /// \brief Unsigned less than comparison
1159 ///
1160 /// Regards both *this and RHS as unsigned quantities and compares them for
1161 /// the validity of the less-than relationship.
1162 ///
1163 /// \returns true if *this < RHS when both are considered unsigned.
1164 bool ult(const APInt &RHS) const { return compare(RHS) < 0; }
1165
1166 /// \brief Unsigned less than comparison
1167 ///
1168 /// Regards both *this as an unsigned quantity and compares it with RHS for
1169 /// the validity of the less-than relationship.
1170 ///
1171 /// \returns true if *this < RHS when considered unsigned.
1172 bool ult(uint64_t RHS) const {
1173 // Only need to check active bits if not a single word.
1174 return (isSingleWord() || getActiveBits() <= 64) && getZExtValue() < RHS;
1175 }
1176
1177 /// \brief Signed less than comparison
1178 ///
1179 /// Regards both *this and RHS as signed quantities and compares them for
1180 /// validity of the less-than relationship.
1181 ///
1182 /// \returns true if *this < RHS when both are considered signed.
1183 bool slt(const APInt &RHS) const { return compareSigned(RHS) < 0; }
1184
1185 /// \brief Signed less than comparison
1186 ///
1187 /// Regards both *this as a signed quantity and compares it with RHS for
1188 /// the validity of the less-than relationship.
1189 ///
1190 /// \returns true if *this < RHS when considered signed.
1191 bool slt(int64_t RHS) const {
1192 return (!isSingleWord() && getMinSignedBits() > 64) ? isNegative()
1193 : getSExtValue() < RHS;
1194 }
1195
1196 /// \brief Unsigned less or equal comparison
1197 ///
1198 /// Regards both *this and RHS as unsigned quantities and compares them for
1199 /// validity of the less-or-equal relationship.
1200 ///
1201 /// \returns true if *this <= RHS when both are considered unsigned.
1202 bool ule(const APInt &RHS) const { return compare(RHS) <= 0; }
1203
1204 /// \brief Unsigned less or equal comparison
1205 ///
1206 /// Regards both *this as an unsigned quantity and compares it with RHS for
1207 /// the validity of the less-or-equal relationship.
1208 ///
1209 /// \returns true if *this <= RHS when considered unsigned.
1210 bool ule(uint64_t RHS) const { return !ugt(RHS); }
1211
1212 /// \brief Signed less or equal comparison
1213 ///
1214 /// Regards both *this and RHS as signed quantities and compares them for
1215 /// validity of the less-or-equal relationship.
1216 ///
1217 /// \returns true if *this <= RHS when both are considered signed.
1218 bool sle(const APInt &RHS) const { return compareSigned(RHS) <= 0; }
1219
1220 /// \brief Signed less or equal comparison
1221 ///
1222 /// Regards both *this as a signed quantity and compares it with RHS for the
1223 /// validity of the less-or-equal relationship.
1224 ///
1225 /// \returns true if *this <= RHS when considered signed.
1226 bool sle(uint64_t RHS) const { return !sgt(RHS); }
1227
1228 /// \brief Unsigned greather than comparison
1229 ///
1230 /// Regards both *this and RHS as unsigned quantities and compares them for
1231 /// the validity of the greater-than relationship.
1232 ///
1233 /// \returns true if *this > RHS when both are considered unsigned.
1234 bool ugt(const APInt &RHS) const { return !ule(RHS); }
1235
1236 /// \brief Unsigned greater than comparison
1237 ///
1238 /// Regards both *this as an unsigned quantity and compares it with RHS for
1239 /// the validity of the greater-than relationship.
1240 ///
1241 /// \returns true if *this > RHS when considered unsigned.
1242 bool ugt(uint64_t RHS) const {
1243 // Only need to check active bits if not a single word.
1244 return (!isSingleWord() && getActiveBits() > 64) || getZExtValue() > RHS;
1245 }
1246
1247 /// \brief Signed greather than comparison
1248 ///
1249 /// Regards both *this and RHS as signed quantities and compares them for the
1250 /// validity of the greater-than relationship.
1251 ///
1252 /// \returns true if *this > RHS when both are considered signed.
1253 bool sgt(const APInt &RHS) const { return !sle(RHS); }
1254
1255 /// \brief Signed greater than comparison
1256 ///
1257 /// Regards both *this as a signed quantity and compares it with RHS for
1258 /// the validity of the greater-than relationship.
1259 ///
1260 /// \returns true if *this > RHS when considered signed.
1261 bool sgt(int64_t RHS) const {
1262 return (!isSingleWord() && getMinSignedBits() > 64) ? !isNegative()
1263 : getSExtValue() > RHS;
1264 }
1265
1266 /// \brief Unsigned greater or equal comparison
1267 ///
1268 /// Regards both *this and RHS as unsigned quantities and compares them for
1269 /// validity of the greater-or-equal relationship.
1270 ///
1271 /// \returns true if *this >= RHS when both are considered unsigned.
1272 bool uge(const APInt &RHS) const { return !ult(RHS); }
1273
1274 /// \brief Unsigned greater or equal comparison
1275 ///
1276 /// Regards both *this as an unsigned quantity and compares it with RHS for
1277 /// the validity of the greater-or-equal relationship.
1278 ///
1279 /// \returns true if *this >= RHS when considered unsigned.
1280 bool uge(uint64_t RHS) const { return !ult(RHS); }
1281
1282 /// \brief Signed greater or equal comparison
1283 ///
1284 /// Regards both *this and RHS as signed quantities and compares them for
1285 /// validity of the greater-or-equal relationship.
1286 ///
1287 /// \returns true if *this >= RHS when both are considered signed.
1288 bool sge(const APInt &RHS) const { return !slt(RHS); }
1289
1290 /// \brief Signed greater or equal comparison
1291 ///
1292 /// Regards both *this as a signed quantity and compares it with RHS for
1293 /// the validity of the greater-or-equal relationship.
1294 ///
1295 /// \returns true if *this >= RHS when considered signed.
1296 bool sge(int64_t RHS) const { return !slt(RHS); }
1297
1298 /// This operation tests if there are any pairs of corresponding bits
1299 /// between this APInt and RHS that are both set.
1300 bool intersects(const APInt &RHS) const {
1301 assert(BitWidth == RHS.BitWidth && "Bit widths must be the same")(static_cast <bool> (BitWidth == RHS.BitWidth &&
"Bit widths must be the same") ? void (0) : __assert_fail ("BitWidth == RHS.BitWidth && \"Bit widths must be the same\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/APInt.h"
, 1301, __extension__ __PRETTY_FUNCTION__))
;
1302 if (isSingleWord())
1303 return (U.VAL & RHS.U.VAL) != 0;
1304 return intersectsSlowCase(RHS);
1305 }
1306
1307 /// This operation checks that all bits set in this APInt are also set in RHS.
1308 bool isSubsetOf(const APInt &RHS) const {
1309 assert(BitWidth == RHS.BitWidth && "Bit widths must be the same")(static_cast <bool> (BitWidth == RHS.BitWidth &&
"Bit widths must be the same") ? void (0) : __assert_fail ("BitWidth == RHS.BitWidth && \"Bit widths must be the same\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/APInt.h"
, 1309, __extension__ __PRETTY_FUNCTION__))
;
1310 if (isSingleWord())
1311 return (U.VAL & ~RHS.U.VAL) == 0;
1312 return isSubsetOfSlowCase(RHS);
1313 }
1314
1315 /// @}
1316 /// \name Resizing Operators
1317 /// @{
1318
1319 /// \brief Truncate to new width.
1320 ///
1321 /// Truncate the APInt to a specified width. It is an error to specify a width
1322 /// that is greater than or equal to the current width.
1323 APInt trunc(unsigned width) const;
1324
1325 /// \brief Sign extend to a new width.
1326 ///
1327 /// This operation sign extends the APInt to a new width. If the high order
1328 /// bit is set, the fill on the left will be done with 1 bits, otherwise zero.
1329 /// It is an error to specify a width that is less than or equal to the
1330 /// current width.
1331 APInt sext(unsigned width) const;
1332
1333 /// \brief Zero extend to a new width.
1334 ///
1335 /// This operation zero extends the APInt to a new width. The high order bits
1336 /// are filled with 0 bits. It is an error to specify a width that is less
1337 /// than or equal to the current width.
1338 APInt zext(unsigned width) const;
1339
1340 /// \brief Sign extend or truncate to width
1341 ///
1342 /// Make this APInt have the bit width given by \p width. The value is sign
1343 /// extended, truncated, or left alone to make it that width.
1344 APInt sextOrTrunc(unsigned width) const;
1345
1346 /// \brief Zero extend or truncate to width
1347 ///
1348 /// Make this APInt have the bit width given by \p width. The value is zero
1349 /// extended, truncated, or left alone to make it that width.
1350 APInt zextOrTrunc(unsigned width) const;
1351
1352 /// \brief Sign extend or truncate to width
1353 ///
1354 /// Make this APInt have the bit width given by \p width. The value is sign
1355 /// extended, or left alone to make it that width.
1356 APInt sextOrSelf(unsigned width) const;
1357
1358 /// \brief Zero extend or truncate to width
1359 ///
1360 /// Make this APInt have the bit width given by \p width. The value is zero
1361 /// extended, or left alone to make it that width.
1362 APInt zextOrSelf(unsigned width) const;
1363
1364 /// @}
1365 /// \name Bit Manipulation Operators
1366 /// @{
1367
1368 /// \brief Set every bit to 1.
1369 void setAllBits() {
1370 if (isSingleWord())
1371 U.VAL = WORD_MAX;
1372 else
1373 // Set all the bits in all the words.
1374 memset(U.pVal, -1, getNumWords() * APINT_WORD_SIZE);
1375 // Clear the unused ones
1376 clearUnusedBits();
1377 }
1378
1379 /// \brief Set a given bit to 1.
1380 ///
1381 /// Set the given bit to 1 whose position is given as "bitPosition".
1382 void setBit(unsigned BitPosition) {
1383 assert(BitPosition <= BitWidth && "BitPosition out of range")(static_cast <bool> (BitPosition <= BitWidth &&
"BitPosition out of range") ? void (0) : __assert_fail ("BitPosition <= BitWidth && \"BitPosition out of range\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/APInt.h"
, 1383, __extension__ __PRETTY_FUNCTION__))
;
1384 WordType Mask = maskBit(BitPosition);
1385 if (isSingleWord())
1386 U.VAL |= Mask;
1387 else
1388 U.pVal[whichWord(BitPosition)] |= Mask;
1389 }
1390
1391 /// Set the sign bit to 1.
1392 void setSignBit() {
1393 setBit(BitWidth - 1);
1394 }
1395
1396 /// Set the bits from loBit (inclusive) to hiBit (exclusive) to 1.
1397 void setBits(unsigned loBit, unsigned hiBit) {
1398 assert(hiBit <= BitWidth && "hiBit out of range")(static_cast <bool> (hiBit <= BitWidth && "hiBit out of range"
) ? void (0) : __assert_fail ("hiBit <= BitWidth && \"hiBit out of range\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/APInt.h"
, 1398, __extension__ __PRETTY_FUNCTION__))
;
1399 assert(loBit <= BitWidth && "loBit out of range")(static_cast <bool> (loBit <= BitWidth && "loBit out of range"
) ? void (0) : __assert_fail ("loBit <= BitWidth && \"loBit out of range\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/APInt.h"
, 1399, __extension__ __PRETTY_FUNCTION__))
;
1400 assert(loBit <= hiBit && "loBit greater than hiBit")(static_cast <bool> (loBit <= hiBit && "loBit greater than hiBit"
) ? void (0) : __assert_fail ("loBit <= hiBit && \"loBit greater than hiBit\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/APInt.h"
, 1400, __extension__ __PRETTY_FUNCTION__))
;
1401 if (loBit == hiBit)
1402 return;
1403 if (loBit < APINT_BITS_PER_WORD && hiBit <= APINT_BITS_PER_WORD) {
1404 uint64_t mask = WORD_MAX >> (APINT_BITS_PER_WORD - (hiBit - loBit));
1405 mask <<= loBit;
1406 if (isSingleWord())
1407 U.VAL |= mask;
1408 else
1409 U.pVal[0] |= mask;
1410 } else {
1411 setBitsSlowCase(loBit, hiBit);
1412 }
1413 }
1414
1415 /// Set the top bits starting from loBit.
1416 void setBitsFrom(unsigned loBit) {
1417 return setBits(loBit, BitWidth);
1418 }
1419
1420 /// Set the bottom loBits bits.
1421 void setLowBits(unsigned loBits) {
1422 return setBits(0, loBits);
1423 }
1424
1425 /// Set the top hiBits bits.
1426 void setHighBits(unsigned hiBits) {
1427 return setBits(BitWidth - hiBits, BitWidth);
1428 }
1429
1430 /// \brief Set every bit to 0.
1431 void clearAllBits() {
1432 if (isSingleWord())
1433 U.VAL = 0;
1434 else
1435 memset(U.pVal, 0, getNumWords() * APINT_WORD_SIZE);
1436 }
1437
1438 /// \brief Set a given bit to 0.
1439 ///
1440 /// Set the given bit to 0 whose position is given as "bitPosition".
1441 void clearBit(unsigned BitPosition) {
1442 assert(BitPosition <= BitWidth && "BitPosition out of range")(static_cast <bool> (BitPosition <= BitWidth &&
"BitPosition out of range") ? void (0) : __assert_fail ("BitPosition <= BitWidth && \"BitPosition out of range\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/APInt.h"
, 1442, __extension__ __PRETTY_FUNCTION__))
;
1443 WordType Mask = ~maskBit(BitPosition);
1444 if (isSingleWord())
1445 U.VAL &= Mask;
1446 else
1447 U.pVal[whichWord(BitPosition)] &= Mask;
1448 }
1449
1450 /// Set the sign bit to 0.
1451 void clearSignBit() {
1452 clearBit(BitWidth - 1);
1453 }
1454
1455 /// \brief Toggle every bit to its opposite value.
1456 void flipAllBits() {
1457 if (isSingleWord()) {
1458 U.VAL ^= WORD_MAX;
1459 clearUnusedBits();
1460 } else {
1461 flipAllBitsSlowCase();
1462 }
1463 }
1464
1465 /// \brief Toggles a given bit to its opposite value.
1466 ///
1467 /// Toggle a given bit to its opposite value whose position is given
1468 /// as "bitPosition".
1469 void flipBit(unsigned bitPosition);
1470
1471 /// Negate this APInt in place.
1472 void negate() {
1473 flipAllBits();
1474 ++(*this);
1475 }
1476
1477 /// Insert the bits from a smaller APInt starting at bitPosition.
1478 void insertBits(const APInt &SubBits, unsigned bitPosition);
1479
1480 /// Return an APInt with the extracted bits [bitPosition,bitPosition+numBits).
1481 APInt extractBits(unsigned numBits, unsigned bitPosition) const;
1482
1483 /// @}
1484 /// \name Value Characterization Functions
1485 /// @{
1486
1487 /// \brief Return the number of bits in the APInt.
1488 unsigned getBitWidth() const { return BitWidth; }
1489
1490 /// \brief Get the number of words.
1491 ///
1492 /// Here one word's bitwidth equals to that of uint64_t.
1493 ///
1494 /// \returns the number of words to hold the integer value of this APInt.
1495 unsigned getNumWords() const { return getNumWords(BitWidth); }
1496
1497 /// \brief Get the number of words.
1498 ///
1499 /// *NOTE* Here one word's bitwidth equals to that of uint64_t.
1500 ///
1501 /// \returns the number of words to hold the integer value with a given bit
1502 /// width.
1503 static unsigned getNumWords(unsigned BitWidth) {
1504 return ((uint64_t)BitWidth + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD;
1505 }
1506
1507 /// \brief Compute the number of active bits in the value
1508 ///
1509 /// This function returns the number of active bits which is defined as the
1510 /// bit width minus the number of leading zeros. This is used in several
1511 /// computations to see how "wide" the value is.
1512 unsigned getActiveBits() const { return BitWidth - countLeadingZeros(); }
1513
1514 /// \brief Compute the number of active words in the value of this APInt.
1515 ///
1516 /// This is used in conjunction with getActiveData to extract the raw value of
1517 /// the APInt.
1518 unsigned getActiveWords() const {
1519 unsigned numActiveBits = getActiveBits();
1520 return numActiveBits ? whichWord(numActiveBits - 1) + 1 : 1;
1521 }
1522
1523 /// \brief Get the minimum bit size for this signed APInt
1524 ///
1525 /// Computes the minimum bit width for this APInt while considering it to be a
1526 /// signed (and probably negative) value. If the value is not negative, this
1527 /// function returns the same value as getActiveBits()+1. Otherwise, it
1528 /// returns the smallest bit width that will retain the negative value. For
1529 /// example, -1 can be written as 0b1 or 0xFFFFFFFFFF. 0b1 is shorter and so
1530 /// for -1, this function will always return 1.
1531 unsigned getMinSignedBits() const {
1532 if (isNegative())
1533 return BitWidth - countLeadingOnes() + 1;
1534 return getActiveBits() + 1;
1535 }
1536
1537 /// \brief Get zero extended value
1538 ///
1539 /// This method attempts to return the value of this APInt as a zero extended
1540 /// uint64_t. The bitwidth must be <= 64 or the value must fit within a
1541 /// uint64_t. Otherwise an assertion will result.
1542 uint64_t getZExtValue() const {
1543 if (isSingleWord())
1544 return U.VAL;
1545 assert(getActiveBits() <= 64 && "Too many bits for uint64_t")(static_cast <bool> (getActiveBits() <= 64 &&
"Too many bits for uint64_t") ? void (0) : __assert_fail ("getActiveBits() <= 64 && \"Too many bits for uint64_t\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/APInt.h"
, 1545, __extension__ __PRETTY_FUNCTION__))
;
1546 return U.pVal[0];
1547 }
1548
1549 /// \brief Get sign extended value
1550 ///
1551 /// This method attempts to return the value of this APInt as a sign extended
1552 /// int64_t. The bit width must be <= 64 or the value must fit within an
1553 /// int64_t. Otherwise an assertion will result.
1554 int64_t getSExtValue() const {
1555 if (isSingleWord())
1556 return SignExtend64(U.VAL, BitWidth);
1557 assert(getMinSignedBits() <= 64 && "Too many bits for int64_t")(static_cast <bool> (getMinSignedBits() <= 64 &&
"Too many bits for int64_t") ? void (0) : __assert_fail ("getMinSignedBits() <= 64 && \"Too many bits for int64_t\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/APInt.h"
, 1557, __extension__ __PRETTY_FUNCTION__))
;
1558 return int64_t(U.pVal[0]);
1559 }
1560
1561 /// \brief Get bits required for string value.
1562 ///
1563 /// This method determines how many bits are required to hold the APInt
1564 /// equivalent of the string given by \p str.
1565 static unsigned getBitsNeeded(StringRef str, uint8_t radix);
1566
1567 /// \brief The APInt version of the countLeadingZeros functions in
1568 /// MathExtras.h.
1569 ///
1570 /// It counts the number of zeros from the most significant bit to the first
1571 /// one bit.
1572 ///
1573 /// \returns BitWidth if the value is zero, otherwise returns the number of
1574 /// zeros from the most significant bit to the first one bits.
1575 unsigned countLeadingZeros() const {
1576 if (isSingleWord()) {
1577 unsigned unusedBits = APINT_BITS_PER_WORD - BitWidth;
1578 return llvm::countLeadingZeros(U.VAL) - unusedBits;
1579 }
1580 return countLeadingZerosSlowCase();
1581 }
1582
1583 /// \brief Count the number of leading one bits.
1584 ///
1585 /// This function is an APInt version of the countLeadingOnes
1586 /// functions in MathExtras.h. It counts the number of ones from the most
1587 /// significant bit to the first zero bit.
1588 ///
1589 /// \returns 0 if the high order bit is not set, otherwise returns the number
1590 /// of 1 bits from the most significant to the least
1591 unsigned countLeadingOnes() const {
1592 if (isSingleWord())
1593 return llvm::countLeadingOnes(U.VAL << (APINT_BITS_PER_WORD - BitWidth));
1594 return countLeadingOnesSlowCase();
1595 }
1596
1597 /// Computes the number of leading bits of this APInt that are equal to its
1598 /// sign bit.
1599 unsigned getNumSignBits() const {
1600 return isNegative() ? countLeadingOnes() : countLeadingZeros();
1601 }
1602
1603 /// \brief Count the number of trailing zero bits.
1604 ///
1605 /// This function is an APInt version of the countTrailingZeros
1606 /// functions in MathExtras.h. It counts the number of zeros from the least
1607 /// significant bit to the first set bit.
1608 ///
1609 /// \returns BitWidth if the value is zero, otherwise returns the number of
1610 /// zeros from the least significant bit to the first one bit.
1611 unsigned countTrailingZeros() const {
1612 if (isSingleWord())
1613 return std::min(unsigned(llvm::countTrailingZeros(U.VAL)), BitWidth);
1614 return countTrailingZerosSlowCase();
1615 }
1616
1617 /// \brief Count the number of trailing one bits.
1618 ///
1619 /// This function is an APInt version of the countTrailingOnes
1620 /// functions in MathExtras.h. It counts the number of ones from the least
1621 /// significant bit to the first zero bit.
1622 ///
1623 /// \returns BitWidth if the value is all ones, otherwise returns the number
1624 /// of ones from the least significant bit to the first zero bit.
1625 unsigned countTrailingOnes() const {
1626 if (isSingleWord())
1627 return llvm::countTrailingOnes(U.VAL);
1628 return countTrailingOnesSlowCase();
1629 }
1630
1631 /// \brief Count the number of bits set.
1632 ///
1633 /// This function is an APInt version of the countPopulation functions
1634 /// in MathExtras.h. It counts the number of 1 bits in the APInt value.
1635 ///
1636 /// \returns 0 if the value is zero, otherwise returns the number of set bits.
1637 unsigned countPopulation() const {
1638 if (isSingleWord())
1639 return llvm::countPopulation(U.VAL);
1640 return countPopulationSlowCase();
1641 }
1642
1643 /// @}
1644 /// \name Conversion Functions
1645 /// @{
1646 void print(raw_ostream &OS, bool isSigned) const;
1647
1648 /// Converts an APInt to a string and append it to Str. Str is commonly a
1649 /// SmallString.
1650 void toString(SmallVectorImpl<char> &Str, unsigned Radix, bool Signed,
1651 bool formatAsCLiteral = false) const;
1652
1653 /// Considers the APInt to be unsigned and converts it into a string in the
1654 /// radix given. The radix can be 2, 8, 10 16, or 36.
1655 void toStringUnsigned(SmallVectorImpl<char> &Str, unsigned Radix = 10) const {
1656 toString(Str, Radix, false, false);
1657 }
1658
1659 /// Considers the APInt to be signed and converts it into a string in the
1660 /// radix given. The radix can be 2, 8, 10, 16, or 36.
1661 void toStringSigned(SmallVectorImpl<char> &Str, unsigned Radix = 10) const {
1662 toString(Str, Radix, true, false);
1663 }
1664
1665 /// \brief Return the APInt as a std::string.
1666 ///
1667 /// Note that this is an inefficient method. It is better to pass in a
1668 /// SmallVector/SmallString to the methods above to avoid thrashing the heap
1669 /// for the string.
1670 std::string toString(unsigned Radix, bool Signed) const;
1671
1672 /// \returns a byte-swapped representation of this APInt Value.
1673 APInt byteSwap() const;
1674
1675 /// \returns the value with the bit representation reversed of this APInt
1676 /// Value.
1677 APInt reverseBits() const;
1678
1679 /// \brief Converts this APInt to a double value.
1680 double roundToDouble(bool isSigned) const;
1681
1682 /// \brief Converts this unsigned APInt to a double value.
1683 double roundToDouble() const { return roundToDouble(false); }
1684
1685 /// \brief Converts this signed APInt to a double value.
1686 double signedRoundToDouble() const { return roundToDouble(true); }
1687
1688 /// \brief Converts APInt bits to a double
1689 ///
1690 /// The conversion does not do a translation from integer to double, it just
1691 /// re-interprets the bits as a double. Note that it is valid to do this on
1692 /// any bit width. Exactly 64 bits will be translated.
1693 double bitsToDouble() const {
1694 return BitsToDouble(getWord(0));
1695 }
1696
1697 /// \brief Converts APInt bits to a double
1698 ///
1699 /// The conversion does not do a translation from integer to float, it just
1700 /// re-interprets the bits as a float. Note that it is valid to do this on
1701 /// any bit width. Exactly 32 bits will be translated.
1702 float bitsToFloat() const {
1703 return BitsToFloat(getWord(0));
1704 }
1705
1706 /// \brief Converts a double to APInt bits.
1707 ///
1708 /// The conversion does not do a translation from double to integer, it just
1709 /// re-interprets the bits of the double.
1710 static APInt doubleToBits(double V) {
1711 return APInt(sizeof(double) * CHAR_BIT8, DoubleToBits(V));
1712 }
1713
1714 /// \brief Converts a float to APInt bits.
1715 ///
1716 /// The conversion does not do a translation from float to integer, it just
1717 /// re-interprets the bits of the float.
1718 static APInt floatToBits(float V) {
1719 return APInt(sizeof(float) * CHAR_BIT8, FloatToBits(V));
1720 }
1721
1722 /// @}
1723 /// \name Mathematics Operations
1724 /// @{
1725
1726 /// \returns the floor log base 2 of this APInt.
1727 unsigned logBase2() const { return getActiveBits() - 1; }
1728
1729 /// \returns the ceil log base 2 of this APInt.
1730 unsigned ceilLogBase2() const {
1731 APInt temp(*this);
1732 --temp;
1733 return temp.getActiveBits();
1734 }
1735
1736 /// \returns the nearest log base 2 of this APInt. Ties round up.
1737 ///
1738 /// NOTE: When we have a BitWidth of 1, we define:
1739 ///
1740 /// log2(0) = UINT32_MAX
1741 /// log2(1) = 0
1742 ///
1743 /// to get around any mathematical concerns resulting from
1744 /// referencing 2 in a space where 2 does no exist.
1745 unsigned nearestLogBase2() const {
1746 // Special case when we have a bitwidth of 1. If VAL is 1, then we
1747 // get 0. If VAL is 0, we get WORD_MAX which gets truncated to
1748 // UINT32_MAX.
1749 if (BitWidth == 1)
1750 return U.VAL - 1;
1751
1752 // Handle the zero case.
1753 if (isNullValue())
1754 return UINT32_MAX(4294967295U);
1755
1756 // The non-zero case is handled by computing:
1757 //
1758 // nearestLogBase2(x) = logBase2(x) + x[logBase2(x)-1].
1759 //
1760 // where x[i] is referring to the value of the ith bit of x.
1761 unsigned lg = logBase2();
1762 return lg + unsigned((*this)[lg - 1]);
1763 }
1764
1765 /// \returns the log base 2 of this APInt if its an exact power of two, -1
1766 /// otherwise
1767 int32_t exactLogBase2() const {
1768 if (!isPowerOf2())
1769 return -1;
1770 return logBase2();
1771 }
1772
1773 /// \brief Compute the square root
1774 APInt sqrt() const;
1775
1776 /// \brief Get the absolute value;
1777 ///
1778 /// If *this is < 0 then return -(*this), otherwise *this;
1779 APInt abs() const {
1780 if (isNegative())
1781 return -(*this);
1782 return *this;
1783 }
1784
1785 /// \returns the multiplicative inverse for a given modulo.
1786 APInt multiplicativeInverse(const APInt &modulo) const;
1787
1788 /// @}
1789 /// \name Support for division by constant
1790 /// @{
1791
1792 /// Calculate the magic number for signed division by a constant.
1793 struct ms;
1794 ms magic() const;
1795
1796 /// Calculate the magic number for unsigned division by a constant.
1797 struct mu;
1798 mu magicu(unsigned LeadingZeros = 0) const;
1799
1800 /// @}
1801 /// \name Building-block Operations for APInt and APFloat
1802 /// @{
1803
1804 // These building block operations operate on a representation of arbitrary
1805 // precision, two's-complement, bignum integer values. They should be
1806 // sufficient to implement APInt and APFloat bignum requirements. Inputs are
1807 // generally a pointer to the base of an array of integer parts, representing
1808 // an unsigned bignum, and a count of how many parts there are.
1809
1810 /// Sets the least significant part of a bignum to the input value, and zeroes
1811 /// out higher parts.
1812 static void tcSet(WordType *, WordType, unsigned);
1813
1814 /// Assign one bignum to another.
1815 static void tcAssign(WordType *, const WordType *, unsigned);
1816
1817 /// Returns true if a bignum is zero, false otherwise.
1818 static bool tcIsZero(const WordType *, unsigned);
1819
1820 /// Extract the given bit of a bignum; returns 0 or 1. Zero-based.
1821 static int tcExtractBit(const WordType *, unsigned bit);
1822
1823 /// Copy the bit vector of width srcBITS from SRC, starting at bit srcLSB, to
1824 /// DST, of dstCOUNT parts, such that the bit srcLSB becomes the least
1825 /// significant bit of DST. All high bits above srcBITS in DST are
1826 /// zero-filled.
1827 static void tcExtract(WordType *, unsigned dstCount,
1828 const WordType *, unsigned srcBits,
1829 unsigned srcLSB);
1830
1831 /// Set the given bit of a bignum. Zero-based.
1832 static void tcSetBit(WordType *, unsigned bit);
1833
1834 /// Clear the given bit of a bignum. Zero-based.
1835 static void tcClearBit(WordType *, unsigned bit);
1836
1837 /// Returns the bit number of the least or most significant set bit of a
1838 /// number. If the input number has no bits set -1U is returned.
1839 static unsigned tcLSB(const WordType *, unsigned n);
1840 static unsigned tcMSB(const WordType *parts, unsigned n);
1841
1842 /// Negate a bignum in-place.
1843 static void tcNegate(WordType *, unsigned);
1844
1845 /// DST += RHS + CARRY where CARRY is zero or one. Returns the carry flag.
1846 static WordType tcAdd(WordType *, const WordType *,
1847 WordType carry, unsigned);
1848 /// DST += RHS. Returns the carry flag.
1849 static WordType tcAddPart(WordType *, WordType, unsigned);
1850
1851 /// DST -= RHS + CARRY where CARRY is zero or one. Returns the carry flag.
1852 static WordType tcSubtract(WordType *, const WordType *,
1853 WordType carry, unsigned);
1854 /// DST -= RHS. Returns the carry flag.
1855 static WordType tcSubtractPart(WordType *, WordType, unsigned);
1856
1857 /// DST += SRC * MULTIPLIER + PART if add is true
1858 /// DST = SRC * MULTIPLIER + PART if add is false
1859 ///
1860 /// Requires 0 <= DSTPARTS <= SRCPARTS + 1. If DST overlaps SRC they must
1861 /// start at the same point, i.e. DST == SRC.
1862 ///
1863 /// If DSTPARTS == SRC_PARTS + 1 no overflow occurs and zero is returned.
1864 /// Otherwise DST is filled with the least significant DSTPARTS parts of the
1865 /// result, and if all of the omitted higher parts were zero return zero,
1866 /// otherwise overflow occurred and return one.
1867 static int tcMultiplyPart(WordType *dst, const WordType *src,
1868 WordType multiplier, WordType carry,
1869 unsigned srcParts, unsigned dstParts,
1870 bool add);
1871
1872 /// DST = LHS * RHS, where DST has the same width as the operands and is
1873 /// filled with the least significant parts of the result. Returns one if
1874 /// overflow occurred, otherwise zero. DST must be disjoint from both
1875 /// operands.
1876 static int tcMultiply(WordType *, const WordType *, const WordType *,
1877 unsigned);
1878
1879 /// DST = LHS * RHS, where DST has width the sum of the widths of the
1880 /// operands. No overflow occurs. DST must be disjoint from both operands.
1881 static void tcFullMultiply(WordType *, const WordType *,
1882 const WordType *, unsigned, unsigned);
1883
1884 /// If RHS is zero LHS and REMAINDER are left unchanged, return one.
1885 /// Otherwise set LHS to LHS / RHS with the fractional part discarded, set
1886 /// REMAINDER to the remainder, return zero. i.e.
1887 ///
1888 /// OLD_LHS = RHS * LHS + REMAINDER
1889 ///
1890 /// SCRATCH is a bignum of the same size as the operands and result for use by
1891 /// the routine; its contents need not be initialized and are destroyed. LHS,
1892 /// REMAINDER and SCRATCH must be distinct.
1893 static int tcDivide(WordType *lhs, const WordType *rhs,
1894 WordType *remainder, WordType *scratch,
1895 unsigned parts);
1896
1897 /// Shift a bignum left Count bits. Shifted in bits are zero. There are no
1898 /// restrictions on Count.
1899 static void tcShiftLeft(WordType *, unsigned Words, unsigned Count);
1900
1901 /// Shift a bignum right Count bits. Shifted in bits are zero. There are no
1902 /// restrictions on Count.
1903 static void tcShiftRight(WordType *, unsigned Words, unsigned Count);
1904
1905 /// The obvious AND, OR and XOR and complement operations.
1906 static void tcAnd(WordType *, const WordType *, unsigned);
1907 static void tcOr(WordType *, const WordType *, unsigned);
1908 static void tcXor(WordType *, const WordType *, unsigned);
1909 static void tcComplement(WordType *, unsigned);
1910
1911 /// Comparison (unsigned) of two bignums.
1912 static int tcCompare(const WordType *, const WordType *, unsigned);
1913
1914 /// Increment a bignum in-place. Return the carry flag.
1915 static WordType tcIncrement(WordType *dst, unsigned parts) {
1916 return tcAddPart(dst, 1, parts);
1917 }
1918
1919 /// Decrement a bignum in-place. Return the borrow flag.
1920 static WordType tcDecrement(WordType *dst, unsigned parts) {
1921 return tcSubtractPart(dst, 1, parts);
1922 }
1923
1924 /// Set the least significant BITS and clear the rest.
1925 static void tcSetLeastSignificantBits(WordType *, unsigned, unsigned bits);
1926
1927 /// \brief debug method
1928 void dump() const;
1929
1930 /// @}
1931};
1932
1933/// Magic data for optimising signed division by a constant.
1934struct APInt::ms {
1935 APInt m; ///< magic number
1936 unsigned s; ///< shift amount
1937};
1938
1939/// Magic data for optimising unsigned division by a constant.
1940struct APInt::mu {
1941 APInt m; ///< magic number
1942 bool a; ///< add indicator
1943 unsigned s; ///< shift amount
1944};
1945
1946inline bool operator==(uint64_t V1, const APInt &V2) { return V2 == V1; }
1947
1948inline bool operator!=(uint64_t V1, const APInt &V2) { return V2 != V1; }
1949
1950/// \brief Unary bitwise complement operator.
1951///
1952/// \returns an APInt that is the bitwise complement of \p v.
1953inline APInt operator~(APInt v) {
1954 v.flipAllBits();
1955 return v;
1956}
1957
1958inline APInt operator&(APInt a, const APInt &b) {
1959 a &= b;
1960 return a;
1961}
1962
1963inline APInt operator&(const APInt &a, APInt &&b) {
1964 b &= a;
1965 return std::move(b);
1966}
1967
1968inline APInt operator&(APInt a, uint64_t RHS) {
1969 a &= RHS;
1970 return a;
1971}
1972
1973inline APInt operator&(uint64_t LHS, APInt b) {
1974 b &= LHS;
1975 return b;
1976}
1977
1978inline APInt operator|(APInt a, const APInt &b) {
1979 a |= b;
1980 return a;
1981}
1982
1983inline APInt operator|(const APInt &a, APInt &&b) {
1984 b |= a;
1985 return std::move(b);
1986}
1987
1988inline APInt operator|(APInt a, uint64_t RHS) {
1989 a |= RHS;
1990 return a;
1991}
1992
1993inline APInt operator|(uint64_t LHS, APInt b) {
1994 b |= LHS;
1995 return b;
1996}
1997
1998inline APInt operator^(APInt a, const APInt &b) {
1999 a ^= b;
2000 return a;
2001}
2002
2003inline APInt operator^(const APInt &a, APInt &&b) {
2004 b ^= a;
2005 return std::move(b);
2006}
2007
2008inline APInt operator^(APInt a, uint64_t RHS) {
2009 a ^= RHS;
2010 return a;
2011}
2012
2013inline APInt operator^(uint64_t LHS, APInt b) {
2014 b ^= LHS;
2015 return b;
2016}
2017
2018inline raw_ostream &operator<<(raw_ostream &OS, const APInt &I) {
2019 I.print(OS, true);
2020 return OS;
2021}
2022
2023inline APInt operator-(APInt v) {
2024 v.negate();
2025 return v;
2026}
2027
2028inline APInt operator+(APInt a, const APInt &b) {
2029 a += b;
2030 return a;
2031}
2032
2033inline APInt operator+(const APInt &a, APInt &&b) {
2034 b += a;
2035 return std::move(b);
2036}
2037
2038inline APInt operator+(APInt a, uint64_t RHS) {
2039 a += RHS;
2040 return a;
2041}
2042
2043inline APInt operator+(uint64_t LHS, APInt b) {
2044 b += LHS;
2045 return b;
2046}
2047
2048inline APInt operator-(APInt a, const APInt &b) {
2049 a -= b;
2050 return a;
2051}
2052
2053inline APInt operator-(const APInt &a, APInt &&b) {
2054 b.negate();
2055 b += a;
2056 return std::move(b);
2057}
2058
2059inline APInt operator-(APInt a, uint64_t RHS) {
2060 a -= RHS;
2061 return a;
2062}
2063
2064inline APInt operator-(uint64_t LHS, APInt b) {
2065 b.negate();
2066 b += LHS;
2067 return b;
2068}
2069
2070inline APInt operator*(APInt a, uint64_t RHS) {
2071 a *= RHS;
2072 return a;
2073}
2074
2075inline APInt operator*(uint64_t LHS, APInt b) {
2076 b *= LHS;
2077 return b;
2078}
2079
2080
2081namespace APIntOps {
2082
2083/// \brief Determine the smaller of two APInts considered to be signed.
2084inline const APInt &smin(const APInt &A, const APInt &B) {
2085 return A.slt(B) ? A : B;
2086}
2087
2088/// \brief Determine the larger of two APInts considered to be signed.
2089inline const APInt &smax(const APInt &A, const APInt &B) {
2090 return A.sgt(B) ? A : B;
2091}
2092
2093/// \brief Determine the smaller of two APInts considered to be signed.
2094inline const APInt &umin(const APInt &A, const APInt &B) {
2095 return A.ult(B) ? A : B;
2096}
2097
2098/// \brief Determine the larger of two APInts considered to be unsigned.
2099inline const APInt &umax(const APInt &A, const APInt &B) {
2100 return A.ugt(B) ? A : B;
2101}
2102
2103/// \brief Compute GCD of two unsigned APInt values.
2104///
2105/// This function returns the greatest common divisor of the two APInt values
2106/// using Stein's algorithm.
2107///
2108/// \returns the greatest common divisor of A and B.
2109APInt GreatestCommonDivisor(APInt A, APInt B);
2110
2111/// \brief Converts the given APInt to a double value.
2112///
2113/// Treats the APInt as an unsigned value for conversion purposes.
2114inline double RoundAPIntToDouble(const APInt &APIVal) {
2115 return APIVal.roundToDouble();
2116}
2117
2118/// \brief Converts the given APInt to a double value.
2119///
2120/// Treats the APInt as a signed value for conversion purposes.
2121inline double RoundSignedAPIntToDouble(const APInt &APIVal) {
2122 return APIVal.signedRoundToDouble();
2123}
2124
2125/// \brief Converts the given APInt to a float vlalue.
2126inline float RoundAPIntToFloat(const APInt &APIVal) {
2127 return float(RoundAPIntToDouble(APIVal));
2128}
2129
2130/// \brief Converts the given APInt to a float value.
2131///
2132/// Treast the APInt as a signed value for conversion purposes.
2133inline float RoundSignedAPIntToFloat(const APInt &APIVal) {
2134 return float(APIVal.signedRoundToDouble());
2135}
2136
2137/// \brief Converts the given double value into a APInt.
2138///
2139/// This function convert a double value to an APInt value.
2140APInt RoundDoubleToAPInt(double Double, unsigned width);
2141
2142/// \brief Converts a float value into a APInt.
2143///
2144/// Converts a float value into an APInt value.
2145inline APInt RoundFloatToAPInt(float Float, unsigned width) {
2146 return RoundDoubleToAPInt(double(Float), width);
2147}
2148
2149} // End of APIntOps namespace
2150
2151// See friend declaration above. This additional declaration is required in
2152// order to compile LLVM with IBM xlC compiler.
2153hash_code hash_value(const APInt &Arg);
2154} // End of llvm namespace
2155
2156#endif