#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Target/TargetRecip.h"
#include <map>
using namespace llvm;
static const char *const RecipOps[] = {
"divd",
"divf",
"vec-divd",
"vec-divf",
"sqrtd",
"sqrtf",
"vec-sqrtd",
"vec-sqrtf",
};
TargetRecip::TargetRecip() {
unsigned NumStrings = llvm::array_lengthof(RecipOps);
for (unsigned i = 0; i < NumStrings; ++i)
RecipMap.insert(std::make_pair(RecipOps[i], RecipParams()));
}
static bool parseRefinementStep(StringRef In, size_t &Position,
uint8_t &Value) {
const char RefStepToken = ':';
Position = In.find(RefStepToken);
if (Position == StringRef::npos)
return false;
StringRef RefStepString = In.substr(Position + 1);
if (RefStepString.size() == 1) {
char RefStepChar = RefStepString[0];
if (RefStepChar >= '0' && RefStepChar <= '9') {
Value = RefStepChar - '0';
return true;
}
}
report_fatal_error("Invalid refinement step for -recip.");
}
bool TargetRecip::parseGlobalParams(const std::string &Arg) {
StringRef ArgSub = Arg;
size_t RefPos;
uint8_t RefSteps;
StringRef RefStepString;
if (parseRefinementStep(ArgSub, RefPos, RefSteps)) {
RefStepString = ArgSub.substr(RefPos + 1);
ArgSub = ArgSub.substr(0, RefPos);
}
bool Enable;
bool UseDefaults;
if (ArgSub == "all") {
UseDefaults = false;
Enable = true;
} else if (ArgSub == "none") {
UseDefaults = false;
Enable = false;
} else if (ArgSub == "default") {
UseDefaults = true;
} else {
return false;
}
if (!UseDefaults)
for (auto &KV : RecipMap)
KV.second.Enabled = Enable;
if (!RefStepString.empty())
for (auto &KV : RecipMap)
KV.second.RefinementSteps = RefSteps;
return true;
}
void TargetRecip::parseIndividualParams(const std::vector<std::string> &Args) {
static const char DisabledPrefix = '!';
unsigned NumArgs = Args.size();
for (unsigned i = 0; i != NumArgs; ++i) {
StringRef Val = Args[i];
bool IsDisabled = Val[0] == DisabledPrefix;
if (IsDisabled)
Val = Val.substr(1);
size_t RefPos;
uint8_t RefSteps;
StringRef RefStepString;
if (parseRefinementStep(Val, RefPos, RefSteps)) {
RefStepString = Val.substr(RefPos + 1);
Val = Val.substr(0, RefPos);
}
RecipIter Iter = RecipMap.find(Val);
if (Iter == RecipMap.end()) {
Iter = RecipMap.find(Val.str() + 'f');
if (Iter == RecipMap.end()) {
Iter = RecipMap.find(Val.str() + 'd');
assert(Iter == RecipMap.end() && "Float entry missing from map");
report_fatal_error("Invalid option for -recip.");
}
if (RecipMap[Val.str() + 'd'].Enabled != Uninitialized) {
report_fatal_error("Duplicate option for -recip.");
}
}
if (Iter->second.Enabled != Uninitialized)
report_fatal_error("Duplicate option for -recip.");
Iter->second.Enabled = !IsDisabled;
if (!RefStepString.empty())
Iter->second.RefinementSteps = RefSteps;
if (Val.back() != 'f' && Val.back() != 'd') {
RecipMap[Val.str() + 'd'].Enabled = !IsDisabled;
if (!RefStepString.empty())
RecipMap[Val.str() + 'd'].RefinementSteps = RefSteps;
}
}
}
TargetRecip::TargetRecip(const std::vector<std::string> &Args) :
TargetRecip() {
unsigned NumArgs = Args.size();
if (NumArgs == 1 && parseGlobalParams(Args[0]))
return;
parseIndividualParams(Args);
}
bool TargetRecip::isEnabled(StringRef Key) const {
ConstRecipIter Iter = RecipMap.find(Key);
assert(Iter != RecipMap.end() && "Unknown name for reciprocal map");
assert(Iter->second.Enabled != Uninitialized &&
"Enablement setting was not initialized");
return Iter->second.Enabled;
}
unsigned TargetRecip::getRefinementSteps(StringRef Key) const {
ConstRecipIter Iter = RecipMap.find(Key);
assert(Iter != RecipMap.end() && "Unknown name for reciprocal map");
assert(Iter->second.RefinementSteps != Uninitialized &&
"Refinement step setting was not initialized");
return Iter->second.RefinementSteps;
}
void TargetRecip::setDefaults(StringRef Key, bool Enable,
unsigned RefSteps) {
if (Key == "all") {
for (auto &KV : RecipMap) {
RecipParams &RP = KV.second;
if (RP.Enabled == Uninitialized)
RP.Enabled = Enable;
if (RP.RefinementSteps == Uninitialized)
RP.RefinementSteps = RefSteps;
}
} else {
RecipParams &RP = RecipMap[Key];
if (RP.Enabled == Uninitialized)
RP.Enabled = Enable;
if (RP.RefinementSteps == Uninitialized)
RP.RefinementSteps = RefSteps;
}
}
bool TargetRecip::operator==(const TargetRecip &Other) const {
for (const auto &KV : RecipMap) {
StringRef Op = KV.first;
const RecipParams &RP = KV.second;
const RecipParams &OtherRP = Other.RecipMap.find(Op)->second;
if (RP.RefinementSteps != OtherRP.RefinementSteps)
return false;
if (RP.Enabled != OtherRP.Enabled)
return false;
}
return true;
}