if (PhysRegInfo[Reg]) {
PhysRegInfo[Reg] = MI;
PhysRegUsed[Reg] = true;
- } else if (const unsigned *AliasSet = RegInfo->getAliasSet(Reg)) {
- for (; unsigned NReg = AliasSet[0]; ++AliasSet)
- if (MachineInstr *LastUse = PhysRegInfo[NReg]) {
- PhysRegInfo[NReg] = MI;
- PhysRegUsed[NReg] = true;
+ } else {
+ for (const unsigned *AliasSet = RegInfo->getAliasSet(Reg);
+ *AliasSet; ++AliasSet) {
+ if (MachineInstr *LastUse = PhysRegInfo[*AliasSet]) {
+ PhysRegInfo[*AliasSet] = MI;
+ PhysRegUsed[*AliasSet] = true;
}
+ }
}
}
RegistersKilled.insert(std::make_pair(LastUse, Reg));
else
RegistersDead.insert(std::make_pair(LastUse, Reg));
- } else if (const unsigned *AliasSet = RegInfo->getAliasSet(Reg)) {
- for (; unsigned NReg = AliasSet[0]; ++AliasSet)
- if (MachineInstr *LastUse = PhysRegInfo[NReg]) {
- if (PhysRegUsed[NReg])
- RegistersKilled.insert(std::make_pair(LastUse, NReg));
+ } else {
+ for (const unsigned *AliasSet = RegInfo->getAliasSet(Reg);
+ *AliasSet; ++AliasSet) {
+ if (MachineInstr *LastUse = PhysRegInfo[*AliasSet]) {
+ if (PhysRegUsed[*AliasSet])
+ RegistersKilled.insert(std::make_pair(LastUse, *AliasSet));
else
- RegistersDead.insert(std::make_pair(LastUse, NReg));
- PhysRegInfo[NReg] = 0; // Kill the aliased register
+ RegistersDead.insert(std::make_pair(LastUse, *AliasSet));
+ PhysRegInfo[*AliasSet] = 0; // Kill the aliased register
}
+ }
}
PhysRegInfo[Reg] = MI;
PhysRegUsed[Reg] = false;
NumOperandsToProcess = 1;
// Loop over implicit uses, using them.
- if (const unsigned *ImplicitUses = MID.ImplicitUses)
- for (unsigned i = 0; ImplicitUses[i]; ++i)
- HandlePhysRegUse(ImplicitUses[i], MI);
+ for (const unsigned *ImplicitUses = MID.ImplicitUses;
+ *ImplicitUses; ++ImplicitUses)
+ HandlePhysRegUse(*ImplicitUses, MI);
// Process all explicit uses...
for (unsigned i = 0; i != NumOperandsToProcess; ++i) {
unsigned Reg = CSRegs[i];
if (ModifiedRegs[Reg]) {
RegsToSave.push_back(Reg); // If modified register...
- } else if (const unsigned *AliasSet = RegInfo->getAliasSet(Reg))
- for (unsigned j = 0; AliasSet[j]; ++j) // Check alias registers too...
- if (ModifiedRegs[AliasSet[j]]) {
+ } else {
+ for (const unsigned *AliasSet = RegInfo->getAliasSet(Reg);
+ *AliasSet; ++AliasSet) { // Check alias registers too...
+ if (ModifiedRegs[*AliasSet]) {
RegsToSave.push_back(Reg);
break;
}
+ }
+ }
}
if (RegsToSave.empty())
///
bool areRegsEqual(unsigned R1, unsigned R2) const {
if (R1 == R2) return true;
- if (const unsigned *AliasSet = RegInfo->getAliasSet(R2))
- for (unsigned i = 0; AliasSet[i]; ++i)
- if (AliasSet[i] == R1) return true;
+ for (const unsigned *AliasSet = RegInfo->getAliasSet(R2);
+ *AliasSet; ++AliasSet) {
+ if (*AliasSet == R1) return true;
+ }
return false;
}
if (PI != PhysRegsUsed.end()) { // Only spill it if it's used!
if (PI->second || !OnlyVirtRegs)
spillVirtReg(MBB, I, PI->second, PhysReg);
- } else if (const unsigned *AliasSet = RegInfo->getAliasSet(PhysReg)) {
+ } else {
// If the selected register aliases any other registers, we must make
// sure that one of the aliases isn't alive...
- for (unsigned i = 0; AliasSet[i]; ++i) {
- PI = PhysRegsUsed.find(AliasSet[i]);
+ for (const unsigned *AliasSet = RegInfo->getAliasSet(PhysReg);
+ *AliasSet; ++AliasSet) {
+ PI = PhysRegsUsed.find(*AliasSet);
if (PI != PhysRegsUsed.end()) // Spill aliased register...
if (PI->second || !OnlyVirtRegs)
- spillVirtReg(MBB, I, PI->second, AliasSet[i]);
+ spillVirtReg(MBB, I, PI->second, *AliasSet);
}
}
}
// If the selected register aliases any other allocated registers, it is
// not free!
- if (const unsigned *AliasSet = RegInfo->getAliasSet(PhysReg))
- for (unsigned i = 0; AliasSet[i]; ++i)
- if (PhysRegsUsed.count(AliasSet[i])) // Aliased register in use?
- return false; // Can't use this reg then.
+ for (const unsigned *AliasSet = RegInfo->getAliasSet(PhysReg);
+ *AliasSet; ++AliasSet)
+ if (PhysRegsUsed.count(*AliasSet)) // Aliased register in use?
+ return false; // Can't use this reg then.
return true;
}
} else {
// If one of the registers aliased to the current register is
// compatible, use it.
- if (const unsigned *AliasSet = RegInfo->getAliasSet(R))
- for (unsigned a = 0; AliasSet[a]; ++a)
- if (RegInfo->getRegClass(AliasSet[a]) == RC) {
- PhysReg = AliasSet[a]; // Take an aliased register
- break;
- }
+ for (const unsigned *AliasSet = RegInfo->getAliasSet(R);
+ *AliasSet; ++AliasSet) {
+ if (RegInfo->getRegClass(*AliasSet) == RC) {
+ PhysReg = *AliasSet; // Take an aliased register
+ break;
+ }
+ }
}
}
}
// Loop over the implicit uses, making sure that they are at the head of the
// use order list, so they don't get reallocated.
- if (const unsigned *ImplicitUses = TID.ImplicitUses)
- for (unsigned i = 0; ImplicitUses[i]; ++i)
- MarkPhysRegRecentlyUsed(ImplicitUses[i]);
+ for (const unsigned *ImplicitUses = TID.ImplicitUses;
+ *ImplicitUses; ++ImplicitUses)
+ MarkPhysRegRecentlyUsed(*ImplicitUses);
// Get the used operands into registers. This has the potential to spill
// incoming values if we are out of registers. Note that we completely
// are used by the instruction (including implicit uses)
unsigned Opcode = MI->getOpcode();
const TargetInstrDescriptor &Desc = TM->getInstrInfo().get(Opcode);
- if (const unsigned *Regs = Desc.ImplicitUses)
- while (*Regs)
- RegsUsed[*Regs++] = true;
+ const unsigned *Regs = Desc.ImplicitUses;
+ while (*Regs)
+ RegsUsed[*Regs++] = true;
- if (const unsigned *Regs = Desc.ImplicitDefs)
- while (*Regs)
- RegsUsed[*Regs++] = true;
+ Regs = Desc.ImplicitDefs;
+ while (*Regs)
+ RegsUsed[*Regs++] = true;
// Loop over uses, move from memory into registers
for (int i = MI->getNumOperands() - 1; i >= 0; --i) {
std::vector<Record*> Instructions =
Records.getAllDerivedDefinitions("Instruction");
+ // Emit empty implicit uses and defs lists
+ OS << "static const unsigned EmptyImpUses[] = { 0 };\n"
+ << "static const unsigned EmptyImpDefs[] = { 0 };\n";
+
// Emit all of the instruction's implicit uses and defs...
for (unsigned i = 0, e = Instructions.size(); i != e; ++i) {
Record *Inst = Instructions[i];
// Emit the implicit uses and defs lists...
LI = R->getValueAsListInit("Uses");
if (!LI->getSize())
- OS << "0, ";
+ OS << "EmptyImpUses, ";
else
OS << R->getName() << "ImpUses, ";
LI = R->getValueAsListInit("Defs");
if (!LI->getSize())
- OS << "0 ";
+ OS << "EmptyImpDefs ";
else
OS << R->getName() << "ImpDefs ";
std::vector<Record*> RegisterAliasesRecs =
Records.getAllDerivedDefinitions("RegisterAliases");
std::map<Record*, std::set<Record*> > RegisterAliases;
-
+
for (unsigned i = 0, e = RegisterAliasesRecs.size(); i != e; ++i) {
Record *AS = RegisterAliasesRecs[i];
Record *R = AS->getValueAsDef("Reg");
if (!RegisterAliases.empty())
OS << "\n\n // Register Alias Sets...\n";
+ // Emit the empty alias list
+ OS << " const unsigned Empty_AliasSet[] = { 0 };\n";
// Loop over all of the registers which have aliases, emitting the alias list
// to memory.
for (std::map<Record*, std::set<Record*> >::iterator
if (RegisterAliases.count(Reg))
OS << Reg->getName() << "_AliasSet,\t";
else
- OS << "0,\t\t";
+ OS << "Empty_AliasSet,\t";
OS << "0, 0 },\n";
}
OS << " };\n"; // End of register descriptors...