}
}
-unsigned CodeGenSubRegIndex::computeLaneMask() {
+unsigned CodeGenSubRegIndex::computeLaneMask() const {
// Already computed?
if (LaneMask)
return LaneMask;
// The lane mask is simply the union of all sub-indices.
unsigned M = 0;
- for (CompMap::iterator I = Composed.begin(), E = Composed.end(); I != E; ++I)
- M |= I->second->computeLaneMask();
+ for (const auto &C : Composed)
+ M |= C.second->computeLaneMask();
assert(M && "Missing lane mask, sub-register cycle?");
LaneMask = M;
return LaneMask;
RegClasses[rci]->inheritProperties(RegBank);
}
-void
-CodeGenRegisterClass::getSuperRegClasses(CodeGenSubRegIndex *SubIdx,
- BitVector &Out) const {
- DenseMap<CodeGenSubRegIndex*,
- SmallPtrSet<CodeGenRegisterClass*, 8> >::const_iterator
- FindI = SuperRegClasses.find(SubIdx);
+void CodeGenRegisterClass::getSuperRegClasses(const CodeGenSubRegIndex *SubIdx,
+ BitVector &Out) const {
+ auto FindI = SuperRegClasses.find(SubIdx);
if (FindI == SuperRegClasses.end())
return;
for (CodeGenRegisterClass *RC : FindI->second)
for (unsigned i = 0, e = SRIs.size(); i != e; ++i)
getSubRegIdx(SRIs[i]);
// Build composite maps from ComposedOf fields.
- for (unsigned i = 0, e = SubRegIndices.size(); i != e; ++i)
- SubRegIndices[i]->updateComponents(*this);
+ for (auto &Idx : SubRegIndices)
+ Idx->updateComponents(*this);
// Read in the register definitions.
std::vector<Record*> Regs = Records.getAllDerivedDefinitions("Register");
}
CodeGenRegBank::~CodeGenRegBank() {
- DeleteContainerPointers(SubRegIndices);
DeleteContainerPointers(Registers);
DeleteContainerPointers(RegClasses);
}
// Create a synthetic CodeGenSubRegIndex without a corresponding Record.
CodeGenSubRegIndex*
CodeGenRegBank::createSubRegIndex(StringRef Name, StringRef Namespace) {
+ //auto SubRegIndicesSize = std::distance(SubRegIndices.begin(), SubRegIndices.end());
+ //SubRegIndices.emplace_front(Name, Namespace, SubRegIndicesSize + 1);
+ //return &SubRegIndices.front();
CodeGenSubRegIndex *Idx = new CodeGenSubRegIndex(Name, Namespace,
SubRegIndices.size() + 1);
SubRegIndices.push_back(Idx);
return Idx;
Idx = new CodeGenSubRegIndex(Def, SubRegIndices.size() + 1);
SubRegIndices.push_back(Idx);
+ //auto SubRegIndicesSize = std::distance(SubRegIndices.begin(), SubRegIndices.end());
+ //SubRegIndices.emplace_front(Def, SubRegIndicesSize + 1);
+ //Idx = &SubRegIndices.front();
return Idx;
}
unsigned Bit = 0;
// Determine mask of lanes that cover their registers.
CoveringLanes = ~0u;
- for (unsigned i = 0, e = SubRegIndices.size(); i != e; ++i) {
- CodeGenSubRegIndex *Idx = SubRegIndices[i];
+ for (auto &Idx : SubRegIndices) {
if (Idx->getComposites().empty()) {
Idx->LaneMask = 1u << Bit;
// Share bit 31 in the unlikely case there are more than 32 leafs.
// by the sub-register graph? This doesn't occur in any known targets.
// Inherit lanes from composites.
- for (unsigned i = 0, e = SubRegIndices.size(); i != e; ++i) {
- unsigned Mask = SubRegIndices[i]->computeLaneMask();
+ for (const auto &Idx : SubRegIndices) {
+ unsigned Mask = Idx->computeLaneMask();
// If some super-registers without CoveredBySubRegs use this index, we can
// no longer assume that the lanes are covering their registers.
- if (!SubRegIndices[i]->AllSuperRegsCovered)
+ if (!Idx->AllSuperRegsCovered)
CoveringLanes &= ~Mask;
}
}
//
void CodeGenRegBank::inferSubClassWithSubReg(CodeGenRegisterClass *RC) {
// Map SubRegIndex to set of registers in RC supporting that SubRegIndex.
- typedef std::map<CodeGenSubRegIndex*, CodeGenRegister::Set,
+ typedef std::map<const CodeGenSubRegIndex *, CodeGenRegister::Set,
CodeGenSubRegIndex::Less> SubReg2SetMap;
// Compute the set of registers supporting each SubRegIndex.
// Find matching classes for all SRSets entries. Iterate in SubRegIndex
// numerical order to visit synthetic indices last.
- for (unsigned sri = 0, sre = SubRegIndices.size(); sri != sre; ++sri) {
- CodeGenSubRegIndex *SubIdx = SubRegIndices[sri];
+ for (const auto &SubIdx : SubRegIndices) {
SubReg2SetMap::const_iterator I = SRSets.find(SubIdx);
// Unsupported SubRegIndex. Skip it.
if (I == SRSets.end())
BitVector TopoSigs(getNumTopoSigs());
// Iterate in SubRegIndex numerical order to visit synthetic indices last.
- for (unsigned sri = 0, sre = SubRegIndices.size(); sri != sre; ++sri) {
- CodeGenSubRegIndex *SubIdx = SubRegIndices[sri];
+ for (auto &SubIdx : SubRegIndices) {
// Skip indexes that aren't fully supported by RC's registers. This was
// computed by inferSubClassWithSubReg() above which should have been
// called first.