1 //===-- AppleObjCRuntime.cpp -------------------------------------*- C++
2 //-*-===//
3 //
4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5 // See https://llvm.org/LICENSE.txt for license information.
6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "AppleObjCRuntime.h"
11 #include "AppleObjCTrampolineHandler.h"
12 
13 #include "clang/AST/Type.h"
14 
15 #include "lldb/Breakpoint/BreakpointLocation.h"
16 #include "lldb/Core/Module.h"
17 #include "lldb/Core/ModuleList.h"
18 #include "lldb/Core/PluginManager.h"
19 #include "lldb/Core/Section.h"
20 #include "lldb/Core/ValueObject.h"
21 #include "lldb/Core/ValueObjectConstResult.h"
22 #include "lldb/DataFormatters/FormattersHelpers.h"
23 #include "lldb/Expression/DiagnosticManager.h"
24 #include "lldb/Expression/FunctionCaller.h"
25 #include "lldb/Symbol/ClangASTContext.h"
26 #include "lldb/Symbol/ObjectFile.h"
27 #include "lldb/Target/ExecutionContext.h"
28 #include "lldb/Target/Process.h"
29 #include "lldb/Target/RegisterContext.h"
30 #include "lldb/Target/StopInfo.h"
31 #include "lldb/Target/Target.h"
32 #include "lldb/Target/Thread.h"
33 #include "lldb/Utility/ConstString.h"
34 #include "lldb/Utility/Log.h"
35 #include "lldb/Utility/Scalar.h"
36 #include "lldb/Utility/Status.h"
37 #include "lldb/Utility/StreamString.h"
38 
39 #include "Plugins/Process/Utility/HistoryThread.h"
40 #include "Plugins/Language/ObjC/NSString.h"
41 #include "Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h"
42 
43 #include <vector>
44 
45 using namespace lldb;
46 using namespace lldb_private;
47 
48 char AppleObjCRuntime::ID = 0;
49 
50 AppleObjCRuntime::~AppleObjCRuntime() {}
51 
52 AppleObjCRuntime::AppleObjCRuntime(Process *process)
53     : ObjCLanguageRuntime(process), m_read_objc_library(false),
54       m_objc_trampoline_handler_up(), m_Foundation_major() {
55   ReadObjCLibraryIfNeeded(process->GetTarget().GetImages());
56 }
57 
58 bool AppleObjCRuntime::GetObjectDescription(Stream &str, ValueObject &valobj) {
59   CompilerType compiler_type(valobj.GetCompilerType());
60   bool is_signed;
61   // ObjC objects can only be pointers (or numbers that actually represents
62   // pointers but haven't been typecast, because reasons..)
63   if (!compiler_type.IsIntegerType(is_signed) && !compiler_type.IsPointerType())
64     return false;
65 
66   // Make the argument list: we pass one arg, the address of our pointer, to
67   // the print function.
68   Value val;
69 
70   if (!valobj.ResolveValue(val.GetScalar()))
71     return false;
72 
73   // Value Objects may not have a process in their ExecutionContextRef.  But we
74   // need to have one in the ref we pass down to eventually call description.
75   // Get it from the target if it isn't present.
76   ExecutionContext exe_ctx;
77   if (valobj.GetProcessSP()) {
78     exe_ctx = ExecutionContext(valobj.GetExecutionContextRef());
79   } else {
80     exe_ctx.SetContext(valobj.GetTargetSP(), true);
81     if (!exe_ctx.HasProcessScope())
82       return false;
83   }
84   return GetObjectDescription(str, val, exe_ctx.GetBestExecutionContextScope());
85 }
86 bool AppleObjCRuntime::GetObjectDescription(Stream &strm, Value &value,
87                                             ExecutionContextScope *exe_scope) {
88   if (!m_read_objc_library)
89     return false;
90 
91   ExecutionContext exe_ctx;
92   exe_scope->CalculateExecutionContext(exe_ctx);
93   Process *process = exe_ctx.GetProcessPtr();
94   if (!process)
95     return false;
96 
97   // We need other parts of the exe_ctx, but the processes have to match.
98   assert(m_process == process);
99 
100   // Get the function address for the print function.
101   const Address *function_address = GetPrintForDebuggerAddr();
102   if (!function_address)
103     return false;
104 
105   Target *target = exe_ctx.GetTargetPtr();
106   CompilerType compiler_type = value.GetCompilerType();
107   if (compiler_type) {
108     if (!ClangASTContext::IsObjCObjectPointerType(compiler_type)) {
109       strm.Printf("Value doesn't point to an ObjC object.\n");
110       return false;
111     }
112   } else {
113     // If it is not a pointer, see if we can make it into a pointer.
114     ClangASTContext *ast_context = ClangASTContext::GetScratch(*target);
115     if (!ast_context)
116       return false;
117 
118     CompilerType opaque_type = ast_context->GetBasicType(eBasicTypeObjCID);
119     if (!opaque_type)
120       opaque_type = ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
121     // value.SetContext(Value::eContextTypeClangType, opaque_type_ptr);
122     value.SetCompilerType(opaque_type);
123   }
124 
125   ValueList arg_value_list;
126   arg_value_list.PushValue(value);
127 
128   // This is the return value:
129   ClangASTContext *ast_context = ClangASTContext::GetScratch(*target);
130   if (!ast_context)
131     return false;
132 
133   CompilerType return_compiler_type = ast_context->GetCStringType(true);
134   Value ret;
135   //    ret.SetContext(Value::eContextTypeClangType, return_compiler_type);
136   ret.SetCompilerType(return_compiler_type);
137 
138   if (exe_ctx.GetFramePtr() == nullptr) {
139     Thread *thread = exe_ctx.GetThreadPtr();
140     if (thread == nullptr) {
141       exe_ctx.SetThreadSP(process->GetThreadList().GetSelectedThread());
142       thread = exe_ctx.GetThreadPtr();
143     }
144     if (thread) {
145       exe_ctx.SetFrameSP(thread->GetSelectedFrame());
146     }
147   }
148 
149   // Now we're ready to call the function:
150 
151   DiagnosticManager diagnostics;
152   lldb::addr_t wrapper_struct_addr = LLDB_INVALID_ADDRESS;
153 
154   if (!m_print_object_caller_up) {
155     Status error;
156     m_print_object_caller_up.reset(
157         exe_scope->CalculateTarget()->GetFunctionCallerForLanguage(
158             eLanguageTypeObjC, return_compiler_type, *function_address,
159             arg_value_list, "objc-object-description", error));
160     if (error.Fail()) {
161       m_print_object_caller_up.reset();
162       strm.Printf("Could not get function runner to call print for debugger "
163                   "function: %s.",
164                   error.AsCString());
165       return false;
166     }
167     m_print_object_caller_up->InsertFunction(exe_ctx, wrapper_struct_addr,
168                                              diagnostics);
169   } else {
170     m_print_object_caller_up->WriteFunctionArguments(
171         exe_ctx, wrapper_struct_addr, arg_value_list, diagnostics);
172   }
173 
174   EvaluateExpressionOptions options;
175   options.SetUnwindOnError(true);
176   options.SetTryAllThreads(true);
177   options.SetStopOthers(true);
178   options.SetIgnoreBreakpoints(true);
179   options.SetTimeout(process->GetUtilityExpressionTimeout());
180   options.SetIsForUtilityExpr(true);
181 
182   ExpressionResults results = m_print_object_caller_up->ExecuteFunction(
183       exe_ctx, &wrapper_struct_addr, options, diagnostics, ret);
184   if (results != eExpressionCompleted) {
185     strm.Printf("Error evaluating Print Object function: %d.\n", results);
186     return false;
187   }
188 
189   addr_t result_ptr = ret.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
190 
191   char buf[512];
192   size_t cstr_len = 0;
193   size_t full_buffer_len = sizeof(buf) - 1;
194   size_t curr_len = full_buffer_len;
195   while (curr_len == full_buffer_len) {
196     Status error;
197     curr_len = process->ReadCStringFromMemory(result_ptr + cstr_len, buf,
198                                               sizeof(buf), error);
199     strm.Write(buf, curr_len);
200     cstr_len += curr_len;
201   }
202   return cstr_len > 0;
203 }
204 
205 lldb::ModuleSP AppleObjCRuntime::GetObjCModule() {
206   ModuleSP module_sp(m_objc_module_wp.lock());
207   if (module_sp)
208     return module_sp;
209 
210   Process *process = GetProcess();
211   if (process) {
212     const ModuleList &modules = process->GetTarget().GetImages();
213     for (uint32_t idx = 0; idx < modules.GetSize(); idx++) {
214       module_sp = modules.GetModuleAtIndex(idx);
215       if (AppleObjCRuntime::AppleIsModuleObjCLibrary(module_sp)) {
216         m_objc_module_wp = module_sp;
217         return module_sp;
218       }
219     }
220   }
221   return ModuleSP();
222 }
223 
224 Address *AppleObjCRuntime::GetPrintForDebuggerAddr() {
225   if (!m_PrintForDebugger_addr) {
226     const ModuleList &modules = m_process->GetTarget().GetImages();
227 
228     SymbolContextList contexts;
229     SymbolContext context;
230 
231     modules.FindSymbolsWithNameAndType(ConstString("_NSPrintForDebugger"),
232                                         eSymbolTypeCode, contexts);
233     if (contexts.IsEmpty()) {
234       modules.FindSymbolsWithNameAndType(ConstString("_CFPrintForDebugger"),
235                                          eSymbolTypeCode, contexts);
236       if (contexts.IsEmpty())
237         return nullptr;
238     }
239 
240     contexts.GetContextAtIndex(0, context);
241 
242     m_PrintForDebugger_addr.reset(new Address(context.symbol->GetAddress()));
243   }
244 
245   return m_PrintForDebugger_addr.get();
246 }
247 
248 bool AppleObjCRuntime::CouldHaveDynamicValue(ValueObject &in_value) {
249   return in_value.GetCompilerType().IsPossibleDynamicType(
250       nullptr,
251       false, // do not check C++
252       true); // check ObjC
253 }
254 
255 bool AppleObjCRuntime::GetDynamicTypeAndAddress(
256     ValueObject &in_value, lldb::DynamicValueType use_dynamic,
257     TypeAndOrName &class_type_or_name, Address &address,
258     Value::ValueType &value_type) {
259   return false;
260 }
261 
262 TypeAndOrName
263 AppleObjCRuntime::FixUpDynamicType(const TypeAndOrName &type_and_or_name,
264                                    ValueObject &static_value) {
265   CompilerType static_type(static_value.GetCompilerType());
266   Flags static_type_flags(static_type.GetTypeInfo());
267 
268   TypeAndOrName ret(type_and_or_name);
269   if (type_and_or_name.HasType()) {
270     // The type will always be the type of the dynamic object.  If our parent's
271     // type was a pointer, then our type should be a pointer to the type of the
272     // dynamic object.  If a reference, then the original type should be
273     // okay...
274     CompilerType orig_type = type_and_or_name.GetCompilerType();
275     CompilerType corrected_type = orig_type;
276     if (static_type_flags.AllSet(eTypeIsPointer))
277       corrected_type = orig_type.GetPointerType();
278     ret.SetCompilerType(corrected_type);
279   } else {
280     // If we are here we need to adjust our dynamic type name to include the
281     // correct & or * symbol
282     std::string corrected_name(type_and_or_name.GetName().GetCString());
283     if (static_type_flags.AllSet(eTypeIsPointer))
284       corrected_name.append(" *");
285     // the parent type should be a correctly pointer'ed or referenc'ed type
286     ret.SetCompilerType(static_type);
287     ret.SetName(corrected_name.c_str());
288   }
289   return ret;
290 }
291 
292 bool AppleObjCRuntime::AppleIsModuleObjCLibrary(const ModuleSP &module_sp) {
293   if (module_sp) {
294     const FileSpec &module_file_spec = module_sp->GetFileSpec();
295     static ConstString ObjCName("libobjc.A.dylib");
296 
297     if (module_file_spec) {
298       if (module_file_spec.GetFilename() == ObjCName)
299         return true;
300     }
301   }
302   return false;
303 }
304 
305 // we use the version of Foundation to make assumptions about the ObjC runtime
306 // on a target
307 uint32_t AppleObjCRuntime::GetFoundationVersion() {
308   if (!m_Foundation_major.hasValue()) {
309     const ModuleList &modules = m_process->GetTarget().GetImages();
310     for (uint32_t idx = 0; idx < modules.GetSize(); idx++) {
311       lldb::ModuleSP module_sp = modules.GetModuleAtIndex(idx);
312       if (!module_sp)
313         continue;
314       if (strcmp(module_sp->GetFileSpec().GetFilename().AsCString(""),
315                  "Foundation") == 0) {
316         m_Foundation_major = module_sp->GetVersion().getMajor();
317         return *m_Foundation_major;
318       }
319     }
320     return LLDB_INVALID_MODULE_VERSION;
321   } else
322     return m_Foundation_major.getValue();
323 }
324 
325 void AppleObjCRuntime::GetValuesForGlobalCFBooleans(lldb::addr_t &cf_true,
326                                                     lldb::addr_t &cf_false) {
327   cf_true = cf_false = LLDB_INVALID_ADDRESS;
328 }
329 
330 bool AppleObjCRuntime::IsModuleObjCLibrary(const ModuleSP &module_sp) {
331   return AppleIsModuleObjCLibrary(module_sp);
332 }
333 
334 bool AppleObjCRuntime::ReadObjCLibrary(const ModuleSP &module_sp) {
335   // Maybe check here and if we have a handler already, and the UUID of this
336   // module is the same as the one in the current module, then we don't have to
337   // reread it?
338   m_objc_trampoline_handler_up.reset(
339       new AppleObjCTrampolineHandler(m_process->shared_from_this(), module_sp));
340   if (m_objc_trampoline_handler_up != nullptr) {
341     m_read_objc_library = true;
342     return true;
343   } else
344     return false;
345 }
346 
347 ThreadPlanSP AppleObjCRuntime::GetStepThroughTrampolinePlan(Thread &thread,
348                                                             bool stop_others) {
349   ThreadPlanSP thread_plan_sp;
350   if (m_objc_trampoline_handler_up)
351     thread_plan_sp = m_objc_trampoline_handler_up->GetStepThroughDispatchPlan(
352         thread, stop_others);
353   return thread_plan_sp;
354 }
355 
356 // Static Functions
357 ObjCLanguageRuntime::ObjCRuntimeVersions
358 AppleObjCRuntime::GetObjCVersion(Process *process, ModuleSP &objc_module_sp) {
359   if (!process)
360     return ObjCRuntimeVersions::eObjC_VersionUnknown;
361 
362   Target &target = process->GetTarget();
363   if (target.GetArchitecture().GetTriple().getVendor() !=
364       llvm::Triple::VendorType::Apple)
365     return ObjCRuntimeVersions::eObjC_VersionUnknown;
366 
367   const ModuleList &target_modules = target.GetImages();
368   std::lock_guard<std::recursive_mutex> gaurd(target_modules.GetMutex());
369 
370   size_t num_images = target_modules.GetSize();
371   for (size_t i = 0; i < num_images; i++) {
372     ModuleSP module_sp = target_modules.GetModuleAtIndexUnlocked(i);
373     // One tricky bit here is that we might get called as part of the initial
374     // module loading, but before all the pre-run libraries get winnowed from
375     // the module list.  So there might actually be an old and incorrect ObjC
376     // library sitting around in the list, and we don't want to look at that.
377     // That's why we call IsLoadedInTarget.
378 
379     if (AppleIsModuleObjCLibrary(module_sp) &&
380         module_sp->IsLoadedInTarget(&target)) {
381       objc_module_sp = module_sp;
382       ObjectFile *ofile = module_sp->GetObjectFile();
383       if (!ofile)
384         return ObjCRuntimeVersions::eObjC_VersionUnknown;
385 
386       SectionList *sections = module_sp->GetSectionList();
387       if (!sections)
388         return ObjCRuntimeVersions::eObjC_VersionUnknown;
389       SectionSP v1_telltale_section_sp =
390           sections->FindSectionByName(ConstString("__OBJC"));
391       if (v1_telltale_section_sp) {
392         return ObjCRuntimeVersions::eAppleObjC_V1;
393       }
394       return ObjCRuntimeVersions::eAppleObjC_V2;
395     }
396   }
397 
398   return ObjCRuntimeVersions::eObjC_VersionUnknown;
399 }
400 
401 void AppleObjCRuntime::SetExceptionBreakpoints() {
402   const bool catch_bp = false;
403   const bool throw_bp = true;
404   const bool is_internal = true;
405 
406   if (!m_objc_exception_bp_sp) {
407     m_objc_exception_bp_sp = LanguageRuntime::CreateExceptionBreakpoint(
408         m_process->GetTarget(), GetLanguageType(), catch_bp, throw_bp,
409         is_internal);
410     if (m_objc_exception_bp_sp)
411       m_objc_exception_bp_sp->SetBreakpointKind("ObjC exception");
412   } else
413     m_objc_exception_bp_sp->SetEnabled(true);
414 }
415 
416 void AppleObjCRuntime::ClearExceptionBreakpoints() {
417   if (!m_process)
418     return;
419 
420   if (m_objc_exception_bp_sp.get()) {
421     m_objc_exception_bp_sp->SetEnabled(false);
422   }
423 }
424 
425 bool AppleObjCRuntime::ExceptionBreakpointsAreSet() {
426   return m_objc_exception_bp_sp && m_objc_exception_bp_sp->IsEnabled();
427 }
428 
429 bool AppleObjCRuntime::ExceptionBreakpointsExplainStop(
430     lldb::StopInfoSP stop_reason) {
431   if (!m_process)
432     return false;
433 
434   if (!stop_reason || stop_reason->GetStopReason() != eStopReasonBreakpoint)
435     return false;
436 
437   uint64_t break_site_id = stop_reason->GetValue();
438   return m_process->GetBreakpointSiteList().BreakpointSiteContainsBreakpoint(
439       break_site_id, m_objc_exception_bp_sp->GetID());
440 }
441 
442 bool AppleObjCRuntime::CalculateHasNewLiteralsAndIndexing() {
443   if (!m_process)
444     return false;
445 
446   Target &target(m_process->GetTarget());
447 
448   static ConstString s_method_signature(
449       "-[NSDictionary objectForKeyedSubscript:]");
450   static ConstString s_arclite_method_signature(
451       "__arclite_objectForKeyedSubscript");
452 
453   SymbolContextList sc_list;
454 
455   target.GetImages().FindSymbolsWithNameAndType(s_method_signature,
456                                                 eSymbolTypeCode, sc_list);
457   if (sc_list.IsEmpty())
458     target.GetImages().FindSymbolsWithNameAndType(s_arclite_method_signature,
459                                                   eSymbolTypeCode, sc_list);
460   return !sc_list.IsEmpty();
461 }
462 
463 lldb::SearchFilterSP AppleObjCRuntime::CreateExceptionSearchFilter() {
464   Target &target = m_process->GetTarget();
465 
466   FileSpecList filter_modules;
467   if (target.GetArchitecture().GetTriple().getVendor() == llvm::Triple::Apple) {
468     filter_modules.Append(std::get<0>(GetExceptionThrowLocation()));
469   }
470   return target.GetSearchFilterForModuleList(&filter_modules);
471 }
472 
473 ValueObjectSP AppleObjCRuntime::GetExceptionObjectForThread(
474     ThreadSP thread_sp) {
475   auto *cpp_runtime = m_process->GetLanguageRuntime(eLanguageTypeC_plus_plus);
476   if (!cpp_runtime) return ValueObjectSP();
477   auto cpp_exception = cpp_runtime->GetExceptionObjectForThread(thread_sp);
478   if (!cpp_exception) return ValueObjectSP();
479 
480   auto descriptor = GetClassDescriptor(*cpp_exception);
481   if (!descriptor || !descriptor->IsValid()) return ValueObjectSP();
482 
483   while (descriptor) {
484     ConstString class_name(descriptor->GetClassName());
485     if (class_name == "NSException")
486       return cpp_exception;
487     descriptor = descriptor->GetSuperclass();
488   }
489 
490   return ValueObjectSP();
491 }
492 
493 ThreadSP AppleObjCRuntime::GetBacktraceThreadFromException(
494     lldb::ValueObjectSP exception_sp) {
495   ValueObjectSP reserved_dict =
496       exception_sp->GetChildMemberWithName(ConstString("reserved"), true);
497   if (!reserved_dict) return ThreadSP();
498 
499   reserved_dict = reserved_dict->GetSyntheticValue();
500   if (!reserved_dict) return ThreadSP();
501 
502   ClangASTContext *clang_ast_context =
503       ClangASTContext::GetScratch(*exception_sp->GetTargetSP());
504   if (!clang_ast_context)
505     return ThreadSP();
506   CompilerType objc_id =
507       clang_ast_context->GetBasicType(lldb::eBasicTypeObjCID);
508   ValueObjectSP return_addresses;
509 
510   auto objc_object_from_address = [&exception_sp, &objc_id](uint64_t addr,
511                                                             const char *name) {
512     Value value(addr);
513     value.SetCompilerType(objc_id);
514     auto object = ValueObjectConstResult::Create(
515         exception_sp->GetTargetSP().get(), value, ConstString(name));
516     object = object->GetDynamicValue(eDynamicDontRunTarget);
517     return object;
518   };
519 
520   for (size_t idx = 0; idx < reserved_dict->GetNumChildren(); idx++) {
521     ValueObjectSP dict_entry = reserved_dict->GetChildAtIndex(idx, true);
522 
523     DataExtractor data;
524     data.SetAddressByteSize(dict_entry->GetProcessSP()->GetAddressByteSize());
525     Status error;
526     dict_entry->GetData(data, error);
527     if (error.Fail()) return ThreadSP();
528 
529     lldb::offset_t data_offset = 0;
530     auto dict_entry_key = data.GetPointer(&data_offset);
531     auto dict_entry_value = data.GetPointer(&data_offset);
532 
533     auto key_nsstring = objc_object_from_address(dict_entry_key, "key");
534     StreamString key_summary;
535     if (lldb_private::formatters::NSStringSummaryProvider(
536             *key_nsstring, key_summary, TypeSummaryOptions()) &&
537         !key_summary.Empty()) {
538       if (key_summary.GetString() == "\"callStackReturnAddresses\"") {
539         return_addresses = objc_object_from_address(dict_entry_value,
540                                                     "callStackReturnAddresses");
541         break;
542       }
543     }
544   }
545 
546   if (!return_addresses) return ThreadSP();
547   auto frames_value =
548       return_addresses->GetChildMemberWithName(ConstString("_frames"), true);
549   addr_t frames_addr = frames_value->GetValueAsUnsigned(0);
550   auto count_value =
551       return_addresses->GetChildMemberWithName(ConstString("_cnt"), true);
552   size_t count = count_value->GetValueAsUnsigned(0);
553   auto ignore_value =
554       return_addresses->GetChildMemberWithName(ConstString("_ignore"), true);
555   size_t ignore = ignore_value->GetValueAsUnsigned(0);
556 
557   size_t ptr_size = m_process->GetAddressByteSize();
558   std::vector<lldb::addr_t> pcs;
559   for (size_t idx = 0; idx < count; idx++) {
560     Status error;
561     addr_t pc = m_process->ReadPointerFromMemory(
562         frames_addr + (ignore + idx) * ptr_size, error);
563     pcs.push_back(pc);
564   }
565 
566   if (pcs.empty()) return ThreadSP();
567 
568   ThreadSP new_thread_sp(new HistoryThread(*m_process, 0, pcs));
569   m_process->GetExtendedThreadList().AddThread(new_thread_sp);
570   return new_thread_sp;
571 }
572 
573 std::tuple<FileSpec, ConstString>
574 AppleObjCRuntime::GetExceptionThrowLocation() {
575   return std::make_tuple(
576       FileSpec("libobjc.A.dylib"), ConstString("objc_exception_throw"));
577 }
578 
579 void AppleObjCRuntime::ReadObjCLibraryIfNeeded(const ModuleList &module_list) {
580   if (!HasReadObjCLibrary()) {
581     std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex());
582 
583     size_t num_modules = module_list.GetSize();
584     for (size_t i = 0; i < num_modules; i++) {
585       auto mod = module_list.GetModuleAtIndex(i);
586       if (IsModuleObjCLibrary(mod)) {
587         ReadObjCLibrary(mod);
588         break;
589       }
590     }
591   }
592 }
593 
594 void AppleObjCRuntime::ModulesDidLoad(const ModuleList &module_list) {
595   ReadObjCLibraryIfNeeded(module_list);
596 }
597