https://github.com/ahatanak updated https://github.com/llvm/llvm-project/pull/79230
>From 678cd8ea37f1d02c70fd09b7107542c8301c3bd2 Mon Sep 17 00:00:00 2001 From: Akira Hatanaka <ahata...@gmail.com> Date: Tue, 16 Jan 2024 13:18:09 -0800 Subject: [PATCH 1/4] Add support for builtin_verbose_trap The builtin causes the program to stop its execution abnormally and shows a human-readable description of the reason for the termination when a debugger is attached or in a symbolicated crash log. The motivation for the builtin is explained in the following RFC: https://discourse.llvm.org/t/rfc-adding-builtin-verbose-trap-string-literal/75845 --- clang/docs/LanguageExtensions.rst | 48 ++++++++++++++++++ clang/include/clang/AST/Expr.h | 5 ++ clang/include/clang/Basic/Builtins.td | 6 +++ .../clang/Basic/DiagnosticSemaKinds.td | 2 + clang/lib/AST/ExprConstant.cpp | 18 +++++-- clang/lib/CodeGen/CGBuiltin.cpp | 12 +++++ clang/lib/CodeGen/CGDebugInfo.cpp | 42 ++++++++++++++++ clang/lib/CodeGen/CGDebugInfo.h | 20 ++++++++ clang/lib/Sema/SemaChecking.cpp | 22 +++++++++ .../CodeGenCXX/debug-info-verbose-trap.cpp | 49 +++++++++++++++++++ clang/test/SemaCXX/verbose-trap.cpp | 28 +++++++++++ 11 files changed, 249 insertions(+), 3 deletions(-) create mode 100644 clang/test/CodeGenCXX/debug-info-verbose-trap.cpp create mode 100644 clang/test/SemaCXX/verbose-trap.cpp diff --git a/clang/docs/LanguageExtensions.rst b/clang/docs/LanguageExtensions.rst index c1420079f75118d..4526bc2df53e422 100644 --- a/clang/docs/LanguageExtensions.rst +++ b/clang/docs/LanguageExtensions.rst @@ -3379,6 +3379,54 @@ Query for this feature with ``__has_builtin(__builtin_debugtrap)``. Query for this feature with ``__has_builtin(__builtin_trap)``. +``__builtin_verbose_trap`` +------------------ + +``__builtin_verbose_trap`` causes the program to stop its execution abnormally +and shows a human-readable description of the reason for the termination when a +debugger is attached or in a symbolicated crash log. + +**Syntax**: + +.. code-block:: c++ + + __builtin_verbose_trap(const char *reason) + +**Description** + +``__builtin_verbose_trap`` is lowered to the ` ``llvm.trap`` <https://llvm.org/docs/LangRef.html#llvm-trap-intrinsic>`_ builtin. +Additionally, clang emits debug metadata that represents an artificial inline +frame whose name encodes the string passed to the builtin, prefixed by a "magic" +prefix. + +For example, consider the following code: + +.. code-block:: c++ + + void foo(int* p) { + if (p == nullptr) + __builtin_verbose_trap("Argument_must_not_be_null"); + } + +The debug metadata would look as if it were produced for the following code: + +.. code-block:: c++ + + __attribute__((always_inline)) + inline void "__llvm_verbose_trap: Argument_must_not_be_null"() { + __builtin_trap(); + } + + void foo(int* p) { + if (p == nullptr) + "__llvm_verbose_trap: Argument_must_not_be_null"(); + } + +However, the LLVM IR would not actually contain a call to the artificial +function — it only exists in the debug metadata. + +Query for this feature with ``__has_builtin(__builtin_verbose_trap)``. + ``__builtin_nondeterministic_value`` ------------------------------------ diff --git a/clang/include/clang/AST/Expr.h b/clang/include/clang/AST/Expr.h index 59f0aee2c0ceddf..68447b19a4a107c 100644 --- a/clang/include/clang/AST/Expr.h +++ b/clang/include/clang/AST/Expr.h @@ -775,6 +775,11 @@ class Expr : public ValueStmt { const Expr *PtrExpression, ASTContext &Ctx, EvalResult &Status) const; + /// If the current Expr can be evaluated to a pointer to a null-terminated + /// constant string, return the constant string (without the terminating null) + /// in Result. Return true if it succeeds. + bool tryEvaluateString(std::string &Result, ASTContext &Ctx) const; + /// Enumeration used to describe the kind of Null pointer constant /// returned from \c isNullPointerConstant(). enum NullPointerConstantKind { diff --git a/clang/include/clang/Basic/Builtins.td b/clang/include/clang/Basic/Builtins.td index 22e616e6cde5990..217c09e85a55cc1 100644 --- a/clang/include/clang/Basic/Builtins.td +++ b/clang/include/clang/Basic/Builtins.td @@ -1096,6 +1096,12 @@ def Trap : Builtin { let Prototype = "void()"; } +def VerboseTrap : Builtin { + let Spellings = ["__builtin_verbose_trap"]; + let Attributes = [NoThrow, NoReturn]; + let Prototype = "void(char const*)"; +} + def Debugtrap : Builtin { let Spellings = ["__builtin_debugtrap"]; let Attributes = [NoThrow]; diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td index a1c32abb4dcd880..40482a964b39d55 100644 --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -8794,6 +8794,8 @@ def err_expected_callable_argument : Error< "expected a callable expression as %ordinal0 argument to %1, found %2">; def note_building_builtin_dump_struct_call : Note< "in call to printing function with arguments '(%0)' while dumping struct">; +def err_builtin_verbose_trap_arg : Error< + "argument to __builtin_verbose_trap must be a non-empty string literal">; def err_atomic_load_store_uses_lib : Error< "atomic %select{load|store}0 requires runtime support that is not " diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp index f1d07d022b25848..33fc9a089a3941d 100644 --- a/clang/lib/AST/ExprConstant.cpp +++ b/clang/lib/AST/ExprConstant.cpp @@ -1880,7 +1880,8 @@ static bool EvaluateAtomic(const Expr *E, const LValue *This, APValue &Result, EvalInfo &Info); static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result); static bool EvaluateBuiltinStrLen(const Expr *E, uint64_t &Result, - EvalInfo &Info); + EvalInfo &Info, + std::string *StringResult = nullptr); /// Evaluate an integer or fixed point expression into an APResult. static bool EvaluateFixedPointOrInteger(const Expr *E, APFixedPoint &Result, @@ -16625,7 +16626,7 @@ bool Expr::tryEvaluateObjectSize(uint64_t &Result, ASTContext &Ctx, } static bool EvaluateBuiltinStrLen(const Expr *E, uint64_t &Result, - EvalInfo &Info) { + EvalInfo &Info, std::string *StringResult) { if (!E->getType()->hasPointerRepresentation() || !E->isPRValue()) return false; @@ -16652,6 +16653,8 @@ static bool EvaluateBuiltinStrLen(const Expr *E, uint64_t &Result, Str = Str.substr(0, Pos); Result = Str.size(); + if (StringResult) + *StringResult = Str; return true; } @@ -16667,12 +16670,21 @@ static bool EvaluateBuiltinStrLen(const Expr *E, uint64_t &Result, if (!Char.getInt()) { Result = Strlen; return true; - } + } else if (StringResult) + StringResult->push_back(Char.getInt().getExtValue()); if (!HandleLValueArrayAdjustment(Info, E, String, CharTy, 1)) return false; } } +bool Expr::tryEvaluateString(std::string &StringResult, ASTContext &Ctx) const { + Expr::EvalStatus Status; + EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantFold); + uint64_t Result; + + return EvaluateBuiltinStrLen(this, Result, Info, &StringResult); +} + bool Expr::EvaluateCharRangeAsString(std::string &Result, const Expr *SizeExpression, const Expr *PtrExpression, ASTContext &Ctx, diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp index 27183c69b7ea377..a701bb7917fd8c3 100644 --- a/clang/lib/CodeGen/CGBuiltin.cpp +++ b/clang/lib/CodeGen/CGBuiltin.cpp @@ -3452,6 +3452,18 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, case Builtin::BI__builtin_trap: EmitTrapCall(Intrinsic::trap); return RValue::get(nullptr); + case Builtin::BI__builtin_verbose_trap: { + llvm::DILocation *TrapLocation = Builder.getCurrentDebugLocation(); + if (getDebugInfo()) { + std::string Str; + E->getArg(0)->tryEvaluateString(Str, getContext()); + TrapLocation = getDebugInfo()->CreateTrapFailureMessageFor( + TrapLocation, "__llvm_verbose_trap", Str); + } + ApplyDebugLocation ApplyTrapDI(*this, TrapLocation); + EmitTrapCall(Intrinsic::trap); + return RValue::get(nullptr); + } case Builtin::BI__debugbreak: EmitTrapCall(Intrinsic::debugtrap); return RValue::get(nullptr); diff --git a/clang/lib/CodeGen/CGDebugInfo.cpp b/clang/lib/CodeGen/CGDebugInfo.cpp index 0f3f684d61dc943..fadbc0a80f8a113 100644 --- a/clang/lib/CodeGen/CGDebugInfo.cpp +++ b/clang/lib/CodeGen/CGDebugInfo.cpp @@ -1628,6 +1628,27 @@ llvm::DIType *CGDebugInfo::createFieldType( offsetInBits, flags, debugType, Annotations); } +llvm::DISubprogram * +CGDebugInfo::getFakeFuncSubprogram(const std::string &FakeFuncName) { + llvm::DISubprogram *&SP = FakeFuncMap[FakeFuncName]; + + if (!SP) { + auto FileScope = TheCU->getFile(); + llvm::DISubroutineType *DIFnTy = DBuilder.createSubroutineType(nullptr); + // Note: We use `FileScope` rather than `TheCU` as the scope because that's + // what LLVM's inliner seems to do. + SP = DBuilder.createFunction( + /*Scope=*/FileScope, /*Name=*/FakeFuncName, /*LinkageName=*/StringRef(), + /*File=*/FileScope, /*LineNo=*/0, /*Ty=*/DIFnTy, + /*ScopeLine=*/0, + /*Flags=*/llvm::DINode::FlagArtificial, + /*SPFlags=*/llvm::DISubprogram::SPFlagDefinition, + /*TParams=*/nullptr, /*ThrownTypes=*/nullptr, /*Annotations=*/nullptr); + } + + return SP; +} + void CGDebugInfo::CollectRecordLambdaFields( const CXXRecordDecl *CXXDecl, SmallVectorImpl<llvm::Metadata *> &elements, llvm::DIType *RecordTy) { @@ -3424,6 +3445,27 @@ llvm::DIMacroFile *CGDebugInfo::CreateTempMacroFile(llvm::DIMacroFile *Parent, return DBuilder.createTempMacroFile(Parent, Line, FName); } +llvm::DILocation *CGDebugInfo::CreateTrapFailureMessageFor( + llvm::DebugLoc TrapLocation, StringRef Prefix, StringRef FailureMsg) { + // Create debug info that describes a fake function whose name is the failure + // message. + std::string FuncName(Prefix); + if (!FailureMsg.empty()) { + // A space in the function name identifies this as not being a real function + // because it's not a valid symbol name. + FuncName += ": "; + FuncName += FailureMsg; + } + + assert(FuncName.size() > 0); + assert(FuncName.find(' ') != std::string::npos && + "Fake function name must contain a space"); + + llvm::DISubprogram *TrapSP = getFakeFuncSubprogram(FuncName); + return llvm::DILocation::get(CGM.getLLVMContext(), /*Line=*/0, /*Column=*/0, + /*Scope=*/TrapSP, /*InlinedAt=*/TrapLocation); +} + static QualType UnwrapTypeForDebugInfo(QualType T, const ASTContext &C) { Qualifiers Quals; do { diff --git a/clang/lib/CodeGen/CGDebugInfo.h b/clang/lib/CodeGen/CGDebugInfo.h index 7b60e94555d0608..21edb5536742600 100644 --- a/clang/lib/CodeGen/CGDebugInfo.h +++ b/clang/lib/CodeGen/CGDebugInfo.h @@ -346,6 +346,14 @@ class CGDebugInfo { const FieldDecl *BitFieldDecl, const llvm::DIDerivedType *BitFieldDI, llvm::ArrayRef<llvm::Metadata *> PreviousFieldsDI, const RecordDecl *RD); + // A cache that maps fake function names used for __builtin_verbose_trap to + // subprograms. + std::map<std::string, llvm::DISubprogram *> FakeFuncMap; + + // A function that returns the subprogram corresponding to the fake function + // name. + llvm::DISubprogram *getFakeFuncSubprogram(const std::string &FakeFuncName); + /// Helpers for collecting fields of a record. /// @{ void CollectRecordLambdaFields(const CXXRecordDecl *CXXDecl, @@ -602,6 +610,18 @@ class CGDebugInfo { return CoroutineParameterMappings; } + // Create a debug location from `TrapLocation` that adds a fake + // inline frame where the frame name is + // + // * `<Prefix>: <FailureMsg>` if `<FailureMsg>` is not empty. + // * `<Prefix>` if `<FailureMsg>` is empty. Note `<Prefix>` must + // contain a space. + // + // This is used to store failure reasons for traps. + llvm::DILocation *CreateTrapFailureMessageFor(llvm::DebugLoc TrapLocation, + StringRef Prefix, + StringRef FailureMsg); + private: /// Emit call to llvm.dbg.declare for a variable declaration. /// Returns a pointer to the DILocalVariable associated with the diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp index 4d280f25cc04c25..4cdd6703c52fdf8 100644 --- a/clang/lib/Sema/SemaChecking.cpp +++ b/clang/lib/Sema/SemaChecking.cpp @@ -171,6 +171,23 @@ static bool checkArgCount(Sema &S, CallExpr *Call, unsigned DesiredArgCount) { << /*is non object*/ 0 << Call->getArg(1)->getSourceRange(); } +static bool checkBuiltinVerboseTrap(CallExpr *Call, Sema &S) { + Expr *Arg = Call->getArg(0); + + if (Arg->isValueDependent()) + return true; + + // FIXME: Add more checks and reject strings that can't be handled by + // debuggers. + std::string Result; + if (!Arg->tryEvaluateString(Result, S.Context) || Result.empty()) { + S.Diag(Arg->getBeginLoc(), diag::err_builtin_verbose_trap_arg) + << Arg->getSourceRange(); + return false; + } + return true; +} + static bool convertArgumentToType(Sema &S, Expr *&Value, QualType Ty) { if (Value->isTypeDependent()) return false; @@ -2882,6 +2899,11 @@ Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID, case Builtin::BI__builtin_matrix_column_major_store: return SemaBuiltinMatrixColumnMajorStore(TheCall, TheCallResult); + case Builtin::BI__builtin_verbose_trap: + if (!checkBuiltinVerboseTrap(TheCall, *this)) + return ExprError(); + break; + case Builtin::BI__builtin_get_device_side_mangled_name: { auto Check = [](CallExpr *TheCall) { if (TheCall->getNumArgs() != 1) diff --git a/clang/test/CodeGenCXX/debug-info-verbose-trap.cpp b/clang/test/CodeGenCXX/debug-info-verbose-trap.cpp new file mode 100644 index 000000000000000..04fa68ae93ecb68 --- /dev/null +++ b/clang/test/CodeGenCXX/debug-info-verbose-trap.cpp @@ -0,0 +1,49 @@ +// RUN: %clang_cc1 -std=c++20 -emit-llvm -debug-info-kind=limited %s -o - | FileCheck %s + +// CHECK-LABEL: define void @_Z2f0v() +// CHECK: call void @llvm.trap(), !dbg ![[LOC17:.*]] + +// CHECK-LABEL: define void @_Z2f1v() +// CHECK: call void @llvm.trap(), !dbg ![[LOC23:.*]] +// CHECK: call void @llvm.trap(), !dbg ![[LOC25:.*]] + +// CHECK-LABEL: define void @_Z2f3v() +// CHECK: call void @_Z2f2IXadsoKcL_ZL8constMsgEEEEvv() + +// CHECK-LABEL: define internal void @_Z2f2IXadsoKcL_ZL8constMsgEEEEvv() +// CHECK: call void @llvm.trap(), !dbg ![[LOC36:.*]] + +// CHECK: ![[FILESCOPE:.*]] = !DIFile(filename: +// CHECK: ![[SUBPROG14:.*]] = distinct !DISubprogram(name: "f0", linkageName: "_Z2f0v", +// CHECK: ![[LOC17]] = !DILocation(line: 0, scope: ![[SUBPROG18:.*]], inlinedAt: ![[LOC20:.*]]) +// CHECK: ![[SUBPROG18]] = distinct !DISubprogram(name: "__llvm_verbose_trap: Argument_must_not_be_null", scope: ![[FILESCOPE]], file: ![[FILESCOPE]], type: !{{.*}}, flags: DIFlagArtificial, spFlags: DISPFlagDefinition, unit: !{{.*}}) +// CHECK: ![[LOC20]] = !DILocation(line: 34, column: 3, scope: ![[SUBPROG14]]) +// CHECK: ![[SUBPROG22:.*]] = distinct !DISubprogram(name: "f1", linkageName: "_Z2f1v", +// CHECK: ![[LOC23]] = !DILocation(line: 0, scope: ![[SUBPROG18]], inlinedAt: ![[LOC24:.*]]) +// CHECK: ![[LOC24]] = !DILocation(line: 38, column: 3, scope: ![[SUBPROG22]]) +// CHECK: ![[LOC25]] = !DILocation(line: 0, scope: ![[SUBPROG26:.*]], inlinedAt: ![[LOC27:.*]]) +// CHECK: ![[SUBPROG26]] = distinct !DISubprogram(name: "__llvm_verbose_trap: hello", scope: ![[FILESCOPE]], file: ![[FILESCOPE]], type: !{{.*}}, flags: DIFlagArtificial, spFlags: DISPFlagDefinition, unit: !{{.*}}) +// CHECK: ![[LOC27]] = !DILocation(line: 39, column: 3, scope: ![[SUBPROG22]]) +// CHECK: ![[SUBPROG32:.*]] = distinct !DISubprogram(name: "f2<&constMsg[0]>", linkageName: "_Z2f2IXadsoKcL_ZL8constMsgEEEEvv", +// CHECK: ![[LOC36]] = !DILocation(line: 0, scope: ![[SUBPROG26]], inlinedAt: ![[LOC37:.*]]) +// CHECK: ![[LOC37]] = !DILocation(line: 44, column: 3, scope: ![[SUBPROG32]]) + +char const constMsg[] = "hello"; + +void f0() { + __builtin_verbose_trap("Argument_must_not_be_null"); +} + +void f1() { + __builtin_verbose_trap("Argument_must_not_be_null"); + __builtin_verbose_trap("hello"); +} + +template <const char * const str> +void f2() { + __builtin_verbose_trap(str); +} + +void f3() { + f2<constMsg>(); +} diff --git a/clang/test/SemaCXX/verbose-trap.cpp b/clang/test/SemaCXX/verbose-trap.cpp new file mode 100644 index 000000000000000..7c152325d30815e --- /dev/null +++ b/clang/test/SemaCXX/verbose-trap.cpp @@ -0,0 +1,28 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcxx-exceptions -verify %s + +#if !__has_builtin(__builtin_verbose_trap) +#error +#endif + +constexpr char const* constMsg1 = "hello"; +char const* const constMsg2 = "hello"; +char const constMsg3[] = "hello"; + +template <const char * const str> +void f(const char * arg) { + __builtin_verbose_trap("Argument_must_not_be_null"); + __builtin_verbose_trap("hello" "world"); + __builtin_verbose_trap(constMsg1); + __builtin_verbose_trap(constMsg2); + __builtin_verbose_trap(""); // expected-error {{argument to __builtin_verbose_trap must be a non-empty string literal}} + __builtin_verbose_trap(); // expected-error {{too few arguments}} + __builtin_verbose_trap(0); // expected-error {{argument to __builtin_verbose_trap must be a non-empty string literal}} + __builtin_verbose_trap(1); // expected-error {{cannot initialize a parameter of type 'const char *' with}} + __builtin_verbose_trap(arg); // expected-error {{argument to __builtin_verbose_trap must be a non-empty string literal}} + __builtin_verbose_trap(str); + __builtin_verbose_trap(u8"hello"); +} + +void test() { + f<constMsg3>(nullptr); +} >From 6c65805633f9a4f7d12be00fd0106f2b0c67e7fb Mon Sep 17 00:00:00 2001 From: Akira Hatanaka <ahata...@gmail.com> Date: Tue, 23 Jan 2024 16:05:13 -0800 Subject: [PATCH 2/4] Fix documentation build error --- clang/docs/LanguageExtensions.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clang/docs/LanguageExtensions.rst b/clang/docs/LanguageExtensions.rst index 4526bc2df53e422..9a873700f658805 100644 --- a/clang/docs/LanguageExtensions.rst +++ b/clang/docs/LanguageExtensions.rst @@ -3380,7 +3380,7 @@ Query for this feature with ``__has_builtin(__builtin_debugtrap)``. Query for this feature with ``__has_builtin(__builtin_trap)``. ``__builtin_verbose_trap`` ------------------- +-------------------------- ``__builtin_verbose_trap`` causes the program to stop its execution abnormally and shows a human-readable description of the reason for the termination when a >From 3e54bf3cf88a5f85b54766cbe4ded3a882db200c Mon Sep 17 00:00:00 2001 From: Akira Hatanaka <ahata...@gmail.com> Date: Tue, 23 Jan 2024 16:13:14 -0800 Subject: [PATCH 3/4] Fix diagnostic message --- clang/include/clang/Basic/DiagnosticSemaKinds.td | 3 ++- clang/test/SemaCXX/verbose-trap.cpp | 6 +++--- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td index 40482a964b39d55..c7101b84b0777f8 100644 --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -8795,7 +8795,8 @@ def err_expected_callable_argument : Error< def note_building_builtin_dump_struct_call : Note< "in call to printing function with arguments '(%0)' while dumping struct">; def err_builtin_verbose_trap_arg : Error< - "argument to __builtin_verbose_trap must be a non-empty string literal">; + "argument to __builtin_verbose_trap must be a pointer to a non-empty constant " + "string">; def err_atomic_load_store_uses_lib : Error< "atomic %select{load|store}0 requires runtime support that is not " diff --git a/clang/test/SemaCXX/verbose-trap.cpp b/clang/test/SemaCXX/verbose-trap.cpp index 7c152325d30815e..2cbfad6c817f82f 100644 --- a/clang/test/SemaCXX/verbose-trap.cpp +++ b/clang/test/SemaCXX/verbose-trap.cpp @@ -14,11 +14,11 @@ void f(const char * arg) { __builtin_verbose_trap("hello" "world"); __builtin_verbose_trap(constMsg1); __builtin_verbose_trap(constMsg2); - __builtin_verbose_trap(""); // expected-error {{argument to __builtin_verbose_trap must be a non-empty string literal}} + __builtin_verbose_trap(""); // expected-error {{argument to __builtin_verbose_trap must be a pointer to a non-empty constant string}} __builtin_verbose_trap(); // expected-error {{too few arguments}} - __builtin_verbose_trap(0); // expected-error {{argument to __builtin_verbose_trap must be a non-empty string literal}} + __builtin_verbose_trap(0); // expected-error {{argument to __builtin_verbose_trap must be a pointer to a non-empty constant string}} __builtin_verbose_trap(1); // expected-error {{cannot initialize a parameter of type 'const char *' with}} - __builtin_verbose_trap(arg); // expected-error {{argument to __builtin_verbose_trap must be a non-empty string literal}} + __builtin_verbose_trap(arg); // expected-error {{argument to __builtin_verbose_trap must be a pointer to a non-empty constant string}} __builtin_verbose_trap(str); __builtin_verbose_trap(u8"hello"); } >From 9cd883e1e1a3996cff190fbef592fd59ebea8dc9 Mon Sep 17 00:00:00 2001 From: Akira Hatanaka <ahata...@gmail.com> Date: Thu, 25 Jan 2024 14:15:16 -0800 Subject: [PATCH 4/4] Address review comments --- clang/docs/LanguageExtensions.rst | 19 +++++++++++-------- clang/lib/CodeGen/CGDebugInfo.cpp | 19 +++++++++---------- clang/lib/CodeGen/CGDebugInfo.h | 16 ++++++++-------- clang/test/SemaCXX/verbose-trap.cpp | 1 + 4 files changed, 29 insertions(+), 26 deletions(-) diff --git a/clang/docs/LanguageExtensions.rst b/clang/docs/LanguageExtensions.rst index 9a873700f658805..ecb0f6feec37fdf 100644 --- a/clang/docs/LanguageExtensions.rst +++ b/clang/docs/LanguageExtensions.rst @@ -3395,9 +3395,9 @@ debugger is attached or in a symbolicated crash log. **Description** ``__builtin_verbose_trap`` is lowered to the ` ``llvm.trap`` <https://llvm.org/docs/LangRef.html#llvm-trap-intrinsic>`_ builtin. -Additionally, clang emits debug metadata that represents an artificial inline -frame whose name encodes the string passed to the builtin, prefixed by a "magic" -prefix. +Additionally, clang emits debugging information that represents an artificial +inline frame whose name encodes the string passed to the builtin, prefixed by a +"magic" prefix. For example, consider the following code: @@ -3405,27 +3405,30 @@ For example, consider the following code: void foo(int* p) { if (p == nullptr) - __builtin_verbose_trap("Argument_must_not_be_null"); + __builtin_verbose_trap("Argument must not be null!"); } -The debug metadata would look as if it were produced for the following code: +The debugging information would look as if it were produced for the following code: .. code-block:: c++ __attribute__((always_inline)) - inline void "__llvm_verbose_trap: Argument_must_not_be_null"() { + inline void "__llvm_verbose_trap: Argument must not be null!"() { __builtin_trap(); } void foo(int* p) { if (p == nullptr) - "__llvm_verbose_trap: Argument_must_not_be_null"(); + "__llvm_verbose_trap: Argument must not be null!"(); } However, the LLVM IR would not actually contain a call to the artificial function — it only exists in the debug metadata. -Query for this feature with ``__has_builtin(__builtin_verbose_trap)``. +Query for this feature with ``__has_builtin(__builtin_verbose_trap)``. Note that +users need to enable debug information to enable this feature. A call to this +builtin is equivalent to a call to ``__builtin_trap`` if debug information isn't +enabled. ``__builtin_nondeterministic_value`` ------------------------------------ diff --git a/clang/lib/CodeGen/CGDebugInfo.cpp b/clang/lib/CodeGen/CGDebugInfo.cpp index fadbc0a80f8a113..a9ae6da65418913 100644 --- a/clang/lib/CodeGen/CGDebugInfo.cpp +++ b/clang/lib/CodeGen/CGDebugInfo.cpp @@ -1629,8 +1629,8 @@ llvm::DIType *CGDebugInfo::createFieldType( } llvm::DISubprogram * -CGDebugInfo::getFakeFuncSubprogram(const std::string &FakeFuncName) { - llvm::DISubprogram *&SP = FakeFuncMap[FakeFuncName]; +CGDebugInfo::createInlinedTrapSubprogram(const std::string &FuncName) { + llvm::DISubprogram *&SP = InlinedTrapFuncMap[FuncName]; if (!SP) { auto FileScope = TheCU->getFile(); @@ -1638,7 +1638,7 @@ CGDebugInfo::getFakeFuncSubprogram(const std::string &FakeFuncName) { // Note: We use `FileScope` rather than `TheCU` as the scope because that's // what LLVM's inliner seems to do. SP = DBuilder.createFunction( - /*Scope=*/FileScope, /*Name=*/FakeFuncName, /*LinkageName=*/StringRef(), + /*Scope=*/FileScope, /*Name=*/FuncName, /*LinkageName=*/StringRef(), /*File=*/FileScope, /*LineNo=*/0, /*Ty=*/DIFnTy, /*ScopeLine=*/0, /*Flags=*/llvm::DINode::FlagArtificial, @@ -3447,8 +3447,11 @@ llvm::DIMacroFile *CGDebugInfo::CreateTempMacroFile(llvm::DIMacroFile *Parent, llvm::DILocation *CGDebugInfo::CreateTrapFailureMessageFor( llvm::DebugLoc TrapLocation, StringRef Prefix, StringRef FailureMsg) { - // Create debug info that describes a fake function whose name is the failure - // message. + assert((!FailureMsg.empty() || Prefix.find(' ') != std::string::npos) && + "Prefix must contain a space when FailureMsg is empty"); + + // Create debug info that describes an inlined function whose name is the + // failure message. std::string FuncName(Prefix); if (!FailureMsg.empty()) { // A space in the function name identifies this as not being a real function @@ -3457,11 +3460,7 @@ llvm::DILocation *CGDebugInfo::CreateTrapFailureMessageFor( FuncName += FailureMsg; } - assert(FuncName.size() > 0); - assert(FuncName.find(' ') != std::string::npos && - "Fake function name must contain a space"); - - llvm::DISubprogram *TrapSP = getFakeFuncSubprogram(FuncName); + llvm::DISubprogram *TrapSP = createInlinedTrapSubprogram(FuncName); return llvm::DILocation::get(CGM.getLLVMContext(), /*Line=*/0, /*Column=*/0, /*Scope=*/TrapSP, /*InlinedAt=*/TrapLocation); } diff --git a/clang/lib/CodeGen/CGDebugInfo.h b/clang/lib/CodeGen/CGDebugInfo.h index 21edb5536742600..ff5591532918361 100644 --- a/clang/lib/CodeGen/CGDebugInfo.h +++ b/clang/lib/CodeGen/CGDebugInfo.h @@ -346,13 +346,13 @@ class CGDebugInfo { const FieldDecl *BitFieldDecl, const llvm::DIDerivedType *BitFieldDI, llvm::ArrayRef<llvm::Metadata *> PreviousFieldsDI, const RecordDecl *RD); - // A cache that maps fake function names used for __builtin_verbose_trap to - // subprograms. - std::map<std::string, llvm::DISubprogram *> FakeFuncMap; + // A cache that maps artificial inlined function names used for + // __builtin_verbose_trap to subprograms. + std::map<std::string, llvm::DISubprogram *> InlinedTrapFuncMap; - // A function that returns the subprogram corresponding to the fake function - // name. - llvm::DISubprogram *getFakeFuncSubprogram(const std::string &FakeFuncName); + // A function that returns the subprogram corresponding to the artificial + // inlined function for traps. + llvm::DISubprogram *createInlinedTrapSubprogram(const std::string &FuncName); /// Helpers for collecting fields of a record. /// @{ @@ -610,8 +610,8 @@ class CGDebugInfo { return CoroutineParameterMappings; } - // Create a debug location from `TrapLocation` that adds a fake - // inline frame where the frame name is + // Create a debug location from `TrapLocation` that adds an artificial inline + // frame where the frame name is // // * `<Prefix>: <FailureMsg>` if `<FailureMsg>` is not empty. // * `<Prefix>` if `<FailureMsg>` is empty. Note `<Prefix>` must diff --git a/clang/test/SemaCXX/verbose-trap.cpp b/clang/test/SemaCXX/verbose-trap.cpp index 2cbfad6c817f82f..7968e9995209576 100644 --- a/clang/test/SemaCXX/verbose-trap.cpp +++ b/clang/test/SemaCXX/verbose-trap.cpp @@ -10,6 +10,7 @@ char const constMsg3[] = "hello"; template <const char * const str> void f(const char * arg) { + __builtin_verbose_trap("Arbitrary string literals can be used!"); __builtin_verbose_trap("Argument_must_not_be_null"); __builtin_verbose_trap("hello" "world"); __builtin_verbose_trap(constMsg1); _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
