Index: cfe/trunk/lib/CodeGen/CGCXXABI.h =================================================================== --- cfe/trunk/lib/CodeGen/CGCXXABI.h +++ cfe/trunk/lib/CodeGen/CGCXXABI.h @@ -73,9 +73,10 @@ return CGF.CXXStructorImplicitParamValue; } - /// Perform prolog initialization of the parameter variable suitable - /// for 'this' emitted by buildThisParam. - void EmitThisParam(CodeGenFunction &CGF); + /// Loads the incoming C++ this pointer as it was passed by the caller. + llvm::Value *loadIncomingCXXThis(CodeGenFunction &CGF); + + void setCXXABIThisValue(CodeGenFunction &CGF, llvm::Value *ThisPtr); ASTContext &getContext() const { return CGM.getContext(); } @@ -358,13 +359,6 @@ return CharUnits::Zero(); } - /// Perform ABI-specific "this" parameter adjustment in a virtual function - /// prologue. - virtual llvm::Value *adjustThisParameterInVirtualFunctionPrologue( - CodeGenFunction &CGF, GlobalDecl GD, llvm::Value *This) { - return This; - } - /// Emit the ABI-specific prolog for the function. virtual void EmitInstanceFunctionProlog(CodeGenFunction &CGF) = 0; Index: cfe/trunk/lib/CodeGen/CGCXXABI.cpp =================================================================== --- cfe/trunk/lib/CodeGen/CGCXXABI.cpp +++ cfe/trunk/lib/CodeGen/CGCXXABI.cpp @@ -149,12 +149,15 @@ } } -void CGCXXABI::EmitThisParam(CodeGenFunction &CGF) { +llvm::Value *CGCXXABI::loadIncomingCXXThis(CodeGenFunction &CGF) { + return CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(getThisDecl(CGF)), + "this"); +} + +void CGCXXABI::setCXXABIThisValue(CodeGenFunction &CGF, llvm::Value *ThisPtr) { /// Initialize the 'this' slot. assert(getThisDecl(CGF) && "no 'this' variable for function"); - CGF.CXXABIThisValue - = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(getThisDecl(CGF)), - "this"); + CGF.CXXABIThisValue = ThisPtr; } void CGCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF, Index: cfe/trunk/lib/CodeGen/CGDecl.cpp =================================================================== --- cfe/trunk/lib/CodeGen/CGDecl.cpp +++ cfe/trunk/lib/CodeGen/CGDecl.cpp @@ -1796,24 +1796,6 @@ setBlockContextParameter(IPD, ArgNo, Arg.getDirectValue()); return; } - - // Apply any prologue 'this' adjustments required by the ABI. Be careful to - // handle the case where 'this' is passed indirectly as part of an inalloca - // struct. - if (const CXXMethodDecl *MD = - dyn_cast_or_null(CurCodeDecl)) { - if (MD->isVirtual() && IPD == CXXABIThisDecl) { - llvm::Value *This = Arg.isIndirect() - ? Builder.CreateLoad(Arg.getIndirectAddress()) - : Arg.getDirectValue(); - This = CGM.getCXXABI().adjustThisParameterInVirtualFunctionPrologue( - *this, CurGD, This); - if (Arg.isIndirect()) - Builder.CreateStore(This, Arg.getIndirectAddress()); - else - Arg = ParamValue::forDirect(This); - } - } } Address DeclPtr = Address::invalid(); Index: cfe/trunk/lib/CodeGen/ItaniumCXXABI.cpp =================================================================== --- cfe/trunk/lib/CodeGen/ItaniumCXXABI.cpp +++ cfe/trunk/lib/CodeGen/ItaniumCXXABI.cpp @@ -1443,8 +1443,9 @@ if (CGF.CurFuncDecl && CGF.CurFuncDecl->hasAttr()) return; - /// Initialize the 'this' slot. - EmitThisParam(CGF); + /// Initialize the 'this' slot. In the Itanium C++ ABI, no prologue + /// adjustments are required, becuase they are all handled by thunks. + setCXXABIThisValue(CGF, loadIncomingCXXThis(CGF)); /// Initialize the 'vtt' slot if needed. if (getStructorImplicitParamDecl(CGF)) { Index: cfe/trunk/lib/CodeGen/MicrosoftCXXABI.cpp =================================================================== --- cfe/trunk/lib/CodeGen/MicrosoftCXXABI.cpp +++ cfe/trunk/lib/CodeGen/MicrosoftCXXABI.cpp @@ -244,9 +244,6 @@ void addImplicitStructorParams(CodeGenFunction &CGF, QualType &ResTy, FunctionArgList &Params) override; - llvm::Value *adjustThisParameterInVirtualFunctionPrologue( - CodeGenFunction &CGF, GlobalDecl GD, llvm::Value *This) override; - void EmitInstanceFunctionProlog(CodeGenFunction &CGF) override; AddedStructorArgs @@ -1433,50 +1430,54 @@ } } -llvm::Value *MicrosoftCXXABI::adjustThisParameterInVirtualFunctionPrologue( - CodeGenFunction &CGF, GlobalDecl GD, llvm::Value *This) { - // In this ABI, every virtual function takes a pointer to one of the - // subobjects that first defines it as the 'this' parameter, rather than a - // pointer to the final overrider subobject. Thus, we need to adjust it back - // to the final overrider subobject before use. - // See comments in the MicrosoftVFTableContext implementation for the details. - CharUnits Adjustment = getVirtualFunctionPrologueThisAdjustment(GD); - if (Adjustment.isZero()) - return This; - - unsigned AS = cast(This->getType())->getAddressSpace(); - llvm::Type *charPtrTy = CGF.Int8Ty->getPointerTo(AS), - *thisTy = This->getType(); - - This = CGF.Builder.CreateBitCast(This, charPtrTy); - assert(Adjustment.isPositive()); - This = CGF.Builder.CreateConstInBoundsGEP1_32(CGF.Int8Ty, This, - -Adjustment.getQuantity()); - return CGF.Builder.CreateBitCast(This, thisTy); -} - void MicrosoftCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) { // Naked functions have no prolog. if (CGF.CurFuncDecl && CGF.CurFuncDecl->hasAttr()) return; - EmitThisParam(CGF); + // Overridden virtual methods of non-primary bases need to adjust the incoming + // 'this' pointer in the prologue. In this hierarchy, C::b will subtract + // sizeof(void*) to adjust from B* to C*: + // struct A { virtual void a(); }; + // struct B { virtual void b(); }; + // struct C : A, B { virtual void b(); }; + // + // Leave the value stored in the 'this' alloca unadjusted, so that the + // debugger sees the unadjusted value. Microsoft debuggers require this, and + // will apply the ThisAdjustment in the method type information. + // FIXME: Do something better for DWARF debuggers, which won't expect this, + // without making our codegen depend on debug info settings. + llvm::Value *This = loadIncomingCXXThis(CGF); + const CXXMethodDecl *MD = cast(CGF.CurGD.getDecl()); + if (!CGF.CurFuncIsThunk && MD->isVirtual()) { + CharUnits Adjustment = getVirtualFunctionPrologueThisAdjustment(CGF.CurGD); + if (!Adjustment.isZero()) { + unsigned AS = cast(This->getType())->getAddressSpace(); + llvm::Type *charPtrTy = CGF.Int8Ty->getPointerTo(AS), + *thisTy = This->getType(); + This = CGF.Builder.CreateBitCast(This, charPtrTy); + assert(Adjustment.isPositive()); + This = CGF.Builder.CreateConstInBoundsGEP1_32(CGF.Int8Ty, This, + -Adjustment.getQuantity()); + This = CGF.Builder.CreateBitCast(This, thisTy, "this.adjusted"); + } + } + setCXXABIThisValue(CGF, This); - /// If this is a function that the ABI specifies returns 'this', initialize - /// the return slot to 'this' at the start of the function. - /// - /// Unlike the setting of return types, this is done within the ABI - /// implementation instead of by clients of CGCXXABI because: - /// 1) getThisValue is currently protected - /// 2) in theory, an ABI could implement 'this' returns some other way; - /// HasThisReturn only specifies a contract, not the implementation + // If this is a function that the ABI specifies returns 'this', initialize + // the return slot to 'this' at the start of the function. + // + // Unlike the setting of return types, this is done within the ABI + // implementation instead of by clients of CGCXXABI because: + // 1) getThisValue is currently protected + // 2) in theory, an ABI could implement 'this' returns some other way; + // HasThisReturn only specifies a contract, not the implementation if (HasThisReturn(CGF.CurGD)) CGF.Builder.CreateStore(getThisValue(CGF), CGF.ReturnValue); else if (hasMostDerivedReturn(CGF.CurGD)) CGF.Builder.CreateStore(CGF.EmitCastToVoidPtr(getThisValue(CGF)), CGF.ReturnValue); - const CXXMethodDecl *MD = cast(CGF.CurGD.getDecl()); if (isa(MD) && MD->getParent()->getNumVBases()) { assert(getStructorImplicitParamDecl(CGF) && "no implicit parameter for a constructor with virtual bases?"); @@ -1961,7 +1962,7 @@ // Start defining the function. CGF.StartFunction(GlobalDecl(), FnInfo.getReturnType(), ThunkFn, FnInfo, FunctionArgs, MD->getLocation(), SourceLocation()); - EmitThisParam(CGF); + setCXXABIThisValue(CGF, loadIncomingCXXThis(CGF)); // Load the vfptr and then callee from the vftable. The callee should have // adjusted 'this' so that the vfptr is at offset zero. @@ -3900,7 +3901,7 @@ FunctionArgs, CD->getLocation(), SourceLocation()); // Create a scope with an artificial location for the body of this function. auto AL = ApplyDebugLocation::CreateArtificial(CGF); - EmitThisParam(CGF); + setCXXABIThisValue(CGF, loadIncomingCXXThis(CGF)); llvm::Value *This = getThisValue(CGF); llvm::Value *SrcVal = Index: cfe/trunk/test/CodeGenCXX/microsoft-abi-multiple-nonvirtual-inheritance.cpp =================================================================== --- cfe/trunk/test/CodeGenCXX/microsoft-abi-multiple-nonvirtual-inheritance.cpp +++ cfe/trunk/test/CodeGenCXX/microsoft-abi-multiple-nonvirtual-inheritance.cpp @@ -19,7 +19,7 @@ extern "C" void foo(void *); void call_left_no_override(ChildNoOverride *child) { -// CHECK: define void @"\01?call_left_no_override +// CHECK-LABEL: define void @"\01?call_left_no_override // CHECK: %[[CHILD:.*]] = load %struct.ChildNoOverride child->left(); @@ -34,7 +34,8 @@ } void ChildOverride::left() { -// CHECK: define x86_thiscallcc void @"\01?left@ChildOverride@@UAEXXZ"(%struct.ChildOverride* %[[THIS:.*]]) +// CHECK-LABEL: define x86_thiscallcc void @"\01?left@ChildOverride@@UAEXXZ" +// CHECK-SAME: (%struct.ChildOverride* %[[THIS:.*]]) // // No need to adjust 'this' as the ChildOverride's layout begins with Left. // CHECK: %[[THIS_ADDR:.*]] = alloca %struct.ChildOverride*, align 4 @@ -48,7 +49,7 @@ } void call_left_override(ChildOverride *child) { -// CHECK: define void @"\01?call_left_override +// CHECK-LABEL: define void @"\01?call_left_override // CHECK: %[[CHILD:.*]] = load %struct.ChildOverride child->left(); @@ -62,7 +63,7 @@ } void call_right_no_override(ChildNoOverride *child) { -// CHECK: define void @"\01?call_right_no_override +// CHECK-LABEL: define void @"\01?call_right_no_override // CHECK: %[[CHILD:.*]] = load %struct.ChildNoOverride child->right(); @@ -82,25 +83,27 @@ } void ChildOverride::right() { -// CHECK: define x86_thiscallcc void @"\01?right@ChildOverride@@UAEXXZ"(i8* +// CHECK-LABEL: define x86_thiscallcc void @"\01?right@ChildOverride@@UAEXXZ"(i8* // // ChildOverride::right gets 'this' cast to Right* in ECX (i.e. this+4) so we // need to adjust 'this' before use. // // CHECK: %[[THIS_ADDR:.*]] = alloca %struct.ChildOverride*, align 4 -// CHECK: %[[THIS_i8:.*]] = getelementptr inbounds i8, i8* %[[ECX:.*]], i32 -4 -// CHECK: %[[THIS:.*]] = bitcast i8* %[[THIS_i8]] to %struct.ChildOverride* -// CHECK: store %struct.ChildOverride* %[[THIS]], %struct.ChildOverride** %[[THIS_ADDR]], align 4 +// CHECK: %[[THIS_INIT:.*]] = bitcast i8* %[[ECX:.*]] to %struct.ChildOverride* +// CHECK: store %struct.ChildOverride* %[[THIS_INIT]], %struct.ChildOverride** %[[THIS_ADDR]], align 4 +// CHECK: %[[THIS_RELOAD:.*]] = load %struct.ChildOverride*, %struct.ChildOverride** %[[THIS_ADDR]] +// CHECK: %[[THIS_i8:.*]] = bitcast %struct.ChildOverride* %[[THIS_RELOAD]] to i8* +// CHECK: %[[THIS_ADJUSTED:.*]] = getelementptr inbounds i8, i8* %[[THIS_i8]], i32 -4 +// CHECK: %[[THIS:.*]] = bitcast i8* %[[THIS_ADJUSTED]] to %struct.ChildOverride* foo(this); -// CHECK: %[[THIS:.*]] = load %struct.ChildOverride*, %struct.ChildOverride** %[[THIS_ADDR]] // CHECK: %[[THIS_PARAM:.*]] = bitcast %struct.ChildOverride* %[[THIS]] to i8* // CHECK: call void @foo(i8* %[[THIS_PARAM]]) // CHECK: ret } void call_right_override(ChildOverride *child) { -// CHECK: define void @"\01?call_right_override +// CHECK-LABEL: define void @"\01?call_right_override // CHECK: %[[CHILD:.*]] = load %struct.ChildOverride child->right(); @@ -127,15 +130,17 @@ }; void GrandchildOverride::right() { -// CHECK: define x86_thiscallcc void @"\01?right@GrandchildOverride@@UAEXXZ"(i8* +// CHECK-LABEL: define x86_thiscallcc void @"\01?right@GrandchildOverride@@UAEXXZ"(i8* // // CHECK: %[[THIS_ADDR:.*]] = alloca %struct.GrandchildOverride*, align 4 -// CHECK: %[[THIS_i8:.*]] = getelementptr inbounds i8, i8* %[[ECX:.*]], i32 -4 -// CHECK: %[[THIS:.*]] = bitcast i8* %[[THIS_i8]] to %struct.GrandchildOverride* -// CHECK: store %struct.GrandchildOverride* %[[THIS]], %struct.GrandchildOverride** %[[THIS_ADDR]], align 4 +// CHECK: %[[THIS_INIT:.*]] = bitcast i8* %[[ECX:.*]] to %struct.GrandchildOverride* +// CHECK: store %struct.GrandchildOverride* %[[THIS_INIT]], %struct.GrandchildOverride** %[[THIS_ADDR]], align 4 +// CHECK: %[[THIS_RELOAD:.*]] = load %struct.GrandchildOverride*, %struct.GrandchildOverride** %[[THIS_ADDR]] +// CHECK: %[[THIS_i8:.*]] = bitcast %struct.GrandchildOverride* %[[THIS_RELOAD]] to i8* +// CHECK: %[[THIS_ADJUSTED:.*]] = getelementptr inbounds i8, i8* %[[THIS_i8]], i32 -4 +// CHECK: %[[THIS:.*]] = bitcast i8* %[[THIS_ADJUSTED]] to %struct.GrandchildOverride* foo(this); -// CHECK: %[[THIS:.*]] = load %struct.GrandchildOverride*, %struct.GrandchildOverride** %[[THIS_ADDR]] // CHECK: %[[THIS_PARAM:.*]] = bitcast %struct.GrandchildOverride* %[[THIS]] to i8* // CHECK: call void @foo(i8* %[[THIS_PARAM]]) // CHECK: ret @@ -148,19 +153,19 @@ void emit_ctors() { Left l; - // CHECK: define {{.*}} @"\01??0Left@@QAE@XZ" + // CHECK-LABEL: define {{.*}} @"\01??0Left@@QAE@XZ" // CHECK-NOT: getelementptr // CHECK: store i32 (...)** bitcast ({ [1 x i8*] }* @"\01??_7Left@@6B@" to i32 (...)**) // CHECK: ret Right r; - // CHECK: define {{.*}} @"\01??0Right@@QAE@XZ" + // CHECK-LABEL: define {{.*}} @"\01??0Right@@QAE@XZ" // CHECK-NOT: getelementptr // CHECK: store i32 (...)** bitcast ({ [1 x i8*] }* @"\01??_7Right@@6B@" to i32 (...)**) // CHECK: ret ChildOverride co; - // CHECK: define {{.*}} @"\01??0ChildOverride@@QAE@XZ" + // CHECK-LABEL: define {{.*}} @"\01??0ChildOverride@@QAE@XZ" // CHECK: %[[THIS:.*]] = load %struct.ChildOverride*, %struct.ChildOverride** // CHECK: %[[VFPTR:.*]] = bitcast %struct.ChildOverride* %[[THIS]] to i32 (...)*** // CHECK: store i32 (...)** bitcast ({ [1 x i8*] }* @"\01??_7ChildOverride@@6BLeft@@@" to i32 (...)**), i32 (...)*** %[[VFPTR]] @@ -171,7 +176,7 @@ // CHECK: ret GrandchildOverride gc; - // CHECK: define {{.*}} @"\01??0GrandchildOverride@@QAE@XZ" + // CHECK-LABEL: define {{.*}} @"\01??0GrandchildOverride@@QAE@XZ" // CHECK: %[[THIS:.*]] = load %struct.GrandchildOverride*, %struct.GrandchildOverride** // CHECK: %[[VFPTR:.*]] = bitcast %struct.GrandchildOverride* %[[THIS]] to i32 (...)*** // CHECK: store i32 (...)** bitcast ({ [1 x i8*] }* @"\01??_7GrandchildOverride@@6BLeft@@@" to i32 (...)**), i32 (...)*** %[[VFPTR]] Index: cfe/trunk/test/CodeGenCXX/microsoft-abi-virtual-inheritance-vtordisps.cpp =================================================================== --- cfe/trunk/test/CodeGenCXX/microsoft-abi-virtual-inheritance-vtordisps.cpp +++ cfe/trunk/test/CodeGenCXX/microsoft-abi-virtual-inheritance-vtordisps.cpp @@ -24,6 +24,7 @@ D::D() {} // Forces vftable emission. // CHECK-LABEL: define linkonce_odr x86_thiscallcc void @"\01?f@D@@$4PPPPPPPM@A@AEXXZ" +// Note that the vtordisp is applied before really adjusting to D*. // CHECK: %[[ECX:.*]] = load %struct.D*, %struct.D** %{{.*}} // CHECK: %[[ECX_i8:.*]] = bitcast %struct.D* %[[ECX]] to i8* // CHECK: %[[VTORDISP_PTR_i8:.*]] = getelementptr inbounds i8, i8* %[[ECX_i8]], i32 -4 Index: cfe/trunk/test/CodeGenCXX/microsoft-abi-virtual-inheritance.cpp =================================================================== --- cfe/trunk/test/CodeGenCXX/microsoft-abi-virtual-inheritance.cpp +++ cfe/trunk/test/CodeGenCXX/microsoft-abi-virtual-inheritance.cpp @@ -1,9 +1,9 @@ -// RUN: %clang_cc1 %s -fno-rtti -triple=i386-pc-win32 -emit-llvm -o %t +// RUN: %clang_cc1 %s -fno-rtti -std=c++11 -Wno-inaccessible-base -triple=i386-pc-win32 -emit-llvm -o %t // RUN: FileCheck %s < %t // RUN: FileCheck --check-prefix=CHECK2 %s < %t // For now, just make sure x86_64 doesn't crash. -// RUN: %clang_cc1 %s -fno-rtti -triple=x86_64-pc-win32 -emit-llvm -o %t +// RUN: %clang_cc1 %s -fno-rtti -std=c++11 -Wno-inaccessible-base -triple=x86_64-pc-win32 -emit-llvm -o %t struct VBase { virtual ~VBase(); @@ -52,12 +52,14 @@ B::~B() { // CHECK-LABEL: define x86_thiscallcc void @"\01??1B@@UAE@XZ" - // Adjust the this parameter: - // CHECK: %[[THIS_PARAM_i8:.*]] = bitcast %struct.B* {{.*}} to i8* - // CHECK: %[[THIS_i8:.*]] = getelementptr inbounds i8, i8* %[[THIS_PARAM_i8]], i32 -8 - // CHECK: %[[THIS:.*]] = bitcast i8* %[[THIS_i8]] to %struct.B* - // CHECK: store %struct.B* %[[THIS]], %struct.B** %[[THIS_ADDR:.*]], align 4 - // CHECK: %[[THIS:.*]] = load %struct.B*, %struct.B** %[[THIS_ADDR]] + // Store initial this: + // CHECK: %[[THIS_ADDR:.*]] = alloca %struct.B* + // CHECK: store %struct.B* %{{.*}}, %struct.B** %[[THIS_ADDR]], align 4 + // Reload and adjust the this parameter: + // CHECK: %[[THIS_RELOAD:.*]] = load %struct.B*, %struct.B** %[[THIS_ADDR]] + // CHECK: %[[THIS_UNADJ_i8:.*]] = bitcast %struct.B* %[[THIS_RELOAD]] to i8* + // CHECK: %[[THIS_ADJ_i8:.*]] = getelementptr inbounds i8, i8* %[[THIS_UNADJ_i8]], i32 -8 + // CHECK: %[[THIS:.*]] = bitcast i8* %[[THIS_ADJ_i8]] to %struct.B* // Restore the vfptr that could have been changed by a subclass. // CHECK: %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8* @@ -97,11 +99,11 @@ // CHECK2: ret // CHECK2-LABEL: define linkonce_odr x86_thiscallcc i8* @"\01??_GB@@UAEPAXI@Z" - // CHECK2: %[[THIS_PARAM_i8:.*]] = bitcast %struct.B* {{.*}} to i8* + // CHECK2: store %struct.B* %{{.*}}, %struct.B** %[[THIS_ADDR:.*]], align 4 + // CHECK2: %[[THIS:.*]] = load %struct.B*, %struct.B** %[[THIS_ADDR]] + // CHECK2: %[[THIS_PARAM_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8* // CHECK2: %[[THIS_i8:.*]] = getelementptr inbounds i8, i8* %[[THIS_PARAM_i8:.*]], i32 -8 // CHECK2: %[[THIS:.*]] = bitcast i8* %[[THIS_i8]] to %struct.B* - // CHECK2: store %struct.B* %[[THIS]], %struct.B** %[[THIS_ADDR:.*]], align 4 - // CHECK2: %[[THIS:.*]] = load %struct.B*, %struct.B** %[[THIS_ADDR]] // CHECK2: call x86_thiscallcc void @"\01??_DB@@QAEXXZ"(%struct.B* %[[THIS]]) // ... // CHECK2: ret @@ -113,13 +115,17 @@ // B::foo gets 'this' cast to VBase* in ECX (i.e. this+8) so we // need to adjust 'this' before use. // -// CHECK: %[[THIS_ADDR:.*]] = alloca %struct.B*, align 4 -// CHECK: %[[THIS_i8:.*]] = getelementptr inbounds i8, i8* %[[ECX:.*]], i32 -8 -// CHECK: %[[THIS:.*]] = bitcast i8* %[[THIS_i8]] to %struct.B* -// CHECK: store %struct.B* %[[THIS]], %struct.B** %[[THIS_ADDR]], align 4 +// Store initial this: +// CHECK: %[[THIS_ADDR:.*]] = alloca %struct.B* +// CHECK: store %struct.B* %{{.*}}, %struct.B** %[[THIS_ADDR]], align 4 +// +// Reload and adjust the this parameter: +// CHECK: %[[THIS_RELOAD:.*]] = load %struct.B*, %struct.B** %[[THIS_ADDR]] +// CHECK: %[[THIS_UNADJ_i8:.*]] = bitcast %struct.B* %[[THIS_RELOAD]] to i8* +// CHECK: %[[THIS_ADJ_i8:.*]] = getelementptr inbounds i8, i8* %[[THIS_UNADJ_i8]], i32 -8 +// CHECK: %[[THIS:.*]] = bitcast i8* %[[THIS_ADJ_i8]] to %struct.B* field = 42; -// CHECK: %[[THIS:.*]] = load %struct.B*, %struct.B** %[[THIS_ADDR]] // CHECK: %[[THIS8:.*]] = bitcast %struct.B* %[[THIS]] to i8* // CHECK: %[[VBPTR:.*]] = getelementptr inbounds i8, i8* %[[THIS8]], i32 0 // CHECK: %[[VBPTR8:.*]] = bitcast i8* %[[VBPTR]] to i32** @@ -284,11 +290,16 @@ D::~D() { // CHECK-LABEL: define x86_thiscallcc void @"\01??1D@diamond@@UAE@XZ"(%"struct.diamond::D"*{{.*}}) - // CHECK: %[[ARG_i8:.*]] = bitcast %"struct.diamond::D"* %{{.*}} to i8* - // CHECK: %[[THIS_i8:.*]] = getelementptr inbounds i8, i8* %[[ARG_i8]], i32 -24 - // CHECK: %[[THIS:.*]] = bitcast i8* %[[THIS_i8]] to %"struct.diamond::D"* - // CHECK: store %"struct.diamond::D"* %[[THIS]], %"struct.diamond::D"** %[[THIS_VAL:.*]], align 4 - // CHECK: %[[THIS:.*]] = load %"struct.diamond::D"*, %"struct.diamond::D"** %[[THIS_VAL]] + // Store initial this: + // CHECK: %[[THIS_ADDR:.*]] = alloca %"struct.diamond::D"* + // CHECK: store %"struct.diamond::D"* %{{.*}}, %"struct.diamond::D"** %[[THIS_ADDR]], align 4 + // + // Reload and adjust the this parameter: + // CHECK: %[[THIS_RELOAD:.*]] = load %"struct.diamond::D"*, %"struct.diamond::D"** %[[THIS_ADDR]] + // CHECK: %[[THIS_UNADJ_i8:.*]] = bitcast %"struct.diamond::D"* %[[THIS_RELOAD]] to i8* + // CHECK: %[[THIS_ADJ_i8:.*]] = getelementptr inbounds i8, i8* %[[THIS_UNADJ_i8]], i32 -24 + // CHECK: %[[THIS:.*]] = bitcast i8* %[[THIS_ADJ_i8]] to %"struct.diamond::D"* + // // CHECK: %[[D_i8:.*]] = bitcast %"struct.diamond::D"* %[[THIS]] to i8* // CHECK: %[[C_i8:.*]] = getelementptr inbounds i8, i8* %[[D_i8]], i32 4 // CHECK: %[[C:.*]] = bitcast i8* %[[C_i8]] to %"struct.diamond::C"* Index: cfe/trunk/test/CodeGenCXX/microsoft-abi-vtables-multiple-nonvirtual-inheritance-this-adjustment.cpp =================================================================== --- cfe/trunk/test/CodeGenCXX/microsoft-abi-vtables-multiple-nonvirtual-inheritance-this-adjustment.cpp +++ cfe/trunk/test/CodeGenCXX/microsoft-abi-vtables-multiple-nonvirtual-inheritance-this-adjustment.cpp @@ -196,7 +196,11 @@ } // BITCODE-LABEL: define void @"\01?g@C@pr30293@@UAAXUNonTrivial@2@@Z"(<{ i8*, %"struct.pr30293::NonTrivial" }>* inalloca) -// BITCODE: %[[this1:[^ ]*]] = load i8*, i8** %[[thisaddr:[^ ]*]], align 4 -// BITCODE-NEXT: %[[this2:[^ ]*]] = getelementptr inbounds i8, i8* %[[this1]], i32 -4 -// BITCODE-NEXT: store i8* %[[this2]], i8** %[[thisaddr]], align 4 +// BITCODE: %[[thisaddr:[^ ]*]] = getelementptr inbounds <{ i8*, %"struct.pr30293::NonTrivial" }>, <{ i8*, %"struct.pr30293::NonTrivial" }>* {{.*}}, i32 0, i32 0 +// BITCODE: %[[thisaddr1:[^ ]*]] = bitcast i8** %[[thisaddr]] to %"struct.pr30293::C"** +// BITCODE: %[[this1:[^ ]*]] = load %"struct.pr30293::C"*, %"struct.pr30293::C"** %[[thisaddr1]], align 4 +// BITCODE: %[[this2:[^ ]*]] = bitcast %"struct.pr30293::C"* %[[this1]] to i8* +// BITCODE: %[[this3:[^ ]*]] = getelementptr inbounds i8, i8* %[[this2]], i32 -4 +// BITCODE: %[[this4:[^ ]*]] = bitcast i8* %[[this3]] to %"struct.pr30293::C"* +// BITCODE: store %"struct.pr30293::C"* %[[this4]], %"struct.pr30293::C"** @"\01?whatsthis@pr30293@@3PAUC@1@A", align 4 }