From: Craig Topper Date: Fri, 26 Jul 2013 06:16:11 +0000 (+0000) Subject: Remove trailing whitespace. X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=d10e5c2e5c1f74620c0a0e312389855ce82df1a5;p=clang Remove trailing whitespace. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@187190 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/CodeGen/CGExprScalar.cpp b/lib/CodeGen/CGExprScalar.cpp index 7d98764548..f34b913c7a 100644 --- a/lib/CodeGen/CGExprScalar.cpp +++ b/lib/CodeGen/CGExprScalar.cpp @@ -161,18 +161,18 @@ public: Value *Visit(Expr *E) { return StmtVisitor::Visit(E); } - + Value *VisitStmt(Stmt *S) { S->dump(CGF.getContext().getSourceManager()); llvm_unreachable("Stmt can't have complex result type!"); } Value *VisitExpr(Expr *S); - + Value *VisitParenExpr(ParenExpr *PE) { - return Visit(PE->getSubExpr()); + return Visit(PE->getSubExpr()); } Value *VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E) { - return Visit(E->getReplacement()); + return Visit(E->getReplacement()); } Value *VisitGenericSelectionExpr(GenericSelectionExpr *GE) { return Visit(GE->getResultExpr()); @@ -243,7 +243,7 @@ public: return EmitLoadOfLValue(E); } Value *VisitObjCMessageExpr(ObjCMessageExpr *E) { - if (E->getMethodDecl() && + if (E->getMethodDecl() && E->getMethodDecl()->getResultType()->isReferenceType()) return EmitLoadOfLValue(E); return CGF.EmitObjCMessageExpr(E).getScalarVal(); @@ -310,7 +310,7 @@ public: llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, bool isInc, bool isPre); - + Value *VisitUnaryAddrOf(const UnaryOperator *E) { if (isa(E->getType())) // never sugared return CGF.CGM.getMemberPointerConstant(E); @@ -335,12 +335,12 @@ public: Value *VisitUnaryExtension(const UnaryOperator *E) { return Visit(E->getSubExpr()); } - + // C++ Value *VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E) { return EmitLoadOfLValue(E); } - + Value *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { return Visit(DAE->getExpr()); } @@ -430,7 +430,7 @@ public: Value *EmitOverflowCheckedBinOp(const BinOpInfo &Ops); // Check for undefined division and modulus behaviors. - void EmitUndefinedBehaviorIntegerDivAndRemCheck(const BinOpInfo &Ops, + void EmitUndefinedBehaviorIntegerDivAndRemCheck(const BinOpInfo &Ops, llvm::Value *Zero,bool isDiv); // Common helper for getting how wide LHS of shift is. static Value *GetWidthMinusOneValue(Value* LHS,Value* RHS); @@ -893,35 +893,35 @@ Value *ScalarExprEmitter::VisitExpr(Expr *E) { Value *ScalarExprEmitter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { // Vector Mask Case - if (E->getNumSubExprs() == 2 || + if (E->getNumSubExprs() == 2 || (E->getNumSubExprs() == 3 && E->getExpr(2)->getType()->isVectorType())) { Value *LHS = CGF.EmitScalarExpr(E->getExpr(0)); Value *RHS = CGF.EmitScalarExpr(E->getExpr(1)); Value *Mask; - + llvm::VectorType *LTy = cast(LHS->getType()); unsigned LHSElts = LTy->getNumElements(); if (E->getNumSubExprs() == 3) { Mask = CGF.EmitScalarExpr(E->getExpr(2)); - + // Shuffle LHS & RHS into one input vector. SmallVector concat; for (unsigned i = 0; i != LHSElts; ++i) { concat.push_back(Builder.getInt32(2*i)); concat.push_back(Builder.getInt32(2*i+1)); } - + Value* CV = llvm::ConstantVector::get(concat); LHS = Builder.CreateShuffleVector(LHS, RHS, CV, "concat"); LHSElts *= 2; } else { Mask = RHS; } - + llvm::VectorType *MTy = cast(Mask->getType()); llvm::Constant* EltMask; - + // Treat vec3 like vec4. if ((LHSElts == 6) && (E->getNumSubExprs() == 3)) EltMask = llvm::ConstantInt::get(MTy->getElementType(), @@ -932,12 +932,12 @@ Value *ScalarExprEmitter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { else EltMask = llvm::ConstantInt::get(MTy->getElementType(), (1 << llvm::Log2_32(LHSElts))-1); - + // Mask off the high bits of each shuffle index. Value *MaskBits = llvm::ConstantVector::getSplat(MTy->getNumElements(), EltMask); Mask = Builder.CreateAnd(Mask, MaskBits, "mask"); - + // newv = undef // mask = mask & maskbits // for each elt @@ -951,7 +951,7 @@ Value *ScalarExprEmitter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { Value *IIndx = Builder.getInt32(i); Value *Indx = Builder.CreateExtractElement(Mask, IIndx, "shuf_idx"); Indx = Builder.CreateZExt(Indx, CGF.Int32Ty, "idx_zext"); - + // Handle vec3 special since the index will be off by one for the RHS. if ((LHSElts == 6) && (E->getNumSubExprs() == 3)) { Value *cmpIndx, *newIndx; @@ -965,10 +965,10 @@ Value *ScalarExprEmitter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { } return NewV; } - + Value* V1 = CGF.EmitScalarExpr(E->getExpr(0)); Value* V2 = CGF.EmitScalarExpr(E->getExpr(1)); - + // Handle vec3 special since the index will be off by one for the RHS. llvm::VectorType *VTy = cast(V1->getType()); SmallVector indices; @@ -1022,7 +1022,7 @@ Value *ScalarExprEmitter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { static llvm::Constant *getMaskElt(llvm::ShuffleVectorInst *SVI, unsigned Idx, unsigned Off, llvm::Type *I32Ty) { int MV = SVI->getMaskValue(Idx); - if (MV == -1) + if (MV == -1) return llvm::UndefValue::get(I32Ty); return llvm::ConstantInt::get(I32Ty, Off+MV); } @@ -1032,13 +1032,13 @@ Value *ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) { (void)Ignore; assert (Ignore == false && "init list ignored"); unsigned NumInitElements = E->getNumInits(); - + if (E->hadArrayRangeDesignator()) CGF.ErrorUnsupported(E, "GNU array range designator extension"); - + llvm::VectorType *VType = dyn_cast(ConvertType(E->getType())); - + if (!VType) { if (NumInitElements == 0) { // C++11 value-initialization for the scalar. @@ -1047,10 +1047,10 @@ Value *ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) { // We have a scalar in braces. Just use the first element. return Visit(E->getInit(0)); } - + unsigned ResElts = VType->getNumElements(); - - // Loop over initializers collecting the Value for each, and remembering + + // Loop over initializers collecting the Value for each, and remembering // whether the source was swizzle (ExtVectorElementExpr). This will allow // us to fold the shuffle for the swizzle into the shuffle for the vector // initializer, since LLVM optimizers generally do not want to touch @@ -1062,11 +1062,11 @@ Value *ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) { Expr *IE = E->getInit(i); Value *Init = Visit(IE); SmallVector Args; - + llvm::VectorType *VVT = dyn_cast(Init->getType()); - + // Handle scalar elements. If the scalar initializer is actually one - // element of a different vector of the same width, use shuffle instead of + // element of a different vector of the same width, use shuffle instead of // extract+insert. if (!VVT) { if (isa(IE)) { @@ -1109,10 +1109,10 @@ Value *ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) { ++CurIdx; continue; } - + unsigned InitElts = VVT->getNumElements(); - // If the initializer is an ExtVecEltExpr (a swizzle), and the swizzle's + // If the initializer is an ExtVecEltExpr (a swizzle), and the swizzle's // input is the same width as the vector being constructed, generate an // optimized shuffle of the swizzle input into the result. unsigned Offset = (CurIdx == 0) ? 0 : ResElts; @@ -1120,7 +1120,7 @@ Value *ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) { llvm::ShuffleVectorInst *SVI = cast(Init); Value *SVOp = SVI->getOperand(0); llvm::VectorType *OpTy = cast(SVOp->getType()); - + if (OpTy->getNumElements() == ResElts) { for (unsigned j = 0; j != CurIdx; ++j) { // If the current vector initializer is a shuffle with undef, merge @@ -1170,11 +1170,11 @@ Value *ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) { VIsUndefShuffle = isa(Init); CurIdx += InitElts; } - + // FIXME: evaluate codegen vs. shuffling against constant null vector. // Emit remaining default initializers. llvm::Type *EltTy = VType->getElementType(); - + // Emit remaining default initializers for (/* Do not initialize i*/; CurIdx < ResElts; ++CurIdx) { Value *Idx = Builder.getInt32(CurIdx); @@ -1189,12 +1189,12 @@ static bool ShouldNullCheckClassCastValue(const CastExpr *CE) { if (CE->getCastKind() == CK_UncheckedDerivedToBase) return false; - + if (isa(E)) { // We always assume that 'this' is never null. return false; } - + if (const ImplicitCastExpr *ICE = dyn_cast(CE)) { // And that glvalue casts are never null. if (ICE->getValueKind() != VK_RValue) @@ -1211,7 +1211,7 @@ Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) { Expr *E = CE->getSubExpr(); QualType DestTy = CE->getType(); CastKind Kind = CE->getCastKind(); - + if (!DestTy->isVoidType()) TestAndClearIgnoreResultAssign(); @@ -1223,10 +1223,10 @@ Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) { case CK_BuiltinFnToFnPtr: llvm_unreachable("builtin functions are handled elsewhere"); - case CK_LValueBitCast: + case CK_LValueBitCast: case CK_ObjCObjectLValueCast: { Value *V = EmitLValue(E).getAddress(); - V = Builder.CreateBitCast(V, + V = Builder.CreateBitCast(V, ConvertType(CGF.getContext().getPointerType(DestTy))); return EmitLoadOfLValue(CGF.MakeNaturalAlignAddrLValue(V, DestTy)); } @@ -1266,7 +1266,7 @@ Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) { E->getType()->getPointeeCXXRecordDecl(); assert(DerivedClassDecl && "DerivedToBase arg isn't a C++ object pointer!"); - return CGF.GetAddressOfBaseClass(Visit(E), DerivedClassDecl, + return CGF.GetAddressOfBaseClass(Visit(E), DerivedClassDecl, CE->path_begin(), CE->path_end(), ShouldNullCheckClassCastValue(CE)); } @@ -1318,7 +1318,7 @@ Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) { case CK_BaseToDerivedMemberPointer: case CK_DerivedToBaseMemberPointer: { Value *Src = Visit(E); - + // Note that the AST doesn't distinguish between checked and // unchecked member pointer conversions, so we always have to // implement checked conversions here. This is inefficient when @@ -1342,7 +1342,7 @@ Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) { case CK_CopyAndAutoreleaseBlockObject: return CGF.EmitBlockCopyAndAutorelease(Visit(E), E->getType()); - + case CK_FloatingRealToComplex: case CK_FloatingComplexCast: case CK_IntegralRealToComplex: @@ -1469,7 +1469,7 @@ EmitAddConsiderOverflowBehavior(const UnaryOperator *E, llvm::Value * ScalarExprEmitter::EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, bool isInc, bool isPre) { - + QualType type = E->getSubExpr()->getType(); llvm::PHINode *atomicPHI = 0; llvm::Value *value; @@ -1495,7 +1495,7 @@ ScalarExprEmitter::EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, } // Special case for atomic increment / decrement on integers, emit // atomicrmw instructions. We skip this if we want to be doing overflow - // checking, and fall into the slow path with the atomic cmpxchg loop. + // checking, and fall into the slow path with the atomic cmpxchg loop. if (!type->isBooleanType() && type->isIntegerType() && !(type->isUnsignedIntegerType() && CGF.SanOpts->UnsignedIntegerOverflow) && @@ -1561,7 +1561,7 @@ ScalarExprEmitter::EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, value = EmitOverflowCheckedBinOp(BinOp); } else value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec"); - + // Next most common: pointer increment. } else if (const PointerType *ptr = type->getAs()) { QualType type = ptr->getPointeeType(); @@ -1575,7 +1575,7 @@ ScalarExprEmitter::EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, value = Builder.CreateGEP(value, numElts, "vla.inc"); else value = Builder.CreateInBoundsGEP(value, numElts, "vla.inc"); - + // Arithmetic on function pointers (!) is just +-1. } else if (type->isFunctionType()) { llvm::Value *amt = Builder.getInt32(amount); @@ -1657,7 +1657,7 @@ ScalarExprEmitter::EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, value = Builder.CreateInBoundsGEP(value, sizeValue, "incdec.objptr"); value = Builder.CreateBitCast(value, input->getType()); } - + if (atomicPHI) { llvm::BasicBlock *opBB = Builder.GetInsertBlock(); llvm::BasicBlock *contBB = CGF.createBasicBlock("atomic_cont", CGF.CurFn); @@ -1688,10 +1688,10 @@ Value *ScalarExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { // Emit unary minus with EmitSub so we handle overflow cases etc. BinOpInfo BinOp; BinOp.RHS = Visit(E->getSubExpr()); - + if (BinOp.RHS->getType()->isFPOrFPVectorTy()) BinOp.LHS = llvm::ConstantFP::getZeroValueForNegation(BinOp.RHS->getType()); - else + else BinOp.LHS = llvm::Constant::getNullValue(BinOp.RHS->getType()); BinOp.Ty = E->getType(); BinOp.Opcode = BO_Sub; @@ -1718,7 +1718,7 @@ Value *ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) { Result = Builder.CreateICmp(llvm::CmpInst::ICMP_EQ, Oper, Zero, "cmp"); return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext"); } - + // Compare operand to zero. Value *BoolVal = CGF.EvaluateExprAsBool(E->getSubExpr()); @@ -1806,7 +1806,7 @@ Value *ScalarExprEmitter::VisitOffsetOfExpr(OffsetOfExpr *E) { // Save the element type. CurrentType = ON.getBase()->getType(); - + // Compute the offset to the base. const RecordType *BaseRT = CurrentType->getAs(); CXXRecordDecl *BaseRD = cast(BaseRT->getDecl()); @@ -1918,10 +1918,10 @@ LValue ScalarExprEmitter::EmitCompoundAssignLValue( Value *&Result) { QualType LHSTy = E->getLHS()->getType(); BinOpInfo OpInfo; - + if (E->getComputationResultType()->isAnyComplexType()) return CGF.EmitScalarCompooundAssignWithComplex(E, Result); - + // Emit the RHS first. __block variables need to have the rhs evaluated // first, plus this should improve codegen a little. OpInfo.RHS = Visit(E->getRHS()); @@ -1994,7 +1994,7 @@ LValue ScalarExprEmitter::EmitCompoundAssignLValue( // Expand the binary operator. Result = (this->*Func)(OpInfo); - + // Convert the result back to the LHS type. Result = EmitScalarConversion(Result, E->getComputationResultType(), LHSTy); @@ -2009,7 +2009,7 @@ LValue ScalarExprEmitter::EmitCompoundAssignLValue( Builder.SetInsertPoint(contBB); return LHSLV; } - + // Store the result value into the LHS lvalue. Bit-fields are handled // specially because the result is altered by the store, i.e., [C99 6.5.16p1] // 'An assignment expression has the value of the left operand after the @@ -2221,7 +2221,7 @@ static Value *emitPointerArithmetic(CodeGenFunction &CGF, // Must have binary (not unary) expr here. Unary pointer // increment/decrement doesn't use this path. const BinaryOperator *expr = cast(op.E); - + Value *pointer = op.LHS; Expr *pointerOperand = expr->getLHS(); Value *index = op.RHS; @@ -2310,7 +2310,7 @@ static Value* buildFMulAdd(llvm::BinaryOperator *MulOp, Value *Addend, const CodeGenFunction &CGF, CGBuilderTy &Builder, bool negMul, bool negAdd) { assert(!(negMul && negAdd) && "Only one of negMul and negAdd should be set."); - + Value *MulOp0 = MulOp->getOperand(0); Value *MulOp1 = MulOp->getOperand(1); if (negMul) { @@ -2340,7 +2340,7 @@ static Value* buildFMulAdd(llvm::BinaryOperator *MulOp, Value *Addend, // Checks that (a) the operation is fusable, and (b) -ffp-contract=on. // Does NOT check the type of the operation - it's assumed that this function // will be called from contexts where it's known that the type is contractable. -static Value* tryEmitFMulAdd(const BinOpInfo &op, +static Value* tryEmitFMulAdd(const BinOpInfo &op, const CodeGenFunction &CGF, CGBuilderTy &Builder, bool isSub=false) { @@ -2488,7 +2488,7 @@ Value *ScalarExprEmitter::EmitSub(const BinOpInfo &op) { divisor = CGF.CGM.getSize(elementSize); } - + // Otherwise, do a full sdiv. This uses the "exact" form of sdiv, since // pointer difference in C is only defined in the case where both operands // are pointing to elements of an array. @@ -2813,9 +2813,9 @@ Value *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) { Value *And = Builder.CreateAnd(LHS, RHS); return Builder.CreateSExt(And, ConvertType(E->getType()), "sext"); } - + llvm::Type *ResTy = ConvertType(E->getType()); - + // If we have 0 && RHS, see if we can elide RHS, if so, just return 0. // If we have 1 && X, just emit X without inserting the control flow. bool LHSCondVal; @@ -2884,9 +2884,9 @@ Value *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) { Value *Or = Builder.CreateOr(LHS, RHS); return Builder.CreateSExt(Or, ConvertType(E->getType()), "sext"); } - + llvm::Type *ResTy = ConvertType(E->getType()); - + // If we have 1 || RHS, see if we can elide RHS, if so, just return 1. // If we have 0 || X, just emit X without inserting the control flow. bool LHSCondVal; @@ -3008,26 +3008,26 @@ VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) { // OpenCL: If the condition is a vector, we can treat this condition like // the select function. - if (CGF.getLangOpts().OpenCL + if (CGF.getLangOpts().OpenCL && condExpr->getType()->isVectorType()) { llvm::Value *CondV = CGF.EmitScalarExpr(condExpr); llvm::Value *LHS = Visit(lhsExpr); llvm::Value *RHS = Visit(rhsExpr); - + llvm::Type *condType = ConvertType(condExpr->getType()); llvm::VectorType *vecTy = cast(condType); - - unsigned numElem = vecTy->getNumElements(); + + unsigned numElem = vecTy->getNumElements(); llvm::Type *elemType = vecTy->getElementType(); - + llvm::Value *zeroVec = llvm::Constant::getNullValue(vecTy); llvm::Value *TestMSB = Builder.CreateICmpSLT(CondV, zeroVec); - llvm::Value *tmp = Builder.CreateSExt(TestMSB, + llvm::Value *tmp = Builder.CreateSExt(TestMSB, llvm::VectorType::get(elemType, - numElem), + numElem), "sext"); llvm::Value *tmp2 = Builder.CreateNot(tmp); - + // Cast float to int to perform ANDs if necessary. llvm::Value *RHSTmp = RHS; llvm::Value *LHSTmp = LHS; @@ -3038,7 +3038,7 @@ VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) { LHSTmp = Builder.CreateBitCast(LHS, tmp->getType()); wasCast = true; } - + llvm::Value *tmp3 = Builder.CreateAnd(RHSTmp, tmp2); llvm::Value *tmp4 = Builder.CreateAnd(LHSTmp, tmp); llvm::Value *tmp5 = Builder.CreateOr(tmp3, tmp4, "cond"); @@ -3047,7 +3047,7 @@ VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) { return tmp5; } - + // If this is a really simple expression (like x ? 4 : 5), emit this as a // select instead of as control flow. We can only do this if it is cheap and // safe to evaluate the LHS and RHS unconditionally. @@ -3123,49 +3123,49 @@ Value *ScalarExprEmitter::VisitBlockExpr(const BlockExpr *block) { Value *ScalarExprEmitter::VisitAsTypeExpr(AsTypeExpr *E) { Value *Src = CGF.EmitScalarExpr(E->getSrcExpr()); llvm::Type *DstTy = ConvertType(E->getType()); - + // Going from vec4->vec3 or vec3->vec4 is a special case and requires // a shuffle vector instead of a bitcast. llvm::Type *SrcTy = Src->getType(); if (isa(DstTy) && isa(SrcTy)) { unsigned numElementsDst = cast(DstTy)->getNumElements(); unsigned numElementsSrc = cast(SrcTy)->getNumElements(); - if ((numElementsDst == 3 && numElementsSrc == 4) + if ((numElementsDst == 3 && numElementsSrc == 4) || (numElementsDst == 4 && numElementsSrc == 3)) { - - + + // In the case of going from int4->float3, a bitcast is needed before // doing a shuffle. - llvm::Type *srcElemTy = + llvm::Type *srcElemTy = cast(SrcTy)->getElementType(); - llvm::Type *dstElemTy = + llvm::Type *dstElemTy = cast(DstTy)->getElementType(); - + if ((srcElemTy->isIntegerTy() && dstElemTy->isFloatTy()) || (srcElemTy->isFloatTy() && dstElemTy->isIntegerTy())) { // Create a float type of the same size as the source or destination. llvm::VectorType *newSrcTy = llvm::VectorType::get(dstElemTy, numElementsSrc); - + Src = Builder.CreateBitCast(Src, newSrcTy, "astypeCast"); } - + llvm::Value *UnV = llvm::UndefValue::get(Src->getType()); - + SmallVector Args; Args.push_back(Builder.getInt32(0)); Args.push_back(Builder.getInt32(1)); Args.push_back(Builder.getInt32(2)); - + if (numElementsDst == 4) Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); - + llvm::Constant *Mask = llvm::ConstantVector::get(Args); - + return Builder.CreateShuffleVector(Src, UnV, Mask, "astype"); } } - + return Builder.CreateBitCast(Src, DstTy, "astype"); } @@ -3240,7 +3240,7 @@ LValue CodeGenFunction::EmitObjCIsaExpr(const ObjCIsaExpr *E) { else V = EmitLValue(BaseExpr).getAddress(); } - + // build Class* type ClassPtrTy = ClassPtrTy->getPointerTo(); V = Builder.CreateBitCast(V, ClassPtrTy); @@ -3268,7 +3268,7 @@ LValue CodeGenFunction::EmitCompoundAssignmentLValue( COMPOUND_OP(Xor); COMPOUND_OP(Or); #undef COMPOUND_OP - + case BO_PtrMemD: case BO_PtrMemI: case BO_Mul: @@ -3293,6 +3293,6 @@ LValue CodeGenFunction::EmitCompoundAssignmentLValue( case BO_Comma: llvm_unreachable("Not valid compound assignment operators"); } - + llvm_unreachable("Unhandled compound assignment operator"); }