Sprinkle scoped timer support all over the Swift language binding.

The scoped timers translate into Signposts on Darwin and should make
performance tracking much easier.

rdar://76070796
(cherry picked from commit c240be4)

Author: adrian-prantl

lldb/source/Plugins/TypeSystem/Swift/SwiftASTContext.cpp

@@ -4209,6 +4209,7 @@ swift::Identifier SwiftASTContext::GetIdentifier(const llvm::StringRef &name) {
 
 ConstString SwiftASTContext::GetMangledTypeName(swift::TypeBase *type_base) {
   VALID_OR_RETURN(ConstString());
+  LLDB_SCOPED_TIMER();
 
   auto iter = m_type_to_mangled_name_map.find(type_base),
        end = m_type_to_mangled_name_map.end();
@@ -4269,6 +4270,7 @@ SwiftASTContext::GetTypeFromMangledTypename(ConstString mangled_typename) {
 }
 
 CompilerType SwiftASTContext::GetAsClangType(ConstString mangled_name) {
+  LLDB_SCOPED_TIMER();
   if (!swift::Demangle::isObjCSymbol(mangled_name.GetStringRef()))
     return {};
 
@@ -4368,6 +4370,7 @@ swift::TypeBase *SwiftASTContext::ReconstructType(ConstString mangled_typename,
   LOG_PRINTF(LIBLLDB_LOG_TYPES, "(\"%s\") -- not cached, searching",
              mangled_cstr);
 
+  LLDB_SCOPED_TIMERF("%s (not cached)", LLVM_PRETTY_FUNCTION);
   found_type = swift::Demangle::getTypeForMangling(
                    *ast_ctx, mangled_typename.GetStringRef())
                    .getPointer();
@@ -4514,6 +4517,7 @@ SwiftASTContext::FindContainedTypeOrDecl(llvm::StringRef name,
                                          TypeOrDecl container_type_or_decl,
                                          TypesOrDecls &results, bool append) {
   VALID_OR_RETURN(0);
+  LLDB_SCOPED_TIMER();
 
   if (!append)
     results.clear();
@@ -4562,7 +4566,7 @@ llvm::Optional<SwiftASTContext::TypeOrDecl>
 SwiftASTContext::FindTypeOrDecl(const char *name,
                                 swift::ModuleDecl *swift_module) {
   VALID_OR_RETURN(llvm::Optional<SwiftASTContext::TypeOrDecl>());
-
+ 
   TypesOrDecls search_results;
 
   FindTypesOrDecls(name, swift_module, search_results, false);
@@ -4648,6 +4652,7 @@ size_t SwiftASTContext::FindTypesOrDecls(const char *name,
 size_t SwiftASTContext::FindType(const char *name,
                                  std::set<CompilerType> &results, bool append) {
   VALID_OR_RETURN(0);
+  LLDB_SCOPED_TIMER();
 
   if (!append)
     results.clear();
@@ -4675,6 +4680,7 @@ size_t SwiftASTContext::FindType(const char *name,
 
 CompilerType SwiftASTContext::ImportType(CompilerType &type, Status &error) {
   VALID_OR_RETURN(CompilerType());
+  LLDB_SCOPED_TIMER();
 
   if (m_ast_context_ap.get() == NULL)
     return CompilerType();
@@ -4928,6 +4934,7 @@ void SwiftASTContext::AddErrorStatusAsGenericDiagnostic(Status error) {
 void SwiftASTContext::PrintDiagnostics(DiagnosticManager &diagnostic_manager,
                                        uint32_t bufferID, uint32_t first_line,
                                        uint32_t last_line) {
+  LLDB_SCOPED_TIMER();
   // If this is a fatal error, copy the error into the AST context's
   // fatal error field, and then put it to the stream, otherwise just
   // dump the diagnostics to the stream.
@@ -5241,6 +5248,7 @@ bool SwiftASTContext::IsPossibleDynamicType(opaque_compiler_type_t type,
                                             bool check_cplusplus,
                                             bool check_objc) {
   VALID_OR_RETURN_CHECK_TYPE(type, false);
+  LLDB_SCOPED_TIMER();
 
   auto can_type = GetCanonicalSwiftType(type);
   if (!can_type)
@@ -5340,6 +5348,7 @@ bool SwiftASTContext::IsFullyRealized(const CompilerType &compiler_type) {
 
 bool SwiftASTContext::GetProtocolTypeInfo(const CompilerType &type,
                                           ProtocolInfo &protocol_info) {
+  LLDB_SCOPED_TIMER();
   if (swift::CanType swift_can_type = ::GetCanonicalSwiftType(type)) {
     if (!swift_can_type.isExistentialType())
       return false;
@@ -5419,6 +5428,7 @@ SwiftASTContext::GetTypeRefType(lldb::opaque_compiler_type_t type) {
 ConstString SwiftASTContext::GetTypeName(opaque_compiler_type_t type) {
   VALID_OR_RETURN_CHECK_TYPE(
       type, ConstString("<invalid Swift context or opaque type>"));
+  LLDB_SCOPED_TIMER();
   std::string type_name;
   swift::Type swift_type(GetSwiftType(type));
 
@@ -5442,6 +5452,7 @@ ConstString SwiftASTContext::GetTypeName(opaque_compiler_type_t type) {
 static llvm::DenseMap<swift::CanType, swift::Identifier>
 GetArchetypeNames(swift::Type swift_type, swift::ASTContext &ast_ctx,
                   const SymbolContext *sc) {
+  LLDB_SCOPED_TIMER();
   llvm::DenseMap<swift::CanType, swift::Identifier> dict;
 
   assert(&swift_type->getASTContext() == &ast_ctx);
@@ -5469,6 +5480,7 @@ ConstString SwiftASTContext::GetDisplayTypeName(opaque_compiler_type_t type,
                                                 const SymbolContext *sc) {
   VALID_OR_RETURN_CHECK_TYPE(
       type, ConstString("<invalid Swift context or opaque type>"));
+  LLDB_SCOPED_TIMER();
   std::string type_name(GetTypeName(type).AsCString(""));
   if (type) {
     swift::Type swift_type(GetSwiftType(type));
@@ -5487,6 +5499,7 @@ uint32_t
 SwiftASTContext::GetTypeInfo(opaque_compiler_type_t type,
                              CompilerType *pointee_or_element_clang_type) {
   VALID_OR_RETURN_CHECK_TYPE(type, 0);
+  LLDB_SCOPED_TIMER();
 
   if (pointee_or_element_clang_type)
     pointee_or_element_clang_type->Clear();
@@ -5810,6 +5823,7 @@ TypeMemberFunctionImpl
 SwiftASTContext::GetMemberFunctionAtIndex(opaque_compiler_type_t type,
                                           size_t idx) {
   VALID_OR_RETURN_CHECK_TYPE(type, TypeMemberFunctionImpl());
+  LLDB_SCOPED_TIMER();
 
   std::string name("");
   CompilerType result_type;
@@ -5983,6 +5997,7 @@ llvm::Optional<uint64_t>
 SwiftASTContext::GetBitSize(opaque_compiler_type_t type,
                             ExecutionContextScope *exe_scope) {
   VALID_OR_RETURN_CHECK_TYPE(type, llvm::None);
+  LLDB_SCOPED_TIMER();
 
   // If the type has type parameters, bind them first.
   swift::CanType swift_can_type(GetCanonicalSwiftType(type));
@@ -6032,6 +6047,7 @@ llvm::Optional<uint64_t>
 SwiftASTContext::GetByteStride(opaque_compiler_type_t type,
                                ExecutionContextScope *exe_scope) {
   VALID_OR_RETURN_CHECK_TYPE(type, llvm::None);
+  LLDB_SCOPED_TIMER();
 
   // If the type has type parameters, bind them first.
   swift::CanType swift_can_type(GetCanonicalSwiftType(type));
@@ -6064,6 +6080,7 @@ llvm::Optional<size_t>
 SwiftASTContext::GetTypeBitAlign(opaque_compiler_type_t type,
                                  ExecutionContextScope *exe_scope) {
   VALID_OR_RETURN_CHECK_TYPE(type, llvm::None);
+  LLDB_SCOPED_TIMER();
 
   // If the type has type parameters, bind them first.
   swift::CanType swift_can_type(GetCanonicalSwiftType(type));
@@ -6264,6 +6281,7 @@ uint32_t SwiftASTContext::GetNumChildren(opaque_compiler_type_t type,
                                          bool omit_empty_base_classes,
                                          const ExecutionContext *exe_ctx) {
   VALID_OR_RETURN_CHECK_TYPE(type, 0);
+  LLDB_SCOPED_TIMER();
 
   uint32_t num_children = 0;
 
@@ -6605,6 +6623,7 @@ CompilerType SwiftASTContext::GetFieldAtIndex(opaque_compiler_type_t type,
                                               uint32_t *bitfield_bit_size_ptr,
                                               bool *is_bitfield_ptr) {
   VALID_OR_RETURN_CHECK_TYPE(type, CompilerType());
+  LLDB_SCOPED_TIMER();
 
   swift::CanType swift_can_type(GetCanonicalSwiftType(type));
 
@@ -6936,6 +6955,7 @@ CompilerType SwiftASTContext::GetChildCompilerTypeAtIndex(
     bool &child_is_base_class, bool &child_is_deref_of_parent,
     ValueObject *valobj, uint64_t &language_flags) {
   VALID_OR_RETURN_CHECK_TYPE(type, CompilerType());
+  LLDB_SCOPED_TIMER();
 
   auto get_type_size = [&exe_ctx](uint32_t &result, CompilerType type) {
     auto *exe_scope =
@@ -7242,6 +7262,7 @@ size_t SwiftASTContext::GetIndexOfChildMemberWithName(
     opaque_compiler_type_t type, const char *name, ExecutionContext *exe_ctx,
     bool omit_empty_base_classes, std::vector<uint32_t> &child_indexes) {
   VALID_OR_RETURN_CHECK_TYPE(type, 0);
+  LLDB_SCOPED_TIMER();
 
   if (name && name[0]) {
     swift::CanType swift_can_type(GetCanonicalSwiftType(type));
@@ -7607,6 +7628,7 @@ bool SwiftASTContext::DumpTypeValue(
     size_t byte_size, uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
     ExecutionContextScope *exe_scope, bool is_base_class) {
   VALID_OR_RETURN_CHECK_TYPE(type, false);
+  LLDB_SCOPED_TIMER();
 
   swift::CanType swift_can_type(GetCanonicalSwiftType(type));
 
@@ -7773,7 +7795,7 @@ bool SwiftASTContext::DumpTypeValue(
 bool SwiftASTContext::IsImportedType(opaque_compiler_type_t type,
                                      CompilerType *original_type) {
   VALID_OR_RETURN_CHECK_TYPE(type, false);
-
+  LLDB_SCOPED_TIMER();
   bool success = false;
 
   if (swift::Type swift_can_type = GetSwiftType(type)) {
@@ -7892,6 +7914,7 @@ void SwiftASTContext::DumpTypeDescription(opaque_compiler_type_t type,
                                           bool print_help_if_available,
                                           bool print_extensions_if_available,
                                           lldb::DescriptionLevel level) {
+  LLDB_SCOPED_TIMER();
   const auto initial_written_bytes = s->GetWrittenBytes();
 
   if (type) {
@@ -8193,6 +8216,7 @@ static swift::ModuleDecl *LoadOneModule(const SourceModule &module,
                                         SwiftASTContext &swift_ast_context,
                                         lldb::StackFrameWP &stack_frame_wp,
                                         Status &error) {
+  LLDB_SCOPED_TIMER();
   if (!module.path.size())
     return nullptr;
 
@@ -8253,6 +8277,7 @@ bool SwiftASTContext::GetImplicitImports(
     llvm::SmallVectorImpl<swift::AttributedImport<swift::ImportedModule>>
         &modules,
     Status &error) {
+  LLDB_SCOPED_TIMER();
   if (!swift_ast_context.GetCompileUnitImports(sc, stack_frame_wp, modules,
                                                error)) {
     return false;
@@ -8348,6 +8373,7 @@ bool SwiftASTContext::GetCompileUnitImportsImpl(
     llvm::SmallVectorImpl<swift::AttributedImport<swift::ImportedModule>>
         *modules,
     Status &error) {
+  LLDB_SCOPED_TIMER();
   CompileUnit *compile_unit = sc.comp_unit;
   if (compile_unit)
     // Check the cache if this compile unit's imports were previously

lldb/source/Target/Target.cpp

@@ -2509,6 +2509,7 @@ Target::CreateUtilityFunction(std::string expression, std::string name,
 llvm::Optional<SwiftASTContextReader> Target::GetScratchSwiftASTContext(
     Status &error, ExecutionContextScope &exe_scope, bool create_on_demand) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_TARGET));
+  LLDB_SCOPED_TIMER();
 
   Module *lldb_module = nullptr;
   if (m_use_scratch_typesystem_per_module)