contrib/llvm/tools/lldb/source/Target/LanguageRuntime.cpp

   1 //===-- LanguageRuntime.cpp -------------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Target/LanguageRuntime.h"
  11 #include "lldb/Target/Target.h"
  12 #include "lldb/Core/PluginManager.h"
  13
  14 using namespace lldb;
  15 using namespace lldb_private;
  16
  17
  18 class ExceptionSearchFilter : public SearchFilter
  19 {
  20 public:
  21     ExceptionSearchFilter (const lldb::TargetSP &target_sp,
  22                            lldb::LanguageType language) :
  23         SearchFilter (target_sp),
  24         m_language (language),
  25         m_language_runtime (NULL),
  26         m_filter_sp ()
  27     {
  28         UpdateModuleListIfNeeded ();
  29     }
  30
  31     virtual bool
  32     ModulePasses (const lldb::ModuleSP &module_sp)
  33     {
  34         UpdateModuleListIfNeeded ();
  35         if (m_filter_sp)
  36             return m_filter_sp->ModulePasses (module_sp);
  37         return false;
  38     }
  39
  40     virtual bool
  41     ModulePasses (const FileSpec &spec)
  42     {
  43         UpdateModuleListIfNeeded ();
  44         if (m_filter_sp)
  45             return m_filter_sp->ModulePasses (spec);
  46         return false;
  47
  48     }
  49
  50     virtual void
  51     Search (Searcher &searcher)
  52     {
  53         UpdateModuleListIfNeeded ();
  54         if (m_filter_sp)
  55             m_filter_sp->Search (searcher);
  56     }
  57
  58     virtual void
  59     GetDescription (Stream *s)
  60     {
  61         UpdateModuleListIfNeeded ();
  62         if (m_filter_sp)
  63             m_filter_sp->GetDescription (s);
  64     }
  65
  66 protected:
  67     LanguageType m_language;
  68     LanguageRuntime *m_language_runtime;
  69     SearchFilterSP m_filter_sp;
  70
  71     void
  72     UpdateModuleListIfNeeded ()
  73     {
  74         ProcessSP process_sp (m_target_sp->GetProcessSP());
  75         if (process_sp)
  76         {
  77             bool refreash_filter = !m_filter_sp;
  78             if (m_language_runtime == NULL)
  79             {
  80                 m_language_runtime = process_sp->GetLanguageRuntime(m_language);
  81                 refreash_filter = true;
  82             }
  83             else
  84             {
  85                 LanguageRuntime *language_runtime = process_sp->GetLanguageRuntime(m_language);
  86                 if (m_language_runtime != language_runtime)
  87                 {
  88                     m_language_runtime = language_runtime;
  89                     refreash_filter = true;
  90                 }
  91             }
  92
  93             if (refreash_filter && m_language_runtime)
  94             {
  95                 m_filter_sp = m_language_runtime->CreateExceptionSearchFilter ();
  96             }
  97         }
  98         else
  99         {
 100             m_filter_sp.reset();
 101             m_language_runtime = NULL;
 102         }
 103     }
 104 };
 105
 106 // The Target is the one that knows how to create breakpoints, so this function
 107 // is meant to be used either by the target or internally in Set/ClearExceptionBreakpoints.
 108 class ExceptionBreakpointResolver : public BreakpointResolver
 109 {
 110 public:
 111     ExceptionBreakpointResolver (lldb::LanguageType language,
 112                                  bool catch_bp,
 113                                  bool throw_bp) :
 114         BreakpointResolver (NULL, BreakpointResolver::ExceptionResolver),
 115         m_language (language),
 116         m_language_runtime (NULL),
 117         m_catch_bp (catch_bp),
 118         m_throw_bp (throw_bp)
 119     {
 120     }
 121
 122     virtual
 123     ~ExceptionBreakpointResolver()
 124     {
 125     }
 126
 127     virtual Searcher::CallbackReturn
 128     SearchCallback (SearchFilter &filter,
 129                     SymbolContext &context,
 130                     Address *addr,
 131                     bool containing)
 132     {
 133
 134         if (SetActualResolver())
 135             return m_actual_resolver_sp->SearchCallback (filter, context, addr, containing);
 136         else
 137             return eCallbackReturnStop;
 138     }
 139
 140     virtual Searcher::Depth
 141     GetDepth ()
 142     {
 143         if (SetActualResolver())
 144             return m_actual_resolver_sp->GetDepth();
 145         else
 146             return eDepthTarget;
 147     }
 148
 149     virtual void
 150     GetDescription (Stream *s)
 151     {
 152         s->Printf ("Exception breakpoint (catch: %s throw: %s)",
 153                    m_catch_bp ? "on" : "off",
 154                    m_throw_bp ? "on" : "off");
 155
 156         SetActualResolver();
 157         if (m_actual_resolver_sp)
 158         {
 159             s->Printf (" using: ");
 160             m_actual_resolver_sp->GetDescription (s);
 161         }
 162         else
 163             s->Printf (" the correct runtime exception handler will be determined when you run");
 164     }
 165
 166     virtual void
 167     Dump (Stream *s) const
 168     {
 169     }
 170
 171     /// Methods for support type inquiry through isa, cast, and dyn_cast:
 172     static inline bool classof(const BreakpointResolverName *) { return true; }
 173     static inline bool classof(const BreakpointResolver *V) {
 174         return V->getResolverID() == BreakpointResolver::ExceptionResolver;
 175     }
 176 protected:
 177     bool
 178     SetActualResolver()
 179     {
 180         ProcessSP process_sp;
 181         if (m_breakpoint)
 182         {
 183             process_sp = m_breakpoint->GetTarget().GetProcessSP();
 184             if (process_sp)
 185             {
 186                 bool refreash_resolver = !m_actual_resolver_sp;
 187                 if (m_language_runtime == NULL)
 188                 {
 189                     m_language_runtime = process_sp->GetLanguageRuntime(m_language);
 190                     refreash_resolver = true;
 191                 }
 192                 else
 193                 {
 194                     LanguageRuntime *language_runtime = process_sp->GetLanguageRuntime(m_language);
 195                     if (m_language_runtime != language_runtime)
 196                     {
 197                         m_language_runtime = language_runtime;
 198                         refreash_resolver = true;
 199                     }
 200                 }
 201
 202                 if (refreash_resolver && m_language_runtime)
 203                 {
 204                     m_actual_resolver_sp = m_language_runtime->CreateExceptionResolver (m_breakpoint, m_catch_bp, m_throw_bp);
 205                 }
 206             }
 207             else
 208             {
 209                 m_actual_resolver_sp.reset();
 210                 m_language_runtime = NULL;
 211             }
 212         }
 213         else
 214         {
 215             m_actual_resolver_sp.reset();
 216             m_language_runtime = NULL;
 217         }
 218         return (bool)m_actual_resolver_sp;
 219     }
 220     lldb::BreakpointResolverSP m_actual_resolver_sp;
 221     lldb::LanguageType m_language;
 222     LanguageRuntime *m_language_runtime;
 223     bool m_catch_bp;
 224     bool m_throw_bp;
 225 };
 226
 227
 228 LanguageRuntime*
 229 LanguageRuntime::FindPlugin (Process *process, lldb::LanguageType language)
 230 {
 231     std::unique_ptr<LanguageRuntime> language_runtime_ap;
 232     LanguageRuntimeCreateInstance create_callback;
 233
 234     for (uint32_t idx = 0;
 235          (create_callback = PluginManager::GetLanguageRuntimeCreateCallbackAtIndex(idx)) != NULL;
 236          ++idx)
 237     {
 238         language_runtime_ap.reset (create_callback(process, language));
 239
 240         if (language_runtime_ap.get())
 241             return language_runtime_ap.release();
 242     }
 243
 244     return NULL;
 245 }
 246
 247 //----------------------------------------------------------------------
 248 // Constructor
 249 //----------------------------------------------------------------------
 250 LanguageRuntime::LanguageRuntime(Process *process) :
 251     m_process (process)
 252 {
 253 }
 254
 255 //----------------------------------------------------------------------
 256 // Destructor
 257 //----------------------------------------------------------------------
 258 LanguageRuntime::~LanguageRuntime()
 259 {
 260 }
 261
 262 BreakpointSP
 263 LanguageRuntime::CreateExceptionBreakpoint (Target &target,
 264                                             lldb::LanguageType language,
 265                                             bool catch_bp,
 266                                             bool throw_bp,
 267                                             bool is_internal)
 268 {
 269     BreakpointResolverSP resolver_sp(new ExceptionBreakpointResolver(language, catch_bp, throw_bp));
 270     SearchFilterSP filter_sp(new ExceptionSearchFilter(target.shared_from_this(), language));
 271
 272     BreakpointSP exc_breakpt_sp (target.CreateBreakpoint (filter_sp, resolver_sp, is_internal));
 273     if (is_internal)
 274         exc_breakpt_sp->SetBreakpointKind("exception");
 275
 276     return exc_breakpt_sp;
 277 }
 278
 279 struct language_name_pair {
 280     const char *name;
 281     LanguageType type;
 282 };
 283
 284 struct language_name_pair language_names[] =
 285 {
 286     // To allow GetNameForLanguageType to be a simple array lookup, the first
 287     // part of this array must follow enum LanguageType exactly.
 288     {   "unknown",          eLanguageTypeUnknown        },
 289     {   "c89",              eLanguageTypeC89            },
 290     {   "c",                eLanguageTypeC              },
 291     {   "ada83",            eLanguageTypeAda83          },
 292     {   "c++",              eLanguageTypeC_plus_plus    },
 293     {   "cobol74",          eLanguageTypeCobol74        },
 294     {   "cobol85",          eLanguageTypeCobol85        },
 295     {   "fortran77",        eLanguageTypeFortran77      },
 296     {   "fortran90",        eLanguageTypeFortran90      },
 297     {   "pascal83",         eLanguageTypePascal83       },
 298     {   "modula2",          eLanguageTypeModula2        },
 299     {   "java",             eLanguageTypeJava           },
 300     {   "c99",              eLanguageTypeC99            },
 301     {   "ada95",            eLanguageTypeAda95          },
 302     {   "fortran95",        eLanguageTypeFortran95      },
 303     {   "pli",              eLanguageTypePLI            },
 304     {   "objective-c",      eLanguageTypeObjC           },
 305     {   "objective-c++",    eLanguageTypeObjC_plus_plus },
 306     {   "upc",              eLanguageTypeUPC            },
 307     {   "d",                eLanguageTypeD              },
 308     {   "python",           eLanguageTypePython         },
 309     // Now synonyms, in arbitrary order
 310     {   "objc",             eLanguageTypeObjC           },
 311     {   "objc++",           eLanguageTypeObjC_plus_plus }
 312 };
 313
 314 static uint32_t num_languages = sizeof(language_names) / sizeof (struct language_name_pair);
 315
 316 LanguageType
 317 LanguageRuntime::GetLanguageTypeFromString (const char *string)
 318 {
 319     for (uint32_t i = 0; i < num_languages; i++)
 320     {
 321         if (strcasecmp (language_names[i].name, string) == 0)
 322             return (LanguageType) language_names[i].type;
 323     }
 324     return eLanguageTypeUnknown;
 325 }
 326
 327 const char *
 328 LanguageRuntime::GetNameForLanguageType (LanguageType language)
 329 {
 330     if (language < num_languages)
 331         return language_names[language].name;
 332     else
 333         return language_names[eLanguageTypeUnknown].name;
 334 }
 335
 336 lldb::SearchFilterSP
 337 LanguageRuntime::CreateExceptionSearchFilter ()
 338 {
 339     return m_process->GetTarget().GetSearchFilterForModule(NULL);
 340 }
 341
 342
 343