StringMap<unsigned> Names2SubRegIndices;
/// Maps from slot numbers to function's unnamed basic blocks.
DenseMap<unsigned, const BasicBlock *> Slots2BasicBlocks;
+ /// Maps from slot numbers to function's unnamed values.
+ DenseMap<unsigned, const Value *> Slots2Values;
/// Maps from target index names to target indices.
StringMap<int> Names2TargetIndices;
/// Maps from direct target flag names to the direct target flag values.
const BasicBlock *getIRBlock(unsigned Slot);
const BasicBlock *getIRBlock(unsigned Slot, const Function &F);
+ const Value *getIRValue(unsigned Slot);
+
void initNames2TargetIndices();
/// Try to convert a name of target index to the corresponding target index.
if (!V)
V = MF.getFunction()->getParent()->getValueSymbolTable().lookup(
Token.stringValue());
- if (!V)
- return error(Twine("use of undefined IR value '") + Token.range() + "'");
break;
}
- // TODO: Parse unnamed IR value references.
+ case MIToken::IRValue: {
+ unsigned SlotNumber = 0;
+ if (getUnsigned(SlotNumber))
+ return true;
+ V = getIRValue(SlotNumber);
+ break;
+ }
default:
llvm_unreachable("The current token should be an IR block reference");
}
+ if (!V)
+ return error(Twine("use of undefined IR value '") + Token.range() + "'");
return false;
}
Dest = MachinePointerInfo(PSV, Offset);
return false;
}
- if (Token.isNot(MIToken::NamedIRValue))
+ if (Token.isNot(MIToken::NamedIRValue) && Token.isNot(MIToken::IRValue))
return error("expected an IR value reference");
const Value *V = nullptr;
if (parseIRValue(V))
return getIRBlockFromSlot(Slot, CustomSlots2BasicBlocks);
}
+static void mapValueToSlot(const Value *V, ModuleSlotTracker &MST,
+ DenseMap<unsigned, const Value *> &Slots2Values) {
+ int Slot = MST.getLocalSlot(V);
+ if (Slot == -1)
+ return;
+ Slots2Values.insert(std::make_pair(unsigned(Slot), V));
+}
+
+/// Creates the mapping from slot numbers to function's unnamed IR values.
+static void initSlots2Values(const Function &F,
+ DenseMap<unsigned, const Value *> &Slots2Values) {
+ ModuleSlotTracker MST(F.getParent(), /*ShouldInitializeAllMetadata=*/false);
+ MST.incorporateFunction(F);
+ for (const auto &Arg : F.args())
+ mapValueToSlot(&Arg, MST, Slots2Values);
+ for (const auto &BB : F) {
+ mapValueToSlot(&BB, MST, Slots2Values);
+ for (const auto &I : BB)
+ mapValueToSlot(&I, MST, Slots2Values);
+ }
+}
+
+const Value *MIParser::getIRValue(unsigned Slot) {
+ if (Slots2Values.empty())
+ initSlots2Values(*MF.getFunction(), Slots2Values);
+ auto ValueInfo = Slots2Values.find(Slot);
+ if (ValueInfo == Slots2Values.end())
+ return nullptr;
+ return ValueInfo->second;
+}
+
void MIParser::initNames2TargetIndices() {
if (!Names2TargetIndices.empty())
return;
ret void
}
+ define void @test3(i32*) {
+ entry3:
+ %1 = alloca i32
+ %b = load i32, i32* %0
+ %c = add i32 %b, 1
+ store i32 %c, i32* %1
+ ret void
+ }
+
define i32 @volatile_inc(i32* %x) {
entry:
%0 = load volatile i32, i32* %x
RETQ
...
---
+name: test3
+tracksRegLiveness: true
+liveins:
+ - { reg: '%rdi' }
+frameInfo:
+ maxAlignment: 4
+stack:
+ - { id: 0, offset: -12, size: 4, alignment: 4 }
+body: |
+ bb.0.entry3:
+ liveins: %rdi
+ ; Verify that the unnamed local values can be serialized.
+ ; CHECK-LABEL: name: test3
+ ; CHECK: %eax = MOV32rm killed %rdi, 1, _, 0, _ :: (load 4 from %ir.0)
+ ; CHECK: MOV32mr %rsp, 1, _, -4, _, killed %eax :: (store 4 into %ir.1)
+ %eax = MOV32rm killed %rdi, 1, _, 0, _ :: (load 4 from %ir.0)
+ %eax = INC32r killed %eax, implicit-def dead %eflags
+ MOV32mr %rsp, 1, _, -4, _, killed %eax :: (store 4 into %ir.1)
+ RETQ
+...
+---
name: volatile_inc
tracksRegLiveness: true
liveins: