[clang][CodeGen] Handle throw expression in conditional operator constant folding

[tambre]

Summary

We're smart and do constant folding when emitting conditional operators.
Thus we emit the live value as a lvalue. This doesn't work if the live value is a throw expression.
Handle this by emitting the throw and returning the dead value as the lvalue.

Fixes PR28184.

[tambre]

Fix formatting

[rsmith]

clang/lib/CodeGen/CGExpr.cpp

4337

The IR we emit for the dead operand is unreachable; it's a bit wasteful to generate it here and (hopefully!) leave it to the optimizer to remove it again. Perhaps we could produce an undef lvalue instead? See CodeGenFunction::EmitUnsupportedLValue for an example of how to build such a value.

clang/test/CodeGenCXX/throw-expressions.cpp

84–87

Please add some CHECKs in here to make sure we actually emit a call to __cxa_throw.

[tambre]

Emit undef lvalue, add throw CHECK to test

[tambre]

clang/lib/CodeGen/CGExpr.cpp

4337

Done.

clang/test/CodeGenCXX/throw-expressions.cpp

84–87

Done.

[rsmith]

Looks good (with the comment suitably tweaked). Thanks!

clang/lib/CodeGen/CGExpr.cpp

4334

Comment doesn't match the code any more.

[tambre]

Update comment

[tambre]

Updated the comment.

Please commit this for me, as I lack commit privileges.

clang/lib/CodeGen/CGExpr.cpp

 //===--- CGExpr.cpp - Emit LLVM Code from Expressions ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
EmitConditionalOperatorLValue(const AbstractConditionalOperator *expr) {
   if (ConstantFoldsToSimpleInteger(condExpr, CondExprBool)) {
     const Expr *live = expr->getTrueExpr(), *dead = expr->getFalseExpr();
     if (!CondExprBool) std::swap(live, dead);
 
     if (!ContainsLabel(dead)) {
       // If the true case is live, we need to track its region.
       if (CondExprBool)
         incrementProfileCounter(expr);
+      // If a throw expression we need to return dead as lvalue.
+      if (auto *ThrowExpr = dyn_cast<CXXThrowExpr>(live->IgnoreParens())) {
+        EmitCXXThrowExpr(ThrowExpr);
+        llvm::Type *Ty =
+            llvm::PointerType::getUnqual(ConvertType(dead->getType()));
+        return MakeAddrLValue(
+            Address(llvm::UndefValue::get(Ty), CharUnits::One()),
+            dead->getType());
+      }
       return EmitLValue(live);
     }
   }
 
   llvm::BasicBlock *lhsBlock = createBasicBlock("cond.true");
   llvm::BasicBlock *rhsBlock = createBasicBlock("cond.false");
   llvm::BasicBlock *contBlock = createBasicBlock("cond.end");
 

clang/test/CodeGenCXX/throw-expressions.cpp

 // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -Wno-unreachable-code -Werror -triple x86_64-linux-gnu -emit-llvm -o - %s | FileCheck %s
 
 int val = 42;
 int& test1() {
   return throw val, val;
 }
 
 int test2() {
namespace DR1560 {
   };
   extern bool b;
   A get();
   // CHECK-LABEL: @_ZN6DR15601bE
   const A &r = b ? get() : throw 0;
   // CHECK-NOT: call {{.*}}@_ZN6DR15601AD1Ev
   // CHECK: call {{.*}} @__cxa_atexit({{.*}} @_ZN6DR15601AD1Ev {{.*}} @_ZGRN6DR15601rE
   // CHECK-NOT: call {{.*}}@_ZN6DR15601AD1Ev
+
+  // PR28184
+  void conditional_throw() {
+    int a;
+    (true ? throw 0 : a) = 0; // CHECK: call void @__cxa_throw({{.*}})
+  }
 }
 
 // CHECK-LABEL: define void @_Z5test7b(
 void test7(bool cond) {
   // CHECK: br i1
   //
   // x.true:
   // CHECK: call void @__cxa_throw(