mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-13 04:30:23 +00:00
Don't pass StringRef by reference.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@108366 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
d26e89dfcb
commit
38e59891ee
@ -457,8 +457,8 @@ StringMap class which is used extensively in LLVM and Clang.</p>
|
||||
may have embedded null characters. Therefore, they cannot simply take
|
||||
a <tt>const char *</tt>, and taking a <tt>const std::string&</tt> requires
|
||||
clients to perform a heap allocation which is usually unnecessary. Instead,
|
||||
many LLVM APIs use a <tt>const StringRef&</tt> or a <tt>const
|
||||
Twine&</tt> for passing strings efficiently.</p>
|
||||
many LLVM APIs use a <tt>StringRef</tt> or a <tt>const Twine&</tt> for
|
||||
passing strings efficiently.</p>
|
||||
|
||||
</div>
|
||||
|
||||
@ -477,19 +477,17 @@ on <tt>std:string</tt>, but does not require heap allocation.</p>
|
||||
an <tt>std::string</tt>, or explicitly with a character pointer and length.
|
||||
For example, the <tt>StringRef</tt> find function is declared as:</p>
|
||||
|
||||
<div class="doc_code">
|
||||
iterator find(const StringRef &Key);
|
||||
</div>
|
||||
<pre class="doc_code">
|
||||
iterator find(StringRef Key);
|
||||
</pre>
|
||||
|
||||
<p>and clients can call it using any one of:</p>
|
||||
|
||||
<div class="doc_code">
|
||||
<pre>
|
||||
<pre class="doc_code">
|
||||
Map.find("foo"); <i>// Lookup "foo"</i>
|
||||
Map.find(std::string("bar")); <i>// Lookup "bar"</i>
|
||||
Map.find(StringRef("\0baz", 4)); <i>// Lookup "\0baz"</i>
|
||||
</pre>
|
||||
</div>
|
||||
|
||||
<p>Similarly, APIs which need to return a string may return a <tt>StringRef</tt>
|
||||
instance, which can be used directly or converted to an <tt>std::string</tt>
|
||||
@ -499,7 +497,8 @@ for more information.</p>
|
||||
|
||||
<p>You should rarely use the <tt>StringRef</tt> class directly, because it contains
|
||||
pointers to external memory it is not generally safe to store an instance of the
|
||||
class (unless you know that the external storage will not be freed).</p>
|
||||
class (unless you know that the external storage will not be freed). StringRef is
|
||||
small and pervasive enough in LLVM that it should always be passed by value.</p>
|
||||
|
||||
</div>
|
||||
|
||||
|
@ -179,7 +179,7 @@ namespace llvm {
|
||||
|
||||
// Constructors.
|
||||
APFloat(const fltSemantics &); // Default construct to 0.0
|
||||
APFloat(const fltSemantics &, const StringRef &);
|
||||
APFloat(const fltSemantics &, StringRef);
|
||||
APFloat(const fltSemantics &, integerPart);
|
||||
APFloat(const fltSemantics &, fltCategory, bool negative);
|
||||
APFloat(const fltSemantics &, uninitializedTag);
|
||||
@ -282,7 +282,7 @@ namespace llvm {
|
||||
bool, roundingMode);
|
||||
opStatus convertFromZeroExtendedInteger(const integerPart *, unsigned int,
|
||||
bool, roundingMode);
|
||||
opStatus convertFromString(const StringRef&, roundingMode);
|
||||
opStatus convertFromString(StringRef, roundingMode);
|
||||
APInt bitcastToAPInt() const;
|
||||
double convertToDouble() const;
|
||||
float convertToFloat() const;
|
||||
@ -386,8 +386,8 @@ namespace llvm {
|
||||
roundingMode, bool *) const;
|
||||
opStatus convertFromUnsignedParts(const integerPart *, unsigned int,
|
||||
roundingMode);
|
||||
opStatus convertFromHexadecimalString(const StringRef&, roundingMode);
|
||||
opStatus convertFromDecimalString (const StringRef&, roundingMode);
|
||||
opStatus convertFromHexadecimalString(StringRef, roundingMode);
|
||||
opStatus convertFromDecimalString(StringRef, roundingMode);
|
||||
char *convertNormalToHexString(char *, unsigned int, bool,
|
||||
roundingMode) const;
|
||||
opStatus roundSignificandWithExponent(const integerPart *, unsigned int,
|
||||
|
@ -162,7 +162,7 @@ class APInt {
|
||||
///
|
||||
/// @param radix 2, 8, 10, or 16
|
||||
/// @brief Convert a char array into an APInt
|
||||
void fromString(unsigned numBits, const StringRef &str, uint8_t radix);
|
||||
void fromString(unsigned numBits, StringRef str, uint8_t radix);
|
||||
|
||||
/// This is used by the toString method to divide by the radix. It simply
|
||||
/// provides a more convenient form of divide for internal use since KnuthDiv
|
||||
@ -248,7 +248,7 @@ public:
|
||||
/// @param str the string to be interpreted
|
||||
/// @param radix the radix to use for the conversion
|
||||
/// @brief Construct an APInt from a string representation.
|
||||
APInt(unsigned numBits, const StringRef &str, uint8_t radix);
|
||||
APInt(unsigned numBits, StringRef str, uint8_t radix);
|
||||
|
||||
/// Simply makes *this a copy of that.
|
||||
/// @brief Copy Constructor.
|
||||
@ -1153,7 +1153,7 @@ public:
|
||||
/// This method determines how many bits are required to hold the APInt
|
||||
/// equivalent of the string given by \arg str.
|
||||
/// @brief Get bits required for string value.
|
||||
static unsigned getBitsNeeded(const StringRef& str, uint8_t radix);
|
||||
static unsigned getBitsNeeded(StringRef str, uint8_t radix);
|
||||
|
||||
/// countLeadingZeros - This function is an APInt version of the
|
||||
/// countLeadingZeros_{32,64} functions in MathExtras.h. It counts the number
|
||||
|
@ -107,7 +107,7 @@ private:
|
||||
|
||||
void EatToEndOfStatement();
|
||||
|
||||
bool ParseAssignment(const StringRef &Name);
|
||||
bool ParseAssignment(StringRef Name);
|
||||
|
||||
bool ParsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc);
|
||||
bool ParseBinOpRHS(unsigned Precedence, const MCExpr *&Res, SMLoc &EndLoc);
|
||||
|
@ -36,7 +36,7 @@ namespace llvm {
|
||||
/// Compiles the given POSIX Extended Regular Expression \arg Regex.
|
||||
/// This implementation supports regexes and matching strings with embedded
|
||||
/// NUL characters.
|
||||
Regex(const StringRef &Regex, unsigned Flags = NoFlags);
|
||||
Regex(StringRef Regex, unsigned Flags = NoFlags);
|
||||
~Regex();
|
||||
|
||||
/// isValid - returns the error encountered during regex compilation, or
|
||||
@ -55,7 +55,7 @@ namespace llvm {
|
||||
/// the first group is always the entire pattern.
|
||||
///
|
||||
/// This returns true on a successful match.
|
||||
bool match(const StringRef &String, SmallVectorImpl<StringRef> *Matches=0);
|
||||
bool match(StringRef String, SmallVectorImpl<StringRef> *Matches = 0);
|
||||
|
||||
/// sub - Return the result of replacing the first match of the regex in
|
||||
/// \arg String with the \arg Repl string. Backreferences like "\0" in the
|
||||
|
@ -64,7 +64,7 @@ namespace llvm {
|
||||
/// intern - Adds a string to the pool and returns a reference-counted
|
||||
/// pointer to it. No additional memory is allocated if the string already
|
||||
/// exists in the pool.
|
||||
PooledStringPtr intern(const StringRef &Str);
|
||||
PooledStringPtr intern(StringRef Str);
|
||||
|
||||
/// empty - Checks whether the pool is empty. Returns true if so.
|
||||
///
|
||||
|
@ -49,7 +49,7 @@ public:
|
||||
/// \param Operands [out] - The list of parsed operands, this returns
|
||||
/// ownership of them to the caller.
|
||||
/// \return True on failure.
|
||||
virtual bool ParseInstruction(const StringRef &Name, SMLoc NameLoc,
|
||||
virtual bool ParseInstruction(StringRef Name, SMLoc NameLoc,
|
||||
SmallVectorImpl<MCParsedAsmOperand*> &Operands) = 0;
|
||||
|
||||
/// ParseDirective - Parse a target specific assembler directive
|
||||
|
@ -712,7 +712,7 @@ bool AsmParser::ParseStatement() {
|
||||
return HadError;
|
||||
}
|
||||
|
||||
bool AsmParser::ParseAssignment(const StringRef &Name) {
|
||||
bool AsmParser::ParseAssignment(StringRef Name) {
|
||||
// FIXME: Use better location, we should use proper tokens.
|
||||
SMLoc EqualLoc = Lexer.getLoc();
|
||||
|
||||
|
@ -761,7 +761,7 @@ APFloat::APFloat(const fltSemantics &ourSemantics,
|
||||
makeNaN();
|
||||
}
|
||||
|
||||
APFloat::APFloat(const fltSemantics &ourSemantics, const StringRef& text)
|
||||
APFloat::APFloat(const fltSemantics &ourSemantics, StringRef text)
|
||||
{
|
||||
assertArithmeticOK(ourSemantics);
|
||||
initialize(&ourSemantics);
|
||||
@ -2185,8 +2185,7 @@ APFloat::convertFromZeroExtendedInteger(const integerPart *parts,
|
||||
}
|
||||
|
||||
APFloat::opStatus
|
||||
APFloat::convertFromHexadecimalString(const StringRef &s,
|
||||
roundingMode rounding_mode)
|
||||
APFloat::convertFromHexadecimalString(StringRef s, roundingMode rounding_mode)
|
||||
{
|
||||
lostFraction lost_fraction = lfExactlyZero;
|
||||
integerPart *significand;
|
||||
@ -2361,7 +2360,7 @@ APFloat::roundSignificandWithExponent(const integerPart *decSigParts,
|
||||
}
|
||||
|
||||
APFloat::opStatus
|
||||
APFloat::convertFromDecimalString(const StringRef &str, roundingMode rounding_mode)
|
||||
APFloat::convertFromDecimalString(StringRef str, roundingMode rounding_mode)
|
||||
{
|
||||
decimalInfo D;
|
||||
opStatus fs;
|
||||
@ -2471,7 +2470,7 @@ APFloat::convertFromDecimalString(const StringRef &str, roundingMode rounding_mo
|
||||
}
|
||||
|
||||
APFloat::opStatus
|
||||
APFloat::convertFromString(const StringRef &str, roundingMode rounding_mode)
|
||||
APFloat::convertFromString(StringRef str, roundingMode rounding_mode)
|
||||
{
|
||||
assertArithmeticOK(*semantics);
|
||||
assert(!str.empty() && "Invalid string length");
|
||||
|
@ -102,7 +102,7 @@ APInt::APInt(unsigned numBits, unsigned numWords, const uint64_t bigVal[])
|
||||
clearUnusedBits();
|
||||
}
|
||||
|
||||
APInt::APInt(unsigned numbits, const StringRef& Str, uint8_t radix)
|
||||
APInt::APInt(unsigned numbits, StringRef Str, uint8_t radix)
|
||||
: BitWidth(numbits), VAL(0) {
|
||||
assert(BitWidth && "Bitwidth too small");
|
||||
fromString(numbits, Str, radix);
|
||||
@ -613,7 +613,7 @@ APInt& APInt::flip(unsigned bitPosition) {
|
||||
return *this;
|
||||
}
|
||||
|
||||
unsigned APInt::getBitsNeeded(const StringRef& str, uint8_t radix) {
|
||||
unsigned APInt::getBitsNeeded(StringRef str, uint8_t radix) {
|
||||
assert(!str.empty() && "Invalid string length");
|
||||
assert((radix == 10 || radix == 8 || radix == 16 || radix == 2) &&
|
||||
"Radix should be 2, 8, 10, or 16!");
|
||||
@ -2046,7 +2046,7 @@ void APInt::udivrem(const APInt &LHS, const APInt &RHS,
|
||||
divide(LHS, lhsWords, RHS, rhsWords, &Quotient, &Remainder);
|
||||
}
|
||||
|
||||
void APInt::fromString(unsigned numbits, const StringRef& str, uint8_t radix) {
|
||||
void APInt::fromString(unsigned numbits, StringRef str, uint8_t radix) {
|
||||
// Check our assumptions here
|
||||
assert(!str.empty() && "Invalid string length");
|
||||
assert((radix == 10 || radix == 8 || radix == 16 || radix == 2) &&
|
||||
|
@ -19,7 +19,7 @@
|
||||
#include <string>
|
||||
using namespace llvm;
|
||||
|
||||
Regex::Regex(const StringRef ®ex, unsigned Flags) {
|
||||
Regex::Regex(StringRef regex, unsigned Flags) {
|
||||
unsigned flags = 0;
|
||||
preg = new llvm_regex();
|
||||
preg->re_endp = regex.end();
|
||||
@ -52,7 +52,7 @@ unsigned Regex::getNumMatches() const {
|
||||
return preg->re_nsub;
|
||||
}
|
||||
|
||||
bool Regex::match(const StringRef &String, SmallVectorImpl<StringRef> *Matches){
|
||||
bool Regex::match(StringRef String, SmallVectorImpl<StringRef> *Matches){
|
||||
unsigned nmatch = Matches ? preg->re_nsub+1 : 0;
|
||||
|
||||
// pmatch needs to have at least one element.
|
||||
|
@ -22,7 +22,7 @@ StringPool::~StringPool() {
|
||||
assert(InternTable.empty() && "PooledStringPtr leaked!");
|
||||
}
|
||||
|
||||
PooledStringPtr StringPool::intern(const StringRef &Key) {
|
||||
PooledStringPtr StringPool::intern(StringRef Key) {
|
||||
table_t::iterator I = InternTable.find(Key);
|
||||
if (I != InternTable.end())
|
||||
return PooledStringPtr(&*I);
|
||||
|
@ -88,7 +88,7 @@ private:
|
||||
/// its register number, or -1 if there is no match. To allow return values
|
||||
/// to be used directly in register lists, arm registers have values between
|
||||
/// 0 and 15.
|
||||
int MatchRegisterName(const StringRef &Name);
|
||||
int MatchRegisterName(StringRef Name);
|
||||
|
||||
/// }
|
||||
|
||||
@ -97,7 +97,7 @@ public:
|
||||
ARMAsmParser(const Target &T, MCAsmParser &_Parser)
|
||||
: TargetAsmParser(T), Parser(_Parser) {}
|
||||
|
||||
virtual bool ParseInstruction(const StringRef &Name, SMLoc NameLoc,
|
||||
virtual bool ParseInstruction(StringRef Name, SMLoc NameLoc,
|
||||
SmallVectorImpl<MCParsedAsmOperand*> &Operands);
|
||||
|
||||
virtual bool ParseDirective(AsmToken DirectiveID);
|
||||
@ -517,7 +517,7 @@ bool ARMAsmParser::ParseShift(ShiftType &St,
|
||||
const AsmToken &Tok = Parser.getTok();
|
||||
if (Tok.isNot(AsmToken::Identifier))
|
||||
return true;
|
||||
const StringRef &ShiftName = Tok.getString();
|
||||
StringRef ShiftName = Tok.getString();
|
||||
if (ShiftName == "lsl" || ShiftName == "LSL")
|
||||
St = Lsl;
|
||||
else if (ShiftName == "lsr" || ShiftName == "LSR")
|
||||
@ -549,7 +549,7 @@ bool ARMAsmParser::ParseShift(ShiftType &St,
|
||||
}
|
||||
|
||||
/// A hack to allow some testing, to be replaced by a real table gen version.
|
||||
int ARMAsmParser::MatchRegisterName(const StringRef &Name) {
|
||||
int ARMAsmParser::MatchRegisterName(StringRef Name) {
|
||||
if (Name == "r0" || Name == "R0")
|
||||
return 0;
|
||||
else if (Name == "r1" || Name == "R1")
|
||||
@ -593,7 +593,7 @@ MatchInstruction(const SmallVectorImpl<MCParsedAsmOperand*> &Operands,
|
||||
MCInst &Inst) {
|
||||
ARMOperand &Op0 = *(ARMOperand*)Operands[0];
|
||||
assert(Op0.Kind == ARMOperand::Token && "First operand not a Token");
|
||||
const StringRef &Mnemonic = Op0.getToken();
|
||||
StringRef Mnemonic = Op0.getToken();
|
||||
if (Mnemonic == "add" ||
|
||||
Mnemonic == "stmfd" ||
|
||||
Mnemonic == "str" ||
|
||||
@ -658,7 +658,7 @@ bool ARMAsmParser::ParseOperand(OwningPtr<ARMOperand> &Op) {
|
||||
}
|
||||
|
||||
/// Parse an arm instruction mnemonic followed by its operands.
|
||||
bool ARMAsmParser::ParseInstruction(const StringRef &Name, SMLoc NameLoc,
|
||||
bool ARMAsmParser::ParseInstruction(StringRef Name, SMLoc NameLoc,
|
||||
SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
|
||||
OwningPtr<ARMOperand> Op;
|
||||
ARMOperand::CreateToken(Op, Name, NameLoc);
|
||||
@ -761,7 +761,7 @@ bool ARMAsmParser::ParseDirectiveSyntax(SMLoc L) {
|
||||
const AsmToken &Tok = Parser.getTok();
|
||||
if (Tok.isNot(AsmToken::Identifier))
|
||||
return Error(L, "unexpected token in .syntax directive");
|
||||
const StringRef &Mode = Tok.getString();
|
||||
StringRef Mode = Tok.getString();
|
||||
if (Mode == "unified" || Mode == "UNIFIED")
|
||||
Parser.Lex();
|
||||
else if (Mode == "divided" || Mode == "DIVIDED")
|
||||
|
@ -14,7 +14,7 @@
|
||||
#include "AlphaMCAsmInfo.h"
|
||||
using namespace llvm;
|
||||
|
||||
AlphaMCAsmInfo::AlphaMCAsmInfo(const Target &T, const StringRef &TT) {
|
||||
AlphaMCAsmInfo::AlphaMCAsmInfo(const Target &T, StringRef TT) {
|
||||
AlignmentIsInBytes = false;
|
||||
PrivateGlobalPrefix = "$";
|
||||
GPRel32Directive = ".gprel32";
|
||||
|
@ -14,14 +14,14 @@
|
||||
#ifndef ALPHATARGETASMINFO_H
|
||||
#define ALPHATARGETASMINFO_H
|
||||
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
#include "llvm/MC/MCAsmInfo.h"
|
||||
|
||||
namespace llvm {
|
||||
class Target;
|
||||
class StringRef;
|
||||
|
||||
struct AlphaMCAsmInfo : public MCAsmInfo {
|
||||
explicit AlphaMCAsmInfo(const Target &T, const StringRef &TT);
|
||||
explicit AlphaMCAsmInfo(const Target &T, StringRef TT);
|
||||
};
|
||||
|
||||
} // namespace llvm
|
||||
|
@ -15,7 +15,7 @@
|
||||
|
||||
using namespace llvm;
|
||||
|
||||
BlackfinMCAsmInfo::BlackfinMCAsmInfo(const Target &T, const StringRef &TT) {
|
||||
BlackfinMCAsmInfo::BlackfinMCAsmInfo(const Target &T, StringRef TT) {
|
||||
GlobalPrefix = "_";
|
||||
CommentString = "//";
|
||||
HasSetDirective = false;
|
||||
|
@ -14,14 +14,14 @@
|
||||
#ifndef BLACKFINTARGETASMINFO_H
|
||||
#define BLACKFINTARGETASMINFO_H
|
||||
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
#include "llvm/MC/MCAsmInfo.h"
|
||||
|
||||
namespace llvm {
|
||||
class Target;
|
||||
class StringRef;
|
||||
|
||||
struct BlackfinMCAsmInfo : public MCAsmInfo {
|
||||
explicit BlackfinMCAsmInfo(const Target &T, const StringRef &TT);
|
||||
explicit BlackfinMCAsmInfo(const Target &T, StringRef TT);
|
||||
};
|
||||
|
||||
} // namespace llvm
|
||||
|
@ -14,7 +14,7 @@
|
||||
#include "SPUMCAsmInfo.h"
|
||||
using namespace llvm;
|
||||
|
||||
SPULinuxMCAsmInfo::SPULinuxMCAsmInfo(const Target &T, const StringRef &TT) {
|
||||
SPULinuxMCAsmInfo::SPULinuxMCAsmInfo(const Target &T, StringRef TT) {
|
||||
ZeroDirective = "\t.space\t";
|
||||
Data64bitsDirective = "\t.quad\t";
|
||||
AlignmentIsInBytes = false;
|
||||
|
@ -14,14 +14,14 @@
|
||||
#ifndef SPUTARGETASMINFO_H
|
||||
#define SPUTARGETASMINFO_H
|
||||
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
#include "llvm/MC/MCAsmInfo.h"
|
||||
|
||||
namespace llvm {
|
||||
class Target;
|
||||
class StringRef;
|
||||
|
||||
struct SPULinuxMCAsmInfo : public MCAsmInfo {
|
||||
explicit SPULinuxMCAsmInfo(const Target &T, const StringRef &TT);
|
||||
explicit SPULinuxMCAsmInfo(const Target &T, StringRef TT);
|
||||
};
|
||||
} // namespace llvm
|
||||
|
||||
|
@ -14,7 +14,7 @@
|
||||
#include "MBlazeMCAsmInfo.h"
|
||||
using namespace llvm;
|
||||
|
||||
MBlazeMCAsmInfo::MBlazeMCAsmInfo(const Target &T, const StringRef &TT) {
|
||||
MBlazeMCAsmInfo::MBlazeMCAsmInfo(const Target &T, StringRef TT) {
|
||||
AlignmentIsInBytes = false;
|
||||
Data16bitsDirective = "\t.half\t";
|
||||
Data32bitsDirective = "\t.word\t";
|
||||
|
@ -14,15 +14,15 @@
|
||||
#ifndef MBLAZETARGETASMINFO_H
|
||||
#define MBLAZETARGETASMINFO_H
|
||||
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
#include "llvm/MC/MCAsmInfo.h"
|
||||
|
||||
namespace llvm {
|
||||
class Target;
|
||||
class StringRef;
|
||||
|
||||
class MBlazeMCAsmInfo : public MCAsmInfo {
|
||||
public:
|
||||
explicit MBlazeMCAsmInfo(const Target &T, const StringRef &TT);
|
||||
explicit MBlazeMCAsmInfo(const Target &T, StringRef TT);
|
||||
};
|
||||
|
||||
} // namespace llvm
|
||||
|
@ -1621,8 +1621,7 @@ const char* MSILWriter::getLibraryName(const GlobalVariable* GV) {
|
||||
}
|
||||
|
||||
|
||||
const char* MSILWriter::getLibraryForSymbol(const StringRef &Name,
|
||||
bool isFunction,
|
||||
const char* MSILWriter::getLibraryForSymbol(StringRef Name, bool isFunction,
|
||||
CallingConv::ID CallingConv) {
|
||||
// TODO: Read *.def file with function and libraries definitions.
|
||||
return "MSVCRT.DLL";
|
||||
|
@ -246,7 +246,7 @@ namespace llvm {
|
||||
|
||||
const char* getLibraryName(const GlobalVariable* GV);
|
||||
|
||||
const char* getLibraryForSymbol(const StringRef &Name, bool isFunction,
|
||||
const char* getLibraryForSymbol(StringRef Name, bool isFunction,
|
||||
CallingConv::ID CallingConv);
|
||||
|
||||
void printExternals();
|
||||
|
@ -14,7 +14,7 @@
|
||||
#include "MSP430MCAsmInfo.h"
|
||||
using namespace llvm;
|
||||
|
||||
MSP430MCAsmInfo::MSP430MCAsmInfo(const Target &T, const StringRef &TT) {
|
||||
MSP430MCAsmInfo::MSP430MCAsmInfo(const Target &T, StringRef TT) {
|
||||
PrivateGlobalPrefix = ".L";
|
||||
WeakRefDirective ="\t.weak\t";
|
||||
PCSymbol=".";
|
||||
|
@ -14,13 +14,14 @@
|
||||
#ifndef MSP430TARGETASMINFO_H
|
||||
#define MSP430TARGETASMINFO_H
|
||||
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
#include "llvm/MC/MCAsmInfo.h"
|
||||
|
||||
namespace llvm {
|
||||
class Target;
|
||||
class StringRef;
|
||||
|
||||
struct MSP430MCAsmInfo : public MCAsmInfo {
|
||||
explicit MSP430MCAsmInfo(const Target &T, const StringRef &TT);
|
||||
explicit MSP430MCAsmInfo(const Target &T, StringRef TT);
|
||||
};
|
||||
|
||||
} // namespace llvm
|
||||
|
@ -14,7 +14,7 @@
|
||||
#include "MipsMCAsmInfo.h"
|
||||
using namespace llvm;
|
||||
|
||||
MipsMCAsmInfo::MipsMCAsmInfo(const Target &T, const StringRef &TT) {
|
||||
MipsMCAsmInfo::MipsMCAsmInfo(const Target &T, StringRef TT) {
|
||||
AlignmentIsInBytes = false;
|
||||
Data16bitsDirective = "\t.half\t";
|
||||
Data32bitsDirective = "\t.word\t";
|
||||
|
@ -14,15 +14,15 @@
|
||||
#ifndef MIPSTARGETASMINFO_H
|
||||
#define MIPSTARGETASMINFO_H
|
||||
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
#include "llvm/MC/MCAsmInfo.h"
|
||||
|
||||
namespace llvm {
|
||||
class Target;
|
||||
class StringRef;
|
||||
|
||||
class MipsMCAsmInfo : public MCAsmInfo {
|
||||
public:
|
||||
explicit MipsMCAsmInfo(const Target &T, const StringRef &TT);
|
||||
explicit MipsMCAsmInfo(const Target &T, StringRef TT);
|
||||
};
|
||||
|
||||
} // namespace llvm
|
||||
|
@ -20,7 +20,7 @@
|
||||
#include "PIC16ISelLowering.h"
|
||||
using namespace llvm;
|
||||
|
||||
PIC16MCAsmInfo::PIC16MCAsmInfo(const Target &T, const StringRef &TT) {
|
||||
PIC16MCAsmInfo::PIC16MCAsmInfo(const Target &T, StringRef TT) {
|
||||
CommentString = ";";
|
||||
GlobalPrefix = PAN::getTagName(PAN::PREFIX_SYMBOL);
|
||||
GlobalDirective = "\tglobal\t";
|
||||
|
@ -25,7 +25,7 @@ namespace llvm {
|
||||
const char *RomData16bitsDirective;
|
||||
const char *RomData32bitsDirective;
|
||||
public:
|
||||
PIC16MCAsmInfo(const Target &T, const StringRef &TT);
|
||||
PIC16MCAsmInfo(const Target &T, StringRef TT);
|
||||
|
||||
virtual const char *getDataASDirective(unsigned size, unsigned AS) const;
|
||||
};
|
||||
|
@ -12,10 +12,9 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "SparcMCAsmInfo.h"
|
||||
#include "llvm/ADT/SmallVector.h"
|
||||
using namespace llvm;
|
||||
|
||||
SparcELFMCAsmInfo::SparcELFMCAsmInfo(const Target &T, const StringRef &TT) {
|
||||
SparcELFMCAsmInfo::SparcELFMCAsmInfo(const Target &T, StringRef TT) {
|
||||
Data16bitsDirective = "\t.half\t";
|
||||
Data32bitsDirective = "\t.word\t";
|
||||
Data64bitsDirective = 0; // .xword is only supported by V9.
|
||||
|
@ -14,13 +14,14 @@
|
||||
#ifndef SPARCTARGETASMINFO_H
|
||||
#define SPARCTARGETASMINFO_H
|
||||
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
#include "llvm/MC/MCAsmInfo.h"
|
||||
|
||||
namespace llvm {
|
||||
class Target;
|
||||
class StringRef;
|
||||
|
||||
struct SparcELFMCAsmInfo : public MCAsmInfo {
|
||||
explicit SparcELFMCAsmInfo(const Target &T, const StringRef &TT);
|
||||
explicit SparcELFMCAsmInfo(const Target &T, StringRef TT);
|
||||
};
|
||||
|
||||
} // namespace llvm
|
||||
|
@ -16,7 +16,7 @@
|
||||
#include "llvm/MC/MCSectionELF.h"
|
||||
using namespace llvm;
|
||||
|
||||
SystemZMCAsmInfo::SystemZMCAsmInfo(const Target &T, const StringRef &TT) {
|
||||
SystemZMCAsmInfo::SystemZMCAsmInfo(const Target &T, StringRef TT) {
|
||||
PrivateGlobalPrefix = ".L";
|
||||
WeakRefDirective = "\t.weak\t";
|
||||
PCSymbol = ".";
|
||||
|
@ -21,7 +21,7 @@ namespace llvm {
|
||||
class StringRef;
|
||||
|
||||
struct SystemZMCAsmInfo : public MCAsmInfo {
|
||||
explicit SystemZMCAsmInfo(const Target &T, const StringRef &TT);
|
||||
explicit SystemZMCAsmInfo(const Target &T, StringRef TT);
|
||||
virtual const MCSection *getNonexecutableStackSection(MCContext &Ctx) const;
|
||||
};
|
||||
|
||||
|
@ -65,7 +65,7 @@ public:
|
||||
X86ATTAsmParser(const Target &T, MCAsmParser &_Parser)
|
||||
: TargetAsmParser(T), Parser(_Parser) {}
|
||||
|
||||
virtual bool ParseInstruction(const StringRef &Name, SMLoc NameLoc,
|
||||
virtual bool ParseInstruction(StringRef Name, SMLoc NameLoc,
|
||||
SmallVectorImpl<MCParsedAsmOperand*> &Operands);
|
||||
|
||||
virtual bool ParseDirective(AsmToken DirectiveID);
|
||||
@ -602,7 +602,7 @@ X86Operand *X86ATTAsmParser::ParseMemOperand(unsigned SegReg, SMLoc MemStart) {
|
||||
}
|
||||
|
||||
bool X86ATTAsmParser::
|
||||
ParseInstruction(const StringRef &Name, SMLoc NameLoc,
|
||||
ParseInstruction(StringRef Name, SMLoc NameLoc,
|
||||
SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
|
||||
// The various flavors of pushf and popf use Requires<In32BitMode> and
|
||||
// Requires<In64BitMode>, but the assembler doesn't yet implement that.
|
||||
|
@ -10,7 +10,7 @@
|
||||
#include "XCoreMCAsmInfo.h"
|
||||
using namespace llvm;
|
||||
|
||||
XCoreMCAsmInfo::XCoreMCAsmInfo(const Target &T, const StringRef &TT) {
|
||||
XCoreMCAsmInfo::XCoreMCAsmInfo(const Target &T, StringRef TT) {
|
||||
SupportsDebugInformation = true;
|
||||
Data16bitsDirective = "\t.short\t";
|
||||
Data32bitsDirective = "\t.long\t";
|
||||
|
@ -14,14 +14,15 @@
|
||||
#ifndef XCORETARGETASMINFO_H
|
||||
#define XCORETARGETASMINFO_H
|
||||
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
#include "llvm/MC/MCAsmInfo.h"
|
||||
|
||||
namespace llvm {
|
||||
class Target;
|
||||
class StringRef;
|
||||
|
||||
class XCoreMCAsmInfo : public MCAsmInfo {
|
||||
public:
|
||||
explicit XCoreMCAsmInfo(const Target &T, const StringRef &TT);
|
||||
explicit XCoreMCAsmInfo(const Target &T, StringRef TT);
|
||||
};
|
||||
|
||||
} // namespace llvm
|
||||
|
@ -90,8 +90,7 @@ enum PrefixType {
|
||||
/// PrintLLVMName - Turn the specified name into an 'LLVM name', which is either
|
||||
/// prefixed with % (if the string only contains simple characters) or is
|
||||
/// surrounded with ""'s (if it has special chars in it). Print it out.
|
||||
static void PrintLLVMName(raw_ostream &OS, const StringRef &Name,
|
||||
PrefixType Prefix) {
|
||||
static void PrintLLVMName(raw_ostream &OS, StringRef Name, PrefixType Prefix) {
|
||||
assert(Name.data() && "Cannot get empty name!");
|
||||
switch (Prefix) {
|
||||
default: llvm_unreachable("Bad prefix!");
|
||||
|
Loading…
Reference in New Issue
Block a user