Make extern weak symbols for type descriptor not defined in translation unit

If a derived type is defined in a module in another translation unit,
its "<scope mangling>.dt.<typename>" global is not declared in the
current translation unit in lowering, and therefore not accessible in
codegen. The symbol is not lowered because it is not use associated in
any of the program units lowered in the current translation unit. If we wanted
to deal with this in lowering, we would need to start lowering
declaration for all variables from the module used by the lowered
program units, which is not the current approach in lowering).

Declare a tentative (extern weak) type descriptor symbol in codegen
if no global exists for the type descriptor symbol. It may be resolved
at link time, and will otherwise be a nullptr (so far, do not make it a
link error if the symbol is defined nowhere to support codegen of FIR
files produced without runtime info symbols for debug purposes).

Author: jeanPerier

flang/lib/Optimizer/CodeGen/CodeGen.cpp

@@ -1172,9 +1172,21 @@ struct EmboxCommonConversion : public FIROpConversion<OP> {
       return rewriter.create<mlir::LLVM::AddressOfOp>(loc, ty,
                                                       global.sym_name());
     }
-    // Builtin derived types have no type descriptors. Return nullptr, that is
-    // what the runtime expects for these types.
-    return rewriter.create<mlir::LLVM::NullOp>(loc, this->voidPtrTy());
+    // The global does not exist in the current translation unit, but may be
+    // defined elsewhere (e.g., type defined in a module).
+    // For now, create a extern_weak symbols (will become nullptr if unresolved)
+    // to support generating code without the front-end generated symbols.
+    // These could be made available_externally to require the symbols to be
+    // defined elsewhere and to cause link-time failure otherwise.
+    auto i8Ty = rewriter.getIntegerType(8);
+    mlir::OpBuilder modBuilder(module.getBodyRegion());
+    // TODO: The symbol should be lowered to constant in lowering, they are read
+    // only.
+    modBuilder.create<mlir::LLVM::GlobalOp>(loc, i8Ty, /*isConstant=*/false,
+                                            mlir::LLVM::Linkage::ExternWeak,
+                                            name, mlir::Attribute{});
+    auto ty = mlir::LLVM::LLVMPointerType::get(i8Ty);
+    return rewriter.create<mlir::LLVM::AddressOfOp>(loc, ty, name);
   }
 
   template <typename BOX>

flang/test/Fir/type-descriptor.fir

@@ -1,13 +1,23 @@
 // RUN: tco -o - %s | FileCheck %s
 
+!type_defined_elsewhere = type !fir.type<_QMsome_moduleTtype_defined_elsewhere{j:i32}>
+fir.global internal @_QFfooEx2 : !fir.box<!fir.heap<!type_defined_elsewhere>> {
+  %0 = fir.zero_bits !fir.heap<!type_defined_elsewhere>
+  %1 = fir.embox %0 : (!fir.heap<!type_defined_elsewhere>) -> !fir.box<!fir.heap<!type_defined_elsewhere>>
+  fir.has_value %1 : !fir.box<!fir.heap<!type_defined_elsewhere>>
+}
+// CHECK: @_QMsome_moduleE.dt.type_defined_elsewhere = extern_weak global i8
+// CHECK: @_QFfooEx2 = internal global { %_QMsome_moduleTtype_defined_elsewhere*, i64, i32, i8, i8, i8, i8, i8*, [1 x i64] }
+// CHECK-SAME: { %_QMsome_moduleTtype_defined_elsewhere* null, i64 ptrtoint (i32* getelementptr (i32, i32* null, i32 1) to i64),
+// CHECK-SAME: i32 20180515, i8 0, i8 34, i8 2, i8 1, i8* @_QMsome_moduleE.dt.type_defined_elsewhere, [1 x i64] undef }
+
 !sometype = type !fir.type<_QFfooTsometype{num:i32,values:!fir.box<!fir.ptr<!fir.array<?x?xf32>>>}>
 fir.global internal @_QFfooE.dt.sometype : i8
 fir.global internal @_QFfooEx : !fir.box<!fir.heap<!sometype>> {
   %0 = fir.zero_bits !fir.heap<!sometype>
   %1 = fir.embox %0 : (!fir.heap<!sometype>) -> !fir.box<!fir.heap<!sometype>>
   fir.has_value %1 : !fir.box<!fir.heap<!sometype>>
 }
-
 // CHECK: @_QFfooEx = internal global { %_QFfooTsometype*, i64, i32, i8, i8, i8, i8, i8*, [1 x i64] }
 // CHECK-SAME: { %_QFfooTsometype* null, i64 ptrtoint (%_QFfooTsometype* getelementptr (%_QFfooTsometype, %_QFfooTsometype* null, i32 1) to i64),
 // CHECK-SAME: i32 20180515, i8 0, i8 34, i8 2, i8 1, i8* @_QFfooE.dt.sometype, [1 x i64] undef }