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 works only when the language of the expression to be evaluated is explicitly specified as C or C++. As future work, should we try to determine the language from the target and assume that C++ and ObjC runtimes are not available for most languages (i.e. go, rust, D, etc)?

[paulherman]

Update ClangASTSource constructor.

[paulherman]

• Guess the language of the expression based on the execution context.
• Tests for language guessing.

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)

source/Expression/ClangASTSource.cpp

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;

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

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)

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)
+        self.expect("expression --language c++11 -- Class(2)", substrs = ["= 4"])
+        #test_result = frame.EvaluateExpression("Class(2)")
+        #self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 4, "Class(2) = 4")
+        
+        self.expect("expression --language c++11 -- Class(3)", substrs = ["= 6"])
+        #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;
+}