From: Craig Topper Date: Wed, 12 Mar 2014 06:41:41 +0000 (+0000) Subject: [C++11] Add 'override' keyword to virtual methods that override their base class. X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=f7bc497ad124eb24508b668f627c35a17426887e;p=clang [C++11] Add 'override' keyword to virtual methods that override their base class. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@203643 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/CodeGen/CGBlocks.cpp b/lib/CodeGen/CGBlocks.cpp index 7f2533d1ff..56c34bcf61 100644 --- a/lib/CodeGen/CGBlocks.cpp +++ b/lib/CodeGen/CGBlocks.cpp @@ -1587,7 +1587,7 @@ public: : ByrefHelpers(alignment), Flags(flags) {} void emitCopy(CodeGenFunction &CGF, llvm::Value *destField, - llvm::Value *srcField) { + llvm::Value *srcField) override { destField = CGF.Builder.CreateBitCast(destField, CGF.VoidPtrTy); srcField = CGF.Builder.CreateBitCast(srcField, CGF.VoidPtrPtrTy); @@ -1602,14 +1602,14 @@ public: CGF.EmitNounwindRuntimeCall(fn, args); } - void emitDispose(CodeGenFunction &CGF, llvm::Value *field) { + void emitDispose(CodeGenFunction &CGF, llvm::Value *field) override { field = CGF.Builder.CreateBitCast(field, CGF.Int8PtrTy->getPointerTo(0)); llvm::Value *value = CGF.Builder.CreateLoad(field); CGF.BuildBlockRelease(value, Flags | BLOCK_BYREF_CALLER); } - void profileImpl(llvm::FoldingSetNodeID &id) const { + void profileImpl(llvm::FoldingSetNodeID &id) const override { id.AddInteger(Flags.getBitMask()); } }; @@ -1620,15 +1620,15 @@ public: ARCWeakByrefHelpers(CharUnits alignment) : ByrefHelpers(alignment) {} void emitCopy(CodeGenFunction &CGF, llvm::Value *destField, - llvm::Value *srcField) { + llvm::Value *srcField) override { CGF.EmitARCMoveWeak(destField, srcField); } - void emitDispose(CodeGenFunction &CGF, llvm::Value *field) { + void emitDispose(CodeGenFunction &CGF, llvm::Value *field) override { CGF.EmitARCDestroyWeak(field); } - void profileImpl(llvm::FoldingSetNodeID &id) const { + void profileImpl(llvm::FoldingSetNodeID &id) const override { // 0 is distinguishable from all pointers and byref flags id.AddInteger(0); } @@ -1641,7 +1641,7 @@ public: ARCStrongByrefHelpers(CharUnits alignment) : ByrefHelpers(alignment) {} void emitCopy(CodeGenFunction &CGF, llvm::Value *destField, - llvm::Value *srcField) { + llvm::Value *srcField) override { // Do a "move" by copying the value and then zeroing out the old // variable. @@ -1665,11 +1665,11 @@ public: store->setAlignment(Alignment.getQuantity()); } - void emitDispose(CodeGenFunction &CGF, llvm::Value *field) { + void emitDispose(CodeGenFunction &CGF, llvm::Value *field) override { CGF.EmitARCDestroyStrong(field, ARCImpreciseLifetime); } - void profileImpl(llvm::FoldingSetNodeID &id) const { + void profileImpl(llvm::FoldingSetNodeID &id) const override { // 1 is distinguishable from all pointers and byref flags id.AddInteger(1); } @@ -1682,7 +1682,7 @@ public: ARCStrongBlockByrefHelpers(CharUnits alignment) : ByrefHelpers(alignment) {} void emitCopy(CodeGenFunction &CGF, llvm::Value *destField, - llvm::Value *srcField) { + llvm::Value *srcField) override { // Do the copy with objc_retainBlock; that's all that // _Block_object_assign would do anyway, and we'd have to pass the // right arguments to make sure it doesn't get no-op'ed. @@ -1695,11 +1695,11 @@ public: store->setAlignment(Alignment.getQuantity()); } - void emitDispose(CodeGenFunction &CGF, llvm::Value *field) { + void emitDispose(CodeGenFunction &CGF, llvm::Value *field) override { CGF.EmitARCDestroyStrong(field, ARCImpreciseLifetime); } - void profileImpl(llvm::FoldingSetNodeID &id) const { + void profileImpl(llvm::FoldingSetNodeID &id) const override { // 2 is distinguishable from all pointers and byref flags id.AddInteger(2); } @@ -1716,20 +1716,20 @@ public: const Expr *copyExpr) : ByrefHelpers(alignment), VarType(type), CopyExpr(copyExpr) {} - bool needsCopy() const { return CopyExpr != 0; } + bool needsCopy() const override { return CopyExpr != 0; } void emitCopy(CodeGenFunction &CGF, llvm::Value *destField, - llvm::Value *srcField) { + llvm::Value *srcField) override { if (!CopyExpr) return; CGF.EmitSynthesizedCXXCopyCtor(destField, srcField, CopyExpr); } - void emitDispose(CodeGenFunction &CGF, llvm::Value *field) { + void emitDispose(CodeGenFunction &CGF, llvm::Value *field) override { EHScopeStack::stable_iterator cleanupDepth = CGF.EHStack.stable_begin(); CGF.PushDestructorCleanup(VarType, field); CGF.PopCleanupBlocks(cleanupDepth); } - void profileImpl(llvm::FoldingSetNodeID &id) const { + void profileImpl(llvm::FoldingSetNodeID &id) const override { id.AddPointer(VarType.getCanonicalType().getAsOpaquePtr()); } }; @@ -2214,7 +2214,7 @@ namespace { llvm::Value *Addr; CallBlockRelease(llvm::Value *Addr) : Addr(Addr) {} - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { // Should we be passing FIELD_IS_WEAK here? CGF.BuildBlockRelease(Addr, BLOCK_FIELD_IS_BYREF); } diff --git a/lib/CodeGen/CGCUDANV.cpp b/lib/CodeGen/CGCUDANV.cpp index 68127d5ae7..fb11751fc9 100644 --- a/lib/CodeGen/CGCUDANV.cpp +++ b/lib/CodeGen/CGCUDANV.cpp @@ -39,7 +39,7 @@ private: public: CGNVCUDARuntime(CodeGenModule &CGM); - void EmitDeviceStubBody(CodeGenFunction &CGF, FunctionArgList &Args); + void EmitDeviceStubBody(CodeGenFunction &CGF, FunctionArgList &Args) override; }; } diff --git a/lib/CodeGen/CGCall.cpp b/lib/CodeGen/CGCall.cpp index a39f13b519..a550abfa9d 100644 --- a/lib/CodeGen/CGCall.cpp +++ b/lib/CodeGen/CGCall.cpp @@ -2250,7 +2250,7 @@ struct DestroyUnpassedArg : EHScopeStack::Cleanup { llvm::Value *Addr; QualType Ty; - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { const CXXDestructorDecl *Dtor = Ty->getAsCXXRecordDecl()->getDestructor(); assert(!Dtor->isTrivial()); CGF.EmitCXXDestructorCall(Dtor, Dtor_Complete, /*for vbase*/ false, diff --git a/lib/CodeGen/CGClass.cpp b/lib/CodeGen/CGClass.cpp index 92400b1b39..6bb3af2038 100644 --- a/lib/CodeGen/CGClass.cpp +++ b/lib/CodeGen/CGClass.cpp @@ -342,7 +342,7 @@ namespace { CallBaseDtor(const CXXRecordDecl *Base, bool BaseIsVirtual) : BaseClass(Base), BaseIsVirtual(BaseIsVirtual) {} - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { const CXXRecordDecl *DerivedClass = cast(CGF.CurCodeDecl)->getParent(); @@ -1368,7 +1368,7 @@ namespace { struct CallDtorDelete : EHScopeStack::Cleanup { CallDtorDelete() {} - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { const CXXDestructorDecl *Dtor = cast(CGF.CurCodeDecl); const CXXRecordDecl *ClassDecl = Dtor->getParent(); CGF.EmitDeleteCall(Dtor->getOperatorDelete(), CGF.LoadCXXThis(), @@ -1384,7 +1384,7 @@ namespace { assert(ShouldDeleteCondition != NULL); } - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { llvm::BasicBlock *callDeleteBB = CGF.createBasicBlock("dtor.call_delete"); llvm::BasicBlock *continueBB = CGF.createBasicBlock("dtor.continue"); llvm::Value *ShouldCallDelete @@ -1413,7 +1413,7 @@ namespace { : field(field), destroyer(destroyer), useEHCleanupForArray(useEHCleanupForArray) {} - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { // Find the address of the field. llvm::Value *thisValue = CGF.LoadCXXThis(); QualType RecordTy = CGF.getContext().getTagDeclType(field->getParent()); @@ -1794,7 +1794,7 @@ namespace { CXXDtorType Type) : Dtor(D), Addr(Addr), Type(Type) {} - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { CGF.EmitCXXDestructorCall(Dtor, Type, /*ForVirtualBase=*/false, /*Delegating=*/true, Addr); } @@ -1846,7 +1846,7 @@ namespace { CallLocalDtor(const CXXDestructorDecl *D, llvm::Value *Addr) : Dtor(D), Addr(Addr) {} - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { CGF.EmitCXXDestructorCall(Dtor, Dtor_Complete, /*ForVirtualBase=*/false, /*Delegating=*/false, Addr); diff --git a/lib/CodeGen/CGDecl.cpp b/lib/CodeGen/CGDecl.cpp index 46de0e50b3..d0380a025d 100644 --- a/lib/CodeGen/CGDecl.cpp +++ b/lib/CodeGen/CGDecl.cpp @@ -365,7 +365,7 @@ namespace { CodeGenFunction::Destroyer *destroyer; bool useEHCleanupForArray; - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { // Don't use an EH cleanup recursively from an EH cleanup. bool useEHCleanupForArray = flags.isForNormalCleanup() && this->useEHCleanupForArray; @@ -384,7 +384,7 @@ namespace { llvm::Value *NRVOFlag; llvm::Value *Loc; - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { // Along the exceptions path we always execute the dtor. bool NRVO = flags.isForNormalCleanup() && NRVOFlag; @@ -410,7 +410,7 @@ namespace { struct CallStackRestore : EHScopeStack::Cleanup { llvm::Value *Stack; CallStackRestore(llvm::Value *Stack) : Stack(Stack) {} - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { llvm::Value *V = CGF.Builder.CreateLoad(Stack); llvm::Value *F = CGF.CGM.getIntrinsic(llvm::Intrinsic::stackrestore); CGF.Builder.CreateCall(F, V); @@ -421,7 +421,7 @@ namespace { const VarDecl &Var; ExtendGCLifetime(const VarDecl *var) : Var(*var) {} - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { // Compute the address of the local variable, in case it's a // byref or something. DeclRefExpr DRE(const_cast(&Var), false, @@ -441,7 +441,7 @@ namespace { const VarDecl *Var) : CleanupFn(CleanupFn), FnInfo(*Info), Var(*Var) {} - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { DeclRefExpr DRE(const_cast(&Var), false, Var.getType(), VK_LValue, SourceLocation()); // Compute the address of the local variable, in case it's a byref @@ -473,7 +473,7 @@ namespace { CallLifetimeEnd(llvm::Value *addr, llvm::Value *size) : Addr(addr), Size(size) {} - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { llvm::Value *castAddr = CGF.Builder.CreateBitCast(Addr, CGF.Int8PtrTy); CGF.Builder.CreateCall2(CGF.CGM.getLLVMLifetimeEndFn(), Size, castAddr) @@ -1509,7 +1509,7 @@ namespace { : ArrayBegin(arrayBegin), ArrayEnd(arrayEnd), ElementType(elementType), Destroyer(destroyer) {} - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { emitPartialArrayDestroy(CGF, ArrayBegin, ArrayEnd, ElementType, Destroyer); } @@ -1531,7 +1531,7 @@ namespace { : ArrayBegin(arrayBegin), ArrayEndPointer(arrayEndPointer), ElementType(elementType), Destroyer(destroyer) {} - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { llvm::Value *arrayEnd = CGF.Builder.CreateLoad(ArrayEndPointer); emitPartialArrayDestroy(CGF, ArrayBegin, arrayEnd, ElementType, Destroyer); @@ -1598,7 +1598,7 @@ namespace { llvm::Value *Param; ARCPreciseLifetime_t Precise; - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { CGF.EmitARCRelease(Param, Precise); } }; diff --git a/lib/CodeGen/CGException.cpp b/lib/CodeGen/CGException.cpp index 607566ca23..ca31717403 100644 --- a/lib/CodeGen/CGException.cpp +++ b/lib/CodeGen/CGException.cpp @@ -360,7 +360,7 @@ namespace { struct FreeException : EHScopeStack::Cleanup { llvm::Value *exn; FreeException(llvm::Value *exn) : exn(exn) {} - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { CGF.EmitNounwindRuntimeCall(getFreeExceptionFn(CGF.CGM), exn); } }; @@ -908,7 +908,7 @@ namespace { CallEndCatch(bool MightThrow) : MightThrow(MightThrow) {} bool MightThrow; - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { if (!MightThrow) { CGF.EmitNounwindRuntimeCall(getEndCatchFn(CGF.CGM)); return; @@ -1330,7 +1330,7 @@ namespace { CallEndCatchForFinally(llvm::Value *ForEHVar, llvm::Value *EndCatchFn) : ForEHVar(ForEHVar), EndCatchFn(EndCatchFn) {} - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { llvm::BasicBlock *EndCatchBB = CGF.createBasicBlock("finally.endcatch"); llvm::BasicBlock *CleanupContBB = CGF.createBasicBlock("finally.cleanup.cont"); @@ -1357,7 +1357,7 @@ namespace { : Body(Body), ForEHVar(ForEHVar), EndCatchFn(EndCatchFn), RethrowFn(RethrowFn), SavedExnVar(SavedExnVar) {} - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { // Enter a cleanup to call the end-catch function if one was provided. if (EndCatchFn) CGF.EHStack.pushCleanup(NormalAndEHCleanup, diff --git a/lib/CodeGen/CGExprCXX.cpp b/lib/CodeGen/CGExprCXX.cpp index d630bad67b..c4e5e1be2e 100644 --- a/lib/CodeGen/CGExprCXX.cpp +++ b/lib/CodeGen/CGExprCXX.cpp @@ -1011,7 +1011,7 @@ namespace { getPlacementArgs()[I] = Arg; } - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { const FunctionProtoType *FPT = OperatorDelete->getType()->getAs(); assert(FPT->getNumParams() == NumPlacementArgs + 1 || @@ -1066,7 +1066,7 @@ namespace { getPlacementArgs()[I] = Arg; } - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { const FunctionProtoType *FPT = OperatorDelete->getType()->getAs(); assert(FPT->getNumParams() == NumPlacementArgs + 1 || @@ -1316,7 +1316,7 @@ namespace { QualType ElementType) : Ptr(Ptr), OperatorDelete(OperatorDelete), ElementType(ElementType) {} - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { CGF.EmitDeleteCall(OperatorDelete, Ptr, ElementType); } }; @@ -1419,7 +1419,7 @@ namespace { : Ptr(Ptr), OperatorDelete(OperatorDelete), NumElements(NumElements), ElementType(ElementType), CookieSize(CookieSize) {} - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { const FunctionProtoType *DeleteFTy = OperatorDelete->getType()->getAs(); assert(DeleteFTy->getNumParams() == 1 || DeleteFTy->getNumParams() == 2); diff --git a/lib/CodeGen/CGObjC.cpp b/lib/CodeGen/CGObjC.cpp index 06d15b6af7..5cc2ff3173 100644 --- a/lib/CodeGen/CGObjC.cpp +++ b/lib/CodeGen/CGObjC.cpp @@ -431,7 +431,7 @@ RValue CodeGenFunction::EmitObjCMessageExpr(const ObjCMessageExpr *E, namespace { struct FinishARCDealloc : EHScopeStack::Cleanup { - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { const ObjCMethodDecl *method = cast(CGF.CurCodeDecl); const ObjCImplDecl *impl = cast(method->getDeclContext()); @@ -1298,7 +1298,7 @@ namespace { : addr(addr), ivar(ivar), destroyer(destroyer), useEHCleanupForArray(useEHCleanupForArray) {} - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { LValue lvalue = CGF.EmitLValueForIvar(CGF.TypeOfSelfObject(), addr, ivar, /*CVR*/ 0); CGF.emitDestroy(lvalue.getAddress(), ivar->getType(), destroyer, @@ -1727,7 +1727,7 @@ namespace { CallObjCRelease(llvm::Value *object) : object(object) {} llvm::Value *object; - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { // Releases at the end of the full-expression are imprecise. CGF.EmitARCRelease(object, ARCImpreciseLifetime); } @@ -2336,7 +2336,7 @@ namespace { CallObjCAutoreleasePoolObject(llvm::Value *token) : Token(token) {} - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { CGF.EmitObjCAutoreleasePoolPop(Token); } }; @@ -2345,7 +2345,7 @@ namespace { CallObjCMRRAutoreleasePoolObject(llvm::Value *token) : Token(token) {} - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { CGF.EmitObjCMRRAutoreleasePoolPop(Token); } }; diff --git a/lib/CodeGen/CGObjCGNU.cpp b/lib/CodeGen/CGObjCGNU.cpp index fc89911290..66c55c4d7e 100644 --- a/lib/CodeGen/CGObjCGNU.cpp +++ b/lib/CodeGen/CGObjCGNU.cpp @@ -479,98 +479,86 @@ public: CGObjCGNU(CodeGenModule &cgm, unsigned runtimeABIVersion, unsigned protocolClassVersion); - virtual llvm::Constant *GenerateConstantString(const StringLiteral *); - - virtual RValue - GenerateMessageSend(CodeGenFunction &CGF, - ReturnValueSlot Return, - QualType ResultType, - Selector Sel, - llvm::Value *Receiver, - const CallArgList &CallArgs, + llvm::Constant *GenerateConstantString(const StringLiteral *) override; + + RValue + GenerateMessageSend(CodeGenFunction &CGF, ReturnValueSlot Return, + QualType ResultType, Selector Sel, + llvm::Value *Receiver, const CallArgList &CallArgs, const ObjCInterfaceDecl *Class, - const ObjCMethodDecl *Method); - virtual RValue - GenerateMessageSendSuper(CodeGenFunction &CGF, - ReturnValueSlot Return, - QualType ResultType, - Selector Sel, + const ObjCMethodDecl *Method) override; + RValue + GenerateMessageSendSuper(CodeGenFunction &CGF, ReturnValueSlot Return, + QualType ResultType, Selector Sel, const ObjCInterfaceDecl *Class, - bool isCategoryImpl, - llvm::Value *Receiver, - bool IsClassMessage, - const CallArgList &CallArgs, - const ObjCMethodDecl *Method); - virtual llvm::Value *GetClass(CodeGenFunction &CGF, - const ObjCInterfaceDecl *OID); - virtual llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel, - bool lval = false); - virtual llvm::Value *GetSelector(CodeGenFunction &CGF, const ObjCMethodDecl - *Method); - virtual llvm::Constant *GetEHType(QualType T); - - virtual llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD, - const ObjCContainerDecl *CD); - virtual void GenerateCategory(const ObjCCategoryImplDecl *CMD); - virtual void GenerateClass(const ObjCImplementationDecl *ClassDecl); - virtual void RegisterAlias(const ObjCCompatibleAliasDecl *OAD); - virtual llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF, - const ObjCProtocolDecl *PD); - virtual void GenerateProtocol(const ObjCProtocolDecl *PD); - virtual llvm::Function *ModuleInitFunction(); - virtual llvm::Constant *GetPropertyGetFunction(); - virtual llvm::Constant *GetPropertySetFunction(); - virtual llvm::Constant *GetOptimizedPropertySetFunction(bool atomic, - bool copy); - virtual llvm::Constant *GetSetStructFunction(); - virtual llvm::Constant *GetGetStructFunction(); - virtual llvm::Constant *GetCppAtomicObjectGetFunction(); - virtual llvm::Constant *GetCppAtomicObjectSetFunction(); - virtual llvm::Constant *EnumerationMutationFunction(); - - virtual void EmitTryStmt(CodeGenFunction &CGF, - const ObjCAtTryStmt &S); - virtual void EmitSynchronizedStmt(CodeGenFunction &CGF, - const ObjCAtSynchronizedStmt &S); - virtual void EmitThrowStmt(CodeGenFunction &CGF, - const ObjCAtThrowStmt &S, - bool ClearInsertionPoint=true); - virtual llvm::Value * EmitObjCWeakRead(CodeGenFunction &CGF, - llvm::Value *AddrWeakObj); - virtual void EmitObjCWeakAssign(CodeGenFunction &CGF, - llvm::Value *src, llvm::Value *dst); - virtual void EmitObjCGlobalAssign(CodeGenFunction &CGF, - llvm::Value *src, llvm::Value *dest, - bool threadlocal=false); - virtual void EmitObjCIvarAssign(CodeGenFunction &CGF, - llvm::Value *src, llvm::Value *dest, - llvm::Value *ivarOffset); - virtual void EmitObjCStrongCastAssign(CodeGenFunction &CGF, - llvm::Value *src, llvm::Value *dest); - virtual void EmitGCMemmoveCollectable(CodeGenFunction &CGF, - llvm::Value *DestPtr, - llvm::Value *SrcPtr, - llvm::Value *Size); - virtual LValue EmitObjCValueForIvar(CodeGenFunction &CGF, - QualType ObjectTy, - llvm::Value *BaseValue, - const ObjCIvarDecl *Ivar, - unsigned CVRQualifiers); - virtual llvm::Value *EmitIvarOffset(CodeGenFunction &CGF, - const ObjCInterfaceDecl *Interface, - const ObjCIvarDecl *Ivar); - virtual llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF); - virtual llvm::Constant *BuildGCBlockLayout(CodeGenModule &CGM, - const CGBlockInfo &blockInfo) { + bool isCategoryImpl, llvm::Value *Receiver, + bool IsClassMessage, const CallArgList &CallArgs, + const ObjCMethodDecl *Method) override; + llvm::Value *GetClass(CodeGenFunction &CGF, + const ObjCInterfaceDecl *OID) override; + llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel, + bool lval = false) override; + llvm::Value *GetSelector(CodeGenFunction &CGF, + const ObjCMethodDecl *Method) override; + llvm::Constant *GetEHType(QualType T) override; + + llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD, + const ObjCContainerDecl *CD) override; + void GenerateCategory(const ObjCCategoryImplDecl *CMD) override; + void GenerateClass(const ObjCImplementationDecl *ClassDecl) override; + void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override; + llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF, + const ObjCProtocolDecl *PD) override; + void GenerateProtocol(const ObjCProtocolDecl *PD) override; + llvm::Function *ModuleInitFunction() override; + llvm::Constant *GetPropertyGetFunction() override; + llvm::Constant *GetPropertySetFunction() override; + llvm::Constant *GetOptimizedPropertySetFunction(bool atomic, + bool copy) override; + llvm::Constant *GetSetStructFunction() override; + llvm::Constant *GetGetStructFunction() override; + llvm::Constant *GetCppAtomicObjectGetFunction() override; + llvm::Constant *GetCppAtomicObjectSetFunction() override; + llvm::Constant *EnumerationMutationFunction() override; + + void EmitTryStmt(CodeGenFunction &CGF, + const ObjCAtTryStmt &S) override; + void EmitSynchronizedStmt(CodeGenFunction &CGF, + const ObjCAtSynchronizedStmt &S) override; + void EmitThrowStmt(CodeGenFunction &CGF, + const ObjCAtThrowStmt &S, + bool ClearInsertionPoint=true) override; + llvm::Value * EmitObjCWeakRead(CodeGenFunction &CGF, + llvm::Value *AddrWeakObj) override; + void EmitObjCWeakAssign(CodeGenFunction &CGF, + llvm::Value *src, llvm::Value *dst) override; + void EmitObjCGlobalAssign(CodeGenFunction &CGF, + llvm::Value *src, llvm::Value *dest, + bool threadlocal=false) override; + void EmitObjCIvarAssign(CodeGenFunction &CGF, llvm::Value *src, + llvm::Value *dest, llvm::Value *ivarOffset) override; + void EmitObjCStrongCastAssign(CodeGenFunction &CGF, + llvm::Value *src, llvm::Value *dest) override; + void EmitGCMemmoveCollectable(CodeGenFunction &CGF, llvm::Value *DestPtr, + llvm::Value *SrcPtr, + llvm::Value *Size) override; + LValue EmitObjCValueForIvar(CodeGenFunction &CGF, QualType ObjectTy, + llvm::Value *BaseValue, const ObjCIvarDecl *Ivar, + unsigned CVRQualifiers) override; + llvm::Value *EmitIvarOffset(CodeGenFunction &CGF, + const ObjCInterfaceDecl *Interface, + const ObjCIvarDecl *Ivar) override; + llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override; + llvm::Constant *BuildGCBlockLayout(CodeGenModule &CGM, + const CGBlockInfo &blockInfo) override { return NULLPtr; } - virtual llvm::Constant *BuildRCBlockLayout(CodeGenModule &CGM, - const CGBlockInfo &blockInfo) { + llvm::Constant *BuildRCBlockLayout(CodeGenModule &CGM, + const CGBlockInfo &blockInfo) override { return NULLPtr; } - - virtual llvm::Constant *BuildByrefLayout(CodeGenModule &CGM, - QualType T) { + + llvm::Constant *BuildByrefLayout(CodeGenModule &CGM, QualType T) override { return NULLPtr; } @@ -596,11 +584,9 @@ class CGObjCGCC : public CGObjCGNU { /// arguments. Returns the IMP for the corresponding method. LazyRuntimeFunction MsgLookupSuperFn; protected: - virtual llvm::Value *LookupIMP(CodeGenFunction &CGF, - llvm::Value *&Receiver, - llvm::Value *cmd, - llvm::MDNode *node, - MessageSendInfo &MSI) { + llvm::Value *LookupIMP(CodeGenFunction &CGF, llvm::Value *&Receiver, + llvm::Value *cmd, llvm::MDNode *node, + MessageSendInfo &MSI) override { CGBuilderTy &Builder = CGF.Builder; llvm::Value *args[] = { EnforceType(Builder, Receiver, IdTy), @@ -609,10 +595,8 @@ protected: imp->setMetadata(msgSendMDKind, node); return imp.getInstruction(); } - virtual llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, - llvm::Value *ObjCSuper, - llvm::Value *cmd, - MessageSendInfo &MSI) { + llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, llvm::Value *ObjCSuper, + llvm::Value *cmd, MessageSendInfo &MSI) override { CGBuilderTy &Builder = CGF.Builder; llvm::Value *lookupArgs[] = {EnforceType(Builder, ObjCSuper, PtrToObjCSuperTy), cmd}; @@ -655,13 +639,11 @@ class CGObjCGNUstep : public CGObjCGNU { /// lookup functions. llvm::Type *SlotTy; public: - virtual llvm::Constant *GetEHType(QualType T); + llvm::Constant *GetEHType(QualType T) override; protected: - virtual llvm::Value *LookupIMP(CodeGenFunction &CGF, - llvm::Value *&Receiver, - llvm::Value *cmd, - llvm::MDNode *node, - MessageSendInfo &MSI) { + llvm::Value *LookupIMP(CodeGenFunction &CGF, llvm::Value *&Receiver, + llvm::Value *cmd, llvm::MDNode *node, + MessageSendInfo &MSI) override { CGBuilderTy &Builder = CGF.Builder; llvm::Function *LookupFn = SlotLookupFn; @@ -697,10 +679,9 @@ class CGObjCGNUstep : public CGObjCGNU { Receiver = Builder.CreateLoad(ReceiverPtr, true); return imp; } - virtual llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, - llvm::Value *ObjCSuper, - llvm::Value *cmd, - MessageSendInfo &MSI) { + llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, llvm::Value *ObjCSuper, + llvm::Value *cmd, + MessageSendInfo &MSI) override { CGBuilderTy &Builder = CGF.Builder; llvm::Value *lookupArgs[] = {ObjCSuper, cmd}; @@ -761,22 +742,22 @@ class CGObjCGNUstep : public CGObjCGNU { CxxAtomicObjectGetFn.init(&CGM, "objc_getCppObjectAtomic", VoidTy, PtrTy, PtrTy, PtrTy, NULL); } - virtual llvm::Constant *GetCppAtomicObjectGetFunction() { + llvm::Constant *GetCppAtomicObjectGetFunction() override { // The optimised functions were added in version 1.7 of the GNUstep // runtime. assert (CGM.getLangOpts().ObjCRuntime.getVersion() >= VersionTuple(1, 7)); return CxxAtomicObjectGetFn; } - virtual llvm::Constant *GetCppAtomicObjectSetFunction() { + llvm::Constant *GetCppAtomicObjectSetFunction() override { // The optimised functions were added in version 1.7 of the GNUstep // runtime. assert (CGM.getLangOpts().ObjCRuntime.getVersion() >= VersionTuple(1, 7)); return CxxAtomicObjectSetFn; } - virtual llvm::Constant *GetOptimizedPropertySetFunction(bool atomic, - bool copy) { + llvm::Constant *GetOptimizedPropertySetFunction(bool atomic, + bool copy) override { // The optimised property functions omit the GC check, and so are not // safe to use in GC mode. The standard functions are fast in GC mode, // so there is less advantage in using them. @@ -809,11 +790,9 @@ protected: /// arguments. Returns the IMP for the corresponding method. LazyRuntimeFunction MsgLookupSuperFn, MsgLookupSuperFnSRet; - virtual llvm::Value *LookupIMP(CodeGenFunction &CGF, - llvm::Value *&Receiver, - llvm::Value *cmd, - llvm::MDNode *node, - MessageSendInfo &MSI) { + llvm::Value *LookupIMP(CodeGenFunction &CGF, llvm::Value *&Receiver, + llvm::Value *cmd, llvm::MDNode *node, + MessageSendInfo &MSI) override { CGBuilderTy &Builder = CGF.Builder; llvm::Value *args[] = { EnforceType(Builder, Receiver, IdTy), @@ -829,10 +808,8 @@ protected: return imp.getInstruction(); } - virtual llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, - llvm::Value *ObjCSuper, - llvm::Value *cmd, - MessageSendInfo &MSI) { + llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, llvm::Value *ObjCSuper, + llvm::Value *cmd, MessageSendInfo &MSI) override { CGBuilderTy &Builder = CGF.Builder; llvm::Value *lookupArgs[] = {EnforceType(Builder, ObjCSuper, PtrToObjCSuperTy), cmd}; @@ -843,8 +820,8 @@ protected: return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFn, lookupArgs); } - virtual llvm::Value *GetClassNamed(CodeGenFunction &CGF, - const std::string &Name, bool isWeak) { + llvm::Value *GetClassNamed(CodeGenFunction &CGF, + const std::string &Name, bool isWeak) override { if (isWeak) return CGObjCGNU::GetClassNamed(CGF, Name, isWeak); diff --git a/lib/CodeGen/CGObjCMac.cpp b/lib/CodeGen/CGObjCMac.cpp index 80a0324d0c..6e2a044993 100644 --- a/lib/CodeGen/CGObjCMac.cpp +++ b/lib/CodeGen/CGObjCMac.cpp @@ -1046,12 +1046,12 @@ public: CGObjCCommonMac(CodeGen::CodeGenModule &cgm) : CGObjCRuntime(cgm), VMContext(cgm.getLLVMContext()) { } - virtual llvm::Constant *GenerateConstantString(const StringLiteral *SL); - - virtual llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD, - const ObjCContainerDecl *CD=0); + llvm::Constant *GenerateConstantString(const StringLiteral *SL) override; + + llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD, + const ObjCContainerDecl *CD=0) override; - virtual void GenerateProtocol(const ObjCProtocolDecl *PD); + void GenerateProtocol(const ObjCProtocolDecl *PD) override; /// GetOrEmitProtocol - Get the protocol object for the given /// declaration, emitting it if necessary. The return value has type @@ -1063,13 +1063,13 @@ public: /// forward references will be filled in with empty bodies if no /// definition is seen. The return value has type ProtocolPtrTy. virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD)=0; - virtual llvm::Constant *BuildGCBlockLayout(CodeGen::CodeGenModule &CGM, - const CGBlockInfo &blockInfo); - virtual llvm::Constant *BuildRCBlockLayout(CodeGen::CodeGenModule &CGM, - const CGBlockInfo &blockInfo); - - virtual llvm::Constant *BuildByrefLayout(CodeGen::CodeGenModule &CGM, - QualType T); + llvm::Constant *BuildGCBlockLayout(CodeGen::CodeGenModule &CGM, + const CGBlockInfo &blockInfo) override; + llvm::Constant *BuildRCBlockLayout(CodeGen::CodeGenModule &CGM, + const CGBlockInfo &blockInfo) override; + + llvm::Constant *BuildByrefLayout(CodeGen::CodeGenModule &CGM, + QualType T) override; }; class CGObjCMac : public CGObjCCommonMac { @@ -1100,9 +1100,9 @@ private: llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF, IdentifierInfo *II); - - llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF); - + + llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override; + /// EmitSuperClassRef - Emits reference to class's main metadata class. llvm::Value *EmitSuperClassRef(const ObjCInterfaceDecl *ID); @@ -1153,13 +1153,13 @@ private: /// GetOrEmitProtocol - Get the protocol object for the given /// declaration, emitting it if necessary. The return value has type /// ProtocolPtrTy. - virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD); + llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override; /// GetOrEmitProtocolRef - Get a forward reference to the protocol /// object for the given declaration, emitting it if needed. These /// forward references will be filled in with empty bodies if no /// definition is seen. The return value has type ProtocolPtrTy. - virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD); + llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override; /// EmitProtocolExtension - Generate the protocol extension /// structure used to store optional instance and class methods, and @@ -1185,94 +1185,86 @@ private: public: CGObjCMac(CodeGen::CodeGenModule &cgm); - virtual llvm::Function *ModuleInitFunction(); + llvm::Function *ModuleInitFunction() override; - virtual CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF, - ReturnValueSlot Return, - QualType ResultType, - Selector Sel, - llvm::Value *Receiver, - const CallArgList &CallArgs, - const ObjCInterfaceDecl *Class, - const ObjCMethodDecl *Method); + CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF, + ReturnValueSlot Return, + QualType ResultType, + Selector Sel, llvm::Value *Receiver, + const CallArgList &CallArgs, + const ObjCInterfaceDecl *Class, + const ObjCMethodDecl *Method) override; - virtual CodeGen::RValue + CodeGen::RValue GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF, - ReturnValueSlot Return, - QualType ResultType, - Selector Sel, - const ObjCInterfaceDecl *Class, - bool isCategoryImpl, - llvm::Value *Receiver, - bool IsClassMessage, - const CallArgList &CallArgs, - const ObjCMethodDecl *Method); - - virtual llvm::Value *GetClass(CodeGenFunction &CGF, - const ObjCInterfaceDecl *ID); + ReturnValueSlot Return, QualType ResultType, + Selector Sel, const ObjCInterfaceDecl *Class, + bool isCategoryImpl, llvm::Value *Receiver, + bool IsClassMessage, const CallArgList &CallArgs, + const ObjCMethodDecl *Method) override; - virtual llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel, - bool lval = false); + llvm::Value *GetClass(CodeGenFunction &CGF, + const ObjCInterfaceDecl *ID) override; + + llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel, + bool lval = false) override; /// The NeXT/Apple runtimes do not support typed selectors; just emit an /// untyped one. - virtual llvm::Value *GetSelector(CodeGenFunction &CGF, - const ObjCMethodDecl *Method); + llvm::Value *GetSelector(CodeGenFunction &CGF, + const ObjCMethodDecl *Method) override; - virtual llvm::Constant *GetEHType(QualType T); + llvm::Constant *GetEHType(QualType T) override; - virtual void GenerateCategory(const ObjCCategoryImplDecl *CMD); + void GenerateCategory(const ObjCCategoryImplDecl *CMD) override; - virtual void GenerateClass(const ObjCImplementationDecl *ClassDecl); + void GenerateClass(const ObjCImplementationDecl *ClassDecl) override; - virtual void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) {} + void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {} - virtual llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF, - const ObjCProtocolDecl *PD); + llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF, + const ObjCProtocolDecl *PD) override; - virtual llvm::Constant *GetPropertyGetFunction(); - virtual llvm::Constant *GetPropertySetFunction(); - virtual llvm::Constant *GetOptimizedPropertySetFunction(bool atomic, - bool copy); - virtual llvm::Constant *GetGetStructFunction(); - virtual llvm::Constant *GetSetStructFunction(); - virtual llvm::Constant *GetCppAtomicObjectGetFunction(); - virtual llvm::Constant *GetCppAtomicObjectSetFunction(); - virtual llvm::Constant *EnumerationMutationFunction(); + llvm::Constant *GetPropertyGetFunction() override; + llvm::Constant *GetPropertySetFunction() override; + llvm::Constant *GetOptimizedPropertySetFunction(bool atomic, + bool copy) override; + llvm::Constant *GetGetStructFunction() override; + llvm::Constant *GetSetStructFunction() override; + llvm::Constant *GetCppAtomicObjectGetFunction() override; + llvm::Constant *GetCppAtomicObjectSetFunction() override; + llvm::Constant *EnumerationMutationFunction() override; - virtual void EmitTryStmt(CodeGen::CodeGenFunction &CGF, - const ObjCAtTryStmt &S); - virtual void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF, - const ObjCAtSynchronizedStmt &S); + void EmitTryStmt(CodeGen::CodeGenFunction &CGF, + const ObjCAtTryStmt &S) override; + void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF, + const ObjCAtSynchronizedStmt &S) override; void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, const Stmt &S); - virtual void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, - const ObjCAtThrowStmt &S, - bool ClearInsertionPoint=true); - virtual llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF, - llvm::Value *AddrWeakObj); - virtual void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, - llvm::Value *src, llvm::Value *dst); - virtual void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, - llvm::Value *src, llvm::Value *dest, - bool threadlocal = false); - virtual void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, - llvm::Value *src, llvm::Value *dest, - llvm::Value *ivarOffset); - virtual void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF, - llvm::Value *src, llvm::Value *dest); - virtual void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF, - llvm::Value *dest, llvm::Value *src, - llvm::Value *size); - - virtual LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, - QualType ObjectTy, - llvm::Value *BaseValue, - const ObjCIvarDecl *Ivar, - unsigned CVRQualifiers); - virtual llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF, - const ObjCInterfaceDecl *Interface, - const ObjCIvarDecl *Ivar); - + void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S, + bool ClearInsertionPoint=true) override; + llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF, + llvm::Value *AddrWeakObj) override; + void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, + llvm::Value *src, llvm::Value *dst) override; + void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, + llvm::Value *src, llvm::Value *dest, + bool threadlocal = false) override; + void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, + llvm::Value *src, llvm::Value *dest, + llvm::Value *ivarOffset) override; + void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF, + llvm::Value *src, llvm::Value *dest) override; + void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF, + llvm::Value *dest, llvm::Value *src, + llvm::Value *size) override; + + LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy, + llvm::Value *BaseValue, const ObjCIvarDecl *Ivar, + unsigned CVRQualifiers) override; + llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF, + const ObjCInterfaceDecl *Interface, + const ObjCIvarDecl *Ivar) override; + /// GetClassGlobal - Return the global variable for the Objective-C /// class of the given name. llvm::GlobalVariable *GetClassGlobal(const std::string &Name, @@ -1351,13 +1343,13 @@ private: /// GetOrEmitProtocol - Get the protocol object for the given /// declaration, emitting it if necessary. The return value has type /// ProtocolPtrTy. - virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD); + llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override; /// GetOrEmitProtocolRef - Get a forward reference to the protocol /// object for the given declaration, emitting it if needed. These /// forward references will be filled in with empty bodies if no /// definition is seen. The return value has type ProtocolPtrTy. - virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD); + llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override; /// EmitProtocolList - Generate the list of referenced /// protocols. The return value has type ProtocolListPtrTy. @@ -1387,8 +1379,8 @@ private: llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF, IdentifierInfo *II, bool Weak); - - llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF); + + llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override; /// EmitSuperClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy, /// for the given super class reference. @@ -1467,112 +1459,104 @@ private: public: CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm); // FIXME. All stubs for now! - virtual llvm::Function *ModuleInitFunction(); - - virtual CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF, - ReturnValueSlot Return, - QualType ResultType, - Selector Sel, - llvm::Value *Receiver, - const CallArgList &CallArgs, - const ObjCInterfaceDecl *Class, - const ObjCMethodDecl *Method); - - virtual CodeGen::RValue + llvm::Function *ModuleInitFunction() override; + + CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF, + ReturnValueSlot Return, + QualType ResultType, Selector Sel, + llvm::Value *Receiver, + const CallArgList &CallArgs, + const ObjCInterfaceDecl *Class, + const ObjCMethodDecl *Method) override; + + CodeGen::RValue GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF, - ReturnValueSlot Return, - QualType ResultType, - Selector Sel, - const ObjCInterfaceDecl *Class, - bool isCategoryImpl, - llvm::Value *Receiver, - bool IsClassMessage, - const CallArgList &CallArgs, - const ObjCMethodDecl *Method); - - virtual llvm::Value *GetClass(CodeGenFunction &CGF, - const ObjCInterfaceDecl *ID); + ReturnValueSlot Return, QualType ResultType, + Selector Sel, const ObjCInterfaceDecl *Class, + bool isCategoryImpl, llvm::Value *Receiver, + bool IsClassMessage, const CallArgList &CallArgs, + const ObjCMethodDecl *Method) override; + + llvm::Value *GetClass(CodeGenFunction &CGF, + const ObjCInterfaceDecl *ID) override; - virtual llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel, - bool lvalue = false) + llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel, + bool lvalue = false) override { return EmitSelector(CGF, Sel, lvalue); } /// The NeXT/Apple runtimes do not support typed selectors; just emit an /// untyped one. - virtual llvm::Value *GetSelector(CodeGenFunction &CGF, - const ObjCMethodDecl *Method) + llvm::Value *GetSelector(CodeGenFunction &CGF, + const ObjCMethodDecl *Method) override { return EmitSelector(CGF, Method->getSelector()); } - virtual void GenerateCategory(const ObjCCategoryImplDecl *CMD); + void GenerateCategory(const ObjCCategoryImplDecl *CMD) override; - virtual void GenerateClass(const ObjCImplementationDecl *ClassDecl); + void GenerateClass(const ObjCImplementationDecl *ClassDecl) override; - virtual void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) {} + void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {} - virtual llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF, - const ObjCProtocolDecl *PD); + llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF, + const ObjCProtocolDecl *PD) override; - virtual llvm::Constant *GetEHType(QualType T); + llvm::Constant *GetEHType(QualType T) override; - virtual llvm::Constant *GetPropertyGetFunction() { + llvm::Constant *GetPropertyGetFunction() override { return ObjCTypes.getGetPropertyFn(); } - virtual llvm::Constant *GetPropertySetFunction() { + llvm::Constant *GetPropertySetFunction() override { return ObjCTypes.getSetPropertyFn(); } - - virtual llvm::Constant *GetOptimizedPropertySetFunction(bool atomic, - bool copy) { + + llvm::Constant *GetOptimizedPropertySetFunction(bool atomic, + bool copy) override { return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy); } - - virtual llvm::Constant *GetSetStructFunction() { + + llvm::Constant *GetSetStructFunction() override { return ObjCTypes.getCopyStructFn(); } - virtual llvm::Constant *GetGetStructFunction() { + llvm::Constant *GetGetStructFunction() override { return ObjCTypes.getCopyStructFn(); } - virtual llvm::Constant *GetCppAtomicObjectSetFunction() { + llvm::Constant *GetCppAtomicObjectSetFunction() override { return ObjCTypes.getCppAtomicObjectFunction(); } - virtual llvm::Constant *GetCppAtomicObjectGetFunction() { + llvm::Constant *GetCppAtomicObjectGetFunction() override { return ObjCTypes.getCppAtomicObjectFunction(); } - - virtual llvm::Constant *EnumerationMutationFunction() { + + llvm::Constant *EnumerationMutationFunction() override { return ObjCTypes.getEnumerationMutationFn(); } - virtual void EmitTryStmt(CodeGen::CodeGenFunction &CGF, - const ObjCAtTryStmt &S); - virtual void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF, - const ObjCAtSynchronizedStmt &S); - virtual void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, - const ObjCAtThrowStmt &S, - bool ClearInsertionPoint=true); - virtual llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF, - llvm::Value *AddrWeakObj); - virtual void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, - llvm::Value *src, llvm::Value *dst); - virtual void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, - llvm::Value *src, llvm::Value *dest, - bool threadlocal = false); - virtual void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, - llvm::Value *src, llvm::Value *dest, - llvm::Value *ivarOffset); - virtual void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF, - llvm::Value *src, llvm::Value *dest); - virtual void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF, - llvm::Value *dest, llvm::Value *src, - llvm::Value *size); - virtual LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, - QualType ObjectTy, - llvm::Value *BaseValue, - const ObjCIvarDecl *Ivar, - unsigned CVRQualifiers); - virtual llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF, - const ObjCInterfaceDecl *Interface, - const ObjCIvarDecl *Ivar); + void EmitTryStmt(CodeGen::CodeGenFunction &CGF, + const ObjCAtTryStmt &S) override; + void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF, + const ObjCAtSynchronizedStmt &S) override; + void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S, + bool ClearInsertionPoint=true) override; + llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF, + llvm::Value *AddrWeakObj) override; + void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, + llvm::Value *src, llvm::Value *dst) override; + void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, + llvm::Value *src, llvm::Value *dest, + bool threadlocal = false) override; + void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, + llvm::Value *src, llvm::Value *dest, + llvm::Value *ivarOffset) override; + void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF, + llvm::Value *src, llvm::Value *dest) override; + void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF, + llvm::Value *dest, llvm::Value *src, + llvm::Value *size) override; + LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy, + llvm::Value *BaseValue, const ObjCIvarDecl *Ivar, + unsigned CVRQualifiers) override; + llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF, + const ObjCInterfaceDecl *Interface, + const ObjCIvarDecl *Ivar) override; }; /// A helper class for performing the null-initialization of a return @@ -3510,7 +3494,7 @@ namespace { : S(*S), SyncArgSlot(SyncArgSlot), CallTryExitVar(CallTryExitVar), ExceptionData(ExceptionData), ObjCTypes(*ObjCTypes) {} - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { // Check whether we need to call objc_exception_try_exit. // In optimized code, this branch will always be folded. llvm::BasicBlock *FinallyCallExit = diff --git a/lib/CodeGen/CGObjCRuntime.cpp b/lib/CodeGen/CGObjCRuntime.cpp index 669b1d0689..8d6c653015 100644 --- a/lib/CodeGen/CGObjCRuntime.cpp +++ b/lib/CodeGen/CGObjCRuntime.cpp @@ -158,7 +158,7 @@ namespace { bool MightThrow; llvm::Value *Fn; - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { if (!MightThrow) { CGF.Builder.CreateCall(Fn)->setDoesNotThrow(); return; @@ -303,7 +303,7 @@ namespace { CallSyncExit(llvm::Value *SyncExitFn, llvm::Value *SyncArg) : SyncExitFn(SyncExitFn), SyncArg(SyncArg) {} - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { CGF.Builder.CreateCall(SyncExitFn, SyncArg)->setDoesNotThrow(); } }; diff --git a/lib/CodeGen/CodeGenAction.cpp b/lib/CodeGen/CodeGenAction.cpp index 383f272732..573f8e98e7 100644 --- a/lib/CodeGen/CodeGenAction.cpp +++ b/lib/CodeGen/CodeGenAction.cpp @@ -69,11 +69,11 @@ namespace clang { llvm::Module *takeModule() { return TheModule.release(); } llvm::Module *takeLinkModule() { return LinkModule.release(); } - virtual void HandleCXXStaticMemberVarInstantiation(VarDecl *VD) { + void HandleCXXStaticMemberVarInstantiation(VarDecl *VD) override { Gen->HandleCXXStaticMemberVarInstantiation(VD); } - virtual void Initialize(ASTContext &Ctx) { + void Initialize(ASTContext &Ctx) override { Context = &Ctx; if (llvm::TimePassesIsEnabled) @@ -87,7 +87,7 @@ namespace clang { LLVMIRGeneration.stopTimer(); } - virtual bool HandleTopLevelDecl(DeclGroupRef D) { + bool HandleTopLevelDecl(DeclGroupRef D) override { PrettyStackTraceDecl CrashInfo(*D.begin(), SourceLocation(), Context->getSourceManager(), "LLVM IR generation of declaration"); @@ -103,7 +103,7 @@ namespace clang { return true; } - virtual void HandleTranslationUnit(ASTContext &C) { + void HandleTranslationUnit(ASTContext &C) override { { PrettyStackTraceString CrashInfo("Per-file LLVM IR generation"); if (llvm::TimePassesIsEnabled) @@ -165,35 +165,35 @@ namespace clang { Ctx.setDiagnosticHandler(OldDiagnosticHandler, OldDiagnosticContext); } - virtual void HandleTagDeclDefinition(TagDecl *D) { + void HandleTagDeclDefinition(TagDecl *D) override { PrettyStackTraceDecl CrashInfo(D, SourceLocation(), Context->getSourceManager(), "LLVM IR generation of declaration"); Gen->HandleTagDeclDefinition(D); } - virtual void HandleTagDeclRequiredDefinition(const TagDecl *D) { + void HandleTagDeclRequiredDefinition(const TagDecl *D) override { Gen->HandleTagDeclRequiredDefinition(D); } - virtual void CompleteTentativeDefinition(VarDecl *D) { + void CompleteTentativeDefinition(VarDecl *D) override { Gen->CompleteTentativeDefinition(D); } - virtual void HandleVTable(CXXRecordDecl *RD, bool DefinitionRequired) { + void HandleVTable(CXXRecordDecl *RD, bool DefinitionRequired) override { Gen->HandleVTable(RD, DefinitionRequired); } - virtual void HandleLinkerOptionPragma(llvm::StringRef Opts) { + void HandleLinkerOptionPragma(llvm::StringRef Opts) override { Gen->HandleLinkerOptionPragma(Opts); } - virtual void HandleDetectMismatch(llvm::StringRef Name, - llvm::StringRef Value) { + void HandleDetectMismatch(llvm::StringRef Name, + llvm::StringRef Value) override { Gen->HandleDetectMismatch(Name, Value); } - virtual void HandleDependentLibrary(llvm::StringRef Opts) { + void HandleDependentLibrary(llvm::StringRef Opts) override { Gen->HandleDependentLibrary(Opts); } diff --git a/lib/CodeGen/EHScopeStack.h b/lib/CodeGen/EHScopeStack.h index 2fc4a48f05..166d420d57 100644 --- a/lib/CodeGen/EHScopeStack.h +++ b/lib/CodeGen/EHScopeStack.h @@ -182,7 +182,7 @@ public: typedef typename DominatingValue::saved_type A0_saved; A0_saved a0_saved; - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { A0 a0 = DominatingValue::restore(CGF, a0_saved); T(a0).Emit(CGF, flags); } @@ -199,7 +199,7 @@ public: A0_saved a0_saved; A1_saved a1_saved; - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { A0 a0 = DominatingValue::restore(CGF, a0_saved); A1 a1 = DominatingValue::restore(CGF, a1_saved); T(a0, a1).Emit(CGF, flags); @@ -219,7 +219,7 @@ public: A1_saved a1_saved; A2_saved a2_saved; - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { A0 a0 = DominatingValue::restore(CGF, a0_saved); A1 a1 = DominatingValue::restore(CGF, a1_saved); A2 a2 = DominatingValue::restore(CGF, a2_saved); @@ -242,7 +242,7 @@ public: A2_saved a2_saved; A3_saved a3_saved; - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { A0 a0 = DominatingValue::restore(CGF, a0_saved); A1 a1 = DominatingValue::restore(CGF, a1_saved); A2 a2 = DominatingValue::restore(CGF, a2_saved); diff --git a/lib/CodeGen/ItaniumCXXABI.cpp b/lib/CodeGen/ItaniumCXXABI.cpp index a9090ee13c..db9e35db4e 100644 --- a/lib/CodeGen/ItaniumCXXABI.cpp +++ b/lib/CodeGen/ItaniumCXXABI.cpp @@ -52,13 +52,13 @@ public: CGCXXABI(CGM), UseARMMethodPtrABI(UseARMMethodPtrABI), UseARMGuardVarABI(UseARMGuardVarABI) { } - bool isReturnTypeIndirect(const CXXRecordDecl *RD) const { + bool isReturnTypeIndirect(const CXXRecordDecl *RD) const override { // Structures with either a non-trivial destructor or a non-trivial // copy constructor are always indirect. return !RD->hasTrivialDestructor() || RD->hasNonTrivialCopyConstructor(); } - RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const { + RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const override { // Structures with either a non-trivial destructor or a non-trivial // copy constructor are always indirect. if (!RD->hasTrivialDestructor() || RD->hasNonTrivialCopyConstructor()) @@ -66,116 +66,117 @@ public: return RAA_Default; } - bool isZeroInitializable(const MemberPointerType *MPT); + bool isZeroInitializable(const MemberPointerType *MPT) override; - llvm::Type *ConvertMemberPointerType(const MemberPointerType *MPT); + llvm::Type *ConvertMemberPointerType(const MemberPointerType *MPT) override; - llvm::Value *EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF, - const Expr *E, - llvm::Value *&This, - llvm::Value *MemFnPtr, - const MemberPointerType *MPT); + llvm::Value * + EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF, + const Expr *E, + llvm::Value *&This, + llvm::Value *MemFnPtr, + const MemberPointerType *MPT) override; - llvm::Value *EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E, - llvm::Value *Base, - llvm::Value *MemPtr, - const MemberPointerType *MPT); + llvm::Value * + EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E, + llvm::Value *Base, + llvm::Value *MemPtr, + const MemberPointerType *MPT) override; llvm::Value *EmitMemberPointerConversion(CodeGenFunction &CGF, const CastExpr *E, - llvm::Value *Src); + llvm::Value *Src) override; llvm::Constant *EmitMemberPointerConversion(const CastExpr *E, - llvm::Constant *Src); + llvm::Constant *Src) override; - llvm::Constant *EmitNullMemberPointer(const MemberPointerType *MPT); + llvm::Constant *EmitNullMemberPointer(const MemberPointerType *MPT) override; - llvm::Constant *EmitMemberPointer(const CXXMethodDecl *MD); + llvm::Constant *EmitMemberPointer(const CXXMethodDecl *MD) override; llvm::Constant *EmitMemberDataPointer(const MemberPointerType *MPT, - CharUnits offset); - llvm::Constant *EmitMemberPointer(const APValue &MP, QualType MPT); + CharUnits offset) override; + llvm::Constant *EmitMemberPointer(const APValue &MP, QualType MPT) override; llvm::Constant *BuildMemberPointer(const CXXMethodDecl *MD, CharUnits ThisAdjustment); llvm::Value *EmitMemberPointerComparison(CodeGenFunction &CGF, - llvm::Value *L, - llvm::Value *R, + llvm::Value *L, llvm::Value *R, const MemberPointerType *MPT, - bool Inequality); + bool Inequality) override; llvm::Value *EmitMemberPointerIsNotNull(CodeGenFunction &CGF, - llvm::Value *Addr, - const MemberPointerType *MPT); + llvm::Value *Addr, + const MemberPointerType *MPT) override; - llvm::Value *adjustToCompleteObject(CodeGenFunction &CGF, - llvm::Value *ptr, - QualType type); + llvm::Value *adjustToCompleteObject(CodeGenFunction &CGF, llvm::Value *ptr, + QualType type) override; - llvm::Value *GetVirtualBaseClassOffset(CodeGenFunction &CGF, - llvm::Value *This, - const CXXRecordDecl *ClassDecl, - const CXXRecordDecl *BaseClassDecl); + llvm::Value * + GetVirtualBaseClassOffset(CodeGenFunction &CGF, llvm::Value *This, + const CXXRecordDecl *ClassDecl, + const CXXRecordDecl *BaseClassDecl) override; void BuildConstructorSignature(const CXXConstructorDecl *Ctor, - CXXCtorType T, - CanQualType &ResTy, - SmallVectorImpl &ArgTys); + CXXCtorType T, CanQualType &ResTy, + SmallVectorImpl &ArgTys) override; - void EmitCXXConstructors(const CXXConstructorDecl *D); + void EmitCXXConstructors(const CXXConstructorDecl *D) override; void BuildDestructorSignature(const CXXDestructorDecl *Dtor, - CXXDtorType T, - CanQualType &ResTy, - SmallVectorImpl &ArgTys); + CXXDtorType T, CanQualType &ResTy, + SmallVectorImpl &ArgTys) override; bool useThunkForDtorVariant(const CXXDestructorDecl *Dtor, - CXXDtorType DT) const { + CXXDtorType DT) const override { // Itanium does not emit any destructor variant as an inline thunk. // Delegating may occur as an optimization, but all variants are either // emitted with external linkage or as linkonce if they are inline and used. return false; } - void EmitCXXDestructors(const CXXDestructorDecl *D); + void EmitCXXDestructors(const CXXDestructorDecl *D) override; void addImplicitStructorParams(CodeGenFunction &CGF, QualType &ResTy, - FunctionArgList &Params); + FunctionArgList &Params) override; - void EmitInstanceFunctionProlog(CodeGenFunction &CGF); + void EmitInstanceFunctionProlog(CodeGenFunction &CGF) override; unsigned addImplicitConstructorArgs(CodeGenFunction &CGF, const CXXConstructorDecl *D, CXXCtorType Type, bool ForVirtualBase, - bool Delegating, CallArgList &Args); + bool Delegating, + CallArgList &Args) override; void EmitDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *DD, CXXDtorType Type, bool ForVirtualBase, - bool Delegating, llvm::Value *This); + bool Delegating, llvm::Value *This) override; - void emitVTableDefinitions(CodeGenVTables &CGVT, const CXXRecordDecl *RD); + void emitVTableDefinitions(CodeGenVTables &CGVT, + const CXXRecordDecl *RD) override; llvm::Value *getVTableAddressPointInStructor( CodeGenFunction &CGF, const CXXRecordDecl *VTableClass, BaseSubobject Base, const CXXRecordDecl *NearestVBase, - bool &NeedsVirtualOffset); + bool &NeedsVirtualOffset) override; llvm::Constant * getVTableAddressPointForConstExpr(BaseSubobject Base, - const CXXRecordDecl *VTableClass); + const CXXRecordDecl *VTableClass) override; llvm::GlobalVariable *getAddrOfVTable(const CXXRecordDecl *RD, - CharUnits VPtrOffset); + CharUnits VPtrOffset) override; llvm::Value *getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD, - llvm::Value *This, llvm::Type *Ty); + llvm::Value *This, + llvm::Type *Ty) override; void EmitVirtualDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *Dtor, CXXDtorType DtorType, SourceLocation CallLoc, - llvm::Value *This); + llvm::Value *This) override; - void emitVirtualInheritanceTables(const CXXRecordDecl *RD); + void emitVirtualInheritanceTables(const CXXRecordDecl *RD) override; - void setThunkLinkage(llvm::Function *Thunk, bool ForVTable) { + void setThunkLinkage(llvm::Function *Thunk, bool ForVTable) override { // Allow inlining of thunks by emitting them with available_externally // linkage together with vtables when needed. if (ForVTable) @@ -183,38 +184,40 @@ public: } llvm::Value *performThisAdjustment(CodeGenFunction &CGF, llvm::Value *This, - const ThisAdjustment &TA); + const ThisAdjustment &TA) override; llvm::Value *performReturnAdjustment(CodeGenFunction &CGF, llvm::Value *Ret, - const ReturnAdjustment &RA); + const ReturnAdjustment &RA) override; - StringRef GetPureVirtualCallName() { return "__cxa_pure_virtual"; } - StringRef GetDeletedVirtualCallName() { return "__cxa_deleted_virtual"; } + StringRef GetPureVirtualCallName() override { return "__cxa_pure_virtual"; } + StringRef GetDeletedVirtualCallName() override + { return "__cxa_deleted_virtual"; } - CharUnits getArrayCookieSizeImpl(QualType elementType); + CharUnits getArrayCookieSizeImpl(QualType elementType) override; llvm::Value *InitializeArrayCookie(CodeGenFunction &CGF, llvm::Value *NewPtr, llvm::Value *NumElements, const CXXNewExpr *expr, - QualType ElementType); + QualType ElementType) override; llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF, llvm::Value *allocPtr, - CharUnits cookieSize); + CharUnits cookieSize) override; void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D, - llvm::GlobalVariable *DeclPtr, bool PerformInit); + llvm::GlobalVariable *DeclPtr, + bool PerformInit) override; void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D, - llvm::Constant *dtor, llvm::Constant *addr); + llvm::Constant *dtor, llvm::Constant *addr) override; llvm::Function *getOrCreateThreadLocalWrapper(const VarDecl *VD, llvm::GlobalVariable *Var); void EmitThreadLocalInitFuncs( llvm::ArrayRef > Decls, - llvm::Function *InitFunc); + llvm::Function *InitFunc) override; LValue EmitThreadLocalDeclRefExpr(CodeGenFunction &CGF, - const DeclRefExpr *DRE); + const DeclRefExpr *DRE) override; - bool NeedsVTTParameter(GlobalDecl GD); + bool NeedsVTTParameter(GlobalDecl GD) override; }; class ARMCXXABI : public ItaniumCXXABI { @@ -223,22 +226,23 @@ public: ItaniumCXXABI(CGM, /* UseARMMethodPtrABI = */ true, /* UseARMGuardVarABI = */ true) {} - bool HasThisReturn(GlobalDecl GD) const { + bool HasThisReturn(GlobalDecl GD) const override { return (isa(GD.getDecl()) || ( isa(GD.getDecl()) && GD.getDtorType() != Dtor_Deleting)); } - void EmitReturnFromThunk(CodeGenFunction &CGF, RValue RV, QualType ResTy); + void EmitReturnFromThunk(CodeGenFunction &CGF, RValue RV, + QualType ResTy) override; - CharUnits getArrayCookieSizeImpl(QualType elementType); + CharUnits getArrayCookieSizeImpl(QualType elementType) override; llvm::Value *InitializeArrayCookie(CodeGenFunction &CGF, llvm::Value *NewPtr, llvm::Value *NumElements, const CXXNewExpr *expr, - QualType ElementType); + QualType ElementType) override; llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF, llvm::Value *allocPtr, - CharUnits cookieSize); + CharUnits cookieSize) override; }; } @@ -1322,7 +1326,7 @@ namespace { llvm::GlobalVariable *Guard; CallGuardAbort(llvm::GlobalVariable *Guard) : Guard(Guard) {} - void Emit(CodeGenFunction &CGF, Flags flags) { + void Emit(CodeGenFunction &CGF, Flags flags) override { CGF.EmitNounwindRuntimeCall(getGuardAbortFn(CGF.CGM, Guard->getType()), Guard); } diff --git a/lib/CodeGen/MicrosoftCXXABI.cpp b/lib/CodeGen/MicrosoftCXXABI.cpp index aac76e7334..22a7cafd25 100644 --- a/lib/CodeGen/MicrosoftCXXABI.cpp +++ b/lib/CodeGen/MicrosoftCXXABI.cpp @@ -37,14 +37,14 @@ class MicrosoftCXXABI : public CGCXXABI { public: MicrosoftCXXABI(CodeGenModule &CGM) : CGCXXABI(CGM) {} - bool HasThisReturn(GlobalDecl GD) const; + bool HasThisReturn(GlobalDecl GD) const override; - bool isReturnTypeIndirect(const CXXRecordDecl *RD) const { + bool isReturnTypeIndirect(const CXXRecordDecl *RD) const override { // Structures that are not C++03 PODs are always indirect. return !RD->isPOD(); } - RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const { + RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const override { if (RD->hasNonTrivialCopyConstructor() || RD->hasNonTrivialDestructor()) { llvm::Triple::ArchType Arch = CGM.getTarget().getTriple().getArch(); if (Arch == llvm::Triple::x86) @@ -56,34 +56,34 @@ public: return RAA_Default; } - StringRef GetPureVirtualCallName() { return "_purecall"; } + StringRef GetPureVirtualCallName() override { return "_purecall"; } // No known support for deleted functions in MSVC yet, so this choice is // arbitrary. - StringRef GetDeletedVirtualCallName() { return "_purecall"; } + StringRef GetDeletedVirtualCallName() override { return "_purecall"; } - bool isInlineInitializedStaticDataMemberLinkOnce() { return true; } + bool isInlineInitializedStaticDataMemberLinkOnce() override{ return true; } llvm::Value *adjustToCompleteObject(CodeGenFunction &CGF, llvm::Value *ptr, - QualType type); + QualType type) override; - llvm::Value *GetVirtualBaseClassOffset(CodeGenFunction &CGF, - llvm::Value *This, - const CXXRecordDecl *ClassDecl, - const CXXRecordDecl *BaseClassDecl); + llvm::Value * + GetVirtualBaseClassOffset(CodeGenFunction &CGF, llvm::Value *This, + const CXXRecordDecl *ClassDecl, + const CXXRecordDecl *BaseClassDecl) override; void BuildConstructorSignature(const CXXConstructorDecl *Ctor, - CXXCtorType Type, - CanQualType &ResTy, - SmallVectorImpl &ArgTys); + CXXCtorType Type, CanQualType &ResTy, + SmallVectorImpl &ArgTys) override; - llvm::BasicBlock *EmitCtorCompleteObjectHandler(CodeGenFunction &CGF, - const CXXRecordDecl *RD); + llvm::BasicBlock * + EmitCtorCompleteObjectHandler(CodeGenFunction &CGF, + const CXXRecordDecl *RD) override; void initializeHiddenVirtualInheritanceMembers(CodeGenFunction &CGF, - const CXXRecordDecl *RD); + const CXXRecordDecl *RD) override; - void EmitCXXConstructors(const CXXConstructorDecl *D); + void EmitCXXConstructors(const CXXConstructorDecl *D) override; // Background on MSVC destructors // ============================== @@ -120,17 +120,18 @@ public: void BuildDestructorSignature(const CXXDestructorDecl *Dtor, CXXDtorType Type, CanQualType &ResTy, - SmallVectorImpl &ArgTys); + SmallVectorImpl &ArgTys) override; /// Non-base dtors should be emitted as delegating thunks in this ABI. bool useThunkForDtorVariant(const CXXDestructorDecl *Dtor, - CXXDtorType DT) const { + CXXDtorType DT) const override { return DT != Dtor_Base; } - void EmitCXXDestructors(const CXXDestructorDecl *D); + void EmitCXXDestructors(const CXXDestructorDecl *D) override; - const CXXRecordDecl *getThisArgumentTypeForMethod(const CXXMethodDecl *MD) { + const CXXRecordDecl * + getThisArgumentTypeForMethod(const CXXMethodDecl *MD) override { MD = MD->getCanonicalDecl(); if (MD->isVirtual() && !isa(MD)) { MicrosoftVTableContext::MethodVFTableLocation ML = @@ -149,56 +150,59 @@ public: llvm::Value *adjustThisArgumentForVirtualCall(CodeGenFunction &CGF, GlobalDecl GD, - llvm::Value *This); + llvm::Value *This) override; void addImplicitStructorParams(CodeGenFunction &CGF, QualType &ResTy, - FunctionArgList &Params); + FunctionArgList &Params) override; llvm::Value *adjustThisParameterInVirtualFunctionPrologue( - CodeGenFunction &CGF, GlobalDecl GD, llvm::Value *This); + CodeGenFunction &CGF, GlobalDecl GD, llvm::Value *This) override; - void EmitInstanceFunctionProlog(CodeGenFunction &CGF); + void EmitInstanceFunctionProlog(CodeGenFunction &CGF) override; unsigned addImplicitConstructorArgs(CodeGenFunction &CGF, const CXXConstructorDecl *D, CXXCtorType Type, bool ForVirtualBase, - bool Delegating, CallArgList &Args); + bool Delegating, + CallArgList &Args) override; void EmitDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *DD, CXXDtorType Type, bool ForVirtualBase, - bool Delegating, llvm::Value *This); + bool Delegating, llvm::Value *This) override; - void emitVTableDefinitions(CodeGenVTables &CGVT, const CXXRecordDecl *RD); + void emitVTableDefinitions(CodeGenVTables &CGVT, + const CXXRecordDecl *RD) override; llvm::Value *getVTableAddressPointInStructor( CodeGenFunction &CGF, const CXXRecordDecl *VTableClass, BaseSubobject Base, const CXXRecordDecl *NearestVBase, - bool &NeedsVirtualOffset); + bool &NeedsVirtualOffset) override; llvm::Constant * getVTableAddressPointForConstExpr(BaseSubobject Base, - const CXXRecordDecl *VTableClass); + const CXXRecordDecl *VTableClass) override; llvm::GlobalVariable *getAddrOfVTable(const CXXRecordDecl *RD, - CharUnits VPtrOffset); + CharUnits VPtrOffset) override; llvm::Value *getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD, - llvm::Value *This, llvm::Type *Ty); + llvm::Value *This, + llvm::Type *Ty) override; void EmitVirtualDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *Dtor, CXXDtorType DtorType, SourceLocation CallLoc, - llvm::Value *This); + llvm::Value *This) override; void adjustCallArgsForDestructorThunk(CodeGenFunction &CGF, GlobalDecl GD, - CallArgList &CallArgs) { + CallArgList &CallArgs) override { assert(GD.getDtorType() == Dtor_Deleting && "Only deleting destructor thunks are available in this ABI"); CallArgs.add(RValue::get(getStructorImplicitParamValue(CGF)), CGM.getContext().IntTy); } - void emitVirtualInheritanceTables(const CXXRecordDecl *RD); + void emitVirtualInheritanceTables(const CXXRecordDecl *RD) override; llvm::GlobalVariable * getAddrOfVBTable(const VPtrInfo &VBT, const CXXRecordDecl *RD, @@ -207,19 +211,19 @@ public: void emitVBTableDefinition(const VPtrInfo &VBT, const CXXRecordDecl *RD, llvm::GlobalVariable *GV) const; - void setThunkLinkage(llvm::Function *Thunk, bool ForVTable) { + void setThunkLinkage(llvm::Function *Thunk, bool ForVTable) override { Thunk->setLinkage(llvm::GlobalValue::WeakAnyLinkage); } llvm::Value *performThisAdjustment(CodeGenFunction &CGF, llvm::Value *This, - const ThisAdjustment &TA); + const ThisAdjustment &TA) override; llvm::Value *performReturnAdjustment(CodeGenFunction &CGF, llvm::Value *Ret, - const ReturnAdjustment &RA); + const ReturnAdjustment &RA) override; void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D, llvm::GlobalVariable *DeclPtr, - bool PerformInit); + bool PerformInit) override; // ==== Notes on array cookies ========= // @@ -244,17 +248,18 @@ public: // } // Whereas it prints "104" and "104" if you give A a destructor. - bool requiresArrayCookie(const CXXDeleteExpr *expr, QualType elementType); - bool requiresArrayCookie(const CXXNewExpr *expr); - CharUnits getArrayCookieSizeImpl(QualType type); + bool requiresArrayCookie(const CXXDeleteExpr *expr, + QualType elementType) override; + bool requiresArrayCookie(const CXXNewExpr *expr) override; + CharUnits getArrayCookieSizeImpl(QualType type) override; llvm::Value *InitializeArrayCookie(CodeGenFunction &CGF, llvm::Value *NewPtr, llvm::Value *NumElements, const CXXNewExpr *expr, - QualType ElementType); + QualType ElementType) override; llvm::Value *readArrayCookieImpl(CodeGenFunction &CGF, llvm::Value *allocPtr, - CharUnits cookieSize); + CharUnits cookieSize) override; private: MicrosoftMangleContext &getMangleContext() { @@ -333,43 +338,43 @@ private: const MicrosoftVTableContext::MethodVFTableLocation &ML); public: - virtual llvm::Type *ConvertMemberPointerType(const MemberPointerType *MPT); + llvm::Type *ConvertMemberPointerType(const MemberPointerType *MPT) override; - virtual bool isZeroInitializable(const MemberPointerType *MPT); + bool isZeroInitializable(const MemberPointerType *MPT) override; - virtual llvm::Constant *EmitNullMemberPointer(const MemberPointerType *MPT); + llvm::Constant *EmitNullMemberPointer(const MemberPointerType *MPT) override; - virtual llvm::Constant *EmitMemberDataPointer(const MemberPointerType *MPT, - CharUnits offset); - virtual llvm::Constant *EmitMemberPointer(const CXXMethodDecl *MD); - virtual llvm::Constant *EmitMemberPointer(const APValue &MP, QualType MPT); + llvm::Constant *EmitMemberDataPointer(const MemberPointerType *MPT, + CharUnits offset) override; + llvm::Constant *EmitMemberPointer(const CXXMethodDecl *MD) override; + llvm::Constant *EmitMemberPointer(const APValue &MP, QualType MPT) override; - virtual llvm::Value *EmitMemberPointerComparison(CodeGenFunction &CGF, - llvm::Value *L, - llvm::Value *R, - const MemberPointerType *MPT, - bool Inequality); + llvm::Value *EmitMemberPointerComparison(CodeGenFunction &CGF, + llvm::Value *L, + llvm::Value *R, + const MemberPointerType *MPT, + bool Inequality) override; - virtual llvm::Value *EmitMemberPointerIsNotNull(CodeGenFunction &CGF, - llvm::Value *MemPtr, - const MemberPointerType *MPT); + llvm::Value *EmitMemberPointerIsNotNull(CodeGenFunction &CGF, + llvm::Value *MemPtr, + const MemberPointerType *MPT) override; - virtual llvm::Value * + llvm::Value * EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E, llvm::Value *Base, llvm::Value *MemPtr, - const MemberPointerType *MPT); + const MemberPointerType *MPT) override; - virtual llvm::Value *EmitMemberPointerConversion(CodeGenFunction &CGF, - const CastExpr *E, - llvm::Value *Src); + llvm::Value *EmitMemberPointerConversion(CodeGenFunction &CGF, + const CastExpr *E, + llvm::Value *Src) override; - virtual llvm::Constant *EmitMemberPointerConversion(const CastExpr *E, - llvm::Constant *Src); + llvm::Constant *EmitMemberPointerConversion(const CastExpr *E, + llvm::Constant *Src) override; - virtual llvm::Value * + llvm::Value * EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF, const Expr *E, llvm::Value *&This, llvm::Value *MemPtr, - const MemberPointerType *MPT); + const MemberPointerType *MPT) override; private: typedef std::pair VFTableIdTy; diff --git a/lib/CodeGen/ModuleBuilder.cpp b/lib/CodeGen/ModuleBuilder.cpp index 03aecce761..7873f44f1d 100644 --- a/lib/CodeGen/ModuleBuilder.cpp +++ b/lib/CodeGen/ModuleBuilder.cpp @@ -45,13 +45,13 @@ namespace { virtual ~CodeGeneratorImpl() {} - virtual llvm::Module* GetModule() { + llvm::Module* GetModule() override { return M.get(); } - virtual llvm::Module *ReleaseModule() { return M.release(); } + llvm::Module *ReleaseModule() override { return M.release(); } - virtual void Initialize(ASTContext &Context) { + void Initialize(ASTContext &Context) override { Ctx = &Context; M->setTargetTriple(Ctx->getTargetInfo().getTriple().getTriple()); @@ -64,14 +64,14 @@ namespace { HandleDependentLibrary(CodeGenOpts.DependentLibraries[i]); } - virtual void HandleCXXStaticMemberVarInstantiation(VarDecl *VD) { + void HandleCXXStaticMemberVarInstantiation(VarDecl *VD) override { if (Diags.hasErrorOccurred()) return; Builder->HandleCXXStaticMemberVarInstantiation(VD); } - virtual bool HandleTopLevelDecl(DeclGroupRef DG) { + bool HandleTopLevelDecl(DeclGroupRef DG) override { if (Diags.hasErrorOccurred()) return true; @@ -85,7 +85,7 @@ namespace { /// to (e.g. struct, union, enum, class) is completed. This allows the /// client hack on the type, which can occur at any point in the file /// (because these can be defined in declspecs). - virtual void HandleTagDeclDefinition(TagDecl *D) { + void HandleTagDeclDefinition(TagDecl *D) override { if (Diags.hasErrorOccurred()) return; @@ -103,7 +103,7 @@ namespace { } } - virtual void HandleTagDeclRequiredDefinition(const TagDecl *D) override { + void HandleTagDeclRequiredDefinition(const TagDecl *D) override { if (Diags.hasErrorOccurred()) return; @@ -112,7 +112,7 @@ namespace { DI->completeRequiredType(RD); } - virtual void HandleTranslationUnit(ASTContext &Ctx) { + void HandleTranslationUnit(ASTContext &Ctx) override { if (Diags.hasErrorOccurred()) { if (Builder) Builder->clear(); @@ -124,30 +124,30 @@ namespace { Builder->Release(); } - virtual void CompleteTentativeDefinition(VarDecl *D) { + void CompleteTentativeDefinition(VarDecl *D) override { if (Diags.hasErrorOccurred()) return; Builder->EmitTentativeDefinition(D); } - virtual void HandleVTable(CXXRecordDecl *RD, bool DefinitionRequired) { + void HandleVTable(CXXRecordDecl *RD, bool DefinitionRequired) override { if (Diags.hasErrorOccurred()) return; Builder->EmitVTable(RD, DefinitionRequired); } - virtual void HandleLinkerOptionPragma(llvm::StringRef Opts) { + void HandleLinkerOptionPragma(llvm::StringRef Opts) override { Builder->AppendLinkerOptions(Opts); } - virtual void HandleDetectMismatch(llvm::StringRef Name, - llvm::StringRef Value) { + void HandleDetectMismatch(llvm::StringRef Name, + llvm::StringRef Value) override { Builder->AddDetectMismatch(Name, Value); } - virtual void HandleDependentLibrary(llvm::StringRef Lib) { + void HandleDependentLibrary(llvm::StringRef Lib) override { Builder->AddDependentLib(Lib); } }; diff --git a/lib/CodeGen/TargetInfo.cpp b/lib/CodeGen/TargetInfo.cpp index f9594c8e16..b7d45cf91c 100644 --- a/lib/CodeGen/TargetInfo.cpp +++ b/lib/CodeGen/TargetInfo.cpp @@ -368,15 +368,15 @@ public: ABIArgInfo classifyReturnType(QualType RetTy) const; ABIArgInfo classifyArgumentType(QualType RetTy) const; - virtual void computeInfo(CGFunctionInfo &FI) const { + void computeInfo(CGFunctionInfo &FI) const override { FI.getReturnInfo() = classifyReturnType(FI.getReturnType()); for (CGFunctionInfo::arg_iterator it = FI.arg_begin(), ie = FI.arg_end(); it != ie; ++it) it->info = classifyArgumentType(it->type); } - virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, - CodeGenFunction &CGF) const; + llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, + CodeGenFunction &CGF) const override; }; class DefaultTargetCodeGenInfo : public TargetCodeGenInfo { @@ -437,9 +437,9 @@ class PNaClABIInfo : public ABIInfo { ABIArgInfo classifyReturnType(QualType RetTy) const; ABIArgInfo classifyArgumentType(QualType RetTy) const; - virtual void computeInfo(CGFunctionInfo &FI) const; - virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, - CodeGenFunction &CGF) const; + void computeInfo(CGFunctionInfo &FI) const override; + llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, + CodeGenFunction &CGF) const override; }; class PNaClTargetCodeGenInfo : public TargetCodeGenInfo { @@ -579,9 +579,9 @@ class X86_32ABIInfo : public ABIInfo { public: - virtual void computeInfo(CGFunctionInfo &FI) const; - virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, - CodeGenFunction &CGF) const; + void computeInfo(CGFunctionInfo &FI) const override; + llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, + CodeGenFunction &CGF) const override; X86_32ABIInfo(CodeGen::CodeGenTypes &CGT, bool d, bool p, bool w, unsigned r) @@ -599,24 +599,25 @@ public: const llvm::Triple &Triple, const CodeGenOptions &Opts); void SetTargetAttributes(const Decl *D, llvm::GlobalValue *GV, - CodeGen::CodeGenModule &CGM) const; + CodeGen::CodeGenModule &CGM) const override; - int getDwarfEHStackPointer(CodeGen::CodeGenModule &CGM) const { + int getDwarfEHStackPointer(CodeGen::CodeGenModule &CGM) const override { // Darwin uses different dwarf register numbers for EH. if (CGM.getTarget().getTriple().isOSDarwin()) return 5; return 4; } bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF, - llvm::Value *Address) const; + llvm::Value *Address) const override; llvm::Type* adjustInlineAsmType(CodeGen::CodeGenFunction &CGF, StringRef Constraint, - llvm::Type* Ty) const { + llvm::Type* Ty) const override { return X86AdjustInlineAsmType(CGF, Constraint, Ty); } - llvm::Constant *getUBSanFunctionSignature(CodeGen::CodeGenModule &CGM) const { + llvm::Constant * + getUBSanFunctionSignature(CodeGen::CodeGenModule &CGM) const override { unsigned Sig = (0xeb << 0) | // jmp rel8 (0x06 << 8) | // .+0x08 ('F' << 16) | @@ -1314,10 +1315,10 @@ public: return false; } - virtual void computeInfo(CGFunctionInfo &FI) const; + void computeInfo(CGFunctionInfo &FI) const override; - virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, - CodeGenFunction &CGF) const; + llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, + CodeGenFunction &CGF) const override; }; /// WinX86_64ABIInfo - The Windows X86_64 ABI information. @@ -1328,10 +1329,10 @@ class WinX86_64ABIInfo : public ABIInfo { public: WinX86_64ABIInfo(CodeGen::CodeGenTypes &CGT) : ABIInfo(CGT) {} - virtual void computeInfo(CGFunctionInfo &FI) const; + void computeInfo(CGFunctionInfo &FI) const override; - virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, - CodeGenFunction &CGF) const; + llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, + CodeGenFunction &CGF) const override; }; class X86_64TargetCodeGenInfo : public TargetCodeGenInfo { @@ -1343,12 +1344,12 @@ public: return static_cast(TargetCodeGenInfo::getABIInfo()); } - int getDwarfEHStackPointer(CodeGen::CodeGenModule &CGM) const { + int getDwarfEHStackPointer(CodeGen::CodeGenModule &CGM) const override { return 7; } bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF, - llvm::Value *Address) const { + llvm::Value *Address) const override { llvm::Value *Eight8 = llvm::ConstantInt::get(CGF.Int8Ty, 8); // 0-15 are the 16 integer registers. @@ -1359,12 +1360,12 @@ public: llvm::Type* adjustInlineAsmType(CodeGen::CodeGenFunction &CGF, StringRef Constraint, - llvm::Type* Ty) const { + llvm::Type* Ty) const override { return X86AdjustInlineAsmType(CGF, Constraint, Ty); } bool isNoProtoCallVariadic(const CallArgList &args, - const FunctionNoProtoType *fnType) const { + const FunctionNoProtoType *fnType) const override { // The default CC on x86-64 sets %al to the number of SSA // registers used, and GCC sets this when calling an unprototyped // function, so we override the default behavior. However, don't do @@ -1388,7 +1389,8 @@ public: return TargetCodeGenInfo::isNoProtoCallVariadic(args, fnType); } - llvm::Constant *getUBSanFunctionSignature(CodeGen::CodeGenModule &CGM) const { + llvm::Constant * + getUBSanFunctionSignature(CodeGen::CodeGenModule &CGM) const override { unsigned Sig = (0xeb << 0) | // jmp rel8 (0x0a << 8) | // .+0x0c ('F' << 16) | @@ -1414,14 +1416,14 @@ public: : X86_32TargetCodeGenInfo(CGT, d, p, w, RegParms) {} void getDependentLibraryOption(llvm::StringRef Lib, - llvm::SmallString<24> &Opt) const { + llvm::SmallString<24> &Opt) const override { Opt = "/DEFAULTLIB:"; Opt += qualifyWindowsLibrary(Lib); } void getDetectMismatchOption(llvm::StringRef Name, llvm::StringRef Value, - llvm::SmallString<32> &Opt) const { + llvm::SmallString<32> &Opt) const override { Opt = "/FAILIFMISMATCH:\"" + Name.str() + "=" + Value.str() + "\""; } }; @@ -1431,12 +1433,12 @@ public: WinX86_64TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT) : TargetCodeGenInfo(new WinX86_64ABIInfo(CGT)) {} - int getDwarfEHStackPointer(CodeGen::CodeGenModule &CGM) const { + int getDwarfEHStackPointer(CodeGen::CodeGenModule &CGM) const override { return 7; } bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF, - llvm::Value *Address) const { + llvm::Value *Address) const override { llvm::Value *Eight8 = llvm::ConstantInt::get(CGF.Int8Ty, 8); // 0-15 are the 16 integer registers. @@ -1446,14 +1448,14 @@ public: } void getDependentLibraryOption(llvm::StringRef Lib, - llvm::SmallString<24> &Opt) const { + llvm::SmallString<24> &Opt) const override { Opt = "/DEFAULTLIB:"; Opt += qualifyWindowsLibrary(Lib); } void getDetectMismatchOption(llvm::StringRef Name, llvm::StringRef Value, - llvm::SmallString<32> &Opt) const { + llvm::SmallString<32> &Opt) const override { Opt = "/FAILIFMISMATCH:\"" + Name.str() + "=" + Value.str() + "\""; } }; @@ -2796,9 +2798,9 @@ class NaClX86_64ABIInfo : public ABIInfo { public: NaClX86_64ABIInfo(CodeGen::CodeGenTypes &CGT, bool HasAVX) : ABIInfo(CGT), PInfo(CGT), NInfo(CGT, HasAVX) {} - virtual void computeInfo(CGFunctionInfo &FI) const; - virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, - CodeGenFunction &CGF) const; + void computeInfo(CGFunctionInfo &FI) const override; + llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, + CodeGenFunction &CGF) const override; private: PNaClABIInfo PInfo; // Used for generating calls with pnaclcall callingconv. X86_64ABIInfo NInfo; // Used for everything else. @@ -2834,13 +2836,13 @@ class PPC32TargetCodeGenInfo : public DefaultTargetCodeGenInfo { public: PPC32TargetCodeGenInfo(CodeGenTypes &CGT) : DefaultTargetCodeGenInfo(CGT) {} - int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const { + int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const override { // This is recovered from gcc output. return 1; // r1 is the dedicated stack pointer } bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF, - llvm::Value *Address) const; + llvm::Value *Address) const override; }; } @@ -2906,7 +2908,7 @@ public: // floating-point value) to avoid pushing them to memory on function // entry. This would require changing the logic in PPCISelLowering // when lowering the parameters in the caller and args in the callee. - virtual void computeInfo(CGFunctionInfo &FI) const { + void computeInfo(CGFunctionInfo &FI) const override { FI.getReturnInfo() = classifyReturnType(FI.getReturnType()); for (CGFunctionInfo::arg_iterator it = FI.arg_begin(), ie = FI.arg_end(); it != ie; ++it) { @@ -2926,9 +2928,8 @@ public: } } - virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, - QualType Ty, - CodeGenFunction &CGF) const; + llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, + CodeGenFunction &CGF) const override; }; class PPC64_SVR4_TargetCodeGenInfo : public TargetCodeGenInfo { @@ -2936,26 +2937,26 @@ public: PPC64_SVR4_TargetCodeGenInfo(CodeGenTypes &CGT) : TargetCodeGenInfo(new PPC64_SVR4_ABIInfo(CGT)) {} - int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const { + int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const override { // This is recovered from gcc output. return 1; // r1 is the dedicated stack pointer } bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF, - llvm::Value *Address) const; + llvm::Value *Address) const override; }; class PPC64TargetCodeGenInfo : public DefaultTargetCodeGenInfo { public: PPC64TargetCodeGenInfo(CodeGenTypes &CGT) : DefaultTargetCodeGenInfo(CGT) {} - int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const { + int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const override { // This is recovered from gcc output. return 1; // r1 is the dedicated stack pointer } bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF, - llvm::Value *Address) const; + llvm::Value *Address) const override; }; } @@ -3203,10 +3204,10 @@ private: bool &IsCPRC) const; bool isIllegalVectorType(QualType Ty) const; - virtual void computeInfo(CGFunctionInfo &FI) const; + void computeInfo(CGFunctionInfo &FI) const override; - virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, - CodeGenFunction &CGF) const; + llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, + CodeGenFunction &CGF) const override; llvm::CallingConv::ID getLLVMDefaultCC() const; llvm::CallingConv::ID getABIDefaultCC() const; @@ -3226,16 +3227,16 @@ public: return static_cast(TargetCodeGenInfo::getABIInfo()); } - int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const { + int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const override { return 13; } - StringRef getARCRetainAutoreleasedReturnValueMarker() const { + StringRef getARCRetainAutoreleasedReturnValueMarker() const override { return "mov\tr7, r7\t\t@ marker for objc_retainAutoreleaseReturnValue"; } bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF, - llvm::Value *Address) const { + llvm::Value *Address) const override { llvm::Value *Four8 = llvm::ConstantInt::get(CGF.Int8Ty, 4); // 0-15 are the 16 integer registers. @@ -3243,13 +3244,13 @@ public: return false; } - unsigned getSizeOfUnwindException() const { + unsigned getSizeOfUnwindException() const override { if (getABIInfo().isEABI()) return 88; return TargetCodeGenInfo::getSizeOfUnwindException(); } void SetTargetAttributes(const Decl *D, llvm::GlobalValue *GV, - CodeGen::CodeGenModule &CGM) const { + CodeGen::CodeGenModule &CGM) const override { const FunctionDecl *FD = dyn_cast(D); if (!FD) return; @@ -3941,9 +3942,9 @@ class NaClARMABIInfo : public ABIInfo { public: NaClARMABIInfo(CodeGen::CodeGenTypes &CGT, ARMABIInfo::ABIKind Kind) : ABIInfo(CGT), PInfo(CGT), NInfo(CGT, Kind) {} - virtual void computeInfo(CGFunctionInfo &FI) const; - virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, - CodeGenFunction &CGF) const; + void computeInfo(CGFunctionInfo &FI) const override; + llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, + CodeGenFunction &CGF) const override; private: PNaClABIInfo PInfo; // Used for generating calls with pnaclcall callingconv. ARMABIInfo NInfo; // Used for everything else. @@ -3991,10 +3992,10 @@ private: ABIArgInfo tryUseRegs(QualType Ty, int &FreeRegs, int RegsNeeded, bool IsInt, llvm::Type *DirectTy = 0) const; - virtual void computeInfo(CGFunctionInfo &FI) const; + void computeInfo(CGFunctionInfo &FI) const override; - virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, - CodeGenFunction &CGF) const; + llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, + CodeGenFunction &CGF) const override; }; class AArch64TargetCodeGenInfo : public TargetCodeGenInfo { @@ -4006,12 +4007,12 @@ public: return static_cast(TargetCodeGenInfo::getABIInfo()); } - int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const { + int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const override { return 31; } bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF, - llvm::Value *Address) const { + llvm::Value *Address) const override { // 0-31 are x0-x30 and sp: 8 bytes each llvm::Value *Eight8 = llvm::ConstantInt::get(CGF.Int8Ty, 8); AssignToArrayRange(CGF.Builder, Address, Eight8, 0, 31); @@ -4396,18 +4397,18 @@ public: ABIArgInfo classifyReturnType(QualType RetTy) const; ABIArgInfo classifyArgumentType(QualType Ty) const; - virtual void computeInfo(CGFunctionInfo &FI) const; - virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, - CodeGenFunction &CFG) const; + void computeInfo(CGFunctionInfo &FI) const override; + llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, + CodeGenFunction &CFG) const override; }; class NVPTXTargetCodeGenInfo : public TargetCodeGenInfo { public: NVPTXTargetCodeGenInfo(CodeGenTypes &CGT) : TargetCodeGenInfo(new NVPTXABIInfo(CGT)) {} - - virtual void SetTargetAttributes(const Decl *D, llvm::GlobalValue *GV, - CodeGen::CodeGenModule &M) const; + + void SetTargetAttributes(const Decl *D, llvm::GlobalValue *GV, + CodeGen::CodeGenModule &M) const override; private: static void addKernelMetadata(llvm::Function *F); }; @@ -4521,15 +4522,15 @@ public: ABIArgInfo classifyReturnType(QualType RetTy) const; ABIArgInfo classifyArgumentType(QualType ArgTy) const; - virtual void computeInfo(CGFunctionInfo &FI) const { + void computeInfo(CGFunctionInfo &FI) const override { FI.getReturnInfo() = classifyReturnType(FI.getReturnType()); for (CGFunctionInfo::arg_iterator it = FI.arg_begin(), ie = FI.arg_end(); it != ie; ++it) it->info = classifyArgumentType(it->type); } - virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, - CodeGenFunction &CGF) const; + llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, + CodeGenFunction &CGF) const override; }; class SystemZTargetCodeGenInfo : public TargetCodeGenInfo { @@ -4829,7 +4830,7 @@ public: MSP430TargetCodeGenInfo(CodeGenTypes &CGT) : TargetCodeGenInfo(new DefaultABIInfo(CGT)) {} void SetTargetAttributes(const Decl *D, llvm::GlobalValue *GV, - CodeGen::CodeGenModule &M) const; + CodeGen::CodeGenModule &M) const override; }; } @@ -4878,9 +4879,9 @@ public: ABIArgInfo classifyReturnType(QualType RetTy) const; ABIArgInfo classifyArgumentType(QualType RetTy, uint64_t &Offset) const; - virtual void computeInfo(CGFunctionInfo &FI) const; - virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, - CodeGenFunction &CGF) const; + void computeInfo(CGFunctionInfo &FI) const override; + llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, + CodeGenFunction &CGF) const override; }; class MIPSTargetCodeGenInfo : public TargetCodeGenInfo { @@ -4890,12 +4891,12 @@ public: : TargetCodeGenInfo(new MipsABIInfo(CGT, IsO32)), SizeOfUnwindException(IsO32 ? 24 : 32) {} - int getDwarfEHStackPointer(CodeGen::CodeGenModule &CGM) const { + int getDwarfEHStackPointer(CodeGen::CodeGenModule &CGM) const override { return 29; } void SetTargetAttributes(const Decl *D, llvm::GlobalValue *GV, - CodeGen::CodeGenModule &CGM) const { + CodeGen::CodeGenModule &CGM) const override { const FunctionDecl *FD = dyn_cast(D); if (!FD) return; llvm::Function *Fn = cast(GV); @@ -4908,9 +4909,9 @@ public: } bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF, - llvm::Value *Address) const; + llvm::Value *Address) const override; - unsigned getSizeOfUnwindException() const { + unsigned getSizeOfUnwindException() const override { return SizeOfUnwindException; } }; @@ -5202,8 +5203,8 @@ public: TCETargetCodeGenInfo(CodeGenTypes &CGT) : DefaultTargetCodeGenInfo(CGT) {} - virtual void SetTargetAttributes(const Decl *D, llvm::GlobalValue *GV, - CodeGen::CodeGenModule &M) const; + void SetTargetAttributes(const Decl *D, llvm::GlobalValue *GV, + CodeGen::CodeGenModule &M) const override; }; void TCETargetCodeGenInfo::SetTargetAttributes(const Decl *D, @@ -5264,10 +5265,10 @@ private: ABIArgInfo classifyReturnType(QualType RetTy) const; ABIArgInfo classifyArgumentType(QualType RetTy) const; - virtual void computeInfo(CGFunctionInfo &FI) const; + void computeInfo(CGFunctionInfo &FI) const override; - virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, - CodeGenFunction &CGF) const; + llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, + CodeGenFunction &CGF) const override; }; class HexagonTargetCodeGenInfo : public TargetCodeGenInfo { @@ -5275,7 +5276,7 @@ public: HexagonTargetCodeGenInfo(CodeGenTypes &CGT) :TargetCodeGenInfo(new HexagonABIInfo(CGT)) {} - int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const { + int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const override { return 29; } }; @@ -5419,9 +5420,9 @@ public: private: ABIArgInfo classifyType(QualType RetTy, unsigned SizeLimit) const; - virtual void computeInfo(CGFunctionInfo &FI) const; - virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, - CodeGenFunction &CGF) const; + void computeInfo(CGFunctionInfo &FI) const override; + llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, + CodeGenFunction &CGF) const override; // Coercion type builder for structs passed in registers. The coercion type // serves two purposes: @@ -5648,12 +5649,12 @@ public: SparcV9TargetCodeGenInfo(CodeGenTypes &CGT) : TargetCodeGenInfo(new SparcV9ABIInfo(CGT)) {} - int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const { + int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const override { return 14; } bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF, - llvm::Value *Address) const; + llvm::Value *Address) const override; }; } // end anonymous namespace @@ -5699,8 +5700,8 @@ namespace { class XCoreABIInfo : public DefaultABIInfo { public: XCoreABIInfo(CodeGen::CodeGenTypes &CGT) : DefaultABIInfo(CGT) {} - virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, - CodeGenFunction &CGF) const; + llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty, + CodeGenFunction &CGF) const override; }; class XCoreTargetCodeGenInfo : public TargetCodeGenInfo {