Incomplete template function causes clang to crash

[llvmbot]

Bugzilla Link	37909
Version	trunk
OS	Windows NT
Reporter	LLVM Bugzilla Contributor
CC	@DougGregor

Extended Description

The following C++ test case causes clang to crash:
Assertion failed: !isIncompleteType() && "This doesn't make sense for incomplete types", file C:\src\llvm_package_333363\llvm\tools\clang\lib\AST\Type.cpp, line 1984

--------- test.cc ------------------------------
template
T&& create();

template<class T, class... Args>
void test() {
T t(create()...); // { dg-error "incomplete" }
(void) t;
}

int main() {
test<int[]>();
}

[wheatman]

this still reproduces on trunk, notably it does not crash on normal trunk, but does crash on the trunk with assertions

https://godbolt.org/z/TeahMTd11

full version was https://github.com/llvm/llvm-project.git 200cc95

[llvmbot]

@llvm/issue-subscribers-clang-codegen

[Endilll]

Still crashing as of post-16 trunk: https://godbolt.org/z/vTonbzxz9

clang++: /root/llvm-project/clang/lib/AST/Type.cpp:2270:
bool clang::Type::isConstantSizeType() const:
Assertion `!isIncompleteType() && "This doesn't make sense for incomplete types"' failed.

PLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace, preprocessed source, and associated run script.
Stack dump:
0.	Program arguments: /opt/compiler-explorer/clang-assertions-trunk/bin/clang++ -gdwarf-4 -g -o /app/output.s -mllvm --x86-asm-syntax=intel -S --gcc-toolchain=/opt/compiler-explorer/gcc-snapshot -fcolor-diagnostics -fno-crash-diagnostics <source>
1.	<eof> parser at end of file
2.	Per-file LLVM IR generation
3.	<source>:5:6: Generating code for declaration 'test'
 #0 0x000055585529ac1a llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x3a9ac1a)
 #1 0x000055585529884c llvm::sys::CleanupOnSignal(unsigned long) (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x3a9884c)
 #2 0x00005558551e7020 CrashRecoverySignalHandler(int) CrashRecoveryContext.cpp:0:0
 #3 0x00007f98dca8d420 __restore_rt (/lib/x86_64-linux-gnu/libpthread.so.0+0x14420)
 #4 0x00007f98dc55a00b raise (/lib/x86_64-linux-gnu/libc.so.6+0x4300b)
 #5 0x00007f98dc539859 abort (/lib/x86_64-linux-gnu/libc.so.6+0x22859)
 #6 0x00007f98dc539729 (/lib/x86_64-linux-gnu/libc.so.6+0x22729)
 #7 0x00007f98dc54afd6 (/lib/x86_64-linux-gnu/libc.so.6+0x33fd6)
 #8 0x000055585876fd8f clang::Type::isConstantSizeType() const (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x6f6fd8f)
 #9 0x00005558558dc44c clang::CodeGen::CodeGenFunction::EmitAutoVarAlloca(clang::VarDecl const&) (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x40dc44c)
#10 0x00005558558dd44a clang::CodeGen::CodeGenFunction::EmitVarDecl(clang::VarDecl const&) (.part.1036) CGDecl.cpp:0:0
#11 0x00005558558dd96b clang::CodeGen::CodeGenFunction::EmitDecl(clang::Decl const&) (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x40dd96b)
#12 0x000055585556587f clang::CodeGen::CodeGenFunction::EmitDeclStmt(clang::DeclStmt const&) (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x3d6587f)
#13 0x0000555855576d95 clang::CodeGen::CodeGenFunction::EmitSimpleStmt(clang::Stmt const*, llvm::ArrayRef<clang::Attr const*>) (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x3d76d95)
#14 0x0000555855571f56 clang::CodeGen::CodeGenFunction::EmitStmt(clang::Stmt const*, llvm::ArrayRef<clang::Attr const*>) (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x3d71f56)
#15 0x00005558555767ec clang::CodeGen::CodeGenFunction::EmitCompoundStmtWithoutScope(clang::CompoundStmt const&, bool, clang::CodeGen::AggValueSlot) (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x3d767ec)
#16 0x00005558555cf818 clang::CodeGen::CodeGenFunction::EmitFunctionBody(clang::Stmt const*) (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x3dcf818)
#17 0x00005558555e072b clang::CodeGen::CodeGenFunction::GenerateCode(clang::GlobalDecl, llvm::Function*, clang::CodeGen::CGFunctionInfo const&) (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x3de072b)
#18 0x00005558556372dc clang::CodeGen::CodeGenModule::EmitGlobalFunctionDefinition(clang::GlobalDecl, llvm::GlobalValue*) (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x3e372dc)
#19 0x0000555855633345 clang::CodeGen::CodeGenModule::EmitGlobalDefinition(clang::GlobalDecl, llvm::GlobalValue*) (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x3e33345)
#20 0x000055585563bd46 clang::CodeGen::CodeGenModule::EmitDeferred() (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x3e3bd46)
#21 0x000055585563d3ed clang::CodeGen::CodeGenModule::Release() (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x3e3d3ed)
#22 0x0000555856369f24 (anonymous namespace)::CodeGeneratorImpl::HandleTranslationUnit(clang::ASTContext&) ModuleBuilder.cpp:0:0
#23 0x000055585636836b clang::BackendConsumer::HandleTranslationUnit(clang::ASTContext&) (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x4b6836b)
#24 0x000055585763a459 clang::ParseAST(clang::Sema&, bool, bool) (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x5e3a459)
#25 0x0000555856367560 clang::CodeGenAction::ExecuteAction() (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x4b67560)
#26 0x0000555855c892e9 clang::FrontendAction::Execute() (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x44892e9)
#27 0x0000555855c1dc42 clang::CompilerInstance::ExecuteAction(clang::FrontendAction&) (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x441dc42)
#28 0x0000555855d60c9f clang::ExecuteCompilerInvocation(clang::CompilerInstance*) (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x4560c9f)
#29 0x0000555852a22cc3 cc1_main(llvm::ArrayRef<char const*>, char const*, void*) (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x1222cc3)
#30 0x0000555852a1ade8 ExecuteCC1Tool(llvm::SmallVectorImpl<char const*>&, llvm::ToolContext const&) driver.cpp:0:0
#31 0x0000555855a912f9 void llvm::function_ref<void ()>::callback_fn<clang::driver::CC1Command::Execute(llvm::ArrayRef<std::optional<llvm::StringRef>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, bool*) const::'lambda'()>(long) Job.cpp:0:0
#32 0x00005558551e74a5 llvm::CrashRecoveryContext::RunSafely(llvm::function_ref<void ()>) (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x39e74a5)
#33 0x0000555855a93eee clang::driver::CC1Command::Execute(llvm::ArrayRef<std::optional<llvm::StringRef>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, bool*) const (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x4293eee)
#34 0x0000555855a6060b clang::driver::Compilation::ExecuteCommand(clang::driver::Command const&, clang::driver::Command const*&, bool) const (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x426060b)
#35 0x0000555855a611e3 clang::driver::Compilation::ExecuteJobs(clang::driver::JobList const&, llvm::SmallVectorImpl<std::pair<int, clang::driver::Command const*>>&, bool) const (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x42611e3)
#36 0x0000555855a69fd6 clang::driver::Driver::ExecuteCompilation(clang::driver::Compilation&, llvm::SmallVectorImpl<std::pair<int, clang::driver::Command const*>>&) (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x4269fd6)
#37 0x0000555852a20a8e clang_main(int, char**, llvm::ToolContext const&) (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x1220a8e)
#38 0x0000555852951cb1 main (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x1151cb1)
#39 0x00007f98dc53b083 __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24083)
#40 0x0000555852a1a4da _start (/opt/compiler-explorer/clang-assertions-trunk/bin/clang+++0x121a4da)
clang++: error: clang frontend command failed with exit code 134 (use -v to see invocation)

[shafik]

So if we try this variant it diagnoses as we would expect: https://godbolt.org/z/zof6n78cf

template<class T>
T&& create();

template<class T, class... Args>
void test() {
  T t(create<Args>()...);       // { dg-error "incomplete" }
  (void) t;
}

struct A;

int main() {
  //test<int[]>();
  test<A>();
}

It is diagnosing here

llvm-project/clang/lib/Sema/SemaDecl.cpp

Line 13199 in dda3b70

if (RequireCompleteType(VDecl->getLocation(), BaseDeclType,

but in the incomplete array type we obtain the element type first:

llvm-project/clang/lib/Sema/SemaDecl.cpp

Line 13198 in dda3b70

BaseDeclType = Array->getElementType();

which means we don't diagnose. Other locations we diagnose this using RequireCompleteType(...) in SemaDecl.cpp we don't do this.

CC @AaronBallman

[Fznamznon]

incomplete array type we obtain the element type first

The comment above the code doing that explains the reason. In case of incomplete array type we still can deduce type from initializer. If that didn't happen we probably should emit an error, just like we do when there is a new - https://godbolt.org/z/YEs3MKvn3 .

[shafik]

incomplete array type we obtain the element type first

The comment above the code doing that explains the reason. In case of incomplete array type we still can deduce type from initializer. If that didn't happen we probably should emit an error, just like we do when there is a new - https://godbolt.org/z/YEs3MKvn3 .

Right, I think we should be diagnosing just like gcc does: https://godbolt.org/z/K3s4G74KG

I guess we need to check Init as well but maybe we need to catch this someplace else.

[shafik]

I think checking if Init is a InitListExpr should be sufficient since an array of incomplete type can only be initialized that way.

CC @AaronBallman am I missing any cases here?

[AaronBallman]

I wasn't able to find any other cases that we didn't already handle properly. You can initialize an incomplete array type with a string literal: char str[] = "testing"; but I don't think that applies here.

[Fznamznon]

I think checking if Init is a InitListExpr should be sufficient since an array of incomplete type can only be initialized that way.

I'm not sure I like the approach. There are several exceptions, for example the initializer can be also a CXXParenListInitExpr, a StringLiteral (as Aaron mentioned), a CompoundLiteralExpr, or same thing wrapped with parenthesis or even stuff like this:

int compound_array[] = __extension__(__builtin_choose_expr(0, 0, _Generic(1, int: (int[]){1, 2, 3, 4, 5, 6, 7, 8})));

That would require a visitor to find a string literal or an init list inside.

There is also ObjC construct like char d[] = @encode(int); which I don't know what means but Init is a ObjCEncodeExpr in this case.

The error for new expression I mentioned earlier checks type of the initializer and I would probably prefer doing something similar. WDYT?