Track expression language from one place in ClangExpressionParser

[ldrumm]

Summary

The current expression language is currently tracked in a few places within the ClangExpressionParser constructor. This patch adds a private lldb::LanguageType attribute to the ClangExpressionParser class and tracks the expression language from that one place.

[clayborg]

I will let Sean review this one as the expression parser is his area of expertise.

[ldrumm]

Updated diff to show full context

[ldrumm]

Hi all

If there are no objections, I'd like to commit this. Is this in an acceptable state?

Best

Luke

[ldrumm]

Hi all

I'm still keen to have someone more familiar with this code to let me know if anything's amiss, but I'll probably move ahead and commit this tomorrow if I don't hear anything.
Let me know if you'd like any changes made - or the patch is simply rotten to the core - and I'll take another shot at it

Best

Luke

[ldrumm]

This patch was committed back in March https://reviews.llvm.org/rL263099 and then reverted 2 hours later in https://reviews.llvm.org/rL263107 due to a testing failure on greendragon related to ObjC. Unfortunately, I no longer have access to Apple hardware (and at the time the testsuite passed on my local mac), so I'm unable to find out exactly what went wrong.

This patch is still needed for RenderScript to handle JIT expressions correctly, so I'd really appreciate it if someone more familiar with OS X would be able to take a look at this, and point out what I'm doing wrong that causes the Objective C tests to blow up.

Any help is - as always - very-much appreciated!

[ldrumm]

This patch was committed back in March https://reviews.llvm.org/rL263099 and then reverted 2 hours later in https://reviews.llvm.org/rL263107 due to a testing failure on greendragon related to ObjC. Unfortunately, I no longer have access to Apple hardware (and at the time the testsuite passed on my local mac), so I'm unable to find out exactly what went wrong.

This patch is still needed for RenderScript to handle JIT expressions correctly, so I'd really appreciate it if someone more familiar with OS X would be able to take a look at this, and point out what I'm doing wrong that causes the Objective C tests to blow up.

Any help is - as always - very-much appreciated!

source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h

std::unique_ptr<clang::Builtin::Context>
       m_builtin_context; ///< Context for Clang built-ins
   std::unique_ptr<clang::SelectorTable>
       m_selector_table; ///< Selector table for Objective-C methods
   std::unique_ptr<clang::CodeGenerator>
       m_code_generator; ///< The Clang object that generates IR
 
   class LLDBPreprocessorCallbacks;
   LLDBPreprocessorCallbacks *m_pp_callbacks; ///< Called when the preprocessor
-                                             ///encounters module imports
+                                             /// encounters module imports
   std::unique_ptr<ClangASTContext> m_ast_context;
+  lldb::LanguageType m_language; ///< The source language of the expression
+                                 /// which may be explicitly set or inferred.
 };
 }
 
 #endif // liblldb_ClangExpressionParser_h_

source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

if (!target_sp) {
     lldb_assert(target_sp.get(),
                 "Can't make an expression parser with a null target.",
                 __FUNCTION__, __FILE__, __LINE__);
     return;
   }
 
   // 1. Create a new compiler instance.
   m_compiler.reset(new CompilerInstance());
-  lldb::LanguageType frame_lang =
-      expr.Language(); // defaults to lldb::eLanguageTypeUnknown
+  m_language = expr.Language(); // defaults to lldb::eLanguageTypeUnknown
   bool overridden_target_opts = false;
   lldb_private::LanguageRuntime *lang_rt = nullptr;
 
   std::string abi;
   ArchSpec target_arch;
   target_arch = target_sp->GetArchitecture();
 
   const auto target_machine = target_arch.GetMachine();
 
   // If the expression is being evaluated in the context of an existing
   // stack frame, we introspect to see if the language runtime is available.
 
   lldb::StackFrameSP frame_sp = exe_scope->CalculateStackFrame();
   lldb::ProcessSP process_sp = exe_scope->CalculateProcess();
 
   // Make sure the user hasn't provided a preferred execution language
   // with `expression --language X -- ...`
-  if (frame_sp && frame_lang == lldb::eLanguageTypeUnknown)
-    frame_lang = frame_sp->GetLanguage();
+  if (frame_sp && m_language == lldb::eLanguageTypeUnknown)
+    m_language = frame_sp->GetLanguage();
 
-  if (process_sp && frame_lang != lldb::eLanguageTypeUnknown) {
-    lang_rt = process_sp->GetLanguageRuntime(frame_lang);
+  if (process_sp && m_language != lldb::eLanguageTypeUnknown) {
+    lang_rt = process_sp->GetLanguageRuntime(m_language);
     if (log)
       log->Printf("Frame has language of type %s",
-                  Language::GetNameForLanguageType(frame_lang));
+                  Language::GetNameForLanguageType(m_language));
   }
 
   // 2. Configure the compiler with a set of default options that are
   // appropriate
   // for most situations.
   if (target_arch.IsValid()) {
     std::string triple = target_arch.GetTriple().str();
     m_compiler->getTargetOpts().Triple = triple;
if (log) {
     log->Printf("Target vector alignment: %d",
                 target_info->getMaxVectorAlign());
   }
   m_compiler->setTarget(target_info);
 
   assert(m_compiler->hasTarget());
 
   // 5. Set language options.
-  lldb::LanguageType language = expr.Language();
-
-  switch (language) {
+  switch (m_language) {
   case lldb::eLanguageTypeC:
   case lldb::eLanguageTypeC89:
   case lldb::eLanguageTypeC99:
   case lldb::eLanguageTypeC11:
     // FIXME: the following language option is a temporary workaround,
     // to "ask for C, get C++."
     // For now, the expression parser must use C++ anytime the
     // language is a C family language, because the expression parser
lldb_private::Error ClangExpressionParser::PrepareForExecution(
   if (lldb::StackFrameSP frame_sp = exe_ctx.GetFrameSP()) {
     sc = frame_sp->GetSymbolContext(lldb::eSymbolContextEverything);
   } else if (lldb::TargetSP target_sp = exe_ctx.GetTargetSP()) {
     sc.target_sp = target_sp;
   }
 
   LLVMUserExpression::IRPasses custom_passes;
   {
-    auto lang = m_expr.Language();
     if (log)
       log->Printf("%s - Currrent expression language is %s\n", __FUNCTION__,
-                  Language::GetNameForLanguageType(lang));
+                  Language::GetNameForLanguageType(m_language));
     lldb::ProcessSP process_sp = exe_ctx.GetProcessSP();
-    if (process_sp && lang != lldb::eLanguageTypeUnknown) {
-      auto runtime = process_sp->GetLanguageRuntime(lang);
+    if (process_sp && m_language != lldb::eLanguageTypeUnknown) {
+      auto runtime = process_sp->GetLanguageRuntime(m_language);
       if (runtime)
         runtime->GetIRPasses(custom_passes);
     }
   }
 
   if (custom_passes.EarlyPasses) {
     if (log)
       log->Printf("%s - Running Early IR Passes from LanguageRuntime on "