|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
examples/BrainF/BrainFDriver.cpp 163 ExecutionEngine *ee = EngineBuilder(std::move(Mod)).create();
examples/Fibonacci/fibonacci.cpp 119 EngineBuilder(std::move(Owner))
examples/HowToUseJIT/HowToUseJIT.cpp 123 ExecutionEngine* EE = EngineBuilder(std::move(Owner)).create();
examples/HowToUseLLJIT/HowToUseLLJIT.cpp 55 return ThreadSafeModule(std::move(M), std::move(Context));
55 return ThreadSafeModule(std::move(M), std::move(Context));
72 ExitOnErr(J->addIRModule(std::move(M)));
examples/Kaleidoscope/BuildingAJIT/Chapter1/KaleidoscopeJIT.h 46 CompileLayer(ES, ObjectLayer, ConcurrentIRCompiler(std::move(JTMB))),
47 DL(std::move(DL)), Mangle(ES, this->DL),
64 return std::make_unique<KaleidoscopeJIT>(std::move(*JTMB), std::move(*DL));
64 return std::make_unique<KaleidoscopeJIT>(std::move(*JTMB), std::move(*DL));
73 ThreadSafeModule(std::move(M), Ctx));
examples/Kaleidoscope/BuildingAJIT/Chapter1/toy.cpp 175 : Opcode(Opcode), Operand(std::move(Operand)) {}
188 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
188 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
201 : Callee(Callee), Args(std::move(Args)) {}
213 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
213 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
213 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
227 : VarName(VarName), Start(std::move(Start)), End(std::move(End)),
227 : VarName(VarName), Start(std::move(Start)), End(std::move(End)),
228 Step(std::move(Step)), Body(std::move(Body)) {}
228 Step(std::move(Step)), Body(std::move(Body)) {}
242 : VarNames(std::move(VarNames)), Body(std::move(Body)) {}
242 : VarNames(std::move(VarNames)), Body(std::move(Body)) {}
259 : Name(Name), Args(std::move(Args)), IsOperator(IsOperator),
284 : Proto(std::move(Proto)), Body(std::move(Body)) {}
284 : Proto(std::move(Proto)), Body(std::move(Body)) {}
334 return std::move(Result);
367 Args.push_back(std::move(Arg));
383 return std::make_unique<CallExprAST>(IdName, std::move(Args));
412 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
412 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
413 std::move(Else));
458 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
458 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
459 std::move(Step), std::move(Body));
459 std::move(Step), std::move(Body));
487 VarNames.push_back(std::make_pair(Name, std::move(Init)));
507 return std::make_unique<VarExprAST>(std::move(VarNames), std::move(Body));
507 return std::make_unique<VarExprAST>(std::move(VarNames), std::move(Body));
548 return std::make_unique<UnaryExprAST>(Opc, std::move(Operand));
578 RHS = ParseBinOpRHS(TokPrec + 1, std::move(RHS));
585 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
585 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
597 return ParseBinOpRHS(0, std::move(LHS));
674 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
674 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
684 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
684 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
1056 FunctionProtos[Proto->getName()] = std::move(Proto);
1119 ExitOnErr(TheJIT->addModule(std::move(TheModule)));
1134 FunctionProtos[ProtoAST->getName()] = std::move(ProtoAST);
1154 ExitOnErr(TheJIT->addModule(std::move(TheModule)));
examples/Kaleidoscope/BuildingAJIT/Chapter2/KaleidoscopeJIT.h 52 CompileLayer(ES, ObjectLayer, ConcurrentIRCompiler(std::move(JTMB))),
54 DL(std::move(DL)), Mangle(ES, this->DL),
75 return std::make_unique<KaleidoscopeJIT>(std::move(*JTMB), std::move(*DL));
75 return std::make_unique<KaleidoscopeJIT>(std::move(*JTMB), std::move(*DL));
80 ThreadSafeModule(std::move(M), Ctx));
examples/Kaleidoscope/BuildingAJIT/Chapter2/toy.cpp 175 : Opcode(Opcode), Operand(std::move(Operand)) {}
188 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
188 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
201 : Callee(Callee), Args(std::move(Args)) {}
213 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
213 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
213 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
227 : VarName(VarName), Start(std::move(Start)), End(std::move(End)),
227 : VarName(VarName), Start(std::move(Start)), End(std::move(End)),
228 Step(std::move(Step)), Body(std::move(Body)) {}
228 Step(std::move(Step)), Body(std::move(Body)) {}
242 : VarNames(std::move(VarNames)), Body(std::move(Body)) {}
242 : VarNames(std::move(VarNames)), Body(std::move(Body)) {}
259 : Name(Name), Args(std::move(Args)), IsOperator(IsOperator),
284 : Proto(std::move(Proto)), Body(std::move(Body)) {}
284 : Proto(std::move(Proto)), Body(std::move(Body)) {}
334 return std::move(Result);
367 Args.push_back(std::move(Arg));
383 return std::make_unique<CallExprAST>(IdName, std::move(Args));
412 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
412 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
413 std::move(Else));
458 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
458 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
459 std::move(Step), std::move(Body));
459 std::move(Step), std::move(Body));
487 VarNames.push_back(std::make_pair(Name, std::move(Init)));
507 return std::make_unique<VarExprAST>(std::move(VarNames), std::move(Body));
507 return std::make_unique<VarExprAST>(std::move(VarNames), std::move(Body));
548 return std::make_unique<UnaryExprAST>(Opc, std::move(Operand));
578 RHS = ParseBinOpRHS(TokPrec + 1, std::move(RHS));
585 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
585 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
597 return ParseBinOpRHS(0, std::move(LHS));
674 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
674 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
684 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
684 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
1056 FunctionProtos[Proto->getName()] = std::move(Proto);
1119 ExitOnErr(TheJIT->addModule(std::move(TheModule)));
1134 FunctionProtos[ProtoAST->getName()] = std::move(ProtoAST);
1154 ExitOnErr(TheJIT->addModule(std::move(TheModule)));
examples/Kaleidoscope/BuildingAJIT/Chapter3/KaleidoscopeJIT.h 77 return optimizeModule(std::move(M));
85 Resolvers[K] = std::move(R);
107 return std::move(Err);
113 [](Error Err) { cantFail(std::move(Err), "lookupFlags failed"); });
116 cantFail(CODLayer.addModule(K, std::move(M)));
examples/Kaleidoscope/BuildingAJIT/Chapter3/toy.cpp 175 : Opcode(Opcode), Operand(std::move(Operand)) {}
188 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
188 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
201 : Callee(Callee), Args(std::move(Args)) {}
213 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
213 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
213 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
227 : VarName(VarName), Start(std::move(Start)), End(std::move(End)),
227 : VarName(VarName), Start(std::move(Start)), End(std::move(End)),
228 Step(std::move(Step)), Body(std::move(Body)) {}
228 Step(std::move(Step)), Body(std::move(Body)) {}
242 : VarNames(std::move(VarNames)), Body(std::move(Body)) {}
242 : VarNames(std::move(VarNames)), Body(std::move(Body)) {}
259 : Name(Name), Args(std::move(Args)), IsOperator(IsOperator),
284 : Proto(std::move(Proto)), Body(std::move(Body)) {}
284 : Proto(std::move(Proto)), Body(std::move(Body)) {}
334 return std::move(Result);
367 Args.push_back(std::move(Arg));
383 return std::make_unique<CallExprAST>(IdName, std::move(Args));
412 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
412 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
413 std::move(Else));
458 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
458 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
459 std::move(Step), std::move(Body));
459 std::move(Step), std::move(Body));
487 VarNames.push_back(std::make_pair(Name, std::move(Init)));
507 return std::make_unique<VarExprAST>(std::move(VarNames), std::move(Body));
507 return std::make_unique<VarExprAST>(std::move(VarNames), std::move(Body));
548 return std::make_unique<UnaryExprAST>(Opc, std::move(Operand));
578 RHS = ParseBinOpRHS(TokPrec + 1, std::move(RHS));
585 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
585 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
597 return ParseBinOpRHS(0, std::move(LHS));
674 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
674 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
684 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
684 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
1055 FunctionProtos[Proto->getName()] = std::move(Proto);
1115 TheJIT->addModule(std::move(TheModule));
1130 FunctionProtos[ProtoAST->getName()] = std::move(ProtoAST);
1144 auto H = TheJIT->addModule(std::move(TheModule));
examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h 56 : Proto(std::move(Proto)), Body(std::move(Body)) {}
56 : Proto(std::move(Proto)), Body(std::move(Body)) {}
100 return std::move(Err);
106 [](Error Err) { cantFail(std::move(Err), "lookupFlags failed"); })),
117 return optimizeModule(std::move(M));
132 cantFail(OptimizeLayer.addModule(K, std::move(M)));
139 auto SharedFnAST = std::shared_ptr<FunctionAST>(std::move(FnAST));
159 addModule(std::move(M));
165 logAllUnhandledErrors(std::move(Err), errs(),
176 CompileCallbackMgr->getCompileCallback(std::move(CompileAction)));
examples/Kaleidoscope/BuildingAJIT/Chapter4/toy.cpp 175 : Opcode(Opcode), Operand(std::move(Operand)) {}
188 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
188 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
201 : Callee(Callee), Args(std::move(Args)) {}
213 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
213 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
213 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
227 : VarName(VarName), Start(std::move(Start)), End(std::move(End)),
227 : VarName(VarName), Start(std::move(Start)), End(std::move(End)),
228 Step(std::move(Step)), Body(std::move(Body)) {}
228 Step(std::move(Step)), Body(std::move(Body)) {}
242 : VarNames(std::move(VarNames)), Body(std::move(Body)) {}
242 : VarNames(std::move(VarNames)), Body(std::move(Body)) {}
259 : Name(Name), Args(std::move(Args)), IsOperator(IsOperator),
319 return std::move(Result);
352 Args.push_back(std::move(Arg));
368 return std::make_unique<CallExprAST>(IdName, std::move(Args));
397 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
397 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
398 std::move(Else));
443 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
443 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
444 std::move(Step), std::move(Body));
444 std::move(Step), std::move(Body));
472 VarNames.push_back(std::make_pair(Name, std::move(Init)));
492 return std::make_unique<VarExprAST>(std::move(VarNames), std::move(Body));
492 return std::make_unique<VarExprAST>(std::move(VarNames), std::move(Body));
533 return std::make_unique<UnaryExprAST>(Opc, std::move(Operand));
563 RHS = ParseBinOpRHS(TokPrec + 1, std::move(RHS));
570 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
570 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
582 return ParseBinOpRHS(0, std::move(LHS));
659 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
659 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
669 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
669 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
1106 auto M = std::move(TheModule);
1118 ExitOnErr(TheJIT->addFunctionAST(std::move(FnAST)));
1131 FunctionProtos[ProtoAST->getName()] = std::move(ProtoAST);
1147 auto H = TheJIT->addModule(std::move(TheModule));
examples/Kaleidoscope/BuildingAJIT/Chapter5/KaleidoscopeJIT.h 58 : Proto(std::move(Proto)), Body(std::move(Body)) {}
58 : Proto(std::move(Proto)), Body(std::move(Body)) {}
107 return std::move(Err);
112 [](Error Err) { cantFail(std::move(Err), "lookupFlags failed"); })),
126 return optimizeModule(std::move(M));
145 cantFail(OptimizeLayer.addModule(K, std::move(M)));
152 auto SharedFnAST = std::shared_ptr<FunctionAST>(std::move(FnAST));
172 addModule(std::move(M));
178 logAllUnhandledErrors(std::move(Err), errs(),
189 CompileCallbackMgr->getCompileCallback(std::move(CompileAction)));
examples/Kaleidoscope/BuildingAJIT/Chapter5/toy.cpp 192 : Opcode(Opcode), Operand(std::move(Operand)) {}
205 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
205 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
218 : Callee(Callee), Args(std::move(Args)) {}
230 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
230 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
230 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
244 : VarName(VarName), Start(std::move(Start)), End(std::move(End)),
244 : VarName(VarName), Start(std::move(Start)), End(std::move(End)),
245 Step(std::move(Step)), Body(std::move(Body)) {}
245 Step(std::move(Step)), Body(std::move(Body)) {}
259 : VarNames(std::move(VarNames)), Body(std::move(Body)) {}
259 : VarNames(std::move(VarNames)), Body(std::move(Body)) {}
276 : Name(Name), Args(std::move(Args)), IsOperator(IsOperator),
336 return std::move(Result);
369 Args.push_back(std::move(Arg));
385 return std::make_unique<CallExprAST>(IdName, std::move(Args));
414 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
414 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
415 std::move(Else));
460 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
460 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
461 std::move(Step), std::move(Body));
461 std::move(Step), std::move(Body));
489 VarNames.push_back(std::make_pair(Name, std::move(Init)));
509 return std::make_unique<VarExprAST>(std::move(VarNames), std::move(Body));
509 return std::make_unique<VarExprAST>(std::move(VarNames), std::move(Body));
550 return std::make_unique<UnaryExprAST>(Opc, std::move(Operand));
580 RHS = ParseBinOpRHS(TokPrec + 1, std::move(RHS));
587 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
587 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
599 return ParseBinOpRHS(0, std::move(LHS));
676 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
676 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
685 PEArgs.push_back(std::move(E));
687 std::make_unique<CallExprAST>("printExprResult", std::move(PEArgs));
692 return std::make_unique<FunctionAST>(std::move(Proto),
693 std::move(PrintExpr));
1130 auto M = std::move(TheModule);
1142 ExitOnErr(TheJIT->addFunctionAST(std::move(FnAST)));
1155 FunctionProtos[ProtoAST->getName()] = std::move(ProtoAST);
1171 auto H = TheJIT->addModule(std::move(TheModule));
examples/Kaleidoscope/Chapter2/toy.cpp 119 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
119 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
130 : Callee(Callee), Args(std::move(Args)) {}
142 : Name(Name), Args(std::move(Args)) {}
155 : Proto(std::move(Proto)), Body(std::move(Body)) {}
155 : Proto(std::move(Proto)), Body(std::move(Body)) {}
202 return std::move(Result);
235 Args.push_back(std::move(Arg));
251 return std::make_unique<CallExprAST>(IdName, std::move(Args));
297 RHS = ParseBinOpRHS(TokPrec + 1, std::move(RHS));
303 LHS = std::make_unique<BinaryExprAST>(BinOp, std::move(LHS),
304 std::move(RHS));
316 return ParseBinOpRHS(0, std::move(LHS));
340 return std::make_unique<PrototypeAST>(FnName, std::move(ArgNames));
351 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
351 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
361 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
361 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
examples/Kaleidoscope/Chapter3/toy.cpp 137 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
137 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
150 : Callee(Callee), Args(std::move(Args)) {}
164 : Name(Name), Args(std::move(Args)) {}
178 : Proto(std::move(Proto)), Body(std::move(Body)) {}
178 : Proto(std::move(Proto)), Body(std::move(Body)) {}
228 return std::move(Result);
261 Args.push_back(std::move(Arg));
277 return std::make_unique<CallExprAST>(IdName, std::move(Args));
323 RHS = ParseBinOpRHS(TokPrec + 1, std::move(RHS));
330 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
330 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
342 return ParseBinOpRHS(0, std::move(LHS));
366 return std::make_unique<PrototypeAST>(FnName, std::move(ArgNames));
377 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
377 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
387 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
387 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
examples/Kaleidoscope/Chapter4/toy.cpp 147 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
147 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
160 : Callee(Callee), Args(std::move(Args)) {}
174 : Name(Name), Args(std::move(Args)) {}
188 : Proto(std::move(Proto)), Body(std::move(Body)) {}
188 : Proto(std::move(Proto)), Body(std::move(Body)) {}
238 return std::move(Result);
271 Args.push_back(std::move(Arg));
287 return std::make_unique<CallExprAST>(IdName, std::move(Args));
333 RHS = ParseBinOpRHS(TokPrec + 1, std::move(RHS));
340 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
340 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
352 return ParseBinOpRHS(0, std::move(LHS));
376 return std::make_unique<PrototypeAST>(FnName, std::move(ArgNames));
387 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
387 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
397 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
397 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
515 FunctionProtos[Proto->getName()] = std::move(Proto);
577 TheJIT->addModule(std::move(TheModule));
592 FunctionProtos[ProtoAST->getName()] = std::move(ProtoAST);
606 auto H = TheJIT->addModule(std::move(TheModule));
examples/Kaleidoscope/Chapter5/toy.cpp 165 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
165 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
178 : Callee(Callee), Args(std::move(Args)) {}
190 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
190 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
190 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
204 : VarName(VarName), Start(std::move(Start)), End(std::move(End)),
204 : VarName(VarName), Start(std::move(Start)), End(std::move(End)),
205 Step(std::move(Step)), Body(std::move(Body)) {}
205 Step(std::move(Step)), Body(std::move(Body)) {}
219 : Name(Name), Args(std::move(Args)) {}
233 : Proto(std::move(Proto)), Body(std::move(Body)) {}
233 : Proto(std::move(Proto)), Body(std::move(Body)) {}
283 return std::move(Result);
316 Args.push_back(std::move(Arg));
332 return std::make_unique<CallExprAST>(IdName, std::move(Args));
361 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
361 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
362 std::move(Else));
407 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
407 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
408 std::move(Step), std::move(Body));
408 std::move(Step), std::move(Body));
460 RHS = ParseBinOpRHS(TokPrec + 1, std::move(RHS));
467 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
467 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
479 return ParseBinOpRHS(0, std::move(LHS));
503 return std::make_unique<PrototypeAST>(FnName, std::move(ArgNames));
514 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
514 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
524 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
524 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
789 FunctionProtos[Proto->getName()] = std::move(Proto);
851 TheJIT->addModule(std::move(TheModule));
866 FunctionProtos[ProtoAST->getName()] = std::move(ProtoAST);
880 auto H = TheJIT->addModule(std::move(TheModule));
examples/Kaleidoscope/Chapter6/toy.cpp 172 : Opcode(Opcode), Operand(std::move(Operand)) {}
185 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
185 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
198 : Callee(Callee), Args(std::move(Args)) {}
210 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
210 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
210 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
224 : VarName(VarName), Start(std::move(Start)), End(std::move(End)),
224 : VarName(VarName), Start(std::move(Start)), End(std::move(End)),
225 Step(std::move(Step)), Body(std::move(Body)) {}
225 Step(std::move(Step)), Body(std::move(Body)) {}
242 : Name(Name), Args(std::move(Args)), IsOperator(IsOperator),
267 : Proto(std::move(Proto)), Body(std::move(Body)) {}
267 : Proto(std::move(Proto)), Body(std::move(Body)) {}
317 return std::move(Result);
350 Args.push_back(std::move(Arg));
366 return std::make_unique<CallExprAST>(IdName, std::move(Args));
395 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
395 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
396 std::move(Else));
441 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
441 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
442 std::move(Step), std::move(Body));
442 std::move(Step), std::move(Body));
480 return std::make_unique<UnaryExprAST>(Opc, std::move(Operand));
510 RHS = ParseBinOpRHS(TokPrec + 1, std::move(RHS));
517 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
517 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
529 return ParseBinOpRHS(0, std::move(LHS));
606 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
606 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
616 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
616 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
901 FunctionProtos[Proto->getName()] = std::move(Proto);
970 TheJIT->addModule(std::move(TheModule));
985 FunctionProtos[ProtoAST->getName()] = std::move(ProtoAST);
999 auto H = TheJIT->addModule(std::move(TheModule));
examples/Kaleidoscope/Chapter7/toy.cpp 180 : Opcode(Opcode), Operand(std::move(Operand)) {}
193 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
193 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
206 : Callee(Callee), Args(std::move(Args)) {}
218 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
218 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
218 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
232 : VarName(VarName), Start(std::move(Start)), End(std::move(End)),
232 : VarName(VarName), Start(std::move(Start)), End(std::move(End)),
233 Step(std::move(Step)), Body(std::move(Body)) {}
233 Step(std::move(Step)), Body(std::move(Body)) {}
247 : VarNames(std::move(VarNames)), Body(std::move(Body)) {}
247 : VarNames(std::move(VarNames)), Body(std::move(Body)) {}
264 : Name(Name), Args(std::move(Args)), IsOperator(IsOperator),
289 : Proto(std::move(Proto)), Body(std::move(Body)) {}
289 : Proto(std::move(Proto)), Body(std::move(Body)) {}
339 return std::move(Result);
372 Args.push_back(std::move(Arg));
388 return std::make_unique<CallExprAST>(IdName, std::move(Args));
417 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
417 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
418 std::move(Else));
463 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
463 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
464 std::move(Step), std::move(Body));
464 std::move(Step), std::move(Body));
492 VarNames.push_back(std::make_pair(Name, std::move(Init)));
512 return std::make_unique<VarExprAST>(std::move(VarNames), std::move(Body));
512 return std::make_unique<VarExprAST>(std::move(VarNames), std::move(Body));
553 return std::make_unique<UnaryExprAST>(Opc, std::move(Operand));
583 RHS = ParseBinOpRHS(TokPrec + 1, std::move(RHS));
590 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
590 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
602 return ParseBinOpRHS(0, std::move(LHS));
679 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
679 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
689 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
689 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
1061 FunctionProtos[Proto->getName()] = std::move(Proto);
1140 TheJIT->addModule(std::move(TheModule));
1155 FunctionProtos[ProtoAST->getName()] = std::move(ProtoAST);
1169 auto H = TheJIT->addModule(std::move(TheModule));
examples/Kaleidoscope/Chapter8/toy.cpp 181 : Opcode(Opcode), Operand(std::move(Operand)) {}
194 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
194 : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
207 : Callee(Callee), Args(std::move(Args)) {}
219 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
219 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
219 : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
233 : VarName(VarName), Start(std::move(Start)), End(std::move(End)),
233 : VarName(VarName), Start(std::move(Start)), End(std::move(End)),
234 Step(std::move(Step)), Body(std::move(Body)) {}
234 Step(std::move(Step)), Body(std::move(Body)) {}
248 : VarNames(std::move(VarNames)), Body(std::move(Body)) {}
248 : VarNames(std::move(VarNames)), Body(std::move(Body)) {}
265 : Name(Name), Args(std::move(Args)), IsOperator(IsOperator),
290 : Proto(std::move(Proto)), Body(std::move(Body)) {}
290 : Proto(std::move(Proto)), Body(std::move(Body)) {}
340 return std::move(Result);
373 Args.push_back(std::move(Arg));
389 return std::make_unique<CallExprAST>(IdName, std::move(Args));
418 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
418 return std::make_unique<IfExprAST>(std::move(Cond), std::move(Then),
419 std::move(Else));
464 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
464 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
465 std::move(Step), std::move(Body));
465 std::move(Step), std::move(Body));
493 VarNames.push_back(std::make_pair(Name, std::move(Init)));
513 return std::make_unique<VarExprAST>(std::move(VarNames), std::move(Body));
513 return std::make_unique<VarExprAST>(std::move(VarNames), std::move(Body));
554 return std::make_unique<UnaryExprAST>(Opc, std::move(Operand));
584 RHS = ParseBinOpRHS(TokPrec + 1, std::move(RHS));
591 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
591 std::make_unique<BinaryExprAST>(BinOp, std::move(LHS), std::move(RHS));
603 return ParseBinOpRHS(0, std::move(LHS));
680 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
680 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
690 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
690 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
1060 FunctionProtos[Proto->getName()] = std::move(Proto);
1132 FunctionProtos[ProtoAST->getName()] = std::move(ProtoAST);
examples/Kaleidoscope/Chapter9/toy.cpp 248 : Opcode(Opcode), Operand(std::move(Operand)) {}
265 : ExprAST(Loc), Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
265 : ExprAST(Loc), Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
283 : ExprAST(Loc), Callee(Callee), Args(std::move(Args)) {}
300 : ExprAST(Loc), Cond(std::move(Cond)), Then(std::move(Then)),
300 : ExprAST(Loc), Cond(std::move(Cond)), Then(std::move(Then)),
301 Else(std::move(Else)) {}
321 : VarName(VarName), Start(std::move(Start)), End(std::move(End)),
321 : VarName(VarName), Start(std::move(Start)), End(std::move(End)),
322 Step(std::move(Step)), Body(std::move(Body)) {}
322 Step(std::move(Step)), Body(std::move(Body)) {}
343 : VarNames(std::move(VarNames)), Body(std::move(Body)) {}
343 : VarNames(std::move(VarNames)), Body(std::move(Body)) {}
368 : Name(Name), Args(std::move(Args)), IsOperator(IsOperator),
393 : Proto(std::move(Proto)), Body(std::move(Body)) {}
393 : Proto(std::move(Proto)), Body(std::move(Body)) {}
447 return std::move(Result);
482 Args.push_back(std::move(Arg));
498 return std::make_unique<CallExprAST>(LitLoc, IdName, std::move(Args));
529 return std::make_unique<IfExprAST>(IfLoc, std::move(Cond), std::move(Then),
529 return std::make_unique<IfExprAST>(IfLoc, std::move(Cond), std::move(Then),
530 std::move(Else));
575 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
575 return std::make_unique<ForExprAST>(IdName, std::move(Start), std::move(End),
576 std::move(Step), std::move(Body));
576 std::move(Step), std::move(Body));
604 VarNames.push_back(std::make_pair(Name, std::move(Init)));
624 return std::make_unique<VarExprAST>(std::move(VarNames), std::move(Body));
624 return std::make_unique<VarExprAST>(std::move(VarNames), std::move(Body));
665 return std::make_unique<UnaryExprAST>(Opc, std::move(Operand));
696 RHS = ParseBinOpRHS(TokPrec + 1, std::move(RHS));
702 LHS = std::make_unique<BinaryExprAST>(BinLoc, BinOp, std::move(LHS),
703 std::move(RHS));
715 return ParseBinOpRHS(0, std::move(LHS));
794 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
794 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
805 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
805 return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
1227 FunctionProtos[Proto->getName()] = std::move(Proto);
1336 FunctionProtos[ProtoAST->getName()] = std::move(ProtoAST);
examples/Kaleidoscope/include/KaleidoscopeJIT.h 49 [](Error Err) { cantFail(std::move(Err), "lookupFlags failed"); })),
65 cantFail(CompileLayer.addModule(K, std::move(M)));
examples/LLJITExamples/ExampleModules.h 48 return make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode());
51 return ThreadSafeModule(std::move(M), std::move(Ctx));
51 return ThreadSafeModule(std::move(M), std::move(Ctx));
examples/LLJITExamples/LLJITWithJITLink/LLJITWithJITLink.cpp 51 .setJITTargetMachineBuilder(std::move(JTMB))
60 ExitOnErr(J->addIRModule(std::move(M)));
examples/LLJITExamples/LLJITWithObjectCache/LLJITWithObjectCache.cpp 63 TMOwningSimpleCompiler(std::move(*TM), &ObjCache));
69 ExitOnErr(J->addIRModule(std::move(M)));
examples/ParallelJIT/ParallelJIT.cpp 269 ExecutionEngine* EE = EngineBuilder(std::move(Owner)).create();
examples/SpeculativeJIT/SpeculativeJIT.cpp 72 std::move(ES), std::move(*DL), std::move(*JTMB), std::move(*LCTMgr),
72 std::move(ES), std::move(*DL), std::move(*JTMB), std::move(*LCTMgr),
72 std::move(ES), std::move(*DL), std::move(*JTMB), std::move(*LCTMgr),
72 std::move(ES), std::move(*DL), std::move(*JTMB), std::move(*LCTMgr),
73 std::move(ISMBuilder), std::move(*ProcessSymbolsSearchGenerator)));
73 std::move(ISMBuilder), std::move(*ProcessSymbolsSearchGenerator)));
74 return std::move(SJ);
80 return CODLayer.add(JD, std::move(TSM));
104 : ES(std::move(ES)), DL(std::move(DL)), LCTMgr(std::move(LCTMgr)),
104 : ES(std::move(ES)), DL(std::move(DL)), LCTMgr(std::move(LCTMgr)),
104 : ES(std::move(ES)), DL(std::move(DL)), LCTMgr(std::move(LCTMgr)),
106 ConcurrentIRCompiler(std::move(JTMB))),
110 std::move(ISMBuilder)) {
112 std::move(ProcessSymbolsGenerator));
118 auto SharedMU = std::shared_ptr<MaterializationUnit>(std::move(MU));
120 CompileThreads.async(std::move(Work));
176 ThreadSafeModule(std::move(M), std::move(Ctx))));
176 ThreadSafeModule(std::move(M), std::move(Ctx))));
include/llvm/ADT/APFloat.h 614 new (this) DoubleAPFloat(std::move(RHS));
702 : Double(std::move(F)) {
745 new (this) IEEEFloat(std::move(RHS.IEEE));
749 new (this) DoubleAPFloat(std::move(RHS.Double));
772 IEEE = std::move(RHS.IEEE);
775 Double = std::move(RHS.Double);
778 new (this) Storage(std::move(RHS));
836 explicit APFloat(IEEEFloat F, const fltSemantics &S) : U(std::move(F), S) {}
838 : U(std::move(F), S) {}
include/llvm/ADT/APInt.h 1998 return std::move(b);
2018 return std::move(b);
2038 return std::move(b);
2068 return std::move(b);
2089 return std::move(b);
include/llvm/ADT/APSInt.h 34 : APInt(std::move(I)), IsUnsigned(isUnsigned) {}
65 APInt::operator=(std::move(RHS));
include/llvm/ADT/AllocatorList.h 41 Node(T &&V) : V(std::move(V)) {}
149 List = std::move(X.List);
150 getAlloc() = std::move(X.getAlloc());
192 return iterator(List.insert(I.wrapped(), *create(std::move(V))));
216 void push_back(T &&V) { insert(end(), std::move(V)); }
217 void push_front(T &&V) { insert(begin(), std::move(V)); }
include/llvm/ADT/Any.h 38 explicit StorageImpl(T &&Value) : Value(std::move(Value)) {}
84 Any(Any &&Other) : Storage(std::move(Other.Storage)) {}
92 Storage = std::move(Other.Storage);
137 return static_cast<T>(std::move(*any_cast<U>(&Value)));
include/llvm/ADT/ArrayRef.h 433 OwningArrayRef(OwningArrayRef &&Other) { *this = std::move(Other); }
include/llvm/ADT/DenseMap.h 203 return try_emplace(std::move(KV.first), std::move(KV.second));
203 return try_emplace(std::move(KV.first), std::move(KV.second));
219 InsertIntoBucket(TheBucket, std::move(Key), std::forward<Ts>(Args)...);
258 TheBucket = InsertIntoBucketWithLookup(TheBucket, std::move(KV.first),
259 std::move(KV.second), Val);
308 return *InsertIntoBucket(TheBucket, std::move(Key));
312 return FindAndConstruct(std::move(Key)).second;
379 DestBucket->getFirst() = std::move(B->getFirst());
380 ::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
529 TheBucket->getFirst() = std::move(Key);
530 ::new (&TheBucket->getSecond()) ValueT(std::move(Value));
930 ::new (&RHSB->getSecond()) ValueT(std::move(LHSB->getSecond()));
933 ::new (&LHSB->getSecond()) ValueT(std::move(RHSB->getSecond()));
949 LargeRep TmpRep = std::move(*LargeSide.getLargeRep());
959 ::new (&NewB->getFirst()) KeyT(std::move(OldB->getFirst()));
963 ::new (&NewB->getSecond()) ValueT(std::move(OldB->getSecond()));
971 new (SmallSide.getLargeRep()) LargeRep(std::move(TmpRep));
1030 ::new (&TmpEnd->getFirst()) KeyT(std::move(P->getFirst()));
1031 ::new (&TmpEnd->getSecond()) ValueT(std::move(P->getSecond()));
1046 LargeRep OldRep = std::move(*getLargeRep());
include/llvm/ADT/DenseSet.h 194 return TheMap.try_emplace(std::move(V), Empty);
206 return TheMap.insert_as({std::move(V), detail::DenseSetEmpty()}, LookupKey);
include/llvm/ADT/DirectedGraph.h 78 DGNode(DGNode<NodeType, EdgeType> &&N) : Edges(std::move(N.Edges)) {}
85 Edges = std::move(N.Edges);
175 DirectedGraph(DGraphType &&RHS) : Nodes(std::move(RHS.Nodes)) {}
181 Nodes = std::move(G.Nodes);
include/llvm/ADT/FunctionExtras.h 164 CallableT(std::move(*reinterpret_cast<CallableT *>(RHSCallableAddr)));
229 new (this) unique_function(std::move(RHS));
248 new (CallableAddr) CallableT(std::move(Callable));
include/llvm/ADT/MapVector.h 57 return std::move(Vector);
135 Vector.push_back(std::move(KV));
220 *O = std::move(*I);
include/llvm/ADT/Optional.h 55 emplace(std::move(other.value));
104 value = std::move(y);
106 ::new ((void *)std::addressof(value)) T(std::move(y));
129 value = std::move(other.value);
131 ::new ((void *)std::addressof(value)) T(std::move(other.value));
204 value = std::move(y);
206 ::new ((void *)std::addressof(value)) T(std::move(y));
227 Optional(T &&y) : Storage(optional_detail::in_place_t{}, std::move(y)) {}
231 Storage = std::move(y);
271 T &&getValue() && { return std::move(Storage.getValue()); }
272 T &&operator*() && { return std::move(Storage.getValue()); }
276 return hasValue() ? std::move(getValue()) : std::forward<U>(value);
include/llvm/ADT/PriorityWorklist.h 231 : P(std::move(P)), M(M) {}
include/llvm/ADT/STLExtras.h 214 : mapped_iterator::iterator_adaptor_base(std::move(U)), F(std::move(F)) {}
214 : mapped_iterator::iterator_adaptor_base(std::move(U)), F(std::move(F)) {}
228 return mapped_iterator<ItTy, FuncTy>(std::move(I), std::move(F));
228 return mapped_iterator<ItTy, FuncTy>(std::move(I), std::move(F));
include/llvm/ADT/ScopeExit.h 34 : ExitFunction(std::move(Rhs.ExitFunction)), Engaged(Rhs.Engaged) {
include/llvm/ADT/Sequence.h 44 : Value(std::move(Arg.Value)) {}
include/llvm/ADT/SetVector.h 68 return std::move(vector_);
278 : P(std::move(P)), set_(set_) {}
include/llvm/ADT/SmallPtrSet.h 354 : SmallPtrSetImplBase(SmallStorage, SmallSize, std::move(that)) {}
434 : BaseT(SmallStorage, SmallSizePowTwo, std::move(that)) {}
456 this->MoveFrom(SmallSizePowTwo, std::move(RHS));
include/llvm/ADT/SmallSet.h 75 VecIter = std::move(Other.VecIter);
79 new (&SetIter) SetIterTy(std::move(Other.SetIter));
104 VecIter = std::move(Other.VecIter);
106 new (&SetIter) SetIterTy(std::move(Other.SetIter));
include/llvm/ADT/SmallVector.h 221 ::new ((void*) this->end()) T(::std::move(Elt));
375 T Result = ::std::move(this->back());
469 this->push_back(::std::move(Elt));
482 ::new ((void*) this->end()) T(::std::move(this->back()));
493 *I = ::std::move(*EltPtr);
511 ::new ((void*) this->end()) T(std::move(this->back()));
881 SmallVectorImpl<T>::operator=(::std::move(RHS));
886 SmallVectorImpl<T>::operator=(::std::move(RHS));
890 SmallVectorImpl<T>::operator=(::std::move(RHS));
895 SmallVectorImpl<T>::operator=(::std::move(RHS));
include/llvm/ADT/SparseBitVector.h 448 : Elements(std::move(RHS.Elements)), CurrElementIter(Elements.begin()) {}
465 Elements = std::move(RHS.Elements);
include/llvm/ADT/StringMap.h 268 : StringMapImpl(std::move(RHS)), Allocator(std::move(RHS.Allocator)) {}
268 : StringMapImpl(std::move(RHS)), Allocator(std::move(RHS.Allocator)) {}
414 return try_emplace(KV.first, std::move(KV.second));
580 : base(std::move(Iter)) {}
include/llvm/ADT/StringSwitch.h 69 Result = std::move(Value);
76 Result = std::move(Value);
83 Result = std::move(Value);
142 Result = std::move(Value);
156 Result = std::move(Value);
183 return std::move(*Result);
190 return std::move(*Result);
include/llvm/ADT/fallible_iterator.h 86 return fallible_iterator(std::move(I), &Err);
95 return fallible_iterator(std::move(I), nullptr);
130 handleError(std::move(Err));
146 handleError(std::move(Err));
198 : I(std::move(I)), ErrState(Err, false) {}
207 *getErrPtr() = std::move(Err);
224 return fallible_iterator<Underlying>::itr(std::move(I), Err);
231 return fallible_iterator<Underlying>::end(std::move(E));
237 return make_range(make_fallible_itr(std::move(I), Err),
238 make_fallible_end(std::move(E)));
include/llvm/ADT/ilist.h 201 : TraitsT(std::move(X)), IntrusiveListT(std::move(X)) {}
201 : TraitsT(std::move(X)), IntrusiveListT(std::move(X)) {}
398 iplist(iplist &&X) : iplist_impl_type(std::move(X)) {}
include/llvm/ADT/iterator.h 88 ReferenceProxy(DerivedT I) : I(std::move(I)) {}
215 explicit iterator_adaptor_base(WrappedIteratorT u) : I(std::move(u)) {
321 : pointer_iterator::iterator_adaptor_base(std::move(u)) {}
include/llvm/ADT/iterator_range.h 42 : begin_iterator(std::move(begin_iterator)),
43 end_iterator(std::move(end_iterator)) {}
55 return iterator_range<T>(std::move(x), std::move(y));
55 return iterator_range<T>(std::move(x), std::move(y));
59 return iterator_range<T>(std::move(p.first), std::move(p.second));
59 return iterator_range<T>(std::move(p.first), std::move(p.second));
include/llvm/Analysis/AliasAnalysis.h 1187 : ImmutablePass(ID), CB(std::move(CB)) {
include/llvm/Analysis/BasicAliasAnalysis.h 77 : AAResultBase(std::move(Arg)), DL(Arg.DL), F(Arg.F), TLI(Arg.TLI),
include/llvm/Analysis/BranchProbabilityInfo.h 62 : Probs(std::move(Arg.Probs)), LastF(Arg.LastF),
63 PostDominatedByUnreachable(std::move(Arg.PostDominatedByUnreachable)),
64 PostDominatedByColdCall(std::move(Arg.PostDominatedByColdCall)) {}
71 Probs = std::move(RHS.Probs);
72 PostDominatedByColdCall = std::move(RHS.PostDominatedByColdCall);
73 PostDominatedByUnreachable = std::move(RHS.PostDominatedByUnreachable);
include/llvm/Analysis/CGSCCPassManager.h 334 : Pass(std::move(Pass)) {}
343 : Pass(std::move(Arg.Pass)) {}
368 return ModuleToPostOrderCGSCCPassAdaptor<CGSCCPassT>(std::move(Pass));
434 : Pass(std::move(Pass)) {}
442 : Pass(std::move(Arg.Pass)) {}
498 PA.intersect(std::move(PassPA));
535 return CGSCCToFunctionPassAdaptor<FunctionPassT>(std::move(Pass));
557 : Pass(std::move(Pass)), MaxIterations(MaxIterations) {}
625 PA.intersect(std::move(PassPA));
684 PA.intersect(std::move(PassPA));
694 PA.intersect(std::move(PassPA));
704 CallCounts = std::move(NewCallCounts);
709 PA.intersect(std::move(PassPA));
728 return DevirtSCCRepeatedPass<PassT>(std::move(Pass), MaxIterations);
896 PA.intersect(std::move(PassPA));
include/llvm/Analysis/DDG.h 52 DDGNode(DDGNode &&N) : DDGNodeBase(std::move(N)), Kind(N.Kind) {}
62 DGNode::operator=(std::move(N));
90 RootDDGNode(RootDDGNode &&N) : DDGNode(std::move(N)) {}
116 DDGNode::operator=(std::move(N));
117 InstList = std::move(N.InstList);
171 DDGEdge(DDGEdge &&E) : DDGEdgeBase(std::move(E)), Kind(E.Kind) {}
179 DDGEdgeBase::operator=(std::move(E));
212 : Name(std::move(G.Name)), DI(std::move(G.DI)), Root(G.Root) {}
212 : Name(std::move(G.Name)), DI(std::move(G.DI)), Root(G.Root) {}
252 : DDGBase(std::move(G)), DDGInfo(std::move(G)) {}
252 : DDGBase(std::move(G)), DDGInfo(std::move(G)) {}
include/llvm/Analysis/IVUsers.h 114 : L(std::move(X.L)), AC(std::move(X.AC)), DT(std::move(X.DT)),
114 : L(std::move(X.L)), AC(std::move(X.AC)), DT(std::move(X.DT)),
114 : L(std::move(X.L)), AC(std::move(X.AC)), DT(std::move(X.DT)),
115 SE(std::move(X.SE)), Processed(std::move(X.Processed)),
115 SE(std::move(X.SE)), Processed(std::move(X.Processed)),
116 IVUses(std::move(X.IVUses)), EphValues(std::move(X.EphValues)) {
116 IVUses(std::move(X.IVUses)), EphValues(std::move(X.EphValues)) {
include/llvm/Analysis/IntervalIterator.h 109 : IntStack(std::move(x.IntStack)), Visited(std::move(x.Visited)),
109 : IntStack(std::move(x.IntStack)), Visited(std::move(x.Visited)),
include/llvm/Analysis/LoopAnalysisManager.h 91 : InnerAM(std::move(Arg.InnerAM)), LI(Arg.LI), MSSAUsed(Arg.MSSAUsed) {
include/llvm/Analysis/LoopInfo.h 520 : Start(std::move(Start)), End(std::move(End)) {}
520 : Start(std::move(Start)), End(std::move(End)) {}
865 : BBMap(std::move(Arg.BBMap)),
866 TopLevelLoops(std::move(Arg.TopLevelLoops)),
867 LoopAllocator(std::move(Arg.LoopAllocator)) {
872 BBMap = std::move(RHS.BBMap);
877 TopLevelLoops = std::move(RHS.TopLevelLoops);
878 LoopAllocator = std::move(RHS.LoopAllocator);
1050 LoopInfo(LoopInfo &&Arg) : BaseT(std::move(static_cast<BaseT &>(Arg))) {}
1052 BaseT::operator=(std::move(static_cast<BaseT &>(RHS)));
include/llvm/Analysis/MemorySSA.h 936 Result(std::unique_ptr<MemorySSA> &&MSSA) : MSSA(std::move(MSSA)) {}
include/llvm/Analysis/MustExecute.h 283 : Visited(std::move(Other.Visited)), Explorer(Other.Explorer),
include/llvm/Analysis/ObjCARCAliasAnalysis.h 45 : AAResultBase(std::move(Arg)), DL(Arg.DL) {}
include/llvm/Analysis/ProfileSummaryInfo.h 68 : M(Arg.M), Summary(std::move(Arg.Summary)) {}
include/llvm/Analysis/PtrUseVisitor.h 239 Offset = std::move(ToVisit.Offset);
include/llvm/Analysis/RegionInfo.h 699 : DT(std::move(Arg.DT)), PDT(std::move(Arg.PDT)), DF(std::move(Arg.DF)),
699 : DT(std::move(Arg.DT)), PDT(std::move(Arg.PDT)), DF(std::move(Arg.DF)),
699 : DT(std::move(Arg.DT)), PDT(std::move(Arg.PDT)), DF(std::move(Arg.DF)),
700 TopLevelRegion(std::move(Arg.TopLevelRegion)),
701 BBtoRegion(std::move(Arg.BBtoRegion)) {
706 DT = std::move(RHS.DT);
707 PDT = std::move(RHS.PDT);
708 DF = std::move(RHS.DF);
709 TopLevelRegion = std::move(RHS.TopLevelRegion);
710 BBtoRegion = std::move(RHS.BBtoRegion);
910 RegionInfo(RegionInfo &&Arg) : Base(std::move(static_cast<Base &>(Arg))) {
915 Base::operator=(std::move(static_cast<Base &>(RHS)));
include/llvm/Analysis/RegionInfoImpl.h 369 at = BBNodeMap.insert(std::move(V)).first;
387 To->children.push_back(std::move(R));
423 SubRegion->children.push_back(std::move(R));
425 Keep.push_back(std::move(R));
include/llvm/Analysis/ScalarEvolution.h 1258 MaxNotTaken(ExactNotTaken), Predicate(std::move(Predicate)) {}
1435 auto Pair = Cache.try_emplace(S, std::move(CR));
1437 Pair.first->second = std::move(CR);
include/llvm/Analysis/ScalarEvolutionAliasAnalysis.h 31 SCEVAAResult(SCEVAAResult &&Arg) : AAResultBase(std::move(Arg)), SE(Arg.SE) {}
include/llvm/Analysis/ScalarEvolutionExpander.h 286 Builder.SetCurrentDebugLocation(std::move(L));
include/llvm/Analysis/SparsePropagation.h 240 return ValueState[Key] = std::move(LV);
252 ValueState[Key] = std::move(LV);
320 std::move(BCValue), BI->getCondition()->getType()));
358 std::move(SCValue), SI.getCondition()->getType()));
406 UpdateState(std::move(ChangedValue.first),
407 std::move(ChangedValue.second));
include/llvm/Analysis/TargetLibraryInfo.h 361 : PresetInfoImpl(std::move(PresetInfoImpl)) {}
include/llvm/Analysis/TargetTransformInfo.h 1384 Model(T Impl) : Impl(std::move(Impl)) {}
1890 : TTICallback(std::move(Arg.TTICallback)) {}
1896 TTICallback = std::move(RHS.TTICallback);
include/llvm/Analysis/ValueLattice.h 133 Res.markConstantRange(std::move(CR));
223 Range = std::move(NewR);
233 new (&Range) ConstantRange(std::move(NewR));
280 markConstantRange(std::move(NewR));
include/llvm/Bitcode/BitcodeReader.h 44 return std::move(*Val);
include/llvm/Bitstream/BitstreamReader.h 212 return std::move(fillResult);
428 return std::move(Err);
451 return std::move(Err);
514 CurAbbrevs = std::move(BlockScope.back().PrevAbbrevs);
include/llvm/Bitstream/BitstreamWriter.h 246 CurAbbrevs = std::move(B.PrevAbbrevs);
492 CurAbbrevs.push_back(std::move(Abbv));
538 Info.Abbrevs.push_back(std::move(Abbv));
include/llvm/CodeGen/AsmPrinter.h 155 : Handler(std::move(Handler)), TimerName(TimerName),
include/llvm/CodeGen/DFAPacketizer.h 85 InstrItins(InstrItins), A(std::move(a)) {
include/llvm/CodeGen/FastISel.h 118 Args = std::move(ArgsList);
142 Args = std::move(ArgsList);
156 Args = std::move(ArgsList);
172 Args = std::move(ArgsList);
include/llvm/CodeGen/GCMetadata.h 61 : Label(L), Loc(std::move(DL)) {}
include/llvm/CodeGen/GlobalISel/CSEInfo.h 145 CSEOpt = std::move(Opt);
include/llvm/CodeGen/MIRYamlMapping.h 39 StringValue(std::string Value) : Value(std::move(Value)) {}
65 FlowStringValue(std::string Value) : StringValue(std::move(Value)) {}
include/llvm/CodeGen/MachineFunction.h 987 CallSitesInfo[CallI] = std::move(CallInfo);
include/llvm/CodeGen/MachineInstr.h 1564 debugLoc = std::move(dl);
include/llvm/CodeGen/MachinePipeliner.h 278 Mutations.push_back(std::move(Mutation));
include/llvm/CodeGen/MachineScheduler.h 291 LIS(C->LIS), SchedImpl(std::move(S)) {}
316 Mutations.push_back(std::move(Mutation));
426 : ScheduleDAGMI(C, std::move(S), /*RemoveKillFlags=*/false),
include/llvm/CodeGen/ModuloSchedule.h 109 : Loop(Loop), ScheduledInstrs(ScheduledInstrs), Cycle(std::move(Cycle)),
110 Stage(std::move(Stage)) {
259 InstrChanges(std::move(InstrChanges)) {}
include/llvm/CodeGen/PBQP/CostAllocator.h 37 : Pool(Pool), Value(std::move(Value)) {}
101 auto P = std::make_shared<PoolEntry>(*this, std::move(ValueKey));
103 return PoolRef(std::move(P), &P->getValue());
119 return VectorPool.getValue(std::move(v));
123 return MatrixPool.getValue(std::move(m));
include/llvm/CodeGen/PBQP/Graph.h 68 NodeEntry(VectorPtr Costs) : Costs(std::move(Costs)) {}
104 : Costs(std::move(Costs)) {
197 Nodes[NId] = std::move(N);
200 Nodes.push_back(std::move(N));
212 Edges[EId] = std::move(E);
215 Edges.push_back(std::move(E));
344 Graph(GraphMetadata Metadata) : Metadata(std::move(Metadata)) {}
377 VectorPtr AllocatedCosts = CostAlloc.getVector(std::move(Costs));
414 MatrixPtr AllocatedCosts = CostAlloc.getMatrix(std::move(Costs));
467 VectorPtr AllocatedCosts = CostAlloc.getVector(std::move(Costs));
509 MatrixPtr AllocatedCosts = CostAlloc.getMatrix(std::move(Costs));
include/llvm/CodeGen/PBQP/Math.h 47 : Length(V.Length), Data(std::move(V.Data)) {
148 : Rows(M.Rows), Cols(M.Cols), Data(std::move(M.Data)) {
258 MDVector(Vector &&v) : Vector(std::move(v)), md(*this) { }
275 MDMatrix(Matrix &&m) : Matrix(std::move(m)), md(*this) { }
include/llvm/CodeGen/PBQPRAConstraint.h 59 Constraints.push_back(std::move(C));
include/llvm/CodeGen/RegAllocPBQP.h 158 return AllowedRegVecs.getValue(std::move(Allowed));
204 this->AllowedRegs = std::move(AllowedRegs);
505 PBQPRAGraph(GraphMetadata Metadata) : BaseT(std::move(Metadata)) {}
include/llvm/CodeGen/SelectionDAG.h 320 : DAGUpdateListener(DAG), Callback(std::move(Callback)) {}
1692 SDCallSiteDbgInfo[CallNode].CSInfo = std::move(CallInfo);
1698 return std::move(I->second).CSInfo;
include/llvm/CodeGen/SelectionDAGNodes.h 770 void setDebugLoc(DebugLoc dl) { debugLoc = std::move(dl); }
1107 IROrder(Order), debugLoc(std::move(dl)) {
include/llvm/CodeGen/StackMaps.h 259 : CSOffsetExpr(CSOffsetExpr), ID(ID), Locations(std::move(Locations)),
260 LiveOuts(std::move(LiveOuts)) {}
include/llvm/CodeGen/SwitchLoweringUtils.h 184 : First(std::move(F)), Last(std::move(L)), SValue(SV), HeaderBB(H),
184 : First(std::move(F)), Last(std::move(L)), SValue(SV), HeaderBB(H),
220 : First(std::move(F)), Range(std::move(R)), SValue(SV), Reg(Rg),
220 : First(std::move(F)), Range(std::move(R)), SValue(SV), Reg(Rg),
222 Cases(std::move(C)), Prob(Pr), OmitRangeCheck(false) {}
include/llvm/CodeGen/TargetLowering.h 3487 Args = std::move(ArgsList);
3500 Args = std::move(ArgsList);
3523 Args = std::move(ArgsList);
3888 : InlineAsm::ConstraintInfo(std::move(Info)) {}
include/llvm/DebugInfo/CodeView/CVRecord.h 103 return std::move(EC);
110 return std::move(EC);
include/llvm/DebugInfo/CodeView/SymbolDeserializer.h 51 return std::move(EC);
include/llvm/DebugInfo/CodeView/SymbolDumper.h 32 ObjDelegate(std::move(ObjDelegate)), CompilationCPUType(CPU),
include/llvm/DebugInfo/CodeView/TypeDeserializer.h 63 return std::move(EC);
include/llvm/DebugInfo/CodeView/TypeRecord.h 565 : TypeRecord(TypeRecordKind::VFTableShape), Slots(std::move(Slots)) {}
841 Value(std::move(Value)), Name(Name) {}
844 Value(std::move(Value)), Name(Name) {}
include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h 274 : Code(Code), Tag(Tag), Attributes(std::move(Attributes)) {}
include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h 178 Version(Version), Augmentation(std::move(Augmentation)),
183 AugmentationData(std::move(AugmentationData)),
include/llvm/DebugInfo/DWARF/DWARFListTable.h 283 return std::move(E);
include/llvm/DebugInfo/DWARF/DWARFVerifier.h 52 : Ranges(std::move(Ranges)) {}
include/llvm/DebugInfo/PDB/ConcreteSymbolEnumerator.h 26 : Enumerator(std::move(SymbolEnumerator)) {}
include/llvm/DebugInfo/PDB/Native/HashTable.h 254 return set_as_internal(K, std::move(V), Traits, None);
include/llvm/DebugInfo/PDB/Native/SymbolCache.h 67 consumeError(std::move(EC));
72 TI, std::move(Record), std::forward<Args>(ConstructorArgs)...);
95 Cache.push_back(std::move(Result));
include/llvm/DebugInfo/PDB/Native/TpiHashing.h 23 : FullRecordHash(Full), ForwardDeclHash(Forward), Class(std::move(CR)) {
29 : FullRecordHash(Full), ForwardDeclHash(Forward), Enum(std::move(ER)) {
35 : FullRecordHash(Full), ForwardDeclHash(Forward), Union(std::move(UR)) {
include/llvm/DebugInfo/PDB/PDBSymbol.h 92 std::unique_ptr<PDBSymbol> S = create(PDBSession, std::move(RawSymbol));
93 return unique_dyn_cast_or_null<ConcreteT>(std::move(S));
99 return unique_dyn_cast_or_null<ConcreteT>(std::move(S));
134 return std::make_unique<ConcreteSymbolEnumerator<T>>(std::move(BaseIter));
include/llvm/Demangle/ItaniumDemangle.h 5509 auto OldParams = std::move(TemplateParams);
5511 TemplateParams = std::move(OldParams);
include/llvm/Demangle/Utility.h 153 Restore = std::move(NewVal);
157 Restore = std::move(OriginalValue);
include/llvm/ExecutionEngine/ExecutionEngine.h 174 Modules.push_back(std::move(M));
492 LazyFunctionCreator = std::move(C);
496 ExecutionEngine(DataLayout DL) : DL(std::move(DL)) {}
include/llvm/ExecutionEngine/JITLink/JITLink.h 709 : Name(std::move(Name)), PointerSize(PointerSize),
727 Sections.push_back(std::move(Sec));
967 Impl(Continuation C) : C(std::move(C)) {}
968 void run(Expected<AsyncLookupResult> LR) override { C(std::move(LR)); }
974 return std::make_unique<Impl>(std::move(Cont));
include/llvm/ExecutionEngine/JITSymbol.h 211 void setFlags(JITSymbolFlags Flags) { this->Flags = std::move(Flags); }
231 : Err(std::move(Err)), Flags(JITSymbolFlags::HasError) {}
251 : GetAddress(std::move(GetAddress)), CachedAddr(0), Flags(Flags) {}
257 : GetAddress(std::move(Other.GetAddress)), Flags(std::move(Other.Flags)) {
257 : GetAddress(std::move(Other.GetAddress)), Flags(std::move(Other.Flags)) {
259 Err = std::move(Other.Err);
261 CachedAddr = std::move(Other.CachedAddr);
265 GetAddress = std::move(Other.GetAddress);
266 Flags = std::move(Other.Flags);
268 Err = std::move(Other.Err);
270 CachedAddr = std::move(Other.CachedAddr);
289 return std::move(Err);
include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h 106 : ImplD(ImplD), ISMgr(std::move(ISMgr)) {}
152 LambdaMaterializer(MaterializerFtor M) : M(std::move(M)) {}
163 return LambdaMaterializer<MaterializerFtor>(std::move(M));
210 : K(std::move(K)), BackingResolver(std::move(BackingResolver)),
210 : K(std::move(K)), BackingResolver(std::move(BackingResolver)),
211 StubsMgr(std::move(StubsMgr)) {}
216 SourceModules.back().SourceMod = std::move(M);
236 return std::move(Err);
292 GetSymbolResolver(std::move(GetSymbolResolver)),
293 SetSymbolResolver(std::move(SetSymbolResolver)),
294 Partition(std::move(Partition)), CompileCallbackMgr(CallbackMgr),
295 CreateIndirectStubsManager(std::move(CreateIndirectStubsManager)),
313 return addLogicalModule(I->second, std::move(M));
318 return addLogicalModule(LogicalDylibs[K], std::move(M));
344 return std::move(Err);
391 auto LMId = LD.addSourceModule(std::move(SrcMPtr));
408 return std::move(Err);
428 CompileCallbackMgr.getCompileCallback(std::move(CompileAction)))
521 return std::move(Err);
560 SetSymbolResolver(LD.K, std::move(GVsResolver));
562 if (auto Err = BaseLayer.addModule(LD.K, std::move(GVsM)))
614 return std::move(Err);
727 std::move(NotFoundViaLegacyLookup));
729 SetSymbolResolver(K, std::move(Resolver));
731 if (auto Err = BaseLayer.addModule(std::move(K), std::move(M)))
731 if (auto Err = BaseLayer.addModule(std::move(K), std::move(M)))
732 return std::move(Err);
760 GetSymbolResolver(std::move(GetSymbolResolver)),
761 SetSymbolResolver(std::move(SetSymbolResolver)),
762 Partition(std::move(Partition)), CompileCallbackMgr(CallbackMgr),
include/llvm/ExecutionEngine/Orc/CompileUtils.h 64 : SimpleCompiler(*TM, ObjCache), TM(std::move(TM)) {}
include/llvm/ExecutionEngine/Orc/Core.h 64 : Aliasee(std::move(Aliasee)), AliasFlags(AliasFlags) {}
285 : SymbolFlags(std::move(InitalSymbolFlags)), K(std::move(K)) {}
285 : SymbolFlags(std::move(InitalSymbolFlags)), K(std::move(K)) {}
300 materialize(MaterializationResponsibility(JD, std::move(SymbolFlags),
301 std::move(K)));
308 discard(JD, std::move(Name));
364 std::move(Symbols), std::move(K));
364 std::move(Symbols), std::move(K));
408 nullptr, true, std::move(Aliases), std::move(K));
408 nullptr, true, std::move(Aliases), std::move(K));
420 &SourceJD, MatchNonExported, std::move(Aliases), std::move(K));
420 &SourceJD, MatchNonExported, std::move(Aliases), std::move(K));
631 : MU(std::move(MU)) {}
647 return std::move(PendingQueries);
819 this->ReportError = std::move(ReportError);
826 void reportError(Error Err) { ReportError(std::move(Err)); }
831 this->DispatchMaterialization = std::move(DispatchMaterialization);
909 DispatchMaterialization(JD, std::move(MU));
917 logAllUnhandledErrors(std::move(Err), errs(), "JIT session error: ");
948 [&]() { DefGenerators.push_back(std::move(DefGenerator)); });
966 auto UMI = std::make_shared<UnmaterializedInfo>(std::move(MU));
983 auto UMI = std::make_shared<UnmaterializedInfo>(std::move(MU));
include/llvm/ExecutionEngine/Orc/ExecutionUtils.h 111 : CtorDtorNames(std::move(CtorDtorNames)), K(K) {}
144 : CtorDtorNames(std::move(CtorDtorNames)), K(K) {}
268 return Load(nullptr, GlobalPrefix, std::move(Allow));
include/llvm/ExecutionEngine/Orc/GlobalMappingLayer.h 51 return BaseLayer.addModule(std::move(M), std::move(Resolver));
51 return BaseLayer.addModule(std::move(M), std::move(Resolver));
include/llvm/ExecutionEngine/Orc/IRCompileLayer.h 79 : BaseLayer(BaseLayer), Compile(std::move(Compile)),
80 NotifyCompiled(std::move(NotifyCompiled)) {}
87 this->NotifyCompiled = std::move(NotifyCompiled);
93 if (auto Err = BaseLayer.addObject(std::move(K), Compile(*M)))
96 NotifyCompiled(std::move(K), std::move(M));
96 NotifyCompiled(std::move(K), std::move(M));
140 NotifyCompiled(std::move(NotifyCompiled)) {}
include/llvm/ExecutionEngine/Orc/IRTransformLayer.h 37 this->Transform = std::move(Transform);
72 : BaseLayer(BaseLayer), Transform(std::move(Transform)) {}
79 return BaseLayer.addModule(std::move(K), Transform(std::move(M)));
79 return BaseLayer.addModule(std::move(K), Transform(std::move(M)));
include/llvm/ExecutionEngine/Orc/IndirectionUtils.h 80 new LocalTrampolinePool(std::move(GetTrampolineLanding), Err));
83 return std::move(Err);
84 return std::move(LTP);
93 return std::move(Err);
117 : GetTrampolineLanding(std::move(GetTrampolineLanding)) {
172 TrampolineBlocks.push_back(std::move(TrampolineBlock));
203 : TP(std::move(TP)), ES(ES),
208 this->TP = std::move(TP);
232 return std::move(Err);
233 return std::move(CCMgr);
255 setTrampolinePool(std::move(*TP));
373 IndirectStubsInfos.push_back(std::move(ISI));
include/llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h 72 this->CPU = std::move(CPU);
78 this->RM = std::move(RM);
84 this->CM = std::move(CM);
include/llvm/ExecutionEngine/Orc/LLJIT.h 67 return ES->createJITDylib(std::move(Name));
78 return addIRModule(Main, std::move(TSM));
86 return addObjectFile(Main, std::move(Obj));
158 TransformLayer->setTransform(std::move(Transform));
164 CODLayer->setPartitionFunction(std::move(Partition));
172 return addLazyIRModule(Main, std::move(M));
212 impl().JTMB = std::move(JTMB);
228 impl().CreateObjectLinkingLayer = std::move(CreateObjectLinkingLayer);
240 impl().CreateCompileFunction = std::move(CreateCompileFunction);
260 return std::move(Err);
265 return std::move(Err);
266 return std::move(J);
311 this->impl().LCTMgr = std::move(LCTMgr);
321 this->impl().ISMBuilder = std::move(ISMBuilder);
include/llvm/ExecutionEngine/Orc/LambdaResolver.h 77 std::move(DylibLookupFtor),
78 std::move(ExternalLookupFtor));
include/llvm/ExecutionEngine/Orc/LazyEmittingLayer.h 46 : K(std::move(K)), M(std::move(M)) {}
46 : K(std::move(K)), M(std::move(M)) {}
60 return std::move(Err);
66 return std::move(Err);
71 return JITSymbol(std::move(GetAddress), Flags);
131 return BaseLayer.addModule(std::move(K), std::move(M));
131 return BaseLayer.addModule(std::move(K), std::move(M));
179 MangledSymbols = std::move(Symbols);
208 std::make_unique<EmissionDeferredModule>(std::move(K), std::move(M));
208 std::make_unique<EmissionDeferredModule>(std::move(K), std::move(M));
include/llvm/ExecutionEngine/Orc/LazyReexports.h 59 : NotifyResolved(std::move(NotifyResolved)) {}
75 std::move(NotifyResolved));
92 this->TP = std::move(TP);
126 setTrampolinePool(std::move(*TP));
140 return std::move(Err);
142 return std::move(LLCTM);
190 LCTManager, ISManager, SourceJD, std::move(CallableAliases), SrcJDLoc,
191 std::move(K));
include/llvm/ExecutionEngine/Orc/Legacy.h 64 return Lookup(std::move(Query), std::move(Symbols));
64 return Lookup(std::move(Query), std::move(Symbols));
126 return std::move(Err);
159 ES.legacyFailQuery(Query, std::move(Err));
180 : ES(ES), LegacyLookup(std::move(LegacyLookup)),
181 ReportError(std::move(ReportError)) {}
186 return std::move(*ResponsibilitySet);
209 ES, std::move(LegacyLookup), std::move(ErrorReporter));
209 ES, std::move(LegacyLookup), std::move(ErrorReporter));
include/llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h 91 this->ReturnObjectBuffer = std::move(ReturnObjectBuffer);
97 Plugins.push_back(std::move(P));
include/llvm/ExecutionEngine/Orc/ObjectTransformLayer.h 62 : BaseLayer(BaseLayer), Transform(std::move(Transform)) {}
70 return BaseLayer.addObject(std::move(K), Transform(std::move(Obj)));
70 return BaseLayer.addObject(std::move(K), Transform(std::move(Obj)));
include/llvm/ExecutionEngine/Orc/OrcABISupport.h 81 : NumStubs(NumStubs), StubsMem(std::move(StubsMem)) {}
83 : NumStubs(Other.NumStubs), StubsMem(std::move(Other.StubsMem)) {
90 StubsMem = std::move(Other.StubsMem);
include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h 174 Unfinalized.push_back(std::move(ObjAllocs));
200 handleAllErrors(std::move(Err), [&](ErrorInfoBase &EIB) {
209 RegisteredEHFrames = std::move(UnfinalizedEHFrames);
460 return std::move(Err);
509 return std::move(Err);
510 return std::move(Client);
544 return std::move(Err);
555 return std::move(Err);
565 return std::move(Err);
609 ES.reportError(std::move(Err));
624 ES.reportError(std::move(Err));
665 ES.reportError(std::move(Err));
673 ES.reportError(std::move(Err));
include/llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h 36 : ResourceId(std::move(ResourceId)),
37 ResourceDescription(std::move(ResourceDescription)) {}
148 : NextId(std::move(FirstValidId)) {}
include/llvm/ExecutionEngine/Orc/OrcRemoteTargetServer.h 60 SymbolLookup(std::move(SymbolLookup)),
61 EHFramesRegister(std::move(EHFramesRegister)),
62 EHFramesDeregister(std::move(EHFramesDeregister)) {
112 Allocs = std::move(Other.Allocs);
130 Allocs[MB.base()] = std::move(MB);
268 return std::move(Err);
277 BlockList.push_back(std::move(IS));
319 TrampolineBlocks.push_back(std::move(TrampolineBlock));
385 return std::move(Err);
include/llvm/ExecutionEngine/Orc/RPCSerialization.h 354 std::make_pair(std::move(Name),
355 std::move(Deserialize)));
363 [KeyName, Serialize = std::move(Serialize)](
380 return handleErrors(std::move(Err),
415 return serialize(C, make_error<StringError>(std::move(ErrMsg),
448 std::move(Name),
469 make_error<StringError>(std::move(Msg),
504 ValOrErr = std::move(Err);
525 return serializeSeq(C, Expected<T>(std::move(Err)));
include/llvm/ExecutionEngine/Orc/RPCUtils.h 64 : FnId(std::move(FnId)), SeqNo(std::move(SeqNo)) {}
64 : FnId(std::move(FnId)), SeqNo(std::move(SeqNo)) {}
97 : SeqNo(std::move(SeqNo)) {}
273 consumeError(std::move(Err));
337 C, std::move(ResultOrErr)))
353 if (auto Err2 = serializeSeq(C, std::move(Err)))
414 template sendResult<WireRetT>(C, ResponseId, SeqNo, std::move(ResultOrErr));
424 sendResult(C, ResponseId, SeqNo, std::move(Err));
531 Handler(std::move(Args)...);
540 return Handler(std::move(Args)...);
568 return run(Handler, std::move(std::get<Indexes>(Args))...);
577 return run(Handler, Responder, std::move(std::get<Indexes>(Args))...);
648 ResponseHandlerImpl(HandlerT Handler) : Handler(std::move(Handler)) {}
662 return Handler(std::move(Result));
670 report_fatal_error(std::move(Err));
683 ResponseHandlerImpl(HandlerT Handler) : Handler(std::move(Handler)) {}
699 report_fatal_error(std::move(Err));
711 ResponseHandlerImpl(HandlerT Handler) : Handler(std::move(Handler)) {}
726 return Handler(std::move(Result));
734 report_fatal_error(std::move(Err));
746 ResponseHandlerImpl(HandlerT Handler) : Handler(std::move(Handler)) {}
754 consumeError(std::move(Result));
758 consumeError(std::move(Result));
761 return Handler(std::move(Result));
769 report_fatal_error(std::move(Err));
781 std::move(H));
793 return (Instance.*Method)(std::move(Args)...);
1043 std::move(Handler));
1072 if (auto Err = appendCallAsync<Func>(std::move(Handler), Args...))
1168 Handlers[NewFnId] = wrapHandler<Func>(std::move(Handler));
1183 Handlers[NewFnId] = wrapAsyncHandler<Func>(std::move(Handler));
1196 PRHandler = std::move(I->second);
1328 std::move(RetVal));
1489 return this->template addHandlerImpl<Func>(std::move(Handler));
1500 return this->template addAsyncHandlerImpl<Func>(std::move(Handler));
1524 Result = std::move(R);
1530 std::move(Result));
1531 return std::move(Err);
1536 std::move(Result));
1537 return std::move(Err);
1543 std::move(Result));
1544 return std::move(Err);
1560 return Endpoint.template appendCallAsync<Func>(std::move(Handler), Args...);
1599 auto WrappedHandler = [this, Handler = std::move(Handler)](ArgType Arg) {
1600 auto Err = Handler(std::move(Arg));
1607 return AsyncDispatch(std::move(WrappedHandler), Args...);
include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h 63 this->NotifyLoaded = std::move(NotifyLoaded);
70 this->NotifyEmitted = std::move(NotifyEmitted);
216 : K(std::move(K)),
218 MemMgr(std::move(MemMgr)),
220 std::move(Obj), std::move(Resolver),
220 std::move(Obj), std::move(Resolver),
266 ObjForNotify = std::move(PFC->Obj); // needed for callback
277 return std::move(Err);
317 : Obj(std::move(Obj)),
318 Resolver(std::move(Resolver)),
341 return std::make_unique<LOS>(Parent, std::move(K), std::move(Obj),
341 return std::make_unique<LOS>(Parent, std::move(K), std::move(Obj),
342 std::move(MemMgr), std::move(Resolver),
342 std::move(MemMgr), std::move(Resolver),
373 : ES(ES), GetResources(std::move(GetResources)),
374 NotifyLoaded(std::move(NotifyLoaded)),
375 NotifyFinalized(std::move(NotifyFinalized)),
376 NotifyFreed(std::move(NotifyFreed)), ProcessAllSections(false) {}
401 *this, K, OwnedObject(std::move(*Obj), std::move(ObjBuffer)),
401 *this, K, OwnedObject(std::move(*Obj), std::move(ObjBuffer)),
402 std::move(R.MemMgr), std::move(R.Resolver), ProcessAllSections);
402 std::move(R.MemMgr), std::move(R.Resolver), ProcessAllSections);
431 return std::move(Err);
include/llvm/ExecutionEngine/Orc/RemoteObjectLayer.h 116 : Remote(Remote), ReportError(std::move(ReportError)),
176 return handleErrors(std::move(Err),
181 return Error(std::move(EIB));
200 InUseSymbols.insert(std::make_pair(Id, std::move(Sym)));
203 return teeLog(std::move(Err));
217 [RSM = std::move(RSM)]() mutable { return RSM.materialize(); },
232 ReportError(std::move(Err));
320 : RemoteObjectLayer<RPCEndpoint>(Remote, std::move(ReportError)) {
339 Resolvers[Handle] = std::move(Resolver);
433 : RemoteObjectLayer<RPCEndpoint>(Remote, std::move(ReportError)),
449 : Buffer(std::move(Buffer)) {
470 auto Buffer = std::make_unique<StringMemoryBuffer>(std::move(ObjBuffer));
482 BaseLayer.addObject(std::move(Buffer), std::move(Resolver))) {
482 BaseLayer.addObject(std::move(Buffer), std::move(Resolver))) {
483 BaseLayerHandles[Id] = std::move(*HandleOrErr);
493 return teeLog(std::move(Err));
502 return this->jitSymbolToRemote(std::move(Sym));
504 return teeLog(std::move(Err));
513 return this->jitSymbolToRemote(std::move(Sym));
515 return teeLog(std::move(Err));
525 return teeLog(std::move(Err));
539 : RemoteObjectLayer<RPCEndpoint>(Remote, std::move(ReportError)) {
550 : RemoteObjectLayer<RPCEndpoint>(Remote, std::move(ReportError)),
include/llvm/ExecutionEngine/Orc/Speculation.h 75 GlobalSpecMap.insert({ImplAddr, std::move(likelySymbols)});
117 ES.reportError(std::move(Err));
149 registerSymbolsWithAddr(RAddr, std::move(Likely));
193 InternedNames[Mangle(NamePair.first)] = std::move(TargetJITNames);
include/llvm/ExecutionEngine/Orc/ThreadSafeModule.h 32 State(std::unique_ptr<LLVMContext> Ctx) : Ctx(std::move(Ctx)) {}
42 Lock(std::shared_ptr<State> S) : S(std::move(S)), L(this->S->Mutex) {}
54 : S(std::make_shared<State>(std::move(NewCtx))) {
96 M = std::move(Other.M);
97 TSCtx = std::move(Other.TSCtx);
105 : M(std::move(M)), TSCtx(std::move(Ctx)) {}
105 : M(std::move(M)), TSCtx(std::move(Ctx)) {}
110 : M(std::move(M)), TSCtx(std::move(TSCtx)) {}
110 : M(std::move(M)), TSCtx(std::move(TSCtx)) {}
include/llvm/ExecutionEngine/RuntimeDyld.h 46 RuntimeDyldError(std::string ErrMsg) : ErrMsg(std::move(ErrMsg)) {}
77 : RTDyld(RTDyld), ObjSecToIDMap(std::move(ObjSecToIDMap)) {}
222 this->NotifyStubEmitted = std::move(NotifyStubEmitted);
include/llvm/FuzzMutate/IRMutator.h 67 : AllowedTypes(std::move(AllowedTypes)),
68 Strategies(std::move(Strategies)) {}
82 : Operations(std::move(Operations)) {}
include/llvm/IR/ConstantRange.h 87 return ConstantRange(std::move(Lower), std::move(Upper));
87 return ConstantRange(std::move(Lower), std::move(Upper));
include/llvm/IR/DIBuilder.h 878 return cast<NodeTy>(MDNode::replaceWithUniqued(std::move(N)));
include/llvm/IR/IRBuilder.h 77 : Callback(std::move(Callback)) {}
156 void SetCurrentDebugLocation(DebugLoc L) { CurDbgLocation = std::move(L); }
801 : IRBuilderBase(C, FPMathTag, OpBundles), Inserter(std::move(I)),
include/llvm/IR/InstrTypes.h 1064 : Tag(std::move(Tag)), Inputs(std::move(Inputs)) {}
1064 : Tag(std::move(Tag)), Inputs(std::move(Inputs)) {}
1066 : Tag(std::move(Tag)), Inputs(Inputs) {}
include/llvm/IR/Instruction.h 328 void setDebugLoc(DebugLoc Loc) { DbgLoc = std::move(Loc); }
include/llvm/IR/ModuleSummaryIndex.h 357 : Kind(K), Flags(Flags), RefEdgeList(std::move(Refs)) {
562 std::vector<ValueInfo>(), std::move(Edges),
600 : GlobalValueSummary(FunctionKind, Flags, std::move(Refs)),
602 CallGraphEdgeList(std::move(CGEdges)) {
607 std::move(TypeTests), std::move(TypeTestAssumeVCalls),
607 std::move(TypeTests), std::move(TypeTestAssumeVCalls),
608 std::move(TypeCheckedLoadVCalls),
609 std::move(TypeTestAssumeConstVCalls),
610 std::move(TypeCheckedLoadConstVCalls)});
769 : GlobalValueSummary(GlobalVarKind, Flags, std::move(Refs)),
785 VTableFuncs = std::make_unique<VTableFuncList>(std::move(Funcs));
1142 addGlobalValueSummary(getOrInsertValueInfo(&GV), std::move(Summary));
1149 std::move(Summary));
1159 ->second.SummaryList.push_back(std::move(Summary));
1424 G.SummaryList.push_back(std::move(Root));
1426 GlobalValueSummaryMapTy::value_type(GlobalValue::GUID(0), std::move(G));
include/llvm/IR/ModuleSummaryIndexYAML.h 228 ArrayRef<FunctionSummary::EdgeTy>{}, std::move(FSum.TypeTests),
229 std::move(FSum.TypeTestAssumeVCalls),
230 std::move(FSum.TypeCheckedLoadVCalls),
231 std::move(FSum.TypeTestAssumeConstVCalls),
232 std::move(FSum.TypeCheckedLoadConstVCalls)));
include/llvm/IR/PassInstrumentation.h 92 BeforePassCallbacks.emplace_back(std::move(C));
96 AfterPassCallbacks.emplace_back(std::move(C));
101 AfterPassInvalidatedCallbacks.emplace_back(std::move(C));
106 BeforeAnalysisCallbacks.emplace_back(std::move(C));
111 AfterAnalysisCallbacks.emplace_back(std::move(C));
include/llvm/IR/PassManager.h 252 *this = std::move(Arg);
478 : Passes(std::move(Arg.Passes)),
479 DebugLogging(std::move(Arg.DebugLogging)) {}
482 Passes = std::move(RHS.Passes);
483 DebugLogging = std::move(RHS.DebugLogging);
528 PA.intersect(std::move(PassPA));
554 Passes.emplace_back(new PassModelT(std::move(Pass)));
1053 Result(Result &&Arg) : InnerAM(std::move(Arg.InnerAM)) {
1287 : Pass(std::move(Pass)) {}
1319 PA.intersect(std::move(PassPA));
1341 return ModuleToFunctionPassAdaptor<FunctionPassT>(std::move(Pass));
1412 RepeatedPass(int Count, PassT P) : Count(Count), P(std::move(P)) {}
1445 return RepeatedPass<PassT>(Count, std::move(P));
include/llvm/IR/PassManagerInternal.h 61 explicit PassModel(PassT Pass) : Pass(std::move(Pass)) {}
169 explicit AnalysisResultModel(ResultT Result) : Result(std::move(Result)) {}
208 explicit AnalysisResultModel(ResultT Result) : Result(std::move(Result)) {}
264 explicit AnalysisPassModel(PassT Pass) : Pass(std::move(Pass)) {}
include/llvm/IR/PatternMatch.h 650 specific_intval(APInt V) : Val(std::move(V)) {}
665 return specific_intval(std::move(V));
include/llvm/IR/ProfileSummary.h 62 : PSK(K), DetailedSummary(std::move(DetailedSummary)),
include/llvm/IR/RemarkStreamer.h 66 handleAllErrors(std::move(E), [&](const ErrorInfoBase &EIB) {
include/llvm/IR/TrackingMDRef.h 113 TypedTrackingMDRef(TypedTrackingMDRef &&X) : Ref(std::move(X.Ref)) {}
117 Ref = std::move(X.Ref);
include/llvm/IR/ValueMap.h 180 Map.insert(std::make_pair(Wrap(KV.first), std::move(KV.second)));
289 ValueT Target(std::move(I->second));
291 Copy.Map->insert(std::make_pair(typed_new_key, std::move(Target)));
include/llvm/LTO/LTO.h 194 NativeObjectStream(std::unique_ptr<raw_pwrite_stream> OS) : OS(std::move(OS)) {}
include/llvm/LTO/legacy/LTOModule.h 120 std::unique_ptr<Module> takeModule() { return std::move(Mod); }
include/llvm/LTO/legacy/ThinLTOCodeGenerator.h 133 void setCacheDir(std::string Path) { CacheOptions.Path = std::move(Path); }
189 void setSaveTempsDir(std::string Path) { SaveTempsDir = std::move(Path); }
196 SavedObjectsDirectoryPath = std::move(Path);
200 void setCpu(std::string Cpu) { TMBuilder.MCpu = std::move(Cpu); }
203 void setAttr(std::string MAttr) { TMBuilder.MAttr = std::move(MAttr); }
207 TMBuilder.Options = std::move(Options);
include/llvm/LineEditor/LineEditor.h 140 ListCompleterModel(T Value) : Value(std::move(Value)) {}
include/llvm/MC/MCAsmMacro.h 77 : Kind(Kind), Str(Str), IntVal(std::move(IntVal)) {}
149 : Name(N), Body(B), Parameters(std::move(P)) {}
include/llvm/MC/MCContext.h 668 SecureLog = std::move(Value);
695 MacroMap.insert(std::make_pair(Name, std::move(Macro)));
include/llvm/MC/MCDisassembler/MCExternalSymbolizer.h 44 : MCSymbolizer(Ctx, std::move(RelInfo)), GetOpInfo(getOpInfo),
include/llvm/MC/MCDisassembler/MCSymbolizer.h 46 : Ctx(Ctx), RelInfo(std::move(RelInfo)) {
include/llvm/MC/MCMachObjectWriter.h 128 : TargetObjectWriter(std::move(MOTW)),
include/llvm/MC/MCWasmStreamer.h 32 : MCObjectStreamer(Context, std::move(TAB), std::move(OW),
32 : MCObjectStreamer(Context, std::move(TAB), std::move(OW),
33 std::move(Emitter)),
include/llvm/MCA/Context.h 64 Hardware.push_back(std::move(H));
include/llvm/MCA/HardwareUnits/ResourceManager.h 396 return setCustomStrategyImpl(std::move(S), ProcResID2Mask[ResourceID]);
include/llvm/MCA/HardwareUnits/Scheduler.h 163 std::move(SelectStrategy)) {}
167 : LSU(Lsu), Resources(std::move(RM)), BusyResourceUnits(0),
169 initializeStrategy(std::move(SelectStrategy));
include/llvm/MCA/Support.h 33 : Message(std::move(M)), Inst(MCI) {}
include/llvm/Object/Archive.h 171 C = std::move(*NextChild);
267 return std::move(ThinBuffers);
include/llvm/Object/Binary.h 202 : Bin(std::move(Bin)), Buf(std::move(Buf)) {}
202 : Bin(std::move(Bin)), Buf(std::move(Buf)) {}
208 : Bin(std::move(Other.Bin)), Buf(std::move(Other.Buf)) {}
208 : Bin(std::move(Other.Bin)), Buf(std::move(Other.Buf)) {}
212 Bin = std::move(Other.Bin);
213 Buf = std::move(Other.Buf);
220 return std::make_pair(std::move(Bin), std::move(Buf));
220 return std::make_pair(std::move(Bin), std::move(Buf));
include/llvm/Object/COFF.h 1018 return errorToErrorCode(std::move(E));
include/llvm/Object/ELF.h 599 return std::move(E);
include/llvm/Object/ELFObjectFile.h 709 handleAllErrors(std::move(SectionsOrErr.takeError()),
949 return std::move(E);
950 auto EF = std::move(*EFOrErr);
include/llvm/Object/ELFTypes.h 668 consumeError(std::move(Err));
include/llvm/Object/Minidump.h 168 StreamMap(std::move(StreamMap)) {}
include/llvm/Object/SymbolicFile.h 74 content_iterator(content_type symb) : Current(std::move(symb)) {}
include/llvm/ObjectYAML/MinidumpYAML.h 67 : Stream(EntryT::Kind, EntryT::Type), Entries(std::move(Entries)) {}
174 Info(Info), CSDVersion(std::move(CSDVersion)) {}
210 : Header(Header), Streams(std::move(Streams)) {}
include/llvm/Option/Arg.h 101 void setAlias(std::unique_ptr<Arg> Alias) { this->Alias = std::move(Alias); }
include/llvm/Option/ArgList.h 156 : Args(std::move(RHS.Args)), OptRanges(std::move(RHS.OptRanges)) {
156 : Args(std::move(RHS.Args)), OptRanges(std::move(RHS.OptRanges)) {
162 Args = std::move(RHS.Args);
164 OptRanges = std::move(RHS.OptRanges);
396 : ArgList(std::move(RHS)), ArgStrings(std::move(RHS.ArgStrings)),
396 : ArgList(std::move(RHS)), ArgStrings(std::move(RHS.ArgStrings)),
397 SynthesizedStrings(std::move(RHS.SynthesizedStrings)),
402 ArgList::operator=(std::move(RHS));
403 ArgStrings = std::move(RHS.ArgStrings);
404 SynthesizedStrings = std::move(RHS.SynthesizedStrings);
include/llvm/ProfileData/Coverage/CoverageMapping.h 430 : Line(Line), Col(Col), Instantiations(std::move(Instantiations)) {}
include/llvm/ProfileData/Coverage/CoverageMappingReader.h 80 return std::move(E);
88 return std::move(E);
include/llvm/ProfileData/InstrProf.h 321 handleAllErrors(std::move(E), [&Err](const InstrProfError &IPE) {
689 InstrProfRecord(std::vector<uint64_t> Counts) : Counts(std::move(Counts)) {}
852 : InstrProfRecord(std::move(Counts)), Name(Name), Hash(Hash) {}
include/llvm/ProfileData/InstrProfReader.h 108 Error error(Error &&E) { return error(InstrProfError::take(std::move(E))); }
156 : DataBuffer(std::move(DataBuffer_)), Line(*DataBuffer, true, '#') {}
211 : DataBuffer(std::move(DataBuffer)) {}
453 : DataBuffer(std::move(DataBuffer)),
454 RemappingBuffer(std::move(RemappingBuffer)), RecordIndex(0) {}
include/llvm/ProfileData/InstrProfWriter.h 56 addRecord(std::move(I), 1, Warn);
include/llvm/ProfileData/ProfileCommon.h 56 : DetailedSummaryCutoffs(std::move(Cutoffs)) {}
75 : ProfileSummaryBuilder(std::move(Cutoffs)) {}
84 : ProfileSummaryBuilder(std::move(Cutoffs)) {}
include/llvm/ProfileData/SampleProfReader.h 248 : Buffer(std::move(B)), Remappings(std::move(SRR)), Reader(R) {
248 : Buffer(std::move(B)), Remappings(std::move(SRR)), Reader(R) {
325 : Profiles(0), Ctx(C), Buffer(std::move(B)), Format(Format) {}
433 return std::move(Reader.Summary);
448 : SampleProfileReader(std::move(B), C, SPF_Text) {}
464 : SampleProfileReader(std::move(B), C, Format) {}
542 : SampleProfileReaderBinary(std::move(B), C, Format) {}
589 : SampleProfileReaderBinary(std::move(B), C, Format) {}
621 : SampleProfileReaderExtBinaryBase(std::move(B), C, Format) {}
627 return std::move(ProfSymList);
655 : SampleProfileReaderBinary(std::move(B), C, SPF_Compact_Binary) {}
685 : SampleProfileReader(std::move(B), C, SPF_GCC),
include/llvm/ProfileData/SampleProfWriter.h 63 : OutputStream(std::move(OS)) {}
include/llvm/Remarks/YAMLRemarkSerializer.h 79 : YAMLRemarkSerializer(Format::YAMLStrTab, OS, Mode, std::move(StrTab)) {}
include/llvm/Support/Allocator.h 159 : CurPtr(Old.CurPtr), End(Old.End), Slabs(std::move(Old.Slabs)),
160 CustomSizedSlabs(std::move(Old.CustomSizedSlabs)),
162 Allocator(std::move(Old.Allocator)) {
182 Slabs = std::move(RHS.Slabs);
183 CustomSizedSlabs = std::move(RHS.CustomSizedSlabs);
184 Allocator = std::move(RHS.Allocator);
456 : Allocator(std::move(Old.Allocator)) {}
460 Allocator = std::move(RHS.Allocator);
include/llvm/Support/Automaton.h 146 Paths.push_back(std::move(P));
include/llvm/Support/BinaryByteStream.h 80 MemBuffer(std::move(Buffer)) {}
215 FileBuffer(std::move(Buffer)) {}
237 : Impl(std::move(Buffer), Endian) {}
include/llvm/Support/BinaryStreamArray.h 166 consumeError(std::move(EC));
215 consumeError(std::move(EC));
287 consumeError(std::move(EC));
include/llvm/Support/Casting.h 317 return cast<X>(std::move(Val));
381 return cast<X>(std::move(Val));
include/llvm/Support/DataExtractor.h 75 Error takeError() { return std::move(Err); }
include/llvm/Support/Error.h 193 *this = std::move(Other);
387 Payloads.push_back(std::move(Payload1));
388 Payloads.push_back(std::move(Payload2));
402 E1List.Payloads.push_back(std::move(Payload));
424 return ErrorList::join(std::move(E1), std::move(E2));
424 return ErrorList::join(std::move(E1), std::move(E2));
487 Expected(Expected &&Other) { moveConstruct(std::move(Other)); }
495 moveConstruct(std::move(Other));
510 moveAssign(std::move(Other));
556 return HasError ? Error(std::move(*getErrorStorage())) : Error::success();
602 new (getStorage()) storage_type(std::move(*Other.getStorage()));
604 new (getErrorStorage()) error_type(std::move(*Other.getErrorStorage()));
614 new (this) Expected(std::move(Other));
733 return std::move(*ValOrErr);
827 return H(std::move(SubE));
843 H(std::move(SubE));
881 return Error(std::move(Payload));
889 std::move(Payload));
890 return handleErrorImpl(std::move(Payload),
912 std::move(R),
913 handleErrorImpl(std::move(P), std::forward<HandlerTs>(Hs)...));
917 return handleErrorImpl(std::move(Payload), std::forward<HandlerTs>(Hs)...);
925 cantFail(handleErrors(std::move(E), std::forward<HandlerTs>(Handlers)...));
931 cantFail(std::move(E));
966 return std::move(Err);
988 handleAllErrors(std::move(E), [&Errors](const ErrorInfoBase &EI) {
1002 handleAllErrors(std::move(Err), [](const ErrorInfoBase &) {});
1014 return std::move(*E);
1027 consumeError(std::move(Err));
1140 return std::move(*EO);
1146 return errorToErrorCode(std::move(Err));
1147 return std::move(*E);
1235 Error takeError() { return Error(std::move(Err)); }
1249 Err = std::move(E);
1250 Line = std::move(LineNum);
1266 return FileError::build(F, Optional<size_t>(), std::move(E));
1272 return FileError::build(F, Optional<size_t>(Line), std::move(E));
1297 : Banner(std::move(Banner)),
1301 void setBanner(std::string Banner) { this->Banner = std::move(Banner); }
1305 this->GetExitCode = std::move(GetExitCode);
1309 void operator()(Error Err) const { checkError(std::move(Err)); }
1315 return std::move(*E);
1329 logAllUnhandledErrors(std::move(Err), errs(), Banner);
include/llvm/Support/ErrorOr.h 115 moveConstruct(std::move(Other));
123 moveConstruct(std::move(Other));
133 moveConstruct(std::move(Other));
142 moveAssign(std::move(Other));
213 new (getStorage()) storage_type(std::move(*Other.getStorage()));
227 new (this) ErrorOr(std::move(Other));
include/llvm/Support/FormatAdapters.h 77 ErrorAdapter(Error &&Item) : FormatAdapter(std::move(Item)) {}
79 ~ErrorAdapter() { consumeError(std::move(Item)); }
104 return detail::ErrorAdapter(std::move(Item));
include/llvm/Support/FormatVariadic.h 99 : Fmt(std::move(rhs.Fmt)),
101 Replacements(std::move(rhs.Replacements)) {
157 Parameters(std::move(Params)) {
164 : formatv_object_base(std::move(rhs)),
165 Parameters(std::move(rhs.Parameters)) {
include/llvm/Support/GenericDomTree.h 257 : Roots(std::move(Arg.Roots)),
258 DomTreeNodes(std::move(Arg.DomTreeNodes)),
267 Roots = std::move(RHS.Roots);
268 DomTreeNodes = std::move(RHS.DomTreeNodes);
595 OldNode = NewNode->addChild(std::move(DomTreeNodes[OldRoot]));
include/llvm/Support/JSON.h 123 return M.try_emplace(std::move(K), std::forward<Ts>(Args)...);
189 void push_back(Value &&E) { V.push_back(std::move(E)); }
197 return V.insert(P, std::move(E));
295 Value(Value &&M) { moveFrom(std::move(M)); }
298 create<json::Array>(std::move(Elements));
303 create<json::Object>(std::move(Properties));
311 V = fixUTF8(std::move(V));
313 create<std::string>(std::move(V));
367 moveFrom(std::move(M));
493 ObjectKey(std::string S) : Owned(new std::string(std::move(S))) {
496 *Owned = fixUTF8(std::move(*Owned));
552 R.first->getSecond().moveFrom(std::move(P.V));
556 return try_emplace(std::move(E.K), std::move(E.V));
556 return try_emplace(std::move(E.K), std::move(E.V));
604 Out = std::move(Result);
include/llvm/Support/KnownBits.h 29 : Zero(std::move(Zero)), One(std::move(One)) {}
29 : Zero(std::move(Zero)), One(std::move(One)) {}
include/llvm/Support/MSVCErrorWorkarounds.h 31 MSVCPError(MSVCPError &&Other) : Error(std::move(Other)) {}
34 Error::operator=(std::move(Other));
38 MSVCPError(Error Err) : Error(std::move(Err)) {}
57 MSVCPExpected(Error Err) : Expected<T>(std::move(Err)) {}
include/llvm/Support/Printable.h 41 : Print(std::move(Print)) {}
include/llvm/Support/SmallVectorMemoryBuffer.h 40 : SV(std::move(SV)), BufferName("<in-memory object>") {
47 : SV(std::move(SV)), BufferName(Name) {
include/llvm/Support/SourceMgr.h 156 NB.Buffer = std::move(F);
158 Buffers.push_back(std::move(NB));
include/llvm/Support/SpecialCaseList.h 133 Section(std::unique_ptr<Matcher> M) : SectionMatcher(std::move(M)){};
include/llvm/Support/TargetRegistry.h 434 return AsmPrinterCtorFn(TM, std::move(Streamer));
483 S = COFFStreamerCtorFn(Ctx, std::move(TAB), std::move(OW),
483 S = COFFStreamerCtorFn(Ctx, std::move(TAB), std::move(OW),
484 std::move(Emitter), RelaxAll,
489 S = MachOStreamerCtorFn(Ctx, std::move(TAB), std::move(OW),
489 S = MachOStreamerCtorFn(Ctx, std::move(TAB), std::move(OW),
490 std::move(Emitter), RelaxAll,
493 S = createMachOStreamer(Ctx, std::move(TAB), std::move(OW),
493 S = createMachOStreamer(Ctx, std::move(TAB), std::move(OW),
494 std::move(Emitter), RelaxAll,
499 S = ELFStreamerCtorFn(T, Ctx, std::move(TAB), std::move(OW),
499 S = ELFStreamerCtorFn(T, Ctx, std::move(TAB), std::move(OW),
500 std::move(Emitter), RelaxAll);
502 S = createELFStreamer(Ctx, std::move(TAB), std::move(OW),
502 S = createELFStreamer(Ctx, std::move(TAB), std::move(OW),
503 std::move(Emitter), RelaxAll);
507 S = WasmStreamerCtorFn(T, Ctx, std::move(TAB), std::move(OW),
507 S = WasmStreamerCtorFn(T, Ctx, std::move(TAB), std::move(OW),
508 std::move(Emitter), RelaxAll);
510 S = createWasmStreamer(Ctx, std::move(TAB), std::move(OW),
510 S = createWasmStreamer(Ctx, std::move(TAB), std::move(OW),
511 std::move(Emitter), RelaxAll);
514 S = createXCOFFStreamer(Ctx, std::move(TAB), std::move(OW),
514 S = createXCOFFStreamer(Ctx, std::move(TAB), std::move(OW),
515 std::move(Emitter), RelaxAll);
532 Ctx, std::move(OS), IsVerboseAsm, UseDwarfDirectory, InstPrint,
533 std::move(CE), std::move(TAB), ShowInst);
533 std::move(CE), std::move(TAB), ShowInst);
590 std::move(RelInfo));
1182 return new AsmPrinterImpl(TM, std::move(Streamer));
include/llvm/Support/TaskQueue.h 43 : C(std::move(C)), P(std::make_shared<std::promise<ResultTy>>()),
86 Task<Callable> T{std::move(C), *this};
95 Tasks.push_back(std::move(T));
97 Scheduler.async(std::move(T));
101 return std::move(F);
117 Continuation = std::move(Tasks.front());
120 Scheduler.async(std::move(Continuation));
include/llvm/Support/ThreadPool.h 57 return asyncImpl(std::move(Task));
include/llvm/Support/VirtualFileSystem.h 134 : Path(std::move(Path)), Type(Type) {}
163 : Impl(std::move(I)) {
372 : FS(std::move(FS)) {}
598 : Entry(EK_Directory, Name), Contents(std::move(Contents)),
599 S(std::move(S)) {}
601 : Entry(EK_Directory, Name), S(std::move(S)) {}
606 Contents.push_back(std::move(Content));
include/llvm/TableGen/Record.h 1726 std::move(R))).second;
1733 std::move(R))).second;
include/llvm/Testing/Support/Error.h 88 : Matcher(std::move(Matcher)) {}
include/llvm/Testing/Support/SupportHelpers.h 31 : ErrorHolder(std::move(Err)), Exp(Exp) {}
include/llvm/TextAPI/MachO/InterfaceFile.h 88 : InstallName(InstallName), Targets(std::move(Targets)) {}
include/llvm/TextAPI/MachO/Symbol.h 60 : Name(Name), Targets(std::move(Targets)), Kind(Kind), Flags(Flags) {}
include/llvm/Transforms/IPO/Attributor.h 611 SccSizeOpt = std::move(SccSize);
include/llvm/Transforms/IPO/FunctionImport.h 109 : Index(Index), ModuleLoader(std::move(ModuleLoader)) {}
include/llvm/Transforms/IPO/Inliner.h 97 : Params(std::move(Params)) {}
100 : Params(std::move(Arg.Params)),
101 ImportedFunctionsStats(std::move(Arg.ImportedFunctionsStats)) {}
include/llvm/Transforms/IPO/Internalize.h 56 : MustPreserveGV(std::move(MustPreserveGV)) {}
73 return InternalizePass(std::move(MustPreserveGV))
include/llvm/Transforms/IPO/PassManagerBuilder.h 228 PassManagerBuilder::addGlobalExtension(Ty, std::move(Fn));
include/llvm/Transforms/Scalar/ConstantHoisting.h 107 Type *Ty=nullptr) : Uses(std::move(Uses)), Offset(Offset), Ty(Ty) {}
include/llvm/Transforms/Scalar/LoopPassManager.h 132 Worklist.insert(std::move(PreOrderLoops));
268 : Pass(std::move(Pass)), LoopCanonicalizationFPM(DebugLogging),
376 PA.intersect(std::move(PassPA));
414 return FunctionToLoopPassAdaptor<LoopPassT>(std::move(Pass), UseMemorySSA,
include/llvm/XRay/FDRLogBuilder.h 34 std::vector<std::unique_ptr<Record>> consume() { return std::move(Records); }
include/llvm/XRay/FDRRecords.h 221 Size(S), TSC(T), CPU(C), Data(std::move(D)) {}
249 Size(S), Delta(D), Data(std::move(P)) {}
277 Size(S), Delta(D), Data(std::move(P)) {}
include/llvm/XRay/FDRTraceExpander.h 39 : RecordVisitor(), C(std::move(F)), LogVersion(L) {}
include/llvm/XRay/Graph.h 454 return Vertices.insert(std::move(Val));
480 const auto &p = Edges.insert(std::move(Val));
include/llvm/XRay/Profile.h 89 : Blocks(std::move(O.Blocks)), NodeStorage(std::move(O.NodeStorage)),
89 : Blocks(std::move(O.Blocks)), NodeStorage(std::move(O.NodeStorage)),
90 Roots(std::move(O.Roots)), PathIDMap(std::move(O.PathIDMap)),
90 Roots(std::move(O.Roots)), PathIDMap(std::move(O.PathIDMap)),
94 Blocks = std::move(O.Blocks);
95 NodeStorage = std::move(O.NodeStorage);
96 Roots = std::move(O.Roots);
97 PathIDMap = std::move(O.PathIDMap);
include/llvm/XRay/RecordPrinter.h 28 : RecordVisitor(), OS(O), Delim(std::move(D)) {}
lib/Analysis/AliasAnalysis.cpp 64 : TLI(Arg.TLI), AAs(std::move(Arg.AAs)), AADeps(std::move(Arg.AADeps)) {
64 : TLI(Arg.TLI), AAs(std::move(Arg.AAs)), AADeps(std::move(Arg.AADeps)) {
744 return new ExternalAAWrapperPass(std::move(Callback));
lib/Analysis/BlockFrequencyInfo.cpp 160 : BFI(std::move(Arg.BFI)) {}
164 BFI = std::move(RHS.BFI);
lib/Analysis/BlockFrequencyInfoImpl.cpp 283 std::vector<FrequencyData> SavedFreqs(std::move(BFI.Freqs));
284 SparseBitVector<> SavedIsIrrLoopHeader(std::move(BFI.IsIrrLoopHeader));
286 BFI.Freqs = std::move(SavedFreqs);
287 BFI.IsIrrLoopHeader = std::move(SavedIsIrrLoopHeader);
lib/Analysis/CFLAndersAliasAnalysis.cpp 93 : GetTLI(std::move(GetTLI)) {}
95 : AAResultBase(std::move(RHS)), GetTLI(std::move(RHS.GetTLI)) {}
95 : AAResultBase(std::move(RHS)), GetTLI(std::move(RHS.GetTLI)) {}
808 std::move(IValueAttrMap));
821 Cache[&Fn] = std::move(FunInfo);
lib/Analysis/CFLSteensAliasAnalysis.cpp 65 : AAResultBase(), GetTLI(std::move(GetTLI)) {}
67 : AAResultBase(std::move(Arg)), GetTLI(std::move(Arg.GetTLI)) {}
67 : AAResultBase(std::move(Arg)), GetTLI(std::move(Arg.GetTLI)) {}
118 : Sets(std::move(S)) {
236 Cache[Fn] = std::move(FunInfo);
lib/Analysis/CGSCCPassManager.cpp 104 PA.intersect(std::move(PassPA));
lib/Analysis/CallGraph.cpp 39 : M(Arg.M), FunctionMap(std::move(Arg.FunctionMap)),
41 CallsExternalNode(std::move(Arg.CallsExternalNode)) {
140 FunctionMap[To] = std::move(I->second);
lib/Analysis/DDG.cpp 93 : DDGNode(std::move(N)), InstList(std::move(N.InstList)) {
93 : DDGNode(std::move(N)), InstList(std::move(N.InstList)) {
lib/Analysis/DemandedBits.cpp 408 Res.first->second = std::move(AB);
lib/Analysis/DependenceAnalysis.cpp 3780 return std::make_unique<FullDependence>(std::move(Result));
lib/Analysis/GlobalsModRef.cpp 945 : AAResultBase(), DL(DL), GetTLI(std::move(GetTLI)) {}
948 : AAResultBase(std::move(Arg)), DL(Arg.DL), GetTLI(std::move(Arg.GetTLI)),
948 : AAResultBase(std::move(Arg)), DL(Arg.DL), GetTLI(std::move(Arg.GetTLI)),
949 NonAddressTakenGlobals(std::move(Arg.NonAddressTakenGlobals)),
950 IndirectGlobals(std::move(Arg.IndirectGlobals)),
951 AllocsForIndirectGlobals(std::move(Arg.AllocsForIndirectGlobals)),
952 FunctionInfos(std::move(Arg.FunctionInfos)),
953 Handles(std::move(Arg.Handles)) {
lib/Analysis/LazyCallGraph.cpp 207 : BPA(std::move(G.BPA)), NodeMap(std::move(G.NodeMap)),
207 : BPA(std::move(G.BPA)), NodeMap(std::move(G.NodeMap)),
208 EntryEdges(std::move(G.EntryEdges)), SCCBPA(std::move(G.SCCBPA)),
208 EntryEdges(std::move(G.EntryEdges)), SCCBPA(std::move(G.SCCBPA)),
209 SCCMap(std::move(G.SCCMap)),
210 LibFunctions(std::move(G.LibFunctions)) {
215 BPA = std::move(G.BPA);
216 NodeMap = std::move(G.NodeMap);
217 EntryEdges = std::move(G.EntryEdges);
218 SCCBPA = std::move(G.SCCBPA);
219 SCCMap = std::move(G.SCCMap);
220 LibFunctions = std::move(G.LibFunctions);
1075 MergedSCCs = std::move(RC->SCCs);
1086 SCCs = std::move(MergedSCCs);
lib/Analysis/LazyValueInfo.cpp 124 return ValueLatticeElement::getRange(std::move(Range));
1247 return ValueLatticeElement::getRange(std::move(TrueValues));
1495 Result = ValueLatticeElement::getRange(std::move(EdgesVals));
lib/Analysis/LoopCacheAnalysis.cpp 543 RefGroup.push_back(std::move(R));
551 RG.push_back(std::move(R));
552 RefGroups.push_back(std::move(RG));
lib/Analysis/MemorySSA.cpp 856 return {Result, std::move(TerminatedPaths)};
894 return {Result, std::move(Clobbers)};
lib/Analysis/ModuleSummaryAnalysis.cpp 155 ConstVCalls.insert({{Guid, Call.Offset}, std::move(Args)});
471 Flags, NumInsts, FunFlags, /*EntryCount=*/0, std::move(Refs),
478 Index.addGlobalValueSummary(F, std::move(FuncSummary));
609 Index.addGlobalValueSummary(V, std::move(GVarSummary));
628 Index.addGlobalValueSummary(A, std::move(AS));
714 Index.addGlobalValueSummary(*GV, std::move(Summary));
720 Index.addGlobalValueSummary(*GV, std::move(Summary));
lib/Analysis/PtrUseVisitor.cpp 28 Worklist.push_back(std::move(NewU));
lib/Analysis/ScalarEvolution.cpp 3330 return APIntOps::GreatestCommonDivisor(std::move(A), std::move(B));
3330 return APIntOps::GreatestCommonDivisor(std::move(A), std::move(B));
3546 UniqueSCEVs.FindNodeOrInsertPos(ID, IP), std::move(ID), IP);
5696 return setRange(AddRec, SignHint, std::move(ConservativeResult));
5748 return setRange(U, SignHint, std::move(ConservativeResult));
5751 return setRange(S, SignHint, std::move(ConservativeResult));
5799 APInt MovedBoundary = Descending ? (StartLower - std::move(Offset))
5800 : (StartUpper + std::move(Offset));
5809 Descending ? std::move(MovedBoundary) : std::move(StartLower);
5809 Descending ? std::move(MovedBoundary) : std::move(StartLower);
5811 Descending ? std::move(StartUpper) : std::move(MovedBoundary);
5811 Descending ? std::move(StartUpper) : std::move(MovedBoundary);
5815 return ConstantRange::getNonEmpty(std::move(NewLower), std::move(NewUpper));
5815 return ConstantRange::getNonEmpty(std::move(NewLower), std::move(NewUpper));
6659 return PredicatedBackedgeTakenCounts.find(L)->second = std::move(Result);
6762 return BackedgeTakenCounts.find(L)->second = std::move(Result);
7046 std::move(Predicate));
7125 return BackedgeTakenInfo(std::move(ExitCounts), CouldComputeBECount,
10495 return (std::move(MaxValue) - MaxStrideMinusOne).slt(MaxRHS);
10503 return (std::move(MaxValue) - MaxStrideMinusOne).ult(MaxRHS);
10519 return (std::move(MinValue) + MaxStrideMinusOne).sgt(MinRHS);
10527 return (std::move(MinValue) + MaxStrideMinusOne).ugt(MinRHS);
11423 LI(Arg.LI), CouldNotCompute(std::move(Arg.CouldNotCompute)),
11424 ValueExprMap(std::move(Arg.ValueExprMap)),
11425 PendingLoopPredicates(std::move(Arg.PendingLoopPredicates)),
11426 PendingPhiRanges(std::move(Arg.PendingPhiRanges)),
11427 PendingMerges(std::move(Arg.PendingMerges)),
11428 MinTrailingZerosCache(std::move(Arg.MinTrailingZerosCache)),
11429 BackedgeTakenCounts(std::move(Arg.BackedgeTakenCounts)),
11431 std::move(Arg.PredicatedBackedgeTakenCounts)),
11433 std::move(Arg.ConstantEvolutionLoopExitValue)),
11434 ValuesAtScopes(std::move(Arg.ValuesAtScopes)),
11435 LoopDispositions(std::move(Arg.LoopDispositions)),
11436 LoopPropertiesCache(std::move(Arg.LoopPropertiesCache)),
11437 BlockDispositions(std::move(Arg.BlockDispositions)),
11438 UnsignedRanges(std::move(Arg.UnsignedRanges)),
11439 SignedRanges(std::move(Arg.SignedRanges)),
11440 UniqueSCEVs(std::move(Arg.UniqueSCEVs)),
11441 UniquePreds(std::move(Arg.UniquePreds)),
11442 SCEVAllocator(std::move(Arg.SCEVAllocator)),
11443 LoopUsers(std::move(Arg.LoopUsers)),
11444 PredicatedSCEVRewrites(std::move(Arg.PredicatedSCEVRewrites)),
lib/Analysis/StackSafetyAnalysis.cpp 390 return StackSafetyInfo(std::move(Info));
545 SSI.emplace(F.first, std::move(F.second));
572 : Info(new FunctionInfo(std::move(Info))) {}
lib/Analysis/StratifiedSets.h 92 : Values(std::move(Map)), Links(std::move(Links)) {}
92 : Values(std::move(Map)), Links(std::move(Links)) {}
340 return StratifiedSets<T>(std::move(Values), std::move(StratLinks));
340 return StratifiedSets<T>(std::move(Values), std::move(StratLinks));
lib/Analysis/SyncDependenceAnalysis.cpp 329 return std::move(JoinBlocks);
352 auto ItInserted = CachedLoopExitJoins.emplace(&Loop, std::move(JoinBlocks));
375 auto ItInserted = CachedBranchJoins.emplace(&Term, std::move(JoinBlocks));
lib/Analysis/TargetLibraryInfo.cpp 578 : CustomNames(std::move(TLI.CustomNames)),
598 CustomNames = std::move(TLI.CustomNames);
lib/Analysis/TargetTransformInfo.cpp 141 : TTIImpl(std::move(Arg.TTIImpl)) {}
144 TTIImpl = std::move(RHS.TTIImpl);
1344 : TTICallback(std::move(TTICallback)) {}
1372 : ImmutablePass(ID), TIRA(std::move(TIRA)) {
1385 return new TargetTransformInfoWrapperPass(std::move(TIRA));
lib/Analysis/ValueTracking.cpp 1032 Known.Zero = std::move(KnownZeroOut);
lib/AsmParser/LLParser.cpp 260 Slots->GlobalValues = std::move(NumberedVals);
261 Slots->MetadataNodes = std::move(NumberedMetadata);
2539 BundleList.emplace_back(std::move(Tag), std::move(Inputs));
2539 BundleList.emplace_back(std::move(Tag), std::move(Inputs));
2600 std::move(Name));
2635 std::move(Name));
3269 std::move(Fn),
3271 .first->second.insert(std::make_pair(std::move(Label), nullptr))
3763 this->Val = std::move(Val);
3767 : Val(std::move(Default)), Seen(false) {}
3788 this->A = std::move(A);
3794 this->B = std::move(B);
3799 : A(std::move(DefaultA)), B(std::move(DefaultB)), Seen(false),
3799 : A(std::move(DefaultA)), B(std::move(DefaultB)), Seen(false),
4315 Result.assign(std::move(MDs));
7963 Index->addGlobalValueSummary(VI, std::move(Summary));
8112 GVFlags, InstCount, FFlags, /*EntryCount=*/0, std::move(Refs),
8113 std::move(Calls), std::move(TypeIdInfo.TypeTests),
8113 std::move(Calls), std::move(TypeIdInfo.TypeTests),
8114 std::move(TypeIdInfo.TypeTestAssumeVCalls),
8115 std::move(TypeIdInfo.TypeCheckedLoadVCalls),
8116 std::move(TypeIdInfo.TypeTestAssumeConstVCalls),
8117 std::move(TypeIdInfo.TypeCheckedLoadConstVCalls));
8122 ID, std::move(FS));
8171 std::make_unique<GlobalVarSummary>(GVFlags, GVarFlags, std::move(Refs));
8174 GS->setVTableFuncs(std::move(VTableFuncs));
8177 ID, std::move(GS));
8228 ID, std::move(AS));
lib/AsmParser/Parser.cpp 31 SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
82 return {std::move(M), std::move(Index)};
82 return {std::move(M), std::move(Index)};
115 SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
151 SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
168 SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
180 SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
lib/BinaryFormat/Magic.cpp 229 std::unique_ptr<MemoryBuffer> FileBuffer = std::move(*FileOrError);
lib/Bitcode/Reader/BitReader.cpp 45 handleAllErrors(std::move(Err), [&](ErrorInfoBase &EIB) {
84 getOwningLazyBitcodeModule(std::move(Owner), Ctx);
91 handleAllErrors(std::move(Err), [&](ErrorInfoBase &EIB) {
112 Ctx, getOwningLazyBitcodeModule(std::move(Owner), Ctx));
lib/Bitcode/Reader/BitcodeAnalyzer.cpp 418 return std::move(Err);
420 return std::move(Err);
425 return std::move(Err);
427 return std::move(Err);
432 return std::move(Err);
434 return std::move(Err);
439 return std::move(Err);
441 return std::move(Err);
446 return std::move(Err);
448 return std::move(Err);
450 return std::move(Err);
452 return std::move(Err);
581 std::move(MaybeNewBlockInfo.get());
584 BlockInfo = std::move(*NewBlockInfo);
745 std::move(MaybeNewBlockInfo.get());
748 BlockInfo = std::move(*NewBlockInfo);
lib/Bitcode/Reader/BitcodeReader.cpp 144 return std::move(Err);
146 return std::move(Stream);
175 return std::move(Err);
232 Entry = std::move(Res.get());
247 return std::move(Err);
260 return std::move(Err);
311 Entry = std::move(Res.get());
327 return std::move(Err);
341 return std::move(Err);
405 return std::move(Err);
422 : Stream(std::move(Stream)), Strtab(Strtab) {
848 handleAllErrors(std::move(Err), [&](ErrorInfoBase &EIB) {
860 : BitcodeReaderBase(std::move(Stream), Strtab), Context(Context),
2043 return std::move(JumpFailed);
3047 std::move(MaybeNewBlockInfo.get());
3050 BlockInfo = std::move(*NewBlockInfo);
5118 OperandBundles.emplace_back(BundleTags[Record[0]], std::move(Inputs));
5351 : BitcodeReaderBase(std::move(Cursor), Strtab), TheIndex(TheIndex),
5903 std::move(Refs), std::move(Calls), std::move(PendingTypeTests),
5903 std::move(Refs), std::move(Calls), std::move(PendingTypeTests),
5903 std::move(Refs), std::move(Calls), std::move(PendingTypeTests),
5904 std::move(PendingTypeTestAssumeVCalls),
5905 std::move(PendingTypeCheckedLoadVCalls),
5906 std::move(PendingTypeTestAssumeConstVCalls),
5907 std::move(PendingTypeCheckedLoadConstVCalls));
5916 TheIndex.addGlobalValueSummary(VIAndOriginalGUID.first, std::move(FS));
5943 TheIndex.addGlobalValueSummary(GUID.first, std::move(AS));
5961 std::make_unique<GlobalVarSummary>(Flags, GVF, std::move(Refs));
5965 TheIndex.addGlobalValueSummary(GUID.first, std::move(FS));
5988 std::make_unique<GlobalVarSummary>(Flags, GVF, std::move(Refs));
5993 TheIndex.addGlobalValueSummary(GUID.first, std::move(VS));
6048 std::move(Refs), std::move(Edges), std::move(PendingTypeTests),
6048 std::move(Refs), std::move(Edges), std::move(PendingTypeTests),
6048 std::move(Refs), std::move(Edges), std::move(PendingTypeTests),
6049 std::move(PendingTypeTestAssumeVCalls),
6050 std::move(PendingTypeCheckedLoadVCalls),
6051 std::move(PendingTypeTestAssumeConstVCalls),
6052 std::move(PendingTypeCheckedLoadConstVCalls));
6061 TheIndex.addGlobalValueSummary(VI, std::move(FS));
6083 TheIndex.addGlobalValueSummary(VI, std::move(AS));
6102 std::make_unique<GlobalVarSummary>(Flags, GVF, std::move(Refs));
6107 TheIndex.addGlobalValueSummary(VI, std::move(FS));
6277 return std::move(Err);
6295 return std::move(Err);
6321 return std::move(FOrErr->Mods);
6356 return std::move(Err);
6373 return std::move(Err);
6422 return std::move(Err);
6450 return std::move(JumpFailed);
6460 return std::move(JumpFailed);
6461 auto *R = new BitcodeReader(std::move(Stream), Strtab, ProducerIdentification,
6471 return std::move(Err);
6476 return std::move(Err);
6480 return std::move(Err);
6482 return std::move(M);
6501 ModuleSummaryIndexBitcodeReader R(std::move(Stream), Strtab, CombinedIndex,
6510 return std::move(JumpFailed);
6513 ModuleSummaryIndexBitcodeReader R(std::move(Stream), Strtab, *Index,
6517 return std::move(Err);
6519 return std::move(Index);
6525 return std::move(Err);
6571 return std::move(JumpFailed);
6574 return std::move(Err);
6610 return std::move(Err);
6649 (*MOrErr)->setOwnedMemoryBuffer(std::move(Buffer));
lib/Bitcode/Reader/MetadataLoader.cpp 641 TheModule(TheModule), getTypeByID(std::move(getTypeByID)),
714 return std::move(Err);
728 return std::move(Err);
735 return std::move(Err);
747 return std::move(Err);
781 return std::move(Err);
826 return std::move(Err);
841 return std::move(Err);
931 consumeError(std::move(Err));
999 toString(std::move(Err)));
1012 toString(std::move(Err)));
2125 Pimpl = std::move(RHS.Pimpl);
2129 : Pimpl(std::move(RHS.Pimpl)) {}
2137 Stream, TheModule, ValueList, std::move(getTypeByID), IsImporting)) {}
lib/Bitcode/Writer/BitcodeWriter.cpp 823 unsigned PtrAbbrev = Stream.EmitAbbrev(std::move(Abbv));
831 unsigned FunctionAbbrev = Stream.EmitAbbrev(std::move(Abbv));
839 unsigned StructAnonAbbrev = Stream.EmitAbbrev(std::move(Abbv));
846 unsigned StructNameAbbrev = Stream.EmitAbbrev(std::move(Abbv));
854 unsigned StructNamedAbbrev = Stream.EmitAbbrev(std::move(Abbv));
861 unsigned ArrayAbbrev = Stream.EmitAbbrev(std::move(Abbv));
1119 unsigned VSTOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbv));
1232 SimpleGVarAbbrev = Stream.EmitAbbrev(std::move(Abbv));
1250 unsigned FilenameAbbrev = Stream.EmitAbbrev(std::move(Abbv));
1456 return Stream.EmitAbbrev(std::move(Abbv));
1487 return Stream.EmitAbbrev(std::move(Abbv));
1930 return Stream.EmitAbbrev(std::move(Abbv));
1960 return Stream.EmitAbbrev(std::move(Abbv));
2058 unsigned OffsetAbbrev = Stream.EmitAbbrev(std::move(Abbv));
2064 unsigned IndexAbbrev = Stream.EmitAbbrev(std::move(Abbv));
2283 AggregateAbbrev = Stream.EmitAbbrev(std::move(Abbv));
2290 String8Abbrev = Stream.EmitAbbrev(std::move(Abbv));
2296 CString7Abbrev = Stream.EmitAbbrev(std::move(Abbv));
2302 CString6Abbrev = Stream.EmitAbbrev(std::move(Abbv));
3063 unsigned FnEntryAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3159 writeUseList(std::move(VE.UseListOrders.back()));
3449 unsigned Abbrev8Bit = Stream.EmitAbbrev(std::move(Abbv));
3457 unsigned Abbrev7Bit = Stream.EmitAbbrev(std::move(Abbv));
3465 unsigned Abbrev6Bit = Stream.EmitAbbrev(std::move(Abbv));
3475 unsigned AbbrevHash = Stream.EmitAbbrev(std::move(Abbv));
3773 unsigned FSCallsProfileAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3791 unsigned FSCallsAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3800 unsigned FSModRefsAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3811 unsigned FSModVTableRefsAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3819 unsigned FSAliasAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3829 unsigned TypeIdCompatibleVtableAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3924 unsigned FSCallsAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3941 unsigned FSCallsProfileAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3951 unsigned FSModRefsAbbrev = Stream.EmitAbbrev(std::move(Abbv));
3960 unsigned FSAliasAbbrev = Stream.EmitAbbrev(std::move(Abbv));
4187 auto StringAbbrev = Stream.EmitAbbrev(std::move(Abbv));
4195 auto EpochAbbrev = Stream.EmitAbbrev(std::move(Abbv));
4371 auto AbbrevNo = Stream->EmitAbbrev(std::move(Abbv));
4402 consumeError(std::move(E));
4560 unsigned FilenameAbbrev = Stream.EmitAbbrev(std::move(Abbv));
lib/Bitstream/Reader/BitstreamReader.cpp 167 return std::move(Err);
191 return std::move(Err);
204 return std::move(Err);
230 return std::move(Err);
359 return std::move(Err);
426 CurAbbrevs.push_back(std::move(Abbv));
434 return std::move(Err);
454 return std::move(NewBlockInfo);
464 return std::move(Err);
468 CurBlockInfo->Abbrevs.push_back(std::move(CurAbbrevs.back()));
lib/CodeGen/AsmPrinter/AccelTable.cpp 522 CompUnits(CompUnits), getCUIndexForEntry(std::move(getCUIndexForEntry)) {
lib/CodeGen/AsmPrinter/AsmPrinter.cpp 187 OutContext(Streamer->getContext()), OutStreamer(std::move(Streamer)) {
3070 auto IterBool = GCMap.insert(std::make_pair(&S, std::move(GMP)));
lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp 96 unsigned BufNum = SrcMgr.AddNewSourceBuffer(std::move(Buffer), SMLoc());
lib/CodeGen/AsmPrinter/CodeViewDebug.cpp 661 logAllUnhandledErrors(std::move(E), errs(), "error: ");
1193 Var.DefRanges.emplace_back(std::move(DefRange));
1197 recordLocalVariable(std::move(Var), Scope);
1268 Var.DefRanges.emplace_back(std::move(DR));
1324 recordLocalVariable(std::move(Var), Scope);
1479 GlobalUDTs.emplace_back(std::move(FullyQualifiedName), Ty);
1481 LocalUDTs.emplace_back(std::move(FullyQualifiedName), Ty);
2820 Block.Locals = std::move(*Locals);
2822 Block.Globals = std::move(*Globals);
3000 GlobalVariables.emplace_back(std::move(CVGV));
3024 VariableList->emplace_back(std::move(CVGV));
lib/CodeGen/AsmPrinter/DIE.cpp 160 DIEAbbrev *New = new (Alloc) DIEAbbrev(std::move(Abbrev));
lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp 463 ScopeDIE->addChild(std::move(I));
465 FinalChildren.push_back(std::move(ScopeDIE));
476 ->addRange(*(Skeleton ? Skeleton : this), std::move(Range));
508 addScopeRangeList(Die, std::move(Ranges));
518 attachRangesOrLowHighPC(Die, std::move(List));
671 DwarfExpr.addExpression(std::move(Cursor));
846 ScopeDIE.addChild(std::move(I));
1140 GlobalNames.insert(std::make_pair(std::move(FullName), &getUnitDie()));
1161 GlobalTypes.insert(std::make_pair(std::move(FullName), &getUnitDie()));
1184 DwarfExpr.addExpression(std::move(Cursor));
1214 DwarfExpr.addExpression(std::move(Cursor));
lib/CodeGen/AsmPrinter/DwarfCompileUnit.h 350 SmallVector<RangeSpan, 2> takeRanges() { return std::move(CURanges); }
lib/CodeGen/AsmPrinter/DwarfDebug.cpp 858 InfoHolder.addUnit(std::move(OwnedUnit));
1289 ConcreteEntities.push_back(std::move(RegVar));
2210 return DwarfExpr.addExpression(std::move(Cursor));
2215 DwarfExpr.addExpression(std::move(ExprCursor));
2789 SkeletonHolder.addUnit(std::move(NewU));
2804 initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
2898 TypeUnitsUnderConstruction.emplace_back(std::move(OwnedUnit), CTy);
2931 auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
2964 TypeUnitsUnderConstruction(std::move(DD->TypeUnitsUnderConstruction)) {
2970 DD->TypeUnitsUnderConstruction = std::move(TypeUnitsUnderConstruction);
lib/CodeGen/AsmPrinter/DwarfFile.cpp 27 CUs.push_back(std::move(U));
129 RangeSpanList(Asm->createTempSymbol("debug_ranges"), CU, std::move(R)));
lib/CodeGen/AsmPrinter/DwarfFile.h 51 : RangeSym(Sym), CU(&CU), Ranges(std::move(Ranges)) {}
lib/CodeGen/CodeGenPrepare.cpp 1897 auto GEPs = std::move(it->second);
2696 Actions.push_back(std::move(Ptr));
2704 Actions.push_back(std::move(Ptr));
2712 Actions.push_back(std::move(Ptr));
lib/CodeGen/DFAPacketizer.cpp 166 Mutations.push_back(std::move(Mutation));
363 VLIWScheduler->addMutation(std::move(Mutation));
lib/CodeGen/GCMetadata.cpp 157 GCStrategyList.push_back(std::move(S));
lib/CodeGen/GlobalISel/CSEInfo.cpp 367 Info.setCSEConfig(std::move(CSEOpt));
lib/CodeGen/GlobalISel/IRTranslator.cpp 1936 PendingPHIs.emplace_back(&PI, std::move(Insts));
lib/CodeGen/GlobalISel/RegBankSelect.cpp 307 RepairPts.emplace_back(std::move(RepairPt));
lib/CodeGen/IfConversion.cpp 207 : MachineFunctionPass(ID), PredicateFtor(std::move(Ftor)) {
486 std::unique_ptr<IfcvtToken> Token = std::move(Tokens.back());
2359 return new IfConverter(std::move(Ftor));
lib/CodeGen/InlineSpiller.cpp 1150 StackSlotToOrigLI[StackSlot] = std::move(LI);
lib/CodeGen/LLVMTargetMachine.cpp 145 Context, std::move(FOut), Options.MCOptions.AsmVerbose,
146 Options.MCOptions.MCUseDwarfDirectory, InstPrinter, std::move(MCE),
147 std::move(MAB), Options.MCOptions.ShowMCInst);
182 getTarget().createAsmPrinter(*this, std::move(AsmStreamer));
262 getTarget().createAsmPrinter(*this, std::move(AsmStreamer));
lib/CodeGen/LiveDebugValues.cpp 112 UserValueScopes(DebugLoc D, LexicalScopes &L) : DL(std::move(D)), LS(L) {}
lib/CodeGen/LiveDebugVariables.cpp 215 : Variable(var), Expression(expr), dl(std::move(L)), locInts(alloc) {}
367 : Label(label), dl(std::move(L)), loc(Idx) {}
lib/CodeGen/MIRParser/MILexer.cpp 79 StringValueStorage = std::move(StrVal);
85 this->IntVal = std::move(IntVal);
lib/CodeGen/MIRParser/MIRParser.cpp 169 SM.AddNewSourceBuffer(std::move(Contents), SMLoc()))->getBuffer(),
376 MF.addCallArgsForwardingRegs(&*CallI, std::move(CSInfo));
916 : Impl(std::move(Impl)) {}
937 return createMIRParser(std::move(FileOrErr.get()), Context);
953 std::make_unique<MIRParserImpl>(std::move(Contents), Filename, Context));
lib/CodeGen/MachineBlockPlacement.cpp 1218 TriangleChain Chain = std::move(Found->second);
1221 TriangleChainMap.insert(std::make_pair(Chain.getKey(), std::move(Chain)));
lib/CodeGen/MachineFunction.cpp 834 CallSiteInfo CSInfo = std::move(CSIt->second);
lib/CodeGen/MachineInstr.cpp 118 : MCID(&tid), debugLoc(std::move(dl)) {
lib/CodeGen/MachineInstrBundle.cpp 28 : MachineFunctionPass(ID), PredicateFtor(std::move(Ftor)) {
83 return new UnpackMachineBundles(std::move(Ftor));
lib/CodeGen/MachineModuleInfo.cpp 141 AddrLabelSymEntry Entry = std::move(AddrLabelSymbols[BB]);
163 AddrLabelSymEntry OldEntry = std::move(AddrLabelSymbols[Old]);
172 NewEntry = std::move(OldEntry); // Set New's entry.
212 : TM(std::move(MMI.TM)),
lib/CodeGen/MachinePipeliner.cpp 548 ModuloSchedule MS(MF, &Loop, std::move(OrderedInsts), std::move(Cycles),
548 ModuloSchedule MS(MF, &Loop, std::move(OrderedInsts), std::move(Cycles),
549 std::move(Stages));
562 ModuloScheduleExpander MSE(MF, MS, LIS, std::move(NewInstrChanges));
lib/CodeGen/MachineVerifier.cpp 300 : MachineFunctionPass(ID), Banner(std::move(banner)) {
lib/CodeGen/ModuloSchedule.cpp 2002 ModuloSchedule MS(MF, &L, std::move(Instrs), std::move(Cycle),
2002 ModuloSchedule MS(MF, &L, std::move(Instrs), std::move(Cycle),
2003 std::move(Stage));
lib/CodeGen/ParallelCG.cpp 58 std::move(M), OSs.size(),
86 std::unique_ptr<Module> MPartInCtx = std::move(MOrErr.get());
92 std::move(BC));
lib/CodeGen/RegAllocPBQP.cpp 209 G.setNodeCosts(NId, std::move(NodeCosts));
429 PBQPRAGraph::EdgeId EId = G.addEdge(NId, MId, std::move(M));
473 G.setNodeCosts(NId, std::move(NewCosts));
488 G.addEdge(N1Id, N2Id, std::move(Costs));
496 G.updateEdgeCosts(EId, std::move(Costs));
645 VRegAllowedMap[VReg] = std::move(VRegAllowed);
668 PBQPRAGraph::NodeId NId = G.addNode(std::move(NodeCosts));
671 G.getMetadata().getAllowedRegs(std::move(VRegAllowed)));
lib/CodeGen/SelectionDAG/FastISel.cpp 889 CLI.setCallee(CI->getCallingConv(), RetTy, Callee, std::move(Args), NumArgs);
900 return setCallee(CC, ResultTy, Sym, std::move(ArgsList), FixedArgs);
1131 CLI.setCallee(RetTy, FTy, Symbol, std::move(Args), CS, NumArgs);
1281 CLI.setCallee(RetTy, FuncTy, CI->getCalledValue(), std::move(Args), CS)
lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp 325 EHInfo.EHPadUnwindMap = std::move(NewMap);
lib/CodeGen/SelectionDAG/LegalizeDAG.cpp 1861 std::make_pair(Shuffle, std::move(FinalIndices)));
2062 std::move(Args))
2108 std::move(Args))
2233 std::move(Args))
2333 std::move(Args));
3769 std::move(Args));
3810 std::move(Args));
lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp 3459 .setLibCallee(TLI.getLibcallCallingConv(LC), RetTy, Func, std::move(Args))
lib/CodeGen/SelectionDAG/LegalizeTypes.cpp 1030 std::move(Args))
lib/CodeGen/SelectionDAG/SDNodeDbgValue.h 61 : Var(Var), Expr(Expr), DL(std::move(dl)), Order(O), IsIndirect(indir) {
70 : Var(Var), Expr(Expr), DL(std::move(dl)), Order(O), IsIndirect(false) {
151 : Label(Label), DL(std::move(dl)), Order(O) {}
lib/CodeGen/SelectionDAG/SelectionDAG.cpp 6226 std::move(Args))
6267 std::move(Args))
6330 std::move(Args))
6371 std::move(Args))
6432 std::move(Args))
6472 std::move(Args))
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp 2548 getValue(GuardCheckFn), std::move(Args));
6507 std::move(Args));
7174 .setCallee(RetTy, FTy, Callee, std::move(Args), CS)
8644 .setCallee(Call->getCallingConv(), ReturnTy, Callee, std::move(Args))
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h 115 : DI(di), dl(std::move(DL)), SDNodeOrder(SDNO) {}
lib/CodeGen/SelectionDAG/TargetLowering.cpp 162 .setLibCallee(getLibcallCallingConv(LC), RetTy, Callee, std::move(Args))
1206 Known = std::move(KnownOut);
4193 ConstraintOperands.emplace_back(std::move(CI));
6843 CLI.setLibCallee(CallingConv::C, VoidPtrType, EmuTlsGetAddr, std::move(Args));
lib/CodeGen/StackColoring.cpp 1186 Intervals.push_back(std::move(LI));
lib/CodeGen/StackMaps.cpp 346 CSInfos.emplace_back(CSOffsetExpr, ID, std::move(Locations),
347 std::move(LiveOuts));
lib/CodeGen/SwitchLoweringUtils.cpp 253 JTCases.emplace_back(std::move(JTH), std::move(JT));
253 JTCases.emplace_back(std::move(JTH), std::move(JT));
449 BitTestCases.emplace_back(std::move(LowBound), std::move(CmpRange),
449 BitTestCases.emplace_back(std::move(LowBound), std::move(CmpRange),
451 ContiguousRange, nullptr, nullptr, std::move(BTI),
lib/CodeGen/TailDuplicator.cpp 252 *DuplicatedPreds = std::move(TDBBs);
lib/DebugInfo/CodeView/DebugStringTableSubsection.cpp 40 return std::move(EC);
lib/DebugInfo/CodeView/DebugSubsectionRecord.cpp 57 : Subsection(std::move(Subsection)), Container(Container) {}
lib/DebugInfo/CodeView/Formatters.cpp 24 : FormatAdapter(std::move(Guid)) {}
lib/DebugInfo/CodeView/LazyRandomTypeCollection.cpp 31 consumeError(std::move(EC));
94 error(std::move(EC));
105 consumeError(std::move(EC));
122 consumeError(std::move(EC));
207 consumeError(std::move(EC));
218 consumeError(std::move(EC));
lib/DebugInfo/CodeView/RecordName.cpp 253 consumeError(std::move(EC));
lib/DebugInfo/CodeView/TypeRecordHelpers.cpp 21 consumeError(std::move(EC));
33 UdtOptions = getUdtOptions<ClassRecord>(std::move(CVT));
36 UdtOptions = getUdtOptions<EnumRecord>(std::move(CVT));
39 UdtOptions = getUdtOptions<UnionRecord>(std::move(CVT));
lib/DebugInfo/CodeView/TypeStreamMerger.cpp 241 LastError = joinErrors(std::move(*LastError), errorCorruptRecord());
353 return std::move(*LastError);
486 return joinErrors(std::move(EC), errorCorruptRecord());
lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp 459 return std::move(Result);
480 return Abbrev(Code, dwarf::Tag(Tag), std::move(*AttrEncOr));
516 if (!Abbrevs.insert(std::move(*AbbrevOr)).second)
622 return std::move(E);
766 NameIndices.push_back(std::move(Next));
821 CurrentEntry = std::move(*EntryOr);
lib/DebugInfo/DWARF/DWARFContext.cpp 70 : DIContext(CK_DWARF), DWPName(std::move(DWPName)), DObj(std::move(DObj)) {}
70 : DIContext(CK_DWARF), DWPName(std::move(DWPName)), DObj(std::move(DObj)) {}
252 WithColor::error() << toString(std::move(Err)) << '\n';
275 WithColor::error() << toString(std::move(Err)) << '\n';
297 WithColor::error() << toString(std::move(E)) << '\n';
522 WithColor::error() << toString(std::move(E)) << '\n';
804 llvm::consumeError(std::move(E));
1228 return std::shared_ptr<DWARFContext>(std::move(S), Ctxt);
1235 return std::shared_ptr<DWARFContext>(std::move(S), Ctxt);
1266 S->File = std::move(Obj.get());
1270 return std::shared_ptr<DWARFContext>(std::move(S), Ctxt);
1274 return make_error<StringError>(Reason + toString(std::move(E)),
1354 WithColor::error() << toString(std::move(E)) << '\n';
1479 UncompressedSections.push_back(std::move(Out));
1554 "failed to decompress '" + Name + "', ", std::move(Err)));
1820 return std::make_unique<DWARFContext>(std::move(DObj), std::move(DWPName));
1820 return std::make_unique<DWARFContext>(std::move(DObj), std::move(DWPName));
1828 return std::make_unique<DWARFContext>(std::move(DObj), "");
1863 handleAllErrors(std::move(Warning), [](ErrorInfoBase &Info) {
lib/DebugInfo/DWARF/DWARFDebugAbbrev.cpp 45 Decls.push_back(std::move(AbbrDecl));
94 AbbrDeclSets.insert(I, std::make_pair(CUAbbrOffset, std::move(AbbrDecls)));
132 AbbrDeclSets.insert(std::make_pair(CUAbbrOffset, std::move(AbbrDecls)))
lib/DebugInfo/DWARF/DWARFDebugFrame.cpp 470 Entries.emplace_back(std::move(Cie));
525 report_fatal_error(toString(std::move(E)));
lib/DebugInfo/DWARF/DWARFDebugLine.cpp 386 std::move(e));
525 return std::move(Err);
1141 UnrecoverableErrorCallback(std::move(Err));
1154 ErrorCallback(std::move(Err));
lib/DebugInfo/DWARF/DWARFDebugLoc.cpp 107 return std::move(Err);
123 LL.Entries.push_back(std::move(E));
134 Locations.push_back(std::move(*LL));
191 LL.Entries.push_back(std::move(E));
194 return std::move(Err);
209 Locations.push_back(std::move(*LL));
lib/DebugInfo/DWARF/DWARFUnit.cpp 116 I = std::next(this->insert(I, std::move(U)));
126 return this->insert(I, std::move(Unit))->get();
166 this->insert(CU, std::move(U));
324 return std::move(E);
408 WithColor::error() << toString(std::move(e));
523 DWO = std::shared_ptr<DWARFCompileUnit>(std::move(DWOContext), DWOCU);
559 return std::move(E);
lib/DebugInfo/DWARF/DWARFVerifier.cpp 37 return std::move(Pos);
41 return std::move(Iter);
792 : OS(S), DCtx(D), DumpOpts(std::move(DumpOpts)), IsObjectFile(false),
826 error() << toString(std::move(E)) << '\n';
1431 error() << toString(std::move(E)) << '\n';
lib/DebugInfo/GSYM/FunctionInfo.cpp 73 FI.OptLineTable = std::move(LT.get());
80 FI.Inline = std::move(II.get());
92 return std::move(FI);
116 return std::move(err);
134 return std::move(err);
lib/DebugInfo/GSYM/GsymReader.cpp 28 MemBuffer(std::move(Buffer)),
55 GsymReader GR(std::move(MemBuffer));
58 return std::move(Err);
59 return std::move(GR);
lib/DebugInfo/GSYM/Header.cpp 81 return std::move(Err);
lib/DebugInfo/GSYM/InlineInfo.cpp 110 Inline.Children.emplace_back(std::move(*Child));
lib/DebugInfo/GSYM/LineTable.cpp 259 return std::move(Err);
lib/DebugInfo/MSF/MSFBuilder.cpp 186 return std::move(EC);
270 return std::move(EC);
344 Layout = std::move(*L);
349 return std::move(EC);
351 FileBufferByteStream Buffer(std::move(*OutFileOrError),
356 return std::move(EC);
364 return std::move(EC);
370 return std::move(EC);
373 return std::move(EC);
377 return std::move(EC);
380 return std::move(Buffer);
lib/DebugInfo/MSF/MappedBlockStream.cpp 231 consumeError(std::move(EC));
lib/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.cpp 184 std::move(Subsection), CodeViewContainer::Pdb));
lib/DebugInfo/PDB/Native/DbiModuleList.cpp 277 return std::move(EC);
lib/DebugInfo/PDB/Native/DbiStream.cpp 48 : Stream(std::move(Stream)), Header(nullptr) {}
279 SectionHeaderStream = std::move(SHS);
304 OldFpoStream = std::move(FS);
321 NewFpoStream = std::move(FS);
lib/DebugInfo/PDB/Native/GlobalsStream.cpp 36 : Stream(std::move(Stream)) {}
78 Result.push_back(std::make_pair(Off, std::move(Record)));
120 return joinErrors(std::move(EC),
141 return joinErrors(std::move(EC),
164 return joinErrors(std::move(EC),
lib/DebugInfo/PDB/Native/HashTable.cpp 29 std::move(EC),
36 return joinErrors(std::move(EC),
54 std::move(EC),
66 return joinErrors(std::move(EC), make_error<RawError>(
lib/DebugInfo/PDB/Native/InfoStream.cpp 23 : Stream(std::move(Stream)), Header(nullptr) {}
30 std::move(EC),
lib/DebugInfo/PDB/Native/InjectedSourceStream.cpp 26 : Stream(std::move(Stream)) {}
lib/DebugInfo/PDB/Native/ModuleDebugStream.cpp 33 : Mod(Module), Stream(std::move(Stream)) {}
140 return std::move(EC);
lib/DebugInfo/PDB/Native/NamedStreamMap.cpp 54 return joinErrors(std::move(EC),
lib/DebugInfo/PDB/Native/NativeEnumInjectedSources.cpp 27 return std::move(E);
lib/DebugInfo/PDB/Native/NativeEnumTypes.cpp 52 : Matches(std::move(Indices)), Index(0), Session(PDBSession) {}
lib/DebugInfo/PDB/Native/NativeSession.cpp 54 : Pdb(std::move(PdbFile)), Allocator(std::move(Allocator)),
54 : Pdb(std::move(PdbFile)), Allocator(std::move(Allocator)),
63 std::move(Buffer), llvm::support::little);
66 auto File = std::make_unique<PDBFile>(Path, std::move(Stream), *Allocator);
73 std::make_unique<NativeSession>(std::move(File), std::move(Allocator));
73 std::make_unique<NativeSession>(std::move(File), std::move(Allocator));
lib/DebugInfo/PDB/Native/NativeSymbolEnumerator.cpp 23 Record(std::move(Record)) {}
lib/DebugInfo/PDB/Native/NativeTypeEnum.cpp 118 Record(std::move(Record)) {}
124 UnmodifiedType(&UnmodifiedType), Modifiers(std::move(Modifier)) {}
lib/DebugInfo/PDB/Native/NativeTypeFunctionSig.cpp 31 RealType(std::move(RealType)) {}
50 : Session(Session), TypeEnumerator(std::move(TypeEnumerator)) {}
68 auto NTFA = std::make_unique<NativeTypeFunctionArg>(Session, std::move(S));
69 return PDBSymbol::create(Session, std::move(NTFA));
81 Proc(std::move(Proc)), Index(Index), IsMemberFunction(false) {}
87 MemberFunc(std::move(MemberFunc)), Index(Index), IsMemberFunction(true) {}
141 new NativeEnumFunctionArgs(Session, std::move(NET)));
lib/DebugInfo/PDB/Native/NativeTypePointer.cpp 30 Record(std::move(Record)) {}
lib/DebugInfo/PDB/Native/NativeTypeTypedef.cpp 10 Record(std::move(Typedef)) {}
lib/DebugInfo/PDB/Native/NativeTypeUDT.cpp 22 Class(std::move(CR)), Tag(Class.getPointer()) {}
27 Union(std::move(UR)), Tag(Union.getPointer()) {}
33 UnmodifiedType(&UnmodifiedType), Modifiers(std::move(Modifier)) {}
lib/DebugInfo/PDB/Native/NativeTypeVTShape.cpp 11 Record(std::move(SR)) {}
lib/DebugInfo/PDB/Native/PDBFile.cpp 44 : FilePath(Path), Allocator(Allocator), Buffer(std::move(PdbFileBuffer)) {}
110 return std::move(EC);
126 consumeError(std::move(EC));
229 DirectoryStream = std::move(DS);
267 auto TempGlobals = std::make_unique<GlobalsStream>(std::move(*GlobalS));
269 return std::move(EC);
270 Globals = std::move(TempGlobals);
280 auto TempInfo = std::make_unique<InfoStream>(std::move(*InfoS));
282 return std::move(EC);
283 Info = std::move(TempInfo);
293 auto TempDbi = std::make_unique<DbiStream>(std::move(*DbiS));
295 return std::move(EC);
296 Dbi = std::move(TempDbi);
306 auto TempTpi = std::make_unique<TpiStream>(*this, std::move(*TpiS));
308 return std::move(EC);
309 Tpi = std::move(TempTpi);
322 auto TempIpi = std::make_unique<TpiStream>(*this, std::move(*IpiS));
324 return std::move(EC);
325 Ipi = std::move(TempIpi);
340 auto TempPublics = std::make_unique<PublicsStream>(std::move(*PublicS));
342 return std::move(EC);
343 Publics = std::move(TempPublics);
359 auto TempSymbols = std::make_unique<SymbolStream>(std::move(*SymbolS));
361 return std::move(EC);
362 Symbols = std::move(TempSymbols);
376 return std::move(EC);
378 StringTableStream = std::move(*NS);
379 Strings = std::move(N);
394 auto IJ = std::make_unique<InjectedSourceStream>(std::move(*IJS));
396 return std::move(EC);
397 InjectedSources = std::move(IJ);
lib/DebugInfo/PDB/Native/PDBFileBuilder.cpp 45 Msf = std::make_unique<MSFBuilder>(std::move(*ExpectedMsf));
114 Desc.Content = std::move(Buffer);
121 InjectedSources.push_back(std::move(Desc));
191 InjectedSourceTable.set_as(VName, std::move(Entry),
274 FileBufferByteStream Buffer = std::move(*ExpectedMsfBuffer);
lib/DebugInfo/PDB/Native/PDBStringTable.cpp 48 return joinErrors(std::move(EC),
68 return joinErrors(std::move(EC),
lib/DebugInfo/PDB/Native/PublicsStream.cpp 41 : Stream(std::move(Stream)) {}
79 return joinErrors(std::move(EC),
85 return joinErrors(std::move(EC),
92 return joinErrors(std::move(EC),
lib/DebugInfo/PDB/Native/SymbolCache.cpp 87 new NativeEnumTypes(Session, Types, std::move(Kinds)));
115 consumeError(std::move(EC));
129 static_cast<NativeTypeEnum &>(UnmodifiedNRS), std::move(Record));
132 static_cast<NativeTypeUDT &>(UnmodifiedNRS), std::move(Record));
186 Id = createSymbolForType<NativeTypeEnum, EnumRecord>(Index, std::move(CVT));
190 std::move(CVT));
195 Id = createSymbolForType<NativeTypeUDT, ClassRecord>(Index, std::move(CVT));
198 Id = createSymbolForType<NativeTypeUDT, UnionRecord>(Index, std::move(CVT));
202 std::move(CVT));
205 Id = createSymbolForModifiedType(Index, std::move(CVT));
209 Index, std::move(CVT));
213 Index, std::move(CVT));
217 Index, std::move(CVT));
269 Id = createSymbol<NativeTypeTypedef>(std::move(US));
lib/DebugInfo/PDB/Native/SymbolStream.cpp 23 : Stream(std::move(Stream)) {}
lib/DebugInfo/PDB/Native/TpiHashing.cpp 47 return std::move(E);
56 return std::move(E);
67 return TagRecordHash{std::move(Deserialized), ThisRecordHash, 0};
74 return TagRecordHash{std::move(Deserialized), FullHash, ThisRecordHash};
82 return std::move(E);
lib/DebugInfo/PDB/Native/TpiStream.cpp 37 : Pdb(File), Stream(std::move(Stream)) {}
112 HashStream = std::move(*HS);
lib/DebugInfo/PDB/PDB.cpp 33 return NativeSession::createFromPdb(std::move(*ErrorOrBuffer), Session);
lib/DebugInfo/PDB/PDBContext.cpp 25 : DIContext(CK_PDB), Session(std::move(PDBSession)) {
lib/DebugInfo/PDB/PDBSymbol.cpp 55 : Session(Other.Session), RawSymbol(std::move(Other.RawSymbol)) {}
106 SymbolPtr->OwnedRawSymbol = std::move(RawSymbol);
lib/DebugInfo/PDB/PDBSymbolFunc.cpp 43 Args.push_back(std::move(Child));
lib/DebugInfo/PDB/PDBSymbolTypeFunctionSig.cpp 36 : Session(PDBSession), Enumerator(std::move(ArgEnumerator)) {}
lib/DebugInfo/PDB/UDTLayout.cpp 71 DataMember(std::move(Member)) {
74 UdtLayout = std::make_unique<ClassLayout>(std::move(UDT));
83 Type(std::move(Sym)) {
99 VTable(std::move(VT)) {
144 OwnedStorage = std::move(UDT);
156 Base(std::move(B)) {
179 VirtualBaseSyms.push_back(std::move(Base));
181 Bases.push_back(std::move(Base));
185 Members.push_back(std::move(Data));
187 Other.push_back(std::move(Data));
189 VTables.push_back(std::move(VT));
191 Funcs.push_back(std::move(Func));
193 Other.push_back(std::move(Child));
209 std::move(Base));
212 addChildToLayout(std::move(BL));
219 std::make_unique<VTableLayoutItem>(*this, std::move(VTables[0]));
223 addChildToLayout(std::move(VTLayout));
227 auto DM = std::make_unique<DataMemberLayoutItem>(*this, std::move(Data));
229 addChildToLayout(std::move(DM));
239 auto VBPL = std::make_unique<VBPtrLayoutItem>(*this, std::move(VBP),
242 addChildToLayout(std::move(VBPL));
253 std::make_unique<BaseClassLayout>(*this, Offset, Elide, std::move(VB));
259 addChildToLayout(std::move(BL));
301 ChildStorage.push_back(std::move(Child));
lib/DebugInfo/Symbolize/DIPrinter.cpp 43 std::unique_ptr<MemoryBuffer> Buf = std::move(BufOrErr.get());
lib/DebugInfo/Symbolize/SymbolizableObjectFile.cpp 50 new SymbolizableObjectFile(Obj, std::move(DICtx), UntagAddresses));
104 return std::move(res);
110 : Module(Obj), DebugInfoContext(std::move(DICtx)),
lib/DebugInfo/Symbolize/Symbolize.cpp 72 createModuleInfo(&Obj, std::move(Context), ModuleName);
378 Pair.first->second = std::move(BinOrErr.get());
399 std::move(ObjOrErr.get()));
412 auto InfoOrErr = SymbolizableObjectFile::create(Obj, std::move(Context),
416 SymMod = std::move(*InfoOrErr);
418 Modules.insert(std::make_pair(ModuleName, std::move(SymMod)));
464 return createFileError(PDBFileName, std::move(Err));
466 Context.reset(new PDBContext(*CoffObject, std::move(Session)));
473 return createModuleInfo(Objects.first, std::move(Context), ModuleName);
lib/ExecutionEngine/ExecutionEngine.cpp 80 Modules.push_back(std::move(M));
85 Init(std::move(M));
89 : DL(std::move(DL)), LazyFunctionCreator(nullptr) {
90 Init(std::move(M));
360 Values.push_back(std::move(Dest));
476 : M(std::move(M)), WhichEngine(EngineKind::Either), ErrorStr(nullptr),
492 auto SharedMM = std::shared_ptr<RTDyldMemoryManager>(std::move(mcjmm));
500 MemMgr = std::shared_ptr<MCJITMemoryManager>(std::move(MM));
506 Resolver = std::shared_ptr<LegacyJITSymbolResolver>(std::move(SR));
542 EE = ExecutionEngine::OrcMCJITReplacementCtor(ErrorStr, std::move(MemMgr),
543 std::move(Resolver),
544 std::move(TheTM));
545 EE->addModule(std::move(M));
547 EE = ExecutionEngine::MCJITCtor(std::move(M), ErrorStr, std::move(MemMgr),
547 EE = ExecutionEngine::MCJITCtor(std::move(M), ErrorStr, std::move(MemMgr),
548 std::move(Resolver), std::move(TheTM));
548 std::move(Resolver), std::move(TheTM));
560 return ExecutionEngine::InterpCtor(std::move(M), ErrorStr);
lib/ExecutionEngine/ExecutionEngineBindings.cpp 197 EngineBuilder builder(std::move(Mod));
lib/ExecutionEngine/GDBRegistrationListener.cpp 70 : Size(Size), Entry(Entry), Obj(std::move(Obj)) {}
175 RegisteredObjectInfo(Size, JITCodeEntry, std::move(DebugObj));
lib/ExecutionEngine/Interpreter/Interpreter.cpp 39 handleAllErrors(std::move(Err), [&](ErrorInfoBase &EIB) {
48 return new Interpreter(std::move(M));
55 : ExecutionEngine(std::move(M)) {
lib/ExecutionEngine/JITLink/EHFrameSupport.cpp 102 return std::move(Err);
111 return std::move(Err);
130 return std::move(Err);
133 return std::move(AugInfo);
142 return std::move(Err);
146 return std::move(Err);
271 CIEInfos[CIESymbol.getAddress()] = std::move(CIEInfo);
517 StoreFrameRange = std::move(StoreRangeAddress)](LinkGraph &G) -> Error {
lib/ExecutionEngine/JITLink/JITLink.cpp 221 return jitLink_MachO(std::move(Ctx));
lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp 29 G = std::move(*GraphOrErr);
36 return Ctx->notifyFailed(std::move(Err));
52 return Ctx->notifyFailed(std::move(Err));
59 return Ctx->notifyFailed(std::move(Err));
77 TmpCtx->lookup(std::move(ExternalSymbols),
79 [S = std::move(Self), L = std::move(Layout)](
79 [S = std::move(Self), L = std::move(Layout)](
82 TmpSelf.linkPhase2(std::move(S), std::move(LookupResult),
82 TmpSelf.linkPhase2(std::move(S), std::move(LookupResult),
83 std::move(L));
104 return deallocateAndBailOut(std::move(Err));
112 return deallocateAndBailOut(std::move(Err));
118 UnownedSelf->linkPhase3(std::move(Self), std::move(Err));
118 UnownedSelf->linkPhase3(std::move(Self), std::move(Err));
121 Alloc->finalizeAsync(std::move(Phase3Continuation));
126 return deallocateAndBailOut(std::move(Err));
127 Ctx->notifyFinalized(std::move(Alloc));
225 Alloc = std::move(*AllocOrErr);
292 Ctx->notifyFailed(joinErrors(std::move(Err), Alloc->deallocate()));
lib/ExecutionEngine/JITLink/JITLinkGeneric.h 36 : Ctx(std::move(Ctx)), Passes(std::move(Passes)) {
36 : Ctx(std::move(Ctx)), Passes(std::move(Passes)) {
139 LTmp.linkPhase1(std::move(L));
lib/ExecutionEngine/JITLink/JITLinkMemoryManager.cpp 27 IPMMAlloc(AllocationMap SegBlocks) : SegBlocks(std::move(SegBlocks)) {}
125 Blocks[KV.first] = std::move(SegMem);
128 new IPMMAlloc(std::move(Blocks)));
lib/ExecutionEngine/JITLink/MachO.cpp 69 return jitLink_MachO_arm64(std::move(Ctx));
71 return jitLink_MachO_x86_64(std::move(Ctx));
lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.cpp 31 return std::move(Err);
34 return std::move(Err);
37 return std::move(Err);
40 return std::move(Err);
43 return std::move(Err);
45 return std::move(G);
57 CustomSectionParserFunctions[SectionName] = std::move(Parser);
166 IndexToSection.insert(std::make_pair(SecIndex, std::move(NSec)));
lib/ExecutionEngine/JITLink/MachO_arm64.cpp 493 : JITLinker(std::move(Ctx), std::move(PassConfig)) {}
493 : JITLinker(std::move(Ctx), std::move(PassConfig)) {}
516 return make_error<JITLinkError>(std::move(ErrMsg));
682 Config.PrePrunePasses.push_back(std::move(MarkLive));
694 return Ctx->notifyFailed(std::move(Err));
697 MachOJITLinker_arm64::link(std::move(Ctx), std::move(Config));
697 MachOJITLinker_arm64::link(std::move(Ctx), std::move(Config));
lib/ExecutionEngine/JITLink/MachO_x86_64.cpp 453 : JITLinker(std::move(Ctx), std::move(PassConfig)) {}
453 : JITLinker(std::move(Ctx), std::move(PassConfig)) {}
476 return make_error<JITLinkError>(std::move(ErrMsg));
571 Config.PrePrunePasses.push_back(std::move(MarkLive));
583 return Ctx->notifyFailed(std::move(Err));
586 MachOJITLinker_x86_64::link(std::move(Ctx), std::move(Config));
586 MachOJITLinker_x86_64::link(std::move(Ctx), std::move(Config));
lib/ExecutionEngine/MCJIT/MCJIT.cpp 59 return new MCJIT(std::move(M), std::move(TM), std::move(MemMgr),
59 return new MCJIT(std::move(M), std::move(TM), std::move(MemMgr),
59 return new MCJIT(std::move(M), std::move(TM), std::move(MemMgr),
60 std::move(Resolver));
66 : ExecutionEngine(TM->createDataLayout(), std::move(M)), TM(std::move(TM)),
66 : ExecutionEngine(TM->createDataLayout(), std::move(M)), TM(std::move(TM)),
67 Ctx(nullptr), MemMgr(std::move(MemMgr)),
68 Resolver(*this, std::move(Resolver)), Dyld(*this->MemMgr, this->Resolver),
80 std::unique_ptr<Module> First = std::move(Modules[0]);
86 OwnedModules.addModule(std::move(First));
108 OwnedModules.addModule(std::move(M));
123 LoadedObjects.push_back(std::move(Obj));
130 addObjectFile(std::move(ObjFile));
131 Buffers.push_back(std::move(MemBuf));
135 Archives.push_back(std::move(A));
172 new SmallVectorMemoryBuffer(std::move(ObjBufferSV)));
230 Buffers.push_back(std::move(ObjectToLoad));
231 LoadedObjects.push_back(std::move(*LoadedObject));
362 addObjectFile(std::move(OF));
617 report_fatal_error(std::move(Err));
lib/ExecutionEngine/MCJIT/MCJIT.h 32 : ParentEngine(Parent), ClientResolver(std::move(Resolver)) {}
lib/ExecutionEngine/Orc/CompileOnDemandLayer.cpp 72 : IRMaterializationUnit(ES, std::move(TSM), std::move(K)),
72 : IRMaterializationUnit(ES, std::move(TSM), std::move(K)),
79 : IRMaterializationUnit(std::move(TSM), std::move(K),
79 : IRMaterializationUnit(std::move(TSM), std::move(K),
80 std::move(SymbolFlags),
81 std::move(SymbolToDefinition)),
86 Parent.emitPartition(std::move(R), std::move(TSM),
86 Parent.emitPartition(std::move(R), std::move(TSM),
87 std::move(SymbolToDefinition));
103 return std::move(Requested);
115 BuildIndirectStubsManager(std::move(BuildIndirectStubsManager)) {}
118 this->Partition = std::move(Partition);
159 ES, std::move(TSM), R.getVModuleKey(), *this))) {
160 ES.reportError(std::move(Err));
165 R.replace(reexports(PDR.getImplDylib(), std::move(NonCallables), true));
167 std::move(Callables), AliaseeImpls));
184 ImplD.setSearchOrder(std::move(NewSearchOrder), false);
187 I = DylibResources.insert(std::make_pair(&TargetD, std::move(PDR))).first;
264 BaseLayer.emit(std::move(R), std::move(TSM));
264 BaseLayer.emit(std::move(R), std::move(TSM));
271 std::move(TSM), R.getSymbols(), std::move(Defs), *this));
271 std::move(TSM), R.getSymbols(), std::move(Defs), *this));
293 return std::move(Err);
314 ES, std::move(TSM), R.getVModuleKey(), *this));
315 BaseLayer.emit(std::move(R), std::move(*ExtractedTSM));
315 BaseLayer.emit(std::move(R), std::move(*ExtractedTSM));
lib/ExecutionEngine/Orc/CompileUtils.cpp 46 std::move(ObjBufferSV),
53 return std::move(ObjBuffer);
77 : JTMB(std::move(JTMB)), ObjCache(ObjCache) {}
lib/ExecutionEngine/Orc/Core.cpp 85 : S(S), ShouldPrint(std::move(ShouldPrint)) {}
108 return SetPrinter<Set, Pred>(S, std::move(P));
253 : Symbols(std::move(Symbols)) {
266 : Symbols(std::move(Symbols)) {
279 : Symbols(std::move(Symbols)) {
294 : NotifyComplete(std::move(NotifyComplete)), RequiredState(RequiredState) {
311 I->second = std::move(Sym);
319 auto TmpNotifyComplete = std::move(NotifyComplete);
321 TmpNotifyComplete(std::move(ResolvedSymbols));
330 NotifyComplete(std::move(Err));
336 bool Added = QueryRegistrations[&JD].insert(std::move(Name)).second;
362 : JD(JD), SymbolFlags(std::move(SymbolFlags)), K(std::move(K)) {
362 : JD(JD), SymbolFlags(std::move(SymbolFlags)), K(std::move(K)) {
431 JD.notifyFailed(std::move(Worklist));
444 JD.replace(std::move(MU));
462 DelegatedFlags[Name] = std::move(I->second);
466 return MaterializationResponsibility(JD, std::move(DelegatedFlags),
467 std::move(NewKey));
485 : MaterializationUnit(extractFlags(Symbols), std::move(K)),
486 Symbols(std::move(Symbols)) {}
516 : MaterializationUnit(extractFlags(Aliases), std::move(K)),
518 Aliases(std::move(Aliases)) {}
540 RequestedAliases[Name] = std::move(I->second);
554 R.replace(reexports(*SourceJD, std::move(Aliases), MatchNonExported));
556 R.replace(symbolAliases(std::move(Aliases)));
563 : R(std::move(R)), Aliases(std::move(Aliases)) {}
563 : R(std::move(R)), Aliases(std::move(Aliases)) {}
591 QueryAliases[KV.first] = std::move(KV.second);
601 R.delegate(ResponsibilitySymbols), std::move(QueryAliases));
603 make_pair(std::move(QuerySymbols), std::move(QueryInfo)));
603 make_pair(std::move(QuerySymbols), std::move(QueryInfo)));
608 auto QuerySymbols = std::move(QueryInfos.back().first);
609 auto QueryInfo = std::move(QueryInfos.back().second);
645 ES.reportError(std::move(Err));
650 ES.reportError(std::move(Err));
661 SymbolState::Resolved, std::move(OnComplete),
662 std::move(RegisterDependencies));
693 return make_error<SymbolsNotFound>(std::move(Unresolved));
709 Allow(std::move(Allow)) {}
800 return std::move(MU);
805 auto UMI = std::make_shared<UnmaterializedInfo>(std::move(MU));
823 ES.dispatchMaterialization(*this, std::move(MustRunMU));
982 CompletedQueries.insert(std::move(Q));
993 (*FailedSymbolsDepMap)[this] = std::move(SymbolsInErrorState);
994 return make_error<FailedToMaterialize>(std::move(FailedSymbolsDepMap));
1126 (*FailedSymbolsDepMap)[this] = std::move(SymbolsInErrorState);
1127 return make_error<FailedToMaterialize>(std::move(FailedSymbolsDepMap));
1153 auto Name = std::move(Worklist.back().second);
1261 ES.runSessionLocked([&]() { SearchOrder = std::move(NewSearchOrder); });
1325 return make_error<SymbolsNotFound>(std::move(Missing));
1329 return make_error<SymbolsCouldNotBeRemoved>(std::move(Materializing));
1467 return make_error<FailedToMaterialize>(std::move(FailedSymbolsMap));
1485 auto MU = std::move(UMII->second->MU);
1498 MUs.push_back(std::move(MU));
1526 SymbolNameSet Unresolved = std::move(Names);
1553 return std::move(Err);
1567 ES.OutstandingMUs.push_back(make_pair(this, std::move(MU)));
1609 auto MU = std::move(UMII->second->MU);
1623 MUs.push_back(std::move(MU));
1698 PendingQueries.insert(I.base(), std::move(Q));
1721 Result.push_back(std::move(PendingQueries.back()));
1729 : ES(ES), JITDylibName(std::move(Name)) {
1822 : SSP(SSP ? std::move(SSP) : std::make_shared<SymbolStringPool>()) {
1845 std::unique_ptr<JITDylib>(new JITDylib(*this, std::move(Name))));
1862 Q.handleFailed(std::move(Err));
1864 reportError(std::move(Err));
1877 PromisedResult.set_value(std::move(*R));
1898 Names, RequiredState, std::move(NotifyComplete));
1901 SymbolNameSet UnresolvedSymbols = AsyncLookup(Query, std::move(Names));
1912 auto Err = make_error<SymbolsNotFound>(std::move(UnresolvedSymbols));
1914 Query->handleFailed(std::move(Err));
1916 reportError(std::move(Err));
1923 return std::move(ResolutionError);
1924 return std::move(Result);
1951 auto Unresolved = std::move(Symbols);
1954 std::move(NotifyComplete));
1972 return make_error<SymbolsNotFound>(std::move(Unresolved));
1986 KV.first->replace(std::move(MU));
2006 Q->handleFailed(std::move(LodgingErr));
2019 OutstandingMUs.push_back(std::make_pair(KV.first, std::move(MU)));
2037 PromisedResult.set_value(std::move(*R));
2067 return std::move(ResolutionError);
2069 return std::move(Result);
2084 if (auto ResultMap = lookup(SearchOrder, std::move(Names), SymbolState::Ready,
2088 return std::move(ResultMap->begin()->second);
2125 JITDylibAndMU = std::move(OutstandingMUs.back());
2133 std::move(JITDylibAndMU.second));
lib/ExecutionEngine/Orc/ExecutionUtils.cpp 133 ES.lookup(JITDylibSearchList({{&JD, true}}), std::move(Names))) {
174 return JD.define(absoluteSymbols(std::move(RuntimeInterposes)));
179 : Dylib(std::move(Dylib)), Allow(std::move(Allow)),
179 : Dylib(std::move(Dylib)), Allow(std::move(Allow)),
188 return make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode());
190 std::move(Lib), GlobalPrefix, std::move(Allow));
190 std::move(Lib), GlobalPrefix, std::move(Allow));
225 cantFail(JD.define(absoluteSymbols(std::move(NewSymbols))));
237 return Create(L, std::move(*ArchiveBuffer));
246 new StaticLibraryDefinitionGenerator(L, std::move(ArchiveBuffer), Err));
249 return std::move(Err);
251 return std::move(ADG);
281 return std::move(Err);
291 : L(L), ArchiveBuffer(std::move(ArchiveBuffer)),
304 Err = std::move(Err2);
lib/ExecutionEngine/Orc/IRCompileLayer.cpp 16 : IRLayer(ES), BaseLayer(BaseLayer), Compile(std::move(Compile)) {}
20 this->NotifyCompiled = std::move(NotifyCompiled);
31 NotifyCompiled(R.getVModuleKey(), std::move(TSM));
35 BaseLayer.emit(std::move(R), std::move(*Obj));
35 BaseLayer.emit(std::move(R), std::move(*Obj));
lib/ExecutionEngine/Orc/IRTransformLayer.cpp 18 : IRLayer(ES), BaseLayer(BaseLayer), Transform(std::move(Transform)) {}
24 if (auto TransformedTSM = Transform(std::move(TSM), R))
25 BaseLayer.emit(std::move(R), std::move(*TransformedTSM));
25 BaseLayer.emit(std::move(R), std::move(*TransformedTSM));
lib/ExecutionEngine/Orc/IndirectionUtils.cpp 31 std::move(K)),
32 Name(std::move(Name)), Compile(std::move(Compile)) {}
32 Name(std::move(Name)), Compile(std::move(Compile)) {}
71 std::move(CallbackName), std::move(Compile),
71 std::move(CallbackName), std::move(Compile),
98 make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode()));
lib/ExecutionEngine/Orc/JITTargetMachineBuilder.cpp 18 : TT(std::move(TT)) {
49 return make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode());
lib/ExecutionEngine/Orc/LLJIT.cpp 22 JTMB = std::move(*JTMBOrErr);
38 return Main.define(absoluteSymbols(std::move(Symbols)));
48 return CompileLayer->add(JD, std::move(TSM), ES->allocateVModule());
54 return ObjLinkingLayer->add(JD, std::move(Obj), ES->allocateVModule());
73 std::make_unique<RTDyldObjectLinkingLayer>(ES, std::move(GetMemMgr));
81 return std::unique_ptr<ObjectLayer>(std::move(ObjLinkingLayer));
90 return S.CreateCompileFunction(std::move(JTMB));
95 return ConcurrentIRCompiler(std::move(JTMB));
101 return TMOwningSimpleCompiler(std::move(*TM));
105 : ES(S.ES ? std::move(S.ES) : std::make_unique<ExecutionSession>()),
114 DL = std::move(*DLOrErr);
121 auto CompileFunction = createCompileFunction(S, std::move(*S.JTMB));
127 *ES, *ObjLinkingLayer, std::move(*CompileFunction));
136 auto SharedMU = std::shared_ptr<MaterializationUnit>(std::move(MU));
138 CompileThreads->async(std::move(Work));
188 return CODLayer->add(JD, std::move(TSM), ES->allocateVModule());
201 LCTMgr = std::move(S.LCTMgr);
205 LCTMgr = std::move(*LCTMgrOrErr);
213 auto ISMBuilder = std::move(S.ISMBuilder);
233 *ES, *TransformLayer, *LCTMgr, std::move(ISMBuilder));
lib/ExecutionEngine/Orc/Layer.cpp 23 *this, std::move(K), std::move(TSM)));
23 *this, std::move(K), std::move(TSM)));
28 : MaterializationUnit(SymbolFlagsMap(), std::move(K)), TSM(std::move(TSM)) {
28 : MaterializationUnit(SymbolFlagsMap(), std::move(K)), TSM(std::move(TSM)) {
48 : MaterializationUnit(std::move(SymbolFlags), std::move(K)),
48 : MaterializationUnit(std::move(SymbolFlags), std::move(K)),
49 TSM(std::move(TSM)), SymbolToDefinition(std::move(SymbolToDefinition)) {}
49 TSM(std::move(TSM)), SymbolToDefinition(std::move(SymbolToDefinition)) {}
76 : IRMaterializationUnit(L.getExecutionSession(), std::move(TSM),
77 std::move(K)),
78 L(L), K(std::move(K)) {}
98 L.emit(std::move(R), std::move(TSM));
98 L.emit(std::move(R), std::move(TSM));
110 auto ObjMU = BasicObjectLayerMaterializationUnit::Create(*this, std::move(K),
111 std::move(O));
114 return JD.define(std::move(*ObjMU));
127 new BasicObjectLayerMaterializationUnit(L, K, std::move(O),
128 std::move(*SymbolFlags)));
134 : MaterializationUnit(std::move(SymbolFlags), std::move(K)), L(L),
134 : MaterializationUnit(std::move(SymbolFlags), std::move(K)), L(L),
135 O(std::move(O)) {}
145 L.emit(std::move(R), std::move(O));
145 L.emit(std::move(R), std::move(O));
178 SymbolFlags[InternedName] = std::move(*SymFlags);
lib/ExecutionEngine/Orc/LazyReexports.cpp 24 : ES(ES), ErrorHandlerAddr(ErrorHandlerAddr), TP(std::move(TP)) {}
35 Reexports[*Trampoline] = std::make_pair(&SourceJD, std::move(SymbolName));
36 Notifiers[*Trampoline] = std::move(NotifyResolved);
75 ES.reportError(std::move(Err));
126 : MaterializationUnit(extractFlags(CallableAliases), std::move(K)),
128 CallableAliases(std::move(CallableAliases)),
148 RequestedAliases[I->first] = std::move(I->second);
154 std::move(CallableAliases), AliaseeTable));
177 SourceJD.getExecutionSession().reportError(std::move(Err));
lib/ExecutionEngine/Orc/Legacy.cpp 26 auto OnResolvedWithUnwrap = [OnResolved = std::move(OnResolved)](
35 Result[*KV.first] = std::move(KV.second);
40 InternedSymbols, SymbolState::Resolved, std::move(OnResolvedWithUnwrap));
47 ES.legacyFailQuery(*Q, make_error<SymbolsNotFound>(std::move(Unresolved)));
lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp 30 : Layer(Layer), MR(std::move(MR)), ObjBuffer(std::move(ObjBuffer)) {}
30 : Layer(Layer), MR(std::move(MR)), ObjBuffer(std::move(ObjBuffer)) {}
36 Layer.ReturnObjectBuffer(std::move(ObjBuffer));
46 Layer.getExecutionSession().reportError(std::move(Err));
64 auto OnResolve = [this, LookupContinuation = std::move(LC)](
73 LookupContinuation->run(std::move(LR));
77 ES.lookup(SearchOrder, std::move(InternedSymbols), SymbolState::Resolved,
78 std::move(OnResolve), [this](const SymbolDependenceMap &Deps) {
129 return notifyFailed(std::move(Err));
131 Layer.getExecutionSession().reportError(std::move(Err));
140 if (auto Err = Layer.notifyEmitted(MR, std::move(A))) {
141 Layer.getExecutionSession().reportError(std::move(Err));
146 Layer.getExecutionSession().reportError(std::move(Err));
240 : Sym(Sym), SymAnonDeps(std::move(SymAnonDeps)) {}
263 Worklist.push_back(WorklistEntry(Sym, std::move(SymAnonDeps)));
326 getExecutionSession().reportError(std::move(Err));
333 *this, std::move(R), std::move(O)));
333 *this, std::move(R), std::move(O)));
352 Err = joinErrors(std::move(Err), P->notifyEmitted(MR));
359 UntrackedAllocs.push_back(std::move(Alloc));
369 Err = joinErrors(std::move(Err), P->notifyRemovingModule(K));
376 Alloc = std::move(AllocItr->second);
382 return joinErrors(std::move(Err), Alloc->deallocate());
390 Err = joinErrors(std::move(Err), P->notifyRemovingAllModules());
395 Allocs = std::move(UntrackedAllocs);
398 Allocs.push_back(std::move(KV.second));
404 Err = joinErrors(std::move(Err), Allocs.back()->deallocate());
464 std::move(UntrackedEHFrameRanges);
478 Err = joinErrors(std::move(Err),
lib/ExecutionEngine/Orc/ObjectTransformLayer.cpp 18 : ObjectLayer(ES), BaseLayer(BaseLayer), Transform(std::move(Transform)) {}
24 if (auto TransformedObj = Transform(std::move(O)))
25 BaseLayer.emit(std::move(R), std::move(*TransformedObj));
25 BaseLayer.emit(std::move(R), std::move(*TransformedObj));
lib/ExecutionEngine/Orc/OrcABISupport.cpp 186 StubsInfo = IndirectStubsInfo(NumStubs, std::move(StubsMem));
267 StubsInfo = IndirectStubsInfo(NumStubs, std::move(StubsMem));
534 StubsInfo = IndirectStubsInfo(NumStubs, std::move(StubsMem));
727 StubsInfo = IndirectStubsInfo(NumStubs, std::move(StubsMem));
978 StubsInfo = IndirectStubsInfo(NumStubs, std::move(StubsMem));
lib/ExecutionEngine/Orc/OrcCBindings.cpp 24 new OrcCBindingsStack(*TM2, std::move(IndirectStubsMgrBuilder));
77 J.addIRModuleEager(std::move(M), SymbolResolver, SymbolResolverCtx)) {
92 J.addIRModuleLazy(std::move(M), SymbolResolver, SymbolResolverCtx)) {
107 J.addObject(std::move(O), SymbolResolver, SymbolResolverCtx)) {
147 return wrap(std::move(Err));
lib/ExecutionEngine/Orc/OrcCBindingsStack.h 128 : Stack(Stack), ExternalResolver(std::move(ExternalResolver)),
129 ExternalResolverCtx(std::move(ExternalResolverCtx)) {}
140 Stack.reportError(std::move(Err));
163 Stack.ES.legacyFailQuery(*Query, std::move(Err));
220 auto Resolver = std::move(ResolverI->second);
236 std::move(IndirectStubsMgrBuilder), Resolvers)),
272 return CCMgr->getCompileCallback(std::move(WrappedCallback));
307 if (auto Err = Layer.addModule(K, std::move(M)))
308 return std::move(Err);
315 AcknowledgeORCv1Deprecation, std::move(CtorNames), K);
317 return std::move(Err);
320 std::move(DtorNames), K);
329 return addIRModule(CompileLayer, std::move(M),
331 std::move(ExternalResolver), ExternalResolverCtx);
343 return addIRModule(*CODLayer, std::move(M),
345 std::move(ExternalResolver), ExternalResolverCtx);
367 if (auto Err = ObjectLayer.addObject(K, std::move(ObjBuffer)))
368 return std::move(Err);
402 return std::move(Err);
420 return std::move(Err);
459 return std::move(*CCMgr);
482 Resolvers[K] = std::move(Resolver);
485 std::move(IndirectStubsMgrBuilder), false);
490 logAllUnhandledErrors(std::move(Err), errs(), "ORC error: ");
lib/ExecutionEngine/Orc/OrcError.cpp 83 : SymbolName(std::move(SymbolName)) {}
98 : SymbolName(std::move(SymbolName)) {}
lib/ExecutionEngine/Orc/OrcMCJITReplacement.cpp 131 AcknowledgeORCv1Deprecation, std::move(KV.second), KV.first)
lib/ExecutionEngine/Orc/OrcMCJITReplacement.h 65 : M(M), ClientMM(std::move(ClientMM)) {}
154 M.reportError(std::move(Err));
161 M.reportError(std::move(Err));
187 M.ES.legacyFailQuery(*Query, std::move(Err));
200 M.ES.legacyFailQuery(*Query, std::move(Err));
223 return new OrcMCJITReplacement(std::move(MemMgr), std::move(Resolver),
223 return new OrcMCJITReplacement(std::move(MemMgr), std::move(Resolver),
224 std::move(TM));
228 logAllUnhandledErrors(std::move(Err), errs(), "MCJIT error: ");
235 : ExecutionEngine(TM->createDataLayout()), TM(std::move(TM)),
237 std::make_shared<MCJITReplacementMemMgr>(*this, std::move(MemMgr))),
239 ClientResolver(std::move(ClientResolver)), NotifyObjectLoaded(*this),
250 Modules.push_back(std::move(M));
292 UnexecutedConstructors[K] = std::move(CtorNames);
293 UnexecutedDestructors[K] = std::move(DtorNames);
295 cantFail(LazyEmitLayer.addModule(K, std::move(M)));
307 cantFail(ObjectLayer.addObject(ES.allocateVModule(), std::move(ObjBuffer)));
311 Archives.push_back(std::move(A));
430 M.UnfinalizedSections[K] = std::move(M.SectionsAllocatedSinceLastLoad);
lib/ExecutionEngine/Orc/RPCUtils.cpp 41 : Signature(std::move(Signature)) {}
lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp 31 [OnResolved = std::move(OnResolved)](
40 Result[*KV.first] = std::move(KV.second);
53 std::move(OnResolvedWithUnwrap), RegisterDependencies);
88 auto SharedR = std::make_shared<MaterializationResponsibility>(std::move(R));
130 MemMgrs.push_back(std::move(Tmp));
137 **Obj, std::move(O), *MemMgr, Resolver, ProcessAllSections,
141 return onObjLoad(K, *SharedR, **Obj, std::move(LoadedObjInfo),
144 [this, K, SharedR, O = std::move(O)](Error Err) mutable {
145 onObjEmit(K, std::move(O), *SharedR, std::move(Err));
145 onObjEmit(K, std::move(O), *SharedR, std::move(Err));
199 getExecutionSession().reportError(std::move(Err));
205 getExecutionSession().reportError(std::move(Err));
211 NotifyEmitted(K, std::move(ObjBuffer));
218 : ES(ES), GetResources(std::move(GetResources)),
219 NotifyLoaded(std::move(NotifyLoaded)),
220 NotifyFinalized(std::move(NotifyFinalized)),
221 NotifyFreed(std::move(NotifyFreed)), ProcessAllSections(false) {}
lib/ExecutionEngine/Orc/SpeculateAnalyses.cpp 123 CallerAndCalles.insert({F.getName(), std::move(Calles)});
278 MinCallerBlocks.push_back(std::move(I.first));
302 CallerAndCalles.insert({F.getName(), std::move(Calles)});
lib/ExecutionEngine/Orc/Speculation.cpp 142 NextLayer.emit(std::move(R), std::move(TSM));
142 NextLayer.emit(std::move(R), std::move(TSM));
lib/ExecutionEngine/Orc/ThreadSafeModule.cpp 59 return ThreadSafeModule(std::move(ClonedModule), std::move(NewTSCtx));
59 return ThreadSafeModule(std::move(ClonedModule), std::move(NewTSCtx));
lib/ExecutionEngine/RuntimeDyld/JITSymbol.cpp 83 OnResolved(std::move(Err));
95 OnResolved(std::move(Err));
105 OnResolved(std::move(Result));
122 return std::move(Err);
130 return std::move(Result);
lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp 133 ErrorStr = toString(std::move(Err));
197 return std::move(Err);
228 ResponsibilitySet = std::move(*ResultOrErr);
322 return std::move(Err);
344 return std::move(Err);
435 return std::move(Err);
763 SymbolTableEntry(SectionID, Offset, std::move(*JITSymFlags));
1167 NewSymbolsP->set_value(std::move(Result));
1196 auto SharedThis = std::shared_ptr<RuntimeDyldImpl>(std::move(This));
1198 [SharedThis, OnEmitted = std::move(OnEmitted),
1199 UnderlyingBuffer = std::move(UnderlyingBuffer)](
1216 OnEmitted(make_error<StringError>(std::move(ErrMsg),
1234 SharedThis->Resolver.lookup(Symbols, std::move(PostResolveContinuation));
1279 Dyld->setNotifyStubEmitted(std::move(NotifyStubEmitted));
1290 Dyld->setNotifyStubEmitted(std::move(NotifyStubEmitted));
1303 Dyld->setNotifyStubEmitted(std::move(NotifyStubEmitted));
1314 std::move(NotifyStubEmitted));
1318 ProcessAllSections, std::move(NotifyStubEmitted));
1322 ProcessAllSections, std::move(NotifyStubEmitted));
1427 if (auto Err = OnLoaded(std::move(Info), RTDyld.getSymbolTable()))
1428 OnEmitted(std::move(Err));
1430 RuntimeDyldImpl::finalizeAsync(std::move(RTDyld.Dyld), std::move(OnEmitted),
1430 RuntimeDyldImpl::finalizeAsync(std::move(RTDyld.Dyld), std::move(OnEmitted),
1431 std::move(UnderlyingBuffer));
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldCOFF.cpp 35 : LoadedObjectInfoHelper(RTDyld, std::move(ObjSecToIDMap)) {}
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp 102 : Value(0), ErrorMsg(std::move(ErrorMsg)) {}
143 return EvalResult(std::move(ErrorMsg));
683 : IsSymbolValid(std::move(IsSymbolValid)),
684 GetSymbolInfo(std::move(GetSymbolInfo)),
685 GetSectionInfo(std::move(GetSectionInfo)),
686 GetStubInfo(std::move(GetStubInfo)), GetGOTInfo(std::move(GetGOTInfo)),
686 GetStubInfo(std::move(GetStubInfo)), GetGOTInfo(std::move(GetGOTInfo)),
800 return std::make_pair(0, std::move(ErrMsg));
833 return std::make_pair((uint64_t)0, std::move(ErrMsg));
855 std::move(IsSymbolValid), std::move(GetSymbolInfo),
855 std::move(IsSymbolValid), std::move(GetSymbolInfo),
856 std::move(GetSectionInfo), std::move(GetStubInfo),
856 std::move(GetSectionInfo), std::move(GetStubInfo),
857 std::move(GetGOTInfo), Endianness, Disassembler, InstPrinter,
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp 96 : ELFObjectFile<ELFT>(std::move(Obj)) {
105 return std::move(E);
107 new DyldELFObject<ELFT>(std::move(*Obj)));
108 return std::move(Ret);
140 : LoadedObjectInfoHelper(RTDyld, std::move(ObjSecToIDMap)) {}
156 return std::move(E);
158 std::unique_ptr<DyldELFObject<ELFT>> Obj = std::move(*ObjOrErr);
183 return std::move(Obj);
211 return OwningBinary<ObjectFile>(std::move(*DebugObj), std::move(Buffer));
211 return OwningBinary<ObjectFile>(std::move(*DebugObj), std::move(Buffer));
1463 return std::move(Err);
1577 return std::move(Err);
1590 return std::move(Err);
1593 return std::move(Err);
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h 571 this->NotifyStubEmitted = std::move(NotifyStubEmitted);
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp 34 : LoadedObjectInfoHelper(RTDyld, std::move(ObjSecToIDMap)) {}
lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOAArch64.h 48 return make_error<StringError>(std::move(ErrMsg),
60 return make_error<StringError>(std::move(ErrMsg),
lib/FuzzMutate/FuzzerCLI.cpp 161 std::unique_ptr<MemoryBuffer> Buf = std::move(BufOrErr.get());
183 errs() << toString(std::move(E)) << "\n";
186 return std::move(M.get());
lib/IR/ConstantRange.cpp 47 : Lower(std::move(V)), Upper(Lower + 1) {}
50 : Lower(std::move(L)), Upper(std::move(U)) {
50 : Lower(std::move(L)), Upper(std::move(U)) {
96 return ConstantRange(APInt::getMinValue(W), std::move(UMax));
102 return ConstantRange(APInt::getSignedMinValue(W), std::move(SMax));
112 return ConstantRange(std::move(UMin) + 1, APInt::getNullValue(W));
118 return ConstantRange(std::move(SMin) + 1, APInt::getSignedMinValue(W));
580 return ConstantRange(std::move(L), std::move(U));
580 return ConstantRange(std::move(L), std::move(U));
623 return ConstantRange(std::move(L), std::move(U));
623 return ConstantRange(std::move(L), std::move(U));
650 return ConstantRange(std::move(Min), std::move(Max));
650 return ConstantRange(std::move(Min), std::move(Max));
657 return ConstantRange(std::move(SMin), std::move(SMax));
657 return ConstantRange(std::move(SMin), std::move(SMax));
679 return ConstantRange(std::move(LowerExt),
846 ConstantRange X = ConstantRange(std::move(NewLower), std::move(NewUpper));
846 ConstantRange X = ConstantRange(std::move(NewLower), std::move(NewUpper));
875 return getNonEmpty(std::move(NewMin), std::move(NewMax) + 1);
875 return getNonEmpty(std::move(NewMin), std::move(NewMax) + 1);
895 return getNonEmpty(std::move(NewMin), std::move(NewMax) + 1);
895 return getNonEmpty(std::move(NewMin), std::move(NewMax) + 1);
917 ConstantRange X = ConstantRange(std::move(NewLower), std::move(NewUpper));
917 ConstantRange X = ConstantRange(std::move(NewLower), std::move(NewUpper));
987 return getNonEmpty(std::move(NewL), std::move(NewU));
987 return getNonEmpty(std::move(NewL), std::move(NewU));
998 return getNonEmpty(std::move(NewL), std::move(NewU));
998 return getNonEmpty(std::move(NewL), std::move(NewU));
1009 return getNonEmpty(std::move(NewL), std::move(NewU));
1009 return getNonEmpty(std::move(NewL), std::move(NewU));
1020 return getNonEmpty(std::move(NewL), std::move(NewU));
1020 return getNonEmpty(std::move(NewL), std::move(NewU));
1041 return getNonEmpty(std::move(Lower), std::move(Upper));
1041 return getNonEmpty(std::move(Lower), std::move(Upper));
1099 ConstantRange(std::move(Lo),
1104 ConstantRange(std::move(Lo), NegL.Lower.sdiv(NegR.Upper - 1) + 1));
1139 return getNonEmpty(APInt::getNullValue(getBitWidth()), std::move(Upper));
1166 return ConstantRange(APInt::getNullValue(getBitWidth()), std::move(Upper));
1175 return ConstantRange(std::move(Lower), APInt(getBitWidth(), 1));
1181 return ConstantRange(std::move(Lower), std::move(Upper));
1181 return ConstantRange(std::move(Lower), std::move(Upper));
1192 return getNonEmpty(APInt::getNullValue(getBitWidth()), std::move(umin) + 1);
1203 return getNonEmpty(std::move(umax), APInt::getNullValue(getBitWidth()));
1228 return ConstantRange(std::move(min), std::move(max) + 1);
1228 return ConstantRange(std::move(min), std::move(max) + 1);
1238 return getNonEmpty(std::move(min), std::move(max));
1238 return getNonEmpty(std::move(min), std::move(max));
1289 return getNonEmpty(std::move(min), std::move(max));
1289 return getNonEmpty(std::move(min), std::move(max));
1298 return getNonEmpty(std::move(NewL), std::move(NewU));
1298 return getNonEmpty(std::move(NewL), std::move(NewU));
1307 return getNonEmpty(std::move(NewL), std::move(NewU));
1307 return getNonEmpty(std::move(NewL), std::move(NewU));
1316 return getNonEmpty(std::move(NewL), std::move(NewU));
1316 return getNonEmpty(std::move(NewL), std::move(NewU));
1325 return getNonEmpty(std::move(NewL), std::move(NewU));
1325 return getNonEmpty(std::move(NewL), std::move(NewU));
lib/IR/DIBuilder.cpp 539 return MDNode::replaceWithDistinct(std::move(NewSP));
545 return MDNode::replaceWithUniqued(std::move(NewTy));
lib/IR/DiagnosticInfo.cpp 351 Args.push_back(std::move(A));
lib/IR/Function.cpp 485 getContext().setGC(*this, std::move(Str));
lib/IR/Instructions.cpp 3934 this->Weights = std::move(Weights);
lib/IR/LLVMContext.cpp 127 pImpl->DiagHandler = std::move(DH);
153 pImpl->RemarkDiagStreamer = std::move(RemarkStreamer);
284 pImpl->GCNames.insert(std::make_pair(&Fn, std::move(GCName)));
287 It->second = std::move(GCName);
330 return std::move(pImpl->DiagHandler);
lib/IR/Metadata.cpp 1125 *I = std::move(Attachments.back());
lib/IR/Module.cpp 404 std::unique_ptr<GVMaterializer> M = std::move(Materializer);
547 OwnedMemoryBuffer = std::move(MB);
lib/IR/ProfileSummary.cpp 183 return new ProfileSummary(SummaryKind, std::move(Summary), TotalCount,
lib/IR/RemarkStreamer.cpp 34 : PassFilter(), RemarkSerializer(std::move(RemarkSerializer)),
43 PassFilter = std::move(R);
159 return make_error<RemarkSetupFormatError>(std::move(E));
175 return make_error<RemarkSetupFormatError>(std::move(E));
178 std::move(*RemarkSerializer), RemarksFilename));
182 return make_error<RemarkSetupPatternError>(std::move(E));
184 return std::move(RemarksFile);
200 return make_error<RemarkSetupFormatError>(std::move(E));
206 return make_error<RemarkSetupFormatError>(std::move(E));
209 std::make_unique<RemarkStreamer>(std::move(*RemarkSerializer)));
213 return make_error<RemarkSetupPatternError>(std::move(E));
lib/IR/SafepointIRVerifier.cpp 772 AvailableOut = std::move(Temp);
896 GCPtrTracker::verifyFunction(std::move(Tracker), Verifier);
lib/IRReader/IRReader.cpp 38 std::move(Buffer), Context, ShouldLazyLoadMetadata);
40 handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
46 return std::move(ModuleOrErr.get());
64 return getLazyIRModule(std::move(FileOrErr.get()), Err, Context,
80 handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
88 return std::move(ModuleOrErr.get());
lib/LTO/Caching.cpp 52 AddBuffer(Task, std::move(*MBOrErr));
81 : NativeObjectStream(std::move(OS)), AddBuffer(std::move(AddBuffer)),
81 : NativeObjectStream(std::move(OS)), AddBuffer(std::move(AddBuffer)),
82 TempFile(std::move(TempFile)), EntryPath(std::move(EntryPath)),
82 TempFile(std::move(TempFile)), EntryPath(std::move(EntryPath)),
109 E = handleErrors(std::move(E), [&](const ECError &E) -> Error {
116 MBOrErr = std::move(MBCopy);
127 toString(std::move(E)) + "\n");
129 AddBuffer(Task, std::move(*MBOrErr));
147 AddBuffer, std::move(*Temp), EntryPath.str(), Task);
lib/LTO/LTO.cpp 454 File->Strtab = std::move(FOrErr->Strtab);
455 return std::move(File);
482 : Conf(std::move(Conf)),
484 ThinLTO(std::move(Backend)) {}
618 return linkRegularLTO(std::move(*ModOrErr), /*LivenessFromIndex=*/false);
624 RegularLTO.ModsWithSummaries.push_back(std::move(*ModOrErr));
672 Mod.M = std::move(*MOrErr);
675 return std::move(Err);
775 return std::move(Mod);
800 return RegularLTO.Mover->move(std::move(Mod.M), Keep,
930 std::unique_ptr<ToolOutputFile> StatsFile = std::move(StatsFileOrErr.get());
935 if (Error Err = linkRegularLTO(std::move(M),
1014 std::move(RegularLTO.CombinedModule), ThinLTO.CombinedIndex);
1069 AddStream(std::move(AddStream)), Cache(std::move(Cache)) {
1069 AddStream(std::move(AddStream)), Cache(std::move(Cache)) {
1140 Err = joinErrors(std::move(*Err), std::move(E));
1140 Err = joinErrors(std::move(*Err), std::move(E));
1142 Err = std::move(E);
1153 return std::move(*Err);
1389 return std::move(E);
1411 return std::move(StatsFile);
lib/LTO/LTOBackend.cpp 185 FAM.registerPass([&] { return std::move(AA); });
237 AAPipelineDesc + "': " + toString(std::move(Err)));
245 FAM.registerPass([&] { return std::move(AA); });
262 PipelineDesc + "': " + toString(std::move(Err)));
361 std::move(Mod), ParallelCodeGenParallelismLevel,
382 std::unique_ptr<Module> MPartInCtx = std::move(MOrErr.get());
391 std::move(BC), ThreadCount++);
443 auto DiagnosticOutputFile = std::move(*DiagFileOrErr);
448 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
455 std::move(Mod));
457 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
498 auto DiagnosticOutputFile = std::move(*DiagFileOrErr);
502 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
506 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
515 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
522 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
539 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
543 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
546 return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
lib/LTO/LTOCodeGenerator.cpp 314 return std::move(*BufferOrErr);
535 DiagnosticOutputFile = std::move(*DiagFileOrErr);
543 StatsFile = std::move(StatsFileOrErr.get());
607 MergedModule = splitCodeGen(std::move(MergedModule), Out, {},
lib/LTO/LTOModule.cpp 47 : Mod(std::move(M)), MBRef(MBRef), _target(TM) {
117 std::unique_ptr<MemoryBuffer> Buffer = std::move(BufferOrErr.get());
139 std::unique_ptr<MemoryBuffer> Buffer = std::move(BufferOrErr.get());
164 (*Ret)->OwnedContext = std::move(Context);
175 std::error_code EC = errorToErrorCode(std::move(E));
231 std::unique_ptr<LTOModule> Ret(new LTOModule(std::move(M), Buffer, target));
235 return std::move(Ret);
lib/LTO/ThinLTOCodeGenerator.cpp 201 return std::move(*ModuleOrErr);
302 return std::make_unique<SmallVectorMemoryBuffer>(std::move(OutputBuffer));
393 consumeError(std::move(Err));
452 return std::make_unique<SmallVectorMemoryBuffer>(std::move(OutputBuffer));
503 TMBuilder.TheTriple = std::move(TheTriple);
528 Modules.emplace_back(std::move(*InputOrError));
575 std::move(Err), errs(),
925 ProducedBinaries[count] = std::move(OutputBuffer);
1066 ProducedBinaries[count] = std::move(ErrOrBuffer.get());
1119 OutputBuffer = std::move(*ReloadedBufferOrErr);
1122 ProducedBinaries[count] = std::move(OutputBuffer);
lib/Linker/IRMover.cpp 429 FoundError = std::move(E);
524 : DstM(DstM), SrcM(std::move(SrcM)), AddLazyFor(std::move(AddLazyFor)),
524 : DstM(DstM), SrcM(std::move(SrcM)), AddLazyFor(std::move(AddLazyFor)),
531 ValueMap.getMDMap() = std::move(SharedMDs);
537 ~IRLinker() { SharedMDs = std::move(*ValueMap.getMDMap()); }
1442 return std::move(*FoundError);
1560 std::move(Src), ValuesToLink, std::move(AddLazyFor),
1560 std::move(Src), ValuesToLink, std::move(AddLazyFor),
lib/Linker/LinkModules.cpp 112 : Mover(Mover), SrcM(std::move(SrcM)), Flags(Flags),
113 InternalizeCallback(std::move(InternalizeCallback)) {}
553 if (Error E = Mover.move(std::move(SrcM), ValuesToLink.getArrayRef(),
558 handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
577 ModuleLinker ModLinker(Mover, std::move(Src), Flags,
578 std::move(InternalizeCallback));
595 return L.linkInModule(std::move(Src), Flags, std::move(InternalizeCallback));
595 return L.linkInModule(std::move(Src), Flags, std::move(InternalizeCallback));
605 return Linker::linkModules(*D, std::move(M));
lib/MC/ELFObjectWriter.cpp 251 : TargetObjectWriter(std::move(MOTW)) {}
292 : ELFObjectWriter(std::move(MOTW)), OS(OS),
311 : ELFObjectWriter(std::move(MOTW)), OS(OS), DwoOS(DwoOS),
897 consumeError(std::move(E));
1550 return std::make_unique<ELFSingleObjectWriter>(std::move(MOTW), OS,
1558 return std::make_unique<ELFDwoObjectWriter>(std::move(MOTW), OS, DwoOS,
lib/MC/MCAsmBackend.cpp 36 return createELFObjectWriter(cast<MCELFObjectTargetWriter>(std::move(TW)), OS,
39 return createMachObjectWriter(cast<MCMachObjectTargetWriter>(std::move(TW)),
43 cast<MCWinCOFFObjectTargetWriter>(std::move(TW)), OS);
45 return createWasmObjectWriter(cast<MCWasmObjectTargetWriter>(std::move(TW)),
49 cast<MCXCOFFObjectTargetWriter>(std::move(TW)), OS);
61 return createELFDwoObjectWriter(cast<MCELFObjectTargetWriter>(std::move(TW)),
lib/MC/MCAsmStreamer.cpp 69 : MCStreamer(Context), OSOwner(std::move(os)), OS(*OSOwner),
72 Context, std::move(asmbackend), std::move(emitter),
72 Context, std::move(asmbackend), std::move(emitter),
2032 return new MCAsmStreamer(Context, std::move(OS), isVerboseAsm,
2033 useDwarfDirectory, IP, std::move(CE), std::move(MAB),
2033 useDwarfDirectory, IP, std::move(CE), std::move(MAB),
lib/MC/MCAssembler.cpp 90 : Context(Context), Backend(std::move(Backend)),
91 Emitter(std::move(Emitter)), Writer(std::move(Writer)),
91 Emitter(std::move(Emitter)), Writer(std::move(Writer)),
lib/MC/MCDisassembler/Disassembler.cpp 93 TT, GetOpInfo, SymbolLookUp, DisInfo, Ctx.get(), std::move(RelInfo)));
94 DisAsm->setSymbolizer(std::move(Symbolizer));
104 TT, DisInfo, TagType, GetOpInfo, SymbolLookUp, TheTarget, std::move(MAI),
105 std::move(MRI), std::move(STI), std::move(MII), std::move(Ctx),
105 std::move(MRI), std::move(STI), std::move(MII), std::move(Ctx),
105 std::move(MRI), std::move(STI), std::move(MII), std::move(Ctx),
105 std::move(MRI), std::move(STI), std::move(MII), std::move(Ctx),
106 std::move(DisAsm), std::move(IP));
106 std::move(DisAsm), std::move(IP));
lib/MC/MCDisassembler/Disassembler.h 96 : TripleName(std::move(TripleName)), DisInfo(DisInfo), TagType(TagType),
98 MAI(std::move(MAI)), MRI(std::move(MRI)), MSI(std::move(MSI)),
98 MAI(std::move(MAI)), MRI(std::move(MRI)), MSI(std::move(MSI)),
98 MAI(std::move(MAI)), MRI(std::move(MRI)), MSI(std::move(MSI)),
99 MII(std::move(MII)), Ctx(std::move(Ctx)), DisAsm(std::move(DisAsm)),
99 MII(std::move(MII)), Ctx(std::move(Ctx)), DisAsm(std::move(DisAsm)),
99 MII(std::move(MII)), Ctx(std::move(Ctx)), DisAsm(std::move(DisAsm)),
100 IP(std::move(IP)), Options(0), CommentStream(CommentsToEmit) {}
lib/MC/MCDisassembler/MCDisassembler.cpp 45 Symbolizer = std::move(Symzer);
lib/MC/MCDisassembler/MCExternalSymbolizer.cpp 196 return new MCExternalSymbolizer(*Ctx, std::move(RelInfo), GetOpInfo,
lib/MC/MCELFStreamer.cpp 45 : MCObjectStreamer(Context, std::move(TAB), std::move(OW),
45 : MCObjectStreamer(Context, std::move(TAB), std::move(OW),
46 std::move(Emitter)) {}
707 new MCELFStreamer(Context, std::move(MAB), std::move(OW), std::move(CE));
707 new MCELFStreamer(Context, std::move(MAB), std::move(OW), std::move(CE));
707 new MCELFStreamer(Context, std::move(MAB), std::move(OW), std::move(CE));
lib/MC/MCMachOStreamer.cpp 69 : MCObjectStreamer(Context, std::move(MAB), std::move(OW),
69 : MCObjectStreamer(Context, std::move(MAB), std::move(OW),
70 std::move(Emitter)),
513 new MCMachOStreamer(Context, std::move(MAB), std::move(OW), std::move(CE),
513 new MCMachOStreamer(Context, std::move(MAB), std::move(OW), std::move(CE),
513 new MCMachOStreamer(Context, std::move(MAB), std::move(OW), std::move(CE),
lib/MC/MCObjectStreamer.cpp 31 Context, std::move(TAB), std::move(Emitter), std::move(OW))),
31 Context, std::move(TAB), std::move(Emitter), std::move(OW))),
31 Context, std::move(TAB), std::move(Emitter), std::move(OW))),
lib/MC/MCParser/AsmParser.cpp 2809 CurBuffer = SrcMgr.AddNewSourceBuffer(std::move(Instantiation), SMLoc());
4426 Parameters.push_back(std::move(Parameter));
4483 MCAsmMacro Macro(Name, Body, std::move(Parameters));
4486 getContext().defineMacro(Name, std::move(Macro));
5552 CurBuffer = SrcMgr.AddNewSourceBuffer(std::move(Instantiation), SMLoc());
lib/MC/MCParser/DarwinAsmParser.cpp 787 getContext().setSecureLog(std::move(NewOS));
lib/MC/MCWasmStreamer.cpp 206 new MCWasmStreamer(Context, std::move(MAB), std::move(OW), std::move(CE));
206 new MCWasmStreamer(Context, std::move(MAB), std::move(OW), std::move(CE));
206 new MCWasmStreamer(Context, std::move(MAB), std::move(OW), std::move(CE));
lib/MC/MCWinCOFFStreamer.cpp 48 : MCObjectStreamer(Context, std::move(MAB), std::move(OW), std::move(CE)),
48 : MCObjectStreamer(Context, std::move(MAB), std::move(OW), std::move(CE)),
48 : MCObjectStreamer(Context, std::move(MAB), std::move(OW), std::move(CE)),
lib/MC/MCXCOFFStreamer.cpp 27 : MCObjectStreamer(Context, std::move(MAB), std::move(OW),
27 : MCObjectStreamer(Context, std::move(MAB), std::move(OW),
28 std::move(Emitter)) {}
90 MCXCOFFStreamer *S = new MCXCOFFStreamer(Context, std::move(MAB),
91 std::move(OW), std::move(CE));
91 std::move(OW), std::move(CE));
lib/MC/MachObjectWriter.cpp 1050 return std::make_unique<MachObjectWriter>(std::move(MOTW), OS,
lib/MC/WasmObjectWriter.cpp 270 : W(OS, support::little), TargetObjectWriter(std::move(MOTW)) {}
1598 return std::make_unique<WasmObjectWriter>(std::move(MOTW), OS);
lib/MC/WinCOFFObjectWriter.cpp 237 : W(OS, support::little), TargetObjectWriter(std::move(MOTW)) {
1101 return std::make_unique<WinCOFFObjectWriter>(std::move(MOTW), OS);
lib/MC/XCOFFObjectWriter.cpp 223 : W(OS, support::big), TargetObjectWriter(std::move(MOTW)),
648 return std::make_unique<XCOFFObjectWriter>(std::move(MOTW), OS);
lib/MCA/Context.cpp 50 addHardwareUnit(std::move(RCU));
51 addHardwareUnit(std::move(PRF));
52 addHardwareUnit(std::move(LSU));
53 addHardwareUnit(std::move(HWS));
57 StagePipeline->appendStage(std::move(Fetch));
61 StagePipeline->appendStage(std::move(Dispatch));
62 StagePipeline->appendStage(std::move(Execute));
63 StagePipeline->appendStage(std::move(Retire));
lib/MCA/HardwareUnits/ResourceManager.cpp 163 Strategies[Index] = std::move(S);
lib/MCA/HardwareUnits/Scheduler.cpp 24 Strategy = S ? std::move(S) : std::make_unique<DefaultSchedulerStrategy>();
lib/MCA/InstrBuilder.cpp 575 return std::move(Err);
585 return std::move(Err);
590 Descriptors[MCI.getOpcode()] = std::move(ID);
594 VariantDescriptors[&MCI] = std::move(ID);
677 return std::move(NewIS);
706 return std::move(NewIS);
lib/MCA/Pipeline.cpp 43 return std::move(Err);
82 Stages.push_back(std::move(S));
lib/MCA/Stages/EntryStage.cpp 38 Instructions.emplace_back(std::move(Inst));
lib/Object/Archive.cpp 49 return make_error<GenericBinaryError>(std::move(StringMsg),
452 Parent->ThinBuffers.push_back(std::move(*Buf));
484 return std::move(Err);
526 return std::move(*BinaryOrErr);
534 return std::move(Err);
535 return std::move(Ret);
855 return std::move(Err);
lib/Object/ArchiveWriter.cpp 73 return std::move(M);
103 M.Buf = std::move(*MemberBufferOrErr);
112 return std::move(M);
254 return {{}, std::move(Header), Names, Pad ? "\n" : ""};
365 Obj = std::move(*ObjOrErr);
373 Obj = std::move(*ObjOrErr);
382 return std::move(E);
485 std::move(StringMsg), object::object_error::parse_failed);
495 return std::move(E);
498 Ret.push_back({std::move(*Symbols), std::move(Header), Data, Padding});
498 Ret.push_back({std::move(*Symbols), std::move(Header), Data, Padding});
lib/Object/Binary.cpp 110 return OwningBinary<Binary>(std::move(Bin), std::move(Buffer));
110 return OwningBinary<Binary>(std::move(Bin), std::move(Buffer));
lib/Object/COFFModuleDefinition.cpp 154 return std::move(Err);
lib/Object/COFFObjectFile.cpp 300 return std::move(E);
1628 return std::move(Ret);
1835 return std::move(E);
lib/Object/Decompressor.cpp 29 return std::move(Err);
lib/Object/ELFObjectFile.cpp 65 return std::move(E);
66 return std::make_unique<ELFObjectFile<ELFT>>(std::move(*Ret));
lib/Object/Error.cpp 81 return handleErrors(std::move(Err), [](std::unique_ptr<ECError> M) -> Error {
90 return Error(std::move(M));
lib/Object/IRObjectFile.cpp 30 : SymbolicFile(Binary::ID_IR, Object), Mods(std::move(Mods)) {
128 Mods.push_back(std::move(*MOrErr));
132 new IRObjectFile(*BCOrErr, std::move(Mods)));
150 F.Mods = std::move(BFCOrErr->Mods);
151 F.Symtab = std::move(FCOrErr->Symtab);
152 F.Strtab = std::move(FCOrErr->Strtab);
153 F.TheReader = std::move(FCOrErr->TheReader);
154 return std::move(F);
lib/Object/IRSymtab.cpp 360 OwnedMods.push_back(std::move(*MOrErr));
366 return std::move(E);
374 return std::move(FC);
406 return upgrade(std::move(BFC.Mods));
408 return std::move(FC);
lib/Object/MachOObjectFile.cpp 1246 new MachOObjectFile(std::move(Object), IsLittleEndian,
1250 return std::move(Err);
1251 return std::move(Obj);
lib/Object/MachOUniversal.cpp 27 return make_error<GenericBinaryError>(std::move(StringMsg),
108 return std::move(Err);
109 return std::move(Ret);
lib/Object/Minidump.cpp 154 new MinidumpFile(Source, Hdr, *ExpectedStreams, std::move(StreamMap)));
lib/Object/ModuleSymbolTable.cpp 109 SrcMgr.AddNewSourceBuffer(std::move(Buffer), SMLoc());
lib/Object/Object.cpp 189 auto *Ret = new OwningBinary<ObjectFile>(std::move(ObjOrErr.get()), std::move(Buf));
189 auto *Ret = new OwningBinary<ObjectFile>(std::move(ObjOrErr.get()), std::move(Buf));
lib/Object/ObjectFile.cpp 173 std::unique_ptr<MemoryBuffer> Buffer = std::move(FileOrErr.get());
178 return std::move(Err);
179 std::unique_ptr<ObjectFile> Obj = std::move(ObjOrErr.get());
181 return OwningBinary<ObjectFile>(std::move(Obj), std::move(Buffer));
181 return OwningBinary<ObjectFile>(std::move(Obj), std::move(Buffer));
lib/Object/SymbolicFile.cpp 85 return std::move(Obj);
91 return std::move(Obj);
lib/Object/TapiUniversal.cpp 31 ParsedFile = std::move(Result.get());
52 return std::move(Err);
53 return std::move(Ret);
lib/Object/WasmObjectFile.cpp 61 return std::move(Err);
63 return std::move(ObjectFile);
888 Signatures.push_back(std::move(Sig));
lib/Object/WindowsResource.cpp 66 return std::move(Ret);
84 return std::move(E);
341 consumeError(std::move(E));
518 auto ElementInserted = IDChildren.emplace(ID, std::move(NewChild));
529 IDChildren.emplace(ID, std::move(NewChild));
545 StringChildren.emplace(NameString, std::move(NewChild));
717 return std::move(OutputBuffer);
1008 return std::move(E);
lib/Object/XCOFFObjectFile.cpp 581 return std::move(E);
589 return std::move(E);
615 return std::move(E);
638 return std::move(E);
652 return std::move(E);
658 return std::move(Obj);
662 return std::move(Obj);
671 return std::move(E);
679 return std::move(E);
682 return std::move(Obj);
lib/ObjectYAML/COFFEmitter.cpp 192 Builders.push_back(std::move(B));
lib/ObjectYAML/CodeViewYAMLDebugSections.cpp 697 return std::move(EC);
701 return std::move(EC);
752 return std::move(Result);
758 Result.push_back(std::move(CVS));
760 return std::move(Result);
895 return std::move(EC);
lib/ObjectYAML/CodeViewYAMLSymbols.cpp 588 return std::move(EC);
lib/ObjectYAML/CodeViewYAMLTypes.cpp 674 return std::move(EC);
lib/ObjectYAML/DWARFEmitter.cpp 377 return std::move(DebugSections);
lib/ObjectYAML/ELFEmitter.cpp 243 Doc.Sections.push_back(std::move(Sec));
lib/ObjectYAML/ELFYAML.cpp 890 Other = std::move(Ret);
lib/ObjectYAML/MinidumpEmitter.cpp 37 Callbacks.push_back(std::move(Callback));
lib/ObjectYAML/MinidumpYAML.cpp 494 return std::make_unique<MemoryListStream>(std::move(Ranges));
512 {M, std::move(*ExpectedName), *ExpectedCv, *ExpectedMisc});
514 return std::make_unique<ModuleListStream>(std::move(Modules));
527 std::move(*ExpectedCSDVersion));
546 return std::make_unique<ThreadListStream>(std::move(Threads));
559 Streams.push_back(std::move(*ExpectedStream));
561 return Object(File.header(), std::move(Streams));
lib/ObjectYAML/yaml2obj.cpp 70 return std::move(*ObjOrErr);
lib/Option/Option.cpp 263 UnaliasedA->setAlias(std::move(A));
lib/Passes/PassBuilder.cpp 484 std::move(LPM1), EnableMSSALoopDependency, DebugLogging));
491 std::move(LPM2), /*UseMemorySSA=*/false, DebugLogging));
581 CGPipeline.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM)));
583 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPipeline)));
606 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
705 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(EarlyFPM)));
758 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(GlobalCleanupPM)));
831 std::move(MainCGPipeline), MaxDevirtIterations)));
1007 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(OptimizePM)));
1174 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(EarlyFPM)));
1239 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(PeepholeFPM)));
1284 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
1329 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(MainFPM)));
1804 return {std::move(ResultPipeline)};
1820 MPM.addPass(std::move(NestedMPM));
1828 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM)));
1836 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
1844 MPM.addPass(createRepeatedPass(*Count, std::move(NestedMPM)));
1947 CGPM.addPass(std::move(NestedCGPM));
1956 CGPM.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM)));
1964 CGPM.addPass(createRepeatedPass(*Count, std::move(NestedCGPM)));
1973 createDevirtSCCRepeatedPass(std::move(NestedCGPM), *MaxRepetitions));
2030 FPM.addPass(std::move(NestedFPM));
2040 FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM), UseMemorySSA,
2049 FPM.addPass(createRepeatedPass(*Count, std::move(NestedFPM)));
2112 LPM.addPass(std::move(NestedLPM));
2120 LPM.addPass(createRepeatedPass(*Count, std::move(NestedLPM)));
2273 Pipeline = {{"cgscc", std::move(*Pipeline)}};
2276 Pipeline = {{"function", std::move(*Pipeline)}};
2278 Pipeline = {{"function", {{"loop", std::move(*Pipeline)}}}};
lib/ProfileData/Coverage/CoverageMapping.cpp 159 consumeError(std::move(E));
223 instrprof_error IPE = InstrProfError::take(std::move(E));
248 consumeError(std::move(E));
260 Functions.push_back(std::move(Function));
286 return std::move(E);
289 return std::move(E);
293 return std::move(Coverage);
299 std::move(E), [](const CoverageMapError &CME) {
311 return std::move(E);
312 auto ProfileReader = std::move(ProfileReaderOrErr.get());
326 E = handleMaybeNoDataFoundError(std::move(E));
328 return std::move(E);
333 Readers.push_back(std::move(Reader));
334 Buffers.push_back(std::move(CovMappingBufOrErr.get()));
693 std::move(InstantiationSet.second)};
694 Result.emplace_back(std::move(IG));
lib/ProfileData/Coverage/CoverageMappingReader.cpp 50 handleAllErrors(std::move(E), [&](const CoverageMapError &CME) {
324 return std::move(Err);
331 return std::move(Err);
334 return std::move(Err);
339 return std::move(Err);
345 return std::move(Err);
497 return std::move(Err);
524 return std::move(Err);
548 return std::move(E);
577 auto Reader = std::move(ReaderExpected.get());
594 Reader->ProfileNames = std::move(ProfileNames);
600 return std::move(E);
605 return std::move(E);
611 return std::move(E);
616 return std::move(E);
619 return std::move(Reader);
646 return std::move(E);
656 CoverageMapping, std::move(ProfileNames), BytesInAddress, Endian);
688 OF = std::move(ObjectFileOrErr.get());
711 return std::move(E);
716 return std::move(E);
725 return std::move(E);
728 CoverageMappingOrErr.get(), std::move(ProfileNames), BytesInAddress,
743 Readers.push_back(std::move(ReaderOrErr.get()));
744 return std::move(Readers);
750 std::unique_ptr<Binary> Bin = std::move(BinOrErr.get());
786 Readers.push_back(std::move(Reader));
789 return std::move(Err);
796 ObjectFileBuffers.push_back(std::move(Buffer));
798 return std::move(Readers);
801 auto ReaderOrErr = loadBinaryFormat(std::move(Bin), Arch);
804 Readers.push_back(std::move(ReaderOrErr.get()));
805 return std::move(Readers);
lib/ProfileData/GCOV.cpp 46 Functions.push_back(std::move(GFun));
627 Buffer = std::move(BufferOrErr.get());
714 return std::move(OS);
lib/ProfileData/InstrProf.cpp 411 consumeError(std::move(E));
457 consumeError(std::move(E));
894 return std::move(E);
896 return std::move(VPD);
1176 auto Reader = std::move(ReaderOrErr.get());
lib/ProfileData/InstrProfReader.cpp 46 return std::move(BufferOrErr.get());
58 return std::move(E);
59 return InstrProfReader::create(std::move(BufferOrError.get()));
74 Result.reset(new IndexedInstrProfReader(std::move(Buffer)));
76 Result.reset(new RawInstrProfReader64(std::move(Buffer)));
78 Result.reset(new RawInstrProfReader32(std::move(Buffer)));
80 Result.reset(new TextInstrProfReader(std::move(Buffer)));
86 return std::move(E);
88 return std::move(Result);
96 return std::move(E);
104 return std::move(E);
105 RemappingBuffer = std::move(RemappingBufferOrError.get());
108 return IndexedInstrProfReader::create(std::move(BufferOrError.get()),
109 std::move(RemappingBuffer));
123 std::move(Buffer), std::move(RemappingBuffer));
123 std::move(Buffer), std::move(RemappingBuffer));
127 return std::move(E);
129 return std::move(Result);
135 InstrProfError::take(std::move(E));
258 return error(std::move(E));
289 return error(std::move(E));
345 return error(std::move(E));
392 Symtab = std::move(NewSymtab);
475 return error(std::move(E));
479 return error(std::move(E));
483 return error(std::move(E));
487 return error(std::move(E));
491 return error(std::move(E));
562 DataBuffer.emplace_back(K, Hash, std::move(CounterBuffer));
638 : RemapBuffer(std::move(RemapBuffer)), Underlying(Underlying) {
702 std::move(E), [](std::unique_ptr<InstrProfError> Err) {
705 : Error(std::move(Err));
843 std::move(RemappingBuffer), *IndexPtr);
849 Index = std::move(IndexPtr);
860 consumeError(error(InstrProfError::take(std::move(E))));
863 Symtab = std::move(NewSymtab);
873 return std::move(Err);
878 return std::move(Data[I]);
889 return error(std::move(E));
900 return error(std::move(E));
lib/ProfileData/InstrProfWriter.cpp 187 addRecord(Name, Hash, std::move(I), Weight, Warn);
241 Dest = std::move(I);
256 addRecord(I.getKey(), Func.first, std::move(Func.second), 1, Warn);
lib/ProfileData/SampleProfReader.cpp 744 SecHdrTable.push_back(std::move(Entry));
1247 auto Buffer = std::move(BufferOrErr.get());
1253 return std::move(Buffer);
1311 std::move(E), [&](const SymbolRemappingParseError &ParseError) {
1320 std::move(B), std::move(Remappings), Reader);
1320 std::move(B), std::move(Remappings), Reader);
1337 Reader.reset(new SampleProfileReaderRawBinary(std::move(B), C));
1339 Reader.reset(new SampleProfileReaderExtBinary(std::move(B), C));
1341 Reader.reset(new SampleProfileReaderCompactBinary(std::move(B), C));
1343 Reader.reset(new SampleProfileReaderGCC(std::move(B), C));
1345 Reader.reset(new SampleProfileReaderText(std::move(B), C));
1357 Reader->Remapper = std::move(ReaderOrErr.get());
1365 return std::move(Reader);
lib/ProfileData/SampleProfWriter.cpp 610 return std::move(Writer);
lib/Remarks/BitstreamRemarkParser.cpp 269 return std::move(E);
317 return std::move(E);
320 StrTab ? std::make_unique<BitstreamRemarkParser>(Buf, std::move(*StrTab))
326 return std::move(Parser);
335 return std::move(E);
429 TmpRemarkBuffer = std::move(*BufferOrErr);
487 return std::move(E);
558 return std::move(Result);
596 return std::move(Result);
lib/Remarks/BitstreamRemarkParser.h 51 StrTab(std::move(StrTab)) {}
lib/Remarks/BitstreamRemarkSerializer.cpp 345 StrTab = std::move(StrTabIn);
lib/Remarks/RemarkParser.cpp 78 return std::make_unique<YAMLStrTabRemarkParser>(Buf, std::move(StrTab));
80 return std::make_unique<BitstreamRemarkParser>(Buf, std::move(StrTab));
97 return createYAMLParserFromMeta(Buf, std::move(StrTab),
98 std::move(ExternalFilePrependPath));
100 return createBitstreamParserFromMeta(Buf, std::move(StrTab),
101 std::move(ExternalFilePrependPath));
118 StrTab ? createRemarkParser(ParserFormat, Buf, std::move(*StrTab))
121 void handleError(Error E) { Err.emplace(toString(std::move(E))); }
150 consumeError(std::move(E));
156 TheCParser.handleError(std::move(E));
lib/Remarks/RemarkSerializer.cpp 45 return std::make_unique<YAMLRemarkSerializer>(OS, Mode, std::move(StrTab));
48 std::move(StrTab));
51 std::move(StrTab));
lib/Remarks/YAMLRemarkParser.cpp 108 return Expected<ParsedStringTable>(std::move(Result));
138 StrTab = std::move(*MaybeStrTab);
156 SeparateBuf = std::move(*BufferOrErr);
163 ? std::make_unique<YAMLStrTabRemarkParser>(Buf, std::move(*StrTab))
166 Result->SeparateBuf = std::move(SeparateBuf);
167 return std::move(Result);
175 : RemarkParser{Format::YAML}, StrTab(std::move(StrTab)), LastErrorMessage(),
193 return std::move(E);
270 return std::move(Result);
427 return std::move(*MaybeResult);
lib/Remarks/YAMLRemarkParser.h 101 : YAMLRemarkParser(Buf, std::move(StrTab)) {}
lib/Remarks/YAMLRemarkSerializer.cpp 163 : YAMLRemarkSerializer(Format::YAML, OS, Mode, std::move(StrTabIn)) {}
170 StrTab = std::move(StrTabIn);
lib/Support/APFloat.cpp 915 *this = std::move(rhs);
3915 Floats(new APFloat[2]{std::move(First), std::move(Second)}) {
3915 Floats(new APFloat[2]{std::move(First), std::move(Second)}) {
3930 : Semantics(RHS.Semantics), Floats(std::move(RHS.Floats)) {
3957 Floats[0] = std::move(z);
3975 Floats[0] = std::move(z);
4011 Floats[0] = std::move(z);
4021 Floats[1] = std::move(z);
4446 return DoubleAPFloat(semPPCDoubleDouble, std::move(First), std::move(Second));
4446 return DoubleAPFloat(semPPCDoubleDouble, std::move(First), std::move(Second));
4453 new (&IEEE) IEEEFloat(std::move(F));
4459 DoubleAPFloat(Semantics, APFloat(std::move(F), S),
4502 *this = APFloat(std::move(getIEEE()), ToSemantics);
lib/Support/APInt.cpp 1194 return std::move(t[i]);
lib/Support/BinaryStreamReader.cpp 164 llvm::consumeError(std::move(EC));
lib/Support/Error.cpp 65 handleAllErrors(std::move(E), [&](const ErrorInfoBase &EI) {
95 handleAllErrors(std::move(Err), [&](const ErrorInfoBase &EI) {
144 logAllUnhandledErrors(std::move(Err), ErrStream);
lib/Support/FileCheck.cpp 45 Err = joinErrors(std::move(Err), LeftOp.takeError());
47 Err = joinErrors(std::move(Err), RightOp.takeError());
48 return std::move(Err);
229 return std::move(LeftOp);
262 return std::make_unique<FileCheckASTBinop>(EvalBinop, std::move(LeftOp),
263 std::move(*RightOpResult));
292 ParseResult = parseBinop(Expr, std::move(*ParseResult), IsLegacyLineExpr,
302 ExpressionAST = std::move(*ParseResult);
316 return std::move(ExpressionAST);
501 ExpressionAST = std::move(*ParseResult);
568 SubstStr, std::move(ExpressionAST), SubstInsertIdx)
857 this, ExpressionStr, std::move(ExpressionAST), InsertIdx));
1136 logAllUnhandledErrors(std::move(DefineError), errs());
1153 SM.AddNewSourceBuffer(std::move(CmdLine), SMLoc());
1343 consumeError(std::move(MatchErrors));
1360 consumeError(std::move(MatchErrors));
1365 handleErrors(std::move(MatchErrors),
1371 consumeError(std::move(MatchErrors));
1399 std::move(MatchErrors));
1815 SM.AddNewSourceBuffer(std::move(CmdLineDefsDiagBuffer), SMLoc());
1822 std::move(Errs),
1838 Errs = joinErrors(std::move(Errs), ExpressionASTResult.takeError());
1842 std::move(*ExpressionASTResult);
1849 Errs = joinErrors(std::move(Errs), Value.takeError());
1867 Errs = joinErrors(std::move(Errs), ParseVarResult.takeError());
1874 Errs = joinErrors(std::move(Errs),
1887 Errs = joinErrors(std::move(Errs), FileCheckErrorDiagnostic::get(
lib/Support/FileCheckImpl.h 159 LeftOperand = std::move(LeftOp);
160 RightOperand = std::move(RightOp);
230 ExpressionAST = std::move(ExprAST);
lib/Support/FileCollector.cpp 36 : Root(std::move(Root)), OverlayRoot(std::move(OverlayRoot)) {
36 : Root(std::move(Root)), OverlayRoot(std::move(OverlayRoot)) {
197 : FS(std::move(FS)), Collector(std::move(Collector)) {}
197 : FS(std::move(FS)), Collector(std::move(Collector)) {}
267 return new FileCollectorFileSystem(std::move(BaseFS), std::move(Collector));
267 return new FileCollectorFileSystem(std::move(BaseFS), std::move(Collector));
lib/Support/FileOutputBuffer.cpp 38 : FileOutputBuffer(Path), Buffer(std::move(Buf)), Temp(std::move(Temp)) {}
38 : FileOutputBuffer(Path), Buffer(std::move(Buf)), Temp(std::move(Temp)) {}
133 fs::TempFile File = std::move(*FileOrErr);
160 return std::make_unique<OnDiskBuffer>(Path, std::move(File),
161 std::move(MappedFile));
lib/Support/Host.cpp 64 return std::move(*Text);
lib/Support/JSON.cpp 21 return try_emplace(std::move(K), nullptr).first->getSecond();
95 back().moveFrom(std::move(V));
139 create<std::string>(std::move(M.as<std::string>()));
143 create<json::Object>(std::move(M.as<json::Object>()));
147 create<json::Array>(std::move(M.as<json::Array>()));
227 return std::move(*Err);
275 Out = std::move(S);
322 if (!parseValue(O[std::move(K)]))
516 return std::move(E);
lib/Support/KnownBits.cpp 34 APInt CarryKnownUnion = std::move(CarryKnownZero) | CarryKnownOne;
35 APInt Known = std::move(LHSKnownUnion) & RHSKnownUnion & CarryKnownUnion;
42 KnownOut.Zero = ~std::move(PossibleSumZero) & Known;
43 KnownOut.One = std::move(PossibleSumOne) & Known;
lib/Support/MemoryBuffer.cpp 131 return std::move(Buf);
138 return std::move(*Buf);
401 return std::move(Result);
453 return std::move(Result);
478 return std::move(Buf);
lib/Support/Path.cpp 1123 TempFile::TempFile(TempFile &&Other) { *this = std::move(Other); }
1125 TmpName = std::move(Other.TmpName);
1243 return std::move(Ret);
lib/Support/SmallPtrSet.cpp 141 MoveHelper(SmallSize, std::move(that));
185 MoveHelper(SmallSize, std::move(RHS));
lib/Support/SourceMgr.cpp 58 return AddNewSourceBuffer(std::move(*NewBufOrErr), IncludeLoc);
104 : Buffer(std::move(Other.Buffer)),
lib/Support/SpecialCaseList.cpp 56 std::make_pair(std::make_unique<Regex>(std::move(CheckRE)), LineNumber));
186 Sections.emplace_back(std::move(M));
191 if (!Entry.insert(std::move(Regexp), LineNo, REError)) {
lib/Support/ThreadPool.cpp 52 Task = std::move(Tasks.front());
83 PackagedTaskTy PackagedTask(std::move(Task));
92 Tasks.push(std::move(PackagedTask));
lib/Support/Threading.cpp 138 new AsyncThreadInfo(std::move(Func)),
lib/Support/TimeProfiler.cpp 42 : Start(std::move(S)), End(std::move(E)), Name(std::move(N)),
42 : Start(std::move(S)), End(std::move(E)), Name(std::move(N)),
42 : Start(std::move(S)), End(std::move(E)), Name(std::move(N)),
43 Detail(std::move(Dt)){};
67 Stack.emplace_back(steady_clock::now(), TimePointType(), std::move(Name),
lib/Support/VirtualFileSystem.cpp 390 FSList.push_back(std::move(BaseFS));
553 : InMemoryNode(Stat.getName(), IME_File), Stat(std::move(Stat)),
554 Buffer(std::move(Buffer)) {}
604 : Node(Node), RequestedName(std::move(RequestedName)) {}
628 : InMemoryNode(Stat.getName(), IME_Directory), Stat(std::move(Stat)) {}
644 return Entries.insert(make_pair(Name, std::move(Child)))
740 Child.reset(new detail::InMemoryDirectory(std::move(Stat)));
743 new detail::InMemoryFile(std::move(Stat), std::move(Buffer)));
743 new detail::InMemoryFile(std::move(Stat), std::move(Buffer)));
746 Dir->addChild(Name, std::move(Child));
757 Name, std::make_unique<detail::InMemoryDirectory>(std::move(Stat))));
789 return addFile(P, ModificationTime, std::move(Buffer), User, Group, Type,
802 std::move(User), std::move(Group), std::move(Type),
802 std::move(User), std::move(Group), std::move(Type),
802 std::move(User), std::move(Group), std::move(Type),
803 std::move(Perms));
921 RequestedDirName(std::move(RequestedDirName)) {
993 : ExternalFS(std::move(FS)) {
1245 FS->Roots.push_back(std::move(E));
1252 DE->addContent(std::move(E));
1369 EntryArrayContents.push_back(std::move(E));
1451 LastComponent, std::move(ExternalContentsPath), UseExternalName);
1456 LastComponent, std::move(EntryArrayContents),
1472 Entries.push_back(std::move(Result));
1475 *I, std::move(Entries),
1526 RootEntries.push_back(std::move(E));
1747 : InnerFile(std::move(InnerFile)), S(std::move(S)) {}
1747 : InnerFile(std::move(InnerFile)), S(std::move(S)) {}
1790 std::make_unique<FileWithFixedStatus>(std::move(*Result), S));
1820 return RedirectingFileSystem::create(std::move(Buffer), DiagHandler,
1822 std::move(ExternalFS));
1857 std::move(Buffer), DiagHandler, YAMLFilePath, DiagContext,
1858 std::move(ExternalFS));
lib/Support/YAMLParser.cpp 781 SM.AddNewSourceBuffer(std::move(InputBufferOwner), SMLoc());
lib/Support/YAMLTraits.cpp 390 SQHNode->Entries.push_back(std::move(Entry));
392 return std::move(SQHNode);
415 mapHNode->Mapping[KeyStr] = std::move(ValueHNode);
417 return std::move(mapHNode);
lib/TableGen/JSONBackend.cpp 57 return std::move(array);
68 return std::move(array);
82 return std::move(obj);
86 return std::move(obj);
92 return std::move(obj);
107 args.push_back(std::move(arg));
109 obj["args"] = std::move(args);
110 return std::move(obj);
119 return std::move(obj);
156 obj["!fields"] = std::move(fields);
161 obj["!superclasses"] = std::move(superclasses);
166 root[Name] = std::move(obj);
178 instanceof[kv.first] = std::move(kv.second);
179 root["!instanceof"] = std::move(instanceof);
182 OS << json::Value(std::move(root)) << "\n";
lib/TableGen/Main.cpp 94 SrcMgr.AddNewSourceBuffer(std::move(*FileOrErr), SMLoc());
125 if (std::move(ExistingOrErr.get())->getBuffer() == Out.str())
lib/TableGen/Record.cpp 1654 Records.addDef(std::move(NewRecOwner));
lib/TableGen/SetTheory.cpp 271 Operators[Name] = std::move(Op);
275 Expanders[ClassName] = std::move(E);
lib/TableGen/TGParser.cpp 348 Loops.back()->Entries.push_back(std::move(E));
359 CurMultiClass->Entries.push_back(std::move(E));
363 return addDefOne(std::move(E.Rec));
426 Dest->push_back(std::move(Rec));
428 Error = addDefOne(std::move(Rec));
473 Records.addDef(std::move(Rec));
2713 return addEntry(std::move(CurRec));
2809 std::unique_ptr<ForeachLoop> Loop = std::move(Loops.back());
2812 return addEntry(std::move(Loop));
2840 Records.addClass(std::move(NewRec));
2914 LetStack.push_back(std::move(LetInfo));
3153 addEntry(std::move(E));
lib/TableGen/TGParser.h 52 RecordsEntry(std::unique_ptr<Record> Rec) : Rec(std::move(Rec)) {}
54 : Loop(std::move(Loop)) {}
lib/Target/AArch64/AArch64A57FPLoadBalancing.cpp 374 V.push_back(std::move(Cs));
398 Changed |= colorChainSet(std::move(I), MBB, Parity);
621 AllChains.push_back(std::move(G));
666 AllChains.push_back(std::move(G));
lib/Target/AArch64/AArch64AsmPrinter.cpp 76 : AsmPrinter(TM, std::move(Streamer)), MCInstLowering(OutContext, *this),
lib/Target/AArch64/AArch64FastISel.cpp 3613 TLI.getLibcallName(LC), std::move(Args));
4912 TLI.getLibcallName(LC), std::move(Args));
lib/Target/AArch64/AArch64ISelLowering.cpp 2593 .setLibCallee(CallingConv::Fast, RetTy, Callee, std::move(Args));
4123 DAG.addCallSiteInfo(Ret.getNode(), std::move(CSInfo));
4130 DAG.addCallSiteInfo(Chain.getNode(), std::move(CSInfo));
lib/Target/AArch64/AArch64PBQPRegAlloc.cpp 202 G.addEdge(node1, node2, std::move(costs));
237 G.updateEdgeCosts(edge, std::move(costs));
314 G.updateEdgeCosts(edge, std::move(costs));
lib/Target/AArch64/AArch64PromoteConstant.cpp 217 Uses OldUses = std::move(IPI->second);
218 InsertPts[NewPt] = std::move(OldUses);
lib/Target/AArch64/AArch64SelectionDAGInfo.cpp 48 std::move(Args))
lib/Target/AArch64/Disassembler/AArch64Disassembler.cpp 277 return new AArch64ExternalSymbolizer(*Ctx, std::move(RelInfo), GetOpInfo,
lib/Target/AArch64/Disassembler/AArch64ExternalSymbolizer.h 27 : MCExternalSymbolizer(Ctx, std::move(RelInfo), GetOpInfo, SymbolLookUp,
lib/Target/AArch64/MCTargetDesc/AArch64ELFStreamer.cpp 80 : MCELFStreamer(Context, std::move(TAB), std::move(OW),
80 : MCELFStreamer(Context, std::move(TAB), std::move(OW),
81 std::move(Emitter)),
210 Context, std::move(TAB), std::move(OW), std::move(Emitter));
210 Context, std::move(TAB), std::move(OW), std::move(Emitter));
210 Context, std::move(TAB), std::move(OW), std::move(Emitter));
lib/Target/AArch64/MCTargetDesc/AArch64MCTargetDesc.cpp 281 return createAArch64ELFStreamer(Ctx, std::move(TAB), std::move(OW),
281 return createAArch64ELFStreamer(Ctx, std::move(TAB), std::move(OW),
282 std::move(Emitter), RelaxAll);
291 return createMachOStreamer(Ctx, std::move(TAB), std::move(OW),
291 return createMachOStreamer(Ctx, std::move(TAB), std::move(OW),
292 std::move(Emitter), RelaxAll, DWARFMustBeAtTheEnd,
301 return createAArch64WinCOFFStreamer(Ctx, std::move(TAB), std::move(OW),
301 return createAArch64WinCOFFStreamer(Ctx, std::move(TAB), std::move(OW),
302 std::move(Emitter), RelaxAll,
lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFStreamer.cpp 27 : MCWinCOFFStreamer(C, std::move(AB), std::move(CE), std::move(OW)) {}
27 : MCWinCOFFStreamer(C, std::move(AB), std::move(CE), std::move(OW)) {}
27 : MCWinCOFFStreamer(C, std::move(AB), std::move(CE), std::move(OW)) {}
195 auto *S = new AArch64WinCOFFStreamer(Context, std::move(MAB),
196 std::move(Emitter), std::move(OW));
196 std::move(Emitter), std::move(OW));
lib/Target/AMDGPU/AMDGPUAliasAnalysis.h 40 : AAResultBase(std::move(Arg)), DL(Arg.DL) {}
lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp 91 return new AMDGPUAsmPrinter(tm, std::move(Streamer));
103 : AsmPrinter(TM, std::move(Streamer)) {
lib/Target/AMDGPU/AMDGPUPerfHintAnalysis.cpp 322 LastAccess = std::move(MAI);
lib/Target/AMDGPU/AsmParser/AMDGPUAsmParser.cpp 2417 Operands.push_back(std::move(R));
2650 Operands.push_back(std::move(Reg));
lib/Target/AMDGPU/Disassembler/AMDGPUDisassembler.cpp 1256 return new AMDGPUSymbolizer(*Ctx, std::move(RelInfo), DisInfo);
lib/Target/AMDGPU/Disassembler/AMDGPUDisassembler.h 157 : MCSymbolizer(Ctx, std::move(RelInfo)), DisInfo(disInfo) {}
lib/Target/AMDGPU/GCNIterativeScheduler.cpp 186 , SaveSchedImpl(std::move(_Sch.SchedImpl))
198 Sch.SchedImpl = std::move(SaveSchedImpl);
lib/Target/AMDGPU/GCNRegPressure.h 129 return std::move(LiveRegs);
lib/Target/AMDGPU/GCNSchedStrategy.cpp 314 ScheduleDAGMILive(C, std::move(S)),
463 auto LiveIn = std::move(LiveInIt->second);
lib/Target/AMDGPU/MCTargetDesc/AMDGPUELFStreamer.cpp 26 : MCELFStreamer(Context, std::move(MAB), std::move(OW),
26 : MCELFStreamer(Context, std::move(MAB), std::move(OW),
27 std::move(Emitter)) {}
36 return new AMDGPUELFStreamer(T, Context, std::move(MAB), std::move(OW),
36 return new AMDGPUELFStreamer(T, Context, std::move(MAB), std::move(OW),
37 std::move(Emitter));
lib/Target/AMDGPU/MCTargetDesc/AMDGPUMCTargetDesc.cpp 104 return createAMDGPUELFStreamer(T, Context, std::move(MAB), std::move(OW),
104 return createAMDGPUELFStreamer(T, Context, std::move(MAB), std::move(OW),
105 std::move(Emitter), RelaxAll);
lib/Target/AMDGPU/R600AsmPrinter.cpp 33 return new R600AsmPrinter(TM, std::move(Streamer));
38 : AsmPrinter(TM, std::move(Streamer)) { }
lib/Target/AMDGPU/R600ControlFlowFinalizer.cpp 356 return ClauseFile(MIb, std::move(ClauseContent));
465 return ClauseFile(&ClauseHead, std::move(ClauseContent));
577 LoopStack.push_back(std::move(Pair));
585 std::move(LoopStack.back());
lib/Target/AMDGPU/R600InstrInfo.cpp 557 TransOps = std::move(IGSrcs.back());
lib/Target/AMDGPU/SIInsertWaitcnts.cpp 1534 MoveBracketsToSucc->Incoming = std::move(Brackets);
lib/Target/AMDGPU/SIModeRegister.cpp 319 BlockInfo[MBB.getNumber()] = std::move(NewInfo);
lib/Target/AMDGPU/SIPeepholeSDWA.cpp 856 SDWAOperands[&MI] = std::move(Operand);
lib/Target/ARC/ARCAsmPrinter.cpp 40 : AsmPrinter(TM, std::move(Streamer)),
lib/Target/ARC/ARCTargetTransformInfo.h 48 : BaseT(std::move(static_cast<BaseT &>(Arg))), ST(std::move(Arg.ST)),
48 : BaseT(std::move(static_cast<BaseT &>(Arg))), ST(std::move(Arg.ST)),
49 TLI(std::move(Arg.TLI)) {}
lib/Target/ARM/ARMAsmPrinter.cpp 57 : AsmPrinter(TM, std::move(Streamer)), AFI(nullptr), MCP(nullptr),
lib/Target/ARM/ARMISelLowering.cpp 2429 DAG.addCallSiteInfo(Ret.getNode(), std::move(CSInfo));
2436 DAG.addCallSiteInfo(Chain.getNode(), std::move(CSInfo));
3209 DAG.getExternalSymbol("__tls_get_addr", PtrVT), std::move(Args));
8779 .setCallee(CC, RetTy, Callee, std::move(Args))
8832 ES, std::move(Args));
9140 .setCallee(CallingConv::ARM_AAPCS_VFP, LCRTy, Callee, std::move(Args))
16008 .setCallee(getLibcallCallingConv(LC), RetTy, Callee, std::move(Args))
16050 .setCallee(CallingConv::ARM_AAPCS, RetTy, Callee, std::move(Args))
lib/Target/ARM/ARMSelectionDAGInfo.cpp 120 std::move(Args))
lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp 446 : MCELFStreamer(Context, std::move(TAB), std::move(OW), std::move(Emitter)),
446 : MCELFStreamer(Context, std::move(TAB), std::move(OW), std::move(Emitter)),
446 : MCELFStreamer(Context, std::move(TAB), std::move(OW), std::move(Emitter)),
474 LastMappingSymbols[getCurrentSection().first] = std::move(LastEMSInfo);
478 LastEMSInfo = std::move(LastMappingSymbol->second);
1508 ARMELFStreamer *S = new ARMELFStreamer(Context, std::move(TAB), std::move(OW),
1508 ARMELFStreamer *S = new ARMELFStreamer(Context, std::move(TAB), std::move(OW),
1509 std::move(Emitter), IsThumb);
lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.cpp 214 Ctx, std::move(MAB), std::move(OW), std::move(Emitter), false,
214 Ctx, std::move(MAB), std::move(OW), std::move(Emitter), false,
214 Ctx, std::move(MAB), std::move(OW), std::move(Emitter), false,
223 return createMachOStreamer(Ctx, std::move(MAB), std::move(OW),
223 return createMachOStreamer(Ctx, std::move(MAB), std::move(OW),
224 std::move(Emitter), false, DWARFMustBeAtTheEnd);
lib/Target/ARM/MCTargetDesc/ARMWinCOFFStreamer.cpp 23 : MCWinCOFFStreamer(C, std::move(AB), std::move(CE), std::move(OW)) {}
23 : MCWinCOFFStreamer(C, std::move(AB), std::move(CE), std::move(OW)) {}
23 : MCWinCOFFStreamer(C, std::move(AB), std::move(CE), std::move(OW)) {}
45 auto *S = new ARMWinCOFFStreamer(Context, std::move(MAB), std::move(Emitter),
45 auto *S = new ARMWinCOFFStreamer(Context, std::move(MAB), std::move(Emitter),
46 std::move(OW));
lib/Target/ARM/Thumb2SizeReduction.cpp 245 : MachineFunctionPass(ID), PredicateFtor(std::move(Ftor)) {
1150 return new Thumb2SizeReduce(std::move(Ftor));
lib/Target/AVR/AVRAsmPrinter.cpp 42 : AsmPrinter(TM, std::move(Streamer)), MRI(*TM.getMCRegisterInfo()) { }
lib/Target/AVR/AVRISelLowering.cpp 389 .setLibCallee(getLibcallCallingConv(LC), RetTy, Callee, std::move(Args))
lib/Target/AVR/MCTargetDesc/AVRMCELFStreamer.cpp 48 return new AVRMCELFStreamer(Context, std::move(MAB), std::move(OW),
48 return new AVRMCELFStreamer(Context, std::move(MAB), std::move(OW),
49 std::move(CE));
lib/Target/AVR/MCTargetDesc/AVRMCELFStreamer.h 32 : MCELFStreamer(Context, std::move(TAB), std::move(OW),
32 : MCELFStreamer(Context, std::move(TAB), std::move(OW),
33 std::move(Emitter)),
40 : MCELFStreamer(Context, std::move(TAB), std::move(OW),
40 : MCELFStreamer(Context, std::move(TAB), std::move(OW),
41 std::move(Emitter)),
lib/Target/AVR/MCTargetDesc/AVRMCTargetDesc.cpp 76 return createELFStreamer(Context, std::move(MAB), std::move(OW),
76 return createELFStreamer(Context, std::move(MAB), std::move(OW),
77 std::move(Emitter), RelaxAll);
lib/Target/BPF/BPFAsmPrinter.cpp 41 : AsmPrinter(TM, std::move(Streamer)), BTF(nullptr) {}
lib/Target/BPF/BPFISelDAGToDAG.cpp 369 TmpVal = std::move(Vals);
lib/Target/BPF/BTFDebug.cpp 393 TypeEntries.push_back(std::move(TypeEntry));
400 TypeEntries.push_back(std::move(TypeEntry));
417 TypeId = addType(std::move(TypeEntry), BTy);
436 TypeId = addType(std::move(TypeEntry)); // For subprogram
438 TypeId = addType(std::move(TypeEntry), STy); // For func ptr
467 TypeId = addType(std::move(TypeEntry), CTy);
495 ElemTypeId = addType(std::move(TypeEntry), CTy);
497 ElemTypeId = addType(std::move(TypeEntry));
509 ArrayIndexTypeId = addType(std::move(TypeEntry));
520 TypeId = addType(std::move(TypeEntry), CTy);
528 TypeId = addType(std::move(TypeEntry), CTy);
573 TypeId = addType(std::move(TypeEntry), DTy);
584 TypeId = addType(std::move(TypeEntry), DTy);
652 TypeId = addType(std::move(TypeEntry), CTy);
685 Buf = std::move(*BufOrErr);
902 uint32_t FuncTypeId = addType(std::move(FuncTypeEntry));
1107 uint32_t VarId = addType(std::move(VarEntry));
1152 addType(std::move(DataSec.second));
1170 StructTypeId = addType(std::move(FwdTypeEntry));
lib/Target/BPF/MCTargetDesc/BPFMCTargetDesc.cpp 57 return createELFStreamer(Ctx, std::move(MAB), std::move(OW), std::move(Emitter),
57 return createELFStreamer(Ctx, std::move(MAB), std::move(OW), std::move(Emitter),
57 return createELFStreamer(Ctx, std::move(MAB), std::move(OW), std::move(Emitter),
lib/Target/Hexagon/AsmParser/HexagonAsmParser.cpp 1205 Operands.push_back(std::move(Operand));
lib/Target/Hexagon/HexagonAsmPrinter.h 35 : AsmPrinter(TM, std::move(Streamer)) {}
lib/Target/Hexagon/HexagonMachineScheduler.h 93 : ScheduleDAGMILive(C, std::move(S)) {}
lib/Target/Hexagon/HexagonSelectionDAGInfo.cpp 58 std::move(Args))
lib/Target/Hexagon/MCTargetDesc/HexagonMCELFStreamer.cpp 51 : MCELFStreamer(Context, std::move(TAB), std::move(OW), std::move(Emitter)),
51 : MCELFStreamer(Context, std::move(TAB), std::move(OW), std::move(Emitter)),
51 : MCELFStreamer(Context, std::move(TAB), std::move(OW), std::move(Emitter)),
58 : MCELFStreamer(Context, std::move(TAB), std::move(OW), std::move(Emitter)),
58 : MCELFStreamer(Context, std::move(TAB), std::move(OW), std::move(Emitter)),
58 : MCELFStreamer(Context, std::move(TAB), std::move(OW), std::move(Emitter)),
156 return new HexagonMCELFStreamer(Context, std::move(MAB), std::move(OW),
156 return new HexagonMCELFStreamer(Context, std::move(MAB), std::move(OW),
157 std::move(CE));
lib/Target/Hexagon/MCTargetDesc/HexagonMCTargetDesc.cpp 258 return createHexagonELFStreamer(T, Context, std::move(MAB), std::move(OW),
258 return createHexagonELFStreamer(T, Context, std::move(MAB), std::move(OW),
259 std::move(Emitter));
lib/Target/Lanai/AsmParser/LanaiAsmParser.cpp 902 Operands.push_back(std::move(Op));
923 Operands.push_back(LanaiOperand::MorphToMemImm(std::move(Op)));
932 Lanai::R0, std::move(Op), LPAC::ADD));
991 ? LanaiOperand::MorphToMemRegImm(BaseReg, std::move(Offset), AluOp)
992 : LanaiOperand::MorphToMemRegReg(BaseReg, std::move(Offset), AluOp));
1028 Operands->push_back(std::move(Op));
lib/Target/Lanai/LanaiAsmPrinter.cpp 47 : AsmPrinter(TM, std::move(Streamer)) {}
lib/Target/Lanai/MCTargetDesc/LanaiMCTargetDesc.cpp 70 return createELFStreamer(Context, std::move(MAB), std::move(OW),
70 return createELFStreamer(Context, std::move(MAB), std::move(OW),
71 std::move(Emitter), RelaxAll);
lib/Target/MSP430/MSP430AsmPrinter.cpp 45 : AsmPrinter(TM, std::move(Streamer)) {}
lib/Target/Mips/AsmParser/MipsAsmParser.cpp 6143 MipsOperand::CreateMem(std::move(Base), IdVal, S, E, *this));
6237 Operands.push_back(MipsOperand::CreateMem(std::move(op), IdVal, S, E, *this));
lib/Target/Mips/MCTargetDesc/MipsELFStreamer.cpp 29 : MCELFStreamer(Context, std::move(MAB), std::move(OW),
29 : MCELFStreamer(Context, std::move(MAB), std::move(OW),
30 std::move(Emitter)) {
119 return new MipsELFStreamer(Context, std::move(MAB), std::move(OW),
119 return new MipsELFStreamer(Context, std::move(MAB), std::move(OW),
120 std::move(Emitter));
lib/Target/Mips/MCTargetDesc/MipsMCTargetDesc.cpp 110 S = createMipsELFStreamer(Context, std::move(MAB), std::move(OW),
110 S = createMipsELFStreamer(Context, std::move(MAB), std::move(OW),
111 std::move(Emitter), RelaxAll);
113 S = createMipsNaClELFStreamer(Context, std::move(MAB), std::move(OW),
113 S = createMipsNaClELFStreamer(Context, std::move(MAB), std::move(OW),
114 std::move(Emitter), RelaxAll);
lib/Target/Mips/MCTargetDesc/MipsNaClELFStreamer.cpp 48 : MipsELFStreamer(Context, std::move(TAB), std::move(OW),
48 : MipsELFStreamer(Context, std::move(TAB), std::move(OW),
49 std::move(Emitter)) {}
268 Context, std::move(TAB), std::move(OW), std::move(Emitter));
268 Context, std::move(TAB), std::move(OW), std::move(Emitter));
268 Context, std::move(TAB), std::move(OW), std::move(Emitter));
lib/Target/Mips/MipsAsmPrinter.h 123 : AsmPrinter(TM, std::move(Streamer)), MCInstLowering(*this) {}
lib/Target/Mips/MipsISelLowering.cpp 2051 .setLibCallee(CallingConv::C, PtrTy, TlsGetAddr, std::move(Args));
lib/Target/NVPTX/NVPTXAsmPrinter.h 292 : AsmPrinter(TM, std::move(Streamer)),
lib/Target/NVPTX/NVPTXMCExpr.h 34 : Kind(Kind), Flt(std::move(Flt)) {}
lib/Target/NVPTX/NVPTXUtilities.cpp 97 (*annotationCache)[m][gv] = std::move(tmp);
100 tmp1[gv] = std::move(tmp);
101 (*annotationCache)[m] = std::move(tmp1);
lib/Target/PowerPC/PPCAsmPrinter.cpp 88 : AsmPrinter(TM, std::move(Streamer)), SM(*this) {}
131 : PPCAsmPrinter(TM, std::move(Streamer)) {}
153 : PPCAsmPrinter(TM, std::move(Streamer)) {}
166 : PPCAsmPrinter(TM, std::move(Streamer)) {}
1834 return new PPCDarwinAsmPrinter(tm, std::move(Streamer));
1836 return new PPCAIXAsmPrinter(tm, std::move(Streamer));
1838 return new PPCLinuxAsmPrinter(tm, std::move(Streamer));
lib/Target/PowerPC/PPCISelDAGToDAG.cpp 2411 Bits = std::move(*Result.second);
lib/Target/PowerPC/PPCISelLowering.cpp 3174 DAG.getExternalSymbol("__trampoline_setup", PtrVT), std::move(Args));
lib/Target/RISCV/RISCVAsmPrinter.cpp 39 : AsmPrinter(TM, std::move(Streamer)) {}
lib/Target/RISCV/RISCVISelLowering.cpp 571 std::move(Args));
lib/Target/Sparc/AsmParser/SparcAsmParser.cpp 749 Offset->isImm() ? SparcOperand::MorphToMEMri(BaseReg, std::move(Offset))
750 : SparcOperand::MorphToMEMrr(BaseReg, std::move(Offset)));
852 Operands.push_back(std::move(Op));
864 Operands.push_back(std::move(Op));
lib/Target/Sparc/SparcAsmPrinter.cpp 47 : AsmPrinter(TM, std::move(Streamer)) {}
lib/Target/Sparc/SparcISelLowering.cpp 2182 .setCallee(CallingConv::C, RetTyABI, Callee, std::move(Args));
2233 .setCallee(CallingConv::C, RetTy, Callee, std::move(Args));
lib/Target/SystemZ/SystemZAsmPrinter.h 31 : AsmPrinter(TM, std::move(Streamer)), SM(*this) {}
lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp 227 Signatures.push_back(std::move(Sig));
518 addSignature(std::move(Signature));
592 Operands.push_back(std::move(Op));
708 addSignature(std::move(Signature));
724 addSignature(std::move(Signature));
lib/Target/WebAssembly/Disassembler/WebAssemblyDisassembler.cpp 58 : MCDisassembler(STI, Ctx), MCII(std::move(MCII)) {}
66 return new WebAssemblyDisassembler(STI, Ctx, std::move(MCII));
lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp 109 addSignature(std::move(Signature));
287 addSignature(std::move(Signature));
lib/Target/WebAssembly/WebAssemblyAsmPrinter.h 33 : AsmPrinter(TM, std::move(Streamer)), Subtarget(nullptr), MRI(nullptr),
42 Signatures.push_back(std::move(Sig));
lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp 63 Printer.addSignature(std::move(Signature));
118 std::make_unique<wasm::WasmSignature>(std::move(Returns), std::move(Params));
118 std::make_unique<wasm::WasmSignature>(std::move(Returns), std::move(Params));
120 Printer.addSignature(std::move(Signature));
169 auto Signature = std::make_unique<wasm::WasmSignature>(std::move(Returns),
170 std::move(Params));
174 Printer.addSignature(std::move(Signature));
257 MCOp = lowerTypeIndexOperand(std::move(Returns), std::move(Params));
257 MCOp = lowerTypeIndexOperand(std::move(Returns), std::move(Params));
265 MCOp = lowerTypeIndexOperand(std::move(Returns),
lib/Target/X86/AsmParser/X86AsmParser.cpp 1266 Operands.push_back(std::move(Dst));
1267 Operands.push_back(std::move(Src));
1270 Operands.push_back(std::move(Src));
1271 Operands.push_back(std::move(Dst));
1352 OrigOperands.push_back(std::move(FinalOperands[i]));
2141 Operands.push_back(std::move(Z));
2639 Operands.push_back(std::move(Op));
lib/Target/X86/Disassembler/X86Disassembler.cpp 156 : MCDisassembler(STI, Ctx), MII(std::move(MII)) {
844 return new X86GenericDisassembler(STI, Ctx, std::move(MII));
lib/Target/X86/MCTargetDesc/X86WinCOFFStreamer.cpp 26 : MCWinCOFFStreamer(C, std::move(AB), std::move(CE), std::move(OW)) {}
26 : MCWinCOFFStreamer(C, std::move(AB), std::move(CE), std::move(OW)) {}
26 : MCWinCOFFStreamer(C, std::move(AB), std::move(CE), std::move(OW)) {}
70 new X86WinCOFFStreamer(C, std::move(AB), std::move(CE), std::move(OW));
70 new X86WinCOFFStreamer(C, std::move(AB), std::move(CE), std::move(OW));
70 new X86WinCOFFStreamer(C, std::move(AB), std::move(CE), std::move(OW));
lib/Target/X86/MCTargetDesc/X86WinCOFFTargetStreamer.cpp 199 AllFPOData.insert({Fn, std::move(CurFPOData)});
lib/Target/X86/X86AsmPrinter.cpp 47 : AsmPrinter(TM, std::move(Streamer)), SM(*this), FM(*this) {}
lib/Target/X86/X86DomainReassignment.cpp 770 Closures.push_back(std::move(C));
lib/Target/X86/X86ISelDAGToDAG.cpp 1321 std::move(Args));
lib/Target/X86/X86ISelLowering.cpp 4097 DAG.addCallSiteInfo(Ret.getNode(), std::move(CSInfo));
4107 DAG.addCallSiteInfo(Chain.getNode(), std::move(CSInfo));
25430 std::move(Args))
27316 .setLibCallee(CallingConv::C, RetTy, Callee, std::move(Args));
33220 Mask = std::move(WidenedMask);
35108 ShuffleMask = std::move(ScaledMask);
36102 Mask = std::move(ScaledMask);
36116 Mask = std::move(WidenedMask);
lib/Target/X86/X86InsertPrefetch.cpp 169 Reader = std::move(ReaderOrErr.get());
lib/Target/X86/X86SelectionDAGInfo.cpp 92 std::move(Args))
lib/Target/XCore/XCoreAsmPrinter.cpp 59 : AsmPrinter(TM, std::move(Streamer)), MCInstLowering(*this) {}
lib/Target/XCore/XCoreISelLowering.cpp 478 std::move(Args));
532 std::move(Args));
lib/Target/XCore/XCoreSelectionDAGInfo.cpp 41 std::move(Args))
lib/Testing/Support/Error.cpp 17 handleAllErrors(std::move(Err),
19 Infos.emplace_back(std::move(Info));
21 return {std::move(Infos)};
lib/Testing/Support/SupportHelpers.cpp 25 return std::make_pair(true, std::move(PathInSameDir));
31 return std::make_pair(true, std::move(PathInParentDir));
lib/TextAPI/ELF/ELFStub.cpp 23 TbeVersion = std::move(Stub.TbeVersion);
24 Arch = std::move(Stub.Arch);
25 SoName = std::move(Stub.SoName);
26 NeededLibs = std::move(Stub.NeededLibs);
27 Symbols = std::move(Stub.Symbols);
lib/TextAPI/ELF/TBEHandler.cpp 152 return std::move(Stub);
lib/TextAPI/MachO/TextStub.cpp 528 Exports.emplace_back(std::move(Section));
585 Undefineds.emplace_back(std::move(Section));
837 ParentUmbrellas.emplace_back(std::move(CurrentSection));
855 TargetSet.emplace(std::move(Targets));
893 CurrentSections.emplace_back(std::move(CurrentSection));
1000 targetSet.emplace(std::move(targets));
1015 Section.emplace_back(std::move(CurrentSection));
1125 return std::move(File);
lib/ToolDrivers/llvm-dlltool/DlltoolDriver.cpp 65 return std::move(*MB);
lib/ToolDrivers/llvm-lib/LibDriver.cpp 107 handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EIB) {
123 B = std::move(MaybeBuf.get());
134 fatalOpenError(std::move(Err), B->getBufferIdentifier());
142 fatalOpenError(std::move(Err), B->getBufferIdentifier());
210 fatalOpenError(std::move(Err), MB.getBufferIdentifier());
225 fatalOpenError(std::move(Err), MB.getBufferIdentifier());
351 MBs.push_back(std::move(*MOrErr));
372 handleAllErrors(std::move(E), [&](const ErrorInfoBase &EI) {
lib/Transforms/IPO/ArgumentPromotion.cpp 735 ToPromote.insert(std::move(Operands));
lib/Transforms/IPO/CalledValuePropagation.cpp 72 : LatticeState(FunctionSet), Functions(std::move(Functions)) {
162 return CVPLatticeVal(std::move(Union));
lib/Transforms/IPO/FunctionImport.cpp 1095 std::unique_ptr<Module> SrcModule = std::move(*SrcModuleOrErr);
1102 return std::move(Err);
1117 return std::move(Err);
1139 return std::move(Err);
1153 return std::move(Err);
1157 return std::move(Err);
1188 if (Mover.move(std::move(SrcModule), GlobalsToImport.getArrayRef(),
1221 std::unique_ptr<ModuleSummaryIndex> Index = std::move(*IndexPtrOrErr);
lib/Transforms/IPO/HotColdSplitting.cpp 601 OutliningWorklist.emplace_back(std::move(Region));
lib/Transforms/IPO/InlineSimple.cpp 48 : LegacyInlinerBase(ID), Params(std::move(Params)) {
lib/Transforms/IPO/Internalize.cpp 258 : ModulePass(ID), MustPreserveGV(std::move(MustPreserveGV)) {
289 return new InternalizeLegacyPass(std::move(MustPreserveGV));
lib/Transforms/IPO/PassManagerBuilder.cpp 199 GlobalExtensions->push_back(std::make_pair(Ty, std::move(Fn)));
203 Extensions.push_back(std::make_pair(Ty, std::move(Fn)));
lib/Transforms/IPO/SampleProfile.cpp 281 : GetAC(std::move(GetAssumptionCache)),
282 GetTTI(std::move(GetTargetTransformInfo)), CoverageTracker(*this),
1687 Reader = std::move(ReaderOrErr.get());
lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp 195 Known.Zero = std::move(IKnownZero);
196 Known.One = std::move(IKnownOne);
229 Known.Zero = std::move(IKnownZero);
230 Known.One = std::move(IKnownOne);
311 Known.Zero = std::move(IKnownZero);
313 Known.One = std::move(IKnownOne);
802 Known.Zero = std::move(IKnownZero);
803 Known.One = std::move(IKnownOne);
833 Known.Zero = std::move(IKnownZero);
834 Known.One = std::move(IKnownOne);
865 Known.Zero = std::move(IKnownZero);
867 Known.One = std::move(IKnownOne);
lib/Transforms/Instrumentation/CFGMST.h 260 Iter->second = std::move(std::make_unique<BBInfo>(Index));
266 Iter->second = std::move(std::make_unique<BBInfo>(Index));
lib/Transforms/Instrumentation/DataFlowSanitizer.cpp 182 void set(std::unique_ptr<SpecialCaseList> List) { SCL = std::move(List); }
479 std::vector<std::string> AllABIListFiles(std::move(ABIListFiles));
1157 ShadowElements[CCS.Shadow] = std::move(UnionElems);
lib/Transforms/Instrumentation/GCOVProfiling.cpp 466 Regexes.emplace_back(std::move(Re));
564 this->GetTLI = std::move(GetTLI);
lib/Transforms/Instrumentation/IndirectCallPromotion.cpp 389 std::string SymtabFailure = toString(std::move(E));
lib/Transforms/Instrumentation/InstrProfiling.cpp 495 this->GetTLI = std::move(GetTLI);
919 report_fatal_error(toString(std::move(E)), false);
lib/Transforms/Instrumentation/PGOInstrumentation.cpp 387 : ModulePass(ID), ProfileFileName(std::move(Filename)), IsCS(IsCS) {
1145 handleAllErrors(std::move(E), [&](const InstrProfError &IPE) {
1178 ProfileRecord = std::move(Result.get());
1529 handleAllErrors(std::move(E), [&](const ErrorInfoBase &EI) {
1537 std::move(ReaderOrErr.get());
1641 : ProfileFileName(std::move(Filename)),
1642 ProfileRemappingFileName(std::move(RemappingFilename)), IsCS(IsCS) {
lib/Transforms/Scalar/ConstantHoisting.cpp 632 RebasedConstantInfo(std::move(ConstCand->Uses), Offset, ConstTy));
634 ConstInfoVec.push_back(std::move(ConstInfo));
lib/Transforms/Scalar/ConstantProp.cpp 117 WorkListVec = std::move(NewWorkListVec);
lib/Transforms/Scalar/Float2Int.cpp 153 IT->second = std::move(R);
155 SeenInsts.insert(std::make_pair(I, std::move(R)));
lib/Transforms/Scalar/GVN.cpp 248 Res.AV = std::move(AV);
1014 std::move(AV)));
lib/Transforms/Scalar/JumpThreading.cpp 316 std::move(BFI), std::move(BPI));
316 std::move(BFI), std::move(BPI));
343 std::move(BFI), std::move(BPI));
343 std::move(BFI), std::move(BPI));
373 BPI = std::move(BPI_);
374 BFI = std::move(BFI_);
lib/Transforms/Scalar/LICM.cpp 479 LoopToAliasSetMap[L] = std::move(CurAST);
1775 PredCache(PIC), AST(ast), MSSAU(MSSAU), LI(li), DL(std::move(dl)),
2170 std::unique_ptr<AliasSetTracker> InnerAST = std::move(MapI->second);
2178 CurAST = std::move(InnerAST);
lib/Transforms/Scalar/LoopDistribute.cpp 817 LVer.setAliasChecks(std::move(Checks));
lib/Transforms/Scalar/LoopLoadElimination.cpp 564 LV.setAliasChecks(std::move(Checks));
lib/Transforms/Scalar/LoopPassManager.cpp 54 PA.intersect(std::move(PassPA));
71 PA.intersect(std::move(PassPA));
lib/Transforms/Scalar/LoopStrengthReduce.cpp 1576 SmallPtrSet<const SCEV *, 4> OldRegs = std::move(Regs);
lib/Transforms/Scalar/LoopUnrollPass.cpp 1210 ForgetAllSCEV(ForgetAllSCEV), ProvidedCount(std::move(Count)),
lib/Transforms/Scalar/MemCpyOptimizer.cpp 1413 LookupAliasAnalysis = std::move(LookupAliasAnalysis_);
1414 LookupAssumptionCache = std::move(LookupAssumptionCache_);
1415 LookupDomTree = std::move(LookupDomTree_);
lib/Transforms/Scalar/MergeICmps.cpp 95 Offset = std::move(that.Offset);
193 : Lhs_(std::move(L)), Rhs_(std::move(R)), SizeBits_(SizeBits) {
193 : Lhs_(std::move(L)), Rhs_(std::move(R)), SizeBits_(SizeBits) {
346 return BCECmpBlock(std::move(Lhs), std::move(Rhs),
346 return BCECmpBlock(std::move(Lhs), std::move(Rhs),
402 Comparisons.push_back(std::move(Comparison));
474 enqueueBlock(Comparisons, std::move(Comparison));
507 enqueueBlock(Comparisons, std::move(Comparison));
516 Comparisons_ = std::move(Comparisons);
lib/Transforms/Scalar/SCCP.cpp 255 AnalysisResults.insert({&F, std::move(A)});
273 : DL(DL), GetTLI(std::move(GetTLI)) {}
lib/Transforms/Scalar/SROA.cpp 3948 SplitLoadsMap.insert(std::make_pair(LI, std::move(SplitLoads)));
lib/Transforms/Scalar/SimpleLoopUnswitch.cpp 2584 UnswitchCandidates.push_back({BI, std::move(Invariants)});
lib/Transforms/Scalar/SimplifyCFGPass.cpp 238 : FunctionPass(ID), PredicateFtor(std::move(Ftor)) {
294 KeepLoops, SinkCommon, std::move(Ftor));
lib/Transforms/Utils/InlineFunction.cpp 1768 OpDefs.emplace_back("deopt", std::move(MergedDeoptArgs));
lib/Transforms/Utils/LoopVersioning.cpp 47 AliasChecks = std::move(Checks);
51 Preds = std::move(Check);
lib/Transforms/Utils/PromoteMemoryToRegister.cpp 167 : BB(B), Pred(P), Values(std::move(V)), Locations(std::move(L)) {}
167 : BB(B), Pred(P), Values(std::move(V)), Locations(std::move(L)) {}
648 RenamePassWorkList.emplace_back(&F.front(), nullptr, std::move(Values),
649 std::move(Locations));
651 RenamePassData RPD = std::move(RenamePassWorkList.back());
lib/Transforms/Utils/SplitModule.cpp 282 ModuleCallback(std::move(MPart));
lib/Transforms/Utils/ValueMapper.cpp 712 TempMDNode ClonedN = D.Placeholder ? std::move(D.Placeholder) : N->clone();
721 auto *NewN = MDNode::replaceWithUniqued(std::move(ClonedN));
lib/XRay/BlockIndexer.cpp 88 std::move(CurrentBlock.Records)});
lib/XRay/FDRRecordProducer.cpp 101 R = std::move(MetadataRecordOrErr.get());
104 return std::move(Err);
105 return std::move(R);
130 R = std::move(BufferExtentsOrError.get());
135 return std::move(R);
168 R = std::move(MetadataRecordOrErr.get());
175 return std::move(Err);
194 return std::move(R);
lib/XRay/FDRTraceWriter.cpp 48 auto T = std::make_tuple(std::forward<Values>(std::move(Ds))...);
lib/XRay/FileHeaderReader.cpp 69 return std::move(FileHeader);
lib/XRay/InstrumentationMap.cpp 223 return std::move(E);
228 return std::move(E);
232 return std::move(E);
236 consumeError(std::move(E));
239 return std::move(E);
242 return std::move(E);
lib/XRay/LogBuilderConsumer.cpp 18 Records.push_back(std::move(R));
32 Result = joinErrors(std::move(Result), R->apply(*V));
lib/XRay/Profile.cpp 39 *this = std::move(P);
93 return std::move(Path);
127 Blocks.emplace_back(std::move(B));
140 return std::move(Path);
227 Merged.addBlock({IndexedThreadBlock.first, std::move(PathAndData)}));
258 cantFail(Merged.addBlock({0, std::move(Block)}));
310 {{P.internPath(Path), std::move(Data)}}}))
311 return std::move(E);
396 return std::move(E);
lib/XRay/Trace.cpp 54 FileHeader = std::move(FileHeaderOrError.get());
279 FileHeader = std::move(FileHeaderOrError.get());
291 if (auto E = C.consume(std::move(R.get())))
446 return std::move(E);
458 return std::move(E);
467 return std::move(E);
475 return std::move(T);
projects/compiler-rt/lib/xray/xray_function_call_trie.h 247 NodeAllocatorType(std::move(*O.NodeAllocator));
259 RootAllocatorType(std::move(*O.RootAllocator));
271 ShadowStackAllocatorType(std::move(*O.ShadowStackAllocator));
283 NodeIdPairAllocatorType(std::move(*O.NodeIdPairAllocator));
341 : Nodes(std::move(O.Nodes)),
342 Roots(std::move(O.Roots)),
343 ShadowStack(std::move(O.ShadowStack)),
348 Nodes = std::move(O.Nodes);
349 Roots = std::move(O.Roots);
350 ShadowStack = std::move(O.ShadowStack);
projects/compiler-rt/lib/xray/xray_profile_collector.cpp 131 if (TDArray->AppendEmplace(Q, std::move(B), std::move(A), std::move(T),
131 if (TDArray->AppendEmplace(Q, std::move(B), std::move(A), std::move(T),
131 if (TDArray->AppendEmplace(Q, std::move(B), std::move(A), std::move(T),
projects/compiler-rt/lib/xray/xray_profiling.cpp 190 profileCollectorService::post(BQ, std::move(*FCT), std::move(*Allocators),
190 profileCollectorService::post(BQ, std::move(*FCT), std::move(*Allocators),
191 std::move(ThreadBuffers), GetTid());
tools/bugpoint/BugDriver.cpp 37 errs() << "Failed to keep temp file " << toString(std::move(E)) << '\n';
41 errs() << "Failed to delete temp file " << toString(std::move(E)) << '\n';
61 Program = std::move(M);
122 std::unique_ptr<Module> OldProgram = std::move(Program);
123 Program = std::move(M);
149 if (Linker::linkModules(*Program, std::move(M)))
189 outs() << toString(std::move(E));
202 errs() << toString(std::move(E));
219 errs() << toString(std::move(E));
225 errs() << toString(std::move(E));
234 errs() << toString(std::move(E));
tools/bugpoint/BugDriver.h 79 void addPass(std::string p) { PassesToRun.push_back(std::move(p)); }
tools/bugpoint/CrashDebugger.cpp 94 OrigProgram = std::move(BD.Program);
113 BD.Program = std::move(OrigProgram);
174 BD.setNewProgram(std::move(M)); // It crashed, keep the trimmed version...
306 BD.setNewProgram(std::move(M)); // It crashed, keep the trimmed version...
364 BD.setNewProgram(std::move(M)); // It crashed, keep the trimmed version...
510 M = std::move(New);
514 BD.setNewProgram(std::move(M)); // It crashed, keep the trimmed version...
617 M = std::move(New);
621 BD.setNewProgram(std::move(M)); // It crashed, keep the trimmed version...
709 M = std::move(New);
713 BD.setNewProgram(std::move(M)); // It crashed, keep the trimmed version...
795 BD.setNewProgram(std::move(M)); // It crashed, keep the trimmed version...
870 BD.setNewProgram(std::move(M)); // It crashed, keep the trimmed version...
941 BD.setNewProgram(std::move(M)); // It crashed, keep the trimmed version...
975 BD.setNewProgram(std::move(M));
1071 BD.setNewProgram(std::move(M));
1211 BD.setNewProgram(std::move(M));
1255 M = BD.performFinalCleanups(std::move(M), true);
1260 std::move(M)); // Yup, it does, keep the reduced version...
1298 errs() << toString(std::move(E)) << "\n";
1300 consumeError(std::move(E));
tools/bugpoint/ExecutionDriver.cpp 350 return std::move(E);
396 return std::move(E);
401 return std::move(E);
420 std::move(E),
447 return std::move(E);
tools/bugpoint/FindBugs.cpp 69 outs() << toString(std::move(E));
81 errs() << toString(std::move(E));
tools/bugpoint/ListReducer.h 52 return std::move(E);
125 return std::move(E);
188 return std::move(E);
tools/bugpoint/Miscompilation.cpp 85 return std::move(E);
126 return std::move(E);
155 BD.swapProgramIn(std::move(PrefixOutput));
172 return std::move(E);
181 BD.setNewProgram(std::move(OriginalInput));
203 return std::move(E);
210 return std::move(E);
240 return std::move(E);
242 return std::move(Merged);
268 std::unique_ptr<Module> Orig = BD.swapProgramIn(std::move(Clone));
283 TestFn(BD, std::move(ToOptimize), std::move(ToNotOptimize));
283 TestFn(BD, std::move(ToOptimize), std::move(ToNotOptimize));
285 BD.setNewProgram(std::move(Orig));
338 return std::move(E);
343 std::unique_ptr<Module> Old = BD.swapProgramIn(std::move(*New));
377 Expected<bool> Result = TestFn(BD, std::move(ToOptimizeLoopExtracted),
378 std::move(ToNotOptimize));
380 return std::move(E);
382 ToOptimizeLoopExtracted = std::move(TOLEBackup);
383 ToNotOptimize = std::move(TNOBackup);
396 std::move(ToOptimizeLoopExtracted)))
407 BD.setNewProgram(std::move(ToNotOptimize));
424 if (Linker::linkModules(*ToNotOptimize, std::move(ToOptimizeLoopExtracted)))
438 BD.setNewProgram(std::move(ToNotOptimize));
463 return std::move(E);
470 return std::move(E);
503 std::unique_ptr<Module> Orig = BD.swapProgramIn(std::move(Clone));
524 Expected<bool> Ret = TestFn(BD, std::move(New), std::move(ToNotOptimize));
524 Expected<bool> Ret = TestFn(BD, std::move(New), std::move(ToNotOptimize));
525 BD.setNewProgram(std::move(Orig));
528 BD.setNewProgram(std::move(Orig));
557 return std::move(E);
565 return std::move(E);
591 if (Linker::linkModules(*ProgClone, std::move(Extracted)))
604 BD.setNewProgram(std::move(ProgClone));
632 return std::move(E);
647 return std::move(E);
658 return std::move(E);
671 return std::move(E);
681 return std::move(E);
709 BD.setNewProgram(std::move(Test));
711 return std::move(E);
720 return std::move(E);
721 if (auto New = std::move(*Result)) {
724 BD.setNewProgram(std::move(New));
782 Test = BD.performFinalCleanups(std::move(Test));
945 Test = CleanupAndPrepareModules(BD, std::move(Test), Safe.get());
985 return std::move(E);
994 return std::move(E);
1037 CleanupAndPrepareModules(*this, std::move(ToCodeGen), ToNotCodeGen.get());
tools/bugpoint/ToolRunner.cpp 247 : CompilerCommand(CompilerCmd), CompilerArgs(std::move(CompArgs)) {}
299 : ExecutionCommand(ExecutionCmd), ExecutorArgs(std::move(ExecArgs)) {}
495 return std::move(E);
tools/bugpoint/bugpoint.cpp 237 errs() << toString(std::move(E));
tools/clang/examples/clang-interpreter/main.cpp 67 : TM(std::move(TM)), DL(std::move(DL)) {
67 : TM(std::move(TM)), DL(std::move(DL)) {
69 ES.getMainJITDylib().addGenerator(std::move(ProcessSymbolsGenerator));
92 std::move(*TM), std::move(DL), std::move(*ProcessSymbolsGenerator)));
92 std::move(*TM), std::move(DL), std::move(*ProcessSymbolsGenerator)));
92 std::move(*TM), std::move(DL), std::move(*ProcessSymbolsGenerator)));
98 return CompileLayer.add(ES.getMainJITDylib(), std::move(M));
189 Clang.setInvocation(std::move(CI));
218 llvm::orc::ThreadSafeModule(std::move(Module), std::move(Ctx))));
218 llvm::orc::ThreadSafeModule(std::move(Module), std::move(Ctx))));
tools/clang/include/clang/AST/APValue.h 287 MakeInt(); setInt(std::move(I));
290 MakeFloat(); setFloat(std::move(F));
293 MakeFixedPoint(std::move(FX));
299 MakeComplexInt(); setComplexInt(std::move(R), std::move(I));
299 MakeComplexInt(); setComplexInt(std::move(R), std::move(I));
302 MakeComplexFloat(); setComplexFloat(std::move(R), std::move(I));
302 MakeComplexFloat(); setComplexFloat(std::move(R), std::move(I));
545 *(APSInt *)(char *)Data.buffer = std::move(I);
549 *(APFloat *)(char *)Data.buffer = std::move(F);
553 *(APFixedPoint *)(char *)Data.buffer = std::move(FX);
566 ((ComplexAPSInt *)(char *)Data.buffer)->Real = std::move(R);
567 ((ComplexAPSInt *)(char *)Data.buffer)->Imag = std::move(I);
573 ((ComplexAPFloat *)(char *)Data.buffer)->Real = std::move(R);
574 ((ComplexAPFloat *)(char *)Data.buffer)->Imag = std::move(I);
612 new ((void *)(char *)Data.buffer) APFixedPoint(std::move(FX));
tools/clang/include/clang/AST/ASTVector.h 65 ASTVector O(std::move(RHS));
tools/clang/include/clang/AST/CanonicalType.h 410 : CanTypeIterator::iterator_adaptor_base(std::move(Iter)) {}
tools/clang/include/clang/AST/DeclTemplate.h 779 : SpecIterator::iterator_adaptor_base(std::move(SetIter)) {}
tools/clang/include/clang/AST/ExternalASTSource.h 183 : PCHModuleName(std::move(Name)), Path(std::move(Path)),
183 : PCHModuleName(std::move(Name)), Path(std::move(Path)),
184 ASTFile(std::move(ASTFile)), Signature(Signature) {}
tools/clang/include/clang/AST/JSONNodeDumper.h 96 Pending.push_back(std::move(DumpWithIndent));
99 Pending.back() = std::move(DumpWithIndent);
tools/clang/include/clang/AST/StmtOpenMP.h 70 : Stmt(SC), Kind(K), StartLoc(std::move(StartLoc)),
71 EndLoc(std::move(EndLoc)), NumClauses(NumClauses),
tools/clang/include/clang/AST/TextNodeDumper.h 113 Pending.push_back(std::move(DumpWithIndent));
116 Pending.back() = std::move(DumpWithIndent);
tools/clang/include/clang/ASTMatchers/ASTMatchFinder.h 293 return std::move(Callback.Nodes);
309 return std::move(Callback.Nodes);
tools/clang/include/clang/ASTMatchers/ASTMatchers.h 3928 *Builder = std::move(Result);
4036 *Builder = std::move(Result);
4833 *Builder = std::move(Result);
6164 *Builder = std::move(Result);
6189 *Builder = std::move(Result);
tools/clang/include/clang/ASTMatchers/ASTMatchersInternal.h 461 Implementation(std::move(Implementation)) {}
482 : InnerMatcher(std::move(InnerMatcher)) {}
624 *Builder = std::move(Result);
640 *Builder = std::move(Result);
1396 std::move(DynMatchers))
tools/clang/include/clang/ASTMatchers/Dynamic/VariantValue.h 213 : Value(std::move(Value)) {}
tools/clang/include/clang/Analysis/Analyses/ThreadSafetyTIL.h 1306 Phi(const Phi &P, ValArray &&Vs) : SExpr(P), Values(std::move(Vs)) {}
1535 Args(std::move(As)), Instrs(std::move(Is)), TermInstr(T) {}
1535 Args(std::move(As)), Instrs(std::move(Is)), TermInstr(T) {}
1704 : SExpr(COP_SCFG), Arena(Cfg.Arena), Blocks(std::move(Ba)) {
tools/clang/include/clang/Analysis/PathDiagnostic.h 786 getActivePath().push_back(std::move(EndPiece));
tools/clang/include/clang/Basic/Diagnostic.h 518 std::unique_ptr<DiagnosticConsumer> takeClient() { return std::move(Owner); }
1302 DB.AddString(toString(std::move(E)));
tools/clang/include/clang/Basic/DiagnosticError.h 22 DiagnosticError(PartialDiagnosticAt Diag) : Diag(std::move(Diag)) {}
33 PartialDiagnosticAt(Loc, std::move(Diag)));
41 Err = llvm::handleErrors(std::move(Err), [&](DiagnosticError &E) {
42 Result = std::move(E.getDiagnostic());
tools/clang/include/clang/Basic/FileManager.h 358 this->FS = std::move(FS);
tools/clang/include/clang/Basic/Module.h 56 : std::array<uint32_t, 5>(std::move(S)) {}
600 : ImportLocs(std::move(O.ImportLocs)), Generation(O.Generation ? 1 : 0) {
608 ImportLocs = std::move(O.ImportLocs);
tools/clang/include/clang/CrossTU/CrossTranslationUnit.h 58 : Code(C), FileName(std::move(FileName)), LineNo(LineNo) {}
61 : Code(C), FileName(std::move(FileName)),
62 TripleToName(std::move(TripleToName)),
63 TripleFromName(std::move(TripleFromName)) {}
tools/clang/include/clang/Driver/Compilation.h 205 void addCommand(std::unique_ptr<Command> C) { Jobs.addJob(std::move(C)); }
tools/clang/include/clang/Driver/Driver.h 316 void setTitle(std::string Value) { DriverTitle = std::move(Value); }
tools/clang/include/clang/Driver/Job.h 115 InputFileList = std::move(List);
186 void addJob(std::unique_ptr<Command> J) { Jobs.push_back(std::move(J)); }
tools/clang/include/clang/Driver/Multilib.h 175 IncludeCallback = std::move(F);
182 FilePathsCallback = std::move(F);
tools/clang/include/clang/Driver/ToolChain.h 159 EffectiveTriple = std::move(ET);
616 TC.setEffectiveTriple(std::move(T));
tools/clang/include/clang/Frontend/ChainedDiagnosticConsumer.h 31 : OwningPrimary(std::move(Primary)), Primary(OwningPrimary.get()),
32 Secondary(std::move(Secondary)) {}
37 : Primary(Primary), Secondary(std::move(Secondary)) {}
tools/clang/include/clang/Frontend/CommandLineSourceLoc.h 94 return ParsedSourceRange{std::move(Begin.FileName),
tools/clang/include/clang/Frontend/CompilerInstance.h 174 : Filename(std::move(filename)), TempFilename(std::move(tempFilename)) {
174 : Filename(std::move(filename)), TempFilename(std::move(tempFilename)) {
498 std::unique_ptr<ASTConsumer> takeASTConsumer() { return std::move(Consumer); }
781 OutputStream = std::move(OutStream);
785 return std::move(OutputStream);
812 DependencyCollectors.push_back(std::move(Listener));
tools/clang/include/clang/Frontend/FrontendAction.h 164 return std::move(CurrentASTUnit);
tools/clang/include/clang/Frontend/TextDiagnosticPrinter.h 47 void setPrefix(std::string Value) { Prefix = std::move(Value); }
tools/clang/include/clang/Frontend/Utils.h 166 : DestDir(std::move(DestDir)) {}
tools/clang/include/clang/Index/IndexingAction.h 45 std::move(DataConsumer), Opts, std::move(PP),
45 std::move(DataConsumer), Opts, std::move(PP),
tools/clang/include/clang/Lex/HeaderMap.h 35 : FileBuffer(std::move(File)), NeedsBSwap(NeedsBSwap) {}
67 : HeaderMapImpl(std::move(File), BSwap) {}
tools/clang/include/clang/Lex/ModuleMap.h 414 Callbacks.push_back(std::move(Callback));
tools/clang/include/clang/Lex/PPCallbacks.h 383 : First(std::move(_First)), Second(std::move(_Second)) {}
383 : First(std::move(_First)), Second(std::move(_Second)) {}
tools/clang/include/clang/Lex/Preprocessor.h 534 : CurLexerKind(std::move(CurLexerKind)),
535 TheSubmodule(std::move(TheSubmodule)), TheLexer(std::move(TheLexer)),
535 TheSubmodule(std::move(TheSubmodule)), TheLexer(std::move(TheLexer)),
536 ThePPLexer(std::move(ThePPLexer)),
537 TheTokenLexer(std::move(TheTokenLexer)),
538 TheDirLookup(std::move(TheDirLookup)) {}
998 C = std::make_unique<PPChainedCallbacks>(std::move(C),
999 std::move(Callbacks));
1000 Callbacks = std::move(C);
1008 OnToken = std::move(F);
1477 EnterTokenStream(std::move(TokCopy), 1, true, IsReinject);
1991 std::move(CurLexer), CurPPLexer,
1992 std::move(CurTokenLexer), CurDirLookup);
1997 CurLexer = std::move(IncludeMacroStack.back().TheLexer);
1999 CurTokenLexer = std::move(IncludeMacroStack.back().TheTokenLexer);
tools/clang/include/clang/Parse/Parser.h 1226 : Param(P), Toks(std::move(Toks)) { }
tools/clang/include/clang/Parse/RAIIObjectsForParser.h 62 : S(Other.S), DiagnosticPool(std::move(Other.DiagnosticPool)),
tools/clang/include/clang/Rewrite/Core/RewriteRope.h 66 : StrData(std::move(Str)), StartOffs(Start), EndOffs(End) {}
tools/clang/include/clang/Rewrite/Frontend/FrontendActions.h 53 : WrapperFrontendAction(std::move(WrappedAction)) {}
tools/clang/include/clang/Sema/CodeCompleteConsumer.h 409 this->ScopeSpecifier = std::move(SS);
652 : AllocatorRef(std::move(Allocator)) {}
870 FixIts(std::move(FixIts)), Hidden(false), InBaseClass(false),
tools/clang/include/clang/Sema/DeclSpec.h 1251 DefaultArgTokens(std::move(DefArgTokens)) {}
tools/clang/include/clang/Sema/DelayedDiagnostic.h 279 : Parent(Other.Parent), Diagnostics(std::move(Other.Diagnostics)) {
285 Diagnostics = std::move(Other.Diagnostics);
313 Diagnostics = std::move(pool.Diagnostics);
tools/clang/include/clang/Sema/Lookup.h 184 : ResultKind(std::move(Other.ResultKind)),
185 Ambiguity(std::move(Other.Ambiguity)), Decls(std::move(Other.Decls)),
185 Ambiguity(std::move(Other.Ambiguity)), Decls(std::move(Other.Decls)),
186 Paths(std::move(Other.Paths)),
187 NamingClass(std::move(Other.NamingClass)),
188 BaseObjectType(std::move(Other.BaseObjectType)),
189 SemaPtr(std::move(Other.SemaPtr)), NameInfo(std::move(Other.NameInfo)),
189 SemaPtr(std::move(Other.SemaPtr)), NameInfo(std::move(Other.NameInfo)),
190 NameContextRange(std::move(Other.NameContextRange)),
191 LookupKind(std::move(Other.LookupKind)), IDNS(std::move(Other.IDNS)),
191 LookupKind(std::move(Other.LookupKind)), IDNS(std::move(Other.IDNS)),
192 Redecl(std::move(Other.Redecl)),
193 ExternalRedecl(std::move(Other.ExternalRedecl)),
194 HideTags(std::move(Other.HideTags)),
195 Diagnose(std::move(Other.Diagnose)),
196 AllowHidden(std::move(Other.AllowHidden)),
197 Shadowed(std::move(Other.Shadowed)),
198 TemplateNameLookup(std::move(Other.TemplateNameLookup)) {
204 ResultKind = std::move(Other.ResultKind);
205 Ambiguity = std::move(Other.Ambiguity);
206 Decls = std::move(Other.Decls);
207 Paths = std::move(Other.Paths);
208 NamingClass = std::move(Other.NamingClass);
209 BaseObjectType = std::move(Other.BaseObjectType);
210 SemaPtr = std::move(Other.SemaPtr);
211 NameInfo = std::move(Other.NameInfo);
212 NameContextRange = std::move(Other.NameContextRange);
213 LookupKind = std::move(Other.LookupKind);
214 IDNS = std::move(Other.IDNS);
215 Redecl = std::move(Other.Redecl);
216 ExternalRedecl = std::move(Other.ExternalRedecl);
217 HideTags = std::move(Other.HideTags);
218 Diagnose = std::move(Other.Diagnose);
219 AllowHidden = std::move(Other.AllowHidden);
220 Shadowed = std::move(Other.Shadowed);
221 TemplateNameLookup = std::move(Other.TemplateNameLookup);
tools/clang/include/clang/Sema/SemaInternal.h 101 CorrectionValidator(std::move(CCC)), MemberContext(MemberContext),
319 *this = std::move(other);
324 Consumer = std::move(other.Consumer);
325 DiagHandler = std::move(other.DiagHandler);
326 RecoveryHandler = std::move(other.RecoveryHandler);
tools/clang/include/clang/Sema/TemplateDeduction.h 135 SuppressedDiagnostics.emplace_back(Loc, std::move(PD));
144 SuppressedDiagnostics.emplace_back(Loc, std::move(PD));
tools/clang/include/clang/Sema/TypoCorrection.h 254 ExtraDiagnostics.push_back(std::move(PD));
tools/clang/include/clang/Serialization/ASTReader.h 251 : First(std::move(First)), Second(std::move(Second)) {}
251 : First(std::move(First)), Second(std::move(Second)) {}
253 std::unique_ptr<ASTReaderListener> takeFirst() { return std::move(First); }
254 std::unique_ptr<ASTReaderListener> takeSecond() { return std::move(Second); }
1576 return std::move(Listener);
1581 this->Listener = std::move(Listener);
1589 L = std::make_unique<ChainedASTReaderListener>(std::move(L),
1590 std::move(Listener));
1591 Listener = std::move(L);
1605 L = std::make_unique<ChainedASTReaderListener>(std::move(L),
1606 std::move(Old));
1608 Reader.setListener(std::move(L));
1655 ModuleMgr.addInMemoryBuffer(FileName, std::move(Buffer));
2695 toString(std::move(Err)));
tools/clang/include/clang/Serialization/InMemoryModuleCache.h 41 : Buffer(std::move(Buffer)) {}
tools/clang/include/clang/Serialization/PCHContainerOperations.h 98 Writers[Writer->getFormat()] = std::move(Writer);
101 Readers[Reader->getFormat()] = std::move(Reader);
tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h 208 Notes.push_back(std::move(P));
513 StackHints[Piece] = std::move(StackHint);
543 Reports.push_back(std::move(R));
547 BugReportEquivClass(std::unique_ptr<BugReport> R) { AddReport(std::move(R)); }
734 : ProgramPointTag(&Kind), Cb(std::move(Cb)), IsPrunable(IsPrunable) {}
747 return std::move(Msg);
767 std::unique_ptr<NoteTag> T(new NoteTag(std::move(Cb), IsPrunable));
768 Tags.push_back(std::move(T));
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h 168 : State(std::move(state)), LCtx(lctx), Origin(E) {}
171 : State(std::move(state)), LCtx(lctx), Origin(D) {}
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h 219 Eng.getBugReporter().emitReport(std::move(R));
233 return Eng.getNoteTags().makeNoteTag(std::move(Cb), IsPrunable);
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h 139 : Location(loc), State(std::move(state)), Succs(IsSink), Id(Id) {
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h 865 : state(std::move(st)), visitor(v) {}
tools/clang/include/clang/Tooling/CommonOptionsParser.h 134 : Compilations(std::move(Compilations)) {}
tools/clang/include/clang/Tooling/CompilationDatabase.h 48 CommandLine(std::move(CommandLine)), Output(Output.str()){}
tools/clang/include/clang/Tooling/Core/Replacement.h 160 : Err(Err), ExistingReplacement(std::move(Existing)) {}
165 : Err(Err), NewReplacement(std::move(New)),
166 ExistingReplacement(std::move(Existing)) {}
tools/clang/include/clang/Tooling/DependencyScanning/DependencyScanningFilesystem.h 39 CachedFileSystemEntry(std::error_code Error) : MaybeStat(std::move(Error)) {}
149 : ProxyFileSystem(std::move(FS)), SharedCache(SharedCache),
tools/clang/include/clang/Tooling/DiagnosticsYaml.h 45 << llvm::toString(std::move(Err)) << "\n";
tools/clang/include/clang/Tooling/JSONCompilationDatabase.h 99 : Database(std::move(Database)), Syntax(Syntax),
tools/clang/include/clang/Tooling/Refactoring/Extract/Extract.h 35 : Code(std::move(Code)),
36 DeclName(DeclName ? std::move(*DeclName) : "extracted") {}
tools/clang/include/clang/Tooling/Refactoring/RefactoringActionRules.h 60 Consumer.handle(std::move(*Changes));
82 Consumer.handle(std::move(*Occurrences));
tools/clang/include/clang/Tooling/Refactoring/RefactoringActionRulesInternal.h 56 return Consumer.handleError(std::move(Err));
60 RuleType::initiate(Context, std::move((*std::get<Is>(Values)))...);
tools/clang/include/clang/Tooling/Refactoring/RefactoringRuleContext.h 66 ASTNodeSelection = std::move(Node);
tools/clang/include/clang/Tooling/Refactoring/Rename/RenamingAction.h 61 : ND(ND), NewName(std::move(NewName)) {}
81 : ND(ND), NewQualifiedName(std::move(NewQualifiedName)) {}
tools/clang/include/clang/Tooling/Transformer/RewriteRule.h 134 Edits.emplace_back(std::move(Edit));
135 return makeRule(std::move(M), std::move(Edits), std::move(Explanation));
135 return makeRule(std::move(M), std::move(Edits), std::move(Explanation));
135 return makeRule(std::move(M), std::move(Edits), std::move(Explanation));
202 return change(node(RewriteRule::RootID), std::move(Replacement));
208 return change(before(std::move(S)), std::move(Replacement));
208 return change(before(std::move(S)), std::move(Replacement));
214 return change(after(std::move(S)), std::move(Replacement));
214 return change(after(std::move(S)), std::move(Replacement));
219 return change(std::move(S),
tools/clang/include/clang/Tooling/Transformer/Stencil.h 69 : Impl(std::move(Impl)) {}
tools/clang/include/clang/Tooling/Transformer/Transformer.h 34 : Rule(std::move(Rule)), Consumer(std::move(Consumer)) {}
34 : Rule(std::move(Rule)), Consumer(std::move(Consumer)) {}
tools/clang/lib/ARCMigrate/ARCMT.cpp 209 CInvok->getDiagnosticOpts().Warnings = std::move(WarnOpts);
271 std::move(CInvok), PCHContainerOps, Diags));
510 : OrigCI(CI), PCHContainerOps(std::move(PCHContainerOps)),
547 std::move(CInvok), PCHContainerOps, Diags, ASTAction.get()));
611 Remapper.remap(filePath.str(), std::move(memBuf));
tools/clang/lib/ARCMigrate/ARCMTActions.cpp 28 : WrapperFrontendAction(std::move(WrappedAction)) {}
37 : WrapperFrontendAction(std::move(WrappedAction)) {}
55 : WrapperFrontendAction(std::move(WrappedAction)), MigrateDir(migrateDir),
tools/clang/lib/ARCMigrate/FileRemapper.cpp 209 remap(getOriginalFile(filePath), std::move(memBuf));
tools/clang/lib/ARCMigrate/ObjCMT.cpp 197 : WrapperFrontendAction(std::move(WrappedAction)), MigrateDir(migrateDir),
214 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
1985 Remapper.remap(filePath.str(), std::move(memBuf));
tools/clang/lib/AST/APValue.cpp 252 MakeFixedPoint(std::move(FXCopy));
tools/clang/lib/AST/ASTContext.cpp 971 ExternalSource = std::move(Source);
1064 auto LazyInits = std::move(LazyInitializers);
tools/clang/lib/AST/ASTImporter.cpp 194 return std::make_tuple<T>(std::move(*ToOrErr));
693 return std::move(Err);
699 return std::move(Err);
709 return std::move(Err);
801 return std::move(Err);
928 return std::move(Err);
1408 return std::move(Err);
1466 return std::move(Err);
1685 joinErrors(std::move(ChildErrors), ImportedOrErr.takeError());
1720 consumeError(std::move(ChildErrors));
2098 return std::move(Err);
2184 return std::move(Err);
2251 return std::move(Err);
2263 return std::move(Err);
2302 return std::move(Err);
2397 return std::move(Err);
2453 return std::move(Err);
2492 return std::move(Err);
2502 return std::move(Err);
2567 return std::move(Err);
2587 return std::move(Err);
2597 return std::move(Err);
2656 return std::move(Err);
2731 return std::move(Err);
2804 return std::move(Err);
2816 return std::move(Err);
3013 return std::move(Err);
3114 return std::move(Err);
3288 return std::move(Err);
3302 return std::move(Err);
3309 return std::move(Err);
3332 return std::move(Err);
3367 return std::move(Err);
3452 return std::move(Err);
3519 return std::move(Err);
3546 return std::move(Err);
3595 return std::move(Err);
3660 return std::move(Err);
3770 return std::move(Err);
3864 return std::move(Err);
3884 return std::move(Err);
3993 return std::move(Err);
4009 return std::move(Err);
4041 return std::move(Err);
4047 return std::move(Err);
4113 return std::move(Err);
4190 return std::move(Err);
4223 return std::move(Err);
4231 return std::move(Err);
4268 return std::move(Err);
4282 return std::move(Err);
4319 return std::move(Err);
4361 return std::move(Err);
4404 return std::move(Err);
4419 return std::move(Err);
4441 return std::move(Err);
4614 return std::move(Err);
4656 return std::move(Err);
4665 return std::move(Err);
4671 return std::move(Err);
4693 return std::move(Err);
4703 return std::move(Err);
4708 return std::move(Err);
4716 return std::move(Err);
4778 return std::move(Err);
4790 return std::move(Err);
4870 return std::move(Err);
4874 return std::move(Err);
4881 return std::move(Err);
5044 return std::move(Err);
5094 return std::move(Err);
5155 return std::move(Err);
5160 return std::move(Err);
5166 return std::move(Err);
5227 return std::move(Err);
5232 return std::move(Err);
5312 return std::move(Err);
5338 return std::move(Err);
5384 return std::move(Err);
5425 return std::move(Err);
5430 return std::move(Err);
5445 return std::move(Err);
5470 return std::move(Err);
5479 return std::move(Err);
5490 return std::move(Err);
5552 return std::move(Err);
5565 return std::move(Err);
5605 return std::move(Err);
5691 return std::move(Err);
5695 return std::move(Err);
5699 return std::move(Err);
5752 return std::move(Err);
5821 return std::move(Err);
6277 return std::move(Err);
6318 return std::move(Err);
6402 return std::move(Err);
6441 return std::move(Err);
6496 return std::move(Err);
6929 return std::move(Err);
6983 return std::move(Err);
7047 return std::move(Err);
7078 return std::move(Err);
7121 return std::move(Err);
7138 return std::move(Err);
7158 return std::move(Err);
7226 return std::move(Err);
7301 return std::move(Err);
7313 return std::move(Err);
7338 return std::move(Err);
7345 return std::move(Err);
7368 return std::move(Err);
7392 return std::move(Err);
7406 return std::move(Err);
7443 return std::move(Err);
7457 return std::move(Err);
7488 return std::move(Err);
7524 return std::move(Err);
7554 return std::move(Err);
7729 return std::move(Err);
7774 joinErrors(std::move(ImportErrors), ImportedOrErr.takeError());
8076 return std::move(Err);
8087 return std::move(Err);
8098 return std::move(Err);
8109 return std::move(Err);
8165 return std::move(Err);
8232 return std::move(Err);
8239 return std::move(Err);
8243 return std::move(Err);
8266 return std::move(Err);
8405 return std::move(Err);
8407 return std::move(Err);
8481 ToID = ToSM.createFileID(std::move(ToBuf),
8517 return std::move(Err);
tools/clang/lib/AST/Expr.cpp 333 APValueResult() = std::move(Value);
tools/clang/lib/AST/ExprConstant.cpp 1267 moveFromAndCancel(std::move(Other));
1272 moveFromAndCancel(std::move(Other));
6469 ArrayValue.getArrayInitializedElt(I) = std::move(*ElementValue);
6605 DestValue = std::move(*MaybeDestValue);
7727 Result = std::move(SizeOfElem);
7741 Result = std::move(BytesAvailable);
9273 Val = APValue(std::move(IntResult));
9278 Val = APValue(std::move(FloatResult));
tools/clang/lib/AST/ExternalASTMerger.cpp 319 llvm::consumeError(std::move(Err));
339 llvm::consumeError(std::move(Err));
tools/clang/lib/AST/Interp/ByteCodeEmitter.cpp 57 Function *Func = P.createFunction(F, ParamOffset, std::move(ParamTypes),
58 std::move(ParamDescriptors));
70 Scopes.emplace_back(std::move(DS));
74 Func->setCode(NextLocalOffset, std::move(Code), std::move(SrcMap),
74 Func->setCode(NextLocalOffset, std::move(Code), std::move(SrcMap),
75 std::move(Scopes));
tools/clang/lib/AST/Interp/ByteCodeExprGen.cpp 51 OldInitFn(std::move(Ctx->InitFn)) {
59 OldInitFn(std::move(Ctx->InitFn)) {
74 Ctx->InitFn = std::move(OldInitFn);
tools/clang/lib/AST/Interp/Descriptor.cpp 30 new (DstPtr) T(std::move(*SrcPtr));
52 new (DstPtr) T(std::move(*SrcPtr));
tools/clang/lib/AST/Interp/EvalEmitter.cpp 59 Locals.insert({Off, std::move(Memory)});
tools/clang/lib/AST/Interp/Function.cpp 22 ParamTypes(std::move(ParamTypes)), Params(std::move(Params)) {}
22 ParamTypes(std::move(ParamTypes)), Params(std::move(Params)) {}
tools/clang/lib/AST/Interp/Function.h 44 Scope(LocalVectorTy &&Descriptors) : Descriptors(std::move(Descriptors)) {}
121 Code = std::move(NewCode);
122 SrcMap = std::move(NewSrcMap);
123 Scopes = std::move(NewScopes);
tools/clang/lib/AST/Interp/Interp.h 551 S.Stk.push<Pointer>(std::move(Field));
564 S.Stk.push<Pointer>(std::move(Field));
tools/clang/lib/AST/Interp/InterpFrame.cpp 22 : Caller(Caller), S(S), Func(Func), This(std::move(This)), RetPC(RetPC),
178 Params.insert({Off, std::move(Memory)});
tools/clang/lib/AST/Interp/InterpStack.h 37 auto Value = std::move(*Ptr);
tools/clang/lib/AST/Interp/Program.cpp 290 Record *R = new (Allocator) Record(RD, std::move(Bases), std::move(Fields),
290 Record *R = new (Allocator) Record(RD, std::move(Bases), std::move(Fields),
291 std::move(VirtBases), VirtSize, Size);
tools/clang/lib/AST/Interp/Record.cpp 17 : Decl(Decl), Bases(std::move(SrcBases)), Fields(std::move(SrcFields)),
17 : Decl(Decl), Bases(std::move(SrcBases)), Fields(std::move(SrcFields)),
tools/clang/lib/AST/JSONNodeDumper.cpp 318 Ret.push_back(std::move(Val));
517 JOS.attribute("exceptionTypes", std::move(Types));
942 JOS.attribute("protocols", std::move(Protocols));
958 JOS.attribute("protocols", std::move(Protocols));
970 JOS.attribute("protocols", std::move(Protocols));
1213 JOS.attribute("path", std::move(Path));
1522 JOS.attribute("args", std::move(Args));
1537 JOS.attribute("attrs", std::move(Attrs));
1554 JOS.attribute("args", std::move(Args));
1591 JOS.attribute("positions", std::move(Positions));
tools/clang/lib/AST/Stmt.cpp 663 Pieces.emplace_back(N, std::move(Str), BeginLoc, EndLoc);
699 Pieces.emplace_back(N, std::move(Str), BeginLoc, EndLoc);
tools/clang/lib/AST/VTableBuilder.cpp 3306 Paths.push_back(std::move(P));
3568 VFPtrLocations[RD] = std::move(VFPtrs);
tools/clang/lib/ASTMatchers/ASTMatchFinder.cpp 311 Options.CheckProfiling->Records = std::move(TimeByBucket);
420 CachedResult = std::move(Result);
668 CachedResult = std::move(Result);
704 *Builder = std::move(BuilderCopy);
721 *Builder = std::move(BuilderCopy);
770 *Builder = std::move(Result);
787 *Builder = std::move(Result);
877 *Builder = std::move(Result);
1007 : Options(std::move(Options)), ParsingDone(nullptr) {}
tools/clang/lib/ASTMatchers/ASTMatchersInternal.cpp 89 : InnerMatchers(std::move(InnerMatchers)) {}
105 : ID(ID), InnerMatcher(std::move(InnerMatcher)) {}
170 new VariadicMatcher<AllOfVariadicOperator>(std::move(InnerMatchers)));
175 new VariadicMatcher<AnyOfVariadicOperator>(std::move(InnerMatchers)));
180 new VariadicMatcher<EachOfVariadicOperator>(std::move(InnerMatchers)));
187 new VariadicMatcher<NotUnaryOperator>(std::move(InnerMatchers)));
243 new IdDynMatcher(ID, std::move(Result.Implementation));
244 return std::move(Result);
309 *Builder = std::move(Result);
320 *Builder = std::move(Result);
349 Names(std::move(N)) {
tools/clang/lib/ASTMatchers/Dynamic/Marshallers.h 334 VariantMatcher Out = VariantMatcher::PolymorphicMatcher(std::move(Matchers));
694 return VariantMatcher::VariadicOperatorMatcher(Op, std::move(InnerArgs));
tools/clang/lib/ASTMatchers/Dynamic/Registry.cpp 65 Constructors[MatcherName] = std::move(Callback);
tools/clang/lib/ASTMatchers/Dynamic/VariantValue.cpp 117 : Matchers(std::move(MatchersIn)) {}
184 : Op(Op), Args(std::move(Args)) {}
228 std::make_shared<PolymorphicPayload>(std::move(Matchers)));
235 std::make_shared<VariadicOpPayload>(Op, std::move(Args)));
tools/clang/lib/Analysis/CFG.cpp 316 : ctx(std::move(ctx)), Vars(this->ctx, 4), Prev(P) {}
1605 return std::move(cfg);
tools/clang/lib/Analysis/Consumed.cpp 1027 Entry = std::move(OwnedStateMap);
1041 Entry = std::move(StateMap);
1062 : std::move(Entry);
1294 BlockInfo.addInfo(*SI, std::move(CurrStates));
1299 BlockInfo.addInfo(*SI, std::move(FalseStates));
tools/clang/lib/Analysis/PathDiagnostic.cpp 88 Current.push_back(std::move(CallEnter));
91 Current.push_back(std::move(callExit));
129 UniqueingDecl(DeclToUnique), ExecutedLines(std::move(ExecutedLines)),
848 path.push_front(std::move(C));
tools/clang/lib/Analysis/ThreadSafety.cpp 163 Facts.push_back(std::move(Entry));
207 FactID F = FM.newFact(std::move(Entry));
1316 FSet.addLock(FactMan, std::move(Entry));
1960 Analyzer->addLock(FSet, std::move(ScopedEntry), CapDiagKind);
2354 addLock(InitialLockset, std::move(Entry), CapDiagKind, true);
2359 addLock(InitialLockset, std::move(Entry), CapDiagKind, true);
tools/clang/lib/Analysis/ThreadSafetyCommon.cpp 739 CurrentLVarMap = std::move(Map);
864 mergeEntryMap(std::move(PredInfo->ExitMap));
937 CurrentBlockInfo->ExitMap = std::move(CurrentLVarMap);
tools/clang/lib/Analysis/plugins/SampleAnalyzer/MainCallChecker.cpp 42 C.emitReport(std::move(report));
tools/clang/lib/Basic/Diagnostic.cpp 78 : Diags(std::move(diags)), DiagOpts(std::move(DiagOpts)) {
78 : Diags(std::move(diags)), DiagOpts(std::move(DiagOpts)) {
tools/clang/lib/Basic/FileManager.cpp 53 : FS(std::move(FS)), FileSystemOpts(FSO), SeenDirEntries(64),
65 StatCache = std::move(statCache);
110 VirtualDirectoryEntries.push_back(std::move(UDE));
318 UFE.File = std::move(F);
tools/clang/lib/Basic/FileSystemStatCache.cpp 73 *F = std::move(*OwnedFile);
tools/clang/lib/CodeGen/BackendUtil.cpp 143 BuryPointer(std::move(TM));
1419 OwnedImports.push_back(std::move(*MBOrErr));
1422 return std::make_unique<lto::NativeObjectStream>(std::move(OS));
1428 handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
1441 Conf.SampleProfile = std::move(SampleProfile);
1446 Conf.CSIRProfile = std::move(CGOpts.InstrProfileOutput);
1449 Conf.CSIRProfile = std::move(CGOpts.ProfileInstrumentUsePath);
1452 Conf.ProfileRemapping = std::move(ProfileRemapping);
1486 handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
1517 std::unique_ptr<ModuleSummaryIndex> CombinedIndex = std::move(*IndexOrErr);
1524 LOpts, std::move(OS), CGOpts.SampleProfileFile,
1543 AsmHelper.EmitAssemblyWithNewPassManager(Action, std::move(OS));
1545 AsmHelper.EmitAssembly(Action, std::move(OS));
tools/clang/lib/CodeGen/CGCUDANV.cpp 525 CudaGpuBinary = std::move(CudaGpuBinaryOrErr.get());
tools/clang/lib/CodeGen/CGCall.cpp 879 : TypeExpansion(TEK_Record), Bases(std::move(Bases)),
880 Fields(std::move(Fields)) {}
950 return std::make_unique<RecordExpansion>(std::move(Bases),
951 std::move(Fields));
2966 Ret->setDebugLoc(std::move(RetDbgLoc));
tools/clang/lib/CodeGen/CGDebugInfo.cpp 134 CGF.Builder.SetCurrentDebugLocation(std::move(Loc));
141 CGF->Builder.SetCurrentDebugLocation(std::move(OriginalLocation));
4726 DBuilder.replaceTemporary(std::move(FwdDecl), cast<llvm::MDNode>(Repl));
tools/clang/lib/CodeGen/CGObjC.cpp 3394 return std::pair<LValue,llvm::Value*>(std::move(lvalue), value);
tools/clang/lib/CodeGen/CGObjCGNU.cpp 1942 EarlyInitList.emplace_back(SuperClass->getName(), std::move(v));
tools/clang/lib/CodeGen/CodeGenAction.cpp 127 AsmOutStream(std::move(OS)), Context(nullptr),
132 LinkModules(std::move(LinkModules)) {
215 *getModule(), std::move(LM.Module), LM.LinkFlags,
222 Err = Linker::linkModules(*getModule(), std::move(LM.Module),
279 std::move(E),
295 std::move(*OptRecordFileOrErr);
309 getModule(), Action, std::move(AsmOutStream));
313 Ctx.setDiagnosticHandler(std::move(OldDiagnosticHandler));
415 FileID FID = CSM.createFileID(std::move(CBuf));
862 return std::move(TheModule);
913 getOwningLazyBitcodeModule(std::move(*BCBuf), *VMContext);
922 LinkModules.push_back({std::move(ModuleOrErr.get()), F.PropagateAttrs,
938 std::move(LinkModules), std::move(OS), *VMContext, CoverageInfo));
938 std::move(LinkModules), std::move(OS), *VMContext, CoverageInfo));
948 CI.getPreprocessor().addPPCallbacks(std::move(Callbacks));
951 return std::move(Result);
992 handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
1015 return std::move(*MOrErr);
1083 std::move(OS));
tools/clang/lib/CodeGen/CodeGenFunction.h 1487 std::move(CGF.CXXInheritedCtorInitExprArgs)) {
1512 std::move(OldCXXInheritedCtorInitExprArgs);
tools/clang/lib/CodeGen/CodeGenModule.cpp 162 llvm::handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EI) {
167 PGOReader = std::move(ReaderOrErr.get());
tools/clang/lib/CodeGen/CodeGenPGO.cpp 972 auto IPE = llvm::InstrProfError::take(std::move(E));
983 std::make_unique<llvm::InstrProfRecord>(std::move(RecordExpected.get()));
tools/clang/lib/CodeGen/EHScopeStack.h 216 ConditionalCleanup(SavedTuple Tuple) : Saved(std::move(Tuple)) {}
286 Cleanup *Obj = new (Buffer) T(std::move(A));
tools/clang/lib/CodeGen/ObjectFilePCHContainerOperations.cpp 146 OS(std::move(OS)), Buffer(std::move(Buffer)) {
146 OS(std::move(OS)), Buffer(std::move(Buffer)) {
240 std::unique_ptr<llvm::LLVMContext> VMContext = std::move(this->VMContext);
241 std::unique_ptr<llvm::Module> M = std::move(this->M);
242 std::unique_ptr<CodeGen::CodeGenModule> Builder = std::move(this->Builder);
308 std::move(OS));
312 SerializedAST = std::move(Empty);
325 CI, MainFileName, OutputFileName, std::move(OS), Buffer);
tools/clang/lib/CodeGen/SwiftCallingConv.cpp 485 auto orig = std::move(Entries);
tools/clang/lib/CodeGen/TargetInfo.cpp 1198 AsmString = std::move(OS.str());
8971 TSC.addIncomplete(ID, std::move(StubEnc));
tools/clang/lib/CrossTU/CrossTranslationUnit.cpp 390 FileASTUnitMap[FileName] = std::move(LoadedUnit);
417 return std::move(IndexLoadError);
447 return std::move(IndexLoadError);
tools/clang/lib/DirectoryWatcher/linux/DirectoryWatcher-linux.cpp 302 InotifyPollingStopSignal(std::move(InotifyPollingStopSignal)) {
359 std::move(*InotifyPollingStopper));
tools/clang/lib/Driver/Driver.cpp 124 : Diags(Diags), VFS(std::move(VFS)), Mode(GCCMode),
460 Target = std::move(LE);
464 Target = std::move(BE);
746 FilePath = std::move(WPath);
969 InputArgList Args = std::move(HasConfigFile ? std::move(*CfgOptions)
969 InputArgList Args = std::move(HasConfigFile ? std::move(*CfgOptions)
970 : std::move(*CLOptions));
1099 std::make_unique<InputArgList>(std::move(Args));
3612 return C.MakeAction<AssembleJobAction>(std::move(Input), types::TY_Object);
tools/clang/lib/Driver/Job.cpp 201 IncFlags.push_back(std::move(NewArg));
211 IncFlags.push_back(std::move(NewInc));
379 Fallback(std::move(Fallback_)) {}
tools/clang/lib/Driver/ToolChains/Clang.cpp 1931 CompilationDatabase = std::move(File);
5542 JA, *this, Exec, CmdArgs, Inputs, std::move(CLCommand)));
tools/clang/lib/Driver/ToolChains/Darwin.cpp 657 Cmd->setInputFileList(std::move(InputFileList));
658 C.addCommand(std::move(Cmd));
tools/clang/lib/Driver/ToolChains/MSVC.cpp 78 Path = std::move(*VCToolsInstallDir);
88 Path = std::move(*VCInstallDir);
588 C.addCommand(std::move(LinkCmd));
tools/clang/lib/Format/ContinuationIndenter.cpp 1603 << llvm::toString(std::move(PrefixErr)) << "\n";
1615 << llvm::toString(std::move(SuffixErr)) << "\n";
1626 << llvm::toString(std::move(Err)) << "\n";
tools/clang/lib/Format/Format.cpp 1195 StyleSet.Add(std::move(DefaultStyle));
1232 (*Styles)[Style.Language] = std::move(Style);
1290 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
1648 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
1967 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
2136 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
2325 << Header << ": " << llvm::toString(std::move(Err))
2345 llvm::consumeError(std::move(Err));
2430 CurrentCode = std::move(*NewCode);
tools/clang/lib/Format/NamespaceEndCommentsFixer.cpp 135 << llvm::toString(std::move(Err)) << "\n";
149 << llvm::toString(std::move(Err)) << "\n";
tools/clang/lib/Format/SortJavaScriptImports.cpp 198 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
tools/clang/lib/Format/TokenAnalyzer.cpp 106 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
tools/clang/lib/Format/UnwrappedLineParser.cpp 147 PreBlockLine = std::move(Parser.Line);
158 Parser.Line = std::move(PreBlockLine);
2478 CurrentLines->push_back(std::move(*Line));
tools/clang/lib/Format/UsingDeclarationsSorter.cpp 148 << llvm::toString(std::move(Err)) << "\n";
172 << llvm::toString(std::move(Err)) << "\n";
tools/clang/lib/Format/WhitespaceManager.cpp 785 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
tools/clang/lib/Frontend/ASTConsumers.cpp 40 : Out(Out ? *Out : llvm::outs()), OwnedOut(std::move(Out)),
142 return std::make_unique<ASTPrinter>(std::move(Out), ASTPrinter::Print,
151 return std::make_unique<ASTPrinter>(std::move(Out),
tools/clang/lib/Frontend/ASTMerge.cpp 89 : AdaptedAction(std::move(adaptedAction)), ASTFiles(ASTFiles.begin(), ASTFiles.end()) {
tools/clang/lib/Frontend/ASTUnit.cpp 144 return std::move(*Val);
275 this->PP = std::move(PP);
739 return std::move(*Buffer);
1023 std::vector<Decl *> takeTopLevelDecls() { return std::move(TopLevelDecls); }
1026 return std::move(TopLevelDeclIDs);
1119 new CompilerInstance(std::move(PCHContainerOps)));
1127 FileMgr = Clang->createFileManager(std::move(VFS));
1191 SavedMainFileBuffer = std::move(OverrideMainBuffer);
1211 consumeError(std::move(Err)); // FIXME this drops errors on the floor.
1386 Preamble = std::move(*NewPreamble);
1415 StoredDiagnostics = std::move(NewPreambleDiags);
1416 PreambleDiagnostics = std::move(NewPreambleDiagsStandalone);
1502 AST->Invocation = std::move(CI);
1560 new CompilerInstance(std::move(PCHContainerOps)));
1566 Clang->setInvocation(std::move(CI));
1636 std::make_unique<MultiplexConsumer>(std::move(Consumers)));
1639 consumeError(std::move(Err)); // FIXME this drops errors on the floor.
1689 return Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer), VFS);
1689 return Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer), VFS);
1710 AST->Invocation = std::move(CI);
1722 if (AST->LoadFromCompilerInvocation(std::move(PCHContainerOps),
1810 if (AST->LoadFromCompilerInvocation(std::move(PCHContainerOps),
1868 Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer), VFS);
1868 Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer), VFS);
2187 Clang->setInvocation(std::move(CCInvocation));
2290 consumeError(std::move(Err)); // FIXME this drops errors on the floor.
2315 consumeError(std::move(Err));
tools/clang/lib/Frontend/ChainedIncludesSource.cpp 32 : CIs(std::move(CIs)) {}
60 : Impl(std::move(CIs)), FinalReader(std::move(FinalReader)) {}
60 : Impl(std::move(CIs)), FinalReader(std::move(FinalReader)) {}
73 : ChainedIncludesSourceMembers(std::move(CIs), std::move(FinalReader)),
73 : ChainedIncludesSourceMembers(std::move(CIs), std::move(FinalReader)),
91 Reader->addInMemoryBuffer(sr, std::move(MemBufs[ti]));
148 Clang->setInvocation(std::move(CInvok));
166 Clang->setASTConsumer(std::move(consumer));
205 CIs.push_back(std::move(Clang));
216 new ChainedIncludesSource(std::move(CIs), Reader));
tools/clang/lib/Frontend/CompilerInstance.cpp 65 ThePCHContainerOperations(std::move(PCHContainerOps)) {}
73 Invocation = std::move(Value);
109 PP = std::move(Value);
124 Consumer = std::move(Value);
135 return std::move(TheSema);
144 ModuleManager = std::move(Reader);
154 ModuleDepCollector = std::move(Collector);
209 llvm::vfs::collectVFSFromYAML(std::move(Buffer.get()),
235 StreamOwner = std::move(FileOS);
241 std::move(StreamOwner));
246 new ChainedDiagnosticConsumer(Diags.takeClient(), std::move(Logger)));
249 new ChainedDiagnosticConsumer(Diags.getClient(), std::move(Logger)));
261 Diags.takeClient(), std::move(SerializedConsumer)));
264 Diags.getClient(), std::move(SerializedConsumer)));
317 FileMgr = new FileManager(getFileSystemOpts(), std::move(VFS));
636 OutputFiles.push_back(std::move(OutFile));
803 return std::move(OS);
807 NonSeekStream = std::move(OS);
808 return std::move(B);
864 SourceMgr.overrideFileContents(FE, std::move(*MB));
883 std::unique_ptr<llvm::MemoryBuffer> SB = std::move(SBOrErr.get());
889 SourceMgr.overrideFileContents(File, std::move(SB));
965 consumeError(std::move(Err)); // FIXME this drops errors on the floor.
1114 Instance.setInvocation(std::move(Invocation));
1235 ModuleMapFile, std::move(ModuleMapBuffer));
1504 getFrontendOpts().UseGlobalModuleIndex, std::move(ReadTimer));
1592 std::move(Listener));
2028 Other.BuiltModules = std::move(BuiltModules);
2033 BuiltModules = std::move(Other.BuiltModules);
2080 consumeError(std::move(Err));
2111 consumeError(std::move(Err));
2152 ExternalSemaSrc = std::move(ESS);
tools/clang/lib/Frontend/CompilerInvocation.cpp 652 llvm::consumeError(std::move(E));
657 std::move(ReaderOrErr.get());
2025 Opts.Inputs.emplace_back(std::move(Inputs[i]), IK);
3709 std::move(Buffer.get()), /*DiagHandler*/ nullptr, File,
tools/clang/lib/Frontend/FrontendAction.cpp 139 CurrentASTUnit = std::move(AST);
206 Consumers.push_back(std::move(PluginConsumer));
208 AfterConsumers.push_back(std::move(PluginConsumer));
214 Consumers.push_back(std::move(Consumer));
216 Consumers.push_back(std::move(C));
219 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
616 setCurrentInput(Input, std::move(AST));
652 setCurrentInput(Input, std::move(AST));
784 auto BufferID = SourceMgr.createFileID(std::move(Buffer), Kind);
879 CI.setASTConsumer(std::move(Consumer));
949 consumeError(std::move(Err));
1002 llvm::BuryPointer(std::move(CurrentASTUnit));
1101 : WrappedAction(std::move(WrappedAction)) {}
tools/clang/lib/Frontend/FrontendActions.cpp 72 return CreateASTPrinter(std::move(OS), CI.getFrontendOpts().ASTDumpFilter);
118 CI, InFile, OutputFile, std::move(OS), Buffer));
120 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
184 CI, InFile, OutputFile, std::move(OS), Buffer));
185 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
tools/clang/lib/Frontend/LogDiagnosticPrinter.cpp 23 : OS(os), StreamOwner(std::move(StreamOwner)), LangOpts(nullptr),
tools/clang/lib/Frontend/MultiplexConsumer.cpp 239 : Consumers(std::move(C)), MutationListener(), DeserializationListener() {
tools/clang/lib/Frontend/PrecompiledPreamble.cpp 59 PCHFS->addFile(PCHFilename, 0, std::move(PCHBuffer));
168 Action(Action), Out(std::move(Out)) {}
186 getPCH() = std::move(Empty);
217 *this, CI.getPreprocessor(), CI.getModuleCache(), Sysroot, std::move(OS));
223 Output = std::move(*Val);
257 TempFile = std::move(*PreamblePCHFile);
261 : PCHStorage(std::move(*TempFile));
281 new CompilerInstance(std::move(PCHContainerOps)));
287 Clang->setInvocation(std::move(PreambleInvocation));
351 Clang->getPreprocessor().addPPCallbacks(std::move(DelegatedPPCallbacks));
356 return errorToErrorCode(std::move(Err));
388 return PrecompiledPreamble(std::move(Storage), std::move(PreambleBytes),
388 return PrecompiledPreamble(std::move(Storage), std::move(PreambleBytes),
390 std::move(FilesInPreamble));
527 : Storage(std::move(Storage)), FilesInPreamble(std::move(FilesInPreamble)),
527 : Storage(std::move(Storage)), FilesInPreamble(std::move(FilesInPreamble)),
528 PreambleBytes(std::move(PreambleBytes)),
557 return TempPCHFile(std::move(File).str());
566 : FilePath(std::move(FilePath)) {
571 FilePath = std::move(Other.FilePath);
579 FilePath = std::move(Other.FilePath);
600 new (&asFile()) TempPCHFile(std::move(File));
605 new (&asMemory()) InMemoryPreamble(std::move(Memory));
609 *this = std::move(Other);
622 new (&asFile()) TempPCHFile(std::move(Other.asFile()));
625 new (&asMemory()) InMemoryPreamble(std::move(Other.asMemory()));
747 VFS = createVFSOverlayForPreamblePCH(PCHPath, std::move(*Buf), VFS);
756 VFS = createVFSOverlayForPreamblePCH(PCHPath, std::move(Buf), VFS);
tools/clang/lib/Frontend/PrintPreprocessedOutput.cpp 680 PP.EnterTokenStream(std::move(Toks), /*NumToks=*/1,
tools/clang/lib/Frontend/Rewrite/FrontendActions.cpp 44 return CreateHTMLPrinter(std::move(OS), CI.getPreprocessor());
71 : NewSuffix(std::move(NewSuffix)) {
135 consumeError(std::move(Err));
169 InFile, std::move(OS), CI.getDiagnostics(), CI.getLangOpts(),
172 return CreateObjCRewriter(InFile, std::move(OS), CI.getDiagnostics(),
tools/clang/lib/Frontend/Rewrite/HTMLPrint.cpp 40 : Out(std::move(OS)), PP(pp), SyntaxHighlight(_SyntaxHighlight),
51 return std::make_unique<HTMLPrinter>(std::move(OS), PP, SyntaxHighlight,
tools/clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp 646 : Diags(D), LangOpts(LOpts), InFileName(inFile), OutFile(std::move(OS)),
666 return std::make_unique<RewriteModernObjC>(InFile, std::move(OS), Diags,
tools/clang/lib/Frontend/Rewrite/RewriteObjC.cpp 512 : RewriteObjC(inFile, std::move(OS), D, LOpts, silenceMacroWarn) {}
580 : Diags(D), LangOpts(LOpts), InFileName(inFile), OutFile(std::move(OS)),
597 InFile, std::move(OS), Diags, LOpts, SilenceRewriteMacroWarning);
tools/clang/lib/Frontend/SerializedDiagnosticPrinter.cpp 142 State(std::move(State)) {}
tools/clang/lib/Frontend/SerializedDiagnosticReader.cpp 83 BlockInfo = std::move(MaybeBlockInfo.get());
100 consumeError(std::move(Err));
147 return llvm::errorToErrorCode(std::move(Err));
166 consumeError(std::move(Err));
184 consumeError(std::move(Err));
215 consumeError(std::move(Err));
238 consumeError(std::move(Err));
tools/clang/lib/Frontend/TestModuleFileExtension.cpp 30 auto Abbrev = Stream.EmitAbbrev(std::move(Abv));
tools/clang/lib/Frontend/VerifyDiagnosticConsumer.cpp 309 UD.DL->push_back(std::move(D));
tools/clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp 85 return std::move(P);
144 Act = std::make_unique<FixItRecompile>(std::move(Act));
155 Act = std::make_unique<arcmt::CheckAction>(std::move(Act));
158 Act = std::make_unique<arcmt::ModifyAction>(std::move(Act));
161 Act = std::make_unique<arcmt::MigrateAction>(std::move(Act),
169 Act = std::make_unique<arcmt::ObjCMigrateAction>(std::move(Act),
179 Act = std::make_unique<ASTMergeAction>(std::move(Act),
292 llvm::BuryPointer(std::move(Act));
tools/clang/lib/Index/FileIndexRecord.cpp 40 Decls.insert(It, std::move(NewInfo));
tools/clang/lib/Index/IndexingAction.cpp 31 : IndexCtx(std::move(IndexCtx)) {}
67 : DataConsumer(std::move(DataConsumer)),
69 PP(std::move(PP)),
70 ShouldSkipFunctionBody(std::move(ShouldSkipFunctionBody)) {
111 : DataConsumer(std::move(DataConsumer)), Opts(Opts) {
138 return std::make_unique<IndexAction>(std::move(DataConsumer), Opts);
tools/clang/lib/Lex/HeaderMap.cpp 62 return std::unique_ptr<HeaderMap>(new HeaderMap(std::move(*FileBuffer), NeedsByteSwap));
tools/clang/lib/Lex/HeaderSearch.cpp 85 : HSOpts(std::move(HSOpts)), Diags(Diags),
125 HeaderMaps.emplace_back(FE, std::move(HM));
tools/clang/lib/Lex/ModuleMap.cpp 1220 Mod->Headers[Module::HK_Excluded].push_back(std::move(Header));
1268 auto Unresolved = std::move(Mod->UnresolvedExports);
1281 auto Unresolved = std::move(Mod->UnresolvedDirectUses);
1294 auto Unresolved = std::move(Mod->UnresolvedConflicts);
2357 Map.addUnresolvedHeader(ActiveModule, std::move(Header), NeedsFramework);
2427 Headers.push_back(std::move(Header));
2435 Map.addHeader(ActiveModule, std::move(Header), ModuleMap::TextualHeader);
tools/clang/lib/Lex/PPDirectives.cpp 1074 EnterTokenStream(std::move(Toks), 2, false, /*IsReinject*/false);
1557 EnterTokenStream(std::move(Tok), 1, true, /*IsReinject*/ false);
tools/clang/lib/Lex/PPLexerChange.cpp 133 TokLexer = std::move(TokenLexerCache[--NumCachedTokenLexers]);
139 CurTokenLexer = std::move(TokLexer);
186 TokLexer = std::move(TokenLexerCache[--NumCachedTokenLexers]);
194 CurTokenLexer = std::move(TokLexer);
558 TokenLexerCache[NumCachedTokenLexers++] = std::move(CurTokenLexer);
575 TokenLexerCache[NumCachedTokenLexers++] = std::move(CurTokenLexer);
688 State.Macros.insert(std::make_pair(Macro.first, std::move(MS)));
tools/clang/lib/Lex/PPMacroExpansion.cpp 809 EnterTokenStream(std::move(Toks), 1, true, /*IsReinject*/ false);
tools/clang/lib/Lex/Pragma.cpp 148 Self.EnterTokenStream(std::move(Toks), Tokens.size(),
tools/clang/lib/Lex/Preprocessor.cpp 84 : PPOpts(std::move(PPOpts)), Diags(&diags), LangOpts(opts),
216 PragmaHandlersBackup = std::move(PragmaHandlers);
227 PragmaHandlers = std::move(PragmaHandlersBackup);
439 SourceMgr.overrideFileContents(File, std::move(NewBuffer));
560 FileID FID = SourceMgr.createFileID(std::move(SB));
1139 EnterTokenStream(std::move(ToksCopy), Toks.size(),
tools/clang/lib/Lex/ScratchBuffer.cpp 80 FileID FID = SourceMgr.createFileID(std::move(OwnBuf));
tools/clang/lib/Parse/ParseCXXInlineMethods.cpp 310 std::unique_ptr<CachedTokens> Toks = std::move(LM.DefaultArgs[I].Toks);
992 Self.PP.EnterTokenStream(std::move(Buffer), Toks.size(), true,
tools/clang/lib/Parse/ParseDecl.cpp 5563 std::move(DS.getAttributes()),
5577 std::move(DS.getAttributes()), SourceLocation());
5613 std::move(DS.getAttributes()), SourceLocation());
5618 std::move(DS.getAttributes()), SourceLocation());
5673 std::move(DS.getAttributes()), SourceLocation());
6183 std::move(attrs), T.getCloseLocation());
6432 std::move(FnAttrs), EndLoc);
6691 Param, std::move(DefArgToks)));
6754 std::move(attrs), T.getCloseLocation());
6770 std::move(attrs), T.getCloseLocation());
6847 std::move(DS.getAttributes()), T.getCloseLocation());
tools/clang/lib/Parse/ParseDeclCXX.cpp 2197 std::move(FTI.Params[ParamIdx].DefaultArgTokens)));
tools/clang/lib/Parse/ParseExprCXX.cpp 1384 std::move(Attr), DeclEndLoc);
1450 std::move(Attr), DeclEndLoc);
3103 std::move(Attrs), T.getCloseLocation());
tools/clang/lib/Parse/ParsePragma.cpp 747 PP.EnterTokenStream(std::move(TheTokens->first), TheTokens->second, true,
1572 std::move(SubjectMatchRules));
1631 PP.EnterTokenStream(std::move(Toks), 1, /*DisableMacroExpansion=*/true,
2244 PP.EnterTokenStream(std::move(Toks), Pragma.size(),
2462 std::pair<std::unique_ptr<Token[]>, size_t>(std::move(TokenArray),
2747 PP.EnterTokenStream(std::move(TokenArray), TokenList.size(),
2932 PP.EnterTokenStream(std::move(TokenArray), TokenList.size(),
3007 PP.EnterTokenStream(std::move(TokenArray), 1,
3279 PP.EnterTokenStream(std::move(TokenArray), 1,
tools/clang/lib/Parse/ParseStmtAsm.cpp 602 TempSrcMgr.AddNewSourceBuffer(std::move(Buffer), llvm::SMLoc());
tools/clang/lib/Sema/AnalysisBasedWarnings.cpp 1636 ONS.push_back(std::move(FNote));
1650 ONS.push_back(std::move(FNote));
1685 Warnings.emplace_back(std::move(Warning), getNotes());
1694 Warnings.emplace_back(std::move(Warning), getNotes());
1706 Warnings.emplace_back(std::move(Warning),
1716 Warnings.emplace_back(std::move(Warning),
1744 Warnings.emplace_back(std::move(Warning),
1756 Warnings.emplace_back(std::move(Warning), getNotes(Note));
1769 Warnings.emplace_back(std::move(Warning), getNotes());
1804 Warnings.emplace_back(std::move(Warning), getNotes(Note, VNote));
1806 Warnings.emplace_back(std::move(Warning), getNotes(Note));
1831 Warnings.emplace_back(std::move(Warning), getNotes(Note));
1833 Warnings.emplace_back(std::move(Warning), getNotes());
1842 Warnings.emplace_back(std::move(Warning), getNotes());
1849 Warnings.emplace_back(std::move(Warning), getNotes());
1856 Warnings.emplace_back(std::move(Warning), getNotes());
1862 Warnings.emplace_back(std::move(Warning), getNotes());
1907 Warnings.emplace_back(std::move(Warning), OptionalNotes());
1919 Warnings.emplace_back(std::move(Warning), OptionalNotes());
1928 Warnings.emplace_back(std::move(Warning), OptionalNotes());
1936 Warnings.emplace_back(std::move(Warning), OptionalNotes());
1945 Warnings.emplace_back(std::move(Warning), OptionalNotes());
1954 Warnings.emplace_back(std::move(Warning), OptionalNotes());
1963 Warnings.emplace_back(std::move(Warning), OptionalNotes());
tools/clang/lib/Sema/DeclSpec.cpp 238 I.Fun.Params[i] = std::move(Params[i]);
tools/clang/lib/Sema/Sema.cpp 188 PP.addPPCallbacks(std::move(Callbacks));
tools/clang/lib/Sema/SemaAttr.cpp 762 {PragmaLoc, &Attribute, std::move(SubjectMatchRules), /*IsUsed=*/false});
tools/clang/lib/Sema/SemaCodeComplete.cpp 88 ShadowMapEntry(ShadowMapEntry &&Move) { *this = std::move(Move); }
1333 Incumbent = std::move(R);
1598 FixIts(std::move(FixIts)) {
4669 CodeCompletionDeclConsumer Consumer(Results, RD, BaseType, std::move(FixIts));
4758 std::move(AccessOpFixIt));
4766 RD, std::move(AccessOpFixIt));
4771 RD, std::move(AccessOpFixIt));
8288 Results.AddResult(std::move(R));
tools/clang/lib/Sema/SemaDecl.cpp14193 std::move(DS.getAttributes()), SourceLocation());
17287 DupVector.emplace_back(std::move(Vec));
tools/clang/lib/Sema/SemaDeclCXX.cpp 400 std::move(chunk.Fun.Params[argIdx].DefaultArgTokens);
tools/clang/lib/Sema/SemaExprCXX.cpp 7710 auto SavedTypoExprs = std::move(TypoExprs);
7711 auto SavedAmbiguousTypoExprs = std::move(AmbiguousTypoExprs);
7746 TypoExprs = std::move(SavedTypoExprs);
7747 AmbiguousTypoExprs = std::move(SavedAmbiguousTypoExprs);
7759 auto SavedTypoExprs = std::move(SemaRef.TypoExprs);
7820 TransformCache = std::move(SavedTransformCache);
7838 SemaRef.TypoExprs = std::move(SavedTypoExprs);
tools/clang/lib/Sema/SemaLookup.cpp 703 ArgTypes.push_back(std::move(Ty));
4867 *this, TypoName, LookupKind, S, SS, std::move(ClonedCCC), MemberContext,
5138 return createDelayedTypo(std::move(Consumer), std::move(TDG), std::move(TRC));
5138 return createDelayedTypo(std::move(Consumer), std::move(TDG), std::move(TRC));
5138 return createDelayedTypo(std::move(Consumer), std::move(TDG), std::move(TRC));
5482 State.Consumer = std::move(TCC);
5483 State.DiagHandler = std::move(TDG);
5484 State.RecoveryHandler = std::move(TRC);
tools/clang/lib/Sema/SemaModule.cpp 224 ModuleScopes.back().OuterVisibleModules = std::move(VisibleModules);
446 ModuleScopes.back().OuterVisibleModules = std::move(VisibleModules);
466 VisibleModules = std::move(ModuleScopes.back().OuterVisibleModules);
tools/clang/lib/Sema/SemaStmt.cpp 2256 LookupResult OldFound = std::move(Found);
tools/clang/lib/Sema/SemaTemplate.cpp 5461 TemplateArgs = std::move(NewArgs);
8477 ConvertedTemplateArgs[Specialization] = std::move(Args);
10326 LateParsedTemplateMap.insert(std::make_pair(FD, std::move(LPT)));
tools/clang/lib/Serialization/ASTReader.cpp 1152 Error(std::move(Err));
1202 Error(std::move(Err));
1257 Error(toString(std::move(Err)));
1324 Error(std::move(Err));
1331 Error(std::move(Err));
1454 llvm::toString(std::move(E)));
1469 Error(std::move(Err));
1548 SourceMgr.overrideFileContents(File, std::move(Buffer));
1567 SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
1628 consumeError(std::move(Err));
1646 consumeError(std::move(Err));
1653 consumeError(std::move(Err));
1681 consumeError(std::move(Err));
1950 Error(std::move(Err));
2098 Error(std::move(Err));
2221 consumeError(std::move(Err));
2289 consumeError(std::move(Err));
2477 consumeError(std::move(Err));
2567 Error(std::move(Err));
2663 Error(std::move(Err));
2703 Error(std::move(Err));
2710 Error(std::move(Err));
2927 Error(std::move(Err));
2967 Error(std::move(Err));
2982 Error(std::move(Err));
2996 Error(std::move(Err));
3028 Error(std::move(Err));
3041 Error(std::move(Err));
4033 auto HiddenNames = std::move(*Hidden);
4084 if (llvm::Error Err = std::move(Result.second)) {
4086 consumeError(std::move(Err)); // FIXME this drops errors on the floor.
4144 consumeError(std::move(Err));
4153 consumeError(std::move(Err));
4502 << moduleKindForDiagnostic(Type) << FileName << std::move(Err);
4576 Error(std::move(Err));
4648 consumeError(std::move(Err));
4750 Error(std::move(Err));
4786 F.ExtensionReaders.push_back(std::move(Reader));
4946 consumeError(std::move(Err));
5002 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName << std::move(Err);
5115 consumeError(std::move(Err)); // FIXME this drops errors on the floor.
5156 consumeError(std::move(Err));
5167 consumeError(std::move(Err));
5236 consumeError(std::move(Err));
5311 consumeError(std::move(Err));
5378 Error(std::move(Err));
5775 HSOpts.UserEntries.emplace_back(std::move(Path), Group, IsFramework,
5783 HSOpts.SystemHeaderPrefixes.emplace_back(std::move(Prefix), IsSystemHeader);
5894 Error(std::move(Err));
6332 Error(std::move(Err));
7660 Error(std::move(Err));
7695 Error(std::move(Err));
7923 Error(std::move(Err));
8477 : Current(std::move(First)), Queued(std::move(Second)) {}
8477 : Current(std::move(First)), Queued(std::move(Second)) {}
8502 return new ChainedIdentifierIterator(std::move(ReaderIter),
8503 std::move(ModulesIter));
8805 LPTMap.insert(std::make_pair(FD, std::move(LT)));
9621 return APValue(std::move(First), ReadAPSInt(Record, Idx));
9629 return APValue(std::move(First), ReadAPFloat(Record, FloatSema2, Idx));
9867 std::move(PendingIdentifierInfos.back().second);
10072 auto OdrMergeFailures = std::move(PendingOdrMergeFailures);
10088 auto FunctionOdrMergeFailures = std::move(PendingFunctionOdrMergeFailures);
10102 auto EnumOdrMergeFailures = std::move(PendingEnumOdrMergeFailures);
12154 auto ESUpdates = std::move(PendingExceptionSpecUpdates);
12166 auto DTUpdates = std::move(PendingDeducedTypeUpdates);
12230 DummyIdResolver(PP), ReadTimer(std::move(ReadTimer)), isysroot(isysroot),
tools/clang/lib/Serialization/ASTReaderDecl.cpp 1143 MergeDefinitionData(Canon, std::move(ID->data()));
1208 MergeDefinitionData(Canon, std::move(PD->data()));
1749 DD = std::move(MergeDD);
1774 DD.VisibleConversions = std::move(MergeDD.VisibleConversions);
1821 MergeDefinitionData(Canon, std::move(*DD));
2143 MergeDefinitionData(CanonSpec, std::move(*DDD));
2466 MergeDefinitionData(ExistingClass, std::move(*DDD));
3625 ": " + toString(std::move(Err)));
3629 Fail("jumping", std::move(JumpFailed));
3972 auto UpdateOffsets = std::move(UpdI->second);
3990 toString(std::move(JumpFailed)));
4035 auto VisibleUpdates = std::move(I->second);
4071 toString(std::move(JumpFailed)));
tools/clang/lib/Serialization/ASTWriter.cpp 889 TypeExtQualAbbrev = Stream.EmitAbbrev(std::move(Abv));
912 TypeFunctionProtoAbbrev = Stream.EmitAbbrev(std::move(Abv));
1481 unsigned MetadataAbbrevCode = Stream.EmitAbbrev(std::move(MetadataAbbrev));
1504 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1524 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1726 unsigned FileAbbrevCode = Stream.EmitAbbrev(std::move(FileAbbrev));
1743 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1791 unsigned IFAbbrevCode = Stream.EmitAbbrev(std::move(IFAbbrev));
1798 unsigned IFHAbbrevCode = Stream.EmitAbbrev(std::move(IFHAbbrev));
1897 unsigned OffsetsAbbrevCode = Stream.EmitAbbrev(std::move(OffsetsAbbrev));
1925 return Stream.EmitAbbrev(std::move(Abbrev));
1940 return Stream.EmitAbbrev(std::move(Abbrev));
1955 return Stream.EmitAbbrev(std::move(Abbrev));
1971 return Stream.EmitAbbrev(std::move(Abbrev));
2229 unsigned TableAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2259 llvm::consumeError(std::move(E));
2411 unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2688 unsigned MacroOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2719 InclusionAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2786 unsigned PPEOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2807 unsigned PPESkippedRangeAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2876 unsigned DefinitionAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2881 unsigned UmbrellaAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2886 unsigned HeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2891 unsigned TopHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2896 unsigned UmbrellaDirAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2902 unsigned RequiresAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2907 unsigned ExcludedHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2912 unsigned TextualHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2917 unsigned PrivateHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2922 unsigned PrivateTextualHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2928 unsigned LinkLibraryAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2933 unsigned ConfigMacroAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2939 unsigned ConflictAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2944 unsigned ExportAsAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3257 unsigned TypeOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3270 unsigned DeclOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3298 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
3515 unsigned MethodPoolAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3530 unsigned SelectorOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3829 unsigned IDTableAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3842 unsigned IdentifierOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
4444 unsigned AbbrevID = Stream.EmitAbbrev(std::move(Abbrev));
4533 unsigned Abbrev = Stream.EmitAbbrev(std::move(Abv));
4676 ModuleFileExtensionWriters.push_back(std::move(Writer));
4917 unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(std::move(Abv));
4929 UpdateVisibleAbbrev = Stream.EmitAbbrev(std::move(Abv));
5031 unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
tools/clang/lib/Serialization/ASTWriterDecl.cpp 1880 DeclFieldAbbrev = Stream.EmitAbbrev(std::move(Abv));
1916 DeclObjCIvarAbbrev = Stream.EmitAbbrev(std::move(Abv));
1966 DeclEnumAbbrev = Stream.EmitAbbrev(std::move(Abv));
2028 DeclRecordAbbrev = Stream.EmitAbbrev(std::move(Abv));
2076 DeclParmVarAbbrev = Stream.EmitAbbrev(std::move(Abv));
2105 DeclTypedefAbbrev = Stream.EmitAbbrev(std::move(Abv));
2157 DeclVarAbbrev = Stream.EmitAbbrev(std::move(Abv));
2220 DeclCXXMethodAbbrev = Stream.EmitAbbrev(std::move(Abv));
2244 DeclRefExprAbbrev = Stream.EmitAbbrev(std::move(Abv));
2263 IntegerLiteralAbbrev = Stream.EmitAbbrev(std::move(Abv));
2282 CharacterLiteralAbbrev = Stream.EmitAbbrev(std::move(Abv));
2302 ExprImplicitCastAbbrev = Stream.EmitAbbrev(std::move(Abv));
2307 DeclContextLexicalAbbrev = Stream.EmitAbbrev(std::move(Abv));
2312 DeclContextVisibleLookupAbbrev = Stream.EmitAbbrev(std::move(Abv));
tools/clang/lib/Serialization/GeneratePCH.cpp 30 SemaPtr(nullptr), Buffer(std::move(Buffer)), Stream(this->Buffer->Data),
tools/clang/lib/Serialization/GlobalModuleIndex.cpp 130 : Buffer(std::move(Buffer)), IdentifierIndex(), NumIdentifierLookups(),
134 "' failed: " + toString(std::move(Err)));
171 Fail(std::move(Err));
174 Fail(std::move(Err));
263 std::unique_ptr<llvm::MemoryBuffer> Buffer = std::move(BufferOrErr.get());
279 return std::make_pair(new GlobalModuleIndex(std::move(Buffer), Cursor),
840 unsigned IDTableAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
tools/clang/lib/Serialization/InMemoryModuleCache.cpp 27 auto Insertion = PCMs.insert(std::make_pair(Filename, std::move(Buffer)));
38 PCM.Buffer = std::move(Buffer);
tools/clang/lib/Serialization/ModuleManager.cpp 75 return std::move(InMemoryBuffers[*Entry]);
166 NewModule->Buffer = &ModuleCache->addBuiltPCM(FileName, std::move(Buffer));
196 NewModule->Buffer = &getModuleCache().addPCM(FileName, std::move(*Buf));
218 Chain.push_back(std::move(NewModule));
278 InMemoryBuffers[Entry] = std::move(Buffer);
tools/clang/lib/Serialization/MultiOnDiskHashTable.h 179 : Tables(std::move(O.Tables)),
180 PendingOverrides(std::move(O.PendingOverrides)) {
223 Buckets, Ptr, Data, std::move(InfoObj));
tools/clang/lib/Serialization/PCHContainerOperations.cpp 35 : Buffer(std::move(Buffer)), OS(std::move(OS)) {}
35 : Buffer(std::move(Buffer)), OS(std::move(OS)) {}
47 Buffer->Data = std::move(Empty);
57 return std::make_unique<RawPCHContainerGenerator>(std::move(OS), Buffer);
tools/clang/lib/StaticAnalyzer/Checkers/ArrayBoundChecker.cpp 82 C.emitReport(std::move(report));
tools/clang/lib/StaticAnalyzer/Checkers/ArrayBoundCheckerV2.cpp 260 BR->addVisitor(std::move(Visitor));
261 checkerContext.emitReport(std::move(BR));
tools/clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp 217 C.emitReport(std::move(R));
525 C.emitReport(std::move(report));
581 C.emitReport(std::move(report));
640 C.emitReport(std::move(report));
794 C.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/BlockInCriticalSectionChecker.cpp 180 C.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/CStringChecker.cpp 578 C.emitReport(std::move(report));
594 C.emitReport(std::move(Report));
616 C.emitReport(std::move(Report));
633 C.emitReport(std::move(Report));
654 C.emitReport(std::move(Report));
tools/clang/lib/StaticAnalyzer/Checkers/CallAndMessageChecker.cpp 105 C.emitReport(std::move(R));
183 C.emitReport(std::move(R));
260 C.emitReport(std::move(R));
305 C.emitReport(std::move(R));
363 C.emitReport(std::move(R));
492 C.emitReport(std::move(R));
535 C.emitReport(std::move(report));
tools/clang/lib/StaticAnalyzer/Checkers/CastSizeChecker.cpp 138 C.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp 581 C.emitReport(std::move(BR));
705 C.emitReport(std::move(BR));
747 C.emitReport(std::move(BR));
tools/clang/lib/StaticAnalyzer/Checkers/CloneChecker.cpp 124 BR.emitReport(std::move(R));
186 BR.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/ConversionChecker.cpp 125 C.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/DebugCheckers.cpp 339 C.emitReport(std::move(Report));
tools/clang/lib/StaticAnalyzer/Checkers/DeleteWithNonVirtualDtorChecker.cpp 100 C.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/DereferenceChecker.cpp 191 C.emitReport(std::move(report));
206 C.emitReport(std::move(report));
tools/clang/lib/StaticAnalyzer/Checkers/DivZeroChecker.cpp 51 R->addVisitor(std::move(Visitor));
53 C.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/DynamicTypeChecker.cpp 88 C.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp 920 C.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/FixedAddressChecker.cpp 61 C.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp 190 : SrcArgs(std::move(Src)), DstArgs(std::move(Dst)),
190 : SrcArgs(std::move(Src)), DstArgs(std::move(Dst)),
325 P.Name, std::move(P.SrcArgs),
331 std::move(F.second));
335 GenericTaintChecker::CustomSinks.try_emplace(S.first, std::move(S.second));
742 C.emitReport(std::move(report));
850 Checker->parseConfiguration(Mgr, Option, std::move(Config.getValue()));
tools/clang/lib/StaticAnalyzer/Checkers/IteratorChecker.cpp 1596 C.emitReport(std::move(R));
1607 C.emitReport(std::move(R));
1618 C.emitReport(std::move(R));
1627 C.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp 777 C.emitReport(std::move(R));
1031 return std::move(Piece);
tools/clang/lib/StaticAnalyzer/Checkers/MIGChecker.cpp 287 C.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp 46 BReporter.emitReport(std::move(Report));
66 BReporter.emitReport(std::move(Report));
84 BReporter.emitReport(std::move(Report));
tools/clang/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp 246 C.emitReport(std::move(Report));
291 C.emitReport(std::move(Report));
346 C.emitReport(std::move(Report));
tools/clang/lib/StaticAnalyzer/Checkers/MacOSXAPIChecker.cpp 145 C.emitReport(std::move(report));
tools/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp 804 StopTrackingCallback(ProgramStateRef st) : state(std::move(st)) {}
2088 C.emitReport(std::move(R));
2114 C.emitReport(std::move(R));
2170 C.emitReport(std::move(R));
2229 C.emitReport(std::move(R));
2266 C.emitReport(std::move(R));
2297 C.emitReport(std::move(R));
2321 C.emitReport(std::move(R));
2352 C.emitReport(std::move(R));
2388 C.emitReport(std::move(R));
2614 C.emitReport(std::move(R));
3352 BR.addCallStackHint(P, std::move(StackHint));
tools/clang/lib/StaticAnalyzer/Checkers/MallocOverflowSecurityChecker.cpp 40 : mulop(m), variable(v), maxVal(std::move(val)) {}
tools/clang/lib/StaticAnalyzer/Checkers/MmapWriteExecChecker.cpp 75 C.emitReport(std::move(Report));
tools/clang/lib/StaticAnalyzer/Checkers/MoveChecker.cpp 436 C.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/NSAutoreleasePoolChecker.cpp 76 C.emitReport(std::move(Report));
tools/clang/lib/StaticAnalyzer/Checkers/NonNullParamChecker.cpp 156 C.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp 179 BR.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/ObjCAtSyncChecker.cpp 52 C.emitReport(std::move(report));
77 C.emitReport(std::move(report));
tools/clang/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp 152 C.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/ObjCSuperDeallocChecker.cpp 194 C.emitReport(std::move(BR));
tools/clang/lib/StaticAnalyzer/Checkers/PaddingChecker.cpp 301 return {NewPad, std::move(OptimalFieldsOrder)};
342 BR->emitReport(std::move(Report));
tools/clang/lib/StaticAnalyzer/Checkers/PointerArithChecker.cpp 180 C.emitReport(std::move(R));
203 C.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/PointerSubChecker.cpp 69 C.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp 246 C.emitReport(std::move(report));
311 C.emitReport(std::move(Report));
335 C.emitReport(std::move(report));
405 C.emitReport(std::move(Report));
445 C.emitReport(std::move(Report));
459 C.emitReport(std::move(Report));
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp 132 StopTrackingCallback(ProgramStateRef st) : state(std::move(st)) {}
882 C.emitReport(std::move(report));
1099 C.emitReport(std::move(R));
1124 C.emitReport(std::move(R));
1278 Ctx.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp 603 return std::move(P);
tools/clang/lib/StaticAnalyzer/Checkers/ReturnPointerRangeChecker.cpp 86 C.emitReport(std::move(report));
tools/clang/lib/StaticAnalyzer/Checkers/ReturnUndefChecker.cpp 92 C.emitReport(std::move(Report));
tools/clang/lib/StaticAnalyzer/Checkers/SimpleStreamChecker.cpp 95 StopTrackingCallback(ProgramStateRef st) : state(std::move(st)) {}
213 C.emitReport(std::move(R));
226 C.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/StackAddrEscapeChecker.cpp 170 C.emitReport(std::move(report));
207 C.emitReport(std::move(Report));
230 C.emitReport(std::move(Report));
360 Ctx.emitReport(std::move(Report));
tools/clang/lib/StaticAnalyzer/Checkers/TaintTesterChecker.cpp 57 C.emitReport(std::move(report));
tools/clang/lib/StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp 177 C.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/UndefBranchChecker.cpp 34 : St(std::move(S)), LCtx(L) {}
104 Ctx.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/UndefCapturedBlockVarChecker.cpp 94 C.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/UndefResultChecker.cpp 181 C.emitReport(std::move(report));
tools/clang/lib/StaticAnalyzer/Checkers/UndefinedArraySubscriptChecker.cpp 58 C.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/UndefinedAssignmentChecker.cpp 116 C.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedObjectChecker.cpp 193 Context.emitReport(std::move(Report));
213 Context.emitReport(std::move(Report));
273 return UninitFields.insert({FR, std::move(NoteMsgBuf)}).second;
tools/clang/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp 140 C.emitReport(std::move(Report));
310 C.emitReport(std::move(report));
356 C.emitReport(std::move(report));
tools/clang/lib/StaticAnalyzer/Checkers/VLASizeChecker.cpp 76 report->addVisitor(std::move(Visitor));
79 C.emitReport(std::move(report));
tools/clang/lib/StaticAnalyzer/Checkers/ValistChecker.cpp 261 C.emitReport(std::move(R));
304 C.emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Checkers/VforkChecker.cpp 137 C.emitReport(std::move(Report));
tools/clang/lib/StaticAnalyzer/Checkers/VirtualCallChecker.cpp 161 C.emitReport(std::move(Report));
tools/clang/lib/StaticAnalyzer/Core/BugReporter.cpp 377 auto piece = std::move(path.front());
399 piece = std::move(pieceToKeep == event ? piece : path.front());
411 path.push_back(std::move(piece));
428 auto piece = std::move(pieces.front());
464 pieces.push_back(std::move(piece));
473 auto Piece = std::move(Path.front());
476 Path.push_back(std::move(Piece));
1209 C.getActivePath().push_front(std::move(Call));
1259 C.getActivePath().push_front(std::move(p));
1300 C.getActivePath().push_front(std::move(PE));
1476 I = pieces.insert(I, std::move(P));
1979 : BugReporterContext(BRC), BugPath(std::move(BugPath)), R(r),
1981 VisitorsDiagnostics(std::move(VisitorsDiagnostics)) {}
2093 return std::move(Construct.PD);
2121 Callbacks.push_back(std::move(visitor));
2592 CurrentBugPath.BugPath = std::move(GNew);
2712 visitors.push_back(std::move(Visitor));
2727 LastPiece = std::move(Piece);
2737 (*Notes)[NextNode].push_back(std::move(P));
2792 std::move(BRC), std::move(BugPath->BugPath), BugPath->Report,
2792 std::move(BRC), std::move(BugPath->BugPath), BugPath->Report,
2793 BugPath->ErrorNode, std::move(visitorNotes));
2814 (*Out)[PC] = std::move(PD);
2839 EQ = new BugReportEquivClass(std::move(R));
2843 EQ->AddReport(std::move(R));
2865 BugReporter::emitReport(std::move(R));
3010 PD->setEndOfPath(std::move(piece));
3025 Pieces.push_front(std::move(ConvertedPiece));
3037 Consumer->HandlePathDiagnostic(std::move(PD));
3257 emitReport(std::move(R));
tools/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp 1592 return std::move(X);
2584 return std::move(event);
tools/clang/lib/StaticAnalyzer/Core/PlistDiagnostics.cpp 163 : MacroName(std::move(N)), Expansion(std::move(E)) {}
163 : MacroName(std::move(N)), Expansion(std::move(E)) {}
830 : Name(std::move(N)), MI(MI), Args(std::move(M)) {}
830 : Name(std::move(N)), MI(MI), Args(std::move(M)) {}
1166 Args.emplace(UnexpArgII, std::move(ExpandedArgTokens));
tools/clang/lib/StaticAnalyzer/Core/RegionStore.cpp 739 svalBuilder(StateMgr.getSValBuilder()), B(std::move(b)) {}
2067 return (LazyBindingsMap[LCV.getCVData()] = std::move(List));
2089 return (LazyBindingsMap[LCV.getCVData()] = std::move(List));
tools/clang/lib/StaticAnalyzer/Core/SarifDiagnostics.cpp 183 return json::Object{{"location", std::move(Location)},
193 json::Object Ret{{"physicalLocation", std::move(PhysicalLocation)}};
230 return json::Object{{"locations", std::move(Locations)}};
332 return json::Object{{"tool", std::move(Tool)},
333 {"results", std::move(Results)},
334 {"artifacts", std::move(Artifacts)}};
355 OS << llvm::formatv("{0:2}\n", json::Value(std::move(Sarif)));
tools/clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp 232 PP(CI.getPreprocessor()), OutDir(outdir), Opts(std::move(opts)),
459 CheckerRegistrationFns.push_back(std::move(Fn));
tools/clang/lib/StaticAnalyzer/Frontend/ModelInjector.cpp 79 Instance.setInvocation(std::move(Invocation));
tools/clang/lib/Tooling/AllTUsExecution.cpp 72 : OptionsParser(std::move(Options)),
166 return std::make_unique<AllTUsToolExecutor>(std::move(OptionsParser),
tools/clang/lib/Tooling/CommonOptionsParser.cpp 57 Adjusters.push_back(std::move(Adjuster));
146 std::move(Compilations));
150 std::move(Adjuster),
153 Compilations = std::move(AdjustingCompilations);
164 return std::move(Err);
165 return std::move(Parser);
175 llvm::toString(std::move(Err)));
tools/clang/lib/Tooling/CompilationDatabase.cpp 374 llvm::sys::path::parent_path(Path), std::move(Args));
383 std::move(ToolCommandLine),
tools/clang/lib/Tooling/Core/Replacement.cpp 284 Replaces.insert(std::move(NewR));
621 Result[Entry.first] = std::move(Entry.second);
tools/clang/lib/Tooling/DependencyScanning/DependencyScanningFilesystem.cpp 45 Result.MaybeStat = std::move(*Stat);
68 Result.Contents = std::move(MinimizedFileContents);
89 Result.PPSkippedRangeMapping = std::move(Mapping);
98 Result.MaybeStat = std::move(Stat);
184 std::move(*MaybeStatus));
217 : Buffer(std::move(Buffer)), Stat(std::move(Stat)) {}
217 : Buffer(std::move(Buffer)), Stat(std::move(Stat)) {}
226 return std::move(Buffer);
253 std::unique_ptr<llvm::vfs::File>(std::move(Result)));
tools/clang/lib/Tooling/DependencyScanning/DependencyScanningTool.cpp 66 return std::move(Result);
tools/clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp 30 : DependencyFileGenerator(*Opts), Opts(std::move(Opts)), C(C) {}
52 : ProxyFileSystem(std::move(FS)) {}
77 DepFS(std::move(DepFS)), PPSkipMappings(PPSkipMappings) {}
84 CompilerInstance Compiler(std::move(PCHContainerOps));
85 Compiler.setInvocation(std::move(Invocation));
130 std::move(Compiler.getInvocation().getDependencyOutputOpts()));
135 std::make_shared<DependencyConsumerForwarder>(std::move(Opts),
tools/clang/lib/Tooling/Execution.cpp 44 return execute(std::move(Action), ArgumentsAdjuster());
52 Actions.emplace_back(std::move(Action), std::move(Adjuster));
52 Actions.emplace_back(std::move(Action), std::move(Adjuster));
81 return std::move(*Executor);
tools/clang/lib/Tooling/GuessTargetAndModeCompilationDatabase.cpp 20 : Base(std::move(Base)) {
53 return std::make_unique<TargetAndModeAdderDatabase>(std::move(Base));
tools/clang/lib/Tooling/Inclusions/HeaderIncludes.cpp 291 Iter->second.push_back(std::move(IncludeToAdd));
360 llvm::toString(std::move(Err));
tools/clang/lib/Tooling/InterpolatingCompilationDatabase.cpp 134 : Cmd(std::move(C)), Type(guessType(Cmd.Filename)),
136 std::vector<std::string> OldArgs = std::move(Cmd.CommandLine);
320 : OriginalPaths(std::move(Files)), Strings(Arena) {
505 : Inner(std::move(Inner)), Index(this->Inner->getAllFiles()) {}
540 return std::make_unique<InterpolatingCompilationDatabase>(std::move(Inner));
tools/clang/lib/Tooling/JSONCompilationDatabase.cpp 171 inferMissingCompileCommands(std::move(Base)))
207 new JSONCompilationDatabase(std::move(*DatabaseBuffer), Syntax));
220 new JSONCompilationDatabase(std::move(DatabaseBuffer), Syntax));
tools/clang/lib/Tooling/Refactoring.cpp 30 : ClangTool(Compilations, SourcePaths, std::move(PCHContainerOps)) {}
tools/clang/lib/Tooling/Refactoring/ASTSelection.cpp 56 SelectedASTNode Result = std::move(SelectionStack.back());
60 return std::move(Result);
134 SelectedASTNode Node = std::move(SelectionStack.back());
137 SelectionStack.back().Children.push_back(std::move(Node));
tools/clang/lib/Tooling/Refactoring/ASTSelectionRequirements.cpp 27 return std::move(*Selection);
38 std::make_unique<SelectedASTNode>(std::move(*ASTSelection));
45 Context.setASTSelection(std::move(StoredSelection));
46 return std::move(*CodeRange);
tools/clang/lib/Tooling/Refactoring/AtomicChange.cpp 162 return std::move(Err);
170 return std::move(Err);
190 return std::move(Err);
212 : Key(std::move(Key)), FilePath(std::move(FilePath)),
212 : Key(std::move(Key)), FilePath(std::move(FilePath)),
213 Error(std::move(Error)), InsertedHeaders(std::move(InsertedHeaders)),
213 Error(std::move(Error)), InsertedHeaders(std::move(InsertedHeaders)),
214 RemovedHeaders(std::move(RemovedHeaders)), Replaces(std::move(Replaces)) {
214 RemovedHeaders(std::move(RemovedHeaders)), Replaces(std::move(Replaces)) {
247 llvm::consumeError(std::move(Err));
271 std::move(Err), [&](const ReplacementError &RE) -> llvm::Error {
311 Replacements AllReplaces = std::move(*Replaces);
317 llvm::toString(std::move(Err)));
326 AllReplaces = std::move(*CleanReplaces);
tools/clang/lib/Tooling/Refactoring/Extract/Extract.cpp 93 return ExtractFunction(std::move(Code), DeclName);
172 return std::move(Err);
189 return std::move(Err);
194 return AtomicChanges{std::move(Change)};
tools/clang/lib/Tooling/Refactoring/Rename/RenamingAction.cpp 74 std::move(NewName));
100 return QualifiedRenameRule(ND, std::move(NewQualifiedName));
159 return std::move(Error);
161 Changes.push_back(std::move(Change));
163 return std::move(Changes);
176 << llvm::toString(std::move(Err)) << "\n";
tools/clang/lib/Tooling/Refactoring/Rename/USRLocFinder.cpp 84 SymbolOccurrences takeOccurrences() { return std::move(Occurrences); }
527 << llvm::toString(std::move(Err)) << "\n";
530 AtomicChanges.push_back(std::move(ReplaceChange));
tools/clang/lib/Tooling/RefactoringCallbacks.cpp 58 << toString(std::move(Err)) << "\n";
97 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
116 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
136 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
147 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
156 : FromId(FromId), Template(std::move(Template)) {}
195 new ReplaceNodeWithTemplate(FromId, std::move(ParsedTemplate)));
234 << "! " << llvm::toString(std::move(Err)) << "\n";
tools/clang/lib/Tooling/StandaloneExecution.cpp 34 : Tool(Compilations, SourcePaths, std::move(PCHContainerOps),
35 std::move(BaseFS)),
45 : OptionsParser(std::move(Options)),
47 std::move(PCHContainerOps)),
79 return std::make_unique<StandaloneToolExecutor>(std::move(OptionsParser));
tools/clang/lib/Tooling/Syntax/BuildTree.cpp 68 return cast<syntax::TranslationUnit>(std::move(Pending).finalize());
276 return std::move(Builder).finalize();
tools/clang/lib/Tooling/Syntax/Tokens.cpp 341 PP.addPPCallbacks(std::move(CB));
350 : Result(SM), CollectedExpansions(std::move(CollectedExpansions)), SM(SM),
352 Result.ExpandedTokens = std::move(Expanded);
385 return std::move(Result);
555 return Builder(std::move(Expanded), std::move(Expansions),
555 return Builder(std::move(Expanded), std::move(Expansions),
tools/clang/lib/Tooling/Syntax/Tree.cpp 19 : SourceMgr(SourceMgr), LangOpts(LangOpts), Tokens(std::move(Tokens)) {}
27 auto FID = SourceMgr.createFileID(std::move(Input));
128 return std::move(OS.str());
tools/clang/lib/Tooling/Tooling.cpp 81 *Diagnostics, std::move(VFS));
157 return runToolOnCodeWithArgs(std::move(ToolAction), Code,
159 "clang-tool", std::move(PCHContainerOps));
194 std::move(ToolAction), Files.get(), std::move(PCHContainerOps));
194 std::move(ToolAction), Files.get(), std::move(PCHContainerOps));
221 return runToolOnCodeWithArgs(std::move(ToolAction), Code, OverlayFileSystem,
280 : Action(std::move(Action)) {}
283 return std::move(Action);
292 : CommandLine(std::move(CommandLine)), Action(Action), OwnsAction(false),
293 Files(Files), PCHContainerOps(std::move(PCHContainerOps)) {}
299 : CommandLine(std::move(CommandLine)),
300 Action(new SingleFrontendActionFactory(std::move(FAction))),
302 PCHContainerOps(std::move(PCHContainerOps)) {}
357 return runInvocation(BinaryName, Compilation.get(), std::move(Invocation),
358 std::move(PCHContainerOps));
372 return Action->runInvocation(std::move(Invocation), Files,
373 std::move(PCHContainerOps), DiagConsumer);
381 CompilerInstance Compiler(std::move(PCHContainerOps));
382 Compiler.setInvocation(std::move(Invocation));
409 PCHContainerOps(std::move(PCHContainerOps)),
410 OverlayFileSystem(new llvm::vfs::OverlayFileSystem(std::move(BaseFS))),
429 ArgsAdjuster = combineAdjusters(std::move(ArgsAdjuster), std::move(Adjuster));
429 ArgsAdjuster = combineAdjusters(std::move(ArgsAdjuster), std::move(Adjuster));
476 AbsolutePaths.push_back(std::move(*AbsPath));
483 InitialWorkingDir = std::move(*CWD);
546 ToolInvocation Invocation(std::move(CommandLine), Action, Files.get(),
581 Invocation, std::move(PCHContainerOps),
589 ASTs.push_back(std::move(AST));
616 "clang-tool", std::move(PCHContainerOps));
635 &Action, Files.get(), std::move(PCHContainerOps));
643 return std::move(ASTs[0]);
tools/clang/lib/Tooling/Transformer/RangeSelector.cpp 171 return transformer::range(node(std::move(BeginID)), node(std::move(EndID)));
171 return transformer::range(node(std::move(BeginID)), node(std::move(EndID)));
235 RelativeSelector(std::string ID) : ID(std::move(ID)) {}
262 return RelativeSelector<CompoundStmt, getStatementsRange>(std::move(ID));
277 return RelativeSelector<CallExpr, getCallArgumentsRange>(std::move(ID));
291 return RelativeSelector<InitListExpr, getElementsRange>(std::move(ID));
304 return RelativeSelector<IfStmt, getElseRange>(std::move(ID));
tools/clang/lib/Tooling/Transformer/RewriteRule.cpp 51 T.Replacement = std::move(*Replacement);
52 Transformations.push_back(std::move(T));
59 E.TargetRange = std::move(S);
60 E.Replacement = std::move(Replacement);
67 std::move(M), std::move(Edits), std::move(Explanation), {}}}};
67 std::move(M), std::move(Edits), std::move(Explanation), {}}}};
67 std::move(M), std::move(Edits), std::move(Explanation), {}}}};
98 Matchers.push_back(*std::move(M));
tools/clang/lib/Tooling/Transformer/Stencil.cpp 47 explicit RawTextData(std::string T) : Text(std::move(T)) {}
53 explicit DebugPrintNodeData(std::string S) : Id(std::move(S)) {}
67 : Op(Op), Id(std::move(Id)) {}
74 explicit SelectorData(RangeSelector S) : Selector(std::move(S)) {}
81 : BaseId(BaseId), Member(std::move(Member)) {}
88 : Id(Id), TruePart(std::move(TruePart)), FalsePart(std::move(FalsePart)) {
88 : Id(Id), TruePart(std::move(TruePart)), FalsePart(std::move(FalsePart)) {
258 return transformer::selection(std::move(Selector));
263 Parts.push_back(std::move(Part));
271 return std::move(Err);
281 std::make_shared<StencilPartImpl<SelectorData>>(std::move(Selector)));
305 std::make_shared<StencilPartImpl<AccessData>>(BaseId, std::move(Member)));
311 Id, std::move(TruePart), std::move(FalsePart)));
311 Id, std::move(TruePart), std::move(FalsePart)));
317 std::move(Fn)));
tools/clang/lib/Tooling/Transformer/Transformer.cpp 54 Consumer(std::move(Err));
71 Consumer(std::move(AC));
tools/clang/tools/c-index-test/core_main.cpp 94 this->PP = std::move(PP);
229 std::move(CInvok), PCHContainerOps, Diags, IndexAction.get()));
tools/clang/tools/clang-diff/ClangDiff.cpp 78 std::move(Compilations));
83 Compilations = std::move(AdjustingCompilations);
111 return std::move(ASTs[0]);
tools/clang/tools/clang-format/ClangFormat.cpp 384 std::unique_ptr<llvm::MemoryBuffer> Code = std::move(CodeOrErr.get());
491 Code = std::move(CodeOrErr.get());
tools/clang/tools/clang-fuzzer/handle-cxx/handle_cxx.cpp 49 action->runInvocation(std::move(Invocation), Files.get(), PCHContainerOps,
tools/clang/tools/clang-fuzzer/handle-llvm/handle_llvm.cpp 156 EngineBuilder builder(std::move(M));
tools/clang/tools/clang-import-test/clang-import-test.cpp 201 Ins->setInvocation(std::move(Inv));
324 MultiplexConsumer Consumers(std::move(ASTConsumers));
328 return std::move(PE);
335 return std::move(CI);
358 llvm::errs() << llvm::toString(std::move(E));
361 ImportCIs.push_back(std::move(*ImportCI));
367 IndirectCIs.push_back(std::move(IndirectCI));
372 IndirectCIs.push_back(std::move(ImportCI));
377 llvm::errs() << llvm::toString(std::move(E));
tools/clang/tools/clang-offload-bundler/ClangOffloadBundler.cpp 407 : FileHandler(), Obj(std::move(ObjIn)),
681 InputBuffers.emplace_back(std::move(*CodeOrErr));
836 logAllUnhandledErrors(std::move(E), WithColor::error(errs(), argv[0]));
927 reportError(std::move(Err));
tools/clang/tools/clang-offload-wrapper/ClangOffloadWrapper.cpp 325 logAllUnhandledErrors(std::move(E), WithColor::error(errs(), argv[0]));
347 Buffers.emplace_back(std::move(*BufOrErr));
tools/clang/tools/clang-refactor/ClangRefactor.cpp 91 : TestSelections(std::move(TestSelections)) {}
115 : Range(std::move(Range)) {}
155 std::move(*ParsedTestSelection));
159 return std::make_unique<SourceRangeSelectionArgument>(std::move(*Range));
172 StringOptions[&Option] = std::move(CLOption);
259 Action(std::move(Action)), ActionRules(std::move(ActionRules)) {
259 Action(std::move(Action)), ActionRules(std::move(ActionRules)) {
321 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
324 llvm::cantFail(std::move(Err)); // This is a success.
365 std::move(Action), Action->createActiveActionRules(),
435 : Callback(std::move(Callback)) {}
444 : Callback(std::move(Callback)) {}
462 : Callback(std::move(Callback)) {}
620 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
tools/clang/tools/clang-refactor/TestSupport.cpp 128 void handleError(llvm::Error Err) override { handleResult(std::move(Err)); }
131 handleResult(std::move(Changes));
135 tooling::RefactoringResultConsumer::handle(std::move(Occurrences));
142 Results.back().push_back(std::move(Result));
198 CanonicalResult = std::move(*Result);
200 CanonicalErrorMessage = std::move(ErrorMessage);
386 TestRanges.GroupedRanges.push_back({Group.first, std::move(Group.second)});
387 return std::move(TestRanges);
tools/clang/tools/clang-scan-deps/ClangScanDeps.cpp 147 std::move(Compilations));
247 WorkerThreads.emplace_back(std::move(Worker));
tools/clang/tools/driver/cc1_main.cpp 282 llvm::BuryPointer(std::move(Clang));
tools/clang/tools/driver/cc1as_main.cpp 347 unsigned BufferIndex = SrcMgr.AddNewSourceBuffer(std::move(*Buffer), SMLoc());
456 Ctx, std::move(FOut), /*asmverbose*/ true,
457 /*useDwarfDirectory*/ true, IP, std::move(CE), std::move(MAB),
457 /*useDwarfDirectory*/ true, IP, std::move(CE), std::move(MAB),
479 T, Ctx, std::move(MAB), std::move(OW), std::move(CE), *STI,
479 T, Ctx, std::move(MAB), std::move(OW), std::move(CE), *STI,
479 T, Ctx, std::move(MAB), std::move(OW), std::move(CE), *STI,
tools/clang/tools/driver/cc1gen_reproducer_main.cpp 106 return std::move(OS.str());
tools/clang/tools/driver/driver.cpp 445 Diags.takeClient(), std::move(SerializedConsumer)));
tools/clang/tools/extra/clang-apply-replacements/lib/Tooling/ApplyReplacements.cpp 219 errs() << llvm::toString(std::move(Err)) << "\n";
tools/clang/tools/extra/clang-apply-replacements/tool/ClangApplyReplacementsMain.cpp 105 format::FormatStyle FormatStyle = std::move(*FormatStyleOrError);
tools/clang/tools/extra/clang-change-namespace/ChangeNamespace.cpp 152 llvm::consumeError(std::move(Err));
189 llvm_unreachable(llvm::toString(std::move(Err)).c_str());
tools/clang/tools/extra/clang-doc/BitcodeReader.cpp 370 I->Members.emplace_back(std::move(T));
375 I->Members.emplace_back(std::move(T));
380 I->ReturnType = std::move(T);
385 I->Params.emplace_back(std::move(T));
397 I->Type = std::move(R);
409 I->Type = std::move(R);
421 I->Type = std::move(R);
432 I->Namespace.emplace_back(std::move(R));
444 I->Namespace.emplace_back(std::move(R));
447 I->ChildNamespaces.emplace_back(std::move(R));
450 I->ChildRecords.emplace_back(std::move(R));
462 I->Namespace.emplace_back(std::move(R));
465 I->Parent = std::move(R);
476 I->Namespace.emplace_back(std::move(R));
479 I->Parents.emplace_back(std::move(R));
482 I->VirtualParents.emplace_back(std::move(R));
485 I->ChildRecords.emplace_back(std::move(R));
500 I->ChildFunctions.emplace_back(std::move(R));
504 I->ChildEnums.emplace_back(std::move(R));
508 I->ChildFunctions.emplace_back(std::move(R));
512 I->ChildEnums.emplace_back(std::move(R));
516 I->Bases.emplace_back(std::move(R));
520 I->ChildFunctions.emplace_back(std::move(R));
563 return joinErrors(std::move(Err), std::move(Skipped));
563 return joinErrors(std::move(Err), std::move(Skipped));
592 if (auto Err = addTypeInfo(I, std::move(TI)))
600 if (auto Err = addTypeInfo(I, std::move(TI)))
608 if (auto Err = addTypeInfo(I, std::move(TI)))
616 if (auto Err = addReference(I, std::move(R), CurrentReferenceField))
624 addChild(I, std::move(F));
631 addChild(I, std::move(BR));
638 addChild(I, std::move(E));
680 consumeError(std::move(Err));
728 return std::move(Err);
729 return std::unique_ptr<Info>{std::move(I)};
754 return std::move(Err);
784 Infos.emplace_back(std::move(InfoOrErr.get()));
789 return std::move(Err);
793 return std::move(Err);
798 consumeError(std::move(Err));
803 return std::move(Infos);
tools/clang/tools/extra/clang-doc/BitcodeWriter.cpp 298 Abbrevs.add(ID, Stream.EmitBlockInfoAbbrev(Block, std::move(Abbrev)));
tools/clang/tools/extra/clang-doc/HTMLGenerator.cpp 282 Out.emplace_back(std::move(LinkNode));
297 Out.emplace_back(std::move(ScriptNode));
358 AppendVector(std::move(Nodes), DivBody->Children);
388 AppendVector(std::move(Nodes), DivBody->Children);
412 ULBody->Children.emplace_back(std::move(LIBody));
431 ULBody->Children.emplace_back(std::move(LiNode));
453 Node->Children.emplace_back(std::move(LocNumberNode));
458 Node->Children.emplace_back(std::move(LocFileNode));
474 Out.emplace_back(std::move(MetaNode));
478 AppendVector(std::move(StylesheetsNodes), Out);
481 AppendVector(std::move(JsNodes), Out);
513 AppendVector(std::move(MainContentInnerNodes), MainContentNode->Children);
521 AppendVector(std::move(InfoIndexHTML), RightSidebarNode->Children);
523 MainNode->Children.emplace_back(std::move(LeftSidebarNode));
524 MainNode->Children.emplace_back(std::move(MainContentNode));
525 MainNode->Children.emplace_back(std::move(RightSidebarNode));
537 FooterNode->Children.emplace_back(std::move(SpanNode));
555 AppendVector(std::move(HeadNodes), F.Children);
556 F.Children.emplace_back(std::move(HeaderNode));
557 F.Children.emplace_back(std::move(MainNode));
558 F.Children.emplace_back(std::move(FooterNode));
594 AppendVector(std::move(Nodes), LiBody->Children);
595 UlBody->Children.emplace_back(std::move(LiBody));
606 FullComment->Children.emplace_back(std::move(Node));
608 return std::move(FullComment);
614 ParagraphComment->Children.emplace_back(std::move(Node));
618 return std::move(ParagraphComment);
631 CommentBlock->Children.emplace_back(std::move(Node));
652 Out.emplace_back(std::move(Node));
735 AppendVector(std::move(ChildNamespaces), Out);
738 AppendVector(std::move(ChildRecords), Out);
742 AppendVector(std::move(ChildFunctions), Out);
745 AppendVector(std::move(ChildEnums), Out);
788 AppendVector(std::move(VParents), PBody->Children);
790 AppendVector(std::move(Parents), PBody->Children);
792 AppendVector(std::move(Parents), PBody->Children);
794 AppendVector(std::move(VParents), PBody->Children);
800 AppendVector(std::move(Members), Out);
803 AppendVector(std::move(ChildRecords), Out);
807 AppendVector(std::move(ChildFunctions), Out);
810 AppendVector(std::move(ChildEnums), Out);
931 MainNode->Children.emplace_back(std::move(LeftSidebarNode));
956 AppendVector(std::move(HeadNodes), F.Children);
957 F.Children.emplace_back(std::move(HeaderNode));
958 F.Children.emplace_back(std::move(MainNode));
959 F.Children.emplace_back(std::move(FooterNode));
tools/clang/tools/extra/clang-doc/Representation.cpp 42 Tmp->merge(std::move(*static_cast<T *>(I.get())));
43 return std::move(Merged);
62 Children.push_back(std::move(ChildToMerge));
65 Children[mergeIdx].merge(std::move(ChildToMerge));
74 Children.push_back(std::move(ChildToMerge));
77 Children[mergeIdx].merge(std::move(ChildToMerge));
86 Children.push_back(std::move(ChildToMerge));
89 Children[mergeIdx].merge(std::move(ChildToMerge));
140 Namespace = std::move(Other.Namespace);
156 DefLoc = std::move(Other.DefLoc);
162 mergeBase(std::move(Other));
168 reduceChildren(ChildNamespaces, std::move(Other.ChildNamespaces));
169 reduceChildren(ChildRecords, std::move(Other.ChildRecords));
170 reduceChildren(ChildFunctions, std::move(Other.ChildFunctions));
171 reduceChildren(ChildEnums, std::move(Other.ChildEnums));
172 mergeBase(std::move(Other));
180 Members = std::move(Other.Members);
182 Bases = std::move(Other.Bases);
184 Parents = std::move(Other.Parents);
186 VirtualParents = std::move(Other.VirtualParents);
188 reduceChildren(ChildRecords, std::move(Other.ChildRecords));
189 reduceChildren(ChildFunctions, std::move(Other.ChildFunctions));
190 reduceChildren(ChildEnums, std::move(Other.ChildEnums));
191 SymbolInfo::merge(std::move(Other));
199 Members = std::move(Other.Members);
200 SymbolInfo::merge(std::move(Other));
210 ReturnType = std::move(Other.ReturnType);
212 Parent = std::move(Other.Parent);
214 Params = std::move(Other.Params);
215 SymbolInfo::merge(std::move(Other));
tools/clang/tools/extra/clang-doc/Representation.h 212 : LineNumber(LineNumber), Filename(std::move(Filename)) {}
214 : LineNumber(LineNumber), Filename(std::move(Filename)),
tools/clang/tools/extra/clang-doc/Serialize.cpp 477 BI.ChildFunctions.emplace_back(std::move(FI));
479 I.Bases.emplace_back(std::move(BI));
504 return {std::unique_ptr<Info>{std::move(I)}, nullptr};
512 return {std::unique_ptr<Info>{std::move(I)},
513 std::unique_ptr<Info>{std::move(ParentI)}};
545 return {std::unique_ptr<Info>{std::move(I)},
546 std::unique_ptr<Info>{std::move(ParentI)}};
553 return {std::unique_ptr<Info>{std::move(I)},
554 std::unique_ptr<Info>{std::move(ParentI)}};
580 ParentI->ChildFunctions.emplace_back(std::move(Func));
582 return {nullptr, std::unique_ptr<Info>{std::move(ParentI)}};
612 ParentI->ChildFunctions.emplace_back(std::move(Func));
614 return {nullptr, std::unique_ptr<Info>{std::move(ParentI)}};
634 ParentI->ChildEnums.emplace_back(std::move(Enum));
638 return {nullptr, std::unique_ptr<Info>{std::move(ParentI)}};
646 ParentI->ChildEnums.emplace_back(std::move(Enum));
649 return {nullptr, std::unique_ptr<Info>{std::move(ParentI)}};
654 ParentI->ChildEnums.emplace_back(std::move(Enum));
657 return {nullptr, std::unique_ptr<Info>{std::move(ParentI)}};
tools/clang/tools/extra/clang-doc/tool/ClangDocMain.cpp 247 << toString(std::move(Err)) << "\n";
249 llvm::errs() << toString(std::move(Err)) << "\n";
319 llvm::errs() << toString(std::move(Err)) << "\n";
331 llvm::errs() << toString(std::move(Err)) << "\n";
tools/clang/tools/extra/clang-include-fixer/FuzzySymbolIndex.cpp 25 std::move(Symbol));
tools/clang/tools/extra/clang-include-fixer/IncludeFixer.cpp 92 Compiler.setInvocation(std::move(Invocation));
143 Correction.addExtraDiagnostic(std::move(PD));
414 return std::move(Err);
420 auto Replaces = std::move(*CleanReplaces);
430 llvm::consumeError(std::move(Err));
tools/clang/tools/extra/clang-include-fixer/IncludeFixerContext.cpp 80 : FilePath(FilePath), QuerySymbolInfos(std::move(QuerySymbols)),
81 MatchedSymbols(std::move(Symbols)) {
tools/clang/tools/extra/clang-include-fixer/SymbolIndexManager.cpp 142 MatchedSymbols.push_back(std::move(SymAndSig));
153 Res.push_back(std::move(SymAndSig.Symbol));
tools/clang/tools/extra/clang-include-fixer/YamlSymbolIndex.h 37 : Symbols(std::move(Symbols)) {}
tools/clang/tools/extra/clang-include-fixer/plugin/IncludeFixerPlugin.cpp 28 : SymbolIndexMgr(std::move(SIM)) {}
79 return std::move(*SymbolIdx);
82 SymbolIndexMgr->addSymbolIndex(std::move(CreateYamlIdx));
tools/clang/tools/extra/clang-include-fixer/tool/ClangIncludeFixer.cpp 213 return std::move(*DB);
216 SymbolIndexMgr->addSymbolIndex(std::move(CreateYamlIdx));
230 return std::move(*DB);
284 Code = std::move(CodeOrErr.get());
tools/clang/tools/extra/clang-move/Move.cpp 79 return CleanPath(std::move(AbsolutePath));
444 CurrentNamespaces = std::move(NextNamespaces);
756 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
774 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
873 Context->FileToReplacements[NewFile] = std::move(AllCode);
tools/clang/tools/extra/clang-tidy/ClangTidy.cpp 150 << llvm::toString(std::move(Err)) << "\n";
214 Replacements = std::move(FormattedReplacements);
298 : MultiplexConsumer(std::move(Consumers)),
299 Profiling(std::move(Profiling)), Finder(std::move(Finder)),
299 Profiling(std::move(Profiling)), Finder(std::move(Finder)),
300 Checks(std::move(Checks)) {}
401 new ast_matchers::MatchFinder(std::move(FinderOptions)));
410 PP->addPPCallbacks(std::move(ModuleExpander));
436 Consumers.push_back(std::move(AnalysisConsumer));
440 std::move(Consumers), std::move(Profiling), std::move(Finder),
440 std::move(Consumers), std::move(Profiling), std::move(Finder),
440 std::move(Consumers), std::move(Profiling), std::move(Finder),
441 std::move(Checks));
tools/clang/tools/extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp 92 << llvm::toString(std::move(Err)) << "\n";
149 : DiagEngine(nullptr), OptionsProvider(std::move(OptionsProvider)),
726 return std::move(Errors);
tools/clang/tools/extra/clang-tidy/ClangTidyModule.cpp 20 Factories[Name] = std::move(Factory);
tools/clang/tools/extra/clang-tidy/ClangTidyOptions.cpp 208 OverrideOptions(OverrideOptions), FS(std::move(VFS)) {
tools/clang/tools/extra/clang-tidy/ClangTidyProfiling.cpp 80 : Storage(std::move(Storage)) {}
tools/clang/tools/extra/clang-tidy/GlobList.cpp 50 Items.push_back(std::move(Item));
tools/clang/tools/extra/clang-tidy/bugprone/ExceptionEscapeCheck.cpp 44 Tracer.ignoreExceptions(std::move(IgnoredExceptions));
tools/clang/tools/extra/clang-tidy/llvm/IncludeOrderCheck.cpp 91 IncludeDirectives[SM.getFileID(HashLoc)].push_back(std::move(ID));
tools/clang/tools/extra/clang-tidy/misc/UnusedUsingDeclsCheck.cpp 38 *Builder = std::move(Result);
tools/clang/tools/extra/clang-tidy/modernize/LoopConvertUtils.h 238 : Expression(E), Kind(Kind), Range(std::move(Range)) {}
tools/clang/tools/extra/clang-tidy/openmp/ExceptionEscapeCheck.cpp 37 Tracer.ignoreExceptions(std::move(IgnoredExceptions));
tools/clang/tools/extra/clang-tidy/plugin/ClangTidyPlugin.cpp 34 : MultiplexConsumer(std::move(Consumer)), Context(std::move(Context)),
34 : MultiplexConsumer(std::move(Consumer)), Context(std::move(Context)),
35 DiagEngine(std::move(DiagEngine)) {}
55 std::move(Context), std::move(DiagEngine), std::move(Vec));
55 std::move(Context), std::move(DiagEngine), std::move(Vec));
55 std::move(Context), std::move(DiagEngine), std::move(Vec));
72 Context = std::make_unique<ClangTidyContext>(std::move(Options));
tools/clang/tools/extra/clang-tidy/readability/IdentifierNamingCheck.cpp 876 Failure.Fixup = std::move(Fixup);
877 Failure.KindName = std::move(KindName);
911 Failure.Fixup = std::move(Fixup);
912 Failure.KindName = std::move(KindName);
tools/clang/tools/extra/clang-tidy/readability/InconsistentDeclarationParameterNameCheck.cpp 54 DifferingParams(std::move(DifferingParams)) {}
155 std::move(DifferingParams));
tools/clang/tools/extra/clang-tidy/tool/ClangTidyMain.cpp 304 OverrideOptions, std::move(FS));
320 std::move(Buffer.get()), /*DiagHandler*/ nullptr, OverlayFile);
428 ClangTidyContext Context(std::move(OwningOptionsProvider),
tools/clang/tools/extra/clang-tidy/utils/ExceptionAnalyzer.h 128 IgnoredExceptions = std::move(ExceptionNames);
tools/clang/tools/extra/clang-tidy/utils/TransformerClangTidyCheck.cpp 43 : ClangTidyCheck(Name, Context), Rule(std::move(R)) {
tools/clang/tools/extra/clangd/ClangdLSPServer.cpp 171 onCancel(std::move(Params));
173 Handler(std::move(Params));
193 Handler(std::move(Params), std::move(Reply));
193 Handler(std::move(Params), std::move(Reply));
210 ReplyHandler = std::move(ReplyCallbacks[Index].second);
230 ReplyHandler(std::move(Result));
234 ReplyHandler(std::move(Err));
247 (Server.*Handler)(P, std::move(Reply));
265 ReplyCallbacks.emplace_back(ID, std::move(Reply));
273 OldestCB = std::move(ReplyCallbacks.front());
325 ID(std::move(Other.ID)), Method(std::move(Other.Method)),
325 ID(std::move(Other.ID)), Method(std::move(Other.Method)),
361 Server->Transp.reply(std::move(ID), std::move(Reply));
361 Server->Transp.reply(std::move(ID), std::move(Reply));
368 Server->Transp.reply(std::move(ID), std::move(Err));
368 Server->Transp.reply(std::move(ID), std::move(Err));
413 RequestCancelers[StrID] = {std::move(Task.second), Cookie};
446 auto ID = MsgHandler->bindReply(std::move(CB));
449 Transp.call(Method, std::move(Params), ID);
455 Transp.notify(Method, std::move(Params));
486 std::move(BaseCDB));
551 {"codeActionProvider", std::move(CodeActionProvider)},
567 {"renameProvider", std::move(RenameProvider)},
587 Reply(std::move(Result));
650 Edit.edit = std::move(WE);
652 "workspace/applyEdit", std::move(Edit),
653 [Reply = std::move(Reply), SuccessMessage = std::move(SuccessMessage)](
653 [Reply = std::move(Reply), SuccessMessage = std::move(SuccessMessage)](
679 ApplyEdit(*Params.workspaceEdit, "Fix applied.", std::move(Reply));
688 auto Action = [this, ApplyEdit, Reply = std::move(Reply),
689 File = Params.tweakArgs->file, Code = std::move(*Code)](
708 return Reply(std::move(Err));
717 return ApplyEdit(std::move(WE), "Tweak applied.", std::move(Reply));
717 return ApplyEdit(std::move(WE), "Tweak applied.", std::move(Reply));
721 std::move(Action));
737 [Reply = std::move(Reply),
744 Reply(std::move(*Items));
751 std::move(Reply));
763 [File, Code, Params, Reply = std::move(Reply)](
859 Results.push_back(std::move(SI));
875 [this, FileURI, Reply = std::move(Reply)](
881 return Reply(std::move(*Items));
923 [Reply = std::move(Reply), File, Code = std::move(*Code),
923 [Reply = std::move(Reply), File, Code = std::move(*Code),
924 Selection = Params.range, FixIts = std::move(FixIts), this](
929 std::vector<CodeAction> Actions = std::move(FixIts);
939 Commands.push_back(std::move(*Command));
944 Server->enumerateTweaks(File.file(), Params.range, std::move(ConsumeActions));
956 [Reply = std::move(Reply),
966 LSPList.items.push_back(std::move(C));
968 return Reply(std::move(LSPList));
975 [Reply = std::move(Reply), this](
980 return Reply(std::move(*Signature));
987 return Reply(std::move(*Signature));
1015 [Params, Reply = std::move(Reply)](
1022 return Reply(std::vector<Location>{std::move(*Toggle)});
1025 Reply(std::move(Defs));
1034 [Params, Reply = std::move(Reply)](
1041 return Reply(std::vector<Location>{std::move(*Toggle)});
1042 Decls.push_back(std::move(S.PreferredDeclaration));
1044 Reply(std::move(Decls));
1053 [Reply = std::move(Reply),
1067 Params.position, std::move(Reply));
1073 [Reply = std::move(Reply), this](
1086 return Reply(std::move(R));
1089 return Reply(std::move(R));
1099 Params.resolve, Params.direction, std::move(Reply));
1106 std::move(Reply));
1119 tooling::CompileCommand(std::move(Entry.second.workingDirectory), File,
1120 std::move(Entry.second.compilationCommand),
1123 CDB->setCompileCommand(File, std::move(New));
1142 {"diagnostics", std::move(Diagnostics)},
1155 CCOpts.Limit, std::move(Reply));
1161 std::move(Reply));
1177 [Reply = std::move(Reply)](
1183 Result.emplace_back(render(std::move(*Ranges)));
1184 return Reply(std::move(Result));
1199 CompileCommandsDir(std::move(CompileCommandsDir)), ClangdServerOpts(Opts),
1244 elog("Transport error: {0}", std::move(Err));
1307 Old = std::move(FileToHighlightings[File]);
1308 FileToHighlightings[File] = std::move(HighlightingsCopy);
1328 LSPDiagnostics.push_back(std::move(Diag));
1339 publishDiagnostics(URI, std::move(LSPDiagnostics));
tools/clang/tools/extra/clangd/ClangdLSPServer.h 168 [CB = std::move(CB), Ctx = Context::current().clone()](
174 CB(std::move(Rsp));
181 callRaw(Method, std::move(Params), std::move(HandleReply));
181 callRaw(Method, std::move(Params), std::move(HandleReply));
tools/clang/tools/extra/clangd/ClangdServer.cpp 68 FIndex->updatePreamble(Path, Ctx, std::move(PP), CanonIncludes);
81 DiagConsumer.onDiagnosticsReady(Path, std::move(Diagnostics));
83 DiagConsumer.onHighlightingsReady(Path, std::move(Highlightings));
171 Inputs.Opts = std::move(Opts);
194 File = File.str(), CB = std::move(CB),
224 CB(std::move(Result));
243 std::move(Task));
250 CB = std::move(CB),
265 std::move(Action));
306 auto Action = [Pos, File = File.str(), CB = std::move(CB),
329 WorkScheduler.runWithAST("PrepareRename", File, std::move(Action));
335 CB = std::move(CB),
348 *Changes = std::move(*Formatted);
356 return CB(std::move(Edits));
359 WorkScheduler.runWithAST("Rename", File, std::move(Action));
375 auto Action = [File = File.str(), Sel, CB = std::move(CB),
386 CB(std::move(Res));
389 WorkScheduler.runWithAST("EnumerateTweaks", File, std::move(Action));
395 [File = File.str(), Sel, TweakID = TweakID.str(), CB = std::move(CB),
413 elog("Failed to format {0}: {1}", It.first(), std::move(Err));
415 return CB(std::move(*Effect));
417 WorkScheduler.runWithAST("ApplyTweak", File, std::move(Action));
422 auto Action = [Callback = std::move(Callback)](
437 WorkScheduler.runWithAST("DumpAST", File, std::move(Action));
442 auto Action = [Pos, CB = std::move(CB),
449 WorkScheduler.runWithAST("Definitions", File, std::move(Action));
462 return CB(std::move(CorrespondingFile));
463 auto Action = [Path = Path.str(), CB = std::move(CB),
469 WorkScheduler.runWithAST("SwitchHeaderSource", Path, std::move(Action));
493 [Pos, CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
499 WorkScheduler.runWithAST("Highlights", File, std::move(Action));
504 auto Action = [File = File.str(), Pos, CB = std::move(CB),
510 CB(clangd::getHover(InpAST->AST, Pos, std::move(Style), Index));
513 WorkScheduler.runWithAST("Hover", File, std::move(Action));
519 auto Action = [File = File.str(), Pos, Resolve, Direction, CB = std::move(CB),
527 WorkScheduler.runWithAST("Type Hierarchy", File, std::move(Action));
547 [Query = Query.str(), Limit, CB = std::move(CB), this]() mutable {
556 [CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
561 WorkScheduler.runWithAST("documentSymbols", File, std::move(Action));
566 auto Action = [Pos, Limit, CB = std::move(CB),
573 WorkScheduler.runWithAST("References", File, std::move(Action));
579 [Pos, CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
585 WorkScheduler.runWithAST("SymbolInfo", File, std::move(Action));
591 [Pos, CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
596 WorkScheduler.runWithAST("SemanticRanges", File, std::move(Action));
tools/clang/tools/extra/clangd/CodeComplete.cpp 334 std::move(*Spelled),
345 Completion.Includes.push_back(std::move(Include));
388 return std::move(Completion);
577 EnclosingAtFront.push_back(std::move(S));
685 CCTUInfo(CCAllocator), ResultsCallback(std::move(ResultsCallback)) {
907 SigHelp.signatures.push_back(std::move(SS.Signature));
930 Signature.parameters.push_back(std::move(Info));
1002 Result.Signature = std::move(Signature);
1053 VFS = Input.Preamble->StatCache->getConsumingFS(std::move(VFS));
1093 std::move(CI),
1096 std::move(ContentsBuffer), std::move(VFS), IgnoreDiags);
1096 std::move(ContentsBuffer), std::move(VFS), IgnoreDiags);
1119 Input.FileName, toString(std::move(Err)));
1161 return std::move(Syms).build();
1309 semaCodeComplete(std::move(RecorderOwner), Opts.getClangCompleteOpts(),
1364 IdentifierResults.push_back(std::move(ID));
1509 return std::move(ResultsBuilder).build();
1544 Bundles[Ret.first->second].push_back(std::move(C));
1547 Bundles.back().push_back(std::move(C));
1579 addCandidate(Top, std::move(Bundle));
1580 return std::move(Top).items();
1664 if (Candidates.push({std::move(Bundle), Scores}))
1744 ? std::move(Flow).runWithoutSema(Contents, *Offset, VFS)
1745 : std::move(Flow).run(
1770 {FileName, Command, Preamble, Contents, *Offset, std::move(VFS)});
tools/clang/tools/extra/clangd/CodeCompletionStrings.cpp 132 *RequiredQualifiers = std::move(*Signature);
tools/clang/tools/extra/clangd/Compiler.cpp 91 Clang->setInvocation(std::move(CI));
tools/clang/tools/extra/clangd/Context.cpp 18 : DataPtr(std::move(DataPtr)) {}
tools/clang/tools/extra/clangd/Context.h 126 std::move(Value))}));
134 /*Parent=*/std::move(DataPtr), &Key,
136 std::move(Value))}));
148 return std::move(*this).derive(Private, std::forward<Type>(Value));
166 TypedAnyStorage(T &&Value) : Value(std::move(Value)) {}
191 WithContext(Context C) : Restore(Context::swapCurrent(std::move(C))) {}
192 ~WithContext() { Context::swapCurrent(std::move(Restore)); }
208 : Restore(Context::current().derive(K, std::move(V))) {}
tools/clang/tools/extra/clangd/Diagnostics.cpp 249 return capitalize(std::move(Result));
265 return capitalize(std::move(Result));
363 Main.relatedInformation->push_back(std::move(RelInfo));
366 OutFn(std::move(Main), D.Fixes);
376 OutFn(std::move(Res), llvm::ArrayRef<Fix>());
421 Diag.Name = std::move(TidyDiag);
447 return std::move(Output);
582 LastDiag->Fixes.push_back(Fix{Message.str(), std::move(Edits)});
637 LastDiag->Notes.push_back(std::move(N));
649 Output.push_back(std::move(*LastDiag));
tools/clang/tools/extra/clangd/DraftStore.cpp 104 Contents = std::move(NewContents);
tools/clang/tools/extra/clangd/ExpectedTypes.cpp 81 OpaqueType::OpaqueType(std::string Data) : Data(std::move(Data)) {}
tools/clang/tools/extra/clangd/FS.cpp 36 StatCache.insert({PathStore, std::move(S)});
62 : ProxyFileSystem(std::move(FS)), StatCache(StatCache) {}
75 StatCache.update(getUnderlyingFS(), std::move(*S));
90 new CollectFS(std::move(FS), *this));
100 : ProxyFileSystem(std::move(FS)), StatCache(StatCache) {}
111 return llvm::IntrusiveRefCntPtr<CacheVFS>(new CacheVFS(std::move(FS), *this));
tools/clang/tools/extra/clangd/FSProvider.cpp 26 : ProxyFileSystem(std::move(FS)) {}
41 return std::unique_ptr<VolatileFile>(new VolatileFile(std::move(*File)));
48 : Wrapped(std::move(Wrapped)) {
tools/clang/tools/extra/clangd/FileDistance.cpp 174 Delegate.reset(new FileDistance(std::move(SchemeSources), Opts));
209 Sources[Path.first] = std::move(Param);
211 return FileDistance(std::move(Sources), Opts);
tools/clang/tools/extra/clangd/FindSymbols.cpp 123 Top.push({Score, std::move(Info)});
125 for (auto &R : std::move(Top).items())
126 Result.push_back(std::move(R.second));
209 Results.push_back(std::move(*Sym));
tools/clang/tools/extra/clangd/FormattedString.cpp 58 return "` " + std::move(R) + " `";
63 return "` " + std::move(R) + " `";
64 return "`" + std::move(R) + "`";
101 C.Contents = std::move(Code);
102 C.Language = std::move(Language);
103 Chunks.push_back(std::move(C));
109 C.Contents = std::move(Code);
110 Chunks.push_back(std::move(C));
tools/clang/tools/extra/clangd/Function.h 49 *this = std::move(Other);
77 Listeners.push_back({std::move(L), ++ListenerCount});
tools/clang/tools/extra/clangd/GlobalCompilationDatabase.cpp 87 llvm::sys::path::filename(File), std::move(Argv),
96 : CompileCommandsDir(std::move(CompileCommandsDir)) {}
115 return std::move(Candidates.front());
212 OnCommandChanged.broadcast(std::move(AllFiles));
250 OnCommandChanged.broadcast(std::move(GovernedFiles));
267 : Base(Base), ResourceDir(ResourceDir ? std::move(*ResourceDir)
269 FallbackFlags(std::move(FallbackFlags)) {
312 Commands[CanonPath] = std::move(*Cmd);
tools/clang/tools/extra/clangd/GlobalCompilationDatabase.h 56 return OnCommandChanged.observe(std::move(L));
tools/clang/tools/extra/clangd/Headers.cpp 89 return HeaderFile{std::move(*IncludePath), /*Verbatim=*/true};
94 return HeaderFile{std::move(*Resolved), /*Verbatim=*/false};
tools/clang/tools/extra/clangd/IncludeFixer.cpp 59 return std::move(Visited);
159 std::move(*Spelled),
179 {std::move(*Edit)}});
366 LastUnresolvedName = std::move(Unresolved);
421 auto Syms = std::move(Matches).build();
422 auto E = FuzzyFindCache.try_emplace(ReqStr, std::move(Syms));
442 auto Syms = std::move(Matches).build();
451 auto E = LookupCache.try_emplace(ID, std::move(Syms));
tools/clang/tools/extra/clangd/IncludeFixer.h 39 : File(File), Inserter(std::move(Inserter)), Index(Index),
tools/clang/tools/extra/clangd/JSONTransport.cpp 21 std::move(E), [&](const LSPError &L) -> llvm::Error {
26 Message = llvm::toString(std::move(Unhandled));
29 {"message", std::move(Message)},
37 return llvm::make_error<LSPError>(std::move(Msg), ErrorCode(*Code));
38 return llvm::make_error<llvm::StringError>(std::move(Msg),
53 {"params", std::move(Params)},
60 {"id", std::move(ID)},
62 {"params", std::move(Params)},
70 {"id", std::move(ID)},
71 {"result", std::move(*Result)},
76 {"id", std::move(ID)},
90 if (!handleMessage(std::move(*Doc), Handler))
143 ID = std::move(*I);
151 return Handler.onReply(std::move(*ID), decodeError(*Err));
155 Result = std::move(*R);
156 return Handler.onReply(std::move(*ID), std::move(Result));
156 return Handler.onReply(std::move(*ID), std::move(Result));
161 Params = std::move(*P);
164 return Handler.onCall(*Method, std::move(Params), std::move(*ID));
164 return Handler.onCall(*Method, std::move(Params), std::move(*ID));
166 return Handler.onNotify(*Method, std::move(Params));
259 return std::move(JSON);
287 return std::move(JSON); // Including at EOF
tools/clang/tools/extra/clangd/Logger.h 42 return fmt_consume(std::move(V));
tools/clang/tools/extra/clangd/ParsedAST.cpp 94 std::vector<Decl *> takeTopLevelDecls() { return std::move(TopLevelDecls); }
235 auto Clang = prepareCompilerInstance(std::move(CI), PreamblePCH,
236 std::move(Buffer), VFS, ASTDiags);
368 toString(std::move(Err)));
373 syntax::TokenBuffer Tokens = std::move(CollectTokens).consume();
403 return ParsedAST(std::move(Preamble), std::move(Clang), std::move(Action),
403 return ParsedAST(std::move(Preamble), std::move(Clang), std::move(Action),
403 return ParsedAST(std::move(Preamble), std::move(Clang), std::move(Action),
404 std::move(Tokens), std::move(Macros), std::move(ParsedDecls),
404 std::move(Tokens), std::move(Macros), std::move(ParsedDecls),
404 std::move(Tokens), std::move(Macros), std::move(ParsedDecls),
405 std::move(Diags), std::move(Includes),
405 std::move(Diags), std::move(Includes),
406 std::move(CanonIncludes));
495 : Preamble(std::move(Preamble)), Clang(std::move(Clang)),
495 : Preamble(std::move(Preamble)), Clang(std::move(Clang)),
496 Action(std::move(Action)), Tokens(std::move(Tokens)),
496 Action(std::move(Action)), Tokens(std::move(Tokens)),
497 Macros(std::move(Macros)), Diags(std::move(Diags)),
497 Macros(std::move(Macros)), Diags(std::move(Diags)),
498 LocalTopLevelDecls(std::move(LocalTopLevelDecls)),
499 Includes(std::move(Includes)), CanonIncludes(std::move(CanonIncludes)) {
499 Includes(std::move(Includes)), CanonIncludes(std::move(CanonIncludes)) {
514 VFS = Preamble->StatCache->getConsumingFS(std::move(VFS));
525 std::move(VFS), Inputs.Index, Inputs.Opts);
tools/clang/tools/extra/clangd/Preamble.cpp 32 IncludeStructure takeIncludes() { return std::move(Includes); }
34 MainFileMacros takeMacros() { return std::move(Macros); }
36 CanonicalIncludes takeCanonicalIncludes() { return std::move(CanonIncludes); }
83 : Preamble(std::move(Preamble)), Diags(std::move(Diags)),
83 : Preamble(std::move(Preamble)), Diags(std::move(Diags)),
84 Includes(std::move(Includes)), Macros(std::move(Macros)),
84 Includes(std::move(Includes)), Macros(std::move(Macros)),
85 StatCache(std::move(StatCache)), CanonIncludes(std::move(CanonIncludes)) {
85 StatCache(std::move(StatCache)), CanonIncludes(std::move(CanonIncludes)) {
151 std::move(*BuiltPreamble), std::move(Diags),
151 std::move(*BuiltPreamble), std::move(Diags),
153 SerializedDeclsCollector.takeMacros(), std::move(StatCache),
tools/clang/tools/extra/clangd/Protocol.cpp 42 return URIForFile(std::move(*Resolved));
50 return URIForFile(std::move(*Resolved));
71 R = std::move(*U);
472 return std::move(Diag);
583 return llvm::json::Value(std::move(Result));
609 return std::move(Cmd);
626 return std::move(CodeAction);
646 return llvm::json::Value(std::move(Result));
655 return llvm::json::Object{{"changes", std::move(FileChanges)}};
758 return std::move(Result);
829 return std::move(Result);
860 return std::move(Result);
871 return std::move(Result);
995 return std::move(Result);
1072 {"lines", std::move(Highlighting.Lines)},
tools/clang/tools/extra/clangd/Protocol.h 62 : Message(std::move(Message)), Code(Code) {}
111 explicit URIForFile(std::string &&File) : File(std::move(File)) {}
tools/clang/tools/extra/clangd/Quality.h 156 : N(N), Greater(std::move(Greater)) {}
166 Heap.back() = std::move(V);
170 Heap.push_back(std::move(V));
182 return std::move(Heap);
tools/clang/tools/extra/clangd/QueryDriverDatabase.cpp 206 Base(std::move(Base)) {
281 std::move(Base));
tools/clang/tools/extra/clangd/RIFF.cpp 37 return std::move(C);
66 return std::move(F);
tools/clang/tools/extra/clangd/Selection.cpp 144 return std::move(OS.str());
178 return std::move(V.Nodes);
223 push(std::move(N));
340 Nodes.back().ASTNode = std::move(Node);
459 return std::move(OS.str());
tools/clang/tools/extra/clangd/SourceCode.cpp 719 return formatReplacements(Code, std::move(*CleanReplaces), Style);
790 Event.Pos = std::move(P);
870 Event.Payload = std::move(NSName);
905 Current = std::move(Event.Payload);
1052 E.Replacements = std::move(*NewEdits);
1078 Enclosing.emplace_back(std::move(Event.Payload));
1086 CurrentNamespace = std::move(Enclosing.back());
1101 ER.EligiblePoints.emplace_back(std::move(Event.Pos));
tools/clang/tools/extra/clangd/SourceCode.h 215 : Replacements(std::move(Reps)), InitialCode(Code) {}
tools/clang/tools/extra/clangd/TUScheduler.cpp 109 LRU.insert(LRU.begin(), {K, std::move(V)});
113 std::unique_ptr<ParsedAST> ForCleanup = std::move(LRU.back().second);
128 std::unique_ptr<ParsedAST> V = std::move(Existing->second);
133 return llvm::Optional<std::unique_ptr<ParsedAST>>(std::move(V));
291 : Worker(std::move(Worker)) {
338 return ASTWorkerHandle(std::move(Worker));
356 FileInputs = std::move(Inputs);
422 Callbacks.onFailedAST(FileName, std::move(CompilerInvocationDiags),
437 Callbacks.onPreambleAST(FileName, Ctx, std::move(PP), CanonIncludes);
489 buildAST(FileName, std::move(Invocation), CompilerInvocationDiags,
491 AST = NewAST ? std::make_unique<ParsedAST>(std::move(*NewAST)) : nullptr;
521 IdleASTs.put(this, std::move(*AST));
523 startTask(TaskName, std::move(Task), WantDiags);
529 auto Task = [=, Action = std::move(Action)]() mutable {
546 AST = NewAST ? std::make_unique<ParsedAST>(std::move(*NewAST)) : nullptr;
550 [&AST, this]() { IdleASTs.put(this, std::move(*AST)); });
557 startTask(Name, std::move(Task), /*UpdateType=*/None);
582 Request{[Callback = std::move(Callback), this]() mutable {
643 {std::move(Task), Name, steady_clock::now(),
651 Status.Action = std::move(Action);
693 Req = std::move(Requests.front());
703 WithContext Guard(std::move(Req.Ctx));
734 Request R = std::move(*I);
736 Requests.push_front(std::move(R));
852 Callbacks(Callbacks ? move(Callbacks)
895 new FileData{Inputs.Contents, std::move(Worker)});
899 FD->Worker->update(std::move(Inputs), WantDiags);
924 Action = std::move(Action)]() mutable {
925 WithContext WC(std::move(Ctx));
940 It->second->Worker->runWithAST(Name, std::move(Action));
971 [Promise = std::move(Promise)](
973 Promise.set_value(std::move(Preamble));
982 ConsistentPreamble = std::move(ConsistentPreamble),
983 Action = std::move(Action), this]() mutable {
998 WithContext Guard(std::move(Ctx));
1005 std::move(Task));
tools/clang/tools/extra/clangd/Threading.cpp 95 Name.str(), std::move(Action), std::move(CleanupTask))
95 Name.str(), std::move(Action), std::move(CleanupTask))
tools/clang/tools/extra/clangd/Threading.h 128 WithContext WithCtx(std::move(Ctx));
131 std::move(Action), Context::current().clone());
tools/clang/tools/extra/clangd/Trace.cpp 68 llvm::json::Object{{"name", Name}, {"args", std::move(Args)}});
123 llvm::json::Object{{"name", std::move(Name)},
124 {"args", std::move(*Args)},
tools/clang/tools/extra/clangd/URI.cpp 220 return std::move(*URI);
230 return std::move(*U);
tools/clang/tools/extra/clangd/XRefs.cpp 102 LSPLoc.uri = std::move(*U);
257 return {std::move(File)};
275 Result.push_back(std::move(Macro));
374 return std::move(References);
407 return std::move(RefFinder).take();
437 Result.push_back(std::move(DH));
564 TempParameters.push_back(std::move(P));
953 Results.push_back(std::move(Result));
977 Results.push_back(std::move(*LSPLoc));
1010 Results.push_back(std::move(NewSymbol));
1022 Results.push_back(std::move(NewMacro));
1105 return std::move(THI);
1121 SubTypes.emplace_back(std::move(*ChildSym));
1148 SuperTypes.emplace_back(std::move(*ParentSym));
tools/clang/tools/extra/clangd/index/Background.cpp 142 CDB(CDB), BackgroundContext(std::move(BackgroundContext)),
144 IndexStorageFactory(std::move(IndexStorageFactory)),
172 auto NeedsReIndexing = loadProject(std::move(ChangedFiles));
179 Tasks.push_back(indexFileTask(std::move(Cmd)));
180 Queue.append(std::move(Tasks));
199 if (auto Error = index(std::move(Cmd)))
200 elog("Indexing {0} failed: {1}", FileName, std::move(Error));
297 auto SS = std::make_unique<SymbolSlab>(std::move(Syms).build());
298 auto RS = std::make_unique<RefSlab>(std::move(Refs).build());
299 auto RelS = std::make_unique<RelationSlab>(std::move(Relations).build());
320 std::move(Error));
337 IndexedSymbols.update(Path, std::move(SS), std::move(RS), std::move(RelS),
337 IndexedSymbols.update(Path, std::move(SS), std::move(RS), std::move(RelS),
337 IndexedSymbols.update(Path, std::move(SS), std::move(RS), std::move(RelS),
363 Inputs.FS = std::move(FS);
365 Inputs.CompileCommand = std::move(Cmd);
371 auto Clang = prepareCompilerInstance(std::move(CI), /*Preamble=*/nullptr,
372 std::move(*Buf), Inputs.FS, IgnoreDiags);
400 IndexOpts, [&](SymbolSlab S) { Index.Symbols = std::move(S); },
401 [&](RefSlab R) { Index.Refs = std::move(R); },
402 [&](RelationSlab R) { Index.Relations = std::move(R); },
403 [&](IncludeGraph IG) { Index.Sources = std::move(IG); });
437 update(AbsolutePath, std::move(Index), ShardVersionsSnapshot, HadErrors);
463 ? std::make_unique<SymbolSlab>(std::move(*LS.Shard->Symbols))
466 ? std::make_unique<RefSlab>(std::move(*LS.Shard->Refs))
470 ? std::make_unique<RelationSlab>(std::move(*LS.Shard->Relations))
477 IndexedSymbols.update(LS.AbsolutePath, std::move(SS), std::move(RS),
477 IndexedSymbols.update(LS.AbsolutePath, std::move(SS), std::move(RS),
478 std::move(RelS), LS.CountReferences);
506 NeedsReIndexing.emplace_back(std::move(*Cmd));
tools/clang/tools/extra/clangd/index/Background.h 71 explicit Task(std::function<void()> Run) : Run(std::move(Run)) {}
tools/clang/tools/extra/clangd/index/BackgroundIndexLoader.cpp 70 LS.Shard = std::move(Shard);
117 Result.push_back(std::move(It.getValue()));
131 return std::move(Loader).takeResult();
tools/clang/tools/extra/clangd/index/BackgroundIndexStorage.cpp 67 return std::make_unique<IndexFileIn>(std::move(*I));
108 GetProjectInfo(std::move(GetProjectInfo)) {
148 return DiskBackedIndexStorageManager(std::move(GetProjectInfo));
tools/clang/tools/extra/clangd/index/BackgroundQueue.cpp 33 Task = std::move(Queue.back());
71 Queue.push_back(std::move(T));
tools/clang/tools/extra/clangd/index/BackgroundRebuild.cpp 130 Target->reset(std::move(NewIndex));
tools/clang/tools/extra/clangd/index/FileIndex.cpp 59 SymbolCollector Collector(std::move(CollectorOpts));
76 return std::make_tuple(std::move(Syms), std::move(Refs),
76 return std::make_tuple(std::move(Syms), std::move(Refs),
77 std::move(Relations));
91 return indexSymbols(AST, std::move(PP), DeclsToIndex, Includes,
103 FileToSymbols[Path] = std::move(Symbols);
109 Item.Slab = std::move(Refs);
110 FileToRefs[Path] = std::move(Item);
115 FileToRelations[Path] = std::move(Relations);
160 SymsStorage.push_back(std::move(Sym.second));
221 llvm::make_pointee_range(AllSymbols), std::move(AllRefs),
222 std::move(AllRelations),
223 std::make_tuple(std::move(SymbolSlabs), std::move(RefSlabs),
223 std::make_tuple(std::move(SymbolSlabs), std::move(RefSlabs),
224 std::move(RefsStorage), std::move(SymsStorage)),
224 std::move(RefsStorage), std::move(SymsStorage)),
228 llvm::make_pointee_range(AllSymbols), std::move(AllRefs),
229 std::move(AllRelations),
230 std::make_tuple(std::move(SymbolSlabs), std::move(RefSlabs),
230 std::make_tuple(std::move(SymbolSlabs), std::move(RefSlabs),
231 std::move(RefsStorage), std::move(SymsStorage)),
231 std::move(RefsStorage), std::move(SymsStorage)),
245 auto Slabs = indexHeaderSymbols(AST, std::move(PP), Includes);
247 Path, std::make_unique<SymbolSlab>(std::move(std::get<0>(Slabs))),
249 std::make_unique<RelationSlab>(std::move(std::get<2>(Slabs))),
259 Path, std::make_unique<SymbolSlab>(std::move(std::get<0>(Contents))),
260 std::make_unique<RefSlab>(std::move(std::get<1>(Contents))),
261 std::make_unique<RelationSlab>(std::move(std::get<2>(Contents))),
tools/clang/tools/extra/clangd/index/Index.cpp 25 Pin = std::move(this->Index);
26 this->Index = std::move(Index);
tools/clang/tools/extra/clangd/index/Index.h 130 : Index(std::move(Index)) {}
tools/clang/tools/extra/clangd/index/IndexAction.cpp 79 Node.Digest = std::move(*Digest);
138 Includes(std::move(Includes)), Opts(Opts),
186 IncludeGraphCallback(std::move(IG));
224 std::make_shared<SymbolCollector>(std::move(Opts)), std::move(Includes),
224 std::make_shared<SymbolCollector>(std::move(Opts)), std::move(Includes),
tools/clang/tools/extra/clangd/index/MemIndex.cpp 23 auto Data = std::make_pair(std::move(Slab), std::move(Refs));
23 auto Data = std::make_pair(std::move(Slab), std::move(Refs));
25 std::move(Data), BackingDataSize);
53 auto Results = std::move(Top).items();
tools/clang/tools/extra/clangd/index/MemIndex.h 43 std::make_shared<Payload>(std::move(BackingData)), nullptr);
tools/clang/tools/extra/clangd/index/Merge.cpp 49 SymbolSlab Dyn = std::move(DynB).build();
tools/clang/tools/extra/clangd/index/Ref.cpp 42 M.insert(std::move(R));
56 return RefSlab(std::move(Result), std::move(Arena), NumRefs);
56 return RefSlab(std::move(Result), std::move(Arena), NumRefs);
tools/clang/tools/extra/clangd/index/Ref.h 110 : Arena(std::move(Arena)), Refs(std::move(Refs)), NumRefs(NumRefs) {}
110 : Arena(std::move(Arena)), Refs(std::move(Refs)), NumRefs(NumRefs) {}
tools/clang/tools/extra/clangd/index/Relation.cpp 35 return RelationSlab{std::move(Relations)};
tools/clang/tools/extra/clangd/index/Relation.h 84 : Relations(std::move(Relations)) {}
tools/clang/tools/extra/clangd/index/Serialization.cpp 211 return std::move(E);
227 return std::move(Table);
454 Entry->getValue() = std::move(IGN);
472 Result.Symbols = std::move(Symbols).build();
484 Result.Refs = std::move(Refs).build();
495 Result.Relations = std::move(Relations).build();
509 return std::move(Result);
656 return std::move(*YAMLContents);
679 Symbols = std::move(*I->Symbols);
681 Refs = std::move(*I->Refs);
683 Relations = std::move(*I->Relations);
695 auto Index = UseDex ? dex::Dex::build(std::move(Symbols), std::move(Refs),
695 auto Index = UseDex ? dex::Dex::build(std::move(Symbols), std::move(Refs),
696 std::move(Relations))
697 : MemIndex::build(std::move(Symbols), std::move(Refs),
697 : MemIndex::build(std::move(Symbols), std::move(Refs),
698 std::move(Relations));
tools/clang/tools/extra/clangd/index/Symbol.cpp 59 SortedSymbols.push_back(std::move(Entry.second));
67 return SymbolSlab(std::move(NewArena), std::move(SortedSymbols));
67 return SymbolSlab(std::move(NewArena), std::move(SortedSymbols));
tools/clang/tools/extra/clangd/index/Symbol.h 229 : Arena(std::move(Arena)), Symbols(std::move(Symbols)) {}
229 : Arena(std::move(Arena)), Symbols(std::move(Symbols)) {}
tools/clang/tools/extra/clangd/index/SymbolCollector.cpp 192 SymbolCollector::SymbolCollector(Options Opts) : Opts(std::move(Opts)) {}
329 BasicSymbol = addDeclaration(*ND, std::move(*ID), IsMainFileOnly);
335 BasicSymbol = addDeclaration(*OriginalDecl, std::move(*ID), IsMainFileOnly);
389 S.ID = std::move(*ID);
557 S.ID = std::move(ID);
tools/clang/tools/extra/clangd/index/SymbolCollector.h 98 this->PP = std::move(PP);
111 SymbolSlab takeSymbols() { return std::move(Symbols).build(); }
112 RefSlab takeRefs() { return std::move(Refs).build(); }
113 RelationSlab takeRelations() { return std::move(Relations).build(); }
tools/clang/tools/extra/clangd/index/YAMLSerialization.cpp 382 Result.Symbols.emplace(std::move(Symbols).build());
383 Result.Refs.emplace(std::move(Refs).build());
384 Result.Relations.emplace(std::move(Relations).build());
385 return std::move(Result);
tools/clang/tools/extra/clangd/index/dex/Dex.cpp 31 auto Data = std::make_pair(std::move(Symbols), std::move(Refs));
31 auto Data = std::make_pair(std::move(Symbols), std::move(Refs));
32 return std::make_unique<Dex>(Data.first, Data.second, Rels, std::move(Data),
139 Corpus.boost(std::move(It), PathProximitySignals.evaluate()));
143 return Corpus.unionOf(std::move(BoostingIterators));
157 return Corpus.unionOf(std::move(BoostingIterators));
181 Criteria.push_back(Corpus.intersect(move(TrigramIterators)));
190 Criteria.push_back(Corpus.unionOf(move(ScopeIterators)));
202 auto Root = Corpus.intersect(move(Criteria));
207 Root = Corpus.limit(move(Root), *Req.Limit * 100);
237 for (const auto &Item : std::move(Top).items())
tools/clang/tools/extra/clangd/index/dex/Dex.h 66 std::make_shared<Payload>(std::move(BackingData)), nullptr);
tools/clang/tools/extra/clangd/index/dex/Iterator.cpp 28 : Iterator(Kind::And), Children(std::move(AllChildren)) {
137 : Iterator(Kind::Or), Children(std::move(AllChildren)) {
284 : Child(std::move(Child)), Factor(Factor) {}
314 : Child(std::move(Child)), Limit(Limit), ItemsLeft(Limit) {}
365 return std::move(Child); // Intersection is empty.
374 RealChildren.push_back(std::move(Child));
381 return std::move(RealChildren.front());
383 return std::make_unique<AndIterator>(std::move(RealChildren));
404 RealChildren.push_back(std::move(Child));
411 return std::move(RealChildren.front());
413 return std::make_unique<OrIterator>(std::move(RealChildren));
431 return std::make_unique<BoostIterator>(std::move(Child), Factor);
438 return std::make_unique<LimitIterator>(std::move(Child), Limit);
tools/clang/tools/extra/clangd/index/dex/Iterator.h 128 Children.push_back(move(Head));
129 populateChildren(Children, move(Tail)...);
182 return intersect(move(Children));
190 return unionOf(move(Children));
tools/clang/tools/extra/clangd/indexer/IndexerMain.cpp 77 Result.Symbols = std::move(Symbols).build();
78 Result.Refs = std::move(Refs).build();
79 Result.Relations = std::move(Relations).build();
125 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
tools/clang/tools/extra/clangd/refactor/Rename.cpp 196 return std::move(Err);
tools/clang/tools/extra/clangd/refactor/Tweak.cpp 68 Available.push_back(std::move(T));
89 return std::move(T);
95 Edit Ed(SM.getBufferData(FID), std::move(Replacements));
97 return std::make_pair(*FilePath, std::move(Ed));
107 auto PathAndEdit = fileEdit(SM, SM.getMainFileID(), std::move(Replacements));
tools/clang/tools/extra/clangd/refactor/tweaks/AnnotateHighlightings.cpp 72 return std::move(Err);
74 return Effect::mainFileEdit(SM, std::move(Result));
tools/clang/tools/extra/clangd/refactor/tweaks/DefineInline.cpp 200 elog("define inline: Failed to add quals: {0}", std::move(Err));
361 Edits.push_back(std::move(*FE));
371 Edits.push_back(std::move(*FE));
375 return std::move(Err);
380 E.ApplyEdits.try_emplace(std::move(Pair.first), std::move(Pair.second));
380 E.ApplyEdits.try_emplace(std::move(Pair.first), std::move(Pair.second));
tools/clang/tools/extra/clangd/refactor/tweaks/DumpAST.cpp 64 return Effect::showMessage(std::move(OS.str()));
121 return Effect::showMessage(std::move(OS.str()));
tools/clang/tools/extra/clangd/refactor/tweaks/ExpandMacro.cpp 125 return Effect::mainFileEdit(SM, std::move(Reps));
tools/clang/tools/extra/clangd/refactor/tweaks/ExtractFunction.cpp 522 return std::move(Visitor.Info);
650 ExtZone = std::move(*MaybeExtZone);
665 return std::move(Err);
667 return std::move(Err);
668 return Effect::mainFileEdit(SM, std::move(Result));
tools/clang/tools/extra/clangd/refactor/tweaks/ExtractVariable.cpp 467 return std::move(Err);
470 return std::move(Err);
471 return Effect::mainFileEdit(Inputs.AST.getSourceManager(), std::move(Result));
tools/clang/tools/extra/clangd/refactor/tweaks/RawStringLiteral.cpp 96 return Effect::mainFileEdit(SM, std::move(Reps));
tools/clang/tools/extra/clangd/refactor/tweaks/RemoveUsingNamespace.cpp 189 return std::move(Err);
196 return std::move(Err);
198 return Effect::mainFileEdit(SM, std::move(R));
tools/clang/tools/extra/clangd/refactor/tweaks/SwapIfBranches.cpp 88 return std::move(Err);
92 return std::move(Err);
93 return Effect::mainFileEdit(SrcMgr, std::move(Result));
tools/clang/tools/extra/clangd/tool/ClangdMain.cpp 591 Placeholder->reset(std::move(Idx));
657 Opts.QueryDriverGlobs = std::move(QueryDriverGlobs);
tools/clang/tools/extra/clangd/unittests/BackgroundIndexTests.cpp 77 return std::make_unique<IndexFileIn>(std::move(*IndexFile));
590 Source.update("", std::make_unique<SymbolSlab>(std::move(SB).build()),
tools/clang/tools/extra/clangd/unittests/CancellationTests.cpp 17 WithContext ContextWithCancellation(std::move(Task.first));
27 ContextWithCancellation.emplace(std::move(Task.first));
38 WithContext ContextWithCancellation(std::move(Task.first));
51 WithContext ContextGuard(std::move(Ctx));
56 std::thread AsyncTask(TaskToBeCancelled, std::move(Task.first));
tools/clang/tools/extra/clangd/unittests/ClangdTests.cpp 615 return std::move(Stats);
774 : StartSecondReparse(std::move(StartSecondReparse)) {}
819 NoConcurrentAccessDiagConsumer DiagConsumer(std::move(StartSecondPromise));
908 : ProxyFileSystem(std::move(FS)), CountStats(CountStats) {}
1047 FileName, std::move(CommandLine), "")};
tools/clang/tools/extra/clangd/unittests/CodeCompleteTests.cpp 83 return Contains(Named(std::move(Name)));
87 return Contains(AllOf(Named(std::move(Name)), Kind(K)));
96 return MemIndex::build(std::move(Slab).build(), RefSlab(), RelationSlab());
106 OverrideIndex = memIndex(std::move(IndexSymbols));
124 OverrideIndex = memIndex(std::move(IndexSymbols));
146 return completions(Server, Text, std::move(IndexSymbols), std::move(Opts),
146 return completions(Server, Text, std::move(IndexSymbols), std::move(Opts),
159 OverrideIndex = memIndex(std::move(IndexSymbols));
1027 return signatures(Test.code(), Test.point(), std::move(IndexSymbols));
1184 auto Reqs = std::move(Requests);
tools/clang/tools/extra/clangd/unittests/ContextTests.cpp 32 Context NewCtx = std::move(Ctx);
tools/clang/tools/extra/clangd/unittests/DexTests.cpp 119 auto And = C.intersect(std::move(Empty1), std::move(Empty2));
119 auto And = C.intersect(std::move(Empty1), std::move(Empty2));
258 auto Tree = C.limit(C.intersect(move(I1), move(I2)), 10);
258 auto Tree = C.limit(C.intersect(move(I1), move(I2)), 10);
766 auto I = dex::Dex::build(std::move(B).build(), RefSlab(), RelationSlab());
tools/clang/tools/extra/clangd/unittests/DiagnosticsTests.cpp 475 {std::move(LSPDiag),
494 {std::move(LSPDiag),
529 return MemIndex::build(std::move(Slab).build(), RefSlab(), RelationSlab());
586 MemIndex::build(std::move(Slab).build(), RefSlab(), RelationSlab());
tools/clang/tools/extra/clangd/unittests/FileIndexTests.cpp 71 return std::make_unique<SymbolSlab>(std::move(Slab).build());
80 return std::make_unique<RefSlab>(std::move(Slab).build());
110 return std::make_unique<SymbolSlab>(std::move(S).build());
274 PI.FS = buildTestFS(std::move(Files));
296 Index.updatePreamble(FooCpp, Ctx, std::move(PP), CanonIncludes);
tools/clang/tools/extra/clangd/unittests/FindTargetTests.cpp 537 Refs.push_back(std::move(R));
574 return AllRefs{std::move(AnnotatedCode), std::move(DumpedReferences)};
574 return AllRefs{std::move(AnnotatedCode), std::move(DumpedReferences)};
tools/clang/tools/extra/clangd/unittests/FormatTests.cpp 33 ADD_FAILURE() << llvm::toString(std::move(E));
tools/clang/tools/extra/clangd/unittests/FunctionTests.cpp 37 SubA = std::move(SubB);
tools/clang/tools/extra/clangd/unittests/FuzzyMatchTests.cpp 50 : Candidate(std::move(Candidate)), Score(Score) {}
tools/clang/tools/extra/clangd/unittests/HeaderSourceSwitchTests.cpp 137 auto Index = MemIndex::build(std::move(AllSymbols).build(), {}, {});
tools/clang/tools/extra/clangd/unittests/HeadersTests.cpp 54 std::move(CI), /*Preamble=*/nullptr,
tools/clang/tools/extra/clangd/unittests/IndexActionTests.cpp 79 [&](SymbolSlab S) { IndexFile.Symbols = std::move(S); },
80 [&](RefSlab R) { IndexFile.Refs = std::move(R); },
81 [&](RelationSlab R) { IndexFile.Relations = std::move(R); },
82 [&](IncludeGraph IG) { IndexFile.Sources = std::move(IG); });
91 Args, std::move(Action), Files.get(),
tools/clang/tools/extra/clangd/unittests/IndexTests.cpp 72 SymbolSlab S = std::move(B).build();
91 RelationSlab Slab = std::move(Builder).build();
107 RelationSlab Slab = std::move(Builder).build();
117 RelationSlab(), std::move(Token),
248 auto I = MemIndex::build(std::move(B).build(), RefSlab(), RelationSlab());
394 std::move(Results).build(),
404 EXPECT_THAT(std::move(Results2).build(),
tools/clang/tools/extra/clangd/unittests/JSONTransportTests.cpp 35 InBuf = std::move(InData);
63 Target.call("echo call", std::move(Params), 42);
74 Target.reply(ID, std::move(Params));
109 EXPECT_FALSE(bool(Err)) << toString(std::move(Err));
150 EXPECT_FALSE(bool(Err)) << toString(std::move(Err));
197 consumeError(std::move(Err));
tools/clang/tools/extra/clangd/unittests/PrintASTTests.cpp 37 Visitor(std::vector<Position> Points) : Points(std::move(Points)) {}
tools/clang/tools/extra/clangd/unittests/SymbolCollectorTests.cpp 202 : COpts(std::move(COpts)), PragmaHandler(PragmaHandler) {}
210 : DataConsumer(std::move(DataConsumer)), Opts(Opts),
236 return std::make_unique<IndexAction>(Collector, std::move(IndexOpts),
tools/clang/tools/extra/clangd/unittests/SyncAPI.cpp 43 return [Promise = std::move(Promise)](T Value) mutable {
44 Promise.set_value(std::make_shared<T>(std::move(Value)));
53 Target->emplace(std::move(*Future.get()));
75 return std::move(*Result);
82 return std::move(*Result);
89 return std::move(*Result);
96 return std::move(*Result);
104 return std::move(*Result);
110 return std::move(*Result);
117 return std::move(*Result);
124 return std::move(*Result);
137 return std::move(Builder).build();
145 return std::move(Slab).build();
152 return std::move(*Result);
159 return std::move(*Result);
tools/clang/tools/extra/clangd/unittests/TUSchedulerTests.cpp 51 Inputs.Contents = std::move(Contents);
59 WithContextValue Ctx(llvm::make_scope_exit(std::move(CB)));
89 File, std::move(Diags));
104 [OrigFile, CB = std::move(CB)](
107 CB(std::move(Diags));
109 S.update(File, std::move(Inputs), WD);
116 std::move(CB));
314 WithContext C(std::move(T.first));
318 return std::move(T.second);
323 WithContext C(std::move(T.first));
328 consumeError(std::move(Err));
331 << llvm::toString(std::move(Err));
337 return std::move(T.second);
539 cantFail(std::move(Preamble)).Preamble->Preamble.getBounds().Size,
554 cantFail(std::move(Preamble)).Preamble->Preamble.getBounds().Size,
583 Preambles[I] = cantFail(std::move(IP)).Preamble;
661 cantFail(std::move(IA));
764 Diagnostics = std::move(D);
792 Diagnostics = std::move(D);
tools/clang/tools/extra/clangd/unittests/TestFS.cpp 71 FileName, std::move(CommandLine), "")};
tools/clang/tools/extra/clangd/unittests/TestIndex.cpp 80 return std::move(Slab).build();
tools/clang/tools/extra/clangd/unittests/TestTU.cpp 73 buildAST(FullFilename, std::move(CI), Diags.take(), Inputs, Preamble);
78 return std::move(*AST);
94 return std::move(Idx);
tools/clang/tools/extra/clangd/unittests/TweakTesting.cpp 75 TU.AdditionalFiles = std::move(ExtraFiles);
95 TU.AdditionalFiles = std::move(ExtraFiles);
tools/clang/tools/extra/clangd/unittests/XRefsTests.cpp 1837 MemIndex::build(std::move(Symbols).build(), RefSlab(), RelationSlab());
tools/clang/tools/extra/modularize/ModularizeUtilities.cpp 310 ModuleMaps.push_back(std::move(ModMap));
tools/clang/tools/extra/pp-trace/PPTrace.cpp 145 Filters.emplace_back(std::move(*Pat), Enabled);
tools/clang/tools/extra/tool-template/ToolTemplate.cpp 115 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
tools/clang/tools/extra/unittests/clang-doc/BitcodeTest.cpp 52 return std::move(Infos.get());
269 F.Description.emplace_back(std::move(Top));
tools/clang/tools/extra/unittests/clang-doc/GeneratorTest.cpp 29 InfoC->Namespace = {std::move(RefB)};
41 InfoF->Namespace = {std::move(RefE), std::move(RefD)};
41 InfoF->Namespace = {std::move(RefE), std::move(RefD)};
49 ExpectedIdx.Children.emplace_back(std::move(IndexA));
54 IndexB.Children.emplace_back(std::move(IndexC));
55 ExpectedIdx.Children.emplace_back(std::move(IndexB));
62 IndexE.Children.emplace_back(std::move(IndexF));
63 IndexD.Children.emplace_back(std::move(IndexE));
64 ExpectedIdx.Children.emplace_back(std::move(IndexD));
68 ExpectedIdx.Children.emplace_back(std::move(IndexG));
tools/clang/tools/extra/unittests/clang-doc/HTMLGeneratorTest.cpp 26 return std::move(G.get());
414 I.Description.emplace_back(std::move(Top));
tools/clang/tools/extra/unittests/clang-doc/MDGeneratorTest.cpp 21 return std::move(G.get());
321 I.Description.emplace_back(std::move(Top));
tools/clang/tools/extra/unittests/clang-doc/MergeTest.cpp 46 Infos.emplace_back(std::make_unique<NamespaceInfo>(std::move(One)));
47 Infos.emplace_back(std::make_unique<NamespaceInfo>(std::move(Two)));
117 Infos.emplace_back(std::make_unique<RecordInfo>(std::move(One)));
118 Infos.emplace_back(std::make_unique<RecordInfo>(std::move(Two)));
172 OneParagraphComment->Children.push_back(std::move(OneTextComment));
173 OneFullComment->Children.push_back(std::move(OneParagraphComment));
192 TwoParagraphComment->Children.push_back(std::move(TwoTextComment));
193 TwoFullComment->Children.push_back(std::move(TwoParagraphComment));
196 Infos.emplace_back(std::make_unique<FunctionInfo>(std::move(One)));
197 Infos.emplace_back(std::make_unique<FunctionInfo>(std::move(Two)));
219 ExpectedParagraphComment->Children.push_back(std::move(ExpectedTextComment));
220 ExpectedFullComment->Children.push_back(std::move(ExpectedParagraphComment));
248 Infos.emplace_back(std::make_unique<EnumInfo>(std::move(One)));
249 Infos.emplace_back(std::make_unique<EnumInfo>(std::move(Two)));
tools/clang/tools/extra/unittests/clang-doc/SerializeTest.cpp 42 EmittedInfos.emplace_back(std::move(I.first));
44 EmittedInfos.emplace_back(std::move(I.second));
107 ExpectedBWithFunction.ChildFunctions.emplace_back(std::move(F));
160 std::move(EConstructor));
175 ExpectedRecordWithMethod.ChildFunctions.emplace_back(std::move(Method));
199 std::move(TemplateMethod));
219 std::move(SpecializedTemplateMethod));
245 ExpectedNamespaceWithEnum.ChildEnums.emplace_back(std::move(E));
256 ExpectedNamespaceWithScopedEnum.ChildEnums.emplace_back(std::move(G));
328 ExpectedBWithFunction.ChildFunctions.emplace_back(std::move(F));
344 ExpectedBWithFunction.ChildFunctions.emplace_back(std::move(F));
397 ExpectedE.Bases.back().ChildFunctions.emplace_back(std::move(FunctionSet));
410 ExpectedE.Bases.back().ChildFunctions.emplace_back(std::move(FunctionGet));
443 ExpectedH.Bases.back().ChildFunctions.emplace_back(std::move(FunctionSetNew));
456 ExpectedH.Bases.back().ChildFunctions.emplace_back(std::move(FunctionGetNew));
501 ExpectedBWithFunction.ChildFunctions.emplace_back(std::move(F));
513 std::move(ExportedF));
tools/clang/tools/extra/unittests/clang-doc/YAMLGeneratorTest.cpp 22 return std::move(G.get());
375 I.Description.emplace_back(std::move(Top));
tools/clang/tools/extra/unittests/clang-query/QueryEngineTest.cpp 30 ASTs[0] = std::move(a);
31 ASTs[1] = std::move(b);
tools/clang/tools/extra/unittests/clang-tidy/ClangTidyTest.h 149 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
156 *Errors = std::move(Diags);
tools/clang/tools/libclang/CIndex.cpp 3378 *out_TU = MakeCXTranslationUnit(CXXIdx, std::move(AU));
3552 *out_TU = MakeCXTranslationUnit(CXXIdx, std::move(Unit));
tools/clang/tools/libclang/CIndexCodeCompletion.cpp 362 FileMgr(std::move(FileMgr)),
593 AllocatedResults.FixItsVector.emplace_back(std::move(Results[I].FixIts));
tools/clang/tools/libclang/CIndexDiagnostic.cpp 34 Diagnostics.push_back(std::move(D));
106 CurrentSet->appendDiagnostic(std::move(Owner));
tools/clang/tools/libclang/CIndexDiagnostic.h 103 ChildDiags.appendDiagnostic(std::move(D));
tools/clang/tools/libclang/CIndexer.h 50 Options(CXGlobalOpt_None), PCHContainerOps(std::move(PCHContainerOps)) {
tools/clang/tools/libclang/CXCompilationDatabase.cpp 42 : CCmd(std::move(Cmd)) {}
52 return new AllocatedCXCompileCommands(std::move(CCmd));
63 return new AllocatedCXCompileCommands(std::move(CCmd));
tools/clang/tools/libclang/CXIndexDataConsumer.cpp 417 cxtu::getASTUnit(CXTU)->setPreprocessor(std::move(PP));
tools/clang/tools/libclang/CXLoadedDiagnostic.cpp 316 TopDiags->appendDiagnostic(std::move(D));
318 CurrentDiags.back()->getChildDiagnostics().appendDiagnostic(std::move(D));
tools/clang/tools/libclang/Indexing.cpp 192 NewParsedRegions.emplace_back(std::move(region));
345 : DataConsumer(std::move(dataConsumer)), Opts(Opts), SKData(skData) {}
375 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
537 BufOwner->push_back(std::move(MB));
560 new CXTUOwner(MakeCXTranslationUnit(CXXIdx, std::move(Unit))));
616 std::move(CInvok), CXXIdx->getPCHContainerOperations(), Diags,
tools/clang/unittests/AST/ASTImporterFixtures.cpp 32 MFS->addFile(FileName, 0, std::move(Buffer));
tools/clang/unittests/AST/ASTImporterFixtures.h 227 << toString(std::move(Err));
tools/clang/unittests/AST/CommentLexer.cpp 63 FileID File = SourceMgr.createFileID(std::move(Buf));
tools/clang/unittests/AST/CommentParser.cpp 56 FileID File = SourceMgr.createFileID(std::move(Buf));
tools/clang/unittests/AST/ExternalASTSourceTest.cpp 57 Compiler.setInvocation(std::move(Invocation));
tools/clang/unittests/AST/NamedDeclPrinterTest.cpp 41 : NumFoundDecls(0), Printer(std::move(Printer)) {}
69 PrintMatch Printer(std::move(Print));
tools/clang/unittests/AST/RecursiveASTVisitorTest.cpp 28 : Process(std::move(Process)) {
78 std::vector<VisitEvent> takeEvents() && { return std::move(Events); }
90 return std::move(Visitor).takeEvents();
tools/clang/unittests/ASTMatchers/ASTMatchersInternalTest.cpp 99 MatchFinder Finder(std::move(Options));
tools/clang/unittests/ASTMatchers/ASTMatchersTest.h 40 : Verified(Verified), FindResultReviewer(std::move(FindResultVerifier)) {}
324 VerifyMatch VerifyVerifiedResult(std::move(FindResultVerifier), &VerifiedResult);
368 Code, AMatcher, std::move(FindResultVerifier), true);
376 Code, AMatcher, std::move(FindResultVerifier), false);
tools/clang/unittests/Analysis/CFGBuildResult.h 26 : S(S), Cfg(std::move(Cfg)) {}
50 TheBuildResult = {BuildResult::BuiltCFG, std::move(Cfg)};
65 return std::move(Callback.TheBuildResult);
tools/clang/unittests/Basic/DiagnosticTest.cpp 85 llvm::cantFail(std::move(Err));
tools/clang/unittests/Basic/FileManagerTest.cpp 151 manager.setStatCache(std::move(statCache));
197 manager.setStatCache(std::move(statCache));
216 manager.setStatCache(std::move(statCache));
245 manager.setStatCache(std::move(statCache));
262 manager.setStatCache(std::move(statCache));
284 manager.setStatCache(std::move(statCache));
355 Manager.setStatCache(std::move(statCache));
388 Manager.setStatCache(std::move(statCache));
420 Manager.setStatCache(std::move(Cache));
tools/clang/unittests/Basic/SourceManagerTest.cpp 58 FileID mainFileID = SourceMgr.createFileID(std::move(Buf));
112 FileID MainFileID = SourceMgr.createFileID(std::move(Buf));
170 SourceMgr.overrideFileContents(SourceFile, std::move(Buf));
174 SourceMgr.overrideFileContents(HeaderFile, std::move(HeaderBuf));
263 FileID mainFileID = SourceMgr.createFileID(std::move(MainBuf));
268 SourceMgr.overrideFileContents(headerFile, std::move(HeaderBuf));
382 SourceMgr.setMainFileID(SourceMgr.createFileID(std::move(MainBuf)));
386 SourceMgr.overrideFileContents(headerFile, std::move(HeaderBuf));
tools/clang/unittests/CodeGen/CodeGenExternalTest.cpp 57 : ASTConsumer(), Builder(std::move(Builder_in))
tools/clang/unittests/DirectoryWatcher/DirectoryWatcherTest.cpp 243 std::thread worker(std::move(task));
tools/clang/unittests/Frontend/CodeGenActionTest.cpp 53 Compiler.setInvocation(std::move(Invocation));
tools/clang/unittests/Frontend/FrontendActionTest.cpp 92 compiler.setInvocation(std::move(invocation));
112 compiler.setInvocation(std::move(invocation));
139 compiler.setInvocation(std::move(invocation));
185 Compiler.setInvocation(std::move(Invocation));
246 Compiler.setInvocation(std::move(Invocation));
279 Compiler.setInvocation(std::move(Invocation));
tools/clang/unittests/Frontend/OutputStreamTest.cpp 38 Compiler.setOutputStream(std::move(IRStream));
39 Compiler.setInvocation(std::move(Invocation));
62 Compiler.setInvocation(std::move(Invocation));
91 Compiler.setInvocation(std::move(Invocation));
95 Compiler.setVerboseOutputStream(std::move(VerboseStream));
tools/clang/unittests/Index/IndexTests.cpp 90 Symbols.push_back(std::move(S));
103 Symbols.push_back(std::move(S));
115 : Index(std::move(Index)), Opts(Opts) {}
128 : Index(std::move(Index)), PP(std::move(PP)), Opts(Opts) {}
128 : Index(std::move(Index)), PP(std::move(PP)), Opts(Opts) {}
tools/clang/unittests/Lex/LexerTest.cpp 52 SourceMgr.setMainFileID(SourceMgr.createFileID(std::move(Buf)));
tools/clang/unittests/Lex/PPCallbacksTest.cpp 177 SourceMgr.setMainFileID(SourceMgr.createFileID(std::move(Buf)));
196 SourceMgr.setMainFileID(SourceMgr.createFileID(std::move(Buf)));
235 SourceMgr.setMainFileID(SourceMgr.createFileID(std::move(Buf)));
266 SourceMgr.setMainFileID(SourceMgr.createFileID(std::move(SourceBuf)));
tools/clang/unittests/Lex/PPConditionalDirectiveRecordTest.cpp 74 SourceMgr.setMainFileID(SourceMgr.createFileID(std::move(Buf)));
tools/clang/unittests/Sema/CodeCompleteTest.cpp 78 : CompletePosition(std::move(P)), ResultCtx(ResultCtx) {}
tools/clang/unittests/Sema/ExternalSemaSourceTest.cpp 228 std::move(Installer), "namespace AAA { } using namespace AAB;", Args));
242 std::move(Installer), "namespace AAA { } using namespace AAB;", Args));
261 std::move(Installer), "namespace AAA { } using namespace AAB;", Args));
276 std::move(Installer), "namespace AAA { } void foo() { AAA::aaa(); }",
292 std::move(Installer),
310 std::move(Installer), "class Incomplete; Incomplete IncompleteInstance;",
tools/clang/unittests/Serialization/InMemoryModuleCacheTest.cpp 42 EXPECT_EQ(RawB, &Cache.addPCM("B", std::move(B)));
60 EXPECT_EQ(RawB, &Cache.addBuiltPCM("B", std::move(B)));
82 EXPECT_EQ(RawB1, &Cache.addPCM("B", std::move(B1)));
97 EXPECT_EQ(RawB2, &Cache.addBuiltPCM("B", std::move(B2)));
111 EXPECT_EQ(RawB, &Cache.addPCM("B", std::move(B)));
tools/clang/unittests/StaticAnalyzer/CallDescriptionTest.cpp 33 Impl(std::move(Data)) {}
tools/clang/unittests/StaticAnalyzer/RegisterCustomCheckersTest.cpp 54 return std::move(AnalysisConsumer);
tools/clang/unittests/Tooling/ASTSelectionTest.cpp 85 Consumer(std::move(Selection));
695 CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
703 CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
712 CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
721 CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
741 CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
762 CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
776 CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
796 CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
824 CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
854 CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
882 CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
921 CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
931 CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
954 CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
986 CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
998 CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
1029 CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
1040 CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
1051 CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
1073 CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
tools/clang/unittests/Tooling/DependencyScannerTest.cpp 56 CompilerInstance Compiler(std::move(PCHContainerOps));
57 Compiler.setInvocation(std::move(Invocation));
tools/clang/unittests/Tooling/ExecutionTest.cpp 96 : OptionsParser(std::move(Options)) {}
130 return std::make_unique<TestToolExecutor>(std::move(OptionsParser));
tools/clang/unittests/Tooling/RangeSelectorTest.cpp 54 return TestMatch{std::move(ASTUnit), MatchResult(Matches[0], &Context)};
tools/clang/unittests/Tooling/RefactoringActionRulesTest.cpp 40 void handleError(llvm::Error Err) override { Result = std::move(Err); }
43 Result = std::move(SourceReplacements);
46 RefactoringResultConsumer::handle(std::move(Occurrences));
55 return std::move(*C.Result);
80 return std::move(E);
110 AtomicChanges Result = std::move(*ErrorOrResult);
183 Result = std::move(Occurrences);
186 RefactoringResultConsumer::handle(std::move(Changes));
195 return std::move(C.Result);
216 return std::move(Occurrences);
230 SymbolOccurrences Occurrences = std::move(*Result);
tools/clang/unittests/Tooling/RefactoringCallbacksTest.cpp 129 handleAllErrors(std::move(E), [&](const llvm::StringError &SE) {
tools/clang/unittests/Tooling/RefactoringTest.cpp 115 llvm::handleAllErrors(std::move(Error), [&](const ReplacementError &RE) {
148 llvm::consumeError(std::move(Err));
152 EXPECT_TRUE(checkReplacementError(std::move(Err),
158 EXPECT_TRUE(checkReplacementError(std::move(Err),
164 EXPECT_TRUE(checkReplacementError(std::move(Err),
177 llvm::consumeError(std::move(Err));
180 llvm::consumeError(std::move(Err));
183 llvm::consumeError(std::move(Err));
192 llvm::consumeError(std::move(Err));
195 llvm::consumeError(std::move(Err));
202 llvm::consumeError(std::move(Err));
212 llvm::consumeError(std::move(Err));
215 llvm::consumeError(std::move(Err));
222 llvm::consumeError(std::move(Err));
225 llvm::consumeError(std::move(Err));
234 llvm::consumeError(std::move(Err));
238 llvm::consumeError(std::move(Err));
242 llvm::consumeError(std::move(Err));
246 llvm::consumeError(std::move(Err));
256 llvm::consumeError(std::move(Err));
260 llvm::consumeError(std::move(Err));
265 llvm::consumeError(std::move(Err));
270 llvm::consumeError(std::move(Err));
283 llvm::consumeError(std::move(Err));
287 llvm::consumeError(std::move(Err));
292 llvm::consumeError(std::move(Err));
303 llvm::consumeError(std::move(Err));
307 llvm::consumeError(std::move(Err));
314 llvm::consumeError(std::move(Err));
324 llvm::consumeError(std::move(Err));
329 llvm::consumeError(std::move(Err));
333 llvm::consumeError(std::move(Err));
345 llvm::consumeError(std::move(Err));
348 llvm::consumeError(std::move(Err));
354 EXPECT_TRUE(checkReplacementError(std::move(Err),
360 llvm::consumeError(std::move(Err));
367 llvm::consumeError(std::move(Err));
370 llvm::consumeError(std::move(Err));
376 llvm::consumeError(std::move(Err));
379 llvm::consumeError(std::move(Err));
387 llvm::consumeError(std::move(Err));
390 EXPECT_TRUE(checkReplacementError(std::move(Err),
397 llvm::consumeError(std::move(Err));
400 llvm::consumeError(std::move(Err));
407 llvm::consumeError(std::move(Err));
410 llvm::consumeError(std::move(Err));
413 llvm::consumeError(std::move(Err));
423 llvm::consumeError(std::move(Err));
426 llvm::consumeError(std::move(Err));
429 llvm::consumeError(std::move(Err));
476 llvm::consumeError(std::move(Err));
481 llvm::consumeError(std::move(Err));
496 EXPECT_TRUE(checkReplacementError(std::move(Err),
1208 llvm::consumeError(std::move(Err));
1262 std::move(Err), replacement_error::wrong_file_path,
1279 checkReplacementError(std::move(Err), replacement_error::wrong_file_path,
1293 std::move(Err), replacement_error::wrong_file_path,
tools/clang/unittests/Tooling/ReplacementTest.h 33 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
tools/clang/unittests/Tooling/RewriterTestContext.h 57 InMemoryFileSystem->addFile(Name, 0, std::move(Source));
tools/clang/unittests/Tooling/SourceCodeBuildersTest.cpp 66 return TestMatch{std::move(AstUnit), MatchResult(Matches[0], &Context)};
tools/clang/unittests/Tooling/StencilTest.cpp 70 return TestMatch{std::move(AstUnit), MatchResult(Matches[0], &Context)};
107 ADD_FAILURE() << "Unhandled error: " << llvm::toString(std::move(Err));
tools/clang/unittests/Tooling/Syntax/TokensTest.cpp 104 Result = std::move(*Collector).consume();
130 Compiler.setInvocation(std::move(CI));
tools/clang/unittests/Tooling/Syntax/TreeTest.cpp 38 : Root(Root), Arena(Arena), Tokens(std::move(Tokens)) {
45 std::move(*Tokens).consume());
68 std::move(Tokens));
89 Compiler.setInvocation(std::move(CI));
tools/clang/unittests/Tooling/ToolingTest.cpp 36 : TestConsumer(std::move(TestConsumer)) {}
43 return std::move(TestConsumer);
tools/clang/unittests/Tooling/TransformerTest.cpp 111 Changes.push_back(std::move(*C));
121 Transformer T(std::move(Rule), consumer());
187 testRule(std::move(Rule), Input, Expected);
tools/clang/utils/TableGen/ClangAttrEmitter.cpp 258 : Argument(Arg, Attr), type(std::move(T)) {}
643 : Argument(Arg, Attr), Type(std::move(T)),
3952 Heading(std::move(HeadingAndSpellings.first)),
3953 SupportedSpellings(std::move(HeadingAndSpellings.second)) {}
4011 return std::make_pair(std::move(Heading), std::move(SupportedSpellings));
4011 return std::make_pair(std::move(Heading), std::move(SupportedSpellings));
tools/clang/utils/TableGen/ClangCommentCommandInfoEmitter.cpp 69 Matches.emplace_back(std::move(Name), std::move(Return));
69 Matches.emplace_back(std::move(Name), std::move(Return));
tools/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp 516 : Piece(MultiPieceClass), Pieces(std::move(Pieces)) {}
662 : Builder(O.Builder), AllocatedPieces(std::move(O.AllocatedPieces)),
708 OldMappings = std::move(Visitor.ModifierMappings);
711 Visitor.ModifierMappings = std::move(NewMappings);
715 Visitor.ModifierMappings = std::move(OldMappings);
tools/clang/utils/TableGen/ClangOptionDocEmitter.cpp 113 return {R, std::move(A)};
tools/clang/utils/TableGen/MveEmitter.cpp 1225 ACLEIntrinsics[Intrinsic->fullName()] = std::move(Intrinsic);
tools/clang/utils/TableGen/NeonEmitter.cpp 157 : TS(std::move(TS)), Float(false), Signed(false), Immediate(false),
275 Variable(Type T, std::string N) : T(std::move(T)), N(std::move(N)) {}
275 Variable(Type T, std::string N) : T(std::move(T)), N(std::move(N)) {}
tools/dsymutil/BinaryHolder.cpp 53 MemBuffer = std::move(*ErrOrBuff);
68 FatBinary = std::move(*ErrOrFat);
80 Archives.push_back(std::move(*ErrOrArchive));
92 MemBuffer = std::move(*ErrOrBuff);
107 FatBinary = std::move(*ErrOrFat);
118 Objects.push_back(std::move(*ErrOrObjectFile));
195 OE.Objects.push_back(std::move(*ErrOrObjectFile));
200 return std::move(Err);
207 MemberCache.try_emplace(Key, std::move(OE));
230 llvm::consumeError(std::move(Err));
246 return std::move(Err);
tools/dsymutil/DebugMap.cpp 144 Result.push_back(std::move(Res));
145 return std::move(Result);
247 << toString(std::move(Err)) << '\n';
253 << toString(std::move(Err)) << '\n';
tools/dsymutil/DwarfLinker.cpp 1725 llvm::consumeError(std::move(E));
1832 DWARFContext::dumpWarning(std::move(Err));
2209 consumeError(std::move(E));
2222 Twine(Obj.getObjectFilename()) + ": " + toString(std::move(Err)), Obj);
2223 return errorToErrorCode(std::move(Err));
2230 Twine(Obj.getObjectFilename()) + ": " + toString(std::move(Err)), Obj);
2231 return errorToErrorCode(std::move(Err));
2351 CompileUnits.push_back(std::move(Unit));
2853 return error(toString(std::move(E)));
2861 DwarfLinker Linker(OutFile, BinHolder, std::move(Options));
tools/dsymutil/DwarfLinker.h 60 : OutFile(OutFile), BinHolder(BinHolder), Options(std::move(Options)) {}
tools/dsymutil/DwarfStreamer.h 47 : OutFile(OutFile), Options(std::move(Options)) {}
tools/dsymutil/MachODebugMapParser.cpp 164 Warning("unable to open object file: " + toString(std::move(Err)),
172 Warning("unable to open object file: " + toString(std::move(Err)),
203 return std::move(Result);
354 << "': " << toString(std::move(Err)) << '\n';
362 << "' as MachO file: " << toString(std::move(Err))
393 return std::move(Results);
tools/dsymutil/MachOUtils.cpp 38 File = std::make_unique<sys::fs::TempFile>(std::move(*T));
47 llvm::consumeError(std::move(E));
84 << toString(std::move(E)) << "\n";
352 toString(std::move(Err)),
361 toString(std::move(Err)),
tools/dsymutil/SymbolMap.cpp 157 return SymbolMapTranslator(std::move(UnobfuscatedStrings), MangleNames);
tools/dsymutil/SymbolMap.h 28 : UnobfuscatedStrings(std::move(UnobfuscatedStrings)),
43 SymbolMapLoader(std::string SymbolMap) : SymbolMap(std::move(SymbolMap)) {}
tools/dsymutil/dsymutil.cpp 238 Options.InputFiles = std::move(*InputFiles);
270 return std::move(E);
423 return std::move(E);
425 return std::move(E);
573 WithColor::error() << toString(std::move(E));
594 linkDwarf(*Stream, BinHolder, *Map, std::move(Options)));
tools/gold/gold-plugin.cpp 480 handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) -> Error {
488 return std::move(*E);
522 Buffer = std::move(BufferOrErr.get());
544 std::unique_ptr<InputFile> Obj = std::move(*ObjOrErr);
713 std::unique_ptr<InputFile> Input = std::move(ObjOrErr.get());
774 check(Lto.add(std::move(Input), Resols),
927 return std::make_unique<LTO>(std::move(Conf), Backend,
tools/llc/llc.cpp 340 WithColor::error(errs(), argv[0]) << toString(std::move(E)) << '\n';
343 std::unique_ptr<ToolOutputFile> RemarksFile = std::move(*RemarksFileOrErr);
tools/lld/COFF/Chunks.h 568 explicit RVATableChunk(SymbolRVASet s) : syms(std::move(s)) {}
619 : relocs(std::move(relocs)) {
tools/lld/COFF/DLL.cpp 155 v.push_back(std::move(syms));
tools/lld/COFF/DebugTypes.cpp 253 return std::move(err);
tools/lld/COFF/Driver.cpp 143 return MBErrPair{std::move(*mbOrErr), std::error_code()};
162 make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take ownership
174 MemoryBufferRef mbref = takeBuffer(std::move(mb));
187 make<std::unique_ptr<Archive>>(std::move(file)); // take ownership
248 driver->addBuffer(std::move(mbOrErr.first), wholeArchive, lazy);
285 toString(std::move(e)));
313 driver->addArchiveBuffer(takeBuffer(std::move(mbOrErr.first)),
758 handleAllErrors(std::move(e),
788 handleError(std::move(e));
854 taskQueue.push_back(std::move(task));
1159 tar = std::move(*errOrWriter);
tools/lld/COFF/DriverUtils.cpp 396 toString(std::move(e)));
403 toString(std::move(e)));
506 return std::move(res);
663 config->exports = std::move(v);
715 fatal(toString(std::move(ec)));
724 fatal(toString(f) + ": " + toString(std::move(ec)));
727 fatal(toString(std::move(ec)));
746 make<std::unique_ptr<MemoryBuffer>>(std::move(*e)); // take ownership
885 return {std::move(args), std::move(exports)};
885 return {std::move(args), std::move(exports)};
tools/lld/COFF/InputFiles.cpp 137 ": Archive::children failed: " + toString(std::move(err)));
147 file = make<BitcodeFile>(mb, "", 0, std::move(symbols));
149 file = make<ObjFile>(mb, std::move(symbols));
882 : InputFile(BitcodeKind, mb), symbols(std::move(symbols)) {
tools/lld/COFF/InputFiles.h 135 : InputFile(ObjectKind, m), symbols(std::move(symbols)) {}
tools/lld/COFF/LTO.cpp 141 checkError(ltoObj->add(std::move(f.obj), resols));
158 files[task] = std::move(mb);
tools/lld/COFF/MapFile.cpp 86 ret[syms[i]] = std::move(str[i]);
tools/lld/COFF/PDB.cpp 283 fileName = std::move(absoluteFileName);
382 return std::move(e);
408 toString(std::move(err)));
414 toString(std::move(err)));
437 fatal("Type server does not have TPI stream: " + toString(std::move(e)));
442 fatal("Error getting type server IPI stream: " + toString(std::move(e)));
458 fatal("codeview::mergeTypeRecords failed: " + toString(std::move(err)));
467 fatal("codeview::mergeIdRecords failed: " + toString(std::move(err)));
473 fatal("codeview::mergeTypeRecords failed: " + toString(std::move(err)));
479 fatal("codeview::mergeIdRecords failed: " + toString(std::move(err)));
848 consumeError(std::move(ec));
1029 newFpoFrames.push_back(std::move(fds));
1157 file.moduleDBI->addDebugSubsection(std::move(newChecksums));
1346 builder.addInjectedSource(file, std::move(*dataOrErr));
tools/lld/COFF/Writer.cpp 631 fatal("failed to write the output file: " + toString(std::move(e)));
1483 maybeAddRVATable(std::move(handlers), "__safe_se_handler_table",
1602 maybeAddRVATable(std::move(addressTakenSyms), "__guard_fids_table",
1607 maybeAddRVATable(std::move(longJmpTargets), "__guard_longjmp_table",
1669 RVATableChunk *tableChunk = make<RVATableChunk>(std::move(tableSymbols));
tools/lld/Common/DWARF.cpp 17 : dwarf(std::move(d)) {
20 handleAllErrors(std::move(err),
tools/lld/Common/ErrorHandler.cpp 86 handleAllErrors(std::move(e),
tools/lld/ELF/AArch64ErrataFix.cpp 524 isd.sections = std::move(tmp);
tools/lld/ELF/ARMErrataFix.cpp 394 isd.sections = std::move(tmp);
tools/lld/ELF/Driver.cpp 179 toString(std::move(err)));
183 make<std::unique_ptr<MemoryBuffer>>(std::move(mb));
238 files.push_back(make<ArchiveFile>(std::move(file)));
458 tar = std::move(*errOrWriter);
tools/lld/ELF/DriverUtils.cpp 110 args = std::move(v);
tools/lld/ELF/InputFiles.cpp 119 make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take MB ownership
1073 file(std::move(file)) {}
1496 file->symbols = std::move(symbols);
tools/lld/ELF/InputSection.cpp 155 ": uncompress failed: " + llvm::toString(std::move(e)));
1127 ": uncompress failed: " + llvm::toString(std::move(e)));
tools/lld/ELF/LTO.cpp 210 checkError(ltoObj->add(std::move(f.obj), resols));
248 files[task] = std::move(mb);
tools/lld/ELF/LinkerScript.cpp 274 sectionCommands = std::move(v);
tools/lld/ELF/MapFile.cpp 98 ret[syms[i]] = std::move(str[i]);
tools/lld/ELF/OutputSections.cpp 276 fatal("compress failed: " + llvm::toString(std::move(e)));
tools/lld/ELF/Relocations.cpp 1574 isd->sections = std::move(tmp);
tools/lld/ELF/ScriptParser.cpp 641 ret.push_back({std::move(excludeFilePat), StringMatcher(v)});
tools/lld/ELF/SyntheticSections.cpp 1722 relativeGroups.emplace_back(std::move(group));
2566 error(toString(sec) + ": " + toString(std::move(e)));
2686 ret.push_back(std::move(sym));
2730 ret->chunks = std::move(chunks);
3283 executableSections = std::move(selectedSections);
tools/lld/ELF/Writer.cpp 620 error("failed to write to the output file: " + toString(std::move(e)));
2605 buffer = std::move(*bufferOrErr);
tools/lld/include/lld/Common/ErrorHandler.h 133 return std::move(*e);
139 return std::move(*e);
146 return std::move(*e);
153 return std::move(*e);
tools/lld/include/lld/Core/Node.h 60 : Node(Node::Kind::File), _file(std::move(f)) {}
tools/lld/include/lld/Core/PassManager.h 31 _passes.push_back(std::move(pass));
tools/lld/include/lld/Core/Resolver.h 55 std::unique_ptr<SimpleFile> resultFile() { return std::move(_result); }
tools/lld/include/lld/ReaderWriter/MachOLinkingContext.h 104 ctx->getNodes().push_back(std::make_unique<FileNode>(std::move(file)));
tools/lld/lib/Core/LinkingContext.cpp 42 return std::move(entryFile);
58 return std::move(undefinedSymFile);
64 result.push_back(std::move(file));
66 result.push_back(std::move(file));
tools/lld/lib/Core/Reader.cpp 28 _readers.push_back(std::move(reader));
32 _yamlHandlers.push_back(std::move(handler));
45 return reader->loadFile(std::move(mb), *this);
tools/lld/lib/Core/Resolver.cpp 34 return std::move(ec);
37 doDefinedAtom(std::move(atom));
39 if (doUndefinedAtom(std::move(atom)))
43 doSharedLibraryAtom(std::move(atom));
45 doAbsoluteAtom(std::move(atom));
66 return std::move(ec);
96 doSharedLibraryAtom(std::move(atom));
256 logAllUnhandledErrors(std::move(EC), llvm::errs(), std::string());
270 logAllUnhandledErrors(std::move(EC), llvm::errs(), std::string());
283 logAllUnhandledErrors(std::move(EC), llvm::errs(), std::string());
tools/lld/lib/Driver/DarwinLdDriver.cpp 109 members.push_back(std::move(file));
124 ctx.registry().loadFile(std::move(mbOrErr.get()));
137 return parseMemberFiles(std::move(file));
139 files.push_back(std::move(file));
163 ctx.getNodes().push_back(std::make_unique<FileNode>(std::move(file)));
1099 handleAllErrors(std::move(ec), [&](const llvm::ErrorInfoBase &EI) {
1118 ctx.addSectCreateSection(seg, sect, std::move(*contentOrErr));
1141 members.insert(members.begin(), std::make_unique<FileNode>(std::move(*i)));
1188 std::make_unique<FileNode>(std::move(mergedFile)));
1201 logAllUnhandledErrors(std::move(ec), *errorHandler().errorOS,
1215 logAllUnhandledErrors(std::move(ec), *errorHandler().errorOS,
tools/lld/lib/ReaderWriter/FileArchive.cpp 73 _filesReturned.push_back(std::move(result));
91 consumeError(std::move(err));
94 result.push_back(std::move(file));
97 return errorToErrorCode(std::move(err));
130 return errorToErrorCode(std::move(Err));
154 _registry.loadFile(std::move(memberMB));
157 result = std::move(fileOrErr.get());
213 std::make_unique<FileArchive>(std::move(mb), reg, path, _logLoading);
214 return std::move(ret);
tools/lld/lib/ReaderWriter/MachO/DebugInfo.h 33 _allocator = std::move(allocator);
52 : DebugInfo(Kind::Dwarf), _tu(std::move(tu)) {}
91 : DebugInfo(Kind::Stabs), _stabs(std::move(stabs)) {}
tools/lld/lib/ReaderWriter/MachO/File.h 33 _mb(std::move(mb)), _ctx(ctx) {}
234 _debugInfo = std::move(debugInfo);
238 std::unique_ptr<DebugInfo> takeDebugInfo() { return std::move(_debugInfo); }
245 return llvm::errorToErrorCode(std::move(ec));
248 return llvm::errorToErrorCode(std::move(ec));
287 _mb(std::move(mb)), _ctx(ctx) {}
335 return llvm::errorToErrorCode(std::move(ec));
338 return llvm::errorToErrorCode(std::move(ec));
tools/lld/lib/ReaderWriter/MachO/LayoutPass.cpp 264 : _registry(registry), _customSorter(std::move(sorter)) {}
430 ret.push_back(SortKey(std::move(atom), root, override));
439 atomRange[i++] = std::move(k._atom);
tools/lld/lib/ReaderWriter/MachO/LayoutPass.h 37 : _atom(std::move(atom)), _root(root), _override(override) {}
44 SortKey(SortKey &&key) : _atom(std::move(key._atom)), _root(key._root),
50 _atom = std::move(key._atom);
tools/lld/lib/ReaderWriter/MachO/MachOLinkingContext.cpp 665 std::unique_ptr<MemoryBuffer> mb = std::move(mbOrErr.get());
673 return std::move(mb);
682 registry().loadFile(std::move(mbOrErr.get()));
689 _indirectDylibs.push_back(std::move(file));
807 getNodes().push_back(std::make_unique<FileNode>(std::move(sectCreateFile)));
811 _sectCreateFile->addSection(seg, sect, std::move(content));
tools/lld/lib/ReaderWriter/MachO/MachONormalizedFileBinaryReader.cpp 273 return std::move(ec);
493 return std::move(ec);
526 return std::move(Err);
530 return std::move(f);
545 std::make_unique<MachOFile>(std::move(mb), &_ctx);
546 return std::move(ret);
571 std::make_unique<MachODylibFile>(std::move(mb), &_ctx);
572 return std::move(ret);
tools/lld/lib/ReaderWriter/MachO/MachONormalizedFileFromAtoms.cpp 640 file.sections.push_back(std::move(temp));
1638 return std::move(err);
1642 return std::move(ec);
1652 return std::move(f);
tools/lld/lib/ReaderWriter/MachO/MachONormalizedFileToAtoms.cpp 626 return handleErrors(std::move(relocErr),
662 return handleErrors(std::move(relocErr),
815 file.setDebugInfo(std::make_unique<StabsDebugInfo>(std::move(stabsList)));
818 file.debugInfo()->setAllocator(std::move(allocator));
981 file.setDebugInfo(std::make_unique<DwarfDebugInfo>(std::move(*tuOrErr)));
983 file.debugInfo()->setAllocator(std::move(allocator));
1170 cieInfos[atom] = std::move(cieInfo);
1406 return std::move(ec);
1407 return std::unique_ptr<File>(std::move(file));
1416 return std::move(ec);
1417 return std::unique_ptr<File>(std::move(file));
tools/lld/lib/ReaderWriter/MachO/MachONormalizedFileYAML.cpp 820 return std::move(f);
tools/lld/lib/ReaderWriter/MachO/SectCreateFile.h 31 _content(std::move(content)) {}
68 new (allocator()) SectCreateAtom(*this, seg, sect, std::move(content)));
tools/lld/unittests/MachOTests/MachONormalizedFileBinaryReaderTests.cpp 37 return std::move(*r);
tools/lld/unittests/MachOTests/MachONormalizedFileBinaryWriterTests.cpp 35 mb = std::move(mbOrErr.get());
tools/lld/unittests/MachOTests/MachONormalizedFileYAMLTests.cpp 34 return std::move(*r);
tools/lld/wasm/Driver.cpp 209 ": Archive::children failed: " + toString(std::move(err)));
213 make<std::unique_ptr<MemoryBuffer>>(std::move(mb));
669 tar = std::move(*errOrWriter);
tools/lld/wasm/InputFiles.cpp 55 make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take MB ownership
tools/lld/wasm/LTO.cpp 70 return std::make_unique<lto::LTO>(std::move(c), backend,
117 checkError(ltoObj->add(std::move(f.obj), resols));
135 files[task] = std::move(mb);
tools/lld/wasm/Writer.cpp 1072 fatal("failed to write the output file: " + toString(std::move(e)));
1087 buffer = std::move(*bufferOrErr);
tools/lldb/include/lldb/Breakpoint/BreakpointOptions.h 89 : TypedBaton(std::move(Data)) {}
tools/lldb/include/lldb/Breakpoint/WatchpointOptions.h 181 : TypedBaton(std::move(Data)) {}
tools/lldb/include/lldb/Core/FileSpecList.h 43 FileSpecList(std::vector<FileSpec> &&rhs) : m_files(std::move(rhs)) {}
tools/lldb/include/lldb/DataFormatters/FormattersContainer.h 83 m_map.emplace_back(std::move(name), std::move(entry));
83 m_map.emplace_back(std::move(name), std::move(entry));
177 Add_Impl(std::move(type), entry, static_cast<KeyType *>(nullptr));
229 m_format_map.Add(std::move(type), entry);
tools/lldb/include/lldb/Expression/DiagnosticManager.h 117 m_diagnostics.push_back(std::move(diagnostic));
142 m_fixed_expression = std::move(fixed_expression);
tools/lldb/include/lldb/Symbol/SymbolFile.h 58 : m_objfile_sp(std::move(objfile_sp)), m_abilities(0),
tools/lldb/include/lldb/Target/ABI.h 142 : m_process_wp(process_sp), m_mc_register_info_up(std::move(info_up)) {
tools/lldb/include/lldb/Utility/Baton.h 60 explicit TypedBaton(std::unique_ptr<T> Item) : Item(std::move(Item)) {}
tools/lldb/include/lldb/Utility/Environment.h 60 Environment(Environment &&RHS) : Base(std::move(RHS)) {}
66 Base::operator=(std::move(RHS));
tools/lldb/include/lldb/Utility/Log.h 150 llvm::formatv(format, llvm::toString(std::move(error)),
tools/lldb/include/lldb/Utility/Reproducer.h 128 m_version = std::move(version);
220 m_callback = std::move(callback);
254 return static_cast<T *>(Register(std::move(provider)));
tools/lldb/include/lldb/Utility/Status.h 72 explicit Status(llvm::Error error) { *this = std::move(error); }
tools/lldb/include/lldb/Utility/StructuredData.h 508 AddItem(key, std::make_shared<String>(std::move(value)));
tools/lldb/source/API/SBDebugger.cpp 162 error.SetError(Status(std::move(e)));
662 dict.AddItem(name, std::move(entry_up));
671 entry_up->AddItem("value", std::move(array_up));
673 dict.AddItem("targets", std::move(entry_up));
694 data.m_impl_up->SetObjectSP(std::move(config_up));
tools/lldb/source/API/SBModule.cpp 466 llvm::consumeError(std::move(err));
484 llvm::consumeError(std::move(err));
512 llvm::consumeError(std::move(err));
tools/lldb/source/API/SBReproducer.cpp 111 error = llvm::toString(std::move(e));
121 error = llvm::toString(std::move(e));
130 error = llvm::toString(std::move(e));
tools/lldb/source/API/SBStream.cpp 27 : m_opaque_up(std::move(rhs.m_opaque_up)), m_is_file(rhs.m_is_file) {}
100 m_opaque_up = std::make_unique<StreamFile>(std::move(file.get()));
tools/lldb/source/API/SBTarget.cpp 230 data.m_impl_up->SetObjectSP(std::move(stats_up));
963 module_list.get(), comp_unit_list.get(), std::move(regexp),
1065 std::move(regexp), false, hardware, move_to_nearest_code);
tools/lldb/source/API/SBVariablesOptions.cpp 232 : m_opaque_up(std::move(lldb_object_ptr)) {}
235 m_opaque_up.reset(std::move(lldb_object_ptr));
tools/lldb/source/Breakpoint/Breakpoint.cpp 194 result_sp->m_options_up = std::move(options_up);
tools/lldb/source/Breakpoint/BreakpointOptions.cpp 525 m_thread_spec_up = std::move(thread_spec_up);
615 auto baton_sp = std::make_shared<CommandBaton>(std::move(cmd_data));
tools/lldb/source/Breakpoint/BreakpointResolverFileRegex.cpp 26 m_regex(std::move(regex)), m_exact_match(exact_match),
72 return new BreakpointResolverFileRegex(bkpt, std::move(regex), names_set,
tools/lldb/source/Breakpoint/BreakpointResolverName.cpp 79 m_class_name(nullptr), m_regex(std::move(func_regex)),
tools/lldb/source/Breakpoint/Watchpoint.cpp 45 std::move(err), "Failed to set type.");
tools/lldb/source/Commands/CommandObjectBreakpoint.cpp 643 llvm::toString(std::move(err)).c_str());
649 &(m_options.m_modules), &(m_options.m_filenames), std::move(regexp),
674 llvm::toString(std::move(err)).c_str());
680 m_options.m_source_regex_func_names, std::move(regexp), internal,
tools/lldb/source/Commands/CommandObjectFrame.cpp 576 "error: %s\n", llvm::toString(std::move(err)).c_str());
tools/lldb/source/Commands/CommandObjectMemory.cpp 785 std::make_unique<StreamFile>(std::move(outfile.get()));
804 output_stream_storage = std::move(outfile_stream_up);
tools/lldb/source/Commands/CommandObjectReproducer.cpp 156 toString(std::move(err)).c_str());
240 SetError(result, std::move(err));
262 std::move(buffer.get()), nullptr, vfs_mapping.GetPath());
tools/lldb/source/Commands/CommandObjectTarget.cpp 2806 Status error = process->WriteObjectFile(std::move(loadables));
tools/lldb/source/Commands/CommandObjectType.cpp 698 category_sp->GetRegexTypeFormatsContainer()->Add(std::move(typeRX),
701 category_sp->GetTypeFormatsContainer()->Add(std::move(typeCS), entry);
1632 category->GetRegexTypeSummariesContainer()->Add(std::move(typeRX), entry);
1640 category->GetTypeSummariesContainer()->Add(std::move(type_name), entry);
2366 category->GetRegexTypeSyntheticsContainer()->Add(std::move(typeRX), entry);
2370 category->GetTypeSyntheticsContainer()->Add(std::move(type_name), entry);
2492 category->GetRegexTypeFiltersContainer()->Add(std::move(typeRX), entry);
2496 category->GetTypeFiltersContainer()->Add(std::move(type_name), entry);
tools/lldb/source/Commands/CommandObjectWatchpointCommand.cpp 232 std::move(data_up));
263 std::make_shared<WatchpointOptions::CommandBaton>(std::move(data_up));
tools/lldb/source/Core/AddressResolverName.cpp 52 m_regex(std::move(func_regex)), m_match_type(AddressResolver::Regexp) {}
tools/lldb/source/Core/FormatEntity.cpp 2018 parent_entry.AppendEntry(std::move(scope_entry));
2269 parent_entry.AppendEntry(std::move(entry));
tools/lldb/source/Core/IOHandler.cpp 328 std::string line = std::move(line_buffer);
tools/lldb/source/Core/Module.cpp 1431 m_old_symfiles.push_back(std::move(m_symfile_up));
tools/lldb/source/Core/StreamFile.cpp 40 m_file_sp = std::move(file.get());
54 m_file_sp = std::move(file.get());
tools/lldb/source/Core/ValueObjectRegister.cpp 267 std::move(err), "Unable to get CompilerType from TypeSystem");
tools/lldb/source/DataFormatters/FormatManager.cpp 965 std::move(any_size_char_arr), string_array_format);
tools/lldb/source/DataFormatters/FormattersHelpers.cpp 34 category_sp->GetTypeFormatsContainer()->Add(std::move(type_name),
45 category_sp->GetTypeSummariesContainer()->Add(std::move(type_name),
58 category_sp->GetTypeSummariesContainer()->Add(std::move(type_name),
72 category_sp->GetTypeSummariesContainer()->Add(std::move(type_name),
86 category_sp->GetTypeSummariesContainer()->Add(std::move(type_name),
101 category_sp->GetTypeSyntheticsContainer()->Add(std::move(type_name),
116 category_sp->GetTypeFiltersContainer()->Add(std::move(type_name),
tools/lldb/source/DataFormatters/VectorType.cpp 230 std::move(err), "Unable to update from scratch TypeSystem");
tools/lldb/source/Expression/IRExecutionUnit.cpp 263 llvm::EngineBuilder builder(std::move(m_module_up));
tools/lldb/source/Expression/Materializer.cpp 871 llvm::toString(std::move(error)).c_str());
tools/lldb/source/Host/common/Editline.cpp 303 return std::move(prompt_stream.GetString());
tools/lldb/source/Host/common/FileCache.cpp 39 m_cache[fd] = std::move(file.get());
tools/lldb/source/Host/common/FileSystem.cpp 66 InstanceImpl().emplace(llvm::vfs::getVFSFromYAML(std::move(buffer.get()),
297 buffer = std::move(*buffer_or_error);
303 buffer = std::move(*buffer_or_error);
305 return std::shared_ptr<DataBufferLLVM>(new DataBufferLLVM(std::move(buffer)));
442 return std::move(file);
tools/lldb/source/Host/common/Host.cpp 589 MonitoringProcessLauncher launcher(std::move(delegate_launcher));
tools/lldb/source/Host/common/MonitoringProcessLauncher.cpp 22 : m_delegate_launcher(std::move(delegate_launcher)) {}
tools/lldb/source/Host/common/NativeProcessProtocol.cpp 373 m_software_breakpoints.emplace(addr, std::move(*expected_bkpt));
tools/lldb/source/Host/common/TaskPool.cpp 46 TaskPoolImpl::GetInstance().AddTask(std::move(task_fn));
63 m_tasks.emplace(std::move(task_fn));
95 std::function<void()> f = std::move(pool->m_tasks.front());
tools/lldb/source/Host/linux/Host.cpp 151 std::unique_ptr<llvm::MemoryBuffer> Cmdline = std::move(*BufferOrError);
196 std::unique_ptr<llvm::MemoryBuffer> Environ = std::move(*BufferOrError);
tools/lldb/source/Host/posix/ConnectionFileDescriptorPosix.cpp 218 m_read_sp = std::move(tcp_socket);
tools/lldb/source/Host/posix/PipePosix.cpp 73 : PipeBase{std::move(pipe_posix)},
78 PipeBase::operator=(std::move(pipe_posix));
tools/lldb/source/Initialization/SystemLifetimeManager.cpp 35 m_initializer = std::move(initializer);
tools/lldb/source/Interpreter/CommandAlias.cpp 53 args = std::move(*args_or);
tools/lldb/source/Interpreter/CommandInterpreter.cpp 2352 FileSP input_file_sp = FileSP(std::move(input_file_up.get()));
tools/lldb/source/Interpreter/CommandObject.cpp 112 args = std::move(*args_or);
tools/lldb/source/Interpreter/OptionValueFormatEntity.cpp 97 m_current_entry = std::move(entry);
tools/lldb/source/Interpreter/OptionValueRegex.cpp 54 error.SetErrorString(llvm::toString(std::move(err)));
tools/lldb/source/Interpreter/Options.cpp 969 return std::move(sstr.str());
1098 return std::move(args_copy);
tools/lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp 1330 new ABIMacOSX_arm(std::move(process_sp), MakeMCRegisterInfo(arch)));
tools/lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.h 90 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
90 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
tools/lldb/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp 1671 new ABIMacOSX_arm64(std::move(process_sp), MakeMCRegisterInfo(arch)));
tools/lldb/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.h 98 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
98 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
tools/lldb/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp 714 new ABIMacOSX_i386(std::move(process_sp), MakeMCRegisterInfo(arch)));
tools/lldb/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.h 97 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
97 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
tools/lldb/source/Plugins/ABI/SysV-arc/ABISysV_arc.cpp 164 ABISP(new ABISysV_arc(std::move(process_sp), MakeMCRegisterInfo(arch))) :
tools/lldb/source/Plugins/ABI/SysV-arm/ABISysV_arm.cpp 1331 new ABISysV_arm(std::move(process_sp), MakeMCRegisterInfo(arch)));
tools/lldb/source/Plugins/ABI/SysV-arm/ABISysV_arm.h 90 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
90 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
tools/lldb/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp 1674 new ABISysV_arm64(std::move(process_sp), MakeMCRegisterInfo(arch)));
tools/lldb/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.h 97 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
97 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
tools/lldb/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp 1018 new ABISysV_hexagon(std::move(process_sp), MakeMCRegisterInfo(arch)));
tools/lldb/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.h 102 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
102 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
tools/lldb/source/Plugins/ABI/SysV-i386/ABISysV_i386.cpp 202 new ABISysV_i386(std::move(process_sp), MakeMCRegisterInfo(arch)));
tools/lldb/source/Plugins/ABI/SysV-i386/ABISysV_i386.h 105 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
105 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
tools/lldb/source/Plugins/ABI/SysV-mips/ABISysV_mips.cpp 560 new ABISysV_mips(std::move(process_sp), MakeMCRegisterInfo(arch)));
tools/lldb/source/Plugins/ABI/SysV-mips/ABISysV_mips.h 92 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
92 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
tools/lldb/source/Plugins/ABI/SysV-mips64/ABISysV_mips64.cpp 558 new ABISysV_mips64(std::move(process_sp), MakeMCRegisterInfo(arch)));
tools/lldb/source/Plugins/ABI/SysV-mips64/ABISysV_mips64.h 105 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
105 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
tools/lldb/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp 222 new ABISysV_ppc(std::move(process_sp), MakeMCRegisterInfo(arch)));
tools/lldb/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.h 101 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
101 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
tools/lldb/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp 74 new ABISysV_ppc64(std::move(process_sp), MakeMCRegisterInfo(arch)));
tools/lldb/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.h 101 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
101 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
tools/lldb/source/Plugins/ABI/SysV-s390x/ABISysV_s390x.cpp 203 return ABISP(new ABISysV_s390x(std::move(process_sp), MakeMCRegisterInfo(arch)));
tools/lldb/source/Plugins/ABI/SysV-s390x/ABISysV_s390x.h 93 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
93 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
tools/lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp 238 return ABISP(new ABISysV_x86_64(std::move(process_sp),
251 new ABISysV_x86_64(std::move(process_sp), MakeMCRegisterInfo(arch)));
tools/lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.h 103 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
103 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
tools/lldb/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.cpp 1096 new ABIWindows_x86_64(std::move(process_sp), MakeMCRegisterInfo(arch)));
tools/lldb/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.h 96 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
96 : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
tools/lldb/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp 977 context_up.get(), std::move(rel_info_up)));
978 disasm_up->setSymbolizer(std::move(symbolizer_up));
991 new MCDisasmInstance(std::move(instr_info_up), std::move(reg_info_up),
991 new MCDisasmInstance(std::move(instr_info_up), std::move(reg_info_up),
992 std::move(subtarget_info_up), std::move(asm_info_up),
992 std::move(subtarget_info_up), std::move(asm_info_up),
993 std::move(context_up), std::move(disasm_up),
993 std::move(context_up), std::move(disasm_up),
994 std::move(instr_printer_up)));
1005 : m_instr_info_up(std::move(instr_info_up)),
1006 m_reg_info_up(std::move(reg_info_up)),
1007 m_subtarget_info_up(std::move(subtarget_info_up)),
1008 m_asm_info_up(std::move(asm_info_up)),
1009 m_context_up(std::move(context_up)), m_disasm_up(std::move(disasm_up)),
1009 m_context_up(std::move(context_up)), m_disasm_up(std::move(disasm_up)),
1010 m_instr_printer_up(std::move(instr_printer_up)) {
tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp 98 LLDB_LOG_ERROR(log, std::move(error), "Couldn't load modules: {0}");
tools/lldb/source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.cpp 150 LLDB_LOG_ERROR(log, std::move(error), "failed to load modules: {0}");
170 LLDB_LOG_ERROR(log, std::move(error), "failed to load modules: {0}");
tools/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp 82 std::move(err), "Failed to get ClangASTContext");
tools/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp 227 m_manager->AddDiagnostic(std::move(new_diagnostic));
275 m_include_directories(std::move(include_directories)),
276 m_filename(std::move(filename)) {
593 m_compiler->getPreprocessor().addPPCallbacks(std::move(pp_callbacks));
937 source_mgr.setMainFileID(source_mgr.createFileID(std::move(memory_buffer)));
976 m_compiler->setASTConsumer(std::move(Consumer));
tools/lldb/source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp 160 : m_diagnostics_engine(std::move(diagnostics_engine)),
161 m_compiler_invocation(std::move(compiler_invocation)),
162 m_compiler_instance(std::move(compiler_instance)),
163 m_parser(std::move(parser)), m_origin_map() {
723 return new ClangModulesDeclVendorImpl(std::move(diagnostics_engine),
724 std::move(invocation),
725 std::move(instance), std::move(parser));
725 std::move(instance), std::move(parser));
tools/lldb/source/Plugins/Language/CPlusPlus/BlockPointer.cpp 48 std::move(err), "Failed to get scratch ClangASTContext");
tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp 119 m_entry = tree_min(std::move(right));
tools/lldb/source/Plugins/Language/ObjC/CoreMedia.cpp 36 std::move(err), "Failed to get scratch type system");
tools/lldb/source/Plugins/Language/ObjC/ObjCLanguage.cpp 946 results.insert(std::move(result));
974 results.insert(std::move(result));
tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp 3828 m_scripts.push_back(std::move(s));
3863 m_allocations.push_back(std::move(a));
4592 std::make_unique<StreamFile>(std::move(file.get()));
tools/lldb/source/Plugins/ObjectFile/Breakpad/BreakpadRecords.cpp 184 return ModuleRecord(OS, Arch, std::move(ID));
211 return InfoRecord(std::move(ID));
tools/lldb/source/Plugins/ObjectFile/Breakpad/BreakpadRecords.h 52 : Record(Module), OS(OS), Arch(Arch), ID(std::move(ID)) {}
67 InfoRecord(UUID ID) : Record(Info), ID(std::move(ID)) {}
tools/lldb/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.cpp 42 return Header{ArchSpec(triple), std::move(uuid)};
85 file_offset, length, std::move(header->arch),
86 std::move(header->uuid));
102 ModuleSpec spec(file, std::move(header->arch));
103 spec.GetUUID() = std::move(header->uuid);
115 m_arch(std::move(arch)), m_uuid(std::move(uuid)) {}
115 m_arch(std::move(arch)), m_uuid(std::move(uuid)) {}
tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp 1745 Segments.insert(Range.GetRangeBase(), Range.GetRangeEnd(), std::move(Seg));
1755 std::move(Sect));
1789 provider.AddSegment(*InfoOr, std::move(Segment));
1837 provider.AddSection(std::move(*InfoOr), std::move(section_sp));
1837 provider.AddSection(std::move(*InfoOr), std::move(section_sp));
1888 section->GetName().AsCString(), llvm::toString(std::move(err)).c_str());
3344 llvm::toString(std::move(error)).c_str());
tools/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp 1528 : EncryptedRanges(std::move(EncryptedRanges)), UnifiedList(UnifiedList) {}
tools/lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp 258 m_owningbin = OWNBINType(std::move(*binary));
tools/lldb/source/Plugins/Platform/Android/AdbClient.cpp 429 sync_service.reset(new SyncService(std::move(m_conn)));
576 : m_conn(std::move(conn)) {}
tools/lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp 61 m_options[&interpreter] = std::move(options);
tools/lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp 345 return std::move(name);
353 return std::move(name);
783 m_remote_signals_sp = std::move(remote_signals_sp);
tools/lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp 377 return std::move(tids);
1602 std::make_pair(thread_id, std::move(*traceMonitor)));
1920 std::make_pair(thread_sp->GetID(), std::move(*traceInstance)));
1969 std::make_pair(threadid, std::move(*traceMonitor)));
tools/lldb/source/Plugins/Process/Linux/ProcessorTrace.cpp 229 StructuredData::ObjectSP(std::move(params_dict)));
267 return std::move(pt_monitor_up);
tools/lldb/source/Plugins/Process/Utility/DynamicRegisterInfo.cpp 30 MoveFrom(std::move(info));
35 MoveFrom(std::move(info));
40 m_regs = std::move(info.m_regs);
41 m_sets = std::move(info.m_sets);
42 m_set_reg_nums = std::move(info.m_set_reg_nums);
43 m_set_names = std::move(info.m_set_names);
44 m_value_regs_map = std::move(info.m_value_regs_map);
45 m_invalidate_regs_map = std::move(info.m_invalidate_regs_map);
46 m_dynamic_reg_size_map = std::move(info.m_dynamic_reg_size_map);
tools/lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp 183 return Status(std::move(error));
518 return std::move(result);
tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp 551 if (SendThreadSpecificPacketAndWaitForResponse(tid, std::move(payload),
3209 tid, std::move(payload), response, false) != PacketResult::Success ||
3224 tid, std::move(payload), response, false) != PacketResult::Success ||
3243 return SendThreadSpecificPacketAndWaitForResponse(tid, std::move(payload),
3257 return SendThreadSpecificPacketAndWaitForResponse(tid, std::move(payload),
3274 tid, std::move(payload), response, false) != PacketResult::Success)
3300 tid, std::move(payload), response, false) != PacketResult::Success)
3646 unescaped_payload.AsRawOstream() << std::move(module_array);
tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.cpp 39 m_packet_handlers[packet_type] = std::move(handler);
119 std::move(error),
120 [&](std::unique_ptr<PacketUnimplementedError> E) { PUE = std::move(E); },
121 [&](std::unique_ptr<llvm::ErrorInfoBase> E) { EIB = std::move(E); });
124 return SendErrorResponse(Status(llvm::Error(std::move(EIB))));
tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp 1169 response_array.push_back(std::move(response));
1173 response.AsRawOstream() << std::move(response_array);
tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp 225 return Status(std::move(Err));
237 m_debugged_process_up = std::move(*process_or);
306 m_debugged_process_up = std::move(*process_or);
532 thread_obj.try_emplace("registers", std::move(*registers));
565 thread_obj.try_emplace("medata", std::move(medata_array));
567 threads_array.push_back(std::move(thread_obj));
668 unescaped_response.AsRawOstream() << std::move(*threads_info);
2768 return std::move(*buffer_or_error);
2830 .insert(std::make_pair(buffer_key, std::move(*buffer_up)))
tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp 229 server_list.push_back(std::move(server));
232 response.AsRawOstream() << std::move(server_list);
tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp 107 StreamFile stream(std::move(file.get()));
1806 gdb_thread->SetQueueInfo(std::move(queue_name), queue_kind,
2331 LLDB_LOG_ERROR(log, std::move(error), "Failed to load modules: {0}");
2336 expedited_register_map[reg] = std::move(value);
tools/lldb/source/Plugins/Process/minidump/MinidumpParser.cpp 34 return MinidumpParser(data_sp, std::move(*ExpectedFile));
39 : m_data_sp(std::move(data_sp)), m_file(std::move(file)) {}
39 : m_data_sp(std::move(data_sp)), m_file(std::move(file)) {}
531 return std::make_pair(std::move(result), is_complete);
tools/lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp 93 unified_section_list.AddSection(std::move(section_sp));
157 std::move(AllData));
170 m_core_data(std::move(core_data)), m_is_wow64(false) {}
199 m_minidump_parser = std::move(*expected_parser);
tools/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp 413 *this = std::move(s.get());
680 return std::move(item.get());
734 llvm::consumeError(std::move(error));
1074 return std::move(backtrace.get());
1535 function = std::move(f.get());
tools/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h 133 return std::move(thing);
151 return std::move(thing);
394 return T(PyRefType::Borrowed, std::move(obj.get().get()));
604 return std::move(mod.get());
729 return std::move(expected.get());
771 return std::move(error);
tools/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp 562 std::move(data_up));
584 std::make_shared<WatchpointOptions::CommandBaton>(std::move(data_up));
939 input_file_sp = std::move(nullin.get());
940 error_file_sp = output_file_sp = std::make_shared<StreamFile>(std::move(nullout.get()));
1102 PythonObject py_return = std::move(maybe_py_return.get());
1207 return Status(std::move(error));
1281 std::make_shared<BreakpointOptions::CommandBaton>(std::move(cmd_data_up));
1309 std::make_shared<BreakpointOptions::CommandBaton>(std::move(data_up));
1333 std::make_shared<WatchpointOptions::CommandBaton>(std::move(data_up));
tools/lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp 292 error.SetErrorString(llvm::toString(std::move(err)));
tools/lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp 162 return FileSpecList(std::move(result));
246 support_files = std::move(*data.support_files);
358 symtab.AddSymbol(std::move(KV.second));
tools/lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h 36 return new SymbolFileBreakpad(std::move(objfile_sp));
41 : SymbolFile(std::move(objfile_sp)) {}
tools/lldb/source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.cpp 48 module, std::move(apple_names_table_up),
49 std::move(apple_namespaces_table_up), std::move(apple_types_table_up),
49 std::move(apple_namespaces_table_up), std::move(apple_types_table_up),
50 std::move(apple_objc_table_up));
tools/lldb/source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.h 28 : DWARFIndex(module), m_apple_names_up(std::move(apple_names)),
29 m_apple_namespaces_up(std::move(apple_namespaces)),
30 m_apple_types_up(std::move(apple_types)),
31 m_apple_objc_up(std::move(apple_objc)) {}
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp 2077 std::move(bases));
3036 base_classes.push_back(std::move(result));
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.cpp 118 std::move(err), "Unable to get DWARFASTParser");
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp 329 result.push_back(std::move(parent));
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp 45 return std::move(error);
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp 211 return std::move(*expected_ranges);
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp 348 m_dwo_symbol_file = std::move(dwo_symbol_file);
tools/lldb/source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.cpp 30 return std::move(E);
33 module, std::move(index_up), debug_names, debug_str, *debug_info));
81 handleErrors(std::move(error), [](const DebugNames::SentinelError &) {}),
tools/lldb/source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.h 55 m_debug_names_up(std::move(debug_names_up)),
tools/lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.h 24 m_units_to_avoid(std::move(units_to_avoid)) {}
tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp 170 LLDB_LOG_ERROR(log, std::move(e),
255 return new SymbolFileDWARF(std::move(objfile_sp),
403 : SymbolFile(std::move(objfile_sp)),
466 m_index = std::move(*index_or);
616 LLDB_LOG_ERROR(log, std::move(error),
621 m_abbr = std::move(abbr);
803 std::move(err), "Unable to parse function");
901 LLDB_LOG_ERROR(log, std::move(error),
1990 std::move(err),
2869 std::move(err), "Cannot get TypeSystem for language {}",
2974 std::move(err), "Unable to parse type");
3787 std::move(parameters));
tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp 241 return new SymbolFileDWARFDebugMap(std::move(objfile_sp));
245 : SymbolFile(std::move(objfile_sp)), m_flags(), m_compile_unit_infos(),
tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwp.cpp 80 : m_obj_file(std::move(obj_file)), m_debug_cu_index(llvm::DW_SECT_INFO)
tools/lldb/source/Plugins/SymbolFile/NativePDB/CompileUnitIndex.cpp 112 : m_id(id), m_debug_stream(std::move(debug_stream)),
113 m_module_descriptor(std::move(descriptor)) {}
133 cci = std::make_unique<CompilandIndexItem>(PdbCompilandId{ modi }, debug_stream, std::move(descriptor));
138 std::move(stream_data));
143 PdbCompilandId{modi}, std::move(debug_stream), std::move(descriptor));
143 PdbCompilandId{modi}, std::move(debug_stream), std::move(descriptor));
tools/lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp 194 qname.insert(4, std::move(piece));
198 return std::move(child);
346 llvm::consumeError(std::move(error));
693 llvm::consumeError(std::move(error));
tools/lldb/source/Plugins/SymbolFile/NativePDB/PdbIndex.cpp 56 result->m_file = std::move(file);
58 return std::move(result);
181 result.push_back({std::move(sym), iter->second});
tools/lldb/source/Plugins/SymbolFile/NativePDB/PdbUtil.cpp 59 return CVTagRecord(std::move(cr));
64 return CVTagRecord(std::move(ur));
69 return CVTagRecord(std::move(er));
77 : cvclass(std::move(c)),
80 : cvunion(std::move(u)), m_kind(Union) {}
81 CVTagRecord::CVTagRecord(EnumRecord &&e) : cvenum(std::move(e)), m_kind(Enum) {}
645 result.ranges = std::move(ranges);
652 result.ranges = std::move(ranges);
668 result.ranges = std::move(ranges);
675 result.ranges = std::move(ranges);
tools/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp 90 std::unique_ptr<llvm::MemoryBuffer> Buffer = std::move(*ErrorOrBuffer);
94 std::move(Buffer), llvm::support::little);
96 auto File = std::make_unique<PDBFile>(Path, std::move(Stream), Allocator);
98 llvm::consumeError(std::move(EC));
102 llvm::consumeError(std::move(EC));
120 OwningBinary<Binary> binary = std::move(*expected_binary);
270 return new SymbolFileNativePDB(std::move(objfile_sp));
274 : SymbolFile(std::move(objfile_sp)) {}
302 auto expected_index = PdbIndex::create(std::move(file_up));
307 m_index = std::move(*expected_index);
330 std::move(err), "Failed to initialize");
1083 llvm::consumeError(std::move(EC));
1125 last_line.getEndLine(), std::move(sequence));
tools/lldb/source/Plugins/SymbolFile/NativePDB/UdtRecordCompleter.cpp 67 std::make_pair(vtable_idx.getValueOr(0), std::move(base_spec)));
224 bases.push_back(std::move(ib.second));
227 clang.TransferBaseClasses(m_derived_ct.GetOpaqueQualType(), std::move(bases));
tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp 1315 base_classes.push_back(std::move(base_spec));
1329 std::move(base_classes));
tools/lldb/source/Plugins/SymbolFile/PDB/PDBLocationToDWARFExpression.cpp 50 found = std::move(fd);
tools/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp 123 return new SymbolFilePDB(std::move(objfile_sp));
127 : SymbolFile(std::move(objfile_sp)), m_session_up(), m_global_scope_up() {}
142 llvm::consumeError(std::move(error));
153 llvm::consumeError(std::move(error));
307 std::move(err), "Unable to parse PDBFunc");
561 std::move(err), "Unable to ResolveTypeUID");
598 std::move(err), "Unable to get dynamic array info for UID");
620 std::move(err), "Unable to get decl for UID");
650 std::move(err), "Unable to get DeclContext for UID");
680 std::move(err), "Unable to get DeclContext containing UID");
709 std::move(err), "Unable to parse decls for context");
1450 std::move(err), "Unable to dump ClangAST");
1662 std::move(err), "Unable to get PDB AST parser");
1683 std::move(err), "Unable to find namespace {}",
1992 std::move(err),
tools/lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp 47 return new SymbolFileSymtab(std::move(objfile_sp));
55 : SymbolFile(std::move(objfile_sp)), m_source_indexes(), m_func_indexes(),
tools/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp 176 LLDB_LOG_ERROR(log, std::move(err),
tools/lldb/source/Symbol/ClangASTImporter.cpp 959 LLDB_LOG_ERROR(log, std::move(err),
tools/lldb/source/Symbol/DWARFCallFrameInfo.cpp 477 m_cie_map[current_entry] = std::move(cie_sp);
tools/lldb/source/Symbol/Function.cpp 133 : return_pc(return_pc), parameters(std::move(parameters)), resolved(false) {
tools/lldb/source/Symbol/Type.cpp 527 std::move(err),
tools/lldb/source/Symbol/TypeSystem.cpp 235 llvm::consumeError(std::move(error));
243 return std::move(error);
252 llvm::consumeError(std::move(error));
260 return std::move(error);
275 llvm::consumeError(std::move(error));
286 return std::move(error);
304 llvm::consumeError(std::move(error));
312 return std::move(error);
321 llvm::consumeError(std::move(error));
329 return std::move(error);
344 llvm::consumeError(std::move(error));
355 return std::move(error);
tools/lldb/source/Target/JITLoader.cpp 26 list.Append(std::move(instance_sp));
tools/lldb/source/Target/Language.cpp 417 results.insert(std::move(scavengeresult));
tools/lldb/source/Target/ModuleCache.cpp 165 m_file_up = std::move(file.get());
tools/lldb/source/Target/Process.cpp 5841 region_list.push_back(std::move(region_info));
tools/lldb/source/Target/StackFrame.cpp 1372 std::move(err), "Unable to guess value for given address");
tools/lldb/source/Target/StackFrameList.cpp 292 path = std::move(solution_path);
tools/lldb/source/Target/Target.cpp 315 nullptr, std::move(source_regex), function_names,
559 nullptr, std::move(func_regex), requested_language, 0, skip));
2177 std::move(err),
2196 llvm::toString(std::move(err)).c_str());
2219 llvm::toString(std::move(err)).c_str());
2243 llvm::toString(std::move(err)).c_str());
2264 std::move(err), "Couldn't get scratch ClangASTContext");
2368 std::move(err), "Unable to get scratch type system");
2451 llvm::consumeError(std::move(error));
2456 return std::move(error);
3148 LLDB_LOG_ERROR(log, std::move(Err), "SetUpPtyRedirection failed: {0}");
3698 m_launch_info.GetEnvironment() = std::move(env);
tools/lldb/source/Target/ThreadPlanTracer.cpp 102 std::move(err),
tools/lldb/source/Utility/Broadcaster.cpp 31 m_manager_sp(std::move(manager_sp)), m_broadcaster_name(name) {
63 listeners.emplace_back(std::move(curr_listener_sp), it->second);
tools/lldb/source/Utility/DataBufferLLVM.cpp 22 : Buffer(std::move(MemBuffer)) {
tools/lldb/source/Utility/Listener.cpp 30 : m_manager_sp(std::move(manager_sp)) {}
194 BroadcasterManagerWPMatcher matcher(std::move(manager_sp));
tools/lldb/source/Utility/Reproducer.cpp 147 : m_root(MakeAbsolute(std::move(root))), m_done(false) {
156 provider->DynamicClassID(), std::move(provider));
157 auto e = m_providers.insert(std::move(key_value));
202 : m_root(MakeAbsolute(std::move(root))), m_loaded(false) {}
237 auto recorder = std::make_unique<DataRecorder>(std::move(filename), ec);
240 return std::move(recorder);
255 m_data_recorders.push_back(std::move(*recorder_or_error));
329 return std::make_unique<CommandLoader>(std::move(files));
tools/lldb/source/Utility/ReproducerInstrumentation.cpp 70 m_replayers[RunID] = std::make_pair(std::move(replayer), id);
72 std::make_pair(m_replayers[RunID].first.get(), std::move(signature));
tools/lldb/source/Utility/Status.cpp 67 std::move(error), [&](std::unique_ptr<llvm::ECError> e) -> llvm::Error {
74 return llvm::Error(std::move(e));
80 SetErrorString(llvm::toString(std::move(error)));
tools/lldb/tools/argdumper/argdumper.cpp 18 llvm::outs() << json::Object({{"arguments", std::move(Arguments)}});
tools/lldb/tools/driver/Driver.h 56 : contents(std::move(contents)), is_file(in_is_file),
tools/lldb/tools/lldb-server/Acceptor.cpp 126 new Acceptor(std::move(listener_socket_up), name, local_socket_id));
134 : m_listener_socket_up(std::move(listener_socket)), m_name(name.str()),
tools/lldb/tools/lldb-server/lldb-gdbserver.cpp 349 error = gdb_server.InitializeConnection(std::move(connection_up));
tools/lldb/tools/lldb-server/lldb-platform.cpp 312 platform.SetPortMap(std::move(gdbserver_portmap));
tools/lldb/tools/lldb-server/lldb-server.cpp 44 llvm::consumeError(std::move(e));
tools/lldb/tools/lldb-test/lldb-test.cpp 304 return std::move(*MB);
358 return std::move(OS.str());
557 CU = std::move(Candidate);
816 WithColor::error() << toString(std::move(E)) << "\n";
1074 WithColor::error() << "initialization failed: " << toString(std::move(e))
tools/lldb/tools/lldb-vscode/ExceptionBreakpoint.h 25 filter(std::move(f)),
26 label(std::move(l)),
tools/lldb/tools/lldb-vscode/IOStream.cpp 28 *this = std::move(other);
tools/lldb/tools/lldb-vscode/JSONUtils.cpp 233 return llvm::json::Value(std::move(object));
289 return llvm::json::Value(std::move(object));
302 return llvm::json::Value(std::move(object));
391 return llvm::json::Value(std::move(object));
472 return llvm::json::Value(std::move(object));
555 g_vsc.source_map[sourceReference] = std::move(source);
559 return llvm::json::Value(std::move(object));
636 return llvm::json::Value(std::move(object));
668 return llvm::json::Value(std::move(object));
782 event.try_emplace("body", std::move(body));
783 return llvm::json::Value(std::move(event));
869 return llvm::json::Value(std::move(object));
tools/lldb/tools/lldb-vscode/VSCode.cpp 215 event.try_emplace("body", std::move(body));
216 SendJSON(llvm::json::Value(std::move(event)));
278 return llvm::json::Value(std::move(scopes));
tools/lldb/tools/lldb-vscode/lldb-vscode.cpp 130 event.try_emplace("body", std::move(body));
131 g_vsc.SendJSON(llvm::json::Value(std::move(event)));
139 event.try_emplace("body", std::move(body));
140 g_vsc.SendJSON(llvm::json::Value(std::move(event)));
150 g_vsc.SendJSON(llvm::json::Value(std::move(event)));
305 event.try_emplace("body", std::move(body));
306 g_vsc.SendJSON(llvm::json::Value(std::move(event)));
400 bp_event.try_emplace("body", std::move(body));
401 g_vsc.SendJSON(llvm::json::Value(std::move(bp_event)));
531 g_vsc.SendJSON(llvm::json::Value(std::move(response)));
584 g_vsc.SendJSON(llvm::json::Value(std::move(response)));
657 response.try_emplace("body", std::move(body));
658 g_vsc.SendJSON(llvm::json::Value(std::move(response)));
695 g_vsc.SendJSON(llvm::json::Value(std::move(response)));
777 g_vsc.SendJSON(llvm::json::Value(std::move(response)));
820 response.try_emplace("body", std::move(body));
821 g_vsc.SendJSON(llvm::json::Value(std::move(response)));
970 response.try_emplace("body", std::move(body));
971 g_vsc.SendJSON(llvm::json::Value(std::move(response)));
1097 body.try_emplace("exceptionBreakpointFilters", std::move(filters));
1139 response.try_emplace("body", std::move(body));
1140 g_vsc.SendJSON(llvm::json::Value(std::move(response)));
1228 g_vsc.SendJSON(llvm::json::Value(std::move(response)));
1276 g_vsc.SendJSON(llvm::json::Value(std::move(response)));
1335 g_vsc.SendJSON(llvm::json::Value(std::move(response)));
1379 g_vsc.SendJSON(llvm::json::Value(std::move(response)));
1454 response.try_emplace("body", std::move(body));
1455 g_vsc.SendJSON(llvm::json::Value(std::move(response)));
1583 request_bps[src_bp.line] = std::move(src_bp);
1629 old_src_bp_pos->second[pair.first] = std::move(pair.second);
1640 g_vsc.source_breakpoints[path] = std::move(request_bps);
1644 body.try_emplace("breakpoints", std::move(response_breakpoints));
1645 response.try_emplace("body", std::move(body));
1646 g_vsc.SendJSON(llvm::json::Value(std::move(response)));
1721 g_vsc.SendJSON(llvm::json::Value(std::move(response)));
1815 request_bps[func_bp.functionName] = std::move(func_bp);
1849 g_vsc.function_breakpoints[pair.first()] = std::move(pair.second);
1853 body.try_emplace("breakpoints", std::move(response_breakpoints));
1854 response.try_emplace("body", std::move(body));
1855 g_vsc.SendJSON(llvm::json::Value(std::move(response)));
1930 response.try_emplace("body", std::move(body));
1931 g_vsc.SendJSON(llvm::json::Value(std::move(response)));
2024 body.try_emplace("stackFrames", std::move(stackFrames));
2025 response.try_emplace("body", std::move(body));
2026 g_vsc.SendJSON(llvm::json::Value(std::move(response)));
2087 g_vsc.SendJSON(llvm::json::Value(std::move(response)));
2139 g_vsc.SendJSON(llvm::json::Value(std::move(response)));
2193 body.try_emplace("threads", std::move(threads));
2194 response.try_emplace("body", std::move(body));
2195 g_vsc.SendJSON(llvm::json::Value(std::move(response)));
2385 response.try_emplace("body", std::move(body));
2386 g_vsc.SendJSON(llvm::json::Value(std::move(response)));
2530 body.try_emplace("variables", std::move(variables));
2531 response.try_emplace("body", std::move(body));
2532 g_vsc.SendJSON(llvm::json::Value(std::move(response)));
2548 body.try_emplace("breakpoints", std::move(response_breakpoints));
2549 response.try_emplace("body", std::move(body));
2550 g_vsc.SendJSON(llvm::json::Value(std::move(response)));
tools/lldb/unittests/Expression/DWARFExpressionTest.cpp 136 m_sections_map = std::move(*sections_map);
tools/lldb/unittests/Expression/DiagnosticManagerTest.cpp 47 mgr.AddDiagnostic(std::move(diag));
tools/lldb/unittests/Host/MainLoopTest.cpp 51 socketpair[0] = std::move(connect_socket_up);
tools/lldb/unittests/Process/POSIX/NativeProcessELFTest.cpp 59 .WillOnce(Return(ByMove(std::move(auxv_buffer))));
78 .WillOnce(Return(ByMove(std::move(auxv_buffer))));
127 .WillOnce(Return(ByMove(std::move(auxv_buffer))));
tools/lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationServerTest.cpp 44 server.SendErrorResponse(std::move(error));
54 server.SendErrorResponse(std::move(error));
67 server.SendErrorResponse(std::move(error));
tools/lldb/unittests/Process/minidump/MinidumpParserTest.cpp 51 parser = std::move(*expected_parser);
66 auto expected_parser = MinidumpParser::Create(std::move(data_buffer_sp));
69 parser = std::move(*expected_parser);
tools/lldb/unittests/Symbol/TestClangASTContext.cpp 358 bases.push_back(std::move(non_empty_base_spec));
360 std::move(bases));
381 bases.push_back(std::move(non_empty_vbase_spec));
383 std::move(bases));
tools/lldb/unittests/Symbol/TestLineEntry.cpp 59 m_file.emplace(std::move(*ExpectedFile));
tools/lldb/unittests/SymbolFile/DWARF/SymbolFileDWARFTests.cpp 243 llvm::toString(std::move(error)));
272 llvm::toString(std::move(error)));
301 llvm::toString(std::move(error)));
327 "null entry", llvm::toString(std::move(error)));
tools/lldb/unittests/TestingSupport/Host/NativeProcessTestUtils.h 108 return std::move(Data);
tools/lldb/unittests/TestingSupport/TestUtilities.cpp 46 return TestFile(Name, std::move(Remover));
tools/lldb/unittests/TestingSupport/TestUtilities.h 37 TestFile(TestFile &&RHS) : Name(std::move(RHS.Name)) {
tools/lldb/unittests/Utility/RegularExpressionTest.cpp 37 consumeError(std::move(err));
47 consumeError(std::move(err));
tools/lldb/unittests/Utility/StatusTest.cpp 49 std::error_code ec = llvm::errorToErrorCode(std::move(eagain));
55 EXPECT_EQ("foo", llvm::toString(std::move(foo)));
tools/lldb/unittests/Utility/StringListTest.cpp 66 s.AppendString(std::move(foo));
70 s.AppendString(std::move(bar));
108 s << std::move(foo);
112 s << std::move(bar);
377 s.InsertStringAtIndex(0, std::move(foo));
tools/lldb/unittests/tools/lldb-server/tests/MessageObjects.cpp 62 m_registers(std::move(registers)) {}
90 Result[Register] = std::move(*RegValOr);
92 return std::move(Result);
127 ThreadInfo(name, reason, std::move(*RegsOr), signal);
200 return std::move(Info);
261 Result[Reg] = std::move(*RegValOr);
263 return std::move(Result);
315 ThreadPcs[Id] = std::move(*PcOr);
323 std::move(ThreadPcs),
324 std::move(*RegistersOr), Reason);
tools/lldb/unittests/tools/lldb-server/tests/MessageObjects.h 113 ThreadPcs(std::move(ThreadPcs)), Registers(std::move(Registers)),
113 ThreadPcs(std::move(ThreadPcs)), Registers(std::move(Registers)),
tools/lldb/unittests/tools/lldb-server/tests/TestBase.h 50 Client = std::move(*ClientOr);
tools/lldb/unittests/tools/lldb-server/tests/TestClient.cpp 115 auto Client = std::unique_ptr<TestClient>(new TestClient(std::move(Conn)));
118 return std::move(E);
122 return std::move(E);
125 return std::move(Client);
217 m_process_info = std::move(*InfoOr);
229 m_register_infos.emplace_back(std::move(*InfoOr));
255 m_stop_reply = std::move(*StopReplyOr);
tools/lldb/unittests/tools/lldb-server/tests/TestClient.h 106 return std::move(E);
tools/lli/RemoteJITUtils.h 83 this->MemMgr = std::move(MemMgr);
87 this->Resolver = std::move(Resolver);
tools/lli/lli.cpp 330 EE.addModule(std::move(M));
407 EngineBuilder builder(std::move(Owner));
478 EE->addModule(std::move(XMod));
490 EE->addObjectFile(std::move(O));
512 object::OwningBinary<object::Archive> OB(std::move(Ar), std::move(ArBuf));
512 object::OwningBinary<object::Archive> OB(std::move(Ar), std::move(ArBuf));
514 EE->addArchive(std::move(OB));
652 ES.setErrorReporter([&](Error Err) { ExitOnErr(std::move(Err)); });
661 std::move(RemoteMM));
805 J->addLazyIRModule(orc::ThreadSafeModule(std::move(MainModule), TSCtx)));
833 J->addLazyIRModule(JD, orc::ThreadSafeModule(std::move(M), TSCtx)));
850 ExitOnErr(J->addObjectFile(std::move(Obj)));
tools/llvm-ar/llvm-ar.cpp 157 handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EIB) {
262 ArchiveBuffers.push_back(std::move(*BufOrErr));
267 Archives.push_back(std::move(*LibOrErr));
621 failIfError(std::move(Err));
667 failIfError(std::move(Err));
671 Members.push_back(std::move(*NMOrErr));
705 failIfError(std::move(Err));
709 Members.push_back(std::move(*NMOrErr));
821 failIfError(std::move(Err));
836 Ret.insert(Ret.begin() + Pos, std::move(M));
918 Kind, Deterministic, Thin, std::move(OldArchiveBuf));
919 failIfError(std::move(E), ArchiveName);
950 performWriteOperation(Operation, OldArchive, std::move(OldArchiveBuf),
972 failIfError(std::move(Err), "unable to load '" + ArchiveName + "'");
975 performOperation(Operation, &Archive, std::move(Buf.get()), NewMembers);
1035 failIfError(std::move(Err));
tools/llvm-as/llvm-as.cpp 124 std::unique_ptr<Module> M = std::move(ModuleAndIndex.Mod);
129 std::unique_ptr<ModuleSummaryIndex> Index = std::move(ModuleAndIndex.Index);
tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp 76 return std::move(E);
78 std::unique_ptr<MemoryBuffer> MemBuf = std::move(*MemBufOrErr);
83 return std::move(MemBuf);
tools/llvm-cat/llvm-cat.cpp 82 OwnedMods.push_back(std::move(M));
tools/llvm-cfi-verify/lib/FileAnalysis.cpp 81 object::OwningBinary<object::Binary> Binary = std::move(BinaryOrErr.get());
82 FileAnalysis Analysis(std::move(Binary));
103 return std::move(InitResponse);
106 return std::move(SectionParseResponse);
109 return std::move(SymbolTableParseResponse);
111 return std::move(Analysis);
115 : Binary(std::move(Binary)) {}
tools/llvm-cfi-verify/llvm-cfi-verify.cpp 69 std::unique_ptr<MemoryBuffer> File = std::move(FileOrErr.get());
tools/llvm-cov/CodeCoverage.cpp 247 LoadedSourceFiles.emplace_back(SourceFile, std::move(Buffer.get()));
267 ViewOpts, std::move(ExpansionCoverage));
269 View.addExpansion(Expansion.Region, std::move(SubView));
286 std::move(FunctionCoverage));
304 ViewOpts, std::move(FileCoverage));
323 Funcname, SourceBuffer.get(), ViewOpts, std::move(SubViewCoverage));
332 View->addInstantiation(Funcname, Line, std::move(SubView));
357 error("Failed to load coverage: " + toString(std::move(E)),
361 auto Coverage = std::move(CoverageOrErr.get());
496 std::unique_ptr<MemoryBuffer> DemanglerBuf = std::move(*BufOrError);
527 error("Could not create view file!", toString(std::move(E)));
530 auto OS = std::move(OSOrErr.get());
535 Printer->closeViewFile(std::move(OS));
724 Filters.push_back(std::move(NameFilterer));
744 Filters.push_back(std::move(StatFilterer));
894 error("Could not create index file!", toString(std::move(E)));
915 error("Could not create view file!", toString(std::move(E)));
918 auto OS = std::move(OSOrErr.get());
932 Printer->closeViewFile(std::move(OS));
tools/llvm-cov/CoverageExporterJson.cpp 171 FileArray.push_back(std::move(File));
219 {{"files", std::move(Files)}, {"totals", renderSummary(Totals)}});
224 auto ExportArray = json::Array({std::move(Export)});
228 {"data", std::move(ExportArray)}});
tools/llvm-cov/CoverageFilters.cpp 57 Filters.push_back(std::move(Filter));
tools/llvm-cov/SourceCoverageView.cpp 72 return std::move(OS);
145 SourceName, File, Options, std::move(CoverageInfo));
148 SourceName, File, Options, std::move(CoverageInfo));
167 ExpansionSubViews.emplace_back(Region, std::move(View));
173 InstantiationSubViews.emplace_back(FunctionName, Line, std::move(View));
tools/llvm-cov/SourceCoverageView.h 36 : Region(Region), View(std::move(View)) {}
38 : Region(std::move(RHS.Region)), View(std::move(RHS.View)) {}
38 : Region(std::move(RHS.Region)), View(std::move(RHS.View)) {}
40 Region = std::move(RHS.Region);
41 View = std::move(RHS.View);
62 : FunctionName(FunctionName), Line(Line), View(std::move(View)) {}
236 CoverageInfo(std::move(CoverageInfo)) {}
tools/llvm-cov/SourceCoverageViewHTML.cpp 289 OwnedStream OS = std::move(OSOrErr.get());
298 return std::move(OS);
397 OwnedStream CSS = std::move(CSSOrErr.get());
404 auto OS = std::move(OSOrErr.get());
tools/llvm-cov/SourceCoverageViewHTML.h 91 : SourceCoverageView(SourceName, File, Options, std::move(CoverageInfo)) {
tools/llvm-cov/SourceCoverageViewText.cpp 36 auto OS = std::move(OSOrErr.get());
tools/llvm-cov/SourceCoverageViewText.h 82 : SourceCoverageView(SourceName, File, Options, std::move(CoverageInfo)) {
tools/llvm-cvtres/llvm-cvtres.cpp 88 handleAllErrors(std::move(EC),
102 return std::move(EC.get());
203 std::unique_ptr<FileOutputBuffer> FileBuffer = std::move(*FileOrErr);
tools/llvm-cxxdump/llvm-cxxdump.cpp 52 logAllUnhandledErrors(std::move(Err), WithColor::error(outs()),
62 return std::move(*EO);
508 logAllUnhandledErrors(std::move(E), OS);
522 error(std::move(Err));
tools/llvm-cxxmap/llvm-cxxmap.cpp 69 exitWithError(toString(std::move(E)), Whence);
83 exitWithError(std::move(E));
tools/llvm-diff/DiffLog.h 43 Arguments(std::move(L.Arguments)) {
tools/llvm-dwarfdump/llvm-dwarfdump.cpp 480 error(Filename, errorToErrorCode(std::move(Err)));
527 std::unique_ptr<MemoryBuffer> Buffer = std::move(BuffOrErr.get());
tools/llvm-dwp/DWPError.h 11 DWPError(std::string Info) : Info(std::move(Info)) {}
tools/llvm-dwp/llvm-dwp.cpp 368 llvm::toString(std::move(E)))
385 return createError(Name, std::move(E));
499 DWOPaths.push_back(std::move(DWOName));
502 return std::move(DWOPaths);
541 Objects.push_back(std::move(*ErrOrObj));
742 logAllUnhandledErrors(std::move(Err), WithColor::error());
tools/llvm-elfabi/ELFObjHandler.cpp 70 consumeError(std::move(Err));
280 TargetStub.Symbols.insert(std::move(Sym));
312 return std::move(Err);
363 return appendToError(std::move(SymReadError),
367 return std::move(DestStub);
tools/llvm-elfabi/ErrorCollector.cpp 25 Errors.push_back(std::move(Err));
35 JoinedErrors = joinErrors(std::move(JoinedErrors), std::move(E));
35 JoinedErrors = joinErrors(std::move(JoinedErrors), std::move(E));
60 consumeError(std::move(E));
tools/llvm-elfabi/llvm-elfabi.cpp 82 std::unique_ptr<MemoryBuffer> FileReadBuffer = std::move(*BufOrError);
91 return std::move(*StubFromELF);
102 return std::move(*StubFromTBE);
128 std::unique_ptr<ELFStub> TargetStub = std::move(StubOrErr.get());
tools/llvm-exegesis/lib/Analysis.cpp 158 : Clustering_(Clustering), InstrInfo_(std::move(InstrInfo)),
210 : RSC(std::move(RSC)) {}
238 Entries.push_back(std::move(Entry));
tools/llvm-exegesis/lib/Assembler.cpp 138 RegistersSetUp(std::move(RegistersSetUp)) {}
197 FunctionFiller Sink(MF, std::move(RegistersSetUp));
257 return object::OwningBinary<object::ObjectFile>(std::move(Obj),
258 std::move(Buffer));
311 ExecEngine->addObjectFile(std::move(ObjectFileHolder));
tools/llvm-exegesis/lib/BenchmarkRunner.cpp 40 : Function(State.createTargetMachine(), std::move(Obj)),
123 InstrBenchmark.Error = toString(std::move(E));
137 const FunctionExecutorImpl Executor(State, std::move(ObjectFile),
141 InstrBenchmark.Error = toString(std::move(E));
144 InstrBenchmark.Measurements = std::move(*Measurements);
164 return std::move(E);
tools/llvm-exegesis/lib/Clustering.cpp 323 return std::move(Error);
tools/llvm-exegesis/lib/Latency.cpp 101 CodeTemplates.push_back(std::move(CT));
122 CT.Instructions.push_back(std::move(IT));
123 CodeTemplates.push_back(std::move(CT));
141 CT.Instructions.push_back(std::move(ThisIT));
142 CT.Instructions.push_back(std::move(OtherIT));
143 CodeTemplates.push_back(std::move(CT));
169 return std::move(Results);
209 return std::move(Result);
tools/llvm-exegesis/lib/LlvmState.cpp 44 new RegisterAliasingTrackerCache(getRegInfo(), std::move(ReservedRegs)));
tools/llvm-exegesis/lib/MCInstrDescView.cpp 340 Configurations.push_back(std::move(ARO));
tools/llvm-exegesis/lib/PerfHelper.cpp 49 : EventString(std::move(Other.EventString)),
50 FullQualifiedEventString(std::move(Other.FullQualifiedEventString)),
tools/llvm-exegesis/lib/SnippetFile.cpp 68 Result->Key.RegisterInitialValues.push_back(std::move(RegVal));
128 SM.AddNewSourceBuffer(std::move(BufferPtr.get()), SMLoc());
159 return std::vector<BenchmarkCode>{std::move(Result)};
tools/llvm-exegesis/lib/SnippetGenerator.cpp 29 Result.push_back(std::move(CT));
83 Output.push_back(std::move(BC));
153 CT.Instructions.push_back(std::move(IT));
154 return std::move(Result);
164 return std::move(Result);
tools/llvm-exegesis/lib/Uops.cpp 114 Instructions.push_back(std::move(IT));
134 PossibleRegsForVar.push_back(std::move(PossibleRegs));
156 Instructions.push_back(std::move(TmpIT));
172 CT.Instructions.push_back(std::move(IT));
174 return getSingleton(std::move(CT));
178 CT.Instructions.push_back(std::move(IT));
180 return getSingleton(std::move(CT));
188 return getSingleton(std::move(CT));
217 CT.Instructions.push_back(std::move(IT));
219 return getSingleton(std::move(CT));
246 return std::move(Result);
tools/llvm-exegesis/lib/X86/Target.cpp 229 CT.Instructions.push_back(std::move(IT));
233 Result.push_back(std::move(CT));
235 return std::move(Result);
241 return std::move(Result);
259 return std::move(E);
310 return std::move(E);
464 return std::move(Instructions);
479 return std::move(Instructions);
493 return std::move(Instructions);
499 return std::move(Instructions);
tools/llvm-exegesis/llvm-exegesis.cpp 313 report_fatal_error(std::move(Err));
356 const Analysis Analyzer(*TheTarget, std::move(InstrInfo), Clustering,
tools/llvm-ifs/llvm-ifs.cpp 178 : IfsVersion(std::move(Stub.IfsVersion)), Triple(std::move(Stub.Triple)),
178 : IfsVersion(std::move(Stub.IfsVersion)), Triple(std::move(Stub.Triple)),
179 ObjectFileFormat(std::move(Stub.ObjectFileFormat)),
180 SOName(std::move(Stub.SOName)), NeededLibs(std::move(Stub.NeededLibs)),
180 SOName(std::move(Stub.SOName)), NeededLibs(std::move(Stub.NeededLibs)),
181 Symbols(std::move(Stub.Symbols)) {}
210 std::unique_ptr<MemoryBuffer> FileReadBuffer = std::move(*BufOrError);
218 return std::move(Stub);
415 std::unique_ptr<IFSStub> TargetStub = std::move(StubOrErr.get());
tools/llvm-isel-fuzzer/llvm-isel-fuzzer.cpp 62 return std::make_unique<IRMutator>(std::move(Types), std::move(Strategies));
62 return std::make_unique<IRMutator>(std::move(Types), std::move(Strategies));
tools/llvm-jitlink/llvm-jitlink.cpp 237 return std::move(Err);
238 return std::move(Allocator);
249 IPMMAlloc(AllocationMap SegBlocks) : SegBlocks(std::move(SegBlocks)) {}
325 Blocks[KV.first] = std::move(SegMem);
328 new IPMMAlloc(std::move(Blocks)));
396 : MemMgr(createMemoryManager()), ObjLayer(ES, *MemMgr), TT(std::move(TT)) {
552 return make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode());
613 JD->setSearchOrder(std::move(O));
629 ExitOnErr(S.ObjLayer.add(JD, std::move(ObjBuffer)));
tools/llvm-link/llvm-link.cpp 160 : createLazyModule(std::move(createLazyModule)) {}
168 std::unique_ptr<Module> Ret = std::move(I->second);
326 std::move(M), ApplicableFlags, [](Module &M, const StringSet<> &GVS) {
332 Err = L.linkInModule(std::move(M), ApplicableFlags);
tools/llvm-lipo/llvm-lipo.cpp 43 logAllUnhandledErrors(std::move(E), OS);
209 reportError(A->getFileName(), std::move(Err));
456 InputBinaries.push_back(std::move(*BinaryOrErr));
582 reportError(OutputFileName, std::move(E));
637 ExtractedObjects.push_back(std::move(BinaryOrError.get()));
699 std::unique_ptr<FileOutputBuffer> OutFile = std::move(OutFileOrError.get());
722 reportError(OutputFileName, std::move(E));
tools/llvm-lto/llvm-lto.cpp 316 Buffer = std::move(BufferOrErr.get());
322 std::move(Context), Buffer->getBufferStart(), Buffer->getBufferSize(),
326 return std::move(*Ret);
471 InputBuffers.push_back(std::move(*InputOrErr));
508 return std::move(*ModuleOrErr);
576 InputBuffers.push_back(std::move(*InputOrErr));
789 InputBuffers.push_back(std::move(*InputOrErr));
828 InputBuffers.push_back(std::move(*InputOrErr));
899 auto Buffer = std::move(BufferOrErr.get());
967 CodeGen.setModule(std::move(Module));
tools/llvm-lto2/llvm-lto2.cpp 143 handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
151 return std::move(*E);
162 return std::move(*E);
283 LTO Lto(std::move(Conf), std::move(Backend));
283 LTO Lto(std::move(Conf), std::move(Backend));
317 MBs.push_back(std::move(MB));
318 check(Lto.add(std::move(Input), Res), F);
338 return std::make_unique<lto::NativeObjectStream>(std::move(S));
tools/llvm-mc/llvm-mc.cpp 345 SrcMgr.AddNewSourceBuffer(std::move(*BufferPtr), SMLoc());
468 TheTarget->createAsmStreamer(Ctx, std::move(FOut), /*asmverbose*/ true,
470 std::move(CE), std::move(MAB), ShowInst));
470 std::move(CE), std::move(MAB), ShowInst));
tools/llvm-mca/PipelinePrinter.h 45 Views.emplace_back(std::move(V));
tools/llvm-mca/llvm-mca.cpp 243 return std::move(Out);
365 SrcMgr.AddNewSourceBuffer(std::move(*BufferPtr), SMLoc());
387 WithColor::error() << toString(std::move(Err)) << '\n';
425 std::unique_ptr<ToolOutputFile> TOF = std::move(*OF);
483 WithColor::error() << toString(std::move(NewE));
488 LoweredSequence.emplace_back(std::move(Inst.get()));
tools/llvm-mt/llvm-mt.cpp 83 handleAllErrors(std::move(EC), [&](const ErrorInfoBase &EI) {
154 std::unique_ptr<FileOutputBuffer> FileBuffer = std::move(*FileOrErr);
tools/llvm-nm/llvm-nm.cpp 260 logAllUnhandledErrors(std::move(E), OS);
279 logAllUnhandledErrors(std::move(E), OS);
1240 consumeError(std::move(E));
1242 error(std::move(E), Obj.getFileName());
1446 error(std::move(Err), MachO->getFileName());
1500 error(std::move(BErr), MachO->getFileName());
1560 error(std::move(LErr), MachO->getFileName());
1630 error(std::move(WErr), MachO->getFileName());
1823 error(std::move(E), Filename, C);
1846 error(std::move(Err), A->getFileName());
1882 error(std::move(E), Filename, ArchFlags.size() > 1 ?
1895 error(std::move(E), Filename, C, ArchFlags.size() > 1 ?
1920 error(std::move(Err), A->getFileName());
1954 error(std::move(E), Filename);
1966 error(std::move(E), Filename, C);
1981 error(std::move(Err), A->getFileName());
2018 error(std::move(E), Filename, moreThanOneArch ?
2031 error(std::move(E), Filename, C, moreThanOneArch ?
2055 error(std::move(Err), A->getFileName());
tools/llvm-objcopy/Buffer.cpp 44 Buf = std::move(*BufferOrErr);
56 return Err ? createFileError(getName(), std::move(Err)) : std::move(Err);
56 return Err ? createFileError(getName(), std::move(Err)) : std::move(Err);
75 return std::move(Buf);
tools/llvm-objcopy/COFF/COFFObjcopy.cpp 48 auto LinkTarget = std::move(*LinkTargetOrErr);
182 auto Buf = std::move(*BufOrErr);
225 return createFileError(Config.InputFilename, std::move(E));
228 return createFileError(Config.OutputFilename, std::move(E));
tools/llvm-objcopy/COFF/Object.h 56 OwnedContents = std::move(Data);
tools/llvm-objcopy/COFF/Reader.cpp 212 return std::move(E);
214 return std::move(E);
216 return std::move(E);
218 return std::move(E);
220 return std::move(Obj);
tools/llvm-objcopy/CopyConfig.cpp 306 return std::move(E);
504 auto Debug = std::move(*DebugOrErr);
536 return std::move(E);
587 return std::move(E);
591 return std::move(E);
595 return std::move(E);
635 return std::move(E);
640 return std::move(E);
644 return std::move(E);
649 return std::move(E);
653 return std::move(E);
658 return std::move(E);
662 return std::move(E);
667 return std::move(E);
671 return std::move(E);
676 return std::move(E);
681 return std::move(E);
686 return std::move(E);
690 return std::move(E);
695 return std::move(E);
726 auto Expr = Config.EntryExpr ? std::move(Config.EntryExpr)
751 DC.CopyConfigs.push_back(std::move(Config));
752 return std::move(DC);
828 return std::move(E);
833 return std::move(E);
838 return std::move(E);
843 return std::move(E);
866 DC.CopyConfigs.push_back(std::move(Config));
878 return std::move(E);
891 return std::move(DC);
tools/llvm-objcopy/CopyConfig.h 135 PosMatchers.push_back(std::move(*Matcher));
137 NegMatchers.push_back(std::move(*Matcher));
tools/llvm-objcopy/ELF/ELFObjcopy.cpp 172 return createFileError(Config.InputFilename, std::move(Err));
182 return createFileError(Config.InputFilename, std::move(Err));
296 std::unique_ptr<FileOutputBuffer> Buf = std::move(*BufferOrErr);
699 std::unique_ptr<MemoryBuffer> Buf = std::move(*BufOrErr);
800 return createFileError(Config.InputFilename, std::move(E));
803 return createFileError(Config.InputFilename, std::move(E));
808 return createFileError(Config.OutputFilename, std::move(E));
tools/llvm-objcopy/ELF/Object.cpp 280 return std::move(E);
296 return std::move(E);
436 reportError(Sec.Name, std::move(E));
511 reportError(Name, std::move(E));
1179 return std::move(Obj);
1235 return std::move(Obj);
1656 return std::move(Records);
tools/llvm-objcopy/ELF/Object.h 958 ? createFileError(MemBuf->getBufferIdentifier(), std::move(E))
960 std::move(E));
965 return parseError(LineNo, std::move(E));
1059 Sections.emplace_back(std::move(Sec));
tools/llvm-objcopy/MachO/MachOObjcopy.cpp 73 return createFileError(Config.InputFilename, std::move(E));
tools/llvm-objcopy/MachO/MachOReader.cpp 172 O.LoadCommands.push_back(std::move(LC));
tools/llvm-objcopy/llvm-objcopy.cpp 66 logAllUnhandledErrors(std::move(E), OS);
81 logAllUnhandledErrors(std::move(E), OS);
89 WithColor::warning(errs(), ToolName) << toString(std::move(E)) << '\n';
108 return createFileError(ArcName, std::move(E));
203 NewArchiveMembers.push_back(std::move(*Member));
206 return createFileError(Config.InputFilename, std::move(Err));
346 logAllUnhandledErrors(std::move(E), WithColor::error(errs(), ToolName));
tools/llvm-objdump/COFFDump.cpp 464 reportError(std::move(E), Obj->getFileName());
586 reportError(std::move(E), Obj->getFileName());
tools/llvm-objdump/MachODump.cpp 1949 reportError(std::move(Err), FileName, ArchiveName, ArchitectureName);
2297 reportError(std::move(Err), Filename, "", ArchitectureName);
2329 reportError(std::move(E), Filename);
2348 reportError(std::move(E), getFileNameForError(C, I), Filename);
2358 reportError(std::move(Err), Filename);
2410 reportError(std::move(E), "", Filename, ArchitectureName);
2430 reportError(std::move(E), getFileNameForError(C, I), Filename,
2439 reportError(std::move(Err), Filename);
2475 reportError(std::move(E), Filename);
2491 reportError(std::move(E), getFileNameForError(C, I), Filename);
2499 reportError(std::move(Err), Filename);
2526 reportError(std::move(E), Filename, "", ArchitectureName);
2543 reportError(std::move(E), getFileNameForError(C, I), Filename,
2555 reportError(std::move(Err), Filename);
7230 &SymbolizerInfo, &Ctx, std::move(RelInfo)));
7231 DisAsm->setSymbolizer(std::move(Symbolizer));
7279 &ThumbSymbolizerInfo, PtrThumbCtx, std::move(ThumbRelInfo)));
7280 ThumbDisAsm->setSymbolizer(std::move(ThumbSymbolizer));
7367 DSYMBuf = std::move(BufOrErr.get());
7377 DSYMBinary = std::move(BinaryOrErr.get());
7413 DSYMBinary = std::move(*MachDSYM);
10311 reportError(std::move(Err), Obj->getFileName());
10332 reportError(std::move(Err), Obj->getFileName());
10384 reportError(std::move(Err), Obj->getFileName());
10409 reportError(std::move(Err), Obj->getFileName());
10441 reportError(std::move(Err), Obj->getFileName());
10460 reportError(std::move(Err), info->O->getFileName());
tools/llvm-objdump/llvm-objdump.cpp 434 logAllUnhandledErrors(std::move(E), OS);
587 Buffer = std::move(*BufferOrError);
601 SourceCache[LineInfo.FileName] = std::move(Buffer);
680 reportError(std::move(E), FileName);
1241 TripleName, nullptr, nullptr, &Symbols, &Ctx, std::move(RelInfo)));
1242 DisAsm->setSymbolizer(std::move(Symbolizer));
1646 reportError(std::move(E), Obj->getFileName());
1680 reportError(std::move(E), Obj->getFileName());
2218 reportError(std::move(E), getFileNameForError(C, I), A->getFileName());
2230 reportError(std::move(Err), A->getFileName());
tools/llvm-objdump/llvm-objdump.h 41 : Predicate(std::move(P)), Iterator(I), End(E) {
70 : Predicate(std::move(P)), Object(O) {}
151 return std::move(*EO);
tools/llvm-opt-fuzzer/llvm-opt-fuzzer.cpp 49 return std::make_unique<IRMutator>(std::move(Types), std::move(Strategies));
49 return std::make_unique<IRMutator>(std::move(Types), std::move(Strategies));
149 consumeError(std::move(Err));
239 errs() << *argv[0] << ": " << toString(std::move(Err)) << "\n";
tools/llvm-opt-report/OptReport.cpp 183 consumeError(std::move(E));
186 handleAllErrors(std::move(E), [&](const ErrorInfoBase &PE) {
tools/llvm-pdbutil/BytesOutputStyle.cpp 344 ModuleDebugStreamRef ModStream(Modi, std::move(ModStreamData));
441 consumeError(std::move(EC));
tools/llvm-pdbutil/DumpOutputStyle.cpp 427 ModuleDebugStreamRef ModS(Modi, std::move(ModStreamData));
432 return std::move(ModS);
529 return std::make_pair(std::move(Stream), Headers);
539 std::tie(Stream, Headers) = std::move(*ExpectedHeaders);
1324 toString(std::move(EC)));
1353 Dep.first, toString(std::move(EC)));
1363 toString(std::move(EC)));
1555 SymbolError = std::make_unique<Error>(std::move(EC));
1562 return std::move(*SymbolError);
1604 toString(std::move(EC)));
1889 std::tie(Stream, Headers) = std::move(*ExpectedHeaders);
tools/llvm-pdbutil/ExplainOutputStyle.cpp 71 DbiStream Dbi(std::move(Stream));
78 InfoStream Info(std::move(Stream));
tools/llvm-pdbutil/FormatUtil.h 125 : FormatAdapter<EndianType>(std::move(Item)) {}
138 return detail::EndianAdapter<T>(std::move(Value));
tools/llvm-pdbutil/InputFile.cpp 58 ModuleDebugStreamRef ModS(Modi, std::move(ModStreamData));
63 return std::move(ModS);
185 DebugStream = std::make_shared<ModuleDebugStreamRef>(std::move(*MDS));
270 IF.CoffObject = std::move(*BinaryOrErr);
272 return std::move(IF);
278 return std::move(Err);
283 return std::move(IF);
296 IF.UnknownFile = std::move(*Result);
298 return std::move(IF);
tools/llvm-pdbutil/MinimalTypeDumper.cpp 51 PUSH_FLAG(ClassOptions, ForwardReference, Options, std::move(Formatted));
tools/llvm-pdbutil/PrettyTypeDumper.cpp 120 auto Layout = std::make_unique<ClassLayout>(std::move(Class));
130 Filtered.push_back(std::move(Layout));
262 auto Layout = std::make_unique<ClassLayout>(std::move(Class));
331 auto UDT = llvm::unique_dyn_cast<PDBSymbolTypeUDT>(std::move(Parent));
tools/llvm-pdbutil/YAMLOutputStyle.cpp 235 pdb::ModuleDebugStreamRef ModS(MI, std::move(ModStreamData));
tools/llvm-pdbutil/llvm-pdbutil.cpp 1128 llvm::unique_dyn_cast<PDBSymbolTypeTypedef>(std::move(Symbol));
1135 llvm::unique_dyn_cast<PDBSymbolTypeEnum>(std::move(Symbol));
1142 llvm::unique_dyn_cast<PDBSymbolTypeUDT>(std::move(Symbol));
1155 llvm::unique_dyn_cast<PDBSymbolFunc>(std::move(Symbol));
1162 llvm::unique_dyn_cast<PDBSymbolData>(std::move(Symbol));
1169 llvm::unique_dyn_cast<PDBSymbolPublicSymbol>(std::move(Symbol));
1237 Funcs.push_back(std::move(Func));
1255 Datas.push_back(std::move(Var));
1389 FileBufferByteStream DestStream(std::move(OutFile), llvm::support::little);
tools/llvm-profdata/llvm-profdata.cpp 69 handleAllErrors(std::move(E), [&](const InstrProfError &IPE) {
80 exitWithError(toString(std::move(E)), Whence);
109 E = handleErrors(std::move(E),
112 return Error(std::move(E));
114 errs() << toString(std::move(E)) << "\n";
151 Remapper->File = std::move(BufOrError.get());
207 instrprof_error IPE = InstrProfError::take(std::move(E));
213 auto Reader = std::move(ReaderOrErr.get());
218 WC->Writer.overlapRecord(std::move(I), Overlap, FuncOverlap, FuncFilter);
236 instrprof_error IPE = InstrProfError::take(std::move(E));
242 auto Reader = std::move(ReaderOrErr.get());
259 WC->Writer.addRecord(std::move(I), Input.Weight, [&](Error E) {
261 consumeError(std::move(E));
266 instrprof_error IPE = InstrProfError::take(std::move(E));
275 WC->Errors.emplace_back(std::move(E), Filename);
281 Dst->Errors.push_back(std::move(ErrorPair));
284 Dst->Writer.mergeRecordsFromWriter(std::move(Src->Writer), [&](Error E) {
285 instrprof_error IPE = InstrProfError::take(std::move(E));
358 warn(toString(std::move(ErrorPair.first)), ErrorPair.second);
373 exitWithError(std::move(E));
427 return std::move(*BufOrError);
488 Readers.push_back(std::move(ReaderOrErr.get()));
523 auto Writer = std::move(WriterOrErr.get());
707 exitWithError(std::move(E), "Error in getting profile count sums");
821 std::vector<uint32_t> Cutoffs = std::move(DetailedSummaryCutoffs);
825 InstrProfSummaryBuilder Builder(std::move(Cutoffs));
827 exitWithError(std::move(E), Filename);
829 auto Reader = std::move(ReaderOrErr.get());
1026 auto Reader = std::move(ReaderOrErr.get());
tools/llvm-rc/ResourceFileWriter.cpp 427 std::move(Err));
821 ItemEntries(std::move(Entries)) {}
970 IconCursorGroupResource HeaderRes(Type, *Header, std::move(ItemEntries));
1158 std::move(Err));
tools/llvm-rc/ResourceFileWriter.h 47 : Params(Params), FS(std::move(Stream)), IconCursorID(1) {
tools/llvm-rc/ResourceScriptParser.cpp 44 : Tokens(std::move(TokenList)), CurLoc(Tokens.begin()), End(Tokens.end()) {}
298 return std::move(Err);
299 consumeError(std::move(Err));
309 return FailureHandler(std::move(CommaError));
318 return std::move(Result);
386 Result.addStmt(std::move(*SingleParse));
389 return std::move(Result);
432 std::move(*OptStatements), MemoryFlags);
445 return std::move(Accels);
480 HelpID, std::move(*OptStatements), IsExtended, MemoryFlags);
484 Dialog->addControl(std::move(*ControlDefResult));
487 return std::move(Dialog);
520 return std::make_unique<UserDefinedResource>(Type, std::move(Data),
530 std::move(**BlockResult), std::move(*FixedResult), MemoryFlags);
530 std::move(**BlockResult), std::move(*FixedResult), MemoryFlags);
622 return std::make_unique<MenuResource>(std::move(*OptStatements),
623 std::move(*Items), MemoryFlags);
673 *CaptionResult, *FlagsResult, std::move(*SubMenuResult)));
682 return std::move(List);
691 auto Table = std::make_unique<StringTableResource>(std::move(*OptStatements),
705 return std::move(Table);
716 Contents->addStmt(std::move(*Stmt));
721 return std::move(Contents);
749 return std::make_unique<VersionInfoValue>(*KeyResult, std::move(Values),
750 std::move(PrecedingCommas));
tools/llvm-rc/ResourceScriptStmt.h 272 Statements.push_back(std::move(Stmt));
290 OptStatements(std::make_unique<OptionalStmtList>(std::move(Stmts))) {}
346 : OptStatementsRCResource(std::move(List), Flags) {}
498 Definitions.push_back(std::move(Def));
547 : Name(Caption), Flags(ItemFlags), SubItems(std::move(SubItemsList)) {}
566 : OptStatementsRCResource(std::move(OptStmts), Flags),
567 Elements(std::move(Items)) {}
587 : OptStatementsRCResource(std::move(List), Flags) {}
659 : OptStatementsRCResource(std::move(OptStmts), Flags), X(PosX), Y(PosY),
663 void addControl(Control &&Ctl) { Controls.push_back(std::move(Ctl)); }
699 : RCResource(Flags), Type(ResourceType), Contents(std::move(Data)),
755 Stmts.push_back(std::move(Stmt));
773 : Key(InfoKey), Values(std::move(Vals)),
774 HasPrecedingComma(std::move(CommasBeforeVals)) {}
829 : RCResource(Flags), MainBlock(std::move(TopLevelBlock)),
830 FixedData(std::move(FixedInfo)) {}
tools/llvm-rc/ResourceScriptToken.cpp 173 return std::move(TokenError);
tools/llvm-rc/llvm-rc.cpp 117 std::unique_ptr<MemoryBuffer> FileContents = std::move(*File);
184 Visitor = std::make_unique<ResourceFileWriter>(Params, std::move(FOut));
193 rc::RCParser Parser{std::move(Tokens)};
tools/llvm-readobj/COFFDumper.cpp 205 llvm::consumeError(std::move(EC));
914 reportError(std::move(E), Obj->getFileName());
916 reportError(std::move(E), Obj->getFileName());
920 reportError(std::move(E), Obj->getFileName());
926 reportError(std::move(E), Obj->getFileName());
930 reportError(std::move(E), Obj->getFileName());
938 reportError(std::move(E), Obj->getFileName());
957 reportError(std::move(E), Obj->getFileName());
973 reportError(std::move(E), Obj->getFileName());
975 reportError(std::move(E), Obj->getFileName());
1057 reportError(std::move(E), Obj->getFileName());
1122 reportError(std::move(E), Obj->getFileName());
1167 CVSymbolDumper CVSD(W, Types, CodeViewContainer::ObjectFile, std::move(CODD),
1173 reportError(std::move(E), Obj->getFileName());
1178 reportError(std::move(E), Obj->getFileName());
1188 reportError(std::move(E), Obj->getFileName());
1208 reportError(std::move(E), Obj->getFileName());
1258 reportError(std::move(E), Obj->getFileName());
1267 consumeError(std::move(EC));
1280 return reportError(std::move(E), Obj->getFileName());
1284 return reportError(std::move(E), Obj->getFileName());
1301 reportError(std::move(E), Obj->getFileName());
1312 reportError(std::move(E), Obj->getFileName());
1772 reportError(std::move(E), Obj->getFileName());
1969 reportError(std::move(Err), "<?>");
1981 reportError(std::move(Err), "<?>");
tools/llvm-readobj/DwarfCFIEHPrinter.h 52 reportError(std::move(E), ObjF->getFileName());
67 reportError(std::move(E), ObjF->getFileName());
86 reportError(std::move(E), ObjF->getFileName());
91 reportError(std::move(E), ObjF->getFileName());
112 reportError(std::move(E), ObjF->getFileName());
187 reportError(std::move(E), ObjF->getFileName());
tools/llvm-readobj/ELFDumper.cpp 1701 reportWarning(std::move(Err), ObjF->getFileName());
3654 return {Sym, std::move(Name)};
4673 reportError(std::move(Err), this->FileName);
4685 reportError(std::move(Err), this->FileName);
5917 reportError(std::move(Err), this->FileName);
5930 reportError(std::move(Err), this->FileName);
tools/llvm-readobj/Win64EHDumper.cpp 293 reportError(std::move(E), Ctx.COFF.getFileName());
321 reportError(std::move(E), Ctx.COFF.getFileName());
tools/llvm-readobj/llvm-readobj.cpp 378 handleAllErrors(createFileError(Input, std::move(Err)),
392 createFileError(Input, std::move(Err)), [&](const ErrorInfoBase &EI) {
558 reportError(std::move(E), Arc->getFileName());
570 reportError(std::move(Err), Arc->getFileName());
592 reportError(std::move(Err), WinRes->getFileName());
619 CVTypes.Binaries.push_back(std::move(*BinaryOrErr));
tools/llvm-reduce/TestRunner.cpp 37 errs() << toString(std::move(E));
tools/llvm-reduce/TestRunner.h 36 void setProgram(std::unique_ptr<Module> P) { Program = std::move(P); }
tools/llvm-reduce/deltas/Delta.cpp 148 ReducedProgram = std::move(Clone);
160 Test.setProgram(std::move(ReducedProgram));
tools/llvm-reduce/llvm-reduce.cpp 85 Tester.setProgram(std::move(OriginalProgram));
tools/llvm-rtdyld/llvm-rtdyld.cpp 192 : Name(Name), MB(std::move(MB)), SectionID(SectionID) {}
233 ExitOnErr(std::move(Err));
820 ResultP->set_value(std::move(Result));
tools/llvm-size/llvm-size.cpp 138 logAllUnhandledErrors(std::move(E), OS);
156 logAllUnhandledErrors(std::move(E), OS);
556 error(std::move(E), a->getFileName(), C);
577 error(std::move(Err), a->getFileName());
612 error(std::move(E), file, ArchFlags.size() > 1 ?
626 error(std::move(E), UA->getFileName(), C,
657 error(std::move(Err), UA->getFileName());
702 error(std::move(E), file);
715 error(std::move(E), UA->getFileName(), C);
739 error(std::move(Err), UA->getFileName());
778 error(std::move(E), file, MoreThanOneArch ?
791 error(std::move(E), UA->getFileName(), C, MoreThanOneArch ?
816 error(std::move(Err), UA->getFileName());
tools/llvm-split/llvm-split.cpp 55 SplitModule(std::move(M), NumOutputs, [&](std::unique_ptr<Module> MPart) {
tools/llvm-xray/func-id-helper.h 37 : BinaryInstrMap(std::move(BinaryInstrMap)), Symbolizer(Symbolizer),
tools/llvm-xray/xray-account.cpp 420 Map = std::move(*InstrumentationMapOrError);
tools/llvm-xray/xray-converter.cpp 235 NodeStore.push_front({FuncId, Parent, {}, {stack_id, std::move(siblings)}});
379 Map = std::move(*InstrumentationMapOrError);
tools/llvm-xray/xray-fdr-dump.cpp 70 if (auto E = C.consume(std::move(R.get())))
85 return joinErrors(std::move(E), R.takeError());
88 if (auto E = C.consume(std::move(R.get())))
tools/llvm-xray/xray-graph-diff.cpp 452 Factories[i].Trace = std::move(*TraceOrErr);
tools/llvm-xray/xray-graph.cpp 434 Map = std::move(*InstrumentationMapOrError);
463 std::move(E));
465 handleAllErrors(std::move(E),
502 F.Trace = std::move(*TraceOrErr);
tools/llvm-xray/xray-stacks.cpp 118 : FormatAdapter<XRayRecord>(std::move(record)), Converter(&conv) {}
701 Map = std::move(*InstrumentationMapOrError);
tools/lto/lto.cpp 133 : LTOCodeGenerator(*Context), OwnedContext(std::move(Context)) {
285 std::move(Context), mem, length, Options, StringRef(path));
tools/obj2yaml/Error.h 35 Obj2YamlError(std::string ErrMsg) : ErrMsg(std::move(ErrMsg)) {}
37 : ErrMsg(std::move(ErrMsg)), Code(C) {}
tools/obj2yaml/elf2yaml.cpp 210 return std::move(E);
215 return std::move(E);
515 return std::move(E);
537 S->Entries = std::move(Entries);
548 return std::move(E);
574 S->Symbols = std::move(Symbols);
588 return std::move(E);
605 return std::move(E);
619 return std::move(E);
629 return std::move(E);
643 return std::move(E);
667 return std::move(E);
682 return std::move(E);
693 return std::move(E);
720 S->Notes = std::move(Entries);
729 return std::move(E);
773 return std::move(E);
822 return std::move(E);
841 return std::move(E);
912 return std::move(E);
948 return std::move(E);
tools/obj2yaml/macho2yaml.cpp 202 return std::move(Y);
238 Y->LoadCommands.push_back(std::move(LC));
506 YAMLFile.MachO = std::move(YAML.get());
549 return errorToErrorCode(std::move(Err));
556 return errorToErrorCode(std::move(Err));
tools/obj2yaml/obj2yaml.cpp 60 logAllUnhandledErrors(std::move(Err), OS);
74 reportError(InputFilename, std::move(Err));
tools/obj2yaml/wasm2yaml.cpp 63 CustomSec = std::move(DylinkSec);
73 CustomSec = std::move(NameSec);
134 CustomSec = std::move(LinkingSec);
157 CustomSec = std::move(ProducersSec);
167 CustomSec = std::move(TargetFeaturesSec);
207 S = std::move(TypeSec);
238 S = std::move(ImportSec);
246 S = std::move(FuncSec);
254 S = std::move(TableSec);
262 S = std::move(MemorySec);
275 S = std::move(GlobalSec);
287 S = std::move(EventSec);
293 S = std::move(StartSec);
305 S = std::move(ExportSec);
319 S = std::move(ElemSec);
336 S = std::move(CodeSec);
350 S = std::move(DataSec);
356 S = std::move(DataCountSec);
371 Y->Sections.push_back(std::move(S));
tools/opt/NewPMDriver.cpp 127 << " pipeline: " << toString(std::move(Err))
301 errs() << Arg0 << ": " << toString(std::move(Err)) << "\n";
311 FAM.registerPass([&] { return std::move(AA); });
328 errs() << Arg0 << ": " << toString(std::move(Err)) << "\n";
tools/opt/opt.cpp 562 errs() << toString(std::move(E)) << '\n';
565 std::unique_ptr<ToolOutputFile> RemarksFile = std::move(*RemarksFileOrErr);
tools/polly/include/polly/ScopBuilder.h 827 std::unique_ptr<Scop> getScop() { return std::move(scop); }
tools/polly/include/polly/ScopDetection.h 170 Verifying(DC.Verifying), Log(std::move(DC.Log)),
171 Accesses(std::move(DC.Accesses)),
172 NonAffineAccesses(std::move(DC.NonAffineAccesses)),
173 ElementSize(std::move(DC.ElementSize)), hasLoads(DC.hasLoads),
175 NonAffineSubRegionSet(std::move(DC.NonAffineSubRegionSet)),
176 BoxedLoopsSet(std::move(DC.BoxedLoopsSet)),
177 RequiredILS(std::move(DC.RequiredILS)) {
tools/polly/include/polly/ScopPass.h 54 Result(Result &&R) : InnerAM(std::move(R.InnerAM)), SI(R.SI) {
208 explicit FunctionToScopPassAdaptor(ScopPassT Pass) : Pass(std::move(Pass)) {}
245 PA.intersect(std::move(PassPA));
268 return FunctionToScopPassAdaptor<ScopPassT>(std::move(Pass));
tools/polly/lib/Analysis/DependenceInfo.cpp 925 auto Inserted = ScopToDepsMap.insert(std::make_pair(S, std::move(D)));
tools/polly/lib/Analysis/ScopBuilder.cpp 2163 scop->addScopStmt(BB, Name, L, std::move(InstList));
3388 AliasGroups.push_back(std::move(AG));
3523 AliasGroups.push_back(std::move(NewAG));
tools/polly/lib/Analysis/ScopDetection.cpp 1419 LastValidRegion = std::move(ExpandedRegion);
tools/polly/lib/Analysis/ScopInfo.cpp 2744 bool Inserted = RegionToScopMap.insert({R, std::move(S)}).second;
tools/polly/lib/Analysis/ScopPass.cpp 80 PA.intersect(std::move(PassPA));
tools/polly/lib/CodeGen/BlockGenerators.cpp 553 EscapeMap[Inst] = std::make_pair(ScalarAddr, std::move(EscapeUsers));
tools/polly/lib/CodeGen/IslNodeBuilder.cpp 1438 std::make_pair(Alloca, std::move(EscapeUsers));
tools/polly/lib/Exchange/JSONExporter.cpp 119 Array["sizes"] = std::move(Sizes);
123 Arrays.push_back(std::move(Array));
163 Accesses.push_back(std::move(access));
165 statement["accesses"] = std::move(Accesses);
167 Statements.push_back(std::move(statement));
170 root["statements"] = std::move(Statements);
171 return json::Value(std::move(root));
716 consumeError(std::move(E));
tools/polly/lib/Support/ISLTools.cpp 198 auto Reversed = reverseDomain(std::move(Map));
500 isl::union_map LifetedFunc = liftDomains(std::move(Func), DomainDomain);
tools/polly/lib/Support/RegisterPasses.cpp 507 PM.addPass(createFunctionToScopPassAdaptor(std::move(SPM)));
639 FPM.addPass(createFunctionToScopPassAdaptor(std::move(SPM)));
682 FPM.addPass(createFunctionToScopPassAdaptor(std::move(SPM)));
685 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
tools/polly/lib/Transform/DeLICM.cpp 106 std::move(Schedule), std::move(WritesMap), InclPrevWrite, InclOverwrite);
106 std::move(Schedule), std::move(WritesMap), InclPrevWrite, InclOverwrite);
130 return singleton(std::move(ReachOverwrite), ResultSpace);
268 : Occupied(std::move(Occupied)), Unused(std::move(Unused)),
268 : Occupied(std::move(Occupied)), Unused(std::move(Unused)),
269 Known(std::move(Known)), Written(std::move(Written)) {
269 Known(std::move(Known)), Written(std::move(Written)) {
740 mapValue(SAI, std::move(DefTarget), std::move(UseTarget),
740 mapValue(SAI, std::move(DefTarget), std::move(UseTarget),
741 std::move(Lifetime), std::move(Proposed));
741 std::move(Lifetime), std::move(Proposed));
747 Zone.learnFrom(std::move(Proposed));
943 mapPHI(SAI, std::move(PHITarget), std::move(WritesTarget),
943 mapPHI(SAI, std::move(PHITarget), std::move(WritesTarget),
944 std::move(Lifetime), std::move(Proposed));
944 std::move(Lifetime), std::move(Proposed));
1432 Knowledge Existing(std::move(ExistingOccupied), std::move(ExistingUnused),
1432 Knowledge Existing(std::move(ExistingOccupied), std::move(ExistingUnused),
1433 std::move(ExistingKnown), std::move(ExistingWrites));
1433 std::move(ExistingKnown), std::move(ExistingWrites));
1434 Knowledge Proposed(std::move(ProposedOccupied), std::move(ProposedUnused),
1434 Knowledge Proposed(std::move(ProposedOccupied), std::move(ProposedUnused),
1435 std::move(ProposedKnown), std::move(ProposedWrites));
1435 std::move(ProposedKnown), std::move(ProposedWrites));
tools/polly/lib/Transform/FlattenAlgo.cpp 290 auto RemainingSubSchedule = scheduleProjectOut(std::move(SubSchedule), 0, 1);
tools/polly/lib/Transform/ZoneAlgo.cpp 625 auto UResult = getScatterFor(std::move(UDomain));
626 auto Result = singleton(std::move(UResult), std::move(ResultSpace));
626 auto Result = singleton(std::move(UResult), std::move(ResultSpace));
tools/polly/unittests/Flatten/FlattenTest.cpp 33 auto Result = flattenSchedule(std::move(Schedule));
tools/polly/unittests/ScopPassManager/PassManagerTest.cpp 64 FPM.addPass(createFunctionToScopPassAdaptor(std::move(SPM)));
tools/sancov/sancov.cpp 137 : Addrs(std::move(Addrs)) {}
197 logAllUnhandledErrors(std::move(Err), errs(), "ERROR: ");
235 std::unique_ptr<MemoryBuffer> Buf = std::move(BufOrErr.get());
268 return std::unique_ptr<RawCoverage>(new RawCoverage(std::move(Addrs)));
788 failIfError(std::move(Err));
850 std::unique_ptr<MemoryBuffer> Buf = std::move(BufOrErr.get());
tools/sanstats/sanstats.cpp 134 std::unique_ptr<MemoryBuffer> MB = std::move(MBOrErr.get());
tools/verify-uselistorder/verify-uselistorder.cpp 167 return std::move(ModuleOr.get());
unittests/ADT/APFloatTest.cpp 1421 llvm::detail::DoubleAPFloat T(APFloat::PPCDoubleDouble(), std::move(F1),
1422 std::move(F2));
1426 llvm::detail::DoubleAPFloat T2(APFloat::PPCDoubleDouble(), std::move(F3),
1427 std::move(F4));
1431 llvm::detail::DoubleAPFloat T3(APFloat::PPCDoubleDouble(), std::move(F5),
1432 std::move(F6));
unittests/ADT/APSIntTest.cpp 29 APSInt D(std::move(Wide));
38 A = std::move(Wide);
unittests/ADT/AnyTest.cpp 57 llvm::Any G(std::move(C));
71 B = std::move(G);
99 llvm::Any G(std::move(C));
107 E = std::move(G);
113 EXPECT_EQ(8, llvm::any_cast<int>(std::move(E)));
151 TestType T3 = llvm::any_cast<TestType>(std::move(A));
unittests/ADT/ArrayRefTest.cpp 251 OwningArrayRef<int> B(std::move(A));
unittests/ADT/BitVectorTest.cpp 1032 TypeParam B(std::move(A));
1045 B = std::move(A);
unittests/ADT/BumpPtrListTest.cpp 190 L1 = std::move(L2);
201 L1 = std::move(L2);
unittests/ADT/DenseMapTest.cpp 588 auto Try2 = Map.try_emplace(0, std::move(P));
unittests/ADT/FallibleIteratorTest.cpp 124 cantFail(std::move(Err));
142 EXPECT_THAT_ERROR(std::move(Err), Failed()) << "Expected failure value";
203 EXPECT_THAT_ERROR(std::move(Err), Succeeded());
211 EXPECT_THAT_ERROR(std::move(Err), Succeeded());
213 EXPECT_THAT_ERROR(std::move(Err), Failed()) << "Expected failure value";
221 EXPECT_THAT_ERROR(std::move(Err), Succeeded());
229 EXPECT_THAT_ERROR(std::move(Err), Succeeded());
231 EXPECT_THAT_ERROR(std::move(Err), Failed());
249 cantFail(std::move(Err));
256 cantFail(std::move(Err));
288 cantFail(std::move(Err));
unittests/ADT/FunctionExtrasTest.cpp 22 unique_function<int(int, int)> Sum2 = std::move(Sum);
26 Sum2 = std::move(Sum3);
33 *&Sum2 = std::move(Sum2);
54 EXPECT_EQ(ReadAndDeallocByRef(std::move(Ptr)), 13);
68 EXPECT_EQ(ReadAndDeallocByVal(std::move(Ptr)), 13);
81 Tmp = std::move(C1);
86 Tmp = std::move(C2);
91 Tmp = std::move(C3);
96 Tmp = std::move(C4);
101 Tmp = std::move(C5);
113 unique_function<int(int)> Small2 = std::move(Small);
127 unique_function<int()> Large2 = std::move(Large);
197 ByValF(std::move(Counter));
210 ByRefF(std::move(Counter));
unittests/ADT/OptionalTest.cpp 292 Optional<MoveOnly> B(std::move(A));
316 B = std::move(A);
329 B = std::move(A);
341 B = std::move(A);
391 EXPECT_EQ(42, std::move(A).getValueOr(MoveOnly(42)).val);
398 EXPECT_EQ(5, std::move(A).getValueOr(MoveOnly(42)).val);
unittests/ADT/STLExtrasTest.cpp 146 Range(Range &&R) : CanMove<Moveable>(std::move(R)), C(R.C), M(R.M), D(R.D) {
292 for (int &i : concat<int>(std::vector<int>(V1234), L56, std::move(SV78)))
unittests/ADT/ScopeExitTest.cpp 36 auto H = std::move(G);
37 auto I = std::move(G);
unittests/ADT/SmallPtrSetTest.cpp 138 SmallPtrSet<int *, 4> s3(std::move(s1));
153 s1 = std::move(s3);
unittests/ADT/SmallSetTest.cpp 142 Iter = std::move(Iter2);
unittests/ADT/SmallVectorTest.cpp 501 this->theVector = std::move(this->otherVector);
781 std::move(static_cast<SmallVectorImpl<Constructable>&>(this->otherVector));
922 Emplaceable &back = V.emplace_back(std::move(A0));
955 Emplaceable &back = V.emplace_back(std::move(A0), std::move(A1));
955 Emplaceable &back = V.emplace_back(std::move(A0), std::move(A1));
966 Emplaceable &back = V.emplace_back(std::move(A0), A1, std::move(A2), A3);
966 Emplaceable &back = V.emplace_back(std::move(A0), A1, std::move(A2), A3);
unittests/ADT/SparseBitVectorTest.cpp 46 SparseBitVector<> MovedVec(std::move(Vec));
51 Vec = std::move(MovedVec);
unittests/ADT/StringMapTest.cpp 369 StringMap<int> B = std::move(A);
381 A = std::move(B);
420 B = std::move(A);
unittests/ADT/TinyPtrVectorTest.cpp 162 TypeParam Move(std::move(Copy2));
168 MultipleElements = std::move(SingleElement);
177 this->V = std::move(this->V2);
185 this->V = std::move(this->V2);
193 this->V = std::move(this->V2);
201 this->V = std::move(this->V2);
209 this->V = std::move(this->V2);
217 this->V = std::move(this->V2);
225 this->V = std::move(this->V2);
232 this->V = std::move(this->V2);
240 this->V = std::move(this->V2);
248 this->V = std::move(this->V2);
256 this->V = std::move(this->V2);
264 this->V = std::move(this->V2);
272 this->V = std::move(this->V2);
280 this->V = std::move(this->V2);
288 this->V = std::move(this->V2);
296 this->V = std::move(this->V2);
unittests/Analysis/AliasAnalysisTest.cpp 82 : AAResultBase(), CB(std::move(CB)) {}
84 : AAResultBase(std::move(Arg)), CB(std::move(Arg.CB)) {}
84 : AAResultBase(std::move(Arg)), CB(std::move(Arg.CB)) {}
108 : ImmutablePass(ID), CB(std::move(CB)) {
118 Result.reset(new TestCustomAAResult(std::move(CB)));
unittests/Analysis/CGSCCPassManagerTest.cpp 272 CGPM1.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM1)));
312 CGPM1.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM2)));
314 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM1)));
322 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM3)));
368 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM1)));
390 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM2)));
409 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM3)));
447 CGPM1.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM1)));
448 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM1)));
471 CGPM2.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM2)));
472 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM2)));
492 CGPM3.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM3)));
493 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM3)));
516 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM1)));
534 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM2)));
554 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM1)));
573 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM2)));
593 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM1)));
608 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM2)));
637 CGPM.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM1)));
652 CGPM.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM2)));
655 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM)));
682 CGPM.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM1)));
700 CGPM.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM2)));
703 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM)));
728 CGPM1.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM1)));
729 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM1)));
747 CGPM2.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM2)));
748 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM2)));
770 CGPM1.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM1)));
771 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM1)));
790 CGPM2.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM2)));
791 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM2)));
813 CGPM1.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM1)));
814 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM1)));
828 CGPM2.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM2)));
829 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM2)));
1086 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM)));
1090 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM2)));
1248 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM)));
1250 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM2)));
1252 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM3)));
1254 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM4)));
unittests/Bitcode/BitReaderTest.cpp 57 return std::move(ModuleOrErr.get());
unittests/Bitstream/BitstreamReaderTest.cpp 109 AbbrevID = Stream.EmitAbbrev(std::move(Abbrev));
unittests/CodeGen/DIEHashTest.cpp 95 Space->addChild(std::move(Foo));
96 CU.addChild(std::move(Space));
127 Unnamed.addChild(std::move(Member));
158 Unnamed.addChild(std::move(Mem1));
167 Unnamed.addChild(std::move(Mem2));
189 Foo.addChild(std::move(Mem));
219 Foo.addChild(std::move(Mem));
254 Foo.addChild(std::move(Mem));
289 Foo.addChild(std::move(Mem));
320 Foo.addChild(std::move(Mem));
367 Foo.addChild(std::move(Mem));
398 Foo.addChild(std::move(Mem));
444 Foo.addChild(std::move(Mem));
474 Foo.addChild(std::move(Mem));
517 Foo.addChild(std::move(Mem));
535 Unnamed.addChild(std::move(Foo));
553 Unnamed.addChild(std::move(Func));
587 A.addChild(std::move(Func));
635 A.addChild(std::move(PI));
693 A.addChild(std::move(PI));
unittests/CodeGen/GlobalISel/GISelMITest.h 77 MIR = createMIRParser(std::move(MBuffer), Context);
117 return make_pair(std::move(M), std::move(MMI));
117 return make_pair(std::move(M), std::move(MMI));
202 SM.AddNewSourceBuffer(std::move(OutputBuf), SMLoc());
unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp 2538 consumeError(std::move(E));
2548 consumeError(std::move(E));
unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp 89 Recoverable = joinErrors(std::move(Recoverable), std::move(Err));
89 Recoverable = joinErrors(std::move(Recoverable), std::move(Err));
92 Unrecoverable = joinErrors(std::move(Unrecoverable), std::move(Err));
92 Unrecoverable = joinErrors(std::move(Unrecoverable), std::move(Err));
99 handleErrors(std::move(Err), [&](const ErrorInfoBase &Actual) {
110 checkError(ArrayRef<StringRef>{ExpectedMsg}, std::move(Err));
477 std::move(Recoverable));
559 std::move(Unrecoverable));
579 std::move(Unrecoverable));
604 std::move(Unrecoverable));
626 std::move(Unrecoverable));
634 std::move(Recoverable));
660 std::move(Unrecoverable));
unittests/DebugInfo/DWARF/DwarfGenerator.cpp 388 return Expected<std::unique_ptr<dwarfgen::Generator>>(std::move(error));
389 return Expected<std::unique_ptr<dwarfgen::Generator>>(std::move(GenUP));
unittests/DebugInfo/GSYM/GSYMTest.cpp 34 handleErrors(std::move(Err), [&](const ErrorInfoBase &Actual) {
45 checkError(ArrayRef<std::string>{ExpectedMsg}, std::move(Err));
356 checkError(ExpectedErrorMsg, std::move(Err));
958 checkError(ExpectedErrorMsg, std::move(Err));
1060 checkError(ExpectedErrorMsg, std::move(Err));
1088 checkError("already finalized", std::move(finalizeErr));
unittests/DebugInfo/PDB/NativeSymbolReuseTest.cpp 34 ASSERT_THAT_ERROR(std::move(E), Succeeded());
61 ASSERT_THAT_ERROR(std::move(E), Succeeded());
103 ASSERT_THAT_ERROR(std::move(E), Succeeded());
unittests/DebugInfo/PDB/PDBApiTest.cpp 468 auto Symbol = PDBSymbol::create(*Session, std::move(RawSymbol));
469 SymbolMap.insert(std::make_pair(Tag, std::move(Symbol)));
unittests/ExecutionEngine/ExecutionEngineTest.cpp 32 Engine.reset(EngineBuilder(std::move(Owner)).setErrorStr(&Error).create());
unittests/ExecutionEngine/JITLink/JITLinkTestCommon.cpp 25 AsmSrc, TripleStr, PIC, LargeCodeModel, std::move(Options), Err));
27 return std::move(Err);
28 return std::move(R);
42 : ObjStream(ObjBuffer), Options(std::move(Options)) {
46 Err = std::move(Err2);
104 TT, *AsCtx, std::move(MAB), std::move(MOW), std::move(CE), *STI,
104 TT, *AsCtx, std::move(MAB), std::move(MOW), std::move(CE), *STI,
104 TT, *AsCtx, std::move(MAB), std::move(MOW), std::move(CE), *STI,
123 : TR(TR), TestCase(std::move(TestCase)) {}
129 MemMgr = std::move(MM);
145 ADD_FAILURE() << "Unexpected failure: " << toString(std::move(Err));
162 LC->run(std::move(LookupResult));
173 make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode()));
185 NotifyFinalized(std::move(A));
unittests/ExecutionEngine/JITLink/JITLinkTestCommon.h 139 std::move(Options));
unittests/ExecutionEngine/JITLink/MachO_x86_64_Tests.cpp 35 std::move(Options));
45 JTCtx->externals() = std::move(Externals);
47 jitLink_MachO_x86_64(std::move(JTCtx));
unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp 96 createJIT(std::move(A));
97 TheJIT->addModule(std::move(B));
116 createJIT(std::move(A));
117 TheJIT->addModule(std::move(B));
137 createJIT(std::move(A));
138 TheJIT->addModule(std::move(B));
158 createJIT(std::move(A));
159 TheJIT->addModule(std::move(B));
179 createJIT(std::move(A));
180 TheJIT->addModule(std::move(B));
222 createJIT(std::move(A));
223 TheJIT->addModule(std::move(B));
255 createJIT(std::move(A));
256 TheJIT->addModule(std::move(B));
257 TheJIT->addModule(std::move(C));
280 createJIT(std::move(A));
281 TheJIT->addModule(std::move(B));
282 TheJIT->addModule(std::move(C));
305 createJIT(std::move(A));
306 TheJIT->addModule(std::move(B));
307 TheJIT->addModule(std::move(C));
330 createJIT(std::move(A));
331 TheJIT->addModule(std::move(B));
332 TheJIT->addModule(std::move(C));
355 createJIT(std::move(A));
356 TheJIT->addModule(std::move(B));
376 createJIT(std::move(A));
377 TheJIT->addModule(std::move(B));
397 createJIT(std::move(A));
398 TheJIT->addModule(std::move(B));
418 createJIT(std::move(A));
419 TheJIT->addModule(std::move(B));
unittests/ExecutionEngine/MCJIT/MCJITObjectCacheTest.cpp 68 AllocatedBuffers.push_back(std::move(NewBuffer));
113 createJIT(std::move(M));
128 createJIT(std::move(M));
155 createJIT(std::move(M));
172 createJIT(std::move(M));
189 createJIT(std::move(M));
207 createJIT(std::move(M));
unittests/ExecutionEngine/MCJIT/MCJITTest.cpp 51 createJIT(std::move(M));
64 createJIT(std::move(M));
85 createJIT(std::move(M));
107 createJIT(std::move(M));
184 createJIT(std::move(M));
201 createJIT(std::move(M));
222 createJIT(std::move(M));
265 createJIT(std::move(M));
unittests/ExecutionEngine/MCJIT/MCJITTestBase.h 307 EngineBuilder EB(std::move(M));
310 .setMCJITMemoryManager(std::move(MM))
unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp 43 FooMR = std::make_shared<MaterializationResponsibility>(std::move(R));
83 cantFail(std::move(Result));
127 [&](MaterializationResponsibility R) { BazR.emplace(std::move(R)); },
147 consumeError(std::move(Err));
156 consumeError(std::move(Err));
184 cantFail(std::move(Result));
227 cantFail(JD.define(std::move(MU)));
363 [&](MaterializationResponsibility R) { FooR.emplace(std::move(R)); });
369 cantFail(std::move(Result));
402 [&](MaterializationResponsibility R) { FooR.emplace(std::move(R)); });
406 [&](MaterializationResponsibility R) { BarR.emplace(std::move(R)); });
410 [&](MaterializationResponsibility R) { BazR.emplace(std::move(R)); });
422 cantFail(std::move(Result));
427 cantFail(std::move(Result));
434 std::move(OnFooResolution), NoDependenciesToRegister);
437 std::move(OnFooReady), NoDependenciesToRegister);
442 cantFail(std::move(Result));
447 cantFail(std::move(Result));
452 std::move(OnBarResolution), NoDependenciesToRegister);
455 std::move(OnBarReady), NoDependenciesToRegister);
461 cantFail(std::move(Result));
466 cantFail(std::move(Result));
471 std::move(OnBazResolution), NoDependenciesToRegister);
474 std::move(OnBazReady), NoDependenciesToRegister);
538 [&](MaterializationResponsibility R) { FooR.emplace(std::move(R)); });
542 [&](MaterializationResponsibility R) { BarR.emplace(std::move(R)); });
550 EXPECT_THAT_EXPECTED(std::move(Result), Failed());
555 std::move(OnFooReady), NoDependenciesToRegister);
559 EXPECT_THAT_EXPECTED(std::move(Result), Failed());
564 std::move(OnBarReady), NoDependenciesToRegister);
601 [&](MaterializationResponsibility R) { FooR.emplace(std::move(R)); });
605 [&](MaterializationResponsibility R) { BarR.emplace(std::move(R)); });
613 EXPECT_THAT_EXPECTED(std::move(Result), Failed());
618 std::move(OnFooReady), NoDependenciesToRegister);
622 EXPECT_THAT_EXPECTED(std::move(Result), Failed());
627 std::move(OnBarReady), NoDependenciesToRegister);
665 [&](MaterializationResponsibility R) { FooR.emplace(std::move(R)); });
669 [&](MaterializationResponsibility R) { BarR.emplace(std::move(R)); });
677 EXPECT_THAT_EXPECTED(std::move(Result), Failed());
682 std::move(OnFooReady), NoDependenciesToRegister);
686 EXPECT_THAT_EXPECTED(std::move(Result), Failed());
691 std::move(OnBarReady), NoDependenciesToRegister);
729 [&](MaterializationResponsibility R) { FooR.emplace(std::move(R)); });
733 [&](MaterializationResponsibility R) { BarR.emplace(std::move(R)); });
741 EXPECT_THAT_EXPECTED(std::move(Result), Failed());
746 std::move(OnFooReady), NoDependenciesToRegister);
750 EXPECT_THAT_EXPECTED(std::move(Result), Failed());
755 std::move(OnBarReady), NoDependenciesToRegister);
788 cantFail(JD.define(std::move(MU)));
871 std::move(OnCompletion), NoDependenciesToRegister);
909 cantFail(std::move(Result));
914 std::move(OnCompletion), NoDependenciesToRegister);
957 TestGenerator(SymbolMap Symbols) : Symbols(std::move(Symbols)) {}
969 cantFail(JD.define(absoluteSymbols(std::move(NewDefs))));
1039 cantFail(std::move(Result));
1052 EXPECT_THAT_EXPECTED(std::move(Result), Failed())
1065 cantFail(JD.define(std::move(BarMU)));
1072 EXPECT_THAT_EXPECTED(std::move(Result), Failed())
1106 std::thread([MU = std::move(MU), &JD] { MU->doMaterialize(JD); });
1147 R.replace(std::move(NewMU));
1211 std::make_unique<MaterializationResponsibility>(std::move(R));
1216 cantFail(std::move(Result));
1220 std::move(OnCompletion), NoDependenciesToRegister);
1232 consumeError(std::move(Err));
unittests/ExecutionEngine/Orc/LazyCallThroughAndReexportsTest.cpp 62 JD, DummyTarget, std::move(NotifyResolved)));
unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp 35 return cantFail(JD.legacyLookup(std::move(Q), Symbols));
62 Resolver->lookup(std::move(Q), SymbolNameSet({Foo, Bar, Baz}));
unittests/ExecutionEngine/Orc/LegacyRTDyldObjectLinkingLayerTest.cpp 114 cantFail(ObjLayer.addObject(K, std::move(Obj)));
138 auto R = std::move(I->second);
140 return LegacyRTDyldObjectLinkingLayer::Resources{MM, std::move(R)};
185 cantFail(ObjLayer.addObject(K1, std::move(Obj1)));
202 cantFail(ObjLayer.addObject(K2, std::move(Obj2)));
270 cantFail(ObjLayer.addObject(K, std::move(Obj1)));
271 cantFail(ObjLayer.addObject(ES.allocateVModule(), std::move(Obj2)));
unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp 203 cantFail(T1.addObject(K1, std::move(Obj1)));
224 M.verifyFindSymbol(std::move(Sym1));
231 M.verifyFindSymbolIn(std::move(Sym2));
254 OwnedObj = T1C.getTransform()(std::move(OwnedObj));
unittests/ExecutionEngine/Orc/OrcTestCommon.h 98 : MaterializationUnit(std::move(SymbolFlags), orc::VModuleKey()),
99 Materialize(std::move(Materialize)), Discard(std::move(Discard)),
99 Materialize(std::move(Materialize)), Discard(std::move(Discard)),
100 Destructor(std::move(Destructor)) {}
110 Materialize(std::move(R));
116 Discard(JD, std::move(Name));
176 std::unique_ptr<Module> takeModule() { return std::move(M); }
219 return addModuleImpl(std::move(M), std::move(R));
219 return addModuleImpl(std::move(M), std::move(R));
unittests/ExecutionEngine/Orc/QueueChannel.h 59 ReadError = std::move(NewReadError);
65 WriteError = std::move(NewWriteError);
173 return std::make_pair(std::move(C1), std::move(C2));
173 return std::make_pair(std::move(C1), std::move(C2));
unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp 668 std::move(Err),
738 std::move(Err),
864 consumeError(std::move(Err));
unittests/ExecutionEngine/Orc/RTDyldObjectLinkingLayerTest.cpp 61 cantFail(std::move(R));
65 cantFail(ObjLayer.add(JD, std::move(Obj), ES.allocateVModule()));
96 EXPECT_TRUE(testSetProcessAllSections(std::move(Obj), true))
148 M = ThreadSafeModule(MB.takeModule(), std::move(TSCtx));
161 cantFail(CompileLayer.add(JD, std::move(M), ES.allocateVModule()));
164 [](Expected<SymbolMap> R) { cantFail(std::move(R)); },
213 M = ThreadSafeModule(MB.takeModule(), std::move(TSCtx));
226 cantFail(CompileLayer.add(JD, std::move(M), ES.allocateVModule()));
229 [](Expected<SymbolMap> R) { cantFail(std::move(R)); },
unittests/ExecutionEngine/Orc/RemoteObjectLayerTest.cpp 40 : AddObject(std::move(AddObject)) {}
44 return AddObject(std::move(Obj), SymTab);
59 return std::move(Err);
120 logAllUnhandledErrors(std::move(Err), llvm::errs());
162 cantFail(Client.addObject(std::move(TestObject),
178 auto ErrMsg = toString(std::move(Err));
209 auto HandleOrErr = Client.addObject(std::move(TestObject),
232 logAllUnhandledErrors(std::move(Err), llvm::errs());
261 auto H = cantFail(Client.addObject(std::move(TestObject),
280 auto ErrMsg = toString(std::move(Err));
312 auto H = cantFail(Client.addObject(std::move(TestObject),
318 auto ErrMsg = toString(std::move(Err));
336 auto ErrMsg = toString(std::move(Err));
376 cantFail(Client.addObject(std::move(TestObject),
391 auto ErrMsg = toString(std::move(Err));
418 auto ErrMsg = toString(std::move(Err));
465 auto H = cantFail(Client.addObject(std::move(TestObject),
478 auto ErrMsg = toString(std::move(Err));
495 logAllUnhandledErrors(std::move(Err), llvm::errs());
524 auto H = cantFail(Client.addObject(std::move(TestObject),
544 auto ErrMsg = toString(std::move(Err));
574 auto H = cantFail(Client.addObject(std::move(TestObject),
580 auto ErrMsg = toString(std::move(Err));
unittests/ExecutionEngine/Orc/ThreadSafeModuleTest.cpp 26 ThreadSafeModule TSM(std::move(M), std::move(TSCtx));
26 ThreadSafeModule TSM(std::move(M), std::move(TSCtx));
35 ThreadSafeModule TSM1(std::move(M1), TSCtx);
38 ThreadSafeModule TSM2(std::move(M2), std::move(TSCtx));
38 ThreadSafeModule TSM2(std::move(M2), std::move(TSCtx));
49 ThreadSafeModule TSM1(std::move(M1), TSCtx);
54 ThreadSafeModule TSM2(std::move(M2), std::move(TSCtx));
54 ThreadSafeModule TSM2(std::move(M2), std::move(TSCtx));
63 ThreadSafeModule TSM(std::move(M), std::move(TSCtx));
63 ThreadSafeModule TSM(std::move(M), std::move(TSCtx));
71 ThreadSafeModule TSM(std::move(M), TSCtx);
unittests/FuzzMutate/StrategiesTest.cpp 38 return std::make_unique<IRMutator>(std::move(Types), std::move(Strategies));
38 return std::make_unique<IRMutator>(std::move(Types), std::move(Strategies));
49 return std::make_unique<IRMutator>(std::move(Types), std::move(Strategies));
49 return std::make_unique<IRMutator>(std::move(Types), std::move(Strategies));
unittests/IR/CFGBuilder.cpp 32 : F(F), Updates(std::move(Updates)) {
unittests/IR/MetadataTest.cpp 56 ContextAndReplaceableUses CRU(std::move(ReplaceableUses));
670 FirstUniqued = MDNode::replaceWithUniqued(std::move(Temp));
681 auto *Uniqued = MDNode::replaceWithUniqued(std::move(Temp));
693 auto *Uniqued = MDNode::replaceWithUniqued(std::move(Temp));
783 auto *Distinct = MDNode::replaceWithDistinct(std::move(Temp));
796 auto *Distinct = MDNode::replaceWithDistinct(std::move(Temp));
823 auto *N = MDNode::replaceWithPermanent(std::move(Temp));
839 EXPECT_EQ(V, MDNode::replaceWithPermanent(std::move(Temp2)));
1126 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1150 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1198 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1234 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1264 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1358 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1497 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1648 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1685 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1751 auto *Clone = MDNode::replaceWithPermanent(std::move(Temp));
1942 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1969 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2021 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2042 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2076 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2097 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2126 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2213 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2249 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2298 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2333 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2439 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2479 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
unittests/IR/PassManagerTest.cpp 206 PA4 = std::move(PA2);
338 Intersected.intersect(std::move(Tmp));
348 Intersected.intersect(std::move(Tmp2));
357 Intersected.intersect(std::move(Tmp3));
426 FPM = std::move(NestedFPM);
428 NestedMPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
429 MPM = std::move(NestedMPM);
444 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
458 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
471 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
485 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
670 LambdaPass(FuncT Func) : Func(std::move(Func)) {}
757 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
761 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM2)));
unittests/Linker/LinkModulesTest.cpp 101 Linker::linkModules(*LinkedModule, std::move(M));
175 Linker::linkModules(*EmptyM, std::move(InternalM));
182 Linker::linkModules(*InternalM, std::move(EmptyM));
198 Linker::linkModules(*M1, std::move(M2));
283 Linker::linkModules(*Dst, std::move(Src));
352 bool Failed = Linker::linkModules(*Foo, std::move(Bar));
unittests/MI/LiveIntervalTest.cpp 56 MIR = createMIRParser(std::move(MBuffer), Context);
unittests/ProfileData/CoverageMappingTest.cpp 29 handleAllErrors(std::move(E), [&](const CoverageMapError &CME) {
69 : Name(OFCD.Name), Hash(OFCD.Hash), Filenames(std::move(OFCD.Filenames)),
70 Regions(std::move(OFCD.Regions)) {}
116 : Name(std::move(Name)), Hash(Hash) {}
119 : ReverseVirtualFileMapping(std::move(IFCD.ReverseVirtualFileMapping)),
120 Name(std::move(IFCD.Name)), Hash(IFCD.Hash),
121 Regions(std::move(IFCD.Regions)) {}
226 auto ReaderOrErr = IndexedInstrProfReader::create(std::move(Profile));
228 ProfileReader = std::move(ReaderOrErr.get());
253 LoadedCoverage = std::move(CoverageOrErr.get());
unittests/ProfileData/InstrProfTest.cpp 27 handleAllErrors(std::move(E), [&](const InstrProfError &IPE) {
46 auto ReaderOrErr = IndexedInstrProfReader::create(std::move(Profile),
47 std::move(Remapping));
49 Reader = std::move(ReaderOrErr.get());
64 readProfile(std::move(Profile));
69 consumeError(std::move(E));
76 readProfile(std::move(Profile));
94 readProfile(std::move(Profile));
119 readProfile(std::move(Profile));
135 ASSERT_TRUE(ErrorEquals(instrprof_error::hash_mismatch, std::move(E1)));
138 ASSERT_TRUE(ErrorEquals(instrprof_error::unknown_function, std::move(E2)));
153 readProfile(std::move(Profile));
207 Writer.mergeRecordsFromWriter(std::move(Writer2), Err);
210 readProfile(std::move(Profile));
246 Writer.addRecord(std::move(Record1), Err);
251 readProfile(std::move(Profile));
281 Writer.addRecord(std::move(Record), Err);
283 readProfile(std::move(Profile));
386 Writer.addRecord(std::move(Record1), 10, Err);
391 readProfile(std::move(Profile));
429 Writer.addRecord(std::move(Record1), Err);
438 readProfile(std::move(Profile));
508 Writer.addRecord(std::move(Record11), Err);
510 Writer.addRecord(std::move(Record12), Err);
518 readProfile(std::move(Profile));
572 auto Err = [&](Error E) { Result = InstrProfError::take(std::move(E)); };
591 Writer.addRecord(std::move(Record4), Err);
600 Writer.addRecord(std::move(Record5), Err);
604 readProfile(std::move(Profile));
652 Writer.addRecord(std::move(Record11), Err);
654 Writer.addRecord(std::move(Record12), Err);
657 readProfile(std::move(Profile));
802 readProfile(std::move(Profile));
811 readProfile(std::move(Profile));
998 readProfile(std::move(Profile), llvm::MemoryBuffer::getMemBuffer(R"(
1038 readProfile(std::move(Profile));
unittests/ProfileData/SampleProfTest.cpp 50 Writer = std::move(WriterOrErr.get());
57 Reader = std::move(ReaderOrErr.get());
122 Profiles[FooName] = std::move(FooSamples);
123 Profiles[BarName] = std::move(BarSamples);
124 Profiles[BazName] = std::move(BazSamples);
125 Profiles[BooName] = std::move(BooSamples);
unittests/Remarks/BitstreamRemarksParsingTest.cpp 39 FromYAMLRemark = std::move(*Remark);
43 EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
53 BSStream, std::move(BSStrTab));
69 FromBSRemark = std::move(*BSRemark);
73 EXPECT_TRUE(errorToBool(std::move(BSE))); // Check for parsing errors.
222 EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
261 BSStream, std::move(BSStrTab));
unittests/Remarks/BitstreamRemarksSerializerTest.cpp 44 std::move(*StrTab));
50 std::move(*MaybeSerializer);
71 std::move(StrTab));
77 /*ExpectedMeta=*/None, std::move(StrTab));
132 std::move(StrTab));
340 std::move(StrTab));
unittests/Remarks/YAMLRemarksParsingTest.cpp 29 EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
45 EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
79 std::move(ExternalFilePrependPath));
464 EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
574 std::move(StrTab));
636 EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
650 std::move(StrTab));
unittests/Remarks/YAMLRemarksSerializerTest.cpp 34 std::move(*StrTab));
39 std::unique_ptr<remarks::RemarkSerializer> S = std::move(*MaybeS);
59 std::move(StrTab));
67 /*ExpectedMeta=*/None, std::move(StrTab));
237 std::move(PreFilledStrTab));
276 std::move(PreFilledStrTab));
299 Rs.emplace_back(std::move(R));
328 /*ExpectedMeta=*/None, std::move(PreFilledStrTab));
unittests/Support/AllocatorTest.cpp 32 BumpPtrAllocator Alloc2 = std::move(Alloc);
43 Alloc = std::move(Alloc2);
unittests/Support/BinaryStreamTest.cpp 151 Streams[I * 2].Input = std::move(InByteStream);
152 Streams[I * 2 + 1].Input = std::move(InBrokenStream);
unittests/Support/Casting.cpp 145 auto FP = cast<foo>(std::move(BP));
165 auto FP = cast_or_null<foo>(std::move(BP));
unittests/Support/ErrorTest.cpp 170 consumeError(std::move(E));
171 consumeError(std::move(F));
172 consumeError(std::move(G));
304 handleAllErrors(std::move(E),
373 consumeError(std::move(E));
378 consumeError(std::move(E));
408 return Error(std::move(SE));
426 [&](std::unique_ptr<CustomError> CE) { return Error(std::move(CE)); });
428 handleAllErrors(std::move(E),
591 consumeError(std::move(E));
671 consumeError(std::move(Err));
731 EXPECT_EQ(toString(std::move(E1)).compare("CustomError {0}"), 0);
734 handleAllErrors(std::move(E2), [](const CustomError &CE) {
739 EXPECT_EQ(toString(std::move(E3))
752 consumeError(std::move(OK));
760 consumeError(std::move(E1));
874 consumeError(createFileError("file.bin", std::move(S)));
882 Error FE1 = createFileError("file.bin", std::move(E1));
883 EXPECT_EQ(toString(std::move(FE1)).compare("'file.bin': CustomError {1}"), 0);
886 Error FE2 = createFileError("file.bin", std::move(E2));
887 handleAllErrors(std::move(FE2), [](const FileError &F) {
892 Error FE3 = createFileError("file.bin", std::move(E3));
893 auto E31 = handleErrors(std::move(FE3), [](std::unique_ptr<FileError> F) {
896 handleAllErrors(std::move(E31), [](const CustomError &C) {
903 EXPECT_EQ(toString(std::move(FE4))
960 EXPECT_EQ(toString(std::move(E1)).compare("Error 1."), 0);
964 EXPECT_EQ(toString(std::move(E2)).compare("Error 1. Detailed information"),
968 handleAllErrors(std::move(E3), [](const TestDebugError &F) {
975 EXPECT_EQ(toString(std::move(E4))
unittests/Support/FileCheckTest.cpp 48 handleAllErrors(std::move(Err), [&](const FileCheckUndefVarError &E) {
57 expectUndefErrors({ExpectedUndefVarName.str()}, std::move(Err));
101 FileCheckASTBinop Binop(doAdd, std::move(FooVarUse), std::move(BarVarUse));
101 FileCheckASTBinop Binop(doAdd, std::move(FooVarUse), std::move(BarVarUse));
139 SM.AddNewSourceBuffer(std::move(Buffer), SMLoc());
424 std::move(LineVarUse), 12);
425 FileCheckNumericSubstitution SubstitutionN(&Context, "N", std::move(NVarUse),
unittests/Support/FormatVariadicTest.cpp 19 Format(int N) : FormatAdapter<int>(std::move(N)) {}
597 explicit Negative(int N) : FormatAdapter<int>(std::move(N)) {}
620 auto fmt2 = std::move(fmt);
637 EXPECT_EQ("Format", formatv("{0}", std::move(var)).str());
669 EXPECT_EQ("0C 3M", formatv("{0}", std::move(R)).str());
688 EXPECT_EQ("X", formatv("{0}", fmt_consume(std::move(E1))).str());
unittests/Support/Path.cpp 591 fs::TempFile File = std::move(*TempFileOrError);
603 fs::TempFile File = std::move(*TempFileOrError);
707 TempFiles.push_back(std::move(*T));
unittests/Support/RegexTest.cpp 144 Regex r2(std::move(r1));
151 r2 = std::move(r1);
unittests/Support/SourceMgrTest.cpp 27 MainBufferID = SM.AddNewSourceBuffer(std::move(MainBuffer), llvm::SMLoc());
unittests/Support/SymbolRemappingReaderTest.cpp 25 return toString(std::move(E));
unittests/Support/TarWriterTest.cpp 50 std::unique_ptr<TarWriter> Tar = std::move(*TarOrErr);
57 std::unique_ptr<MemoryBuffer> MB = std::move(*MBOrErr);
131 std::unique_ptr<TarWriter> Tar = std::move(*TarOrErr);
149 std::unique_ptr<TarWriter> Tar = std::move(*TarOrErr);
168 std::unique_ptr<TarWriter> Tar = std::move(*TarOrErr);
unittests/Support/VirtualFileSystemTest.cpp 1349 return getVFSFromYAML(std::move(Buffer), CountingDiagHandler, "", this,
unittests/TableGen/CodeExpanderTest.cpp 22 SrcMgr.AddNewSourceBuffer(std::move(Buffer), SMLoc());
unittests/Target/AArch64/InstSizes.cpp 59 createMIRParser(std::move(MBuffer), Context);
unittests/Target/WebAssembly/WebAssemblyExceptionInfoTest.cpp 48 MIR = createMIRParser(std::move(MBuffer), Context);
unittests/Target/X86/MachineSizeOptsTest.cpp 70 Parser = createMIRParser(std::move(MBuffer), Context);
unittests/TextAPI/ELFYAMLTest.cpp 46 std::unique_ptr<ELFStub> Stub = std::move(StubOrErr.get());
71 std::unique_ptr<ELFStub> Stub = std::move(StubOrErr.get());
130 std::unique_ptr<ELFStub> Stub = std::move(StubOrErr.get());
194 ELFStub Moved = std::move(Stub);
unittests/TextAPI/TextStubV1Tests.cpp 87 auto File = std::move(Result.get());
140 auto File = std::move(Result.get());
226 auto File = std::move(Result.get());
243 auto File = std::move(Result.get());
260 auto File = std::move(Result.get());
277 auto File = std::move(Result.get());
294 auto File = std::move(Result.get());
311 auto File = std::move(Result.get());
327 auto File = std::move(Result.get());
343 auto File = std::move(Result.get());
359 auto File = std::move(Result.get());
391 auto File = std::move(Result.get());
407 auto File = std::move(Result.get());
unittests/TextAPI/TextStubV2Tests.cpp 89 auto File = std::move(Result.get());
160 auto File = std::move(Result.get());
246 auto File = std::move(Result.get());
264 auto File = std::move(Result.get());
281 auto File = std::move(Result.get());
298 auto File = std::move(Result.get());
315 auto File = std::move(Result.get());
332 auto File = std::move(Result.get());
348 auto File = std::move(Result.get());
364 auto File = std::move(Result.get());
380 auto File = std::move(Result.get());
412 auto File = std::move(Result.get());
428 auto File = std::move(Result.get());
unittests/TextAPI/TextStubV3Tests.cpp 93 auto File = std::move(Result.get());
203 auto File = std::move(Result.get());
220 auto File = std::move(Result.get());
237 auto File = std::move(Result.get());
253 auto File = std::move(Result.get());
271 auto File = std::move(Result.get());
288 auto File = std::move(Result.get());
303 auto File = std::move(Result.get());
325 auto File = std::move(Result.get());
341 auto File = std::move(Result.get());
357 auto File = std::move(Result.get());
373 auto File = std::move(Result.get());
405 auto File = std::move(Result.get());
421 auto File = std::move(Result.get());
unittests/TextAPI/TextStubV4Tests.cpp 110 auto File = std::move(Result.get());
151 Undefineds.emplace_back(std::move(temp));
153 Sym->isReexported() ? Reexports.emplace_back(std::move(temp))
154 : Exports.emplace_back(std::move(temp));
252 auto File = std::move(Result.get());
274 auto File = std::move(Result.get());
293 auto File = std::move(Result.get());
311 auto File = std::move(Result.get());
328 auto File = std::move(Result.get());
345 auto File = std::move(Result.get());
361 auto File = std::move(Result.get());
378 auto File = std::move(Result.get());
396 auto File = std::move(Result.get());
414 auto File = std::move(Result.get());
431 auto File = std::move(Result.get());
446 auto File = std::move(Result.get());
461 auto File = std::move(Result.get());
476 auto File = std::move(Result.get());
unittests/Transforms/Scalar/LoopPassManagerTest.cpp 338 FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM)));
339 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
365 FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM)));
366 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
447 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
663 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
764 FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM)));
765 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
847 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
924 FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM)));
927 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
1127 FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM)));
1130 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
1416 FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM)));
1581 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
unittests/Transforms/Utils/ValueMapperTest.cpp 40 U1 = MDNode::replaceWithUniqued(std::move(T));
82 N0 = MDNode::replaceWithUniqued(std::move(T0));
unittests/XRay/FDRProducerConsumerTest.cpp 146 if (auto E = C.consume(std::move(R.get())))
187 if (auto E = C.consume(std::move(R.get())))
unittests/XRay/GraphTest.cpp 174 TypeParam G(std::move(this->Graph));
unittests/XRay/ProfileTest.cpp 95 P1 = std::move(P0);
unittests/tools/llvm-cfi-verify/FileAnalysis.cpp 71 handleAllErrors(std::move(Err), [&](const UnsupportedDisassembly &E) {
unittests/tools/llvm-cfi-verify/GraphBuilder.cpp 131 handleAllErrors(std::move(Err), [&](const UnsupportedDisassembly &E) {
unittests/tools/llvm-exegesis/ClusteringTest.cpp 81 consumeError(std::move(Error));
93 consumeError(std::move(Error));
unittests/tools/llvm-exegesis/X86/SnippetFileTest.cpp 95 consumeError(std::move(Error));
105 consumeError(std::move(Error));
115 consumeError(std::move(Error));
unittests/tools/llvm-exegesis/X86/SnippetGeneratorTest.cpp 56 return std::move(CodeTemplateOrError.get());
158 consumeError(std::move(Error));
383 consumeError(std::move(Error));
395 Snippet.push_back(std::move(IT));
410 Snippet.push_back(std::move(Mov));
416 Snippet.push_back(std::move(Add));
usr/include/c++/7.4.0/bits/alloc_traits.h 536 { __one = std::move(__two); }
usr/include/c++/7.4.0/bits/basic_string.h 149 : allocator_type(std::move(__a)), _M_p(__dat) { }
532 : _M_dataplus(_M_local_data(), std::move(__str._M_get_allocator()))
1375 return *this = std::move(__str);
5955 { return std::move(__lhs.append(__rhs)); }
5961 { return std::move(__rhs.insert(0, __lhs)); }
5971 return __cond ? std::move(__rhs.insert(0, __lhs))
5972 : std::move(__lhs.append(__rhs));
5979 { return std::move(__rhs.insert(0, __lhs)); }
5985 { return std::move(__rhs.insert(0, 1, __lhs)); }
5991 { return std::move(__lhs.append(__rhs)); }
5997 { return std::move(__lhs.append(1, __rhs)); }
usr/include/c++/7.4.0/bits/deque.tcc 645 push_front(_GLIBCXX_MOVE(front()));
657 push_back(_GLIBCXX_MOVE(back()));
665 *__pos = _GLIBCXX_MOVE(__x_copy);
usr/include/c++/7.4.0/bits/forward_list.h 294 : _Node_alloc_type(std::move(__a)), _M_head()
317 : _M_impl(std::move(__a)) { }
322 : _M_impl(std::move(__lst._M_get_Node_allocator()))
540 : _Base(std::move(__list)) { }
830 { this->_M_insert_after(cbefore_begin(), std::move(__val)); }
usr/include/c++/7.4.0/bits/hashtable.h 468 _M_move_assign(std::move(__ht), __bool_constant<__move_storage>());
1150 __hashtable_base::operator=(std::move(__ht));
1262 __hashtable_alloc(std::move(__ht._M_base_alloc())),
usr/include/c++/7.4.0/bits/hashtable_policy.h 751 std::forward_as_tuple(std::move(__k)),
946 return __h._M_insert(std::move(__v), __node_gen, __unique_keys());
usr/include/c++/7.4.0/bits/move.h 150 _Tp __old_val = std::move(__obj);
198 _Tp __tmp = _GLIBCXX_MOVE(__a);
199 __a = _GLIBCXX_MOVE(__b);
200 __b = _GLIBCXX_MOVE(__tmp);
usr/include/c++/7.4.0/bits/predefined_ops.h 136 : _M_comp(_GLIBCXX_MOVE(__comp))
150 { return _Iter_comp_iter<_Compare>(_GLIBCXX_MOVE(__comp)); }
159 : _M_comp(_GLIBCXX_MOVE(__comp))
170 : _M_comp(std::move(__comp._M_comp))
183 { return _Iter_comp_val<_Compare>(_GLIBCXX_MOVE(__comp)); }
188 { return _Iter_comp_val<_Compare>(_GLIBCXX_MOVE(__comp)); }
197 : _M_comp(_GLIBCXX_MOVE(__comp))
208 : _M_comp(std::move(__comp._M_comp))
221 { return _Val_comp_iter<_Compare>(_GLIBCXX_MOVE(__comp)); }
226 { return _Val_comp_iter<_Compare>(_GLIBCXX_MOVE(__comp)); }
277 : _M_pred(_GLIBCXX_MOVE(__pred))
289 { return _Iter_pred<_Predicate>(_GLIBCXX_MOVE(__pred)); }
321 : _M_comp(_GLIBCXX_MOVE(__comp)), _M_it1(__it1)
335 _GLIBCXX_MOVE(__comp._M_comp), __it);
345 : _M_pred(_GLIBCXX_MOVE(__pred))
357 { return _Iter_negate<_Predicate>(_GLIBCXX_MOVE(__pred._M_pred)); }
usr/include/c++/7.4.0/bits/regex.h 512 : basic_regex(std::move(__first), std::move(__last), locale_type(), __f)
512 : basic_regex(std::move(__first), std::move(__last), locale_type(), __f)
545 { return this->assign(std::move(__rhs)); }
603 basic_regex __tmp(std::move(__rhs));
765 : _M_flags(__f), _M_loc(std::move(__loc)),
767 std::move(__first), std::move(__last), _M_loc, _M_flags))
767 std::move(__first), std::move(__last), _M_loc, _M_flags))
usr/include/c++/7.4.0/bits/regex_automaton.h 150 _MatcherT(std::move(__rhs._M_get_matcher()));
252 return _M_insert_state(std::move(__tmp));
264 return _M_insert_state(std::move(__tmp));
271 __tmp._M_get_matcher() = std::move(__m);
272 return _M_insert_state(std::move(__tmp));
282 return _M_insert_state(std::move(__tmp));
291 return _M_insert_state(std::move(__tmp));
310 return _M_insert_state(std::move(__tmp));
319 return _M_insert_state(std::move(__tmp));
329 this->push_back(std::move(__s));
usr/include/c++/7.4.0/bits/regex_automaton.tcc 173 return _M_insert_state(std::move(__tmp));
206 auto __id = _M_nfa._M_insert_state(std::move(__dup));
usr/include/c++/7.4.0/bits/regex_compiler.h 73 { return std::move(_M_nfa); }
usr/include/c++/7.4.0/bits/regex_compiler.tcc 416 _M_nfa->_M_insert_matcher(std::move(__matcher))));
447 _M_nfa->_M_insert_matcher(std::move(__matcher))));
usr/include/c++/7.4.0/bits/regex_executor.tcc 126 auto __old_queue = std::move(_M_states._M_match_queue);
129 _M_cur_results = std::move(__task.second);
usr/include/c++/7.4.0/bits/shared_ptr.h 147 : __shared_ptr<_Tp>(__p, std::move(__d)) { }
245 : __shared_ptr<_Tp>(std::move(__r)) { }
254 : __shared_ptr<_Tp>(std::move(__r)) { }
278 : __shared_ptr<_Tp>(std::move(__r)) { }
319 this->__shared_ptr<_Tp>::operator=(std::move(__r));
327 this->__shared_ptr<_Tp>::operator=(std::move(__r));
335 this->__shared_ptr<_Tp>::operator=(std::move(__r));
usr/include/c++/7.4.0/bits/shared_ptr_base.h 414 explicit _Sp_ebo_helper(_Tp&& __tp) : _Tp(std::move(__tp)) { }
425 explicit _Sp_ebo_helper(_Tp&& __tp) : _M_tp(std::move(__tp)) { }
446 : _M_ptr(__p), _Del_base(std::move(__d)), _Alloc_base(__a)
460 : _M_impl(__p, std::move(__d), _Alloc()) { }
464 : _M_impl(__p, std::move(__d), __a) { }
605 : __shared_count(__p, std::move(__d), allocator<void>())
617 ::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a));
617 ::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a));
637 ::new (__mem) _Sp_cp_type(std::move(__a),
1088 : _M_ptr(__p), _M_refcount(__p, std::move(__d))
1161 _M_refcount = __shared_count<_Lp>(std::move(__r));
1213 __shared_ptr(std::move(__r)).swap(*this);
1221 __shared_ptr(std::move(__r)).swap(*this);
1229 __shared_ptr(std::move(__r)).swap(*this);
1636 : _M_ptr(__r._M_ptr), _M_refcount(std::move(__r._M_refcount))
1669 _M_refcount = std::move(__r._M_refcount);
usr/include/c++/7.4.0/bits/std_function.h 239 { _M_init_functor(__functor, std::move(__f), _Local_storage()); }
264 { ::new (__functor._M_access()) _Functor(std::move(__f)); }
268 { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); }
500 function(std::move(__x)).swap(*this);
693 _My_handler::_M_init_functor(_M_functor, std::move(__f));
usr/include/c++/7.4.0/bits/std_mutex.h 250 unique_lock(std::move(__u)).swap(*this);
usr/include/c++/7.4.0/bits/stl_algo.h 871 *__result = _GLIBCXX_MOVE(*__first);
975 *++__dest = _GLIBCXX_MOVE(*__first);
1365 _ValueType __t = _GLIBCXX_MOVE(*__p);
1367 *(__p + __n - 1) = _GLIBCXX_MOVE(__t);
1388 _ValueType __t = _GLIBCXX_MOVE(*(__p + __n - 1));
1390 *__p = _GLIBCXX_MOVE(__t);
1566 *__result2 = _GLIBCXX_MOVE(*__first);
1572 *__result1 = _GLIBCXX_MOVE(*__first);
1577 *__result2 = _GLIBCXX_MOVE(*__first);
1825 __val = _GLIBCXX_MOVE(*__last);
1830 *__last = _GLIBCXX_MOVE(*__next);
1834 *__last = _GLIBCXX_MOVE(__val);
1850 __val = _GLIBCXX_MOVE(*__i);
1852 *__first = _GLIBCXX_MOVE(__val);
2312 *__result = _GLIBCXX_MOVE(*__first2);
2317 *__result = _GLIBCXX_MOVE(*__first1);
2351 *--__result = _GLIBCXX_MOVE(*__last1);
2361 *--__result = _GLIBCXX_MOVE(*__last2);
2647 *__result = _GLIBCXX_MOVE(*__first2);
2652 *__result = _GLIBCXX_MOVE(*__first1);
usr/include/c++/7.4.0/bits/stl_algobase.h 343 *__result = std::move(*__first);
548 *--__result = std::move(*--__last);
usr/include/c++/7.4.0/bits/stl_bvector.h 436 : _Bit_alloc_type(std::move(__a)), _M_start(), _M_finish(),
473 : _M_impl(std::move(__x._M_get_Bit_allocator()))
622 : _Base(std::move(__x)) { }
usr/include/c++/7.4.0/bits/stl_deque.h 512 : _M_impl(std::move(__x._M_get_Tp_allocator()))
520 : _Deque_base(std::move(__x), typename _Alloc_traits::is_always_equal{})
571 : _Tp_alloc_type(std::move(__a)), _M_map(), _M_map_size(0),
963 : _Base(std::move(__x)) { }
1072 _M_move_assign1(std::move(__x), __always_equal{});
1521 { emplace_front(std::move(__x)); }
1558 { emplace_back(std::move(__x)); }
1666 { return emplace(__position, std::move(__x)); }
usr/include/c++/7.4.0/bits/stl_heap.h 135 *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __parent));
139 *(__first + __holeIndex) = _GLIBCXX_MOVE(__value);
170 _ValueType __value = _GLIBCXX_MOVE(*(__last - 1));
172 _DistanceType(0), _GLIBCXX_MOVE(__value), __comp);
204 __decltype(__gnu_cxx::__ops::__iter_comp_val(_GLIBCXX_MOVE(__comp)))
205 __cmp(_GLIBCXX_MOVE(__comp));
206 _ValueType __value = _GLIBCXX_MOVE(*(__last - 1));
208 _DistanceType(0), _GLIBCXX_MOVE(__value), __cmp);
225 *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __secondChild));
231 *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first
235 __decltype(__gnu_cxx::__ops::__iter_comp_val(_GLIBCXX_MOVE(__comp)))
236 __cmp(_GLIBCXX_MOVE(__comp));
238 _GLIBCXX_MOVE(__value), __cmp);
251 _ValueType __value = _GLIBCXX_MOVE(*__result);
252 *__result = _GLIBCXX_MOVE(*__first);
255 _GLIBCXX_MOVE(__value), __comp);
318 __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(_GLIBCXX_MOVE(__comp));
341 _ValueType __value = _GLIBCXX_MOVE(*(__first + __parent));
342 std::__adjust_heap(__first, __parent, __len, _GLIBCXX_MOVE(__value),
396 __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(_GLIBCXX_MOVE(__comp));
460 __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(_GLIBCXX_MOVE(__comp));
553 __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(_GLIBCXX_MOVE(__comp));
usr/include/c++/7.4.0/bits/stl_iterator.h 499 container->push_back(std::move(__value));
703 iter = container->insert(iter, std::move(__value));
usr/include/c++/7.4.0/bits/stl_list.h 342 : _Node_alloc_type(std::move(__a)), _M_node()
410 : _M_impl(std::move(__x._M_get_Node_allocator()))
411 { _M_move_nodes(std::move(__x)); }
666 : _Base(std::move(__x)) { }
765 _M_move_assign(std::move(__x), __bool_constant<__move_storage>());
1073 { this->_M_insert(begin(), std::move(__x)); }
1123 { this->_M_insert(end(), std::move(__x)); }
1215 { return emplace(__position, std::move(__x)); }
1444 { splice(__position, std::move(__x)); }
1502 { splice(__position, std::move(__x), __i); }
1572 { splice(__position, std::move(__x), __first, __last); }
1648 { merge(std::move(__x)); }
1675 { merge(std::move(__x), __comp); }
usr/include/c++/7.4.0/bits/stl_map.h 513 std::forward_as_tuple(std::move(__k)),
803 { return _M_t._M_insert_unique(std::move(__x)); }
863 { return _M_t._M_insert_unique_(__position, std::move(__x)); }
usr/include/c++/7.4.0/bits/stl_multimap.h 539 { return _M_t._M_insert_equal(std::move(__x)); }
usr/include/c++/7.4.0/bits/stl_multiset.h 498 { return _M_t._M_insert_equal(std::move(__x)); }
usr/include/c++/7.4.0/bits/stl_queue.h 257 { c.push_back(std::move(__x)); }
483 : c(std::move(__s)), comp(__x)
605 c.push_back(std::move(__x));
usr/include/c++/7.4.0/bits/stl_set.h 511 _M_t._M_insert_unique(std::move(__x));
542 { return _M_t._M_insert_unique_(__position, std::move(__x)); }
usr/include/c++/7.4.0/bits/stl_stack.h 157 : c(std::move(__c)) { }
231 { c.push_back(std::move(__x)); }
usr/include/c++/7.4.0/bits/stl_tempbuf.h 195 _GLIBCXX_MOVE(*__seed));
200 _GLIBCXX_MOVE(*__prev));
201 *__seed = _GLIBCXX_MOVE(*__prev);
usr/include/c++/7.4.0/bits/stl_tree.h 703 : _Node_allocator(std::move(__a)), _Base_key_compare(__comp)
1665 _M_impl._M_key_compare = std::move(__x._M_impl._M_key_compare);
usr/include/c++/7.4.0/bits/stl_vector.h 98 : _Tp_alloc_type(std::move(__a)),
145 : _M_impl(std::move(__x._M_get_Tp_allocator()))
345 : _Base(std::move(__x)) { }
466 _M_move_assign(std::move(__x), __bool_constant<__move_storage>());
954 { emplace_back(std::move(__x)); }
1043 { return _M_insert_rval(__position, std::move(__x)); }
1497 { return _M_insert_rval(__position, std::move(__v)); }
usr/include/c++/7.4.0/bits/unique_ptr.h 226 : _M_t(std::move(__p), std::move(__d))
226 : _M_t(std::move(__p), std::move(__d))
usr/include/c++/7.4.0/bits/unordered_map.h 585 { return _M_h.insert(std::move(__x)); }
977 { return _M_h[std::move(__k)]; }
usr/include/c++/7.4.0/bits/unordered_set.h 424 { return _M_h.insert(std::move(__x)); }
usr/include/c++/7.4.0/bits/vector.tcc 136 _M_insert_aux(__pos, std::move(__x_copy._M_val()));
321 std::move(__v));
325 _M_insert_aux(begin() + __n, std::move(__v));
327 _M_realloc_insert(begin() + __n, std::move(__v));
353 _M_insert_aux(begin() + __n, std::move(__tmp._M_val()));
374 _GLIBCXX_MOVE(*(this->_M_impl._M_finish
usr/include/c++/7.4.0/condition_variable 156 return wait_until(__lock, __clock_t::now() + __reltime, std::move(__p));
262 unique_lock<mutex> __my_lock2(std::move(__my_lock));
285 unique_lock<mutex> __my_lock2(std::move(__my_lock));
usr/include/c++/7.4.0/functional 415 ::std::get<(is_placeholder<_Arg>::value - 1)>(std::move(__tuple));
534 : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
540 : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
540 : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
usr/include/c++/7.4.0/future 258 ::new (_M_storage._M_addr()) _Res(std::move(__res));
426 __mr->_M_shared_state = std::move(__self);
488 _M_promise->_M_storage->_M_set(std::move(*_M_arg));
489 return std::move(_M_promise->_M_storage);
502 { return std::move(_M_promise->_M_storage); }
517 return std::move(_M_promise->_M_storage);
779 future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { }
787 future(std::move(__fut))._M_swap(*this);
796 return std::move(this->_M_get_result()._M_value());
865 future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { }
873 future(std::move(__fut))._M_swap(*this);
903 : _Base_type(std::move(__uf))
908 : _Base_type(std::move(__sf))
981 : _Base_type(std::move(__uf))
986 : _Base_type(std::move(__sf))
997 shared_future(std::move(__sf))._M_swap(*this);
1016 : _M_state(std::move(__sf._M_state))
1022 : _M_state(std::move(__uf._M_state))
1039 { return shared_future<void>(std::move(*this)); }
1061 : _M_future(std::move(__rhs._M_future)),
1062 _M_storage(std::move(__rhs._M_storage))
1082 _M_future->_M_break_promise(std::move(_M_storage));
1114 { _M_future->_M_set_result(_State::__setter(this, std::move(__r))); }
1262 : _M_future(std::move(__rhs._M_future)),
1263 _M_storage(std::move(__rhs._M_storage))
1276 : _M_future(std::move(__rhs._M_future)),
1277 _M_storage(std::move(__rhs._M_storage))
1285 _M_future->_M_break_promise(std::move(_M_storage));
1292 promise(std::move(__rhs)).swap(*this);
1349 return std::move(*_M_result);
1372 return std::move(*_M_result);
1433 std::move(__self));
1461 return __create_task_state<_Res(_Args...)>(std::move(_M_impl._M_fn),
1512 _M_state->_M_break_promise(std::move(_M_state->_M_result));
1534 packaged_task(std::move(__other)).swap(*this);
1597 : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn))
1662 : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn))
1673 this->_M_break_promise(std::move(_M_result));
1696 return std::make_shared<__state_type>(std::move(__fn));
1705 return std::make_shared<__state_type>(std::move(__fn));
usr/include/c++/7.4.0/thread 234 { return std::__invoke(std::get<_Ind>(std::move(_M_t))...); }
usr/include/c++/7.4.0/tuple 226 : _Inherited(std::move(_M_tail(__in))),
236 : _Inherited(std::move
305 _M_tail(*this) = std::move(_M_tail(__in));
324 _M_tail(*this) = std::move
845 static_cast<_Inherited&>(*this) = std::move(__in);
865 static_cast<_Inherited&>(*this) = std::move(__in);
1219 static_cast<_Inherited&>(*this) = std::move(__in);
1235 static_cast<_Inherited&>(*this) = std::move(__in);
usr/include/c++/7.4.0/utility 231 { return __pair_get<_Int>::__move_get(std::move(__in)); }
utils/TableGen/AsmMatcherEmitter.cpp 1528 Matchables.push_back(std::move(II));
1550 auto II = std::make_unique<MatchableInfo>(std::move(Alias));
1557 Matchables.push_back(std::move(II));
1625 NewMatchables.push_back(std::move(AliasII));
2251 ConversionTable.push_back(std::move(ConversionRow));
utils/TableGen/AsmWriterEmitter.cpp 186 UniqueOperandCommands.push_back(std::move(Command));
377 TableDrivenOperandPrinters.push_back(std::move(UniqueOperandCommands));
627 : Result(std::move(R)), AsmString(std::move(AS)) {}
627 : Result(std::move(R)), AsmString(std::move(AS)) {}
975 IAPrinterMap[Aliases.first].push_back(std::move(IAP));
utils/TableGen/CodeEmitterGen.cpp 474 CaseMap[Case].push_back(std::move(InstName));
utils/TableGen/CodeGenDAGPatterns.cpp 1900 New = std::make_shared<TreePatternNode>(getOperator(), std::move(CChildren),
1941 setChild(i, std::move(NewChild));
2000 getOperator(), std::move(NewChildren), getNumTypes());
2868 std::make_shared<TreePatternNode>(Operator, std::move(Children),
2905 N->setChild(i, std::move(Child));
3227 DefaultOpInfo.DefaultOps.push_back(std::move(TPN));
3676 ResNodes.push_back(std::move(RNode));
3737 OpNode = std::make_shared<TreePatternNode>(Xform, std::move(Children),
3741 ResultNodeOperands.push_back(std::move(OpNode));
3749 I.getRecord(), std::move(ResultNodeOperands),
4085 return std::make_shared<TreePatternNode>(Xform, std::move(Children),
4251 PatternsToMatch.emplace_back(P.getSrcRecord(), Preds, std::move(NewSrc),
4252 std::move(NewDst), P.getDstRegs(),
4383 Orig->getOperator(), std::move(NewChildren), Orig->getNumTypes());
4559 Variants.push_back(std::move(ChildVariants[0])); // Intrinsic id.
4560 Variants.push_back(std::move(ChildVariants[2]));
4561 Variants.push_back(std::move(ChildVariants[1]));
4563 Variants.push_back(std::move(ChildVariants[i]));
4567 Variants.push_back(std::move(ChildVariants[1]));
4568 Variants.push_back(std::move(ChildVariants[0]));
4570 Variants.push_back(std::move(ChildVariants[i]));
utils/TableGen/CodeGenDAGPatterns.h 669 Children(std::move(Ch)) {
1114 Predicates(std::move(preds)), Dstregs(std::move(dstregs)),
1114 Predicates(std::move(preds)), Dstregs(std::move(dstregs)),
utils/TableGen/CodeGenInstruction.h 346 : Name(std::move(N)), R(r), Kind(K_Record) {}
utils/TableGen/CodeGenSchedule.cpp 397 Fn.addOpcode(Info.first, std::move(Info.second));
414 STIPredicates.emplace_back(std::move(Predicate));
1025 SchedClasses[Idx].ProcIndices = std::move(PI);
1676 SCTrans.PredTerm = std::move(Preds);
1678 .Transitions.push_back(std::move(SCTrans));
utils/TableGen/CodeGenSchedule.h 144 : Index(Index), Name(std::move(Name)), ItinClassDef(ItinClassDef) {}
254 Index(Idx), ModelName(std::move(Name)), ModelDef(MDef), ItinsDef(IDef),
357 OpcodeGroup(OpcodeInfo &&OpInfo) : Info(std::move(OpInfo)) {}
394 Groups.emplace_back(std::move(Info));
utils/TableGen/DAGISelMatcherEmitter.cpp 74 VecPatterns.insert(make_pair(std::move(P), VecPatterns.size()));
75 VecIncludeStrings.push_back(std::move(include_loc));
713 getPatternIdxFromTable(src + " -> " + dst, std::move(include_src));
790 getPatternIdxFromTable(src + " -> " + dst, std::move(include_src));
utils/TableGen/FastISelEmitter.cpp 44 : Name(Name), RC(RC), SubRegNo(std::move(SubRegNo)),
45 PhysRegs(std::move(PhysRegs)),
46 PredicateCheck(std::move(PredicateCheck)) {}
606 std::move(Memo));
utils/TableGen/FixedLenDecoderEmitter.cpp 71 : Decoder(std::move(D)), HasCompleteDecoder(HCD), InitValue(0) {}
137 : RK(R), Target(R), PredicateNamespace(std::move(PredicateNamespace)),
138 GuardPrefix(std::move(GPrefix)), GuardPostfix(std::move(GPostfix)),
138 GuardPrefix(std::move(GPrefix)), GuardPostfix(std::move(GPostfix)),
139 ReturnOK(std::move(ROK)), ReturnFail(std::move(RFail)),
139 ReturnOK(std::move(ROK)), ReturnFail(std::move(RFail)),
140 Locals(std::move(L)) {}
547 FilteredInstructions(std::move(f.FilteredInstructions)),
548 VariableInstructions(std::move(f.VariableInstructions)),
549 FilterChooserMap(std::move(f.FilterChooserMap)), NumFiltered(f.NumFiltered),
utils/TableGen/GICombinerEmitter.cpp 275 ActiveRules.emplace_back(std::move(Rule));
utils/TableGen/GlobalISelEmitter.cpp 728 std::unique_ptr<PredicateMatcher> P = std::move(Conditions.front());
1015 std::unique_ptr<PredicateTy> Front = std::move(Predicates.front());
1022 Predicates.push_front(std::move(Predicate));
2284 Stash.push_back(std::move(OP));
2299 Stash.push_back(std::move(OP));
3499 return failedImport(toString(std::move(Error)) +
3750 return std::move(Error);
3824 return failedImport(toString(std::move(Error)) + " for Src operand (" +
4000 return std::move(Error);
4079 return std::move(Error);
4099 return std::move(Error);
4113 return std::move(Error);
4124 return std::move(Error);
4296 return std::move(Error);
4327 return std::move(Error);
4335 return std::move(Error);
4536 return std::move(Error);
4545 toString(std::move(Err)) + ")");
4548 toString(std::move(Err)) + ")");
4576 return std::move(Error);
4604 return std::move(M);
4694 return std::move(Error);
4700 return std::move(Error);
4721 return std::move(M);
4752 return std::move(M);
4773 return std::move(M);
4797 return std::move(M);
4804 return std::move(M);
4899 MatcherStorage.emplace_back(std::move(CurrentGroup));
5034 "Skipped pattern: " + toString(std::move(Err)));
5036 consumeError(std::move(Err));
5049 Rules.push_back(std::move(MatcherOrErr.get()));
5341 EpilogueMatchers.emplace_back(std::move(OP));
5396 std::unique_ptr<PredicateMatcher> Result = std::move(OP);
utils/TableGen/RegisterInfoEmitter.cpp 381 DwarfRegNums.emplace_back(Reg, std::move(RegNums));
utils/TableGen/SearchableTableEmitter.cpp 663 Enums.emplace_back(std::move(Enum));
702 Tables.emplace_back(std::move(Table));
743 Enums.emplace_back(std::move(Enum));
773 Tables.emplace_back(std::move(Table));
utils/benchmark/src/benchmark_register.cc 99 families_.push_back(std::move(family));
210 benchmarks->push_back(std::move(instance));
221 families->AddBenchmark(std::move(bench_ptr));
299 args_.push_back(std::move(tmp));
utils/unittest/googlemock/include/gmock/gmock-actions.h 507 explicit ByMoveWrapper(T value) : payload(internal::move(value)) {}
541 explicit ReturnAction(R value) : value_(new R(internal::move(value))) {}
609 return internal::move(wrapper_->payload);
1064 return internal::ReturnAction<R>(internal::move(value));
1097 return internal::ByMoveWrapper<R>(internal::move(x));
utils/unittest/googlemock/include/gmock/gmock-matchers.h 1838 explicit PredicateFormatterFromMatcher(M m) : matcher_(internal::move(m)) {}
1882 return PredicateFormatterFromMatcher<M>(internal::move(matcher));
utils/unittest/googlemock/include/gmock/gmock-spec-builders.h 1308 : value_(::testing::internal::move(value)) {
1314 T Unwrap() { return ::testing::internal::move(value_); }
1412 : result_(::testing::internal::move(result)) {