6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-12 13:30:51 +00:00
Code Issues Projects Releases Wiki Activity

Removing LLVM_DELETED_FUNCTION, as MSVC 2012 was the last reason for requiring the macro. NFC; LLVM edition.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@229340 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Aaron Ballman 2015-02-15 22:54:22 +00:00
parent aee01b35e4
commit 66981fe208
161 changed files with 827 additions and 855 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
examples/Kaleidoscope/Chapter4/toy.cpp
View File

@ -447,8 +447,8 @@ private:
};
class HelpingMemoryManager : public SectionMemoryManager {
HelpingMemoryManager(const HelpingMemoryManager &) LLVM_DELETED_FUNCTION;
void operator=(const HelpingMemoryManager &) LLVM_DELETED_FUNCTION;
HelpingMemoryManager(const HelpingMemoryManager &) = delete;
void operator=(const HelpingMemoryManager &) = delete;
public:
HelpingMemoryManager(MCJITHelper *Helper) : MasterHelper(Helper) {}

250
examples/Kaleidoscope/MCJIT/cached/toy.cpp
View File

@ -36,8 +36,8 @@ InputIR("input-IR",
cl::desc("Specify the name of an IR file to load for function definitions"),
cl::value_desc("input IR file name"));
cl::opt<bool>
UseObjectCache("use-object-cache",
cl::opt<bool>
UseObjectCache("use-object-cache",
cl::desc("Enable use of the MCJIT object caching"),
cl::init(false));
@ -55,14 +55,14 @@ enum Token {
// primary
tok_identifier = -4, tok_number = -5,
// control
tok_if = -6, tok_then = -7, tok_else = -8,
tok_for = -9, tok_in = -10,
// operators
tok_binary = -11, tok_unary = -12,
// var definition
tok_var = -13
};
@ -111,11 +111,11 @@ static int gettok() {
// Comment until end of line.
do LastChar = getchar();
while (LastChar != EOF && LastChar != '\n' && LastChar != '\r');
if (LastChar != EOF)
return gettok();
}
// Check for end of file. Don't eat the EOF.
if (LastChar == EOF)
return tok_eof;
@ -159,7 +159,7 @@ class UnaryExprAST : public ExprAST {
char Opcode;
ExprAST *Operand;
public:
UnaryExprAST(char opcode, ExprAST *operand)
UnaryExprAST(char opcode, ExprAST *operand)
: Opcode(opcode), Operand(operand) {}
virtual Value *Codegen();
};
@ -169,7 +169,7 @@ class BinaryExprAST : public ExprAST {
char Op;
ExprAST *LHS, *RHS;
public:
BinaryExprAST(char op, ExprAST *lhs, ExprAST *rhs)
BinaryExprAST(char op, ExprAST *lhs, ExprAST *rhs)
: Op(op), LHS(lhs), RHS(rhs) {}
virtual Value *Codegen();
};
@ -212,7 +212,7 @@ public:
VarExprAST(const std::vector<std::pair<std::string, ExprAST*> > &varnames,
ExprAST *body)
: VarNames(varnames), Body(body) {}
virtual Value *Codegen();
};
@ -227,19 +227,19 @@ public:
PrototypeAST(const std::string &name, const std::vector<std::string> &args,
bool isoperator = false, unsigned prec = 0)
: Name(name), Args(args), isOperator(isoperator), Precedence(prec) {}
bool isUnaryOp() const { return isOperator && Args.size() == 1; }
bool isBinaryOp() const { return isOperator && Args.size() == 2; }
char getOperatorName() const {
assert(isUnaryOp() || isBinaryOp());
return Name[Name.size()-1];
}
unsigned getBinaryPrecedence() const { return Precedence; }
Function *Codegen();
void CreateArgumentAllocas(Function *F);
};
@ -250,7 +250,7 @@ class FunctionAST {
public:
FunctionAST(PrototypeAST *proto, ExprAST *body)
: Proto(proto), Body(body) {}
Function *Codegen();
};
@ -274,7 +274,7 @@ static std::map<char, int> BinopPrecedence;
static int GetTokPrecedence() {
if (!isascii(CurTok))
return -1;
// Make sure it's a declared binop.
int TokPrec = BinopPrecedence[CurTok];
if (TokPrec <= 0) return -1;
@ -293,12 +293,12 @@ static ExprAST *ParseExpression();
/// ::= identifier '(' expression* ')'
static ExprAST *ParseIdentifierExpr() {
std::string IdName = IdentifierStr;
getNextToken(); // eat identifier.
if (CurTok != '(') // Simple variable ref.
return new VariableExprAST(IdName);
// Call.
getNextToken(); // eat (
std::vector<ExprAST*> Args;
@ -318,7 +318,7 @@ static ExprAST *ParseIdentifierExpr() {
// Eat the ')'.
getNextToken();
return new CallExprAST(IdName, Args);
}
@ -334,7 +334,7 @@ static ExprAST *ParseParenExpr() {
getNextToken(); // eat (.
ExprAST *V = ParseExpression();
if (!V) return 0;
if (CurTok != ')')
return Error("expected ')'");
getNextToken(); // eat ).
@ -344,26 +344,26 @@ static ExprAST *ParseParenExpr() {
/// ifexpr ::= 'if' expression 'then' expression 'else' expression
static ExprAST *ParseIfExpr() {
getNextToken(); // eat the if.
// condition.
ExprAST *Cond = ParseExpression();
if (!Cond) return 0;
if (CurTok != tok_then)
return Error("expected then");
getNextToken(); // eat the then
ExprAST *Then = ParseExpression();
if (Then == 0) return 0;
if (CurTok != tok_else)
return Error("expected else");
getNextToken();
ExprAST *Else = ParseExpression();
if (!Else) return 0;
return new IfExprAST(Cond, Then, Else);
}
@ -373,24 +373,24 @@ static ExprAST *ParseForExpr() {
if (CurTok != tok_identifier)
return Error("expected identifier after for");
std::string IdName = IdentifierStr;
getNextToken(); // eat identifier.
if (CurTok != '=')
return Error("expected '=' after for");
getNextToken(); // eat '='.
ExprAST *Start = ParseExpression();
if (Start == 0) return 0;
if (CurTok != ',')
return Error("expected ',' after for start value");
getNextToken();
ExprAST *End = ParseExpression();
if (End == 0) return 0;
// The step value is optional.
ExprAST *Step = 0;
if (CurTok == ',') {
@ -398,18 +398,18 @@ static ExprAST *ParseForExpr() {
Step = ParseExpression();
if (Step == 0) return 0;
}
if (CurTok != tok_in)
return Error("expected 'in' after for");
getNextToken(); // eat 'in'.
ExprAST *Body = ParseExpression();
if (Body == 0) return 0;
return new ForExprAST(IdName, Start, End, Step, Body);
}
/// varexpr ::= 'var' identifier ('=' expression)?
/// varexpr ::= 'var' identifier ('=' expression)?
// (',' identifier ('=' expression)?)* 'in' expression
static ExprAST *ParseVarExpr() {
getNextToken(); // eat the var.
@ -419,7 +419,7 @@ static ExprAST *ParseVarExpr() {
// At least one variable name is required.
if (CurTok != tok_identifier)
return Error("expected identifier after var");
while (1) {
std::string Name = IdentifierStr;
getNextToken(); // eat identifier.
@ -428,29 +428,29 @@ static ExprAST *ParseVarExpr() {
ExprAST *Init = 0;
if (CurTok == '=') {
getNextToken(); // eat the '='.
Init = ParseExpression();
if (Init == 0) return 0;
}
VarNames.push_back(std::make_pair(Name, Init));
// End of var list, exit loop.
if (CurTok != ',') break;
getNextToken(); // eat the ','.
if (CurTok != tok_identifier)
return Error("expected identifier list after var");
}
// At this point, we have to have 'in'.
if (CurTok != tok_in)
return Error("expected 'in' keyword after 'var'");
getNextToken(); // eat 'in'.
ExprAST *Body = ParseExpression();
if (Body == 0) return 0;
return new VarExprAST(VarNames, Body);
}
@ -480,7 +480,7 @@ static ExprAST *ParseUnary() {
// If the current token is not an operator, it must be a primary expr.
if (!isascii(CurTok) || CurTok == '(' || CurTok == ',')
return ParsePrimary();
// If this is a unary operator, read it.
int Opc = CurTok;
getNextToken();
@ -495,20 +495,20 @@ static ExprAST *ParseBinOpRHS(int ExprPrec, ExprAST *LHS) {
// If this is a binop, find its precedence.
while (1) {
int TokPrec = GetTokPrecedence();
// If this is a binop that binds at least as tightly as the current binop,
// consume it, otherwise we are done.
if (TokPrec < ExprPrec)
return LHS;
// Okay, we know this is a binop.
int BinOp = CurTok;
getNextToken(); // eat binop
// Parse the unary expression after the binary operator.
ExprAST *RHS = ParseUnary();
if (!RHS) return 0;
// If BinOp binds less tightly with RHS than the operator after RHS, let
// the pending operator take RHS as its LHS.
int NextPrec = GetTokPrecedence();
@ -516,7 +516,7 @@ static ExprAST *ParseBinOpRHS(int ExprPrec, ExprAST *LHS) {
RHS = ParseBinOpRHS(TokPrec+1, RHS);
if (RHS == 0) return 0;
}
// Merge LHS/RHS.
LHS = new BinaryExprAST(BinOp, LHS, RHS);
}
@ -528,7 +528,7 @@ static ExprAST *ParseBinOpRHS(int ExprPrec, ExprAST *LHS) {
static ExprAST *ParseExpression() {
ExprAST *LHS = ParseUnary();
if (!LHS) return 0;
return ParseBinOpRHS(0, LHS);
}
@ -538,10 +538,10 @@ static ExprAST *ParseExpression() {
/// ::= unary LETTER (id)
static PrototypeAST *ParsePrototype() {
std::string FnName;
unsigned Kind = 0; // 0 = identifier, 1 = unary, 2 = binary.
unsigned BinaryPrecedence = 30;
switch (CurTok) {
default:
return ErrorP("Expected function name in prototype");
@ -567,7 +567,7 @@ static PrototypeAST *ParsePrototype() {
FnName += (char)CurTok;
Kind = 2;
getNextToken();
// Read the precedence if present.
if (CurTok == tok_number) {
if (NumVal < 1 || NumVal > 100)
@ -577,23 +577,23 @@ static PrototypeAST *ParsePrototype() {
}
break;
}
if (CurTok != '(')
return ErrorP("Expected '(' in prototype");
std::vector<std::string> ArgNames;
while (getNextToken() == tok_identifier)
ArgNames.push_back(IdentifierStr);
if (CurTok != ')')
return ErrorP("Expected ')' in prototype");
// success.
getNextToken(); // eat ')'.
// Verify right number of names for operator.
if (Kind && ArgNames.size() != Kind)
return ErrorP("Invalid number of operands for operator");
return new PrototypeAST(FnName, ArgNames, Kind != 0, BinaryPrecedence);
}
@ -762,14 +762,14 @@ private:
class HelpingMemoryManager : public SectionMemoryManager
{
HelpingMemoryManager(const HelpingMemoryManager&) LLVM_DELETED_FUNCTION;
void operator=(const HelpingMemoryManager&) LLVM_DELETED_FUNCTION;
HelpingMemoryManager(const HelpingMemoryManager&) = delete;
void operator=(const HelpingMemoryManager&) = delete;
public:
HelpingMemoryManager(MCJITHelper *Helper) : MasterHelper(Helper) {}
virtual ~HelpingMemoryManager() {}
/// This method returns the address of the specified function.
/// This method returns the address of the specified function.
/// Our implementation will attempt to find functions in other
/// modules associated with the MCJITHelper to cross link functions
/// from one generated module to another.
@ -838,9 +838,9 @@ Function *MCJITHelper::getFunction(const std::string FnName) {
// If we don't have a prototype yet, create one.
if (!PF)
PF = Function::Create(F->getFunctionType(),
Function::ExternalLinkage,
FnName,
PF = Function::Create(F->getFunctionType(),
Function::ExternalLinkage,
FnName,
OpenModule);
return PF;
}
@ -1027,11 +1027,11 @@ Value *VariableExprAST::Codegen() {
Value *UnaryExprAST::Codegen() {
Value *OperandV = Operand->Codegen();
if (OperandV == 0) return 0;
Function *F = TheHelper->getFunction(MakeLegalFunctionName(std::string("unary")+Opcode));
if (F == 0)
return ErrorV("Unknown unary operator");
return Builder.CreateCall(F, OperandV, "unop");
}
@ -1053,11 +1053,11 @@ Value *BinaryExprAST::Codegen() {
Builder.CreateStore(Val, Variable);
return Val;
}
Value *L = LHS->Codegen();
Value *R = RHS->Codegen();
if (L == 0 || R == 0) return 0;
switch (Op) {
case '+': return Builder.CreateFAdd(L, R, "addtmp");
case '-': return Builder.CreateFSub(L, R, "subtmp");
@ -1070,12 +1070,12 @@ Value *BinaryExprAST::Codegen() {
"booltmp");
default: break;
}
// If it wasn't a builtin binary operator, it must be a user defined one. Emit
// a call to it.
Function *F = TheHelper->getFunction(MakeLegalFunctionName(std::string("binary")+Op));
assert(F && "binary operator not found!");
Value *Ops[] = { L, R };
return Builder.CreateCall(F, Ops, "binop");
}
@ -1085,7 +1085,7 @@ Value *CallExprAST::Codegen() {
Function *CalleeF = TheHelper->getFunction(Callee);
if (CalleeF == 0)
return ErrorV("Unknown function referenced");
// If argument mismatch error.
if (CalleeF->arg_size() != Args.size())
return ErrorV("Incorrect # arguments passed");
@ -1095,56 +1095,56 @@ Value *CallExprAST::Codegen() {
ArgsV.push_back(Args[i]->Codegen());
if (ArgsV.back() == 0) return 0;
}
return Builder.CreateCall(CalleeF, ArgsV, "calltmp");
}
Value *IfExprAST::Codegen() {
Value *CondV = Cond->Codegen();
if (CondV == 0) return 0;
// Convert condition to a bool by comparing equal to 0.0.
CondV = Builder.CreateFCmpONE(CondV,
CondV = Builder.CreateFCmpONE(CondV,
ConstantFP::get(getGlobalContext(), APFloat(0.0)),
"ifcond");
Function *TheFunction = Builder.GetInsertBlock()->getParent();
// Create blocks for the then and else cases. Insert the 'then' block at the
// end of the function.
BasicBlock *ThenBB = BasicBlock::Create(getGlobalContext(), "then", TheFunction);
BasicBlock *ElseBB = BasicBlock::Create(getGlobalContext(), "else");
BasicBlock *MergeBB = BasicBlock::Create(getGlobalContext(), "ifcont");
Builder.CreateCondBr(CondV, ThenBB, ElseBB);
// Emit then value.
Builder.SetInsertPoint(ThenBB);
Value *ThenV = Then->Codegen();
if (ThenV == 0) return 0;
Builder.CreateBr(MergeBB);
// Codegen of 'Then' can change the current block, update ThenBB for the PHI.
ThenBB = Builder.GetInsertBlock();
// Emit else block.
TheFunction->getBasicBlockList().push_back(ElseBB);
Builder.SetInsertPoint(ElseBB);
Value *ElseV = Else->Codegen();
if (ElseV == 0) return 0;
Builder.CreateBr(MergeBB);
// Codegen of 'Else' can change the current block, update ElseBB for the PHI.
ElseBB = Builder.GetInsertBlock();
// Emit merge block.
TheFunction->getBasicBlockList().push_back(MergeBB);
Builder.SetInsertPoint(MergeBB);
PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2,
"iftmp");
PN->addIncoming(ThenV, ThenBB);
PN->addIncoming(ElseV, ElseBB);
return PN;
@ -1157,7 +1157,7 @@ Value *ForExprAST::Codegen() {
// start = startexpr
// store start -> var
// goto loop
// loop:
// loop:
// ...
// bodyexpr
// ...
@ -1170,40 +1170,40 @@ Value *ForExprAST::Codegen() {
// store nextvar -> var
// br endcond, loop, endloop
// outloop:
Function *TheFunction = Builder.GetInsertBlock()->getParent();
// Create an alloca for the variable in the entry block.
AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, VarName);
// Emit the start code first, without 'variable' in scope.
Value *StartVal = Start->Codegen();
if (StartVal == 0) return 0;
// Store the value into the alloca.
Builder.CreateStore(StartVal, Alloca);
// Make the new basic block for the loop header, inserting after current
// block.
BasicBlock *LoopBB = BasicBlock::Create(getGlobalContext(), "loop", TheFunction);
// Insert an explicit fall through from the current block to the LoopBB.
Builder.CreateBr(LoopBB);
// Start insertion in LoopBB.
Builder.SetInsertPoint(LoopBB);
// Within the loop, the variable is defined equal to the PHI node. If it
// shadows an existing variable, we have to restore it, so save it now.
AllocaInst *OldVal = NamedValues[VarName];
NamedValues[VarName] = Alloca;
// Emit the body of the loop. This, like any other expr, can change the
// current BB. Note that we ignore the value computed by the body, but don't
// allow an error.
if (Body->Codegen() == 0)
return 0;
// Emit the step value.
Value *StepVal;
if (Step) {
@ -1213,52 +1213,52 @@ Value *ForExprAST::Codegen() {
// If not specified, use 1.0.
StepVal = ConstantFP::get(getGlobalContext(), APFloat(1.0));
}
// Compute the end condition.
Value *EndCond = End->Codegen();
if (EndCond == 0) return EndCond;
// Reload, increment, and restore the alloca. This handles the case where
// the body of the loop mutates the variable.
Value *CurVar = Builder.CreateLoad(Alloca, VarName.c_str());
Value *NextVar = Builder.CreateFAdd(CurVar, StepVal, "nextvar");
Builder.CreateStore(NextVar, Alloca);
// Convert condition to a bool by comparing equal to 0.0.
EndCond = Builder.CreateFCmpONE(EndCond,
EndCond = Builder.CreateFCmpONE(EndCond,
ConstantFP::get(getGlobalContext(), APFloat(0.0)),
"loopcond");
// Create the "after loop" block and insert it.
BasicBlock *AfterBB = BasicBlock::Create(getGlobalContext(), "afterloop", TheFunction);
// Insert the conditional branch into the end of LoopEndBB.
Builder.CreateCondBr(EndCond, LoopBB, AfterBB);
// Any new code will be inserted in AfterBB.
Builder.SetInsertPoint(AfterBB);
// Restore the unshadowed variable.
if (OldVal)
NamedValues[VarName] = OldVal;
else
NamedValues.erase(VarName);
// for expr always returns 0.0.
return Constant::getNullValue(Type::getDoubleTy(getGlobalContext()));
}
Value *VarExprAST::Codegen() {
std::vector<AllocaInst *> OldBindings;
Function *TheFunction = Builder.GetInsertBlock()->getParent();
// Register all variables and emit their initializer.
for (unsigned i = 0, e = VarNames.size(); i != e; ++i) {
const std::string &VarName = VarNames[i].first;
ExprAST *Init = VarNames[i].second;
// Emit the initializer before adding the variable to scope, this prevents
// the initializer from referencing the variable itself, and permits stuff
// like this:
@ -1271,22 +1271,22 @@ Value *VarExprAST::Codegen() {
} else { // If not specified, use 0.0.
InitVal = ConstantFP::get(getGlobalContext(), APFloat(0.0));
}
AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, VarName);
Builder.CreateStore(InitVal, Alloca);
// Remember the old variable binding so that we can restore the binding when
// we unrecurse.
OldBindings.push_back(NamedValues[VarName]);
// Remember this binding.
NamedValues[VarName] = Alloca;
}
// Codegen the body, now that all vars are in scope.
Value *BodyVal = Body->Codegen();
if (BodyVal == 0) return 0;
// Pop all our variables from scope.
for (unsigned i = 0, e = VarNames.size(); i != e; ++i)
NamedValues[VarNames[i].first] = OldBindings[i];
@ -1297,7 +1297,7 @@ Value *VarExprAST::Codegen() {
Function *PrototypeAST::Codegen() {
// Make the function type: double(double,double) etc.
std::vector<Type*> Doubles(Args.size(),
std::vector<Type*> Doubles(Args.size(),
Type::getDoubleTy(getGlobalContext()));
FunctionType *FT = FunctionType::get(Type::getDoubleTy(getGlobalContext()),
Doubles, false);
@ -1314,26 +1314,26 @@ Function *PrototypeAST::Codegen() {
// Delete the one we just made and get the existing one.
F->eraseFromParent();
F = M->getFunction(Name);
// If F already has a body, reject this.
if (!F->empty()) {
ErrorF("redefinition of function");
return 0;
}
// If F took a different number of args, reject.
if (F->arg_size() != Args.size()) {
ErrorF("redefinition of function with different # args");
return 0;
}
}
// Set names for all arguments.
unsigned Idx = 0;
for (Function::arg_iterator AI = F->arg_begin(); Idx != Args.size();
++AI, ++Idx)
AI->setName(Args[Idx]);
return F;
}
@ -1355,19 +1355,19 @@ void PrototypeAST::CreateArgumentAllocas(Function *F) {
Function *FunctionAST::Codegen() {
NamedValues.clear();
Function *TheFunction = Proto->Codegen();
if (TheFunction == 0)
return 0;
// If this is an operator, install it.
if (Proto->isBinaryOp())
BinopPrecedence[Proto->getOperatorName()] = Proto->getBinaryPrecedence();
// Create a new basic block to start insertion into.
BasicBlock *BB = BasicBlock::Create(getGlobalContext(), "entry", TheFunction);
Builder.SetInsertPoint(BB);
// Add all arguments to the symbol table and create their allocas.
Proto->CreateArgumentAllocas(TheFunction);
@ -1428,7 +1428,7 @@ static void HandleTopLevelExpression() {
if (Function *LF = F->Codegen()) {
// JIT the function, returning a function pointer.
void *FPtr = TheHelper->getPointerToFunction(LF);
// Cast it to the right type (takes no arguments, returns a double) so we
// can call it as a native function.
double (*FP)() = (double (*)())(intptr_t)FPtr;
@ -1465,20 +1465,20 @@ static void MainLoop() {
//===----------------------------------------------------------------------===//
/// putchard - putchar that takes a double and returns 0.
extern "C"
extern "C"
double putchard(double X) {
putchar((char)X);
return 0;
}
/// printd - printf that takes a double prints it as "%f\n", returning 0.
extern "C"
extern "C"
double printd(double X) {
printf("%f", X);
return 0;
}
extern "C"
extern "C"
double printlf() {
printf("\n");
return 0;

6
examples/Kaleidoscope/MCJIT/complete/toy.cpp
View File

@ -37,7 +37,7 @@ namespace {
cl::value_desc("input IR file name"));
cl::opt<bool>
VerboseOutput("verbose",
VerboseOutput("verbose",
cl::desc("Enable verbose output (results, IR, etc.) to stderr"),
cl::init(false));
@ -830,8 +830,8 @@ private:
class HelpingMemoryManager : public SectionMemoryManager
{
HelpingMemoryManager(const HelpingMemoryManager&) LLVM_DELETED_FUNCTION;
void operator=(const HelpingMemoryManager&) LLVM_DELETED_FUNCTION;
HelpingMemoryManager(const HelpingMemoryManager&) = delete;
void operator=(const HelpingMemoryManager&) = delete;
public:
HelpingMemoryManager(MCJITHelper *Helper) : MasterHelper(Helper) {}

248
examples/Kaleidoscope/MCJIT/initial/toy.cpp
View File

@ -32,14 +32,14 @@ enum Token {
// primary
tok_identifier = -4, tok_number = -5,
// control
tok_if = -6, tok_then = -7, tok_else = -8,
tok_for = -9, tok_in = -10,
// operators
tok_binary = -11, tok_unary = -12,
// var definition
tok_var = -13
};
@ -88,11 +88,11 @@ static int gettok() {
// Comment until end of line.
do LastChar = getchar();
while (LastChar != EOF && LastChar != '\n' && LastChar != '\r');
if (LastChar != EOF)
return gettok();
}
// Check for end of file. Don't eat the EOF.
if (LastChar == EOF)
return tok_eof;
@ -136,7 +136,7 @@ class UnaryExprAST : public ExprAST {
char Opcode;
ExprAST *Operand;
public:
UnaryExprAST(char opcode, ExprAST *operand)
UnaryExprAST(char opcode, ExprAST *operand)
: Opcode(opcode), Operand(operand) {}
virtual Value *Codegen();
};
@ -146,7 +146,7 @@ class BinaryExprAST : public ExprAST {
char Op;
ExprAST *LHS, *RHS;
public:
BinaryExprAST(char op, ExprAST *lhs, ExprAST *rhs)
BinaryExprAST(char op, ExprAST *lhs, ExprAST *rhs)
: Op(op), LHS(lhs), RHS(rhs) {}
virtual Value *Codegen();
};
@ -189,7 +189,7 @@ public:
VarExprAST(const std::vector<std::pair<std::string, ExprAST*> > &varnames,
ExprAST *body)
: VarNames(varnames), Body(body) {}
virtual Value *Codegen();
};
@ -204,19 +204,19 @@ public:
PrototypeAST(const std::string &name, const std::vector<std::string> &args,
bool isoperator = false, unsigned prec = 0)
: Name(name), Args(args), isOperator(isoperator), Precedence(prec) {}
bool isUnaryOp() const { return isOperator && Args.size() == 1; }
bool isBinaryOp() const { return isOperator && Args.size() == 2; }
char getOperatorName() const {
assert(isUnaryOp() || isBinaryOp());
return Name[Name.size()-1];
}
unsigned getBinaryPrecedence() const { return Precedence; }
Function *Codegen();
void CreateArgumentAllocas(Function *F);
};
@ -227,7 +227,7 @@ class FunctionAST {
public:
FunctionAST(PrototypeAST *proto, ExprAST *body)
: Proto(proto), Body(body) {}
Function *Codegen();
};
@ -251,7 +251,7 @@ static std::map<char, int> BinopPrecedence;
static int GetTokPrecedence() {
if (!isascii(CurTok))
return -1;
// Make sure it's a declared binop.
int TokPrec = BinopPrecedence[CurTok];
if (TokPrec <= 0) return -1;
@ -270,12 +270,12 @@ static ExprAST *ParseExpression();
/// ::= identifier '(' expression* ')'
static ExprAST *ParseIdentifierExpr() {
std::string IdName = IdentifierStr;
getNextToken(); // eat identifier.
if (CurTok != '(') // Simple variable ref.
return new VariableExprAST(IdName);
// Call.
getNextToken(); // eat (
std::vector<ExprAST*> Args;
@ -295,7 +295,7 @@ static ExprAST *ParseIdentifierExpr() {
// Eat the ')'.
getNextToken();
return new CallExprAST(IdName, Args);
}
@ -311,7 +311,7 @@ static ExprAST *ParseParenExpr() {
getNextToken(); // eat (.
ExprAST *V = ParseExpression();
if (!V) return 0;
if (CurTok != ')')
return Error("expected ')'");
getNextToken(); // eat ).
@ -321,26 +321,26 @@ static ExprAST *ParseParenExpr() {
/// ifexpr ::= 'if' expression 'then' expression 'else' expression
static ExprAST *ParseIfExpr() {
getNextToken(); // eat the if.
// condition.
ExprAST *Cond = ParseExpression();
if (!Cond) return 0;
if (CurTok != tok_then)
return Error("expected then");
getNextToken(); // eat the then
ExprAST *Then = ParseExpression();
if (Then == 0) return 0;
if (CurTok != tok_else)
return Error("expected else");
getNextToken();
ExprAST *Else = ParseExpression();
if (!Else) return 0;
return new IfExprAST(Cond, Then, Else);
}
@ -350,24 +350,24 @@ static ExprAST *ParseForExpr() {
if (CurTok != tok_identifier)
return Error("expected identifier after for");
std::string IdName = IdentifierStr;
getNextToken(); // eat identifier.
if (CurTok != '=')
return Error("expected '=' after for");
getNextToken(); // eat '='.
ExprAST *Start = ParseExpression();
if (Start == 0) return 0;
if (CurTok != ',')
return Error("expected ',' after for start value");
getNextToken();
ExprAST *End = ParseExpression();
if (End == 0) return 0;
// The step value is optional.
ExprAST *Step = 0;
if (CurTok == ',') {
@ -375,18 +375,18 @@ static ExprAST *ParseForExpr() {
Step = ParseExpression();
if (Step == 0) return 0;
}
if (CurTok != tok_in)
return Error("expected 'in' after for");
getNextToken(); // eat 'in'.
ExprAST *Body = ParseExpression();
if (Body == 0) return 0;
return new ForExprAST(IdName, Start, End, Step, Body);
}
/// varexpr ::= 'var' identifier ('=' expression)?
/// varexpr ::= 'var' identifier ('=' expression)?
// (',' identifier ('=' expression)?)* 'in' expression
static ExprAST *ParseVarExpr() {
getNextToken(); // eat the var.
@ -396,7 +396,7 @@ static ExprAST *ParseVarExpr() {
// At least one variable name is required.
if (CurTok != tok_identifier)
return Error("expected identifier after var");
while (1) {
std::string Name = IdentifierStr;
getNextToken(); // eat identifier.
@ -405,29 +405,29 @@ static ExprAST *ParseVarExpr() {
ExprAST *Init = 0;
if (CurTok == '=') {
getNextToken(); // eat the '='.
Init = ParseExpression();
if (Init == 0) return 0;
}
VarNames.push_back(std::make_pair(Name, Init));
// End of var list, exit loop.
if (CurTok != ',') break;
getNextToken(); // eat the ','.
if (CurTok != tok_identifier)
return Error("expected identifier list after var");
}
// At this point, we have to have 'in'.
if (CurTok != tok_in)
return Error("expected 'in' keyword after 'var'");
getNextToken(); // eat 'in'.
ExprAST *Body = ParseExpression();
if (Body == 0) return 0;
return new VarExprAST(VarNames, Body);
}
@ -457,7 +457,7 @@ static ExprAST *ParseUnary() {
// If the current token is not an operator, it must be a primary expr.
if (!isascii(CurTok) || CurTok == '(' || CurTok == ',')
return ParsePrimary();
// If this is a unary operator, read it.
int Opc = CurTok;
getNextToken();
@ -472,20 +472,20 @@ static ExprAST *ParseBinOpRHS(int ExprPrec, ExprAST *LHS) {
// If this is a binop, find its precedence.
while (1) {
int TokPrec = GetTokPrecedence();
// If this is a binop that binds at least as tightly as the current binop,
// consume it, otherwise we are done.
if (TokPrec < ExprPrec)
return LHS;
// Okay, we know this is a binop.
int BinOp = CurTok;
getNextToken(); // eat binop
// Parse the unary expression after the binary operator.
ExprAST *RHS = ParseUnary();
if (!RHS) return 0;
// If BinOp binds less tightly with RHS than the operator after RHS, let
// the pending operator take RHS as its LHS.
int NextPrec = GetTokPrecedence();
@ -493,7 +493,7 @@ static ExprAST *ParseBinOpRHS(int ExprPrec, ExprAST *LHS) {
RHS = ParseBinOpRHS(TokPrec+1, RHS);
if (RHS == 0) return 0;
}
// Merge LHS/RHS.
LHS = new BinaryExprAST(BinOp, LHS, RHS);
}
@ -505,7 +505,7 @@ static ExprAST *ParseBinOpRHS(int ExprPrec, ExprAST *LHS) {
static ExprAST *ParseExpression() {
ExprAST *LHS = ParseUnary();
if (!LHS) return 0;
return ParseBinOpRHS(0, LHS);
}
@ -515,10 +515,10 @@ static ExprAST *ParseExpression() {
/// ::= unary LETTER (id)
static PrototypeAST *ParsePrototype() {
std::string FnName;
unsigned Kind = 0; // 0 = identifier, 1 = unary, 2 = binary.
unsigned BinaryPrecedence = 30;
switch (CurTok) {
default:
return ErrorP("Expected function name in prototype");
@ -544,7 +544,7 @@ static PrototypeAST *ParsePrototype() {
FnName += (char)CurTok;
Kind = 2;
getNextToken();
// Read the precedence if present.
if (CurTok == tok_number) {
if (NumVal < 1 || NumVal > 100)
@ -554,23 +554,23 @@ static PrototypeAST *ParsePrototype() {
}
break;
}
if (CurTok != '(')
return ErrorP("Expected '(' in prototype");
std::vector<std::string> ArgNames;
while (getNextToken() == tok_identifier)
ArgNames.push_back(IdentifierStr);
if (CurTok != ')')
return ErrorP("Expected ')' in prototype");
// success.
getNextToken(); // eat ')'.
// Verify right number of names for operator.
if (Kind && ArgNames.size() != Kind)
return ErrorP("Invalid number of operands for operator");
return new PrototypeAST(FnName, ArgNames, Kind != 0, BinaryPrecedence);
}
@ -670,14 +670,14 @@ private:
class HelpingMemoryManager : public SectionMemoryManager
{
HelpingMemoryManager(const HelpingMemoryManager&) LLVM_DELETED_FUNCTION;
void operator=(const HelpingMemoryManager&) LLVM_DELETED_FUNCTION;
HelpingMemoryManager(const HelpingMemoryManager&) = delete;
void operator=(const HelpingMemoryManager&) = delete;
public:
HelpingMemoryManager(MCJITHelper *Helper) : MasterHelper(Helper) {}
virtual ~HelpingMemoryManager() {}
/// This method returns the address of the specified function.
/// This method returns the address of the specified function.
/// Our implementation will attempt to find functions in other
/// modules associated with the MCJITHelper to cross link functions
/// from one generated module to another.
@ -739,9 +739,9 @@ Function *MCJITHelper::getFunction(const std::string FnName) {
// If we don't have a prototype yet, create one.
if (!PF)
PF = Function::Create(F->getFunctionType(),
Function::ExternalLinkage,
FnName,
PF = Function::Create(F->getFunctionType(),
Function::ExternalLinkage,
FnName,
OpenModule);
return PF;
}
@ -885,11 +885,11 @@ Value *VariableExprAST::Codegen() {
Value *UnaryExprAST::Codegen() {
Value *OperandV = Operand->Codegen();
if (OperandV == 0) return 0;
Function *F = TheHelper->getFunction(MakeLegalFunctionName(std::string("unary")+Opcode));
if (F == 0)
return ErrorV("Unknown unary operator");
return Builder.CreateCall(F, OperandV, "unop");
}
@ -911,11 +911,11 @@ Value *BinaryExprAST::Codegen() {
Builder.CreateStore(Val, Variable);
return Val;
}
Value *L = LHS->Codegen();
Value *R = RHS->Codegen();
if (L == 0 || R == 0) return 0;
switch (Op) {
case '+': return Builder.CreateFAdd(L, R, "addtmp");
case '-': return Builder.CreateFSub(L, R, "subtmp");
@ -928,12 +928,12 @@ Value *BinaryExprAST::Codegen() {
"booltmp");
default: break;
}
// If it wasn't a builtin binary operator, it must be a user defined one. Emit
// a call to it.
Function *F = TheHelper->getFunction(MakeLegalFunctionName(std::string("binary")+Op));
assert(F && "binary operator not found!");
Value *Ops[] = { L, R };
return Builder.CreateCall(F, Ops, "binop");
}
@ -943,7 +943,7 @@ Value *CallExprAST::Codegen() {
Function *CalleeF = TheHelper->getFunction(Callee);
if (CalleeF == 0)
return ErrorV("Unknown function referenced");
// If argument mismatch error.
if (CalleeF->arg_size() != Args.size())
return ErrorV("Incorrect # arguments passed");
@ -953,56 +953,56 @@ Value *CallExprAST::Codegen() {
ArgsV.push_back(Args[i]->Codegen());
if (ArgsV.back() == 0) return 0;
}
return Builder.CreateCall(CalleeF, ArgsV, "calltmp");
}
Value *IfExprAST::Codegen() {
Value *CondV = Cond->Codegen();
if (CondV == 0) return 0;
// Convert condition to a bool by comparing equal to 0.0.
CondV = Builder.CreateFCmpONE(CondV,
CondV = Builder.CreateFCmpONE(CondV,
ConstantFP::get(getGlobalContext(), APFloat(0.0)),
"ifcond");
Function *TheFunction = Builder.GetInsertBlock()->getParent();
// Create blocks for the then and else cases. Insert the 'then' block at the
// end of the function.
BasicBlock *ThenBB = BasicBlock::Create(getGlobalContext(), "then", TheFunction);
BasicBlock *ElseBB = BasicBlock::Create(getGlobalContext(), "else");
BasicBlock *MergeBB = BasicBlock::Create(getGlobalContext(), "ifcont");
Builder.CreateCondBr(CondV, ThenBB, ElseBB);
// Emit then value.
Builder.SetInsertPoint(ThenBB);
Value *ThenV = Then->Codegen();
if (ThenV == 0) return 0;
Builder.CreateBr(MergeBB);
// Codegen of 'Then' can change the current block, update ThenBB for the PHI.
ThenBB = Builder.GetInsertBlock();
// Emit else block.
TheFunction->getBasicBlockList().push_back(ElseBB);
Builder.SetInsertPoint(ElseBB);
Value *ElseV = Else->Codegen();
if (ElseV == 0) return 0;
Builder.CreateBr(MergeBB);
// Codegen of 'Else' can change the current block, update ElseBB for the PHI.
ElseBB = Builder.GetInsertBlock();
// Emit merge block.
TheFunction->getBasicBlockList().push_back(MergeBB);
Builder.SetInsertPoint(MergeBB);
PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2,
"iftmp");
PN->addIncoming(ThenV, ThenBB);
PN->addIncoming(ElseV, ElseBB);
return PN;
@ -1015,7 +1015,7 @@ Value *ForExprAST::Codegen() {
// start = startexpr
// store start -> var
// goto loop
// loop:
// loop:
// ...
// bodyexpr
// ...
@ -1028,40 +1028,40 @@ Value *ForExprAST::Codegen() {
// store nextvar -> var
// br endcond, loop, endloop
// outloop:
Function *TheFunction = Builder.GetInsertBlock()->getParent();
// Create an alloca for the variable in the entry block.
AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, VarName);
// Emit the start code first, without 'variable' in scope.
Value *StartVal = Start->Codegen();
if (StartVal == 0) return 0;
// Store the value into the alloca.
Builder.CreateStore(StartVal, Alloca);
// Make the new basic block for the loop header, inserting after current
// block.
BasicBlock *LoopBB = BasicBlock::Create(getGlobalContext(), "loop", TheFunction);
// Insert an explicit fall through from the current block to the LoopBB.
Builder.CreateBr(LoopBB);
// Start insertion in LoopBB.
Builder.SetInsertPoint(LoopBB);
// Within the loop, the variable is defined equal to the PHI node. If it
// shadows an existing variable, we have to restore it, so save it now.
AllocaInst *OldVal = NamedValues[VarName];
NamedValues[VarName] = Alloca;
// Emit the body of the loop. This, like any other expr, can change the
// current BB. Note that we ignore the value computed by the body, but don't
// allow an error.
if (Body->Codegen() == 0)
return 0;
// Emit the step value.
Value *StepVal;
if (Step) {
@ -1071,52 +1071,52 @@ Value *ForExprAST::Codegen() {
// If not specified, use 1.0.
StepVal = ConstantFP::get(getGlobalContext(), APFloat(1.0));
}
// Compute the end condition.
Value *EndCond = End->Codegen();
if (EndCond == 0) return EndCond;
// Reload, increment, and restore the alloca. This handles the case where
// the body of the loop mutates the variable.
Value *CurVar = Builder.CreateLoad(Alloca, VarName.c_str());
Value *NextVar = Builder.CreateFAdd(CurVar, StepVal, "nextvar");
Builder.CreateStore(NextVar, Alloca);
// Convert condition to a bool by comparing equal to 0.0.
EndCond = Builder.CreateFCmpONE(EndCond,
EndCond = Builder.CreateFCmpONE(EndCond,
ConstantFP::get(getGlobalContext(), APFloat(0.0)),
"loopcond");
// Create the "after loop" block and insert it.
BasicBlock *AfterBB = BasicBlock::Create(getGlobalContext(), "afterloop", TheFunction);
// Insert the conditional branch into the end of LoopEndBB.
Builder.CreateCondBr(EndCond, LoopBB, AfterBB);
// Any new code will be inserted in AfterBB.
Builder.SetInsertPoint(AfterBB);
// Restore the unshadowed variable.
if (OldVal)
NamedValues[VarName] = OldVal;
else
NamedValues.erase(VarName);
// for expr always returns 0.0.
return Constant::getNullValue(Type::getDoubleTy(getGlobalContext()));
}
Value *VarExprAST::Codegen() {
std::vector<AllocaInst *> OldBindings;
Function *TheFunction = Builder.GetInsertBlock()->getParent();
// Register all variables and emit their initializer.
for (unsigned i = 0, e = VarNames.size(); i != e; ++i) {
const std::string &VarName = VarNames[i].first;
ExprAST *Init = VarNames[i].second;
// Emit the initializer before adding the variable to scope, this prevents
// the initializer from referencing the variable itself, and permits stuff
// like this:
@ -1129,22 +1129,22 @@ Value *VarExprAST::Codegen() {
} else { // If not specified, use 0.0.
InitVal = ConstantFP::get(getGlobalContext(), APFloat(0.0));
}
AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, VarName);
Builder.CreateStore(InitVal, Alloca);
// Remember the old variable binding so that we can restore the binding when
// we unrecurse.
OldBindings.push_back(NamedValues[VarName]);
// Remember this binding.
NamedValues[VarName] = Alloca;
}
// Codegen the body, now that all vars are in scope.
Value *BodyVal = Body->Codegen();
if (BodyVal == 0) return 0;
// Pop all our variables from scope.
for (unsigned i = 0, e = VarNames.size(); i != e; ++i)
NamedValues[VarNames[i].first] = OldBindings[i];
@ -1155,7 +1155,7 @@ Value *VarExprAST::Codegen() {
Function *PrototypeAST::Codegen() {
// Make the function type: double(double,double) etc.
std::vector<Type*> Doubles(Args.size(),
std::vector<Type*> Doubles(Args.size(),
Type::getDoubleTy(getGlobalContext()));
FunctionType *FT = FunctionType::get(Type::getDoubleTy(getGlobalContext()),
Doubles, false);
@ -1172,26 +1172,26 @@ Function *PrototypeAST::Codegen() {
// Delete the one we just made and get the existing one.
F->eraseFromParent();
F = M->getFunction(Name);
// If F already has a body, reject this.
if (!F->empty()) {
ErrorF("redefinition of function");
return 0;
}
// If F took a different number of args, reject.
if (F->arg_size() != Args.size()) {
ErrorF("redefinition of function with different # args");
return 0;
}
}
// Set names for all arguments.
unsigned Idx = 0;
for (Function::arg_iterator AI = F->arg_begin(); Idx != Args.size();
++AI, ++Idx)
AI->setName(Args[Idx]);
return F;
}
@ -1213,19 +1213,19 @@ void PrototypeAST::CreateArgumentAllocas(Function *F) {
Function *FunctionAST::Codegen() {
NamedValues.clear();
Function *TheFunction = Proto->Codegen();
if (TheFunction == 0)
return 0;
// If this is an operator, install it.
if (Proto->isBinaryOp())
BinopPrecedence[Proto->getOperatorName()] = Proto->getBinaryPrecedence();
// Create a new basic block to start insertion into.
BasicBlock *BB = BasicBlock::Create(getGlobalContext(), "entry", TheFunction);
Builder.SetInsertPoint(BB);
// Add all arguments to the symbol table and create their allocas.
Proto->CreateArgumentAllocas(TheFunction);
@ -1238,7 +1238,7 @@ Function *FunctionAST::Codegen() {
return TheFunction;
}
// Error reading body, remove function.
TheFunction->eraseFromParent();
@ -1285,7 +1285,7 @@ static void HandleTopLevelExpression() {
if (Function *LF = F->Codegen()) {
// JIT the function, returning a function pointer.
void *FPtr = TheHelper->getPointerToFunction(LF);
// Cast it to the right type (takes no arguments, returns a double) so we
// can call it as a native function.
double (*FP)() = (double (*)())(intptr_t)FPtr;
@ -1322,20 +1322,20 @@ static void MainLoop() {
//===----------------------------------------------------------------------===//
/// putchard - putchar that takes a double and returns 0.
extern "C"
extern "C"
double putchard(double X) {
putchar((char)X);
return 0;
}
/// printd - printf that takes a double prints it as "%f\n", returning 0.
extern "C"
extern "C"
double printd(double X) {
printf("%f", X);
return 0;
}
extern "C"
extern "C"
double printlf() {
printf("\n");
return 0;

246
examples/Kaleidoscope/MCJIT/lazy/toy.cpp
View File

@ -34,14 +34,14 @@ enum Token {
// primary
tok_identifier = -4, tok_number = -5,
// control
tok_if = -6, tok_then = -7, tok_else = -8,
tok_for = -9, tok_in = -10,
// operators
tok_binary = -11, tok_unary = -12,
// var definition
tok_var = -13
};
@ -90,11 +90,11 @@ static int gettok() {
// Comment until end of line.
do LastChar = getchar();
while (LastChar != EOF && LastChar != '\n' && LastChar != '\r');
if (LastChar != EOF)
return gettok();
}
// Check for end of file. Don't eat the EOF.
if (LastChar == EOF)
return tok_eof;
@ -138,7 +138,7 @@ class UnaryExprAST : public ExprAST {
char Opcode;
ExprAST *Operand;
public:
UnaryExprAST(char opcode, ExprAST *operand)
UnaryExprAST(char opcode, ExprAST *operand)
: Opcode(opcode), Operand(operand) {}
virtual Value *Codegen();
};
@ -148,7 +148,7 @@ class BinaryExprAST : public ExprAST {
char Op;
ExprAST *LHS, *RHS;
public:
BinaryExprAST(char op, ExprAST *lhs, ExprAST *rhs)
BinaryExprAST(char op, ExprAST *lhs, ExprAST *rhs)
: Op(op), LHS(lhs), RHS(rhs) {}
virtual Value *Codegen();
};
@ -191,7 +191,7 @@ public:
VarExprAST(const std::vector<std::pair<std::string, ExprAST*> > &varnames,
ExprAST *body)
: VarNames(varnames), Body(body) {}
virtual Value *Codegen();
};
@ -206,19 +206,19 @@ public:
PrototypeAST(const std::string &name, const std::vector<std::string> &args,
bool isoperator = false, unsigned prec = 0)
: Name(name), Args(args), isOperator(isoperator), Precedence(prec) {}
bool isUnaryOp() const { return isOperator && Args.size() == 1; }
bool isBinaryOp() const { return isOperator && Args.size() == 2; }
char getOperatorName() const {
assert(isUnaryOp() || isBinaryOp());
return Name[Name.size()-1];
}
unsigned getBinaryPrecedence() const { return Precedence; }
Function *Codegen();
void CreateArgumentAllocas(Function *F);
};
@ -229,7 +229,7 @@ class FunctionAST {
public:
FunctionAST(PrototypeAST *proto, ExprAST *body)
: Proto(proto), Body(body) {}
Function *Codegen();
};
@ -253,7 +253,7 @@ static std::map<char, int> BinopPrecedence;
static int GetTokPrecedence() {
if (!isascii(CurTok))
return -1;
// Make sure it's a declared binop.
int TokPrec = BinopPrecedence[CurTok];
if (TokPrec <= 0) return -1;
@ -272,12 +272,12 @@ static ExprAST *ParseExpression();
/// ::= identifier '(' expression* ')'
static ExprAST *ParseIdentifierExpr() {
std::string IdName = IdentifierStr;
getNextToken(); // eat identifier.
if (CurTok != '(') // Simple variable ref.
return new VariableExprAST(IdName);
// Call.
getNextToken(); // eat (
std::vector<ExprAST*> Args;
@ -297,7 +297,7 @@ static ExprAST *ParseIdentifierExpr() {
// Eat the ')'.
getNextToken();
return new CallExprAST(IdName, Args);
}
@ -313,7 +313,7 @@ static ExprAST *ParseParenExpr() {
getNextToken(); // eat (.
ExprAST *V = ParseExpression();
if (!V) return 0;
if (CurTok != ')')
return Error("expected ')'");
getNextToken(); // eat ).
@ -323,26 +323,26 @@ static ExprAST *ParseParenExpr() {
/// ifexpr ::= 'if' expression 'then' expression 'else' expression
static ExprAST *ParseIfExpr() {
getNextToken(); // eat the if.
// condition.
ExprAST *Cond = ParseExpression();
if (!Cond) return 0;
if (CurTok != tok_then)
return Error("expected then");
getNextToken(); // eat the then
ExprAST *Then = ParseExpression();
if (Then == 0) return 0;
if (CurTok != tok_else)
return Error("expected else");
getNextToken();
ExprAST *Else = ParseExpression();
if (!Else) return 0;
return new IfExprAST(Cond, Then, Else);
}
@ -352,24 +352,24 @@ static ExprAST *ParseForExpr() {
if (CurTok != tok_identifier)
return Error("expected identifier after for");
std::string IdName = IdentifierStr;
getNextToken(); // eat identifier.
if (CurTok != '=')
return Error("expected '=' after for");
getNextToken(); // eat '='.
ExprAST *Start = ParseExpression();
if (Start == 0) return 0;
if (CurTok != ',')
return Error("expected ',' after for start value");
getNextToken();
ExprAST *End = ParseExpression();
if (End == 0) return 0;
// The step value is optional.
ExprAST *Step = 0;
if (CurTok == ',') {
@ -377,18 +377,18 @@ static ExprAST *ParseForExpr() {
Step = ParseExpression();
if (Step == 0) return 0;
}
if (CurTok != tok_in)
return Error("expected 'in' after for");
getNextToken(); // eat 'in'.
ExprAST *Body = ParseExpression();
if (Body == 0) return 0;
return new ForExprAST(IdName, Start, End, Step, Body);
}
/// varexpr ::= 'var' identifier ('=' expression)?
/// varexpr ::= 'var' identifier ('=' expression)?
// (',' identifier ('=' expression)?)* 'in' expression
static ExprAST *ParseVarExpr() {
getNextToken(); // eat the var.
@ -398,7 +398,7 @@ static ExprAST *ParseVarExpr() {
// At least one variable name is required.
if (CurTok != tok_identifier)
return Error("expected identifier after var");
while (1) {
std::string Name = IdentifierStr;
getNextToken(); // eat identifier.
@ -407,29 +407,29 @@ static ExprAST *ParseVarExpr() {
ExprAST *Init = 0;
if (CurTok == '=') {
getNextToken(); // eat the '='.
Init = ParseExpression();
if (Init == 0) return 0;
}
VarNames.push_back(std::make_pair(Name, Init));
// End of var list, exit loop.
if (CurTok != ',') break;
getNextToken(); // eat the ','.
if (CurTok != tok_identifier)
return Error("expected identifier list after var");
}
// At this point, we have to have 'in'.
if (CurTok != tok_in)
return Error("expected 'in' keyword after 'var'");
getNextToken(); // eat 'in'.
ExprAST *Body = ParseExpression();
if (Body == 0) return 0;
return new VarExprAST(VarNames, Body);
}
@ -459,7 +459,7 @@ static ExprAST *ParseUnary() {
// If the current token is not an operator, it must be a primary expr.
if (!isascii(CurTok) || CurTok == '(' || CurTok == ',')
return ParsePrimary();
// If this is a unary operator, read it.
int Opc = CurTok;
getNextToken();
@ -474,20 +474,20 @@ static ExprAST *ParseBinOpRHS(int ExprPrec, ExprAST *LHS) {
// If this is a binop, find its precedence.
while (1) {
int TokPrec = GetTokPrecedence();
// If this is a binop that binds at least as tightly as the current binop,
// consume it, otherwise we are done.
if (TokPrec < ExprPrec)
return LHS;
// Okay, we know this is a binop.
int BinOp = CurTok;
getNextToken(); // eat binop
// Parse the unary expression after the binary operator.
ExprAST *RHS = ParseUnary();
if (!RHS) return 0;
// If BinOp binds less tightly with RHS than the operator after RHS, let
// the pending operator take RHS as its LHS.
int NextPrec = GetTokPrecedence();
@ -495,7 +495,7 @@ static ExprAST *ParseBinOpRHS(int ExprPrec, ExprAST *LHS) {
RHS = ParseBinOpRHS(TokPrec+1, RHS);
if (RHS == 0) return 0;
}
// Merge LHS/RHS.
LHS = new BinaryExprAST(BinOp, LHS, RHS);
}
@ -507,7 +507,7 @@ static ExprAST *ParseBinOpRHS(int ExprPrec, ExprAST *LHS) {
static ExprAST *ParseExpression() {
ExprAST *LHS = ParseUnary();
if (!LHS) return 0;
return ParseBinOpRHS(0, LHS);
}
@ -517,10 +517,10 @@ static ExprAST *ParseExpression() {
/// ::= unary LETTER (id)
static PrototypeAST *ParsePrototype() {
std::string FnName;
unsigned Kind = 0; // 0 = identifier, 1 = unary, 2 = binary.
unsigned BinaryPrecedence = 30;
switch (CurTok) {
default:
return ErrorP("Expected function name in prototype");
@ -546,7 +546,7 @@ static PrototypeAST *ParsePrototype() {
FnName += (char)CurTok;
Kind = 2;
getNextToken();
// Read the precedence if present.
if (CurTok == tok_number) {
if (NumVal < 1 || NumVal > 100)
@ -556,23 +556,23 @@ static PrototypeAST *ParsePrototype() {
}
break;
}
if (CurTok != '(')
return ErrorP("Expected '(' in prototype");
std::vector<std::string> ArgNames;
while (getNextToken() == tok_identifier)
ArgNames.push_back(IdentifierStr);
if (CurTok != ')')
return ErrorP("Expected ')' in prototype");
// success.
getNextToken(); // eat ')'.
// Verify right number of names for operator.
if (Kind && ArgNames.size() != Kind)
return ErrorP("Invalid number of operands for operator");
return new PrototypeAST(FnName, ArgNames, Kind != 0, BinaryPrecedence);
}
@ -673,14 +673,14 @@ private:
class HelpingMemoryManager : public SectionMemoryManager
{
HelpingMemoryManager(const HelpingMemoryManager&) LLVM_DELETED_FUNCTION;
void operator=(const HelpingMemoryManager&) LLVM_DELETED_FUNCTION;
HelpingMemoryManager(const HelpingMemoryManager&) = delete;
void operator=(const HelpingMemoryManager&) = delete;
public:
HelpingMemoryManager(MCJITHelper *Helper) : MasterHelper(Helper) {}
virtual ~HelpingMemoryManager() {}
/// This method returns the address of the specified function.
/// This method returns the address of the specified function.
/// Our implementation will attempt to find functions in other
/// modules associated with the MCJITHelper to cross link functions
/// from one generated module to another.
@ -749,9 +749,9 @@ Function *MCJITHelper::getFunction(const std::string FnName) {
// If we don't have a prototype yet, create one.
if (!PF)
PF = Function::Create(F->getFunctionType(),
Function::ExternalLinkage,
FnName,
PF = Function::Create(F->getFunctionType(),
Function::ExternalLinkage,
FnName,
OpenModule);
return PF;
}
@ -925,11 +925,11 @@ Value *VariableExprAST::Codegen() {
Value *UnaryExprAST::Codegen() {
Value *OperandV = Operand->Codegen();
if (OperandV == 0) return 0;
Function *F = TheHelper->getFunction(MakeLegalFunctionName(std::string("unary")+Opcode));
if (F == 0)
return ErrorV("Unknown unary operator");
return Builder.CreateCall(F, OperandV, "unop");
}
@ -951,11 +951,11 @@ Value *BinaryExprAST::Codegen() {
Builder.CreateStore(Val, Variable);
return Val;
}
Value *L = LHS->Codegen();
Value *R = RHS->Codegen();
if (L == 0 || R == 0) return 0;
switch (Op) {
case '+': return Builder.CreateFAdd(L, R, "addtmp");
case '-': return Builder.CreateFSub(L, R, "subtmp");
@ -968,12 +968,12 @@ Value *BinaryExprAST::Codegen() {
"booltmp");
default: break;
}
// If it wasn't a builtin binary operator, it must be a user defined one. Emit
// a call to it.
Function *F = TheHelper->getFunction(MakeLegalFunctionName(std::string("binary")+Op));
assert(F && "binary operator not found!");
Value *Ops[] = { L, R };
return Builder.CreateCall(F, Ops, "binop");
}
@ -983,7 +983,7 @@ Value *CallExprAST::Codegen() {
Function *CalleeF = TheHelper->getFunction(Callee);
if (CalleeF == 0)
return ErrorV("Unknown function referenced");
// If argument mismatch error.
if (CalleeF->arg_size() != Args.size())
return ErrorV("Incorrect # arguments passed");
@ -993,56 +993,56 @@ Value *CallExprAST::Codegen() {
ArgsV.push_back(Args[i]->Codegen());
if (ArgsV.back() == 0) return 0;
}
return Builder.CreateCall(CalleeF, ArgsV, "calltmp");
}
Value *IfExprAST::Codegen() {
Value *CondV = Cond->Codegen();
if (CondV == 0) return 0;
// Convert condition to a bool by comparing equal to 0.0.
CondV = Builder.CreateFCmpONE(CondV,
CondV = Builder.CreateFCmpONE(CondV,
ConstantFP::get(getGlobalContext(), APFloat(0.0)),
"ifcond");
Function *TheFunction = Builder.GetInsertBlock()->getParent();
// Create blocks for the then and else cases. Insert the 'then' block at the
// end of the function.
BasicBlock *ThenBB = BasicBlock::Create(getGlobalContext(), "then", TheFunction);
BasicBlock *ElseBB = BasicBlock::Create(getGlobalContext(), "else");
BasicBlock *MergeBB = BasicBlock::Create(getGlobalContext(), "ifcont");
Builder.CreateCondBr(CondV, ThenBB, ElseBB);
// Emit then value.
Builder.SetInsertPoint(ThenBB);
Value *ThenV = Then->Codegen();
if (ThenV == 0) return 0;
Builder.CreateBr(MergeBB);
// Codegen of 'Then' can change the current block, update ThenBB for the PHI.
ThenBB = Builder.GetInsertBlock();
// Emit else block.
TheFunction->getBasicBlockList().push_back(ElseBB);
Builder.SetInsertPoint(ElseBB);
Value *ElseV = Else->Codegen();
if (ElseV == 0) return 0;
Builder.CreateBr(MergeBB);
// Codegen of 'Else' can change the current block, update ElseBB for the PHI.
ElseBB = Builder.GetInsertBlock();
// Emit merge block.
TheFunction->getBasicBlockList().push_back(MergeBB);
Builder.SetInsertPoint(MergeBB);
PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2,
"iftmp");
PN->addIncoming(ThenV, ThenBB);
PN->addIncoming(ElseV, ElseBB);
return PN;
@ -1055,7 +1055,7 @@ Value *ForExprAST::Codegen() {
// start = startexpr
// store start -> var
// goto loop
// loop:
// loop:
// ...
// bodyexpr
// ...
@ -1068,40 +1068,40 @@ Value *ForExprAST::Codegen() {
// store nextvar -> var
// br endcond, loop, endloop
// outloop:
Function *TheFunction = Builder.GetInsertBlock()->getParent();
// Create an alloca for the variable in the entry block.
AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, VarName);
// Emit the start code first, without 'variable' in scope.
Value *StartVal = Start->Codegen();
if (StartVal == 0) return 0;
// Store the value into the alloca.
Builder.CreateStore(StartVal, Alloca);
// Make the new basic block for the loop header, inserting after current
// block.
BasicBlock *LoopBB = BasicBlock::Create(getGlobalContext(), "loop", TheFunction);
// Insert an explicit fall through from the current block to the LoopBB.
Builder.CreateBr(LoopBB);
// Start insertion in LoopBB.
Builder.SetInsertPoint(LoopBB);
// Within the loop, the variable is defined equal to the PHI node. If it
// shadows an existing variable, we have to restore it, so save it now.
AllocaInst *OldVal = NamedValues[VarName];
NamedValues[VarName] = Alloca;
// Emit the body of the loop. This, like any other expr, can change the
// current BB. Note that we ignore the value computed by the body, but don't
// allow an error.
if (Body->Codegen() == 0)
return 0;
// Emit the step value.
Value *StepVal;
if (Step) {
@ -1111,52 +1111,52 @@ Value *ForExprAST::Codegen() {
// If not specified, use 1.0.
StepVal = ConstantFP::get(getGlobalContext(), APFloat(1.0));
}
// Compute the end condition.
Value *EndCond = End->Codegen();
if (EndCond == 0) return EndCond;
// Reload, increment, and restore the alloca. This handles the case where
// the body of the loop mutates the variable.
Value *CurVar = Builder.CreateLoad(Alloca, VarName.c_str());
Value *NextVar = Builder.CreateFAdd(CurVar, StepVal, "nextvar");
Builder.CreateStore(NextVar, Alloca);
// Convert condition to a bool by comparing equal to 0.0.
EndCond = Builder.CreateFCmpONE(EndCond,
EndCond = Builder.CreateFCmpONE(EndCond,
ConstantFP::get(getGlobalContext(), APFloat(0.0)),
"loopcond");
// Create the "after loop" block and insert it.
BasicBlock *AfterBB = BasicBlock::Create(getGlobalContext(), "afterloop", TheFunction);
// Insert the conditional branch into the end of LoopEndBB.
Builder.CreateCondBr(EndCond, LoopBB, AfterBB);
// Any new code will be inserted in AfterBB.
Builder.SetInsertPoint(AfterBB);
// Restore the unshadowed variable.
if (OldVal)
NamedValues[VarName] = OldVal;
else
NamedValues.erase(VarName);
// for expr always returns 0.0.
return Constant::getNullValue(Type::getDoubleTy(getGlobalContext()));
}
Value *VarExprAST::Codegen() {
std::vector<AllocaInst *> OldBindings;
Function *TheFunction = Builder.GetInsertBlock()->getParent();
// Register all variables and emit their initializer.
for (unsigned i = 0, e = VarNames.size(); i != e; ++i) {
const std::string &VarName = VarNames[i].first;
ExprAST *Init = VarNames[i].second;
// Emit the initializer before adding the variable to scope, this prevents
// the initializer from referencing the variable itself, and permits stuff
// like this:
@ -1169,22 +1169,22 @@ Value *VarExprAST::Codegen() {
} else { // If not specified, use 0.0.
InitVal = ConstantFP::get(getGlobalContext(), APFloat(0.0));
}
AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, VarName);
Builder.CreateStore(InitVal, Alloca);
// Remember the old variable binding so that we can restore the binding when
// we unrecurse.
OldBindings.push_back(NamedValues[VarName]);
// Remember this binding.
NamedValues[VarName] = Alloca;
}
// Codegen the body, now that all vars are in scope.
Value *BodyVal = Body->Codegen();
if (BodyVal == 0) return 0;
// Pop all our variables from scope.
for (unsigned i = 0, e = VarNames.size(); i != e; ++i)
NamedValues[VarNames[i].first] = OldBindings[i];
@ -1195,7 +1195,7 @@ Value *VarExprAST::Codegen() {
Function *PrototypeAST::Codegen() {
// Make the function type: double(double,double) etc.
std::vector<Type*> Doubles(Args.size(),
std::vector<Type*> Doubles(Args.size(),
Type::getDoubleTy(getGlobalContext()));
FunctionType *FT = FunctionType::get(Type::getDoubleTy(getGlobalContext()),
Doubles, false);
@ -1212,26 +1212,26 @@ Function *PrototypeAST::Codegen() {
// Delete the one we just made and get the existing one.
F->eraseFromParent();
F = M->getFunction(Name);
// If F already has a body, reject this.
if (!F->empty()) {
ErrorF("redefinition of function");
return 0;
}
// If F took a different number of args, reject.
if (F->arg_size() != Args.size()) {
ErrorF("redefinition of function with different # args");
return 0;
}
}
// Set names for all arguments.
unsigned Idx = 0;
for (Function::arg_iterator AI = F->arg_begin(); Idx != Args.size();
++AI, ++Idx)
AI->setName(Args[Idx]);
return F;
}
@ -1253,19 +1253,19 @@ void PrototypeAST::CreateArgumentAllocas(Function *F) {
Function *FunctionAST::Codegen() {
NamedValues.clear();
Function *TheFunction = Proto->Codegen();
if (TheFunction == 0)
return 0;
// If this is an operator, install it.
if (Proto->isBinaryOp())
BinopPrecedence[Proto->getOperatorName()] = Proto->getBinaryPrecedence();
// Create a new basic block to start insertion into.
BasicBlock *BB = BasicBlock::Create(getGlobalContext(), "entry", TheFunction);
Builder.SetInsertPoint(BB);
// Add all arguments to the symbol table and create their allocas.
Proto->CreateArgumentAllocas(TheFunction);
@ -1326,7 +1326,7 @@ static void HandleTopLevelExpression() {
if (Function *LF = F->Codegen()) {
// JIT the function, returning a function pointer.
void *FPtr = TheHelper->getPointerToFunction(LF);
// Cast it to the right type (takes no arguments, returns a double) so we
// can call it as a native function.
double (*FP)() = (double (*)())(intptr_t)FPtr;
@ -1363,20 +1363,20 @@ static void MainLoop() {
//===----------------------------------------------------------------------===//
/// putchard - putchar that takes a double and returns 0.
extern "C"
extern "C"
double putchard(double X) {
putchar((char)X);
return 0;
}
/// printd - printf that takes a double prints it as "%f\n", returning 0.
extern "C"
extern "C"
double printd(double X) {
printf("%f", X);
return 0;
}
extern "C"
extern "C"
double printlf() {
printf("\n");
return 0;

2
include/llvm/ADT/APFloat.h
View File

@ -376,7 +376,7 @@ public:
/// The definition of equality is not straightforward for floating point, so
/// we won't use operator==. Use one of the following, or write whatever it
/// is you really mean.
bool operator==(const APFloat &) const LLVM_DELETED_FUNCTION;
bool operator==(const APFloat &) const = delete;
/// IEEE comparison with another floating point number (NaNs compare
/// unordered, 0==-0).

4
include/llvm/ADT/ImmutableList.h
View File

@ -33,8 +33,8 @@ class ImmutableListImpl : public FoldingSetNode {
friend class ImmutableListFactory<T>;
void operator=(const ImmutableListImpl&) LLVM_DELETED_FUNCTION;
ImmutableListImpl(const ImmutableListImpl&) LLVM_DELETED_FUNCTION;
void operator=(const ImmutableListImpl&) = delete;
ImmutableListImpl(const ImmutableListImpl&) = delete;
public:
const T& getHead() const { return Head; }

4
include/llvm/ADT/ImmutableMap.h
View File

@ -122,8 +122,8 @@ public:
}
private:
Factory(const Factory& RHS) LLVM_DELETED_FUNCTION;
void operator=(const Factory& RHS) LLVM_DELETED_FUNCTION;
Factory(const Factory& RHS) = delete;
void operator=(const Factory& RHS) = delete;
};
bool contains(key_type_ref K) const {

4
include/llvm/ADT/ImmutableSet.h
View File

@ -1014,8 +1014,8 @@ public:
}
private:
Factory(const Factory& RHS) LLVM_DELETED_FUNCTION;
void operator=(const Factory& RHS) LLVM_DELETED_FUNCTION;
Factory(const Factory& RHS) = delete;
void operator=(const Factory& RHS) = delete;
};
friend class Factory;

2
include/llvm/ADT/STLExtras.h
View File

@ -340,7 +340,7 @@ make_unique(size_t n) {
/// This function isn't used and is only here to provide better compile errors.
template <class T, class... Args>
typename std::enable_if<std::extent<T>::value != 0>::type
make_unique(Args &&...) LLVM_DELETED_FUNCTION;
make_unique(Args &&...) = delete;
struct FreeDeleter {
void operator()(void* v) {

4
include/llvm/ADT/ScopedHashTable.h
View File

@ -90,8 +90,8 @@ class ScopedHashTableScope {
/// LastValInScope - This is the last value that was inserted for this scope
/// or null if none have been inserted yet.
ScopedHashTableVal<K, V> *LastValInScope;
void operator=(ScopedHashTableScope&) LLVM_DELETED_FUNCTION;
ScopedHashTableScope(ScopedHashTableScope&) LLVM_DELETED_FUNCTION;
void operator=(ScopedHashTableScope&) = delete;
ScopedHashTableScope(ScopedHashTableScope&) = delete;
public:
ScopedHashTableScope(ScopedHashTable<K, V, KInfo, AllocatorTy> &HT);
~ScopedHashTableScope();

4
include/llvm/ADT/SmallPtrSet.h
View File

@ -132,7 +132,7 @@ private:
/// Grow - Allocate a larger backing store for the buckets and move it over.
void Grow(unsigned NewSize);
void operator=(const SmallPtrSetImplBase &RHS) LLVM_DELETED_FUNCTION;
void operator=(const SmallPtrSetImplBase &RHS) = delete;
protected:
/// swap - Swaps the elements of two sets.
/// Note: This method assumes that both sets have the same small size.
@ -242,7 +242,7 @@ template <typename PtrType>
class SmallPtrSetImpl : public SmallPtrSetImplBase {
typedef PointerLikeTypeTraits<PtrType> PtrTraits;
SmallPtrSetImpl(const SmallPtrSetImpl&) LLVM_DELETED_FUNCTION;
SmallPtrSetImpl(const SmallPtrSetImpl&) = delete;
protected:
// Constructors that forward to the base.
SmallPtrSetImpl(const void **SmallStorage, const SmallPtrSetImpl &that)

2
include/llvm/ADT/SmallVector.h
View File

@ -343,7 +343,7 @@ template <typename T>
class SmallVectorImpl : public SmallVectorTemplateBase<T, isPodLike<T>::value> {
typedef SmallVectorTemplateBase<T, isPodLike<T>::value > SuperClass;
SmallVectorImpl(const SmallVectorImpl&) LLVM_DELETED_FUNCTION;
SmallVectorImpl(const SmallVectorImpl&) = delete;
public:
typedef typename SuperClass::iterator iterator;
typedef typename SuperClass::size_type size_type;

4
include/llvm/ADT/SparseMultiSet.h
View File

@ -133,8 +133,8 @@ class SparseMultiSet {
// Disable copy construction and assignment.
// This data structure is not meant to be used that way.
SparseMultiSet(const SparseMultiSet&) LLVM_DELETED_FUNCTION;
SparseMultiSet &operator=(const SparseMultiSet&) LLVM_DELETED_FUNCTION;
SparseMultiSet(const SparseMultiSet&) = delete;
SparseMultiSet &operator=(const SparseMultiSet&) = delete;
/// Whether the given entry is the head of the list. List heads's previous
/// pointers are to the tail of the list, allowing for efficient access to the

4
include/llvm/ADT/SparseSet.h
View File

@ -133,8 +133,8 @@ class SparseSet {
// Disable copy construction and assignment.
// This data structure is not meant to be used that way.
SparseSet(const SparseSet&) LLVM_DELETED_FUNCTION;
SparseSet &operator=(const SparseSet&) LLVM_DELETED_FUNCTION;
SparseSet(const SparseSet&) = delete;
SparseSet &operator=(const SparseSet&) = delete;
public:
typedef ValueT value_type;

2
include/llvm/ADT/StringMap.h
View File

@ -111,7 +111,7 @@ public:
/// and data.
template<typename ValueTy>
class StringMapEntry : public StringMapEntryBase {
StringMapEntry(StringMapEntry &E) LLVM_DELETED_FUNCTION;
StringMapEntry(StringMapEntry &E) = delete;
public:
ValueTy second;

2
include/llvm/ADT/Twine.h
View File

@ -182,7 +182,7 @@ namespace llvm {
/// Since the intended use of twines is as temporary objects, assignments
/// when concatenating might cause undefined behavior or stack corruptions
Twine &operator=(const Twine &Other) LLVM_DELETED_FUNCTION;
Twine &operator=(const Twine &Other) = delete;
/// isNull - Check for the null twine.
bool isNull() const {

12
include/llvm/ADT/ilist.h
View File

@ -237,14 +237,14 @@ public:
// These are to catch errors when people try to use them as random access
// iterators.
template<typename T>
void operator-(int, ilist_iterator<T>) LLVM_DELETED_FUNCTION;
void operator-(int, ilist_iterator<T>) = delete;
template<typename T>
void operator-(ilist_iterator<T>,int) LLVM_DELETED_FUNCTION;
void operator-(ilist_iterator<T>,int) = delete;
template<typename T>
void operator+(int, ilist_iterator<T>) LLVM_DELETED_FUNCTION;
void operator+(int, ilist_iterator<T>) = delete;
template<typename T>
void operator+(ilist_iterator<T>,int) LLVM_DELETED_FUNCTION;
void operator+(ilist_iterator<T>,int) = delete;
// operator!=/operator== - Allow mixed comparisons without dereferencing
// the iterator, which could very likely be pointing to end().
@ -332,8 +332,8 @@ class iplist : public Traits {
// No fundamental reason why iplist can't be copyable, but the default
// copy/copy-assign won't do.
iplist(const iplist &) LLVM_DELETED_FUNCTION;
void operator=(const iplist &) LLVM_DELETED_FUNCTION;
iplist(const iplist &) = delete;
void operator=(const iplist &) = delete;
public:
typedef NodeTy *pointer;

4
include/llvm/Analysis/AliasSetTracker.h
View File

@ -226,8 +226,8 @@ private:
AccessTy(NoModRef), AliasTy(MustAlias), Volatile(false) {
}
AliasSet(const AliasSet &AS) LLVM_DELETED_FUNCTION;
void operator=(const AliasSet &AS) LLVM_DELETED_FUNCTION;
AliasSet(const AliasSet &AS) = delete;
void operator=(const AliasSet &AS) = delete;
PointerRec *getSomePointer() const {
return PtrList;

4
include/llvm/Analysis/CallGraph.h
View File

@ -273,8 +273,8 @@ private:
/// CalledFunctions array of this or other CallGraphNodes.
unsigned NumReferences;
CallGraphNode(const CallGraphNode &) LLVM_DELETED_FUNCTION;
void operator=(const CallGraphNode &) LLVM_DELETED_FUNCTION;
CallGraphNode(const CallGraphNode &) = delete;
void operator=(const CallGraphNode &) = delete;
void DropRef() { --NumReferences; }
void AddRef() { ++NumReferences; }

4
include/llvm/Analysis/DependenceAnalysis.h
View File

@ -278,8 +278,8 @@ namespace llvm {
/// DependenceAnalysis - This class is the main dependence-analysis driver.
///
class DependenceAnalysis : public FunctionPass {
void operator=(const DependenceAnalysis &) LLVM_DELETED_FUNCTION;
DependenceAnalysis(const DependenceAnalysis &) LLVM_DELETED_FUNCTION;
void operator=(const DependenceAnalysis &) = delete;
DependenceAnalysis(const DependenceAnalysis &) = delete;
public:
/// depends - Tests for a dependence between the Src and Dst instructions.
/// Returns NULL if no dependence; otherwise, returns a Dependence (or a

4
include/llvm/Analysis/LazyValueInfo.h
View File

@ -33,8 +33,8 @@ class LazyValueInfo : public FunctionPass {
class TargetLibraryInfo *TLI;
DominatorTree *DT;
void *PImpl;
LazyValueInfo(const LazyValueInfo&) LLVM_DELETED_FUNCTION;
void operator=(const LazyValueInfo&) LLVM_DELETED_FUNCTION;
LazyValueInfo(const LazyValueInfo&) = delete;
void operator=(const LazyValueInfo&) = delete;
public:
static char ID;
LazyValueInfo() : FunctionPass(ID), PImpl(nullptr) {

12
include/llvm/Analysis/LoopInfo.h
View File

@ -79,9 +79,9 @@ class LoopBase {
SmallPtrSet<const BlockT*, 8> DenseBlockSet;
LoopBase(const LoopBase<BlockT, LoopT> &) LLVM_DELETED_FUNCTION;
LoopBase(const LoopBase<BlockT, LoopT> &) = delete;
const LoopBase<BlockT, LoopT>&
operator=(const LoopBase<BlockT, LoopT> &) LLVM_DELETED_FUNCTION;
operator=(const LoopBase<BlockT, LoopT> &) = delete;
public:
/// Loop ctor - This creates an empty loop.
LoopBase() : ParentLoop(nullptr) {}
@ -501,8 +501,8 @@ class LoopInfoBase {
friend class LoopBase<BlockT, LoopT>;
friend class LoopInfo;
void operator=(const LoopInfoBase &) LLVM_DELETED_FUNCTION;
LoopInfoBase(const LoopInfoBase &) LLVM_DELETED_FUNCTION;
void operator=(const LoopInfoBase &) = delete;
LoopInfoBase(const LoopInfoBase &) = delete;
public:
LoopInfoBase() { }
~LoopInfoBase() { releaseMemory(); }
@ -651,8 +651,8 @@ class LoopInfo : public LoopInfoBase<BasicBlock, Loop> {
friend class LoopBase<BasicBlock, Loop>;
void operator=(const LoopInfo &) LLVM_DELETED_FUNCTION;
LoopInfo(const LoopInfo &) LLVM_DELETED_FUNCTION;
void operator=(const LoopInfo &) = delete;
LoopInfo(const LoopInfo &) = delete;
public:
LoopInfo() {}

12
include/llvm/Analysis/RegionInfo.h
View File

@ -115,8 +115,8 @@ public:
typedef typename Tr::RegionT RegionT;
private:
RegionNodeBase(const RegionNodeBase &) LLVM_DELETED_FUNCTION;
const RegionNodeBase &operator=(const RegionNodeBase &) LLVM_DELETED_FUNCTION;
RegionNodeBase(const RegionNodeBase &) = delete;
const RegionNodeBase &operator=(const RegionNodeBase &) = delete;
/// This is the entry basic block that starts this region node. If this is a
/// BasicBlock RegionNode, then entry is just the basic block, that this
@ -261,8 +261,8 @@ class RegionBase : public RegionNodeBase<Tr> {
typedef typename InvBlockTraits::ChildIteratorType PredIterTy;
friend class RegionInfoBase<Tr>;
RegionBase(const RegionBase &) LLVM_DELETED_FUNCTION;
const RegionBase &operator=(const RegionBase &) LLVM_DELETED_FUNCTION;
RegionBase(const RegionBase &) = delete;
const RegionBase &operator=(const RegionBase &) = delete;
// Information necessary to manage this Region.
RegionInfoT *RI;
@ -674,8 +674,8 @@ class RegionInfoBase {
RegionInfoBase();
virtual ~RegionInfoBase();
RegionInfoBase(const RegionInfoBase &) LLVM_DELETED_FUNCTION;
const RegionInfoBase &operator=(const RegionInfoBase &) LLVM_DELETED_FUNCTION;
RegionInfoBase(const RegionInfoBase &) = delete;
const RegionInfoBase &operator=(const RegionInfoBase &) = delete;
DomTreeT *DT;
PostDomTreeT *PDT;

4
include/llvm/Analysis/ScalarEvolution.h
View File

@ -71,8 +71,8 @@ namespace llvm {
unsigned short SubclassData;
private:
SCEV(const SCEV &) LLVM_DELETED_FUNCTION;
void operator=(const SCEV &) LLVM_DELETED_FUNCTION;
SCEV(const SCEV &) = delete;
void operator=(const SCEV &) = delete;
public:
/// NoWrapFlags are bitfield indices into SubclassData.

4
include/llvm/Analysis/SparsePropagation.h
View File

@ -131,8 +131,8 @@ class SparseSolver {
typedef std::pair<BasicBlock*,BasicBlock*> Edge;
std::set<Edge> KnownFeasibleEdges;
SparseSolver(const SparseSolver&) LLVM_DELETED_FUNCTION;
void operator=(const SparseSolver&) LLVM_DELETED_FUNCTION;
SparseSolver(const SparseSolver&) = delete;
void operator=(const SparseSolver&) = delete;
public:
explicit SparseSolver(AbstractLatticeFunction *Lattice)
: LatticeFunc(Lattice) {}

4
include/llvm/Bitcode/BitstreamReader.h
View File

@ -50,8 +50,8 @@ private:
/// information in the BlockInfo block. Only llvm-bcanalyzer uses this.
bool IgnoreBlockInfoNames;
BitstreamReader(const BitstreamReader&) LLVM_DELETED_FUNCTION;
void operator=(const BitstreamReader&) LLVM_DELETED_FUNCTION;
BitstreamReader(const BitstreamReader&) = delete;
void operator=(const BitstreamReader&) = delete;
public:
BitstreamReader() : IgnoreBlockInfoNames(true) {
}

4
include/llvm/CodeGen/GCMetadataPrinter.h
View File

@ -44,8 +44,8 @@ protected:
GCMetadataPrinter();
private:
GCMetadataPrinter(const GCMetadataPrinter &) LLVM_DELETED_FUNCTION;
GCMetadataPrinter &operator=(const GCMetadataPrinter &) LLVM_DELETED_FUNCTION;
GCMetadataPrinter(const GCMetadataPrinter &) = delete;
GCMetadataPrinter &operator=(const GCMetadataPrinter &) = delete;
public:
GCStrategy &getStrategy() { return *S; }

2
include/llvm/CodeGen/LiveInterval.h
View File

@ -745,7 +745,7 @@ namespace llvm {
#endif
private:
LiveInterval& operator=(const LiveInterval& rhs) LLVM_DELETED_FUNCTION;
LiveInterval& operator=(const LiveInterval& rhs) = delete;
/// Appends @p Range to SubRanges list.
void appendSubRange(SubRange *Range) {

4
include/llvm/CodeGen/LiveIntervalUnion.h
View File

@ -179,8 +179,8 @@ public:
}
private:
Query(const Query&) LLVM_DELETED_FUNCTION;
void operator=(const Query&) LLVM_DELETED_FUNCTION;
Query(const Query&) = delete;
void operator=(const Query&) = delete;
};
// Array of LiveIntervalUnions.

4
include/llvm/CodeGen/LivePhysRegs.h
View File

@ -44,8 +44,8 @@ class LivePhysRegs {
const TargetRegisterInfo *TRI;
SparseSet<unsigned> LiveRegs;
LivePhysRegs(const LivePhysRegs&) LLVM_DELETED_FUNCTION;
LivePhysRegs &operator=(const LivePhysRegs&) LLVM_DELETED_FUNCTION;
LivePhysRegs(const LivePhysRegs&) = delete;
LivePhysRegs &operator=(const LivePhysRegs&) = delete;
public:
/// \brief Constructs a new empty LivePhysRegs set.
LivePhysRegs() : TRI(nullptr), LiveRegs() {}

4
include/llvm/CodeGen/MachineDominanceFrontier.h
View File

@ -26,8 +26,8 @@ public:
typedef DominanceFrontierBase<MachineBasicBlock>::iterator iterator;
typedef DominanceFrontierBase<MachineBasicBlock>::const_iterator const_iterator;
void operator=(const MachineDominanceFrontier &) LLVM_DELETED_FUNCTION;
MachineDominanceFrontier(const MachineDominanceFrontier &) LLVM_DELETED_FUNCTION;
void operator=(const MachineDominanceFrontier &) = delete;
MachineDominanceFrontier(const MachineDominanceFrontier &) = delete;
static char ID;

4
include/llvm/CodeGen/MachineFunction.h
View File

@ -145,8 +145,8 @@ class MachineFunction {
/// True if the function includes any inline assembly.
bool HasInlineAsm;
MachineFunction(const MachineFunction &) LLVM_DELETED_FUNCTION;
void operator=(const MachineFunction&) LLVM_DELETED_FUNCTION;
MachineFunction(const MachineFunction &) = delete;
void operator=(const MachineFunction&) = delete;
public:
MachineFunction(const Function *Fn, const TargetMachine &TM,
unsigned FunctionNum, MachineModuleInfo &MMI);

6
include/llvm/CodeGen/MachineInstr.h
View File

@ -93,10 +93,10 @@ private:
DebugLoc debugLoc; // Source line information.
MachineInstr(const MachineInstr&) LLVM_DELETED_FUNCTION;
void operator=(const MachineInstr&) LLVM_DELETED_FUNCTION;
MachineInstr(const MachineInstr&) = delete;
void operator=(const MachineInstr&) = delete;
// Use MachineFunction::DeleteMachineInstr() instead.
~MachineInstr() LLVM_DELETED_FUNCTION;
~MachineInstr() = delete;
// Intrusive list support
friend struct ilist_traits<MachineInstr>;

4
include/llvm/CodeGen/MachineLoopInfo.h
View File

@ -74,8 +74,8 @@ class MachineLoopInfo : public MachineFunctionPass {
LoopInfoBase<MachineBasicBlock, MachineLoop> LI;
friend class LoopBase<MachineBasicBlock, MachineLoop>;
void operator=(const MachineLoopInfo &) LLVM_DELETED_FUNCTION;
MachineLoopInfo(const MachineLoopInfo &) LLVM_DELETED_FUNCTION;
void operator=(const MachineLoopInfo &) = delete;
MachineLoopInfo(const MachineLoopInfo &) = delete;
public:
static char ID; // Pass identification, replacement for typeid

4
include/llvm/CodeGen/MachineRegisterInfo.h
View File

@ -123,8 +123,8 @@ private:
/// second element.
std::vector<std::pair<unsigned, unsigned> > LiveIns;
MachineRegisterInfo(const MachineRegisterInfo&) LLVM_DELETED_FUNCTION;
void operator=(const MachineRegisterInfo&) LLVM_DELETED_FUNCTION;
MachineRegisterInfo(const MachineRegisterInfo&) = delete;
void operator=(const MachineRegisterInfo&) = delete;
public:
explicit MachineRegisterInfo(const MachineFunction *MF);

4
include/llvm/CodeGen/MachineSSAUpdater.h
View File

@ -107,8 +107,8 @@ public:
private:
unsigned GetValueAtEndOfBlockInternal(MachineBasicBlock *BB);
void operator=(const MachineSSAUpdater&) LLVM_DELETED_FUNCTION;
MachineSSAUpdater(const MachineSSAUpdater&) LLVM_DELETED_FUNCTION;
void operator=(const MachineSSAUpdater&) = delete;
MachineSSAUpdater(const MachineSSAUpdater&) = delete;
};
} // End llvm namespace

8
include/llvm/CodeGen/SelectionDAG.h
View File

@ -115,8 +115,8 @@ class SDDbgInfo {
typedef DenseMap<const SDNode*, SmallVector<SDDbgValue*, 2> > DbgValMapType;
DbgValMapType DbgValMap;
void operator=(const SDDbgInfo&) LLVM_DELETED_FUNCTION;
SDDbgInfo(const SDDbgInfo&) LLVM_DELETED_FUNCTION;
void operator=(const SDDbgInfo&) = delete;
SDDbgInfo(const SDDbgInfo&) = delete;
public:
SDDbgInfo() {}
@ -262,8 +262,8 @@ private:
DenseSet<SDNode *> &visited,
int level, bool &printed);
void operator=(const SelectionDAG&) LLVM_DELETED_FUNCTION;
SelectionDAG(const SelectionDAG&) LLVM_DELETED_FUNCTION;
void operator=(const SelectionDAG&) = delete;
SelectionDAG(const SelectionDAG&) = delete;
public:
explicit SelectionDAG(const TargetMachine &TM, llvm::CodeGenOpt::Level);

6
include/llvm/CodeGen/SelectionDAGNodes.h
View File

@ -259,8 +259,8 @@ class SDUse {
/// this operand.
SDUse **Prev, *Next;
SDUse(const SDUse &U) LLVM_DELETED_FUNCTION;
void operator=(const SDUse &U) LLVM_DELETED_FUNCTION;
SDUse(const SDUse &U) = delete;
void operator=(const SDUse &U) = delete;
public:
SDUse() : Val(), User(nullptr), Prev(nullptr), Next(nullptr) {}
@ -1611,7 +1611,7 @@ public:
/// BUILD_VECTORs.
class BuildVectorSDNode : public SDNode {
// These are constructed as SDNodes and then cast to BuildVectorSDNodes.
explicit BuildVectorSDNode() LLVM_DELETED_FUNCTION;
explicit BuildVectorSDNode() = delete;
public:
/// isConstantSplat - Check if this is a constant splat, and if so, find the
/// smallest element size that splats the vector. If MinSplatBits is

4
include/llvm/CodeGen/VirtRegMap.h
View File

@ -63,8 +63,8 @@ namespace llvm {
/// createSpillSlot - Allocate a spill slot for RC from MFI.
unsigned createSpillSlot(const TargetRegisterClass *RC);
VirtRegMap(const VirtRegMap&) LLVM_DELETED_FUNCTION;
void operator=(const VirtRegMap&) LLVM_DELETED_FUNCTION;
VirtRegMap(const VirtRegMap&) = delete;
void operator=(const VirtRegMap&) = delete;
public:
static char ID;

4
include/llvm/DebugInfo/DWARF/DWARFContext.h
View File

@ -44,8 +44,8 @@ class DWARFContext : public DIContext {
std::unique_ptr<DWARFDebugAbbrev> AbbrevDWO;
std::unique_ptr<DWARFDebugLocDWO> LocDWO;
DWARFContext(DWARFContext &) LLVM_DELETED_FUNCTION;
DWARFContext &operator=(DWARFContext &) LLVM_DELETED_FUNCTION;
DWARFContext(DWARFContext &) = delete;
DWARFContext &operator=(DWARFContext &) = delete;
/// Read compile units from the debug_info section (if necessary)
/// and store them in CUs.

4
include/llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h
View File

@ -34,8 +34,8 @@ protected:
/// had been provided by this instance. Higher level layers are responsible
/// for taking any action required to handle the missing symbols.
class LinkedObjectSet {
LinkedObjectSet(const LinkedObjectSet&) LLVM_DELETED_FUNCTION;
void operator=(const LinkedObjectSet&) LLVM_DELETED_FUNCTION;
LinkedObjectSet(const LinkedObjectSet&) = delete;
void operator=(const LinkedObjectSet&) = delete;
public:
LinkedObjectSet(std::unique_ptr<RTDyldMemoryManager> MM)
: MM(std::move(MM)), RTDyld(llvm::make_unique<RuntimeDyld>(&*this->MM)),

4
include/llvm/ExecutionEngine/RTDyldMemoryManager.h
View File

@ -34,8 +34,8 @@ class ExecutionEngine;
// FIXME: As the RuntimeDyld fills out, additional routines will be needed
// for the varying types of objects to be allocated.
class RTDyldMemoryManager {
RTDyldMemoryManager(const RTDyldMemoryManager&) LLVM_DELETED_FUNCTION;
void operator=(const RTDyldMemoryManager&) LLVM_DELETED_FUNCTION;
RTDyldMemoryManager(const RTDyldMemoryManager&) = delete;
void operator=(const RTDyldMemoryManager&) = delete;
public:
RTDyldMemoryManager() {}
virtual ~RTDyldMemoryManager();

4
include/llvm/ExecutionEngine/RuntimeDyld.h
View File

@ -32,8 +32,8 @@ class RuntimeDyldCheckerImpl;
class RuntimeDyld {
friend class RuntimeDyldCheckerImpl;
RuntimeDyld(const RuntimeDyld &) LLVM_DELETED_FUNCTION;
void operator=(const RuntimeDyld &) LLVM_DELETED_FUNCTION;
RuntimeDyld(const RuntimeDyld &) = delete;
void operator=(const RuntimeDyld &) = delete;
// RuntimeDyldImpl is the actual class. RuntimeDyld is just the public
// interface.

4
include/llvm/ExecutionEngine/SectionMemoryManager.h
View File

@ -35,8 +35,8 @@ namespace llvm {
/// MCJIT::finalizeObject or by calling SectionMemoryManager::finalizeMemory
/// directly. Clients of MCJIT should call MCJIT::finalizeObject.
class SectionMemoryManager : public RTDyldMemoryManager {
SectionMemoryManager(const SectionMemoryManager&) LLVM_DELETED_FUNCTION;
void operator=(const SectionMemoryManager&) LLVM_DELETED_FUNCTION;
SectionMemoryManager(const SectionMemoryManager&) = delete;
void operator=(const SectionMemoryManager&) = delete;
public:
SectionMemoryManager() { }

4
include/llvm/IR/BasicBlock.h
View File

@ -82,8 +82,8 @@ private:
void setParent(Function *parent);
friend class SymbolTableListTraits<BasicBlock, Function>;
BasicBlock(const BasicBlock &) LLVM_DELETED_FUNCTION;
void operator=(const BasicBlock &) LLVM_DELETED_FUNCTION;
BasicBlock(const BasicBlock &) = delete;
void operator=(const BasicBlock &) = delete;
/// \brief Constructor.
///

2
include/llvm/IR/Comdat.h
View File

@ -49,7 +49,7 @@ private:
friend class Module;
Comdat();
Comdat(SelectionKind SK, StringMapEntry<Comdat> *Name);
Comdat(const Comdat &) LLVM_DELETED_FUNCTION;
Comdat(const Comdat &) = delete;
// Points to the map in Module.
StringMapEntry<Comdat> *Name;

4
include/llvm/IR/Constant.h
View File

@ -39,8 +39,8 @@ namespace llvm {
/// don't have to worry about the lifetime of the objects.
/// @brief LLVM Constant Representation
class Constant : public User {
void operator=(const Constant &) LLVM_DELETED_FUNCTION;
Constant(const Constant &) LLVM_DELETED_FUNCTION;
void operator=(const Constant &) = delete;
Constant(const Constant &) = delete;
void anchor() override;
protected:

40
include/llvm/IR/Constants.h
View File

@ -46,8 +46,8 @@ template <class ConstantClass> struct ConstantAggrKeyType;
/// @brief Class for constant integers.
class ConstantInt : public Constant {
void anchor() override;
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
ConstantInt(const ConstantInt &) LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
ConstantInt(const ConstantInt &) = delete;
ConstantInt(IntegerType *Ty, const APInt& V);
APInt Val;
protected:
@ -228,8 +228,8 @@ public:
class ConstantFP : public Constant {
APFloat Val;
void anchor() override;
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
ConstantFP(const ConstantFP &) LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
ConstantFP(const ConstantFP &) = delete;
friend class LLVMContextImpl;
protected:
ConstantFP(Type *Ty, const APFloat& V);
@ -294,8 +294,8 @@ public:
/// ConstantAggregateZero - All zero aggregate value
///
class ConstantAggregateZero : public Constant {
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
ConstantAggregateZero(const ConstantAggregateZero &) LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
ConstantAggregateZero(const ConstantAggregateZero &) = delete;
protected:
explicit ConstantAggregateZero(Type *ty)
: Constant(ty, ConstantAggregateZeroVal, nullptr, 0) {}
@ -338,7 +338,7 @@ public:
///
class ConstantArray : public Constant {
friend struct ConstantAggrKeyType<ConstantArray>;
ConstantArray(const ConstantArray &) LLVM_DELETED_FUNCTION;
ConstantArray(const ConstantArray &) = delete;
protected:
ConstantArray(ArrayType *T, ArrayRef<Constant *> Val);
public:
@ -380,7 +380,7 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantArray, Constant)
//
class ConstantStruct : public Constant {
friend struct ConstantAggrKeyType<ConstantStruct>;
ConstantStruct(const ConstantStruct &) LLVM_DELETED_FUNCTION;
ConstantStruct(const ConstantStruct &) = delete;
protected:
ConstantStruct(StructType *T, ArrayRef<Constant *> Val);
public:
@ -439,7 +439,7 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantStruct, Constant)
///
class ConstantVector : public Constant {
friend struct ConstantAggrKeyType<ConstantVector>;
ConstantVector(const ConstantVector &) LLVM_DELETED_FUNCTION;
ConstantVector(const ConstantVector &) = delete;
protected:
ConstantVector(VectorType *T, ArrayRef<Constant *> Val);
public:
@ -488,8 +488,8 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantVector, Constant)
/// ConstantPointerNull - a constant pointer value that points to null
///
class ConstantPointerNull : public Constant {
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
ConstantPointerNull(const ConstantPointerNull &) LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
ConstantPointerNull(const ConstantPointerNull &) = delete;
protected:
explicit ConstantPointerNull(PointerType *T)
: Constant(T,
@ -539,8 +539,8 @@ class ConstantDataSequential : public Constant {
/// element array of i8, or a 1-element array of i32. They'll both end up in
/// the same StringMap bucket, linked up.
ConstantDataSequential *Next;
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
ConstantDataSequential(const ConstantDataSequential &) LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
ConstantDataSequential(const ConstantDataSequential &) = delete;
protected:
explicit ConstantDataSequential(Type *ty, ValueTy VT, const char *Data)
: Constant(ty, VT, nullptr, 0), DataElements(Data), Next(nullptr) {}
@ -650,8 +650,8 @@ private:
/// operands because it stores all of the elements of the constant as densely
/// packed data, instead of as Value*'s.
class ConstantDataArray : public ConstantDataSequential {
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
ConstantDataArray(const ConstantDataArray &) LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
ConstantDataArray(const ConstantDataArray &) = delete;
void anchor() override;
friend class ConstantDataSequential;
explicit ConstantDataArray(Type *ty, const char *Data)
@ -702,8 +702,8 @@ public:
/// operands because it stores all of the elements of the constant as densely
/// packed data, instead of as Value*'s.
class ConstantDataVector : public ConstantDataSequential {
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
ConstantDataVector(const ConstantDataVector &) LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
ConstantDataVector(const ConstantDataVector &) = delete;
void anchor() override;
friend class ConstantDataSequential;
explicit ConstantDataVector(Type *ty, const char *Data)
@ -753,7 +753,7 @@ public:
/// BlockAddress - The address of a basic block.
///
class BlockAddress : public Constant {
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
void *operator new(size_t s) { return User::operator new(s, 2); }
BlockAddress(Function *F, BasicBlock *BB);
public:
@ -1165,8 +1165,8 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantExpr, Constant)
/// LangRef.html#undefvalues for details.
///
class UndefValue : public Constant {
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
UndefValue(const UndefValue &) LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
UndefValue(const UndefValue &) = delete;
protected:
explicit UndefValue(Type *T) : Constant(T, UndefValueVal, nullptr, 0) {}
protected:

4
include/llvm/IR/DIBuilder.h
View File

@ -80,8 +80,8 @@ namespace llvm {
/// Each subprogram's preserved local variables.
DenseMap<MDNode *, std::vector<TrackingMDNodeRef>> PreservedVariables;
DIBuilder(const DIBuilder &) LLVM_DELETED_FUNCTION;
void operator=(const DIBuilder &) LLVM_DELETED_FUNCTION;
DIBuilder(const DIBuilder &) = delete;
void operator=(const DIBuilder &) = delete;
/// \brief Create a temporary.
///

2
include/llvm/IR/DebugInfoMetadata.h
View File

@ -63,7 +63,7 @@ class MDLocation : public MDNode {
}
// Disallow replacing operands.
void replaceOperandWith(unsigned I, Metadata *New) LLVM_DELETED_FUNCTION;
void replaceOperandWith(unsigned I, Metadata *New) = delete;
public:
DEFINE_MDNODE_GET(MDLocation,

24
include/llvm/IR/DerivedTypes.h
View File

@ -94,8 +94,8 @@ public:
/// FunctionType - Class to represent function types
///
class FunctionType : public Type {
FunctionType(const FunctionType &) LLVM_DELETED_FUNCTION;
const FunctionType &operator=(const FunctionType &) LLVM_DELETED_FUNCTION;
FunctionType(const FunctionType &) = delete;
const FunctionType &operator=(const FunctionType &) = delete;
FunctionType(Type *Result, ArrayRef<Type*> Params, bool IsVarArgs);
public:
@ -188,8 +188,8 @@ public:
/// generator for a target expects).
///
class StructType : public CompositeType {
StructType(const StructType &) LLVM_DELETED_FUNCTION;
const StructType &operator=(const StructType &) LLVM_DELETED_FUNCTION;
StructType(const StructType &) = delete;
const StructType &operator=(const StructType &) = delete;
StructType(LLVMContext &C)
: CompositeType(C, StructTyID), SymbolTableEntry(nullptr) {}
enum {
@ -308,8 +308,8 @@ public:
///
class SequentialType : public CompositeType {
Type *ContainedType; ///< Storage for the single contained type.
SequentialType(const SequentialType &) LLVM_DELETED_FUNCTION;
const SequentialType &operator=(const SequentialType &) LLVM_DELETED_FUNCTION;
SequentialType(const SequentialType &) = delete;
const SequentialType &operator=(const SequentialType &) = delete;
protected:
SequentialType(TypeID TID, Type *ElType)
@ -335,8 +335,8 @@ public:
class ArrayType : public SequentialType {
uint64_t NumElements;
ArrayType(const ArrayType &) LLVM_DELETED_FUNCTION;
const ArrayType &operator=(const ArrayType &) LLVM_DELETED_FUNCTION;
ArrayType(const ArrayType &) = delete;
const ArrayType &operator=(const ArrayType &) = delete;
ArrayType(Type *ElType, uint64_t NumEl);
public:
/// ArrayType::get - This static method is the primary way to construct an
@ -361,8 +361,8 @@ public:
class VectorType : public SequentialType {
unsigned NumElements;
VectorType(const VectorType &) LLVM_DELETED_FUNCTION;
const VectorType &operator=(const VectorType &) LLVM_DELETED_FUNCTION;
VectorType(const VectorType &) = delete;
const VectorType &operator=(const VectorType &) = delete;
VectorType(Type *ElType, unsigned NumEl);
public:
/// VectorType::get - This static method is the primary way to construct an
@ -446,8 +446,8 @@ public:
/// PointerType - Class to represent pointers.
///
class PointerType : public SequentialType {
PointerType(const PointerType &) LLVM_DELETED_FUNCTION;
const PointerType &operator=(const PointerType &) LLVM_DELETED_FUNCTION;
PointerType(const PointerType &) = delete;
const PointerType &operator=(const PointerType &) = delete;
explicit PointerType(Type *ElType, unsigned AddrSpace);
public:
/// PointerType::get - This constructs a pointer to an object of the specified

4
include/llvm/IR/Function.h
View File

@ -113,8 +113,8 @@ private:
}
void BuildLazyArguments() const;
Function(const Function&) LLVM_DELETED_FUNCTION;
void operator=(const Function&) LLVM_DELETED_FUNCTION;
Function(const Function&) = delete;
void operator=(const Function&) = delete;
/// Do the actual lookup of an intrinsic ID when the query could not be
/// answered from the cache.

4
include/llvm/IR/GlobalAlias.h
View File

@ -28,8 +28,8 @@ template<typename ValueSubClass, typename ItemParentClass>
class GlobalAlias : public GlobalValue, public ilist_node<GlobalAlias> {
friend class SymbolTableListTraits<GlobalAlias, Module>;
void operator=(const GlobalAlias &) LLVM_DELETED_FUNCTION;
GlobalAlias(const GlobalAlias &) LLVM_DELETED_FUNCTION;
void operator=(const GlobalAlias &) = delete;
GlobalAlias(const GlobalAlias &) = delete;
void setParent(Module *parent);

2
include/llvm/IR/GlobalObject.h
View File

@ -24,7 +24,7 @@ class Comdat;
class Module;
class GlobalObject : public GlobalValue {
GlobalObject(const GlobalObject &) LLVM_DELETED_FUNCTION;
GlobalObject(const GlobalObject &) = delete;
protected:
GlobalObject(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps,

2
include/llvm/IR/GlobalValue.h
View File

@ -29,7 +29,7 @@ class PointerType;
class Module;
class GlobalValue : public Constant {
GlobalValue(const GlobalValue &) LLVM_DELETED_FUNCTION;
GlobalValue(const GlobalValue &) = delete;
public:
/// @brief An enumeration for the kinds of linkage for global values.
enum LinkageTypes {

6
include/llvm/IR/GlobalVariable.h
View File

@ -34,9 +34,9 @@ template<typename ValueSubClass, typename ItemParentClass>
class GlobalVariable : public GlobalObject, public ilist_node<GlobalVariable> {
friend class SymbolTableListTraits<GlobalVariable, Module>;
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
void operator=(const GlobalVariable &) LLVM_DELETED_FUNCTION;
GlobalVariable(const GlobalVariable &) LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
void operator=(const GlobalVariable &) = delete;
GlobalVariable(const GlobalVariable &) = delete;
void setParent(Module *parent);

10
include/llvm/IR/IRBuilder.h
View File

@ -198,8 +198,8 @@ public:
BasicBlock::iterator Point;
DebugLoc DbgLoc;
InsertPointGuard(const InsertPointGuard &) LLVM_DELETED_FUNCTION;
InsertPointGuard &operator=(const InsertPointGuard &) LLVM_DELETED_FUNCTION;
InsertPointGuard(const InsertPointGuard &) = delete;
InsertPointGuard &operator=(const InsertPointGuard &) = delete;
public:
InsertPointGuard(IRBuilderBase &B)
@ -219,9 +219,9 @@ public:
FastMathFlags FMF;
MDNode *FPMathTag;
FastMathFlagGuard(const FastMathFlagGuard &) LLVM_DELETED_FUNCTION;
FastMathFlagGuard(const FastMathFlagGuard &) = delete;
FastMathFlagGuard &operator=(
const FastMathFlagGuard &) LLVM_DELETED_FUNCTION;
const FastMathFlagGuard &) = delete;
public:
FastMathFlagGuard(IRBuilderBase &B)
@ -1295,7 +1295,7 @@ private:
// \brief Provided to resolve 'CreateIntCast(Ptr, Ptr, "...")', giving a
// compile time error, instead of converting the string to bool for the
// isSigned parameter.
Value *CreateIntCast(Value *, Type *, const char *) LLVM_DELETED_FUNCTION;
Value *CreateIntCast(Value *, Type *, const char *) = delete;
public:
Value *CreateFPCast(Value *V, Type *DestTy, const Twine &Name = "") {
if (V->getType() == DestTy)

4
include/llvm/IR/InlineAsm.h
View File

@ -40,8 +40,8 @@ private:
friend struct InlineAsmKeyType;
friend class ConstantUniqueMap<InlineAsm>;
InlineAsm(const InlineAsm &) LLVM_DELETED_FUNCTION;
void operator=(const InlineAsm&) LLVM_DELETED_FUNCTION;
InlineAsm(const InlineAsm &) = delete;
void operator=(const InlineAsm&) = delete;
std::string AsmString, Constraints;
bool HasSideEffects;

8
include/llvm/IR/InstrTypes.h
View File

@ -83,7 +83,7 @@ public:
//===----------------------------------------------------------------------===//
class UnaryInstruction : public Instruction {
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
protected:
UnaryInstruction(Type *Ty, unsigned iType, Value *V,
@ -132,7 +132,7 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(UnaryInstruction, Value)
//===----------------------------------------------------------------------===//
class BinaryOperator : public Instruction {
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
protected:
void init(BinaryOps iType);
BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
@ -674,8 +674,8 @@ public:
/// This class is the base class for the comparison instructions.
/// @brief Abstract base class of comparison instructions.
class CmpInst : public Instruction {
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
CmpInst() LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
CmpInst() = delete;
protected:
CmpInst(Type *ty, Instruction::OtherOps op, unsigned short pred,
Value *LHS, Value *RHS, const Twine &Name = "",

4
include/llvm/IR/Instruction.h
View File

@ -31,8 +31,8 @@ template<typename ValueSubClass, typename ItemParentClass>
class SymbolTableListTraits;
class Instruction : public User, public ilist_node<Instruction> {
void operator=(const Instruction &) LLVM_DELETED_FUNCTION;
Instruction(const Instruction &) LLVM_DELETED_FUNCTION;
void operator=(const Instruction &) = delete;
Instruction(const Instruction &) = delete;
BasicBlock *Parent;
DebugLoc DbgLoc; // 'dbg' Metadata cache.

20
include/llvm/IR/Instructions.h
View File

@ -285,7 +285,7 @@ private:
/// StoreInst - an instruction for storing to memory
///
class StoreInst : public Instruction {
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
void AssertOK();
protected:
StoreInst *clone_impl() const override;
@ -411,7 +411,7 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(StoreInst, Value)
/// FenceInst - an instruction for ordering other memory operations
///
class FenceInst : public Instruction {
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
void Init(AtomicOrdering Ordering, SynchronizationScope SynchScope);
protected:
FenceInst *clone_impl() const override;
@ -478,7 +478,7 @@ private:
/// there. Returns the value that was loaded.
///
class AtomicCmpXchgInst : public Instruction {
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
void Init(Value *Ptr, Value *Cmp, Value *NewVal,
AtomicOrdering SuccessOrdering, AtomicOrdering FailureOrdering,
SynchronizationScope SynchScope);
@ -634,7 +634,7 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(AtomicCmpXchgInst, Value)
/// the old value.
///
class AtomicRMWInst : public Instruction {
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
protected:
AtomicRMWInst *clone_impl() const override;
public:
@ -1961,7 +1961,7 @@ ExtractValueInst::ExtractValueInst(Value *Agg,
class InsertValueInst : public Instruction {
SmallVector<unsigned, 4> Indices;
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
InsertValueInst(const InsertValueInst &IVI);
void init(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs,
const Twine &NameStr);
@ -2091,7 +2091,7 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertValueInst, Value)
// scientist's overactive imagination.
//
class PHINode : public Instruction {
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
/// ReservedSpace - The number of operands actually allocated. NumOperands is
/// the number actually in use.
unsigned ReservedSpace;
@ -2298,7 +2298,7 @@ class LandingPadInst : public Instruction {
public:
enum ClauseType { Catch, Filter };
private:
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
// Allocate space for exactly zero operands.
void *operator new(size_t s) {
return User::operator new(s, 0);
@ -2565,7 +2565,7 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BranchInst, Value)
/// SwitchInst - Multiway switch
///
class SwitchInst : public TerminatorInst {
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
unsigned ReservedSpace;
// Operand[0] = Value to switch on
// Operand[1] = Default basic block destination
@ -2874,7 +2874,7 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(SwitchInst, Value)
/// IndirectBrInst - Indirect Branch Instruction.
///
class IndirectBrInst : public TerminatorInst {
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
unsigned ReservedSpace;
// Operand[0] = Value to switch on
// Operand[1] = Default basic block destination
@ -3302,7 +3302,7 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ResumeInst, Value)
/// end of the block cannot be reached.
///
class UnreachableInst : public TerminatorInst {
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
protected:
UnreachableInst *clone_impl() const override;

6
include/llvm/IR/IntrinsicInst.h
View File

@ -35,9 +35,9 @@ namespace llvm {
/// functions. This allows the standard isa/dyncast/cast functionality to
/// work with calls to intrinsic functions.
class IntrinsicInst : public CallInst {
IntrinsicInst() LLVM_DELETED_FUNCTION;
IntrinsicInst(const IntrinsicInst&) LLVM_DELETED_FUNCTION;
void operator=(const IntrinsicInst&) LLVM_DELETED_FUNCTION;
IntrinsicInst() = delete;
IntrinsicInst(const IntrinsicInst&) = delete;
void operator=(const IntrinsicInst&) = delete;
public:
/// getIntrinsicID - Return the intrinsic ID of this intrinsic.
///

4
include/llvm/IR/LLVMContext.h
View File

@ -176,8 +176,8 @@ public:
}
private:
LLVMContext(LLVMContext&) LLVM_DELETED_FUNCTION;
void operator=(LLVMContext&) LLVM_DELETED_FUNCTION;
LLVMContext(LLVMContext&) = delete;
void operator=(LLVMContext&) = delete;
/// addModule - Register a module as being instantiated in this context. If
/// the context is deleted, the module will be deleted as well.

35
include/llvm/IR/Metadata.h
View File

@ -464,9 +464,9 @@ dyn_extract_or_null(Y &&MD) {
class MDString : public Metadata {
friend class StringMapEntry<MDString>;
MDString(const MDString &) LLVM_DELETED_FUNCTION;
MDString &operator=(MDString &&) LLVM_DELETED_FUNCTION;
MDString &operator=(const MDString &) LLVM_DELETED_FUNCTION;
MDString(const MDString &) = delete;
MDString &operator=(MDString &&) = delete;
MDString &operator=(const MDString &) = delete;
StringMapEntry<MDString> *Entry;
MDString() : Metadata(MDStringKind, Uniqued), Entry(nullptr) {}
@ -551,10 +551,10 @@ struct DenseMapInfo<AAMDNodes> {
///
/// In particular, this is used by \a MDNode.
class MDOperand {
MDOperand(MDOperand &&) LLVM_DELETED_FUNCTION;
MDOperand(const MDOperand &) LLVM_DELETED_FUNCTION;
MDOperand &operator=(MDOperand &&) LLVM_DELETED_FUNCTION;
MDOperand &operator=(const MDOperand &) LLVM_DELETED_FUNCTION;
MDOperand(MDOperand &&) = delete;
MDOperand(const MDOperand &) = delete;
MDOperand &operator=(MDOperand &&) = delete;
MDOperand &operator=(const MDOperand &) = delete;
Metadata *MD;
@ -610,15 +610,12 @@ template <> struct simplify_type<const MDOperand> {
class ContextAndReplaceableUses {
PointerUnion<LLVMContext *, ReplaceableMetadataImpl *> Ptr;
ContextAndReplaceableUses() LLVM_DELETED_FUNCTION;
ContextAndReplaceableUses(ContextAndReplaceableUses &&)
LLVM_DELETED_FUNCTION;
ContextAndReplaceableUses(const ContextAndReplaceableUses &)
LLVM_DELETED_FUNCTION;
ContextAndReplaceableUses() = delete;
ContextAndReplaceableUses(ContextAndReplaceableUses &&) = delete;
ContextAndReplaceableUses(const ContextAndReplaceableUses &) = delete;
ContextAndReplaceableUses &operator=(ContextAndReplaceableUses &&) = delete;
ContextAndReplaceableUses &
operator=(ContextAndReplaceableUses &&) LLVM_DELETED_FUNCTION;
ContextAndReplaceableUses &
operator=(const ContextAndReplaceableUses &) LLVM_DELETED_FUNCTION;
operator=(const ContextAndReplaceableUses &) = delete;
public:
ContextAndReplaceableUses(LLVMContext &Context) : Ptr(&Context) {}
@ -700,9 +697,9 @@ class MDNode : public Metadata {
friend class ReplaceableMetadataImpl;
friend class LLVMContextImpl;
MDNode(const MDNode &) LLVM_DELETED_FUNCTION;
void operator=(const MDNode &) LLVM_DELETED_FUNCTION;
void *operator new(size_t) LLVM_DELETED_FUNCTION;
MDNode(const MDNode &) = delete;
void operator=(const MDNode &) = delete;
void *operator new(size_t) = delete;
unsigned NumOperands;
unsigned NumUnresolved;
@ -1011,7 +1008,7 @@ class NamedMDNode : public ilist_node<NamedMDNode> {
friend struct ilist_traits<NamedMDNode>;
friend class LLVMContextImpl;
friend class Module;
NamedMDNode(const NamedMDNode &) LLVM_DELETED_FUNCTION;
NamedMDNode(const NamedMDNode &) = delete;
std::string Name;
Module *Parent;

8
include/llvm/IR/Operator.h
View File

@ -34,12 +34,12 @@ class Operator : public User {
private:
// The Operator class is intended to be used as a utility, and is never itself
// instantiated.
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
void *operator new(size_t s) LLVM_DELETED_FUNCTION;
Operator() LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
void *operator new(size_t s) = delete;
Operator() = delete;
protected:
// NOTE: Cannot use LLVM_DELETED_FUNCTION because it's not legal to delete
// NOTE: Cannot use = delete because it's not legal to delete
// an overridden method that's not deleted in the base class. Cannot leave
// this unimplemented because that leads to an ODR-violation.
~Operator();

12
include/llvm/IR/PassManager.h
View File

@ -241,8 +241,8 @@ public:
private:
typedef detail::PassConcept<IRUnitT> PassConceptT;
PassManager(const PassManager &) LLVM_DELETED_FUNCTION;
PassManager &operator=(const PassManager &) LLVM_DELETED_FUNCTION;
PassManager(const PassManager &) = delete;
PassManager &operator=(const PassManager &) = delete;
std::vector<std::unique_ptr<PassConceptT>> Passes;
@ -281,9 +281,9 @@ template <typename DerivedT, typename IRUnitT> class AnalysisManagerBase {
return static_cast<const DerivedT *>(this);
}
AnalysisManagerBase(const AnalysisManagerBase &) LLVM_DELETED_FUNCTION;
AnalysisManagerBase(const AnalysisManagerBase &) = delete;
AnalysisManagerBase &
operator=(const AnalysisManagerBase &) LLVM_DELETED_FUNCTION;
operator=(const AnalysisManagerBase &) = delete;
protected:
typedef detail::AnalysisResultConcept<IRUnitT> ResultConceptT;
@ -453,8 +453,8 @@ public:
}
private:
AnalysisManager(const AnalysisManager &) LLVM_DELETED_FUNCTION;
AnalysisManager &operator=(const AnalysisManager &) LLVM_DELETED_FUNCTION;
AnalysisManager(const AnalysisManager &) = delete;
AnalysisManager &operator=(const AnalysisManager &) = delete;
/// \brief Get an analysis result, running the pass if necessary.
ResultConceptT &getResultImpl(void *PassID, IRUnitT &IR) {

4
include/llvm/IR/Statepoint.h
View File

@ -45,8 +45,8 @@ bool isGCResult(const ImmutableCallSite &CS);
template <typename InstructionTy, typename ValueTy, typename CallSiteTy>
class StatepointBase {
CallSiteTy StatepointCS;
void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION;
void *operator new(size_t s) LLVM_DELETED_FUNCTION;
void *operator new(size_t, unsigned) = delete;
void *operator new(size_t s) = delete;
protected:
explicit StatepointBase(InstructionTy *I) : StatepointCS(I) {

2
include/llvm/IR/Use.h
View File

@ -77,7 +77,7 @@ public:
typedef PointerIntPair<User *, 1, unsigned> UserRef;
private:
Use(const Use &U) LLVM_DELETED_FUNCTION;
Use(const Use &U) = delete;
/// Destructor - Only for zap()
~Use() {

4
include/llvm/IR/UseListOrder.h
View File

@ -45,8 +45,8 @@ struct UseListOrder {
}
private:
UseListOrder(const UseListOrder &X) LLVM_DELETED_FUNCTION;
UseListOrder &operator=(const UseListOrder &X) LLVM_DELETED_FUNCTION;
UseListOrder(const UseListOrder &X) = delete;
UseListOrder &operator=(const UseListOrder &X) = delete;
};
typedef std::vector<UseListOrder> UseListOrderStack;

4
include/llvm/IR/User.h
View File

@ -33,8 +33,8 @@ template <class>
struct OperandTraits;
class User : public Value {
User(const User &) LLVM_DELETED_FUNCTION;
void *operator new(size_t) LLVM_DELETED_FUNCTION;
User(const User &) = delete;
void *operator new(size_t) = delete;
template <unsigned>
friend struct HungoffOperandTraits;
virtual void anchor();

4
include/llvm/IR/Value.h
View File

@ -180,8 +180,8 @@ private:
Use &getUse() const { return *UI; }
};
void operator=(const Value &) LLVM_DELETED_FUNCTION;
Value(const Value &) LLVM_DELETED_FUNCTION;
void operator=(const Value &) = delete;
Value(const Value &) = delete;
protected:
Value(Type *Ty, unsigned scid);

2
include/llvm/IR/ValueHandle.h
View File

@ -58,7 +58,7 @@ private:
Value* V;
ValueHandleBase(const ValueHandleBase&) LLVM_DELETED_FUNCTION;
ValueHandleBase(const ValueHandleBase&) = delete;
public:
explicit ValueHandleBase(HandleBaseKind Kind)
: PrevPair(nullptr, Kind), Next(nullptr), V(nullptr) {}

4
include/llvm/IR/ValueMap.h
View File

@ -86,8 +86,8 @@ class ValueMap {
MapT Map;
std::unique_ptr<MDMapT> MDMap;
ExtraData Data;
ValueMap(const ValueMap&) LLVM_DELETED_FUNCTION;
ValueMap& operator=(const ValueMap&) LLVM_DELETED_FUNCTION;
ValueMap(const ValueMap&) = delete;
ValueMap& operator=(const ValueMap&) = delete;
public:
typedef KeyT key_type;
typedef ValueT mapped_type;

4
include/llvm/MC/MCAsmBackend.h
View File

@ -32,8 +32,8 @@ class raw_ostream;
/// MCAsmBackend - Generic interface to target specific assembler backends.
class MCAsmBackend {
MCAsmBackend(const MCAsmBackend &) LLVM_DELETED_FUNCTION;
void operator=(const MCAsmBackend &) LLVM_DELETED_FUNCTION;
MCAsmBackend(const MCAsmBackend &) = delete;
void operator=(const MCAsmBackend &) = delete;
protected: // Can only create subclasses.
MCAsmBackend();

12
include/llvm/MC/MCAssembler.h
View File

@ -47,8 +47,8 @@ class MCAsmBackend;
class MCFragment : public ilist_node<MCFragment> {
friend class MCAsmLayout;
MCFragment(const MCFragment&) LLVM_DELETED_FUNCTION;
void operator=(const MCFragment&) LLVM_DELETED_FUNCTION;
MCFragment(const MCFragment&) = delete;
void operator=(const MCFragment&) = delete;
public:
enum FragmentType {
@ -563,8 +563,8 @@ public:
class MCSectionData : public ilist_node<MCSectionData> {
friend class MCAsmLayout;
MCSectionData(const MCSectionData&) LLVM_DELETED_FUNCTION;
void operator=(const MCSectionData&) LLVM_DELETED_FUNCTION;
MCSectionData(const MCSectionData&) = delete;
void operator=(const MCSectionData&) = delete;
public:
typedef iplist<MCFragment> FragmentListType;
@ -865,8 +865,8 @@ public:
unsigned Update;
} VersionMinInfoType;
private:
MCAssembler(const MCAssembler&) LLVM_DELETED_FUNCTION;
void operator=(const MCAssembler&) LLVM_DELETED_FUNCTION;
MCAssembler(const MCAssembler&) = delete;
void operator=(const MCAssembler&) = delete;
MCContext &Context;

4
include/llvm/MC/MCCodeEmitter.h
View File

@ -22,8 +22,8 @@ template<typename T> class SmallVectorImpl;
/// MCCodeEmitter - Generic instruction encoding interface.
class MCCodeEmitter {
private:
MCCodeEmitter(const MCCodeEmitter &) LLVM_DELETED_FUNCTION;
void operator=(const MCCodeEmitter &) LLVM_DELETED_FUNCTION;
MCCodeEmitter(const MCCodeEmitter &) = delete;
void operator=(const MCCodeEmitter &) = delete;
protected: // Can only create subclasses.
MCCodeEmitter();

4
include/llvm/MC/MCContext.h
View File

@ -47,8 +47,8 @@ namespace llvm {
/// of the sections that it creates.
///
class MCContext {
MCContext(const MCContext&) LLVM_DELETED_FUNCTION;
MCContext &operator=(const MCContext&) LLVM_DELETED_FUNCTION;
MCContext(const MCContext&) = delete;
MCContext &operator=(const MCContext&) = delete;
public:
typedef StringMap<MCSymbol*, BumpPtrAllocator&> SymbolTable;
private:

4
include/llvm/MC/MCExpr.h
View File

@ -44,8 +44,8 @@ public:
private:
ExprKind Kind;
MCExpr(const MCExpr&) LLVM_DELETED_FUNCTION;
void operator=(const MCExpr&) LLVM_DELETED_FUNCTION;
MCExpr(const MCExpr&) = delete;
void operator=(const MCExpr&) = delete;
bool EvaluateAsAbsolute(int64_t &Res, const MCAssembler *Asm,
const MCAsmLayout *Layout,

4
include/llvm/MC/MCLabel.h
View File

@ -32,8 +32,8 @@ namespace llvm {
MCLabel(unsigned instance)
: Instance(instance) {}
MCLabel(const MCLabel&) LLVM_DELETED_FUNCTION;
void operator=(const MCLabel&) LLVM_DELETED_FUNCTION;
MCLabel(const MCLabel&) = delete;
void operator=(const MCLabel&) = delete;
public:
/// getInstance - Get the current instance of this Directional Local Label.
unsigned getInstance() const { return Instance; }

4
include/llvm/MC/MCObjectWriter.h
View File

@ -37,8 +37,8 @@ class MCValue;
/// The object writer also contains a number of helper methods for writing
/// binary data to the output stream.
class MCObjectWriter {
MCObjectWriter(const MCObjectWriter &) LLVM_DELETED_FUNCTION;
void operator=(const MCObjectWriter &) LLVM_DELETED_FUNCTION;
MCObjectWriter(const MCObjectWriter &) = delete;
void operator=(const MCObjectWriter &) = delete;
protected:
raw_ostream &OS;

4
include/llvm/MC/MCParser/AsmLexer.h
View File

@ -31,8 +31,8 @@ class AsmLexer : public MCAsmLexer {
StringRef CurBuf;
bool isAtStartOfLine;
void operator=(const AsmLexer&) LLVM_DELETED_FUNCTION;
AsmLexer(const AsmLexer&) LLVM_DELETED_FUNCTION;
void operator=(const AsmLexer&) = delete;
AsmLexer(const AsmLexer&) = delete;
protected:
/// LexToken - Read the next token and return its code.

4
include/llvm/MC/MCParser/MCAsmLexer.h
View File

@ -124,8 +124,8 @@ class MCAsmLexer {
SMLoc ErrLoc;
std::string Err;
MCAsmLexer(const MCAsmLexer &) LLVM_DELETED_FUNCTION;
void operator=(const MCAsmLexer &) LLVM_DELETED_FUNCTION;
MCAsmLexer(const MCAsmLexer &) = delete;
void operator=(const MCAsmLexer &) = delete;
protected: // Can only create subclasses.
const char *TokStart;
bool SkipSpace;

4
include/llvm/MC/MCParser/MCAsmParser.h
View File

@ -68,8 +68,8 @@ public:
ExtensionDirectiveHandler;
private:
MCAsmParser(const MCAsmParser &) LLVM_DELETED_FUNCTION;
void operator=(const MCAsmParser &) LLVM_DELETED_FUNCTION;
MCAsmParser(const MCAsmParser &) = delete;
void operator=(const MCAsmParser &) = delete;
MCTargetAsmParser *TargetParser;

4
include/llvm/MC/MCParser/MCAsmParserExtension.h
View File

@ -21,8 +21,8 @@ class Twine;
/// which is implemented by target and object file assembly parser
/// implementations.
class MCAsmParserExtension {
MCAsmParserExtension(const MCAsmParserExtension &) LLVM_DELETED_FUNCTION;
void operator=(const MCAsmParserExtension &) LLVM_DELETED_FUNCTION;
MCAsmParserExtension(const MCAsmParserExtension &) = delete;
void operator=(const MCAsmParserExtension &) = delete;
MCAsmParser *Parser;

4
include/llvm/MC/MCRelocationInfo.h
View File

@ -28,8 +28,8 @@ class MCContext;
/// \brief Create MCExprs from relocations found in an object file.
class MCRelocationInfo {
MCRelocationInfo(const MCRelocationInfo &) LLVM_DELETED_FUNCTION;
void operator=(const MCRelocationInfo &) LLVM_DELETED_FUNCTION;
MCRelocationInfo(const MCRelocationInfo &) = delete;
void operator=(const MCRelocationInfo &) = delete;
protected:
MCContext &Ctx;

4
include/llvm/MC/MCSection.h
View File

@ -35,8 +35,8 @@ namespace llvm {
};
private:
MCSection(const MCSection&) LLVM_DELETED_FUNCTION;
void operator=(const MCSection&) LLVM_DELETED_FUNCTION;
MCSection(const MCSection&) = delete;
void operator=(const MCSection&) = delete;
protected:
MCSection(SectionVariant V, SectionKind K) : Variant(V), Kind(K) {}
SectionVariant Variant;

4
include/llvm/MC/MCStreamer.h
View File

@ -175,8 +175,8 @@ class MCStreamer {
MCContext &Context;
std::unique_ptr<MCTargetStreamer> TargetStreamer;
MCStreamer(const MCStreamer &) LLVM_DELETED_FUNCTION;
MCStreamer &operator=(const MCStreamer &) LLVM_DELETED_FUNCTION;
MCStreamer(const MCStreamer &) = delete;
MCStreamer &operator=(const MCStreamer &) = delete;
std::vector<MCDwarfFrameInfo> DwarfFrameInfos;
MCDwarfFrameInfo *getCurrentDwarfFrameInfo();

4
include/llvm/MC/MCSymbol.h
View File

@ -66,8 +66,8 @@ namespace llvm {
: Name(name), Section(nullptr), Value(nullptr),
IsTemporary(isTemporary), IsRedefinable(false), IsUsed(false) {}
MCSymbol(const MCSymbol&) LLVM_DELETED_FUNCTION;
void operator=(const MCSymbol&) LLVM_DELETED_FUNCTION;
MCSymbol(const MCSymbol&) = delete;
void operator=(const MCSymbol&) = delete;
public:
/// getName - Get the symbol name.
StringRef getName() const { return Name; }

4
include/llvm/MC/MCSymbolizer.h
View File

@ -38,8 +38,8 @@ class raw_ostream;
/// operands are actually symbolizable, and in what way. I don't think this
/// information exists right now.
class MCSymbolizer {
MCSymbolizer(const MCSymbolizer &) LLVM_DELETED_FUNCTION;
void operator=(const MCSymbolizer &) LLVM_DELETED_FUNCTION;
MCSymbolizer(const MCSymbolizer &) = delete;
void operator=(const MCSymbolizer &) = delete;
protected:
MCContext &Ctx;

4
include/llvm/MC/MCTargetAsmParser.h
View File

@ -91,8 +91,8 @@ public:
};
private:
MCTargetAsmParser(const MCTargetAsmParser &) LLVM_DELETED_FUNCTION;
void operator=(const MCTargetAsmParser &) LLVM_DELETED_FUNCTION;
MCTargetAsmParser(const MCTargetAsmParser &) = delete;
void operator=(const MCTargetAsmParser &) = delete;
protected: // Can only create subclasses.
MCTargetAsmParser();

4
include/llvm/Object/Binary.h
View File

@ -28,8 +28,8 @@ namespace object {
class Binary {
private:
Binary() LLVM_DELETED_FUNCTION;
Binary(const Binary &other) LLVM_DELETED_FUNCTION;
Binary() = delete;
Binary(const Binary &other) = delete;
unsigned int TypeID;

4
include/llvm/Object/ObjectFile.h
View File

@ -180,8 +180,8 @@ public:
/// figures out which type to create.
class ObjectFile : public SymbolicFile {
virtual void anchor();
ObjectFile() LLVM_DELETED_FUNCTION;
ObjectFile(const ObjectFile &other) LLVM_DELETED_FUNCTION;
ObjectFile() = delete;
ObjectFile(const ObjectFile &other) = delete;
protected:
ObjectFile(unsigned int Type, MemoryBufferRef Source);

4
include/llvm/Option/Arg.h
View File

@ -29,8 +29,8 @@ class ArgList;
/// The Arg class encodes just enough information to be able to
/// derive the argument values efficiently.
class Arg {
Arg(const Arg &) LLVM_DELETED_FUNCTION;
void operator=(const Arg &) LLVM_DELETED_FUNCTION;
Arg(const Arg &) = delete;
void operator=(const Arg &) = delete;
private:
/// \brief The option this argument is an instance of.

4
include/llvm/Option/ArgList.h
View File

@ -91,8 +91,8 @@ public:
/// and to iterate over groups of arguments.
class ArgList {
private:
ArgList(const ArgList &) LLVM_DELETED_FUNCTION;
void operator=(const ArgList &) LLVM_DELETED_FUNCTION;
ArgList(const ArgList &) = delete;
void operator=(const ArgList &) = delete;
public:
typedef SmallVector<Arg*, 16> arglist_type;

2
include/llvm/Option/OptSpecifier.h
View File

@ -21,7 +21,7 @@ namespace opt {
unsigned ID;
private:
explicit OptSpecifier(bool) LLVM_DELETED_FUNCTION;
explicit OptSpecifier(bool) = delete;
public:
OptSpecifier() : ID(0) {}

4
include/llvm/Pass.h
View File

@ -83,8 +83,8 @@ class Pass {
AnalysisResolver *Resolver; // Used to resolve analysis
const void *PassID;
PassKind Kind;
void operator=(const Pass&) LLVM_DELETED_FUNCTION;
Pass(const Pass &) LLVM_DELETED_FUNCTION;
void operator=(const Pass&) = delete;
Pass(const Pass &) = delete;
public:
explicit Pass(PassKind K, char &pid)

2
include/llvm/PassAnalysisSupport.h
View File

@ -120,7 +120,7 @@ public:
class PMDataManager;
class AnalysisResolver {
private:
AnalysisResolver() LLVM_DELETED_FUNCTION;
AnalysisResolver() = delete;
public:
explicit AnalysisResolver(PMDataManager &P) : PM(P) { }

4
include/llvm/PassInfo.h
View File

@ -138,8 +138,8 @@ public:
}
private:
void operator=(const PassInfo &) LLVM_DELETED_FUNCTION;
PassInfo(const PassInfo &) LLVM_DELETED_FUNCTION;
void operator=(const PassInfo &) = delete;
PassInfo(const PassInfo &) = delete;
};
}

14
include/llvm/ProfileData/CoverageMappingReader.h
View File

@ -90,10 +90,9 @@ protected:
class RawCoverageFilenamesReader : public RawCoverageReader {
std::vector<StringRef> &Filenames;
RawCoverageFilenamesReader(const RawCoverageFilenamesReader &)
LLVM_DELETED_FUNCTION;
RawCoverageFilenamesReader(const RawCoverageFilenamesReader &) = delete;
RawCoverageFilenamesReader &
operator=(const RawCoverageFilenamesReader &) LLVM_DELETED_FUNCTION;
operator=(const RawCoverageFilenamesReader &) = delete;
public:
RawCoverageFilenamesReader(StringRef Data, std::vector<StringRef> &Filenames)
@ -109,10 +108,9 @@ class RawCoverageMappingReader : public RawCoverageReader {
std::vector<CounterExpression> &Expressions;
std::vector<CounterMappingRegion> &MappingRegions;
RawCoverageMappingReader(const RawCoverageMappingReader &)
LLVM_DELETED_FUNCTION;
RawCoverageMappingReader(const RawCoverageMappingReader &) = delete;
RawCoverageMappingReader &
operator=(const RawCoverageMappingReader &) LLVM_DELETED_FUNCTION;
operator=(const RawCoverageMappingReader &) = delete;
public:
RawCoverageMappingReader(StringRef MappingData,
@ -166,9 +164,9 @@ private:
std::vector<CounterMappingRegion> MappingRegions;
ObjectFileCoverageMappingReader(const ObjectFileCoverageMappingReader &)
LLVM_DELETED_FUNCTION;
= delete;
ObjectFileCoverageMappingReader &
operator=(const ObjectFileCoverageMappingReader &) LLVM_DELETED_FUNCTION;
operator=(const ObjectFileCoverageMappingReader &) = delete;
/// \brief Set the current error_code and return same.
std::error_code error(std::error_code EC) {

Some files were not shown because too many files have changed in this diff Show More