aboutsummaryrefslogtreecommitdiff
path: root/lib/CodeGen/MIRParser/MIParser.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'lib/CodeGen/MIRParser/MIParser.cpp')
-rw-r--r--lib/CodeGen/MIRParser/MIParser.cpp197
1 files changed, 172 insertions, 25 deletions
diff --git a/lib/CodeGen/MIRParser/MIParser.cpp b/lib/CodeGen/MIRParser/MIParser.cpp
index c68d87b15a31..1a78ae3aad07 100644
--- a/lib/CodeGen/MIRParser/MIParser.cpp
+++ b/lib/CodeGen/MIRParser/MIParser.cpp
@@ -11,8 +11,8 @@
//
//===----------------------------------------------------------------------===//
-#include "MILexer.h"
#include "MIParser.h"
+#include "MILexer.h"
#include "llvm/ADT/APInt.h"
#include "llvm/ADT/APSInt.h"
#include "llvm/ADT/ArrayRef.h"
@@ -21,8 +21,8 @@
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringMap.h"
-#include "llvm/ADT/StringSwitch.h"
#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSwitch.h"
#include "llvm/ADT/Twine.h"
#include "llvm/AsmParser/Parser.h"
#include "llvm/AsmParser/SlotMapping.h"
@@ -33,12 +33,15 @@
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
#include "llvm/CodeGen/MachineMemOperand.h"
-#include "llvm/CodeGen/MachineModuleInfo.h"
#include "llvm/CodeGen/MachineOperand.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
+#include "llvm/CodeGen/TargetInstrInfo.h"
+#include "llvm/CodeGen/TargetRegisterInfo.h"
+#include "llvm/CodeGen/TargetSubtargetInfo.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DataLayout.h"
+#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/DebugLoc.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/InstrTypes.h"
@@ -63,11 +66,8 @@
#include "llvm/Support/SMLoc.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/raw_ostream.h"
-#include "llvm/Target/TargetInstrInfo.h"
#include "llvm/Target/TargetIntrinsicInfo.h"
#include "llvm/Target/TargetMachine.h"
-#include "llvm/Target/TargetRegisterInfo.h"
-#include "llvm/Target/TargetSubtargetInfo.h"
#include <algorithm>
#include <cassert>
#include <cctype>
@@ -209,9 +209,11 @@ public:
bool parseJumpTableIndexOperand(MachineOperand &Dest);
bool parseExternalSymbolOperand(MachineOperand &Dest);
bool parseMDNode(MDNode *&Node);
+ bool parseDIExpression(MDNode *&Node);
bool parseMetadataOperand(MachineOperand &Dest);
bool parseCFIOffset(int &Offset);
bool parseCFIRegister(unsigned &Reg);
+ bool parseCFIEscapeValues(std::string& Values);
bool parseCFIOperand(MachineOperand &Dest);
bool parseIRBlock(BasicBlock *&BB, const Function &F);
bool parseBlockAddressOperand(MachineOperand &Dest);
@@ -429,7 +431,7 @@ bool MIParser::parseBasicBlockDefinition(
break;
case MIToken::IRBlock:
// TODO: Report an error when both name and ir block are specified.
- if (parseIRBlock(BB, *MF.getFunction()))
+ if (parseIRBlock(BB, MF.getFunction()))
return true;
lex();
break;
@@ -445,7 +447,7 @@ bool MIParser::parseBasicBlockDefinition(
if (!Name.empty()) {
BB = dyn_cast_or_null<BasicBlock>(
- MF.getFunction()->getValueSymbolTable()->lookup(Name));
+ MF.getFunction().getValueSymbolTable()->lookup(Name));
if (!BB)
return error(Loc, Twine("basic block '") + Name +
"' is not defined in the function '" +
@@ -854,10 +856,14 @@ bool MIParser::parseStandaloneStackObject(int &FI) {
bool MIParser::parseStandaloneMDNode(MDNode *&Node) {
lex();
- if (Token.isNot(MIToken::exclaim))
+ if (Token.is(MIToken::exclaim)) {
+ if (parseMDNode(Node))
+ return true;
+ } else if (Token.is(MIToken::md_diexpr)) {
+ if (parseDIExpression(Node))
+ return true;
+ } else
return error("expected a metadata node");
- if (parseMDNode(Node))
- return true;
if (Token.isNot(MIToken::Eof))
return error("expected end of string after the metadata node");
return false;
@@ -1054,6 +1060,9 @@ bool MIParser::parseRegisterFlag(unsigned &Flags) {
case MIToken::kw_debug_use:
Flags |= RegState::Debug;
break;
+ case MIToken::kw_renamable:
+ Flags |= RegState::Renamable;
+ break;
default:
llvm_unreachable("The current token should be a register flag");
}
@@ -1206,7 +1215,8 @@ bool MIParser::parseRegisterOperand(MachineOperand &Dest,
Reg, Flags & RegState::Define, Flags & RegState::Implicit,
Flags & RegState::Kill, Flags & RegState::Dead, Flags & RegState::Undef,
Flags & RegState::EarlyClobber, SubReg, Flags & RegState::Debug,
- Flags & RegState::InternalRead);
+ Flags & RegState::InternalRead, Flags & RegState::Renamable);
+
return false;
}
@@ -1224,7 +1234,7 @@ bool MIParser::parseIRConstant(StringRef::iterator Loc, StringRef StringValue,
const Constant *&C) {
auto Source = StringValue.str(); // The source has to be null terminated.
SMDiagnostic Err;
- C = parseConstantValue(Source, Err, *MF.getFunction()->getParent(),
+ C = parseConstantValue(Source, Err, *MF.getFunction().getParent(),
&PFS.IRSlots);
if (!C)
return error(Loc + Err.getColumnNo(), Err.getMessage());
@@ -1244,7 +1254,7 @@ bool MIParser::parseLowLevelType(StringRef::iterator Loc, LLT &Ty) {
lex();
return false;
} else if (Token.is(MIToken::PointerType)) {
- const DataLayout &DL = MF.getFunction()->getParent()->getDataLayout();
+ const DataLayout &DL = MF.getDataLayout();
unsigned AS = APSInt(Token.range().drop_front()).getZExtValue();
Ty = LLT::pointer(AS, DL.getPointerSizeInBits(AS));
lex();
@@ -1338,6 +1348,8 @@ bool MIParser::parseMBBReference(MachineBasicBlock *&MBB) {
return error(Twine("use of undefined machine basic block #") +
Twine(Number));
MBB = MBBInfo->second;
+ // TODO: Only parse the name if it's a MachineBasicBlockLabel. Deprecate once
+ // we drop the <irname> from the bb.<id>.<irname> format.
if (!Token.stringValue().empty() && Token.stringValue() != MBB->getName())
return error(Twine("the name of machine basic block #") + Twine(Number) +
" isn't '" + Token.stringValue() + "'");
@@ -1407,7 +1419,7 @@ bool MIParser::parseFixedStackObjectOperand(MachineOperand &Dest) {
bool MIParser::parseGlobalValue(GlobalValue *&GV) {
switch (Token.kind()) {
case MIToken::NamedGlobalValue: {
- const Module *M = MF.getFunction()->getParent();
+ const Module *M = MF.getFunction().getParent();
GV = M->getNamedValue(Token.stringValue());
if (!GV)
return error(Twine("use of undefined global value '") + Token.range() +
@@ -1492,6 +1504,7 @@ bool MIParser::parseSubRegisterIndexOperand(MachineOperand &Dest) {
bool MIParser::parseMDNode(MDNode *&Node) {
assert(Token.is(MIToken::exclaim));
+
auto Loc = Token.location();
lex();
if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
@@ -1507,10 +1520,56 @@ bool MIParser::parseMDNode(MDNode *&Node) {
return false;
}
+bool MIParser::parseDIExpression(MDNode *&Expr) {
+ assert(Token.is(MIToken::md_diexpr));
+ lex();
+
+ // FIXME: Share this parsing with the IL parser.
+ SmallVector<uint64_t, 8> Elements;
+
+ if (expectAndConsume(MIToken::lparen))
+ return true;
+
+ if (Token.isNot(MIToken::rparen)) {
+ do {
+ if (Token.is(MIToken::Identifier)) {
+ if (unsigned Op = dwarf::getOperationEncoding(Token.stringValue())) {
+ lex();
+ Elements.push_back(Op);
+ continue;
+ }
+ return error(Twine("invalid DWARF op '") + Token.stringValue() + "'");
+ }
+
+ if (Token.isNot(MIToken::IntegerLiteral) ||
+ Token.integerValue().isSigned())
+ return error("expected unsigned integer");
+
+ auto &U = Token.integerValue();
+ if (U.ugt(UINT64_MAX))
+ return error("element too large, limit is " + Twine(UINT64_MAX));
+ Elements.push_back(U.getZExtValue());
+ lex();
+
+ } while (consumeIfPresent(MIToken::comma));
+ }
+
+ if (expectAndConsume(MIToken::rparen))
+ return true;
+
+ Expr = DIExpression::get(MF.getFunction().getContext(), Elements);
+ return false;
+}
+
bool MIParser::parseMetadataOperand(MachineOperand &Dest) {
MDNode *Node = nullptr;
- if (parseMDNode(Node))
- return true;
+ if (Token.is(MIToken::exclaim)) {
+ if (parseMDNode(Node))
+ return true;
+ } else if (Token.is(MIToken::md_diexpr)) {
+ if (parseDIExpression(Node))
+ return true;
+ }
Dest = MachineOperand::CreateMetadata(Node);
return false;
}
@@ -1541,6 +1600,21 @@ bool MIParser::parseCFIRegister(unsigned &Reg) {
return false;
}
+bool MIParser::parseCFIEscapeValues(std::string &Values) {
+ do {
+ if (Token.isNot(MIToken::HexLiteral))
+ return error("expected a hexadecimal literal");
+ unsigned Value;
+ if (getUnsigned(Value))
+ return true;
+ if (Value > UINT8_MAX)
+ return error("expected a 8-bit integer (too large)");
+ Values.push_back(static_cast<uint8_t>(Value));
+ lex();
+ } while (consumeIfPresent(MIToken::comma));
+ return false;
+}
+
bool MIParser::parseCFIOperand(MachineOperand &Dest) {
auto Kind = Token.kind();
lex();
@@ -1560,6 +1634,13 @@ bool MIParser::parseCFIOperand(MachineOperand &Dest) {
CFIIndex =
MF.addFrameInst(MCCFIInstruction::createOffset(nullptr, Reg, Offset));
break;
+ case MIToken::kw_cfi_rel_offset:
+ if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
+ parseCFIOffset(Offset))
+ return true;
+ CFIIndex = MF.addFrameInst(
+ MCCFIInstruction::createRelOffset(nullptr, Reg, Offset));
+ break;
case MIToken::kw_cfi_def_cfa_register:
if (parseCFIRegister(Reg))
return true;
@@ -1573,6 +1654,12 @@ bool MIParser::parseCFIOperand(MachineOperand &Dest) {
CFIIndex = MF.addFrameInst(
MCCFIInstruction::createDefCfaOffset(nullptr, -Offset));
break;
+ case MIToken::kw_cfi_adjust_cfa_offset:
+ if (parseCFIOffset(Offset))
+ return true;
+ CFIIndex = MF.addFrameInst(
+ MCCFIInstruction::createAdjustCfaOffset(nullptr, Offset));
+ break;
case MIToken::kw_cfi_def_cfa:
if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
parseCFIOffset(Offset))
@@ -1581,6 +1668,42 @@ bool MIParser::parseCFIOperand(MachineOperand &Dest) {
CFIIndex =
MF.addFrameInst(MCCFIInstruction::createDefCfa(nullptr, Reg, -Offset));
break;
+ case MIToken::kw_cfi_remember_state:
+ CFIIndex = MF.addFrameInst(MCCFIInstruction::createRememberState(nullptr));
+ break;
+ case MIToken::kw_cfi_restore:
+ if (parseCFIRegister(Reg))
+ return true;
+ CFIIndex = MF.addFrameInst(MCCFIInstruction::createRestore(nullptr, Reg));
+ break;
+ case MIToken::kw_cfi_restore_state:
+ CFIIndex = MF.addFrameInst(MCCFIInstruction::createRestoreState(nullptr));
+ break;
+ case MIToken::kw_cfi_undefined:
+ if (parseCFIRegister(Reg))
+ return true;
+ CFIIndex = MF.addFrameInst(MCCFIInstruction::createUndefined(nullptr, Reg));
+ break;
+ case MIToken::kw_cfi_register: {
+ unsigned Reg2;
+ if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
+ parseCFIRegister(Reg2))
+ return true;
+
+ CFIIndex =
+ MF.addFrameInst(MCCFIInstruction::createRegister(nullptr, Reg, Reg2));
+ break;
+ }
+ case MIToken::kw_cfi_window_save:
+ CFIIndex = MF.addFrameInst(MCCFIInstruction::createWindowSave(nullptr));
+ break;
+ case MIToken::kw_cfi_escape: {
+ std::string Values;
+ if (parseCFIEscapeValues(Values))
+ return true;
+ CFIIndex = MF.addFrameInst(MCCFIInstruction::createEscape(nullptr, Values));
+ break;
+ }
default:
// TODO: Parse the other CFI operands.
llvm_unreachable("The current token should be a cfi operand");
@@ -1819,6 +1942,7 @@ bool MIParser::parseMachineOperand(MachineOperand &Dest,
case MIToken::kw_internal:
case MIToken::kw_early_clobber:
case MIToken::kw_debug_use:
+ case MIToken::kw_renamable:
case MIToken::underscore:
case MIToken::NamedRegister:
case MIToken::VirtualRegister:
@@ -1851,13 +1975,23 @@ bool MIParser::parseMachineOperand(MachineOperand &Dest,
return parseExternalSymbolOperand(Dest);
case MIToken::SubRegisterIndex:
return parseSubRegisterIndexOperand(Dest);
+ case MIToken::md_diexpr:
case MIToken::exclaim:
return parseMetadataOperand(Dest);
case MIToken::kw_cfi_same_value:
case MIToken::kw_cfi_offset:
+ case MIToken::kw_cfi_rel_offset:
case MIToken::kw_cfi_def_cfa_register:
case MIToken::kw_cfi_def_cfa_offset:
+ case MIToken::kw_cfi_adjust_cfa_offset:
+ case MIToken::kw_cfi_escape:
case MIToken::kw_cfi_def_cfa:
+ case MIToken::kw_cfi_register:
+ case MIToken::kw_cfi_remember_state:
+ case MIToken::kw_cfi_restore:
+ case MIToken::kw_cfi_restore_state:
+ case MIToken::kw_cfi_undefined:
+ case MIToken::kw_cfi_window_save:
return parseCFIOperand(Dest);
case MIToken::kw_blockaddress:
return parseBlockAddressOperand(Dest);
@@ -1968,7 +2102,7 @@ bool MIParser::parseOperandsOffset(MachineOperand &Op) {
bool MIParser::parseIRValue(const Value *&V) {
switch (Token.kind()) {
case MIToken::NamedIRValue: {
- V = MF.getFunction()->getValueSymbolTable()->lookup(Token.stringValue());
+ V = MF.getFunction().getValueSymbolTable()->lookup(Token.stringValue());
break;
}
case MIToken::IRValue: {
@@ -2029,8 +2163,11 @@ bool MIParser::getHexUint(APInt &Result) {
return true;
StringRef V = S.substr(2);
APInt A(V.size()*4, V, 16);
- Result = APInt(A.getActiveBits(),
- ArrayRef<uint64_t>(A.getRawData(), A.getNumWords()));
+
+ // If A is 0, then A.getActiveBits() is 0. This isn't a valid bitwidth. Make
+ // sure it isn't the case before constructing result.
+ unsigned NumBits = (A == 0) ? 32 : A.getActiveBits();
+ Result = APInt(NumBits, ArrayRef<uint64_t>(A.getRawData(), A.getNumWords()));
return false;
}
@@ -2216,9 +2353,15 @@ bool MIParser::parseMachineMemoryOperand(MachineMemOperand *&Dest) {
Flags |= MachineMemOperand::MOStore;
lex();
+ // Optional 'store' for operands that both load and store.
+ if (Token.is(MIToken::Identifier) && Token.stringValue() == "store") {
+ Flags |= MachineMemOperand::MOStore;
+ lex();
+ }
+
// Optional synchronization scope.
SyncScope::ID SSID;
- if (parseOptionalScope(MF.getFunction()->getContext(), SSID))
+ if (parseOptionalScope(MF.getFunction().getContext(), SSID))
return true;
// Up to two atomic orderings (cmpxchg provides guarantees on failure).
@@ -2238,7 +2381,11 @@ bool MIParser::parseMachineMemoryOperand(MachineMemOperand *&Dest) {
MachinePointerInfo Ptr = MachinePointerInfo();
if (Token.is(MIToken::Identifier)) {
- const char *Word = Flags & MachineMemOperand::MOLoad ? "from" : "into";
+ const char *Word =
+ ((Flags & MachineMemOperand::MOLoad) &&
+ (Flags & MachineMemOperand::MOStore))
+ ? "on"
+ : Flags & MachineMemOperand::MOLoad ? "from" : "into";
if (Token.stringValue() != Word)
return error(Twine("expected '") + Word + "'");
lex();
@@ -2395,12 +2542,12 @@ static const BasicBlock *getIRBlockFromSlot(
const BasicBlock *MIParser::getIRBlock(unsigned Slot) {
if (Slots2BasicBlocks.empty())
- initSlots2BasicBlocks(*MF.getFunction(), Slots2BasicBlocks);
+ initSlots2BasicBlocks(MF.getFunction(), Slots2BasicBlocks);
return getIRBlockFromSlot(Slot, Slots2BasicBlocks);
}
const BasicBlock *MIParser::getIRBlock(unsigned Slot, const Function &F) {
- if (&F == MF.getFunction())
+ if (&F == &MF.getFunction())
return getIRBlock(Slot);
DenseMap<unsigned, const BasicBlock *> CustomSlots2BasicBlocks;
initSlots2BasicBlocks(F, CustomSlots2BasicBlocks);
@@ -2431,7 +2578,7 @@ static void initSlots2Values(const Function &F,
const Value *MIParser::getIRValue(unsigned Slot) {
if (Slots2Values.empty())
- initSlots2Values(*MF.getFunction(), Slots2Values);
+ initSlots2Values(MF.getFunction(), Slots2Values);
auto ValueInfo = Slots2Values.find(Slot);
if (ValueInfo == Slots2Values.end())
return nullptr;
generated by cgit v1.2.3 (git 2.25.1) at 2024-10-27 20:19:11 +0000