diff --git a/clang/include/clang/CodeGen/SwiftCallingConv.h b/clang/include/clang/CodeGen/SwiftCallingConv.h index d7a0c84699ab0..806c3f13ffe62 100644 --- a/clang/include/clang/CodeGen/SwiftCallingConv.h +++ b/clang/include/clang/CodeGen/SwiftCallingConv.h @@ -88,6 +88,8 @@ class SwiftAggLowering { /// passed indirectly as an argument bool shouldPassIndirectly(bool asReturnValue) const; + bool shouldReturnTypedErrorIndirectly() const; + using EnumerationCallback = llvm::function_ref; diff --git a/clang/include/module.modulemap b/clang/include/module.modulemap index f9f8ba3a778cc..efb3b8e01af46 100644 --- a/clang/include/module.modulemap +++ b/clang/include/module.modulemap @@ -37,6 +37,7 @@ module Clang_Basic { umbrella "clang/Basic" textual header "clang/Basic/AArch64SVEACLETypes.def" + textual header "clang/Basic/AMDGPUTypes.def" textual header "clang/Basic/BuiltinsAArch64.def" textual header "clang/Basic/BuiltinsAMDGPU.def" textual header "clang/Basic/BuiltinsAArch64NeonSVEBridge.def" diff --git a/clang/lib/CodeGen/ABIInfo.cpp b/clang/lib/CodeGen/ABIInfo.cpp index edd7146dc1ac7..d2f82644ddeb2 100644 --- a/clang/lib/CodeGen/ABIInfo.cpp +++ b/clang/lib/CodeGen/ABIInfo.cpp @@ -275,6 +275,15 @@ bool SwiftABIInfo::shouldPassIndirectly(ArrayRef ComponentTys, return occupiesMoreThan(ComponentTys, /*total=*/4); } +bool SwiftABIInfo::shouldReturnTypedErrorIndirectly( + ArrayRef ComponentTys) const { + for (llvm::Type *type : ComponentTys) { + if (!type->isIntegerTy() && !type->isPointerTy()) + return true; + } + return shouldPassIndirectly(ComponentTys, /*AsReturnValue=*/true); +} + bool SwiftABIInfo::isLegalVectorType(CharUnits VectorSize, llvm::Type *EltTy, unsigned NumElts) const { // The default implementation of this assumes that the target guarantees diff --git a/clang/lib/CodeGen/ABIInfo.h b/clang/lib/CodeGen/ABIInfo.h index b8a8de57e5b97..25655e1bf14d3 100644 --- a/clang/lib/CodeGen/ABIInfo.h +++ b/clang/lib/CodeGen/ABIInfo.h @@ -153,6 +153,9 @@ class SwiftABIInfo { /// Returns true if swifterror is lowered to a register by the target ABI. bool isSwiftErrorInRegister() const { return SwiftErrorInRegister; }; + + virtual bool + shouldReturnTypedErrorIndirectly(ArrayRef ComponentTys) const; }; } // end namespace CodeGen } // end namespace clang diff --git a/clang/lib/CodeGen/SwiftCallingConv.cpp b/clang/lib/CodeGen/SwiftCallingConv.cpp index ab2e2bd0b3064..21578d3eeb401 100644 --- a/clang/lib/CodeGen/SwiftCallingConv.cpp +++ b/clang/lib/CodeGen/SwiftCallingConv.cpp @@ -644,6 +644,27 @@ bool SwiftAggLowering::shouldPassIndirectly(bool asReturnValue) const { return getSwiftABIInfo(CGM).shouldPassIndirectly(componentTys, asReturnValue); } +bool SwiftAggLowering::shouldReturnTypedErrorIndirectly() const { + assert(Finished && "haven't yet finished lowering"); + + // Empty types don't need to be passed indirectly. + if (Entries.empty()) + return false; + + // Avoid copying the array of types when there's just a single element. + if (Entries.size() == 1) { + return getSwiftABIInfo(CGM).shouldReturnTypedErrorIndirectly( + Entries.back().Type); + } + + SmallVector componentTys; + componentTys.reserve(Entries.size()); + for (auto &entry : Entries) { + componentTys.push_back(entry.Type); + } + return getSwiftABIInfo(CGM).shouldReturnTypedErrorIndirectly(componentTys); +} + bool swiftcall::shouldPassIndirectly(CodeGenModule &CGM, ArrayRef componentTys, bool asReturnValue) { diff --git a/clang/lib/Index/IndexRecordHasher.cpp b/clang/lib/Index/IndexRecordHasher.cpp index 4b015a7d19c95..ef28b0d5596fa 100644 --- a/clang/lib/Index/IndexRecordHasher.cpp +++ b/clang/lib/Index/IndexRecordHasher.cpp @@ -367,6 +367,10 @@ static hash_code computeHash(const TemplateArgument &Arg, case TemplateArgument::Integral: COMBINE_HASH('V', Hasher.hash(Arg.getIntegralType()), Arg.getAsIntegral()); break; + + case TemplateArgument::StructuralValue: + // FIXME: Hash structural values + break; } return Hash; diff --git a/lldb/include/lldb/Expression/ExpressionParser.h b/lldb/include/lldb/Expression/ExpressionParser.h index ab5223c915530..2ef7e036909c7 100644 --- a/lldb/include/lldb/Expression/ExpressionParser.h +++ b/lldb/include/lldb/Expression/ExpressionParser.h @@ -119,14 +119,35 @@ class ExpressionParser { /// \return /// An error code indicating the success or failure of the operation. /// Test with Success(). - virtual Status + Status PrepareForExecution(lldb::addr_t &func_addr, lldb::addr_t &func_end, std::shared_ptr &execution_unit_sp, ExecutionContext &exe_ctx, bool &can_interpret, - lldb_private::ExecutionPolicy execution_policy) = 0; + lldb_private::ExecutionPolicy execution_policy); bool GetGenerateDebugInfo() const { return m_generate_debug_info; } +protected: + virtual Status + DoPrepareForExecution(lldb::addr_t &func_addr, lldb::addr_t &func_end, + std::shared_ptr &execution_unit_sp, + ExecutionContext &exe_ctx, bool &can_interpret, + lldb_private::ExecutionPolicy execution_policy) = 0; + +private: + /// Run all static initializers for an execution unit. + /// + /// \param[in] execution_unit_sp + /// The execution unit. + /// + /// \param[in] exe_ctx + /// The execution context to use when running them. Thread can't be null. + /// + /// \return + /// The error code indicating the + Status RunStaticInitializers(lldb::IRExecutionUnitSP &execution_unit_sp, + ExecutionContext &exe_ctx); + protected: Expression &m_expr; ///< The expression to be parsed bool m_generate_debug_info; diff --git a/lldb/source/Expression/CMakeLists.txt b/lldb/source/Expression/CMakeLists.txt index 3bf2d3bf220ee..e6c34635f38cc 100644 --- a/lldb/source/Expression/CMakeLists.txt +++ b/lldb/source/Expression/CMakeLists.txt @@ -10,6 +10,7 @@ add_lldb_library(lldbExpression ${PLUGIN_DEPENDENCY_ARG} DWARFExpression.cpp DWARFExpressionList.cpp Expression.cpp + ExpressionParser.cpp ExpressionTypeSystemHelper.cpp ExpressionVariable.cpp FunctionCaller.cpp diff --git a/lldb/source/Expression/ExpressionParser.cpp b/lldb/source/Expression/ExpressionParser.cpp new file mode 100644 index 0000000000000..e9f7121c2499e --- /dev/null +++ b/lldb/source/Expression/ExpressionParser.cpp @@ -0,0 +1,72 @@ +//===-- ExpressionParser.cpp ----------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// + +#include "lldb/Expression/ExpressionParser.h" +#include "lldb/Expression/DiagnosticManager.h" +#include "lldb/Expression/IRExecutionUnit.h" +#include "lldb/Target/ExecutionContext.h" +#include "lldb/Target/ThreadPlanCallFunction.h" + +using namespace lldb; +using namespace lldb_private; + +Status ExpressionParser::PrepareForExecution( + addr_t &func_addr, addr_t &func_end, + std::shared_ptr &execution_unit_sp, + ExecutionContext &exe_ctx, bool &can_interpret, + ExecutionPolicy execution_policy) { + Status status = + DoPrepareForExecution(func_addr, func_end, execution_unit_sp, exe_ctx, + can_interpret, execution_policy); + if (status.Success() && exe_ctx.GetProcessPtr() && exe_ctx.HasThreadScope()) + status = RunStaticInitializers(execution_unit_sp, exe_ctx); + + return status; +} + +Status +ExpressionParser::RunStaticInitializers(IRExecutionUnitSP &execution_unit_sp, + ExecutionContext &exe_ctx) { + Status err; + + if (!execution_unit_sp.get()) { + err.SetErrorString( + "can't run static initializers for a NULL execution unit"); + return err; + } + + if (!exe_ctx.HasThreadScope()) { + err.SetErrorString("can't run static initializers without a thread"); + return err; + } + + std::vector static_initializers; + + execution_unit_sp->GetStaticInitializers(static_initializers); + + for (addr_t static_initializer : static_initializers) { + EvaluateExpressionOptions options; + + ThreadPlanSP call_static_initializer(new ThreadPlanCallFunction( + exe_ctx.GetThreadRef(), Address(static_initializer), CompilerType(), + llvm::ArrayRef(), options)); + + DiagnosticManager execution_errors; + ExpressionResults results = + exe_ctx.GetThreadRef().GetProcess()->RunThreadPlan( + exe_ctx, call_static_initializer, options, execution_errors); + + if (results != eExpressionCompleted) { + err.SetErrorStringWithFormat("couldn't run static initializer: %s", + execution_errors.GetString().c_str()); + return err; + } + } + + return err; +} diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp index 1dd98567f8d69..303e88feea20b 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp @@ -1296,7 +1296,7 @@ static bool FindFunctionInModule(ConstString &mangled_name, return false; } -lldb_private::Status ClangExpressionParser::PrepareForExecution( +lldb_private::Status ClangExpressionParser::DoPrepareForExecution( lldb::addr_t &func_addr, lldb::addr_t &func_end, lldb::IRExecutionUnitSP &execution_unit_sp, ExecutionContext &exe_ctx, bool &can_interpret, ExecutionPolicy execution_policy) { @@ -1472,47 +1472,3 @@ lldb_private::Status ClangExpressionParser::PrepareForExecution( return err; } - -lldb_private::Status ClangExpressionParser::RunStaticInitializers( - lldb::IRExecutionUnitSP &execution_unit_sp, ExecutionContext &exe_ctx) { - lldb_private::Status err; - - lldbassert(execution_unit_sp.get()); - lldbassert(exe_ctx.HasThreadScope()); - - if (!execution_unit_sp.get()) { - err.SetErrorString( - "can't run static initializers for a NULL execution unit"); - return err; - } - - if (!exe_ctx.HasThreadScope()) { - err.SetErrorString("can't run static initializers without a thread"); - return err; - } - - std::vector static_initializers; - - execution_unit_sp->GetStaticInitializers(static_initializers); - - for (lldb::addr_t static_initializer : static_initializers) { - EvaluateExpressionOptions options; - - lldb::ThreadPlanSP call_static_initializer(new ThreadPlanCallFunction( - exe_ctx.GetThreadRef(), Address(static_initializer), CompilerType(), - llvm::ArrayRef(), options)); - - DiagnosticManager execution_errors; - lldb::ExpressionResults results = - exe_ctx.GetThreadRef().GetProcess()->RunThreadPlan( - exe_ctx, call_static_initializer, options, execution_errors); - - if (results != lldb::eExpressionCompleted) { - err.SetErrorStringWithFormat("couldn't run static initializer: %s", - execution_errors.GetString().c_str()); - return err; - } - } - - return err; -} diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h index 185a5a381f23c..0852e928a9d42 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h @@ -113,24 +113,11 @@ class ClangExpressionParser : public ExpressionParser { /// \return /// An error code indicating the success or failure of the operation. /// Test with Success(). - Status - PrepareForExecution(lldb::addr_t &func_addr, lldb::addr_t &func_end, - lldb::IRExecutionUnitSP &execution_unit_sp, - ExecutionContext &exe_ctx, bool &can_interpret, - lldb_private::ExecutionPolicy execution_policy) override; - - /// Run all static initializers for an execution unit. - /// - /// \param[in] execution_unit_sp - /// The execution unit. - /// - /// \param[in] exe_ctx - /// The execution context to use when running them. Thread can't be null. - /// - /// \return - /// The error code indicating the - Status RunStaticInitializers(lldb::IRExecutionUnitSP &execution_unit_sp, - ExecutionContext &exe_ctx); + Status DoPrepareForExecution( + lldb::addr_t &func_addr, lldb::addr_t &func_end, + lldb::IRExecutionUnitSP &execution_unit_sp, ExecutionContext &exe_ctx, + bool &can_interpret, + lldb_private::ExecutionPolicy execution_policy) override; /// Returns a string representing current ABI. /// diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp b/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp index c7e98d12590d9..35038a56440d5 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp @@ -698,21 +698,6 @@ bool ClangUserExpression::Parse(DiagnosticManager &diagnostic_manager, if (!parse_success) return false; - if (exe_ctx.GetProcessPtr() && execution_policy == eExecutionPolicyTopLevel) { - Status static_init_error = - m_parser->RunStaticInitializers(m_execution_unit_sp, exe_ctx); - - if (!static_init_error.Success()) { - const char *error_cstr = static_init_error.AsCString(); - if (error_cstr && error_cstr[0]) - diagnostic_manager.Printf(lldb::eSeverityError, "%s\n", error_cstr); - else - diagnostic_manager.PutString(lldb::eSeverityError, - "couldn't run static initializers\n"); - return false; - } - } - if (m_execution_unit_sp) { bool register_execution_unit = false; diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserSwift.h b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserSwift.h index b368921b4b85a..1aacf38ec86b7 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserSwift.h +++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserSwift.h @@ -70,11 +70,11 @@ class DWARFASTParserSwift : public lldb_private::plugin::dwarf::DWARFASTParser, lldb_private::CompilerDeclContext decl_context) override {} // FIXME: What should this do? - lldb_private::ConstString + std::string GetDIEClassTemplateParams(const DWARFDIE &die) override { assert(false && "DWARFASTParserSwift::GetDIEClassTemplateParams has not " "yet been implemented"); - return lldb_private::ConstString(); + return {}; } static bool classof(const DWARFASTParser *Parser) { diff --git a/lldb/source/Target/ThreadPlanStepOverRange.cpp b/lldb/source/Target/ThreadPlanStepOverRange.cpp index 48855693ad317..a0b16f4573957 100644 --- a/lldb/source/Target/ThreadPlanStepOverRange.cpp +++ b/lldb/source/Target/ThreadPlanStepOverRange.cpp @@ -334,37 +334,6 @@ bool ThreadPlanStepOverRange::ShouldStop(Event *event_ptr) { return false; } -bool ThreadPlanStepRange::DoPlanExplainsStop(Event *event_ptr) { - // For crashes, breakpoint hits, signals, etc,cd let the base plan (or some - // plan above us) handle the stop. That way the user can see the stop, step - // around, and then when they are done, continue and have their step - // complete. The exception is if we've hit our "run to next branch" - // breakpoint. Note, unlike the step in range plan, we don't mark ourselves - // complete if we hit an unexplained breakpoint/crash. - - Log *log = GetLog(LLDBLog::Step); - StopInfoSP stop_info_sp = GetPrivateStopInfo(); - bool return_value; - - if (stop_info_sp) { - StopReason reason = stop_info_sp->GetStopReason(); - - if (reason == eStopReasonTrace) { - return_value = true; - } else if (reason == eStopReasonBreakpoint) { - return_value = NextRangeBreakpointExplainsStop(stop_info_sp); - } else { - if (log) - log->PutCString("ThreadPlanStepOverRange got asked if it explains the " - "stop for some reason other than step."); - return_value = false; - } - } else - return_value = true; - - return return_value; -} - bool ThreadPlanStepOverRange::DoWillResume(lldb::StateType resume_state, bool current_plan) { if (resume_state != eStateSuspended && m_first_resume) {