Fix ObjC++ types Class and id being defined in C and C++ expressions.

[paulherman]

Summary

This allows using "Class" and "id" as identifiers in C and C++ expressions. This was because ObjC++ runtime was available by default. It now selects the default language when evaluating an expression from the current frame compile unit.

[paulherman]

Fix ObjC++ types Class and id being defined in C and C++ expressions.

Ignore previous commit included by mistake.

[spyffe]

It looks like this patch does not use "language" to determine which language the expression parser runs in, but rather to allow lookups specifically of "id" and "Class" if the current frame is not Objective-C++. Is that correct?

[spyffe]

Ooh, I'm reading the patch at the beginning of ClangUserExpression::Evaluate again and it does look like this patch sets language based on the language of the containing frame, and that affects what language the expression is parsed in.

I don't think it's appropriate to force the expression parser out of Objective-C or C++ mode in non-ObjC frames, because it's entirely possible for a user to want to run Objective-C (or C++ code) from frames in a different language. For example, it is often the case that a user will want to call [NSApplication sharedApplication] in an app, even if they are in C/C++ code.

For the same reason I think the idea of a target-level language isn't the right approach. Rather, I think there should be a setting that says "force all expressions to this language by default" that the user can set if they're debugging a process that prefers a particular language. By default, this setting would be Objective-C++ – but for cases where the user is expecting to deal mostly with pure C++ binaries, that can be switched to C++. It might even be something that could be set on a per-platform basis.

Be aware (as I usually warn) that you will get a broken expression parser if you try to force it to use only C. The expression parser uses references internally to allow you to use local variables without dereferencing pointers. We want to get Clang support for a "C-language reference" of some sort eventually, but until that happens you need to at least enable C++.

[paulherman]

The idea is that, as I user, I do not expect the identifiers "Class" and "id" to not be available - I don't think I've seen a warning or notice about that when evaluating expressions.

I believe that setting the language based on the current frame is a good guess. I think evaluating something in the language of the current frame is more common than evaluating something that is in ObjC++ and the current frame is C++.

The idea about target-level language is that it only selects a specific language (i.e. not the default ObjC++) if all the compile units are in the same language. I believe this to be right since a debugger is not a REPL, hence we shouldn't expect the users to evaluate something in ObjC++ if their binary doesn't contain anything related to that language.

[dawn]

Hi Sean,

In D11790#221730, @spyffe wrote:

Ooh, I'm reading the patch at the beginning of ClangUserExpression::Evaluate again and it does look like this patch sets language based on the language of the containing frame, and that affects what language the expression is parsed in.

Yep - and I agree that this is a good thing.

I don't think it's appropriate to force the expression parser out of Objective-C or C++ mode in non-ObjC frames ...

But the parsing of ObjC conflicts with other languages. This is a real problem.

For the same reason I think the idea of a target-level language isn't the right approach.

I agree here.

Rather, I think there should be a setting that says "force all expressions to this language by default" that the user can set if they're debugging a process that prefers a particular language.

We have such a setting with target.language.

By default, this setting would be Objective-C++

I disagree here - the default is (and should be) unknown.

In D11790#221770, @paulherman wrote:

The idea is that, as I user, I do not expect the identifiers "Class" and "id" to not be available - I don't think I've seen a warning or notice about that when evaluating expressions.

I believe that setting the language based on the current frame is a good guess. I think evaluating something in the language of the current frame is more common than evaluating something that is in ObjC++ and the current frame is C++.

I'm totally with Paul on this, and we've discussed this same issue in http://reviews.llvm.org/D11482, http://reviews.llvm.org/D11173 and http://reviews.llvm.org/D11102. It was Jim's belief that you would be in favor of using the frame too, but here it sounds like you *do* want to always be able to eval ObjC, which contradicts Jim and Greg. I believe the approach I took in http://reviews.llvm.org/D11102 is exactly what was requested from Greg and Jim. If you disagree, please talk to them, because Paul and I are stuck between two conflicting desires here, and we can't move forward. Note that my patch at http://reviews.llvm.org/D11102 still awaits your review.

Thanks,
-Dawn

[dawn]

Hi Paul,

Some background... I basically tried the same thing in my original http://reviews.llvm.org/D11102 and http://reviews.llvm.org/D11173. In light of Sean's objections in http://reviews.llvm.org/D11173, I created http://reviews.llvm.org/D11482 which used an option to control this behavior, but Greg and Jim objected to that, so I took their comments and revised http://reviews.llvm.org/D11102 to what I believed the consensus was.

You should read the comments in http://reviews.llvm.org/D11482 as they apply here as well.

My revision of http://reviews.llvm.org/D11102 is what I believe the consensus was, so perhaps you would like to abandon this patch in favor of that one?

Thanks,
-Dawn

[zturner]

Is Objective C++ even a thing on non-Apple platforms? I dont' think we
should be forcing a default *anything* to a language that only exists on a
subset of supported platforms. But even ignoring that, I don't think
preferential treatment should be given to any particular language.

If there is going to be a setting, then perhaps the setting should be
something like:

lldb.expression-eval-mode = {ObjC++, C++, current-frame}

and the default value of the setting should be "current-frame".

[spyffe]

I totally agree that Objective-C shouldn’t be part of the default on non-Apple platforms.
The way I imagine this working is that your current frame’s language gets “upgraded” – for the Clang expression parser, at least to something that supports C++, but for other languages perhaps something else.
So, supposing e.g. Go gets its own expression parser:

[on Apple]

(current frame -> expression language)
C -> ObjC++
C++ -> ObjC++
ObjC -> ObjC++
Go -> Go)

[on Linux]
C -> C++
C++ -> C++
ObjC -> ObjC++
Go -> Go

The dependency of the Clang expression parser on C++ is an implementation detail, so we should upgrade C/ObjC to C++/ObjC++ internally.
The only settable preference here is whether Objective-C is globally desirable. Maybe it would be best to just have a simple global setting:

lldb.force-objc-in-clang-expressions = true (on Apple), false (elsewhere)

Sean

[paulherman]

This patch does exactly that. It detects the language of the frame and upgrades it according to the rules you said (I think I might've missed ObjC -> ObjC++, but that can be added).

Regarding the global setting of ObjC, I believe it is not helpful. What I mean is, when debugging something in ObjC the frame is probably already ObjC.

Paul

[dawn]

See inline comments.

source/Commands/CommandObjectExpression.cpp

308

Why was this removed? Doesn't this break the intent of the target.language setting? That is:

if expression --language option is set, use it,
else if target.language option is set, use it,
else default to the language of the frame.

Please keep this or preserve the above behavior another way.

source/Expression/ClangUserExpression.cpp

1063

If the user explicitly wanted the language to be C (either by expression --language or target.language settings), we should not give them C++11.

include/lldb/Expression/ClangASTSource.h

public:
     //------------------------------------------------------------------
     /// Constructor
     ///
     /// Initializes class variables.
     ///
     /// @param[in] declMap
     ///     A reference to the LLDB object that handles entity lookup.
     //------------------------------------------------------------------
-    ClangASTSource (const lldb::TargetSP &target) :
+    ClangASTSource (const lldb::TargetSP &target, bool allow_objc = true, bool allow_cxx = true) :
         m_import_in_progress (false),
         m_lookups_enabled (false),
         m_target (target),
         m_ast_context (NULL),
         m_active_lexical_decls (),
-        m_active_lookups ()
+        m_active_lookups (),
+        m_allow_objc (allow_objc),
+        m_allow_cxx (allow_cxx)
     {
         m_ast_importer = m_target->GetClangASTImporter();
     }
   
     //------------------------------------------------------------------
     /// Destructor
     //------------------------------------------------------------------
     ~ClangASTSource();
protected:
     bool                    m_import_in_progress;
     bool                    m_lookups_enabled;
 
     const lldb::TargetSP                m_target;           ///< The target to use in finding variables and types.
     clang::ASTContext                  *m_ast_context;      ///< The AST context requests are coming in for.
     ClangASTImporter                   *m_ast_importer;     ///< The target's AST importer.
     std::set<const clang::Decl *>       m_active_lexical_decls;
     std::set<const char *>              m_active_lookups;
+
+    bool m_allow_objc;
+    bool m_allow_cxx;
+
 };
 
 //----------------------------------------------------------------------
 /// @class NameSearchContext ClangASTSource.h "lldb/Expression/ClangASTSource.h"
 /// @brief Container for all objects relevant to a single name lookup
 ///     
 /// LLDB needs to create Decls for entities it finds.  This class communicates
 /// what name is being searched for and provides helper functions to construct

include/lldb/Expression/ClangExpressionDeclMap.h

public:
     ///     If true, inhibits the normal deallocation of the memory for
     ///     the result persistent variable, and instead marks the variable
     ///     as persisting.
     ///
     /// @param[in] exe_ctx
     ///     The execution context to use when parsing.
     //------------------------------------------------------------------
     ClangExpressionDeclMap (bool keep_result_in_memory,
-                            ExecutionContext &exe_ctx);
+                            ExecutionContext &exe_ctx,
+                            bool allow_objc = true,
+                            bool allow_cxx = true);
     
     //------------------------------------------------------------------
     /// Destructor
     //------------------------------------------------------------------
     ~ClangExpressionDeclMap ();
     
     //------------------------------------------------------------------
     /// Enable the state needed for parsing and IR transformation.
public:
     FindExternalVisibleDecls (NameSearchContext &context, 
                               lldb::ModuleSP module,
                               ClangNamespaceDecl &namespace_decl,
                               unsigned int current_id);
 private:
     ClangExpressionVariableList    m_found_entities;           ///< All entities that were looked up for the parser.
     ClangExpressionVariableList    m_struct_members;           ///< All entities that need to be placed in the struct.
     bool                           m_keep_result_in_memory;    ///< True if result persistent variables generated by this expression should stay in memory.
-    
+    bool                           m_allow_cxx;                ///< Search for C++ symbols
+    bool                           m_allow_objc;               ///< Search for ObjC symbols
+    
     //----------------------------------------------------------------------
     /// The following values should not live beyond parsing
     //----------------------------------------------------------------------
     class ParserVars 
     {
     public:
         ParserVars(ClangExpressionDeclMap &decl_map) :
             m_decl_map(decl_map)

include/lldb/Target/Target.h

//    SetDisassemblyFlavor(const char *flavor);
     SetStandardErrorPath (const char *path);
     
     bool
     GetBreakpointsConsultPlatformAvoidList ();
     
     lldb::LanguageType
     GetLanguage () const;
 
+    void SetLanguage (lldb::LanguageType);
+
     const char *
     GetExpressionPrefixContentsAsCString ();
 
     bool
     GetUseHexImmediates() const;
 
     bool
     GetUseFastStepping() const;
public:
     void
     ModulesDidLoad (ModuleList &module_list);
 
     void
     ModulesDidUnload (ModuleList &module_list, bool delete_locations);
     
     void
     SymbolsDidLoad (ModuleList &module_list);
-    
+    lldb::LanguageType
+    ComputeLanguageType(const ModuleList &module_list);
+    
     void
     ClearModules(bool delete_locations);
 
     //------------------------------------------------------------------
     /// Called as the last function in Process::DidExec().
     ///
     /// Process::DidExec() will clear a lot of state in the process,
     /// then try to reload a dynamic loader plugin to discover what

source/Commands/CommandObjectExpression.cpp

if (target)
         EvaluateExpressionOptions options;
         options.SetCoerceToId(m_varobj_options.use_objc);
         options.SetUnwindOnError(m_command_options.unwind_on_error);
         options.SetIgnoreBreakpoints (m_command_options.ignore_breakpoints);
         options.SetKeepInMemory(keep_in_memory);
         options.SetUseDynamic(m_varobj_options.use_dynamic);
         options.SetTryAllThreads(m_command_options.try_all_threads);
         options.SetDebug(m_command_options.debug);
-        
-        // If the language was not specified, set it from target's properties
-        if (m_command_options.language != eLanguageTypeUnknown)
-            options.SetLanguage(m_command_options.language);
-        else
-            options.SetLanguage(target->GetLanguage());
         
         // If there is any chance we are going to stop and want to see
         // what went wrong with our expression, we should generate debug info
         if (!m_command_options.ignore_breakpoints ||
             !m_command_options.unwind_on_error)
             options.SetGenerateDebugInfo(true);
         
         if (m_command_options.timeout > 0)
             options.SetTimeoutUsec(m_command_options.timeout);

source/Expression/ClangASTSource.cpp

case DeclarationName::Identifier:
                 identifier_info->getBuiltinID() != 0)
             {
                 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
                 return false;
             }
         }
         break;
 
-    // Operator names.  Not important for now.
+    // Operator names.
     case DeclarationName::CXXOperatorName:
     case DeclarationName::CXXLiteralOperatorName:
-      SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
-      return false;
+        break;
 
     // Using directives found in this context.
     // Tell Sema we didn't find any or we'll end up getting asked a *lot*.
     case DeclarationName::CXXUsingDirective:
       SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
       return false;
 
     case DeclarationName::ObjCZeroArgSelector:
ClangASTSource::FindExternalVisibleDecls (NameSearchContext &context,
 
     const ConstString name(context.m_decl_name.getAsString().c_str());
 
     const char *name_unique_cstr = name.GetCString();
 
     static ConstString id_name("id");
     static ConstString Class_name("Class");
 
-    if (name == id_name || name == Class_name)
+    if (m_allow_objc && (name == id_name || name == Class_name))
         return;
 
     if (name_unique_cstr == NULL)
         return;
 
     // The ClangASTSource is not responsible for finding $-names.
     if (name_unique_cstr[0] == '$')
         return;
if (extern_c) {
         context = LinkageSpecDecl::Create(*ast,
                                           context,
                                           SourceLocation(),
                                           SourceLocation(),
                                           clang::LinkageSpecDecl::LanguageIDs::lang_c,
                                           false);
     }
 
+    // Pass the identifier info for functions the decl_name is needed for operators
+    clang::DeclarationName decl_name = m_decl_name.getNameKind() == DeclarationName::Identifier ? m_decl_name.getAsIdentifierInfo() : m_decl_name;
+
     clang::FunctionDecl *func_decl = FunctionDecl::Create (*ast,
                                                            context,
                                                            SourceLocation(),
                                                            SourceLocation(),
-                                                           m_decl_name.getAsIdentifierInfo(),
+                                                           decl_name,
                                                            qual_type,
                                                            NULL,
                                                            SC_Extern,
                                                            isInlineSpecified,
                                                            hasWrittenPrototype,
                                                            isConstexprSpecified);
 
     // We have to do more than just synthesize the FunctionDecl.  We have to

source/Expression/ClangExpressionDeclMap.cpp

 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace clang;
 
-ClangExpressionDeclMap::ClangExpressionDeclMap (bool keep_result_in_memory, ExecutionContext &exe_ctx) :
-    ClangASTSource (exe_ctx.GetTargetSP()),
+ClangExpressionDeclMap::ClangExpressionDeclMap (bool keep_result_in_memory, ExecutionContext &exe_ctx, bool allow_objc, bool allow_cxx) : 
+    ClangASTSource (exe_ctx.GetTargetSP(), allow_objc, allow_cxx),
     m_found_entities (),
     m_struct_members (),
     m_keep_result_in_memory (keep_result_in_memory),
+    m_allow_cxx (allow_cxx),
+    m_allow_objc (allow_objc),
     m_parser_vars (),
     m_struct_vars ()
 {
     EnableStructVars();
 }
 
 ClangExpressionDeclMap::~ClangExpressionDeclMap()
 {
ClangExpressionDeclMap::FindExternalVisibleDecls (NameSearchContext &context,
     const char *name_unique_cstr = name.GetCString();
 
     if (name_unique_cstr == NULL)
         return;
 
     static ConstString id_name("id");
     static ConstString Class_name("Class");
 
-    if (name == id_name || name == Class_name)
+    if (m_allow_objc && (name == id_name || name == Class_name))
         return;
 
     // Only look for functions by name out in our symbols if the function
     // doesn't start with our phony prefix of '$'
     Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
     StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
     if (name_unique_cstr[0] == '$' && !namespace_decl)
     {

source/Expression/ClangExpressionParser.cpp

ClangExpressionParser::ClangExpressionParser (ExecutionContextScope *exe_scope,
 
     // 3. Set options.
 
     lldb::LanguageType language = expr.Language();
 
     switch (language)
     {
     case lldb::eLanguageTypeC:
+    case lldb::eLanguageTypeC89:
+    case lldb::eLanguageTypeC99:
+    case lldb::eLanguageTypeC11:
         break;
     case lldb::eLanguageTypeObjC:
         m_compiler->getLangOpts().ObjC1 = true;
         m_compiler->getLangOpts().ObjC2 = true;
         break;
     case lldb::eLanguageTypeC_plus_plus:
+    case lldb::eLanguageTypeC_plus_plus_14:
+    case lldb::eLanguageTypeC_plus_plus_11:
+    case lldb::eLanguageTypeC_plus_plus_03:
         m_compiler->getLangOpts().CPlusPlus = true;
         m_compiler->getLangOpts().CPlusPlus11 = true;
         m_compiler->getHeaderSearchOpts().UseLibcxx = true;
         break;
     case lldb::eLanguageTypeObjC_plus_plus:
     default:
         m_compiler->getLangOpts().ObjC1 = true;
         m_compiler->getLangOpts().ObjC2 = true;

source/Expression/ClangUserExpression.cpp

 #if HAVE_SYS_TYPES_H
 #  include <sys/types.h>
 #endif
 
 #include <cstdlib>
 #include <string>
 #include <map>
 
+#include "lldb/lldb-enumerations.h"
 #include "lldb/Core/ConstString.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Expression/ASTResultSynthesizer.h"
 #include "lldb/Expression/ClangExpressionDeclMap.h"

 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Target/ThreadPlanCallUserExpression.h"
 
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 
+using namespace lldb;
 using namespace lldb_private;
 
 ClangUserExpression::ClangUserExpression (const char *expr,
                                           const char *expr_prefix,
                                           lldb::LanguageType language,
                                           ResultType desired_type) :
     ClangExpression (),
     m_stack_frame_bottom (LLDB_INVALID_ADDRESS),
ClangUserExpression::ClangUserExpression (const char *expr,
     m_needs_object_ptr (false),
     m_const_object (false),
     m_target (NULL),
     m_can_interpret (false),
     m_materialized_address (LLDB_INVALID_ADDRESS)
 {
     switch (m_language)
     {
+    case lldb::eLanguageTypeC:
+    case lldb::eLanguageTypeC89:
+    case lldb::eLanguageTypeC99:
+    case lldb::eLanguageTypeC11:
+        break;
     case lldb::eLanguageTypeC_plus_plus:
+    case lldb::eLanguageTypeC_plus_plus_14:
+    case lldb::eLanguageTypeC_plus_plus_11:
+    case lldb::eLanguageTypeC_plus_plus_03:
         m_allow_cxx = true;
         break;
     case lldb::eLanguageTypeObjC:
         m_allow_objc = true;
         break;
     case lldb::eLanguageTypeObjC_plus_plus:
     default:
         m_allow_cxx = true;
ClangUserExpression::Parse (Stream &error_stream,
     }
 
     //////////////////////////
     // Parse the expression
     //
 
     m_materializer_ap.reset(new Materializer());
 
-    m_expr_decl_map.reset(new ClangExpressionDeclMap(keep_result_in_memory, exe_ctx));
+    m_expr_decl_map.reset(new ClangExpressionDeclMap(keep_result_in_memory, exe_ctx, m_allow_objc, m_allow_cxx));
 
     class OnExit
     {
     public:
         typedef std::function <void (void)> Callback;
 
         OnExit (Callback const &callback) :
             m_callback(callback)
ClangUserExpression::Evaluate (ExecutionContext &exe_ctx,
                                const char *expr_cstr,
                                const char *expr_prefix,
                                lldb::ValueObjectSP &result_valobj_sp,
                                Error &error)
 {
     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EXPRESSIONS | LIBLLDB_LOG_STEP));
 
     lldb_private::ExecutionPolicy execution_policy = options.GetExecutionPolicy();
-    const lldb::LanguageType language = options.GetLanguage();
+
+    // Predict the language if it was not set in options
+    lldb::LanguageType language = options.GetLanguage();
+    if (language == eLanguageTypeUnknown) {
+        StackFrameSP frame = exe_ctx.GetFrameSP();
+        if (frame && frame->HasDebugInformation()) {
+            Block *block = frame->GetFrameBlock();
+            if (block != NULL) {
+                lldb::ModuleSP module = block->CalculateSymbolContextModule();
+                SymbolContext symbol_context;
+                block->CalculateSymbolContext(&symbol_context);
+
+                if (module) 
+                    language = module->GetSymbolVendor()->ParseCompileUnitLanguage(symbol_context);
+            }
+        }
+    }
+    if (language == eLanguageTypeUnknown) {
+        StackFrameSP frame = exe_ctx.GetFrameSP();
+        if (frame) {
+            TargetSP target = frame->CalculateTarget();
+            if (target)
+                language = target->GetLanguage();
+        }
+    }
+    // Treat C and C++ as C++11
+    std::set<lldb::LanguageType> c_langs = {eLanguageTypeC99, eLanguageTypeC, eLanguageTypeC89, eLanguageTypeC11, eLanguageTypeC_plus_plus, eLanguageTypeC_plus_plus_11, eLanguageTypeC_plus_plus_03};
+    if (c_langs.find(language) != c_langs.end())
+        language = eLanguageTypeC_plus_plus_11;
+
     const ResultType desired_type = options.DoesCoerceToId() ? ClangUserExpression::eResultTypeId : ClangUserExpression::eResultTypeAny;
     lldb::ExpressionResults execution_results = lldb::eExpressionSetupError;
 
     Process *process = exe_ctx.GetProcessPtr();
 
     if (process == NULL || process->GetState() != lldb::eStateStopped)
     {
         if (execution_policy == eExecutionPolicyAlways)

source/Target/Target.cpp

 #include "lldb/Host/Host.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionGroupWatchpoint.h"
 #include "lldb/Interpreter/OptionValues.h"
 #include "lldb/Interpreter/Property.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ObjectFile.h"
+#include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadSpec.h"

 void
 Target::ModuleUpdated (const ModuleList& module_list, const ModuleSP &old_module_sp, const ModuleSP &new_module_sp)
 {
     // A module is replacing an already added module
     if (m_valid)
         m_breakpoint_list.UpdateBreakpointsWhenModuleIsReplaced(old_module_sp, new_module_sp);
 }
 
+lldb::LanguageType
+Target::ComputeLanguageType(const ModuleList &module_list) {
+    std::set<lldb::LanguageType> languages;
+
+    for (size_t i = 0; i < module_list.GetSize(); i++) {
+        lldb::ModuleSP module = module_list.GetModuleAtIndex(i);
+
+        if (module) {
+            for (size_t compile_unit_id = 0; compile_unit_id < module->GetNumCompileUnits(); compile_unit_id++) {
+                CompUnitSP compile_unit = module->GetCompileUnitAtIndex(compile_unit_id);
+                SymbolContext module_symbol_context(CalculateTarget(), module, compile_unit.get());
+                lldb::LanguageType module_language = module->GetSymbolVendor()->ParseCompileUnitLanguage(module_symbol_context);
+                languages.insert(module_language);
+            }
+        }
+    }
+
+
+    lldb::LanguageType target_language = eLanguageTypeUnknown;
+    if (languages.size() == 1) {
+        target_language = *languages.begin();
+    } 
+
+    return target_language;
+}
+
 void
 Target::ModulesDidLoad (ModuleList &module_list)
 {
     if (m_valid && module_list.GetSize())
     {
         m_breakpoint_list.UpdateBreakpoints (module_list, true, false);
+
+        ModuleList ml;
+        ml.Append(GetExecutableModule());
+        SetLanguage(ComputeLanguageType(ml));
+
         if (m_process_sp)
         {
             m_process_sp->ModulesDidLoad (module_list);
         }
         BroadcastEvent (eBroadcastBitModulesLoaded, new TargetEventData (this->shared_from_this(), module_list));
     }
 }
 
TargetProperties::TargetProperties (Target *target) :
     Properties (),
     m_launch_info ()
 {
     if (target)
     {
         m_collection_sp.reset (new TargetOptionValueProperties(target, Target::GetGlobalProperties()));
 
         // Set callbacks to update launch_info whenever "settins set" updated any of these properties
+
         m_collection_sp->SetValueChangedCallback(ePropertyArg0, TargetProperties::Arg0ValueChangedCallback, this);
         m_collection_sp->SetValueChangedCallback(ePropertyRunArgs, TargetProperties::RunArgsValueChangedCallback, this);
         m_collection_sp->SetValueChangedCallback(ePropertyEnvVars, TargetProperties::EnvVarsValueChangedCallback, this);
         m_collection_sp->SetValueChangedCallback(ePropertyInputPath, TargetProperties::InputPathValueChangedCallback, this);
         m_collection_sp->SetValueChangedCallback(ePropertyOutputPath, TargetProperties::OutputPathValueChangedCallback, this);
         m_collection_sp->SetValueChangedCallback(ePropertyErrorPath, TargetProperties::ErrorPathValueChangedCallback, this);
         m_collection_sp->SetValueChangedCallback(ePropertyDetachOnError, TargetProperties::DetachOnErrorValueChangedCallback, this);
         m_collection_sp->SetValueChangedCallback(ePropertyDisableASLR, TargetProperties::DisableASLRValueChangedCallback, this);

 TargetProperties::GetLanguage () const
 {
     OptionValueLanguage *value = m_collection_sp->GetPropertyAtIndexAsOptionValueLanguage (NULL, ePropertyLanguage);
     if (value)
         return value->GetCurrentValue();
     return LanguageType();
 }
 
+void
+TargetProperties::SetLanguage (lldb::LanguageType language) {
+    OptionValueLanguage *value = m_collection_sp->GetPropertyAtIndexAsOptionValueLanguage(NULL, ePropertyLanguage);
+    value->SetLanguageValue(language);
+}
+
 const char *
 TargetProperties::GetExpressionPrefixContentsAsCString ()
 {
     const uint32_t idx = ePropertyExprPrefix;
     OptionValueFileSpec *file = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpec (NULL, false, idx);
     if (file)
     {
         const bool null_terminate = true;

test/lang/cpp/chained-calls/Makefile

+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

test/lang/cpp/chained-calls/TestCppChainedCalls.py

+import lldb
+from lldbtest import *
+import lldbutil
+
+class TestCppChainedCalls(TestBase):
+    
+    mydir = TestBase.compute_mydir(__file__)
+    
+    @skipUnlessDarwin
+    @dsym_test
+    def test_with_dsym_and_run_command(self):
+        self.buildDsym()
+        self.check()
+
+    @dwarf_test
+    def test_with_dwarf_and_run_command(self):
+        self.buildDwarf()
+        self.check()
+
+    def setUp(self):
+        TestBase.setUp(self)
+
+    def check(self):
+        # Get main source file
+        src_file = "main.cpp"
+        src_file_spec = lldb.SBFileSpec(src_file)
+        self.assertTrue(src_file_spec.IsValid(), "Main source file")
+        
+        # Get the path of the executable
+        cwd = os.getcwd() 
+        exe_file = "a.out"
+        exe_path  = os.path.join(cwd, exe_file)
+        
+        # Load the executable
+        target = self.dbg.CreateTarget(exe_path)
+        self.assertTrue(target.IsValid(), VALID_TARGET)
+
+        # Break on main function
+        main_breakpoint = target.BreakpointCreateBySourceRegex("Break here", src_file_spec)
+        self.assertTrue(main_breakpoint.IsValid() and main_breakpoint.GetNumLocations() >= 1, VALID_BREAKPOINT)
+
+        # Launch the process
+        args = None
+        env = None
+        process = target.LaunchSimple(args, env, cwd)
+        self.assertTrue(process.IsValid(), PROCESS_IS_VALID)
+
+        # Get the thread of the process
+        self.assertTrue(process.GetState() == lldb.eStateStopped, PROCESS_STOPPED)
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+
+        # Get frame for current thread 
+        frame = thread.GetSelectedFrame()
+        
+        # Test chained calls
+        test_result = frame.EvaluateExpression("g(f(12345))")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 12345, "g(f(12345)) = 12345")
+
+        test_result = frame.EvaluateExpression("q(p()).a")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 12345678, "q(p()).a = 12345678")
+
+        test_result = frame.EvaluateExpression("(p() + r()).a")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 22345678, "(p() + r()).a = 22345678")
+
+        test_result = frame.EvaluateExpression("q(p() + r()).a")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 22345678, "q(p() + r()).a = 22345678")
+
+        test_result = frame.EvaluateExpression("g(f(6700) + f(89))")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 6789, "g(f(6700) + f(89)) = 6789")
+
+        test_result = frame.EvaluateExpression("g(f(g(f(300) + f(40))) + f(5))")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 345, "g(f(g(f(300) + f(40))) + f(5)) = 345")
+
+        test_result = frame.EvaluateExpression("getb(makeb(), 789)")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 789, "getb(makeb(), 789) = 789")
+
+        test_result = frame.EvaluateExpression("(*c).a")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 5678, "(*c).a = 5678")
+
+        test_result = frame.EvaluateExpression("(*c + *c).a")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 11356, "(*c + *c).a = 11356")
+
+        test_result = frame.EvaluateExpression("q(*c + *c).a")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 11356, "q(*c + *c).a = 11356")
+
+        test_result = frame.EvaluateExpression("make_int().get_type()")
+        self.assertTrue(test_result.IsValid() and test_result.GetValue() == "INT", "make_int().get_type() = \"INT\"")
+
+
+if __name__ == '__main__':
+    import atexit
+    lldb.SBDebugger.Initialize()
+    atexit.register(lambda: lldb.SBDebugger.Terminate())
+    unittest2.main()

test/lang/cpp/chained-calls/main.cpp

+class S
+{
+public:
+  S () { }
+  S (S &obj);
+
+  S operator+ (const S &s);
+
+  int a;
+};
+
+S::S (S &obj)
+{
+  a = obj.a;
+}
+
+S
+S::operator+ (const S &s)
+{
+  S res;
+
+  res.a = a + s.a;
+
+  return res;
+}
+
+S
+f (int i)
+{
+  S s;
+
+  s.a = i;
+
+  return s;
+}
+
+int
+g (const S &s)
+{
+  return s.a;
+}
+
+class A
+{
+public:
+  A operator+ (const A &);
+  int a;
+};
+
+A
+A::operator+ (const A &obj)
+{
+  A n;
+
+  n.a = a + obj.a;
+
+  return n;
+}
+
+A
+p ()
+{
+  A a;
+  a.a = 12345678;
+  return a;
+}
+
+A
+r ()
+{
+  A a;
+  a.a = 10000000;
+  return a;
+}
+
+A
+q (const A &a)
+{
+  return a;
+}
+
+class B
+{
+public:
+  int b[1024];
+};
+
+B
+makeb ()
+{
+  B b;
+  int i;
+
+  for (i = 0; i < 1024; i++)
+    b.b[i] = i;
+
+  return b;
+}
+
+int
+getb (const B &b, int i)
+{
+  return b.b[i];
+}
+
+class C
+{
+public:
+  C ();
+  ~C ();
+
+  A operator* ();
+
+  A *a_ptr;
+};
+
+C::C ()
+{
+  a_ptr = new A;
+  a_ptr->a = 5678;
+}
+
+C::~C ()
+{
+  delete a_ptr;
+}
+
+A
+C::operator* ()
+{
+  return *a_ptr;
+}
+
+#define TYPE_INDEX 1
+
+enum type
+{
+  INT,
+  CHAR
+};
+
+union U
+{
+public:
+  U (type t);
+  type get_type ();
+
+  int a;
+  char c;
+  type tp[2];
+};
+
+U::U (type t)
+{
+  tp[TYPE_INDEX] = t;
+}
+
+U
+make_int ()
+{
+  return U (INT);
+}
+
+U
+make_char ()
+{
+  return U (CHAR);
+}
+
+type
+U::get_type ()
+{
+  return tp[TYPE_INDEX];
+}
+
+int
+main ()
+{
+  int i = g(f(0));
+  A a = q(p() + r());
+
+  B b = makeb ();
+  C c;
+
+  return i + getb(b, 0);  /* Break here */
+}

test/lang/cpp/global_operators/Makefile

+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

test/lang/cpp/global_operators/TestCppGlobalOperators.py

+"""
+Test that global operators are found and evaluated.
+"""
+import lldb
+from lldbtest import *
+import lldbutil
+
+class TestCppGlobalOperators(TestBase):
+    
+    mydir = TestBase.compute_mydir(__file__)
+    
+    @skipUnlessDarwin
+    @dsym_test
+    def test_with_dsym_and_run_command(self):
+        self.buildDsym()
+        self.check()
+
+    @dwarf_test
+    def test_with_dwarf_and_run_command(self):
+        self.buildDwarf()
+        self.check()
+
+    def setUp(self):
+        TestBase.setUp(self)
+
+    def check(self):
+        # Get main source file
+        src_file = "main.cpp"
+        src_file_spec = lldb.SBFileSpec(src_file)
+        self.assertTrue(src_file_spec.IsValid(), "Main source file")
+        
+        # Get the path of the executable
+        cwd = os.getcwd() 
+        exe_file = "a.out"
+        exe_path  = os.path.join(cwd, exe_file)
+        
+        # Load the executable
+        target = self.dbg.CreateTarget(exe_path)
+        self.assertTrue(target.IsValid(), VALID_TARGET)
+
+        # Break on main function
+        main_breakpoint = target.BreakpointCreateBySourceRegex("// break here", src_file_spec)
+        self.assertTrue(main_breakpoint.IsValid() and main_breakpoint.GetNumLocations() >= 1, VALID_BREAKPOINT)
+
+        # Launch the process
+        args = None
+        env = None
+        process = target.LaunchSimple(args, env, cwd)
+        self.assertTrue(process.IsValid(), PROCESS_IS_VALID)
+
+        # Get the thread of the process
+        self.assertTrue(process.GetState() == lldb.eStateStopped, PROCESS_STOPPED)
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+
+        # Check if global operators are evaluated 
+        frame = thread.GetSelectedFrame()
+
+        test_result = frame.EvaluateExpression("operator==(s1, s2)")
+        self.assertTrue(test_result.IsValid() and test_result.GetValue() == "false", "operator==(s1, s2) = false")
+ 
+        test_result = frame.EvaluateExpression("operator==(s1, s3)")
+        self.assertTrue(test_result.IsValid() and test_result.GetValue() == "true", "operator==(s1, s3) = true")
+
+        test_result = frame.EvaluateExpression("operator==(s2, s3)")
+        self.assertTrue(test_result.IsValid() and test_result.GetValue() == "false", "operator==(s2, s3) = false")
+
+
+if __name__ == '__main__':
+    import atexit
+    lldb.SBDebugger.Initialize()
+    atexit.register(lambda: lldb.SBDebugger.Terminate())
+    unittest2.main()

test/lang/cpp/global_operators/main.cpp

+struct Struct {
+  int value;
+};
+
+bool operator==(const Struct &a, const Struct &b) {
+  return a.value == b.value;
+}
+
+int main() {
+  Struct s1, s2, s3;
+  s1.value = 3;
+  s2.value = 5;
+  s3.value = 3;
+  return 0; // break here
+}
+

test/lang/cpp/nsimport/Makefile

+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

test/lang/cpp/nsimport/TestCppNsImport.py

+"""
+Tests imported namespaces in C++.
+"""
+import lldb
+from lldbtest import *
+import lldbutil
+
+class TestCppNsImport(TestBase):
+    
+    mydir = TestBase.compute_mydir(__file__)
+    
+    @skipUnlessDarwin
+    @dsym_test
+    def test_with_dsym_and_run_command(self):
+        """Tests imported namespaces in C++."""
+        self.buildDsym()
+        self.check()
+
+    @dwarf_test
+    def test_with_dwarf_and_run_command(self):
+        """Tests imported namespaces in C++."""
+        self.buildDwarf()
+        self.check()
+
+    def setUp(self):
+        TestBase.setUp(self)
+
+    def check(self):
+        """Tests imported namespaces in C++."""
+
+        # Get main source file
+        src_file = "main.cpp"
+        src_file_spec = lldb.SBFileSpec(src_file)
+        self.assertTrue(src_file_spec.IsValid(), "Main source file")
+        
+        # Get the path of the executable
+        cwd = os.getcwd() 
+        exe_file = "a.out"
+        exe_path  = os.path.join(cwd, exe_file)
+        
+        # Load the executable
+        target = self.dbg.CreateTarget(exe_path)
+        self.assertTrue(target.IsValid(), VALID_TARGET)
+
+        # Break on main function
+        main_breakpoint = target.BreakpointCreateByName("main")
+        self.assertTrue(main_breakpoint.IsValid() and main_breakpoint.GetNumLocations() >= 1, VALID_BREAKPOINT)
+
+        # Launch the process
+        args = None
+        env = None
+        process = target.LaunchSimple(args, env, cwd)
+        self.assertTrue(process.IsValid(), PROCESS_IS_VALID)
+
+        # Get the thread of the process
+        self.assertTrue(process.GetState() == lldb.eStateStopped, PROCESS_STOPPED)
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+
+        # Get current fream of the thread at the breakpoint 
+        frame = thread.GetSelectedFrame()
+
+        # Test imported namespaces
+        test_result = frame.EvaluateExpression("x")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 11, "x = 11")
+        
+        test_result = frame.EvaluateExpression("xx")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 22, "xx = 22")
+
+        test_result = frame.EvaluateExpression("xxx")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 33, "xxx = 33")
+
+if __name__ == '__main__':
+    import atexit
+    lldb.SBDebugger.Initialize()
+    atexit.register(lambda: lldb.SBDebugger.Terminate())
+    unittest2.main()

test/lang/cpp/nsimport/main.cpp

+namespace A {
+    int x = 11;
+    namespace {
+        int xx = 22;
+    }
+}
+
+using namespace A;
+
+namespace {
+    int xxx = 33;
+};
+
+int main() {
+    x;
+    xx;
+    xxx;
+    return 0;
+}

test/lang/cpp/restricted_names/Makefile

+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

test/lang/cpp/restricted_names/TestCppRestrictedNames.py

+"""
+Test restricted names ('id' and 'Class') in C++.
+"""
+import lldb
+from lldbtest import *
+import lldbutil
+
+class TestCppSizeof(TestBase):
+    
+    mydir = TestBase.compute_mydir(__file__)
+    
+    @skipUnlessDarwin
+    @dsym_test
+    def test_with_dsym_and_run_command(self):
+        self.buildDsym()
+        self.check()
+
+    @dwarf_test
+    def test_with_dwarf_and_run_command(self):
+        self.buildDwarf()
+        self.check()
+
+    def setUp(self):
+        TestBase.setUp(self)
+
+    def check(self):
+        # Get main source file
+        src_file = "main.cpp"
+        src_file_spec = lldb.SBFileSpec(src_file)
+        self.assertTrue(src_file_spec.IsValid(), "Main source file")
+        
+        # Get the path of the executable
+        cwd = os.getcwd() 
+        exe_file = "a.out"
+        exe_path  = os.path.join(cwd, exe_file)
+        
+        # Load the executable
+        target = self.dbg.CreateTarget(exe_path)
+        self.assertTrue(target.IsValid(), VALID_TARGET)
+
+        # Break on main function
+        main_breakpoint = target.BreakpointCreateBySourceRegex("// break here", src_file_spec)
+        self.assertTrue(main_breakpoint.IsValid() and main_breakpoint.GetNumLocations() >= 1, VALID_BREAKPOINT)
+
+        # Launch the process
+        args = None
+        env = None
+        process = target.LaunchSimple(args, env, cwd)
+        self.assertTrue(process.IsValid(), PROCESS_IS_VALID)
+
+        # Get the thread of the process
+        self.assertTrue(process.GetState() == lldb.eStateStopped, PROCESS_STOPPED)
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+
+        # Get current fream of the thread at the breakpoint 
+        frame = thread.GetSelectedFrame()
+
+        # Test result for restricted names (check for wrong result)
+        test_result = frame.EvaluateExpression("Class(2)")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 4, "Class(2) = 4")
+        
+        test_result = frame.EvaluateExpression("Class(3)")
+        self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 6, "Class(3) = 6")
+        
+
+if __name__ == '__main__':
+    import atexit
+    lldb.SBDebugger.Initialize()
+    atexit.register(lambda: lldb.SBDebugger.Terminate())
+    unittest2.main()

test/lang/cpp/restricted_names/main.cpp

+int Class(int x) {
+    return x + x;
+}
+
+int main() { // break here
+    return 0;
+}

test/lang/objc/objc-builtin-types/TestObjCBuiltinTypes.py

 """Test that the expression parser doesn't get confused by 'id' and 'Class'"""
 
 import os, time
 import unittest2
 import lldb
 import lldbutil
 from lldbtest import *
 
 class TestObjCBuiltinTypes(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipUnlessDarwin
-    @python_api_test
-
+    @unittest2.expectedFailure
     @dsym_test
     def test_with_dsym_and_python_api(self):
         """Test expression parser respect for ObjC built-in types."""
         self.buildDsym()
         self.objc_builtin_types()
 
-    @python_api_test
+    @unittest2.expectedFailure
     @dwarf_test
     def test_with_dwarf_and_python_api(self):
         """Test expression parser respect for ObjC built-in types."""
         self.buildDwarf()
         self.objc_builtin_types()
 
     def setUp(self):
         # Call super's setUp().