1 //===-- Language.cpp -------------------------------------------------*- C++
2 //-*-===//
3 //
4 //                     The LLVM Compiler Infrastructure
5 //
6 // This file is distributed under the University of Illinois Open Source
7 // License. See LICENSE.TXT for details.
8 //
9 //===----------------------------------------------------------------------===//
10 
11 #include <functional>
12 #include <map>
13 #include <mutex>
14 
15 #include "lldb/Target/Language.h"
16 
17 #include "lldb/Core/PluginManager.h"
18 #include "lldb/Core/Stream.h"
19 #include "lldb/Symbol/SymbolFile.h"
20 #include "lldb/Symbol/TypeList.h"
21 #include "lldb/Target/Target.h"
22 
23 using namespace lldb;
24 using namespace lldb_private;
25 using namespace lldb_private::formatters;
26 
27 typedef std::unique_ptr<Language> LanguageUP;
28 typedef std::map<lldb::LanguageType, LanguageUP> LanguagesMap;
29 
30 static LanguagesMap &GetLanguagesMap() {
31   static LanguagesMap *g_map = nullptr;
32   static std::once_flag g_initialize;
33 
34   std::call_once(g_initialize, [] {
35     g_map = new LanguagesMap(); // NOTE: INTENTIONAL LEAK due to global
36                                 // destructor chain
37   });
38 
39   return *g_map;
40 }
41 static std::mutex &GetLanguagesMutex() {
42   static std::mutex *g_mutex = nullptr;
43   static std::once_flag g_initialize;
44 
45   std::call_once(g_initialize, [] {
46     g_mutex = new std::mutex(); // NOTE: INTENTIONAL LEAK due to global
47                                 // destructor chain
48   });
49 
50   return *g_mutex;
51 }
52 
53 Language *Language::FindPlugin(lldb::LanguageType language) {
54   std::lock_guard<std::mutex> guard(GetLanguagesMutex());
55   LanguagesMap &map(GetLanguagesMap());
56   auto iter = map.find(language), end = map.end();
57   if (iter != end)
58     return iter->second.get();
59 
60   Language *language_ptr = nullptr;
61   LanguageCreateInstance create_callback;
62 
63   for (uint32_t idx = 0;
64        (create_callback =
65             PluginManager::GetLanguageCreateCallbackAtIndex(idx)) != nullptr;
66        ++idx) {
67     language_ptr = create_callback(language);
68 
69     if (language_ptr) {
70       map[language] = std::unique_ptr<Language>(language_ptr);
71       return language_ptr;
72     }
73   }
74 
75   return nullptr;
76 }
77 
78 void Language::ForEach(std::function<bool(Language *)> callback) {
79   std::lock_guard<std::mutex> guard(GetLanguagesMutex());
80   LanguagesMap &map(GetLanguagesMap());
81   for (const auto &entry : map) {
82     if (!callback(entry.second.get()))
83       break;
84   }
85 }
86 
87 bool Language::IsTopLevelFunction(Function &function) { return false; }
88 
89 lldb::TypeCategoryImplSP Language::GetFormatters() { return nullptr; }
90 
91 HardcodedFormatters::HardcodedFormatFinder Language::GetHardcodedFormats() {
92   return {};
93 }
94 
95 HardcodedFormatters::HardcodedSummaryFinder Language::GetHardcodedSummaries() {
96   return {};
97 }
98 
99 HardcodedFormatters::HardcodedSyntheticFinder
100 Language::GetHardcodedSynthetics() {
101   return {};
102 }
103 
104 HardcodedFormatters::HardcodedValidatorFinder
105 Language::GetHardcodedValidators() {
106   return {};
107 }
108 
109 std::vector<ConstString>
110 Language::GetPossibleFormattersMatches(ValueObject &valobj,
111                                        lldb::DynamicValueType use_dynamic) {
112   return {};
113 }
114 
115 lldb_private::formatters::StringPrinter::EscapingHelper
116 Language::GetStringPrinterEscapingHelper(
117     lldb_private::formatters::StringPrinter::GetPrintableElementType
118         elem_type) {
119   return StringPrinter::GetDefaultEscapingHelper(elem_type);
120 }
121 
122 struct language_name_pair {
123   const char *name;
124   LanguageType type;
125 };
126 
127 struct language_name_pair language_names[] = {
128     // To allow GetNameForLanguageType to be a simple array lookup, the first
129     // part of this array must follow enum LanguageType exactly.
130     {"unknown", eLanguageTypeUnknown},
131     {"c89", eLanguageTypeC89},
132     {"c", eLanguageTypeC},
133     {"ada83", eLanguageTypeAda83},
134     {"c++", eLanguageTypeC_plus_plus},
135     {"cobol74", eLanguageTypeCobol74},
136     {"cobol85", eLanguageTypeCobol85},
137     {"fortran77", eLanguageTypeFortran77},
138     {"fortran90", eLanguageTypeFortran90},
139     {"pascal83", eLanguageTypePascal83},
140     {"modula2", eLanguageTypeModula2},
141     {"java", eLanguageTypeJava},
142     {"c99", eLanguageTypeC99},
143     {"ada95", eLanguageTypeAda95},
144     {"fortran95", eLanguageTypeFortran95},
145     {"pli", eLanguageTypePLI},
146     {"objective-c", eLanguageTypeObjC},
147     {"objective-c++", eLanguageTypeObjC_plus_plus},
148     {"upc", eLanguageTypeUPC},
149     {"d", eLanguageTypeD},
150     {"python", eLanguageTypePython},
151     {"opencl", eLanguageTypeOpenCL},
152     {"go", eLanguageTypeGo},
153     {"modula3", eLanguageTypeModula3},
154     {"haskell", eLanguageTypeHaskell},
155     {"c++03", eLanguageTypeC_plus_plus_03},
156     {"c++11", eLanguageTypeC_plus_plus_11},
157     {"ocaml", eLanguageTypeOCaml},
158     {"rust", eLanguageTypeRust},
159     {"c11", eLanguageTypeC11},
160     {"swift", eLanguageTypeSwift},
161     {"julia", eLanguageTypeJulia},
162     {"dylan", eLanguageTypeDylan},
163     {"c++14", eLanguageTypeC_plus_plus_14},
164     {"fortran03", eLanguageTypeFortran03},
165     {"fortran08", eLanguageTypeFortran08},
166     // Vendor Extensions
167     {"mipsassem", eLanguageTypeMipsAssembler},
168     {"renderscript", eLanguageTypeExtRenderScript},
169     // Now synonyms, in arbitrary order
170     {"objc", eLanguageTypeObjC},
171     {"objc++", eLanguageTypeObjC_plus_plus},
172     {"pascal", eLanguageTypePascal83}};
173 
174 static uint32_t num_languages =
175     sizeof(language_names) / sizeof(struct language_name_pair);
176 
177 LanguageType Language::GetLanguageTypeFromString(llvm::StringRef string) {
178   for (const auto &L : language_names) {
179     if (string.equals_lower(L.name))
180       return static_cast<LanguageType>(L.type);
181   }
182 
183   return eLanguageTypeUnknown;
184 }
185 
186 const char *Language::GetNameForLanguageType(LanguageType language) {
187   if (language < num_languages)
188     return language_names[language].name;
189   else
190     return language_names[eLanguageTypeUnknown].name;
191 }
192 
193 void Language::PrintAllLanguages(Stream &s, const char *prefix,
194                                  const char *suffix) {
195   for (uint32_t i = 1; i < num_languages; i++) {
196     s.Printf("%s%s%s", prefix, language_names[i].name, suffix);
197   }
198 }
199 
200 void Language::ForAllLanguages(
201     std::function<bool(lldb::LanguageType)> callback) {
202   for (uint32_t i = 1; i < num_languages; i++) {
203     if (!callback(language_names[i].type))
204       break;
205   }
206 }
207 
208 bool Language::LanguageIsCPlusPlus(LanguageType language) {
209   switch (language) {
210   case eLanguageTypeC_plus_plus:
211   case eLanguageTypeC_plus_plus_03:
212   case eLanguageTypeC_plus_plus_11:
213   case eLanguageTypeC_plus_plus_14:
214   case eLanguageTypeObjC_plus_plus:
215     return true;
216   default:
217     return false;
218   }
219 }
220 
221 bool Language::LanguageIsObjC(LanguageType language) {
222   switch (language) {
223   case eLanguageTypeObjC:
224   case eLanguageTypeObjC_plus_plus:
225     return true;
226   default:
227     return false;
228   }
229 }
230 
231 bool Language::LanguageIsC(LanguageType language) {
232   switch (language) {
233   case eLanguageTypeC:
234   case eLanguageTypeC89:
235   case eLanguageTypeC99:
236   case eLanguageTypeC11:
237     return true;
238   default:
239     return false;
240   }
241 }
242 
243 bool Language::LanguageIsPascal(LanguageType language) {
244   switch (language) {
245   case eLanguageTypePascal83:
246     return true;
247   default:
248     return false;
249   }
250 }
251 
252 LanguageType Language::GetPrimaryLanguage(LanguageType language) {
253   switch (language) {
254   case eLanguageTypeC_plus_plus:
255   case eLanguageTypeC_plus_plus_03:
256   case eLanguageTypeC_plus_plus_11:
257   case eLanguageTypeC_plus_plus_14:
258     return eLanguageTypeC_plus_plus;
259   case eLanguageTypeC:
260   case eLanguageTypeC89:
261   case eLanguageTypeC99:
262   case eLanguageTypeC11:
263     return eLanguageTypeC;
264   case eLanguageTypeObjC:
265   case eLanguageTypeObjC_plus_plus:
266     return eLanguageTypeObjC;
267   case eLanguageTypePascal83:
268   case eLanguageTypeCobol74:
269   case eLanguageTypeCobol85:
270   case eLanguageTypeFortran77:
271   case eLanguageTypeFortran90:
272   case eLanguageTypeFortran95:
273   case eLanguageTypeFortran03:
274   case eLanguageTypeFortran08:
275   case eLanguageTypeAda83:
276   case eLanguageTypeAda95:
277   case eLanguageTypeModula2:
278   case eLanguageTypeJava:
279   case eLanguageTypePLI:
280   case eLanguageTypeUPC:
281   case eLanguageTypeD:
282   case eLanguageTypePython:
283   case eLanguageTypeOpenCL:
284   case eLanguageTypeGo:
285   case eLanguageTypeModula3:
286   case eLanguageTypeHaskell:
287   case eLanguageTypeOCaml:
288   case eLanguageTypeRust:
289   case eLanguageTypeSwift:
290   case eLanguageTypeJulia:
291   case eLanguageTypeDylan:
292   case eLanguageTypeMipsAssembler:
293   case eLanguageTypeExtRenderScript:
294   case eLanguageTypeUnknown:
295   default:
296     return language;
297   }
298 }
299 
300 void Language::GetLanguagesSupportingTypeSystems(
301     std::set<lldb::LanguageType> &languages,
302     std::set<lldb::LanguageType> &languages_for_expressions) {
303   uint32_t idx = 0;
304 
305   while (TypeSystemEnumerateSupportedLanguages enumerate = PluginManager::
306              GetTypeSystemEnumerateSupportedLanguagesCallbackAtIndex(idx++)) {
307     (*enumerate)(languages, languages_for_expressions);
308   }
309 }
310 
311 void Language::GetLanguagesSupportingREPLs(
312     std::set<lldb::LanguageType> &languages) {
313   uint32_t idx = 0;
314 
315   while (REPLEnumerateSupportedLanguages enumerate =
316              PluginManager::GetREPLEnumerateSupportedLanguagesCallbackAtIndex(
317                  idx++)) {
318     (*enumerate)(languages);
319   }
320 }
321 
322 std::unique_ptr<Language::TypeScavenger> Language::GetTypeScavenger() {
323   return nullptr;
324 }
325 
326 const char *Language::GetLanguageSpecificTypeLookupHelp() { return nullptr; }
327 
328 size_t Language::TypeScavenger::Find(ExecutionContextScope *exe_scope,
329                                      const char *key, ResultSet &results,
330                                      bool append) {
331   if (!exe_scope || !exe_scope->CalculateTarget().get())
332     return false;
333 
334   if (!key || !key[0])
335     return false;
336 
337   if (!append)
338     results.clear();
339 
340   size_t old_size = results.size();
341 
342   if (this->Find_Impl(exe_scope, key, results))
343     return results.size() - old_size;
344   return 0;
345 }
346 
347 bool Language::ImageListTypeScavenger::Find_Impl(
348     ExecutionContextScope *exe_scope, const char *key, ResultSet &results) {
349   bool result = false;
350 
351   Target *target = exe_scope->CalculateTarget().get();
352   if (target) {
353     const auto &images(target->GetImages());
354     SymbolContext null_sc;
355     ConstString cs_key(key);
356     llvm::DenseSet<SymbolFile *> searched_sym_files;
357     TypeList matches;
358     images.FindTypes(null_sc, cs_key, false, UINT32_MAX, searched_sym_files,
359                      matches);
360     for (const auto &match : matches.Types()) {
361       if (match.get()) {
362         CompilerType compiler_type(match->GetFullCompilerType());
363         compiler_type = AdjustForInclusion(compiler_type);
364         if (!compiler_type)
365           continue;
366         std::unique_ptr<Language::TypeScavenger::Result> scavengeresult(
367             new Result(compiler_type));
368         results.insert(std::move(scavengeresult));
369         result = true;
370       }
371     }
372   }
373 
374   return result;
375 }
376 
377 bool Language::GetFormatterPrefixSuffix(ValueObject &valobj,
378                                         ConstString type_hint,
379                                         std::string &prefix,
380                                         std::string &suffix) {
381   return false;
382 }
383 
384 DumpValueObjectOptions::DeclPrintingHelper Language::GetDeclPrintingHelper() {
385   return nullptr;
386 }
387 
388 LazyBool Language::IsLogicalTrue(ValueObject &valobj, Error &error) {
389   return eLazyBoolCalculate;
390 }
391 
392 bool Language::IsNilReference(ValueObject &valobj) { return false; }
393 
394 bool Language::IsUninitializedReference(ValueObject &valobj) { return false; }
395 
396 bool Language::GetFunctionDisplayName(const SymbolContext *sc,
397                                       const ExecutionContext *exe_ctx,
398                                       FunctionNameRepresentation representation,
399                                       Stream &s) {
400   return false;
401 }
402 
403 void Language::GetExceptionResolverDescription(bool catch_on, bool throw_on,
404                                                Stream &s) {
405   GetDefaultExceptionResolverDescription(catch_on, throw_on, s);
406 }
407 
408 void Language::GetDefaultExceptionResolverDescription(bool catch_on,
409                                                       bool throw_on,
410                                                       Stream &s) {
411   s.Printf("Exception breakpoint (catch: %s throw: %s)",
412            catch_on ? "on" : "off", throw_on ? "on" : "off");
413 }
414 //----------------------------------------------------------------------
415 // Constructor
416 //----------------------------------------------------------------------
417 Language::Language() {}
418 
419 //----------------------------------------------------------------------
420 // Destructor
421 //----------------------------------------------------------------------
422 Language::~Language() {}
423