[CIR] Add support for typeid l-value emission

Implements support for typeid expressions as l-values, matching traditional
CodeGen behavior. The typeid operator returns a const reference to std::type_info,
which requires creating an l-value from the RTTI descriptor.

Key changes:
- CIRGenExprCXX: Add emitCXXTypeidExpr to emit GetGlobalOp for RTTI descriptors
- CIRGenExpr: Add emitCXXTypeidLValue to create l-value from typeid expression
- Refactored duplicate RTTI lookup code into helper lambda
- Added comprehensive tests covering type operands, expression operands, and
  polymorphic types

Tests include CIR, LLVM (via CIR), and OGCG (Original CodeGen) output verification.

Note: Polymorphic typeid (vtable lookup) is not yet implemented and guarded with
llvm_unreachable.

ghstack-source-id: e5e988639148fc0e73faedc22575ba9c5f2ba972
Pull-Request: llvm/clangir#2001

Author: lanza

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -2237,11 +2237,6 @@ LValue CIRGenFunction::emitCastLValue(const CastExpr *E) {
   llvm_unreachable("Unhandled lvalue cast kind?");
 }
 
-LValue CIRGenFunction::emitCXXTypeidLValue(const CXXTypeidExpr *E) {
-  assert(!cir::MissingFeatures::cxxTypeid() && "NYI");
-  llvm_unreachable("NYI");
-}
-
 // TODO(cir): candidate for common helper between LLVM and CIR codegen.
 static DeclRefExpr *tryToConvertMemberExprToDeclRefExpr(CIRGenFunction &CGF,
                                                         const MemberExpr *ME) {
@@ -2861,15 +2856,14 @@ LValue CIRGenFunction::emitLValue(const Expr *E) {
   case Expr::ImplicitCastExprClass:
   case Expr::ObjCBridgedCastExprClass:
     return emitCastLValue(cast<CastExpr>(E));
+  case Expr::CXXTypeidExprClass:
+    return emitCXXTypeidLValue(cast<CXXTypeidExpr>(E));
   case Expr::OpaqueValueExprClass:
     return emitOpaqueValueLValue(cast<OpaqueValueExpr>(E));
 
   case Expr::MaterializeTemporaryExprClass:
     return emitMaterializeTemporaryExpr(cast<MaterializeTemporaryExpr>(E));
 
-  case Expr::CXXTypeidExprClass:
-    return emitCXXTypeidLValue(cast<CXXTypeidExpr>(E));
-
   case Expr::ObjCPropertyRefExprClass:
     llvm_unreachable("cannot emit a property reference directly");
   case Expr::StmtExprClass:

clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp

@@ -1809,3 +1809,60 @@ mlir::Value CIRGenFunction::emitDynamicCast(Address ThisAddr,
   return CGM.getCXXABI().emitDynamicCast(*this, loc, srcRecordTy, destRecordTy,
                                          destCirTy, isRefCast, ThisAddr);
 }
+
+mlir::Value CIRGenFunction::emitCXXTypeidExpr(const CXXTypeidExpr *E) {
+  auto loc = getLoc(E->getSourceRange());
+
+  // Helper to create a GetGlobalOp from an RTTI descriptor attribute.
+  auto createGetGlobalForRTTI = [&](mlir::Attribute typeInfo) -> mlir::Value {
+    auto globalView = mlir::cast<cir::GlobalViewAttr>(typeInfo);
+    auto *globalOp = mlir::SymbolTable::lookupSymbolIn(CGM.getModule(),
+                                                       globalView.getSymbol());
+    assert(globalOp && "RTTI global not found");
+    auto global = mlir::cast<cir::GlobalOp>(globalOp);
+
+    // The result type of GetGlobalOp is a pointer to the global's symbol type.
+    auto ptrTy = builder.getPointerTo(global.getSymType());
+    return cir::GetGlobalOp::create(builder, loc, ptrTy,
+                                    globalView.getSymbol());
+  };
+
+  // If this is a type operand, just get the address of the RTTI descriptor.
+  if (E->isTypeOperand()) {
+    QualType operandTy = E->getTypeOperand(getContext());
+    mlir::Attribute typeInfo = CGM.getAddrOfRTTIDescriptor(loc, operandTy);
+    return createGetGlobalForRTTI(typeInfo);
+  }
+
+  // C++ [expr.typeid]p2:
+  //   When typeid is applied to a glvalue expression whose type is a
+  //   polymorphic class type, the result refers to a std::type_info object
+  //   representing the type of the most derived object (that is, the dynamic
+  //   type) to which the glvalue refers.
+
+  // If the operand is already the most derived object, no need to look up
+  // vtable.
+  if (E->isPotentiallyEvaluated() && !E->isMostDerived(getContext())) {
+    // This requires emitting code similar to dynamic_cast that looks up the
+    // type_info pointer from the vtable. Note that this path also needs to
+    // handle null checking when E->hasNullCheck() is true.
+    llvm_unreachable("NYI: typeid with polymorphic types (vtable lookup)");
+  }
+
+  // For non-polymorphic types, just return the static RTTI descriptor.
+  QualType operandTy = E->getExprOperand()->getType();
+  mlir::Attribute typeInfo = CGM.getAddrOfRTTIDescriptor(loc, operandTy);
+  return createGetGlobalForRTTI(typeInfo);
+}
+
+LValue CIRGenFunction::emitCXXTypeidLValue(const CXXTypeidExpr *E) {
+  mlir::Value V = emitCXXTypeidExpr(E);
+
+  LValueBaseInfo baseInfo;
+  TBAAAccessInfo tbaaInfo;
+  CharUnits alignment = CGM.getNaturalTypeAlignment(E->getType(), &baseInfo, &tbaaInfo);
+
+  // Use the Address constructor that extracts the element type from the pointer
+  Address addr(V, alignment);
+  return LValue::makeAddr(addr, E->getType(), getContext(), baseInfo, tbaaInfo);
+}

clang/lib/CIR/CodeGen/CIRGenFunction.h

@@ -1918,7 +1918,6 @@ class CIRGenFunction : public CIRGenTypeCache {
                                              cir::CaseOpKind kind,
                                              bool buildingTopLevelCase);
   LValue emitCastLValue(const CastExpr *E);
-  LValue emitCXXTypeidLValue(const CXXTypeidExpr *E);
 
   mlir::LogicalResult emitCaseStmt(const clang::CaseStmt &S,
                                    mlir::Type condType,
@@ -2157,6 +2156,12 @@ class CIRGenFunction : public CIRGenTypeCache {
 
   mlir::Value emitDynamicCast(Address ThisAddr, const CXXDynamicCastExpr *DCE);
 
+  /// Emit the operand of a typeid expression as an mlir::Value.
+  mlir::Value emitCXXTypeidExpr(const CXXTypeidExpr *E);
+
+  /// Emit a typeid expression as an l-value.
+  LValue emitCXXTypeidLValue(const CXXTypeidExpr *E);
+
   /// Emits try/catch information for the current EH stack.
   void emitEHResumeBlock(bool isCleanup, mlir::Block *ehResumeBlock,
                          mlir::Location loc);

clang/test/CIR/CodeGen/typeid-lvalue.cpp

@@ -0,0 +1,119 @@
+// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir %s --check-prefix=CIR
+// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-linux-gnu -fclangir -emit-llvm %s -o %t.ll
+// RUN: FileCheck --input-file=%t.ll %s --check-prefix=LLVM
+// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-linux-gnu -emit-llvm %s -o %t.og.ll
+// RUN: FileCheck --input-file=%t.og.ll %s --check-prefix=OGCG
+
+namespace std {
+  class type_info {
+  public:
+    virtual ~type_info();
+    const char* name() const { return __name; }
+    bool operator==(const type_info& __arg) const {
+     return __name == __arg.__name;
+    }
+
+    bool operator!=(const type_info& __arg) const {
+      return !operator==(__arg);
+    }
+
+    bool before(const type_info& __arg) const {
+      return __name < __arg.__name;
+    }
+
+    unsigned long hash_code() const {
+      return reinterpret_cast<unsigned long long>(__name);
+    }
+  protected:
+    const char *__name;
+  };
+}
+
+// Test 1: Non-polymorphic type - simple struct
+struct Simple {
+  int x;
+};
+
+void test_simple_type(const std::type_info*& out) {
+  // CIR-LABEL: cir.func {{.*}}@_Z16test_simple_type
+  out = &typeid(Simple);
+  // CIR: cir.get_global @_ZTI6Simple
+
+  // LLVM-LABEL: define {{.*}}@_Z16test_simple_type
+  // LLVM: store ptr @_ZTI6Simple
+
+  // OGCG-LABEL: define {{.*}}@_Z16test_simple_type
+  // OGCG: store ptr @_ZTI6Simple
+}
+
+// Test 2: Non-polymorphic type - expression operand
+void test_expression_operand(const std::type_info*& out) {
+  // CIR-LABEL: cir.func {{.*}}@_Z23test_expression_operand
+  Simple s;
+  out = &typeid(s);
+  // CIR: cir.get_global @_ZTI6Simple
+
+  // LLVM-LABEL: define {{.*}}@_Z23test_expression_operand
+  // LLVM: store ptr @_ZTI6Simple
+
+  // OGCG-LABEL: define {{.*}}@_Z23test_expression_operand
+  // OGCG: store ptr @_ZTI6Simple
+}
+
+// Test 3: Polymorphic base class
+struct Base {
+  virtual ~Base() = default;
+};
+
+struct Derived : Base {
+  int y;
+};
+
+// Test with non-polymorphic lookup (type operand)
+void test_polymorphic_type(const std::type_info*& out) {
+  // CIR-LABEL: cir.func {{.*}}@_Z21test_polymorphic_type
+  out = &typeid(Base);
+  // CIR: cir.get_global @_ZTI4Base
+
+  // LLVM-LABEL: define {{.*}}@_Z21test_polymorphic_type
+  // LLVM: store ptr @_ZTI4Base
+
+  // OGCG-LABEL: define {{.*}}@_Z21test_polymorphic_type
+  // OGCG: store ptr @_ZTI4Base
+}
+
+// Test 4: Built-in type
+void test_builtin_type(const std::type_info*& out) {
+  // CIR-LABEL: cir.func {{.*}}@_Z17test_builtin_type
+  out = &typeid(int);
+  // CIR: cir.get_global @_ZTIi
+
+  // LLVM-LABEL: define {{.*}}@_Z17test_builtin_type
+  // LLVM: store ptr @_ZTIi
+
+  // OGCG-LABEL: define {{.*}}@_Z17test_builtin_type
+  // OGCG: store ptr @_ZTIi
+}
+
+// Test 5: Passing typeid as function argument
+void consume_type_info(const std::type_info& ti) {
+  // CIR-LABEL: cir.func {{.*}}@_Z17consume_type_info
+
+  // LLVM-LABEL: define {{.*}}@_Z17consume_type_info
+
+  // OGCG-LABEL: define {{.*}}@_Z17consume_type_info
+}
+
+void test_function_argument() {
+  // CIR-LABEL: cir.func {{.*}}@_Z22test_function_argumentv
+  consume_type_info(typeid(int));
+  // CIR: cir.get_global @_ZTIi
+  // CIR: cir.call @_Z17consume_type_info
+
+  // LLVM-LABEL: define {{.*}}@_Z22test_function_argumentv
+  // LLVM: call {{.*}}@_Z17consume_type_infoRKSt9type_info(ptr @_ZTIi)
+
+  // OGCG-LABEL: define {{.*}}@_Z22test_function_argumentv
+  // OGCG: call {{.*}}@_Z17consume_type_infoRKSt9type_info(ptr {{.*}}@_ZTIi)
+}