ClangExpressionDeclMap.h revision 21ef5bb658e4582339bedf5befc10c13953bdac0
1//===-- ClangExpressionDeclMap.h --------------------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10#ifndef liblldb_ClangExpressionDeclMap_h_ 11#define liblldb_ClangExpressionDeclMap_h_ 12 13// C Includes 14#include <signal.h> 15#include <stdint.h> 16 17// C++ Includes 18#include <vector> 19 20// Other libraries and framework includes 21// Project includes 22#include "llvm/ADT/APInt.h" 23#include "llvm/ADT/DenseMap.h" 24#include "clang/AST/Decl.h" 25#include "lldb/lldb-public.h" 26#include "lldb/Core/ClangForward.h" 27#include "lldb/Core/Value.h" 28#include "lldb/Expression/ClangASTSource.h" 29#include "lldb/Expression/ClangExpressionVariable.h" 30#include "lldb/Symbol/TaggedASTType.h" 31#include "lldb/Symbol/SymbolContext.h" 32#include "lldb/Target/ExecutionContext.h" 33 34namespace lldb_private { 35 36//---------------------------------------------------------------------- 37/// @class ClangExpressionDeclMap ClangExpressionDeclMap.h "lldb/Expression/ClangExpressionDeclMap.h" 38/// @brief Manages named entities that are defined in LLDB's debug information. 39/// 40/// The Clang parser uses the ClangASTSource as an interface to request named 41/// entities from outside an expression. The ClangASTSource reports back, listing 42/// all possible objects corresponding to a particular name. But it in turn 43/// relies on ClangExpressionDeclMap, which performs several important functions. 44/// 45/// First, it records what variables and functions were looked up and what Decls 46/// were returned for them. 47/// 48/// Second, it constructs a struct on behalf of IRForTarget, recording which 49/// variables should be placed where and relaying this information back so that 50/// IRForTarget can generate context-independent code. 51/// 52/// Third, it "materializes" this struct on behalf of the expression command, 53/// finding the current values of each variable and placing them into the 54/// struct so that it can be passed to the JITted version of the IR. 55/// 56/// Fourth and finally, it "dematerializes" the struct after the JITted code has 57/// has executed, placing the new values back where it found the old ones. 58//---------------------------------------------------------------------- 59class ClangExpressionDeclMap : 60 public ClangASTSource 61{ 62public: 63 //------------------------------------------------------------------ 64 /// Constructor 65 /// 66 /// Initializes class variables. 67 /// 68 /// @param[in] keep_result_in_memory 69 /// If true, inhibits the normal deallocation of the memory for 70 /// the result persistent variable, and instead marks the variable 71 /// as persisting. 72 //------------------------------------------------------------------ 73 ClangExpressionDeclMap (bool keep_result_in_memory, 74 ExecutionContext &exe_ctx); 75 76 //------------------------------------------------------------------ 77 /// Destructor 78 //------------------------------------------------------------------ 79 ~ClangExpressionDeclMap (); 80 81 //------------------------------------------------------------------ 82 /// Enable the state needed for parsing and IR transformation. 83 /// 84 /// @param[in] exe_ctx 85 /// The execution context to use when finding types for variables. 86 /// Also used to find a "scratch" AST context to store result types. 87 /// 88 /// @return 89 /// True if parsing is possible; false if it is unsafe to continue. 90 //------------------------------------------------------------------ 91 bool 92 WillParse (ExecutionContext &exe_ctx); 93 94 //------------------------------------------------------------------ 95 /// [Used by ClangExpressionParser] For each variable that had an unknown 96 /// type at the beginning of parsing, determine its final type now. 97 /// 98 /// @return 99 /// True on success; false otherwise. 100 //------------------------------------------------------------------ 101 bool 102 ResolveUnknownTypes(); 103 104 //------------------------------------------------------------------ 105 /// Disable the state needed for parsing and IR transformation. 106 //------------------------------------------------------------------ 107 void 108 DidParse (); 109 110 //------------------------------------------------------------------ 111 /// [Used by IRForTarget] Get a new result variable name of the form 112 /// $n, where n is a natural number starting with 0. 113 /// 114 /// @param[in] name 115 /// The std::string to place the name into. 116 //------------------------------------------------------------------ 117 const ConstString & 118 GetPersistentResultName (); 119 120 //------------------------------------------------------------------ 121 /// [Used by IRForTarget] Get a constant variable given a name, 122 /// a type, and an llvm::APInt. 123 /// 124 /// @param[in] name 125 /// The name of the variable 126 /// 127 /// @param[in] type 128 /// The type of the variable, which will be imported into the 129 /// target's AST context 130 /// 131 /// @param[in] value 132 /// The value of the variable 133 /// 134 /// @return 135 /// The created variable 136 //------------------------------------------------------------------ 137 lldb::ClangExpressionVariableSP 138 BuildIntegerVariable (const ConstString &name, 139 lldb_private::TypeFromParser type, 140 const llvm::APInt& value); 141 142 //------------------------------------------------------------------ 143 /// [Used by IRForTarget] Cast an existing variable given a Decl and 144 /// a type. 145 /// 146 /// @param[in] name 147 /// The name of the new variable 148 /// 149 /// @param[in] decl 150 /// The Clang variable declaration for the original variable, 151 /// which must be looked up in the map 152 /// 153 /// @param[in] type 154 /// The desired type of the variable after casting 155 /// 156 /// @return 157 /// The created variable 158 //------------------------------------------------------------------ 159 lldb::ClangExpressionVariableSP 160 BuildCastVariable (const ConstString &name, 161 clang::VarDecl *decl, 162 lldb_private::TypeFromParser type); 163 164 //------------------------------------------------------------------ 165 /// [Used by IRForTarget] Add a variable to the list of persistent 166 /// variables for the process. 167 /// 168 /// @param[in] decl 169 /// The Clang declaration for the persistent variable, used for 170 /// lookup during parsing. 171 /// 172 /// @param[in] name 173 /// The name of the persistent variable, usually $something. 174 /// 175 /// @param[in] type 176 /// The type of the variable, in the Clang parser's context. 177 /// 178 /// @return 179 /// True on success; false otherwise. 180 //------------------------------------------------------------------ 181 bool 182 AddPersistentVariable (const clang::NamedDecl *decl, 183 const ConstString &name, 184 TypeFromParser type, 185 bool is_result, 186 bool is_lvalue); 187 188 //------------------------------------------------------------------ 189 /// [Used by IRForTarget] Add a variable to the struct that needs to 190 /// be materialized each time the expression runs. 191 /// 192 /// @param[in] decl 193 /// The Clang declaration for the variable. 194 /// 195 /// @param[in] name 196 /// The name of the variable. 197 /// 198 /// @param[in] value 199 /// The LLVM IR value for this variable. 200 /// 201 /// @param[in] size 202 /// The size of the variable in bytes. 203 /// 204 /// @param[in] alignment 205 /// The required alignment of the variable in bytes. 206 /// 207 /// @return 208 /// True on success; false otherwise. 209 //------------------------------------------------------------------ 210 bool 211 AddValueToStruct (const clang::NamedDecl *decl, 212 const ConstString &name, 213 llvm::Value *value, 214 size_t size, 215 off_t alignment); 216 217 //------------------------------------------------------------------ 218 /// [Used by IRForTarget] Finalize the struct, laying out the position 219 /// of each object in it. 220 /// 221 /// @return 222 /// True on success; false otherwise. 223 //------------------------------------------------------------------ 224 bool 225 DoStructLayout (); 226 227 //------------------------------------------------------------------ 228 /// [Used by IRForTarget] Get general information about the laid-out 229 /// struct after DoStructLayout() has been called. 230 /// 231 /// @param[out] num_elements 232 /// The number of elements in the struct. 233 /// 234 /// @param[out] size 235 /// The size of the struct, in bytes. 236 /// 237 /// @param[out] alignment 238 /// The alignment of the struct, in bytes. 239 /// 240 /// @return 241 /// True if the information could be retrieved; false otherwise. 242 //------------------------------------------------------------------ 243 bool 244 GetStructInfo (uint32_t &num_elements, 245 size_t &size, 246 off_t &alignment); 247 248 //------------------------------------------------------------------ 249 /// [Used by IRForTarget] Get specific information about one field 250 /// of the laid-out struct after DoStructLayout() has been called. 251 /// 252 /// @param[out] decl 253 /// The parsed Decl for the field, as generated by ClangASTSource 254 /// on ClangExpressionDeclMap's behalf. In the case of the result 255 /// value, this will have the name $__lldb_result even if the 256 /// result value ends up having the name $1. This is an 257 /// implementation detail of IRForTarget. 258 /// 259 /// @param[out] value 260 /// The IR value for the field (usually a GlobalVariable). In 261 /// the case of the result value, this will have the correct 262 /// name ($1, for instance). This is an implementation detail 263 /// of IRForTarget. 264 /// 265 /// @param[out] offset 266 /// The offset of the field from the beginning of the struct. 267 /// As long as the struct is aligned according to its required 268 /// alignment, this offset will align the field correctly. 269 /// 270 /// @param[out] name 271 /// The name of the field as used in materialization. 272 /// 273 /// @param[in] index 274 /// The index of the field about which information is requested. 275 /// 276 /// @return 277 /// True if the information could be retrieved; false otherwise. 278 //------------------------------------------------------------------ 279 bool 280 GetStructElement (const clang::NamedDecl *&decl, 281 llvm::Value *&value, 282 off_t &offset, 283 ConstString &name, 284 uint32_t index); 285 286 //------------------------------------------------------------------ 287 /// [Used by IRForTarget] Get information about a function given its 288 /// Decl. 289 /// 290 /// @param[in] decl 291 /// The parsed Decl for the Function, as generated by ClangASTSource 292 /// on ClangExpressionDeclMap's behalf. 293 /// 294 /// @param[out] ptr 295 /// The absolute address of the function in the target. 296 /// 297 /// @return 298 /// True if the information could be retrieved; false otherwise. 299 //------------------------------------------------------------------ 300 bool 301 GetFunctionInfo (const clang::NamedDecl *decl, 302 uint64_t &ptr); 303 304 //------------------------------------------------------------------ 305 /// [Used by IRForTarget] Get the address of a function given nothing 306 /// but its name. Some functions are needed but didn't get Decls made 307 /// during parsing -- specifically, sel_registerName is never called 308 /// in the generated IR but we need to call it nonetheless. 309 /// 310 /// @param[in] name 311 /// The name of the function. 312 /// 313 /// @param[out] ptr 314 /// The absolute address of the function in the target. 315 /// 316 /// @return 317 /// True if the address could be retrieved; false otherwise. 318 //------------------------------------------------------------------ 319 bool 320 GetFunctionAddress (const ConstString &name, 321 uint64_t &ptr); 322 323 //------------------------------------------------------------------ 324 /// [Used by IRForTarget] Get the address of a symbol given nothing 325 /// but its name. 326 /// 327 /// @param[in] target 328 /// The target to find the symbol in. If not provided, 329 /// then the current parsing context's Target. 330 /// 331 /// @param[in] name 332 /// The name of the symbol. 333 /// 334 /// @return 335 /// Valid load address for the symbol 336 //------------------------------------------------------------------ 337 lldb::addr_t 338 GetSymbolAddress (Target &target, 339 const ConstString &name, 340 lldb::SymbolType symbol_type); 341 342 lldb::addr_t 343 GetSymbolAddress (const ConstString &name, 344 lldb::SymbolType symbol_type); 345 346 //------------------------------------------------------------------ 347 /// [Used by IRInterpreter] Get basic target information. 348 /// 349 /// @param[out] byte_order 350 /// The byte order of the target. 351 /// 352 /// @param[out] address_byte_size 353 /// The size of a pointer in bytes. 354 /// 355 /// @return 356 /// True if the information could be determined; false 357 /// otherwise. 358 //------------------------------------------------------------------ 359 struct TargetInfo 360 { 361 lldb::ByteOrder byte_order; 362 size_t address_byte_size; 363 364 TargetInfo() : 365 byte_order(lldb::eByteOrderInvalid), 366 address_byte_size(0) 367 { 368 } 369 370 bool IsValid() 371 { 372 return (byte_order != lldb::eByteOrderInvalid && 373 address_byte_size != 0); 374 } 375 }; 376 TargetInfo GetTargetInfo(); 377 378 //------------------------------------------------------------------ 379 /// [Used by IRInterpreter] Promote an unknown address to a 380 /// LoadAddress or FileAddress depending on the presence of a 381 /// process. 382 /// 383 /// @param[in] addr 384 /// The address to promote. 385 /// 386 /// @return 387 /// The wrapped entity. 388 //------------------------------------------------------------------ 389 lldb_private::Value WrapBareAddress (lldb::addr_t addr); 390 391 //------------------------------------------------------------------ 392 /// [Used by IRInterpreter] Write to the target. 393 /// 394 /// @param[in] value 395 /// The address to write to. 396 /// 397 /// @param[in] addr 398 /// The address of the data buffer to read from. 399 /// 400 /// @param[in] length 401 /// The amount of data to write, in bytes. 402 /// 403 /// @return 404 /// True if the write could be performed; false otherwise. 405 //------------------------------------------------------------------ 406 bool 407 WriteTarget (lldb_private::Value &value, 408 const uint8_t *data, 409 size_t length); 410 411 //------------------------------------------------------------------ 412 /// [Used by IRInterpreter] Read from the target. 413 /// 414 /// @param[in] data 415 /// The address of the data buffer to write to. 416 /// 417 /// @param[in] value 418 /// The address to read from. 419 /// 420 /// @param[in] length 421 /// The amount of data to read, in bytes. 422 /// 423 /// @return 424 /// True if the read could be performed; false otherwise. 425 //------------------------------------------------------------------ 426 bool 427 ReadTarget (uint8_t *data, 428 lldb_private::Value &value, 429 size_t length); 430 431 //------------------------------------------------------------------ 432 /// [Used by IRInterpreter] Get the Value for a NamedDecl. 433 /// 434 /// @param[in] decl 435 /// The Decl whose value is to be found. 436 /// 437 /// @return 438 /// The value, or NULL. 439 //------------------------------------------------------------------ 440 lldb_private::Value 441 LookupDecl (clang::NamedDecl *decl); 442 443 //------------------------------------------------------------------ 444 /// [Used by IRInterpreter] Get the Value for "this", "self", or 445 /// "_cmd". 446 /// 447 /// @param[in] name 448 /// The name of the entity to be found. 449 /// 450 /// @return 451 /// The value, or NULL. 452 //------------------------------------------------------------------ 453 lldb_private::Value 454 GetSpecialValue (const ConstString &name); 455 456 //------------------------------------------------------------------ 457 /// [Used by IRInterpreter] Returns true if the result is a 458 /// reference to data in the target, meaning it must be 459 /// dereferenced once more to get its data. 460 /// 461 /// @param[in] name 462 /// The name of the result. 463 /// 464 /// @return 465 /// True if the result is a reference; false otherwise (or on 466 /// error). 467 //------------------------------------------------------------------ 468 bool 469 ResultIsReference (const ConstString &name); 470 471 //------------------------------------------------------------------ 472 /// [Used by IRInterpreter] Find the result persistent variable, 473 /// propagate the given value to it, and return it. 474 /// 475 /// @param[out] valobj 476 /// Set to the complete object. 477 /// 478 /// @param[in] value 479 /// A value indicating the location of the value's contents. 480 /// 481 /// @param[in] name 482 /// The name of the result. 483 /// 484 /// @param[in] type 485 /// The type of the data. 486 /// 487 /// @param[in] transient 488 /// True if the data should be treated as disappearing after the 489 /// expression completes. In that case, it gets no live data. 490 /// 491 /// @param[in] maybe_make_load 492 /// True if the value is a file address but should be potentially 493 /// upgraded to a load address if a target is presence. 494 /// 495 /// @return 496 /// True on success; false otherwise. 497 //------------------------------------------------------------------ 498 bool 499 CompleteResultVariable (lldb::ClangExpressionVariableSP &valobj, 500 lldb_private::Value &value, 501 const ConstString &name, 502 lldb_private::TypeFromParser type, 503 bool transient, 504 bool maybe_make_load); 505 506 //------------------------------------------------------------------ 507 /// [Used by CommandObjectExpression] Materialize the entire struct 508 /// at a given address, which should be aligned as specified by 509 /// GetStructInfo(). 510 /// 511 /// @param[in] exe_ctx 512 /// The execution context at which to dump the struct. 513 /// 514 /// @param[in] struct_address 515 /// The address at which the struct should be written. 516 /// 517 /// @param[in] error 518 /// An Error to populate with any messages related to 519 /// materializing the struct. 520 /// 521 /// @return 522 /// True on success; false otherwise. 523 //------------------------------------------------------------------ 524 bool 525 Materialize (ExecutionContext &exe_ctx, 526 lldb::addr_t &struct_address, 527 Error &error); 528 529 //------------------------------------------------------------------ 530 /// [Used by CommandObjectExpression] Get the "this" pointer 531 /// from a given execution context. 532 /// 533 /// @param[out] object_ptr 534 /// The this pointer. 535 /// 536 /// @param[in] object_name 537 /// The name of the object pointer -- "this," "self," or similar 538 /// depending on language 539 /// 540 /// @param[in] exe_ctx 541 /// The execution context at which to dump the struct. 542 /// 543 /// @param[in] error 544 /// An Error to populate with any messages related to 545 /// finding the "this" pointer. 546 /// 547 /// @param[in] suppress_type_check 548 /// True if the type is not needed. 549 /// 550 /// @return 551 /// True on success; false otherwise. 552 //------------------------------------------------------------------ 553 bool 554 GetObjectPointer (lldb::addr_t &object_ptr, 555 ConstString &object_name, 556 ExecutionContext &exe_ctx, 557 Error &error, 558 bool suppress_type_check = false); 559 560 //------------------------------------------------------------------ 561 /// [Used by CommandObjectExpression] Pretty-print a materialized 562 /// struct, which must have been materialized by Materialize(), 563 /// byte for byte on a given stream. 564 /// 565 /// @param[in] exe_ctx 566 /// The execution context from which to read the struct. 567 /// 568 /// @param[in] s 569 /// The stream on which to write the pretty-printed output. 570 /// 571 /// @param[in] error 572 /// An Error to populate with any messages related to 573 /// pretty-printing the struct. 574 /// 575 /// @return 576 /// True on success; false otherwise. 577 //------------------------------------------------------------------ 578 bool 579 DumpMaterializedStruct (ExecutionContext &exe_ctx, 580 Stream &s, 581 Error &error); 582 583 //------------------------------------------------------------------ 584 /// [Used by CommandObjectExpression] Deaterialize the entire struct. 585 /// 586 /// @param[in] exe_ctx 587 /// The execution context from which to read the struct. 588 /// 589 /// @param[out] result 590 /// A ClangExpressionVariable containing the result of the 591 /// expression, for potential re-use. 592 /// 593 /// @param[in] stack_frame_top, stack_frame_bottom 594 /// If not LLDB_INVALID_ADDRESS, the bounds for the stack frame 595 /// in which the expression ran. A result whose address falls 596 /// inside this stack frame is dematerialized as a value 597 /// requiring rematerialization. 598 /// 599 /// @param[in] error 600 /// An Error to populate with any messages related to 601 /// dematerializing the struct. 602 /// 603 /// @return 604 /// True on success; false otherwise. 605 //------------------------------------------------------------------ 606 bool 607 Dematerialize (ExecutionContext &exe_ctx, 608 lldb::ClangExpressionVariableSP &result_sp, 609 lldb::addr_t stack_frame_top, 610 lldb::addr_t stack_frame_bottom, 611 Error &error); 612 613 //------------------------------------------------------------------ 614 /// [Used by ClangASTSource] Find all entities matching a given name, 615 /// using a NameSearchContext to make Decls for them. 616 /// 617 /// @param[in] context 618 /// The NameSearchContext that can construct Decls for this name. 619 /// 620 /// @return 621 /// True on success; false otherwise. 622 //------------------------------------------------------------------ 623 void 624 FindExternalVisibleDecls (NameSearchContext &context); 625 626 //------------------------------------------------------------------ 627 /// Find all entities matching a given name in a given module/namespace, 628 /// using a NameSearchContext to make Decls for them. 629 /// 630 /// @param[in] context 631 /// The NameSearchContext that can construct Decls for this name. 632 /// 633 /// @param[in] module 634 /// If non-NULL, the module to query. 635 /// 636 /// @param[in] namespace_decl 637 /// If valid and module is non-NULL, the parent namespace. 638 /// 639 /// @param[in] name 640 /// The name as a plain C string. The NameSearchContext contains 641 /// a DeclarationName for the name so at first the name may seem 642 /// redundant, but ClangExpressionDeclMap operates in RTTI land so 643 /// it can't access DeclarationName. 644 /// 645 /// @param[in] current_id 646 /// The ID for the current FindExternalVisibleDecls invocation, 647 /// for logging purposes. 648 /// 649 /// @return 650 /// True on success; false otherwise. 651 //------------------------------------------------------------------ 652 void 653 FindExternalVisibleDecls (NameSearchContext &context, 654 lldb::ModuleSP module, 655 ClangNamespaceDecl &namespace_decl, 656 unsigned int current_id); 657private: 658 ClangExpressionVariableList m_found_entities; ///< All entities that were looked up for the parser. 659 ClangExpressionVariableList m_struct_members; ///< All entities that need to be placed in the struct. 660 bool m_keep_result_in_memory; ///< True if result persistent variables generated by this expression should stay in memory. 661 662 //---------------------------------------------------------------------- 663 /// The following values should not live beyond parsing 664 //---------------------------------------------------------------------- 665 class ParserVars 666 { 667 public: 668 ParserVars(ClangExpressionDeclMap &decl_map) : 669 m_exe_ctx(NULL), 670 m_sym_ctx(), 671 m_persistent_vars(NULL), 672 m_enable_lookups(false), 673 m_decl_map(decl_map) 674 { 675 } 676 677 Target * 678 GetTarget() 679 { 680 if (m_exe_ctx && m_exe_ctx->GetTargetPtr()) 681 return m_exe_ctx->GetTargetPtr(); 682 else if (m_sym_ctx.target_sp) 683 m_sym_ctx.target_sp.get(); 684 return NULL; 685 } 686 687 ExecutionContext *m_exe_ctx; ///< The execution context to use when parsing. 688 SymbolContext m_sym_ctx; ///< The symbol context to use in finding variables and types. 689 ClangPersistentVariables *m_persistent_vars; ///< The persistent variables for the process. 690 bool m_enable_lookups; ///< Set to true during parsing if we have found the first "$__lldb" name. 691 TargetInfo m_target_info; ///< Basic information about the target. 692 private: 693 ClangExpressionDeclMap &m_decl_map; 694 DISALLOW_COPY_AND_ASSIGN (ParserVars); 695 }; 696 697 std::auto_ptr<ParserVars> m_parser_vars; 698 699 //---------------------------------------------------------------------- 700 /// Activate parser-specific variables 701 //---------------------------------------------------------------------- 702 void 703 EnableParserVars() 704 { 705 if (!m_parser_vars.get()) 706 m_parser_vars.reset(new ParserVars(*this)); 707 } 708 709 //---------------------------------------------------------------------- 710 /// Deallocate parser-specific variables 711 //---------------------------------------------------------------------- 712 void 713 DisableParserVars() 714 { 715 m_parser_vars.reset(); 716 } 717 718 //---------------------------------------------------------------------- 719 /// The following values contain layout information for the materialized 720 /// struct, but are not specific to a single materialization 721 //---------------------------------------------------------------------- 722 struct StructVars { 723 StructVars() : 724 m_struct_alignment(0), 725 m_struct_size(0), 726 m_struct_laid_out(false), 727 m_result_name(), 728 m_object_pointer_type(NULL, NULL) 729 { 730 } 731 732 off_t m_struct_alignment; ///< The alignment of the struct in bytes. 733 size_t m_struct_size; ///< The size of the struct in bytes. 734 bool m_struct_laid_out; ///< True if the struct has been laid out and the layout is valid (that is, no new fields have been added since). 735 ConstString m_result_name; ///< The name of the result variable ($1, for example) 736 TypeFromUser m_object_pointer_type; ///< The type of the "this" variable, if one exists 737 }; 738 739 std::auto_ptr<StructVars> m_struct_vars; 740 741 //---------------------------------------------------------------------- 742 /// Activate struct variables 743 //---------------------------------------------------------------------- 744 void 745 EnableStructVars() 746 { 747 if (!m_struct_vars.get()) 748 m_struct_vars.reset(new struct StructVars); 749 } 750 751 //---------------------------------------------------------------------- 752 /// Deallocate struct variables 753 //---------------------------------------------------------------------- 754 void 755 DisableStructVars() 756 { 757 m_struct_vars.reset(); 758 } 759 760 //---------------------------------------------------------------------- 761 /// The following values refer to a specific materialization of the 762 /// structure in a process 763 //---------------------------------------------------------------------- 764 struct MaterialVars { 765 MaterialVars() : 766 m_allocated_area(0), 767 m_materialized_location(0) 768 { 769 } 770 771 Process *m_process; ///< The process that the struct is materialized into. 772 lldb::addr_t m_allocated_area; ///< The base of the memory allocated for the struct. Starts on a potentially unaligned address and may therefore be larger than the struct. 773 lldb::addr_t m_materialized_location; ///< The address at which the struct is placed. Falls inside the allocated area. 774 }; 775 776 std::auto_ptr<MaterialVars> m_material_vars; 777 778 //---------------------------------------------------------------------- 779 /// Activate materialization-specific variables 780 //---------------------------------------------------------------------- 781 void 782 EnableMaterialVars() 783 { 784 if (!m_material_vars.get()) 785 m_material_vars.reset(new struct MaterialVars); 786 } 787 788 //---------------------------------------------------------------------- 789 /// Deallocate materialization-specific variables 790 //---------------------------------------------------------------------- 791 void 792 DisableMaterialVars() 793 { 794 m_material_vars.reset(); 795 } 796 797 //------------------------------------------------------------------ 798 /// Given a stack frame, find a variable that matches the given name and 799 /// type. We need this for expression re-use; we may not always get the 800 /// same lldb::Variable back, and we want the expression to work wherever 801 /// it can. Returns the variable defined in the tightest scope. 802 /// 803 /// @param[in] frame 804 /// The stack frame to use as a basis for finding the variable. 805 /// 806 /// @param[in] name 807 /// The name as a plain C string. 808 /// 809 /// @param[in] type 810 /// The required type for the variable. This function may be called 811 /// during parsing, in which case we don't know its type; hence the 812 /// default. 813 /// 814 /// @return 815 /// The LLDB Variable found, or NULL if none was found. 816 //------------------------------------------------------------------ 817 lldb::VariableSP 818 FindVariableInScope (StackFrame &frame, 819 const ConstString &name, 820 TypeFromUser *type = NULL); 821 822 //------------------------------------------------------------------ 823 /// Given a target, find a data symbol that has the given name. 824 /// 825 /// @param[in] target 826 /// The target to use as the basis for the search. 827 /// 828 /// @param[in] name 829 /// The name as a plain C string. 830 /// 831 /// @return 832 /// The LLDB Symbol found, or NULL if none was found. 833 //--------------------------------------------------------- 834 Symbol * 835 FindGlobalDataSymbol (Target &target, 836 const ConstString &name); 837 838 //------------------------------------------------------------------ 839 /// Given a target, find a variable that matches the given name and 840 /// type. 841 /// 842 /// @param[in] target 843 /// The target to use as a basis for finding the variable. 844 /// 845 /// @param[in] module 846 /// If non-NULL, the module to search. 847 /// 848 /// @param[in] name 849 /// The name as a plain C string. 850 /// 851 /// @param[in] namespace_decl 852 /// If non-NULL and module is non-NULL, the parent namespace. 853 /// 854 /// @param[in] type 855 /// The required type for the variable. This function may be called 856 /// during parsing, in which case we don't know its type; hence the 857 /// default. 858 /// 859 /// @return 860 /// The LLDB Variable found, or NULL if none was found. 861 //------------------------------------------------------------------ 862 lldb::VariableSP 863 FindGlobalVariable (Target &target, 864 lldb::ModuleSP &module, 865 const ConstString &name, 866 ClangNamespaceDecl *namespace_decl, 867 TypeFromUser *type = NULL); 868 869 //------------------------------------------------------------------ 870 /// Get the value of a variable in a given execution context and return 871 /// the associated Types if needed. 872 /// 873 /// @param[in] exe_ctx 874 /// The execution context to look for the variable in. 875 /// 876 /// @param[in] var 877 /// The variable to evaluate. 878 /// 879 /// @param[in] parser_ast_context 880 /// The AST context of the parser, to store the found type in. 881 /// 882 /// @param[out] found_type 883 /// The type of the found value, as it was found in the user process. 884 /// This is only useful when the variable is being inspected on behalf 885 /// of the parser, hence the default. 886 /// 887 /// @param[out] parser_type 888 /// The type of the found value, as it was copied into the parser's 889 /// AST context. This is only useful when the variable is being 890 /// inspected on behalf of the parser, hence the default. 891 /// 892 /// @param[in] decl 893 /// The Decl to be looked up. 894 /// 895 /// @return 896 /// The LLDB Value for the variable. 897 //------------------------------------------------------------------ 898 Value * 899 GetVariableValue (ExecutionContext &exe_ctx, 900 lldb::VariableSP &var, 901 clang::ASTContext *parser_ast_context, 902 TypeFromUser *found_type = NULL, 903 TypeFromParser *parser_type = NULL); 904 905 //------------------------------------------------------------------ 906 /// Use the NameSearchContext to generate a Decl for the given LLDB 907 /// Variable, and put it in the Tuple list. 908 /// 909 /// @param[in] context 910 /// The NameSearchContext to use when constructing the Decl. 911 /// 912 /// @param[in] var 913 /// The LLDB Variable that needs a Decl. 914 /// 915 /// @param[in] valobj 916 /// The LLDB ValueObject for that variable. 917 //------------------------------------------------------------------ 918 void 919 AddOneVariable (NameSearchContext &context, 920 lldb::VariableSP var, 921 lldb::ValueObjectSP valobj, 922 unsigned int current_id); 923 924 //------------------------------------------------------------------ 925 /// Use the NameSearchContext to generate a Decl for the given 926 /// persistent variable, and put it in the list of found entities. 927 /// 928 /// @param[in] context 929 /// The NameSearchContext to use when constructing the Decl. 930 /// 931 /// @param[in] pvar 932 /// The persistent variable that needs a Decl. 933 /// 934 /// @param[in] current_id 935 /// The ID of the current invocation of FindExternalVisibleDecls 936 /// for logging purposes. 937 //------------------------------------------------------------------ 938 void 939 AddOneVariable (NameSearchContext &context, 940 lldb::ClangExpressionVariableSP &pvar_sp, 941 unsigned int current_id); 942 943 //------------------------------------------------------------------ 944 /// Use the NameSearchContext to generate a Decl for the given LLDB 945 /// symbol (treated as a variable), and put it in the list of found 946 /// entities. 947 /// 948 /// @param[in] context 949 /// The NameSearchContext to use when constructing the Decl. 950 /// 951 /// @param[in] var 952 /// The LLDB Variable that needs a Decl. 953 //------------------------------------------------------------------ 954 void 955 AddOneGenericVariable (NameSearchContext &context, 956 Symbol &symbol, 957 unsigned int current_id); 958 959 //------------------------------------------------------------------ 960 /// Use the NameSearchContext to generate a Decl for the given 961 /// function. (Functions are not placed in the Tuple list.) Can 962 /// handle both fully typed functions and generic functions. 963 /// 964 /// @param[in] context 965 /// The NameSearchContext to use when constructing the Decl. 966 /// 967 /// @param[in] fun 968 /// The Function that needs to be created. If non-NULL, this is 969 /// a fully-typed function. 970 /// 971 /// @param[in] sym 972 /// The Symbol that corresponds to a function that needs to be 973 /// created with generic type (unitptr_t foo(...)). 974 //------------------------------------------------------------------ 975 void 976 AddOneFunction (NameSearchContext &context, 977 Function *fun, 978 Symbol *sym, 979 unsigned int current_id); 980 981 //------------------------------------------------------------------ 982 /// Use the NameSearchContext to generate a Decl for the given 983 /// register. 984 /// 985 /// @param[in] context 986 /// The NameSearchContext to use when constructing the Decl. 987 /// 988 /// @param[in] reg_info 989 /// The information corresponding to that register. 990 //------------------------------------------------------------------ 991 void 992 AddOneRegister (NameSearchContext &context, 993 const RegisterInfo *reg_info, 994 unsigned int current_id); 995 996 //------------------------------------------------------------------ 997 /// Use the NameSearchContext to generate a Decl for the given 998 /// type. (Types are not placed in the Tuple list.) 999 /// 1000 /// @param[in] context 1001 /// The NameSearchContext to use when constructing the Decl. 1002 /// 1003 /// @param[in] type 1004 /// The type that needs to be created. 1005 /// 1006 /// @param[in] add_method 1007 /// True if a method with signature void $__lldb_expr(void*) 1008 /// should be added to the C++ class type passed in 1009 //------------------------------------------------------------------ 1010 void 1011 AddOneType (NameSearchContext &context, 1012 TypeFromUser &type, 1013 unsigned int current_id, 1014 bool add_method); 1015 1016 //------------------------------------------------------------------ 1017 /// Actually do the task of materializing or dematerializing the struct. 1018 /// Since both tasks are very similar, although ClangExpressionDeclMap 1019 /// exposes two functions to the outside, both call DoMaterialize. 1020 /// 1021 /// @param[in] dematerialize 1022 /// True if the struct is to be dematerialized; false if it is to 1023 /// be materialized. 1024 /// 1025 /// @param[in] exe_ctx 1026 /// The execution context to use. 1027 /// 1028 /// @param[in] stack_frame_top, stack_frame_bottom 1029 /// If not LLDB_INVALID_ADDRESS, the bounds for the stack frame 1030 /// in which the expression ran. A result whose address falls 1031 /// inside this stack frame is dematerialized as a value 1032 /// requiring rematerialization. 1033 /// 1034 /// @param[out] result 1035 /// If the struct is being dematerialized, a pointer into which the 1036 /// location of the result persistent variable is placed. If not, 1037 /// NULL. 1038 /// 1039 /// @param[in] err 1040 /// An Error to populate with any messages related to 1041 /// (de)materializing the struct. 1042 /// 1043 /// @return 1044 /// True on success; false otherwise. 1045 //------------------------------------------------------------------ 1046 bool 1047 DoMaterialize (bool dematerialize, 1048 ExecutionContext &exe_ctx, 1049 lldb::addr_t stack_frame_top, 1050 lldb::addr_t stack_frame_bottom, 1051 lldb::ClangExpressionVariableSP *result_sp_ptr, 1052 Error &err); 1053 1054 //------------------------------------------------------------------ 1055 /// Clean up the state required to dematerialize the variable. 1056 //------------------------------------------------------------------ 1057 void 1058 DidDematerialize (); 1059 1060 //------------------------------------------------------------------ 1061 /// Actually do the task of materializing or dematerializing a persistent 1062 /// variable. 1063 /// 1064 /// @param[in] dematerialize 1065 /// True if the variable is to be dematerialized; false if it is to 1066 /// be materialized. 1067 /// 1068 /// @param[in] exe_ctx 1069 /// The execution context to use. 1070 /// 1071 /// @param[in] var_sp 1072 /// The persistent variable to materialize 1073 /// 1074 /// @param[in] addr 1075 /// The address at which to materialize the variable. 1076 /// 1077 /// @param[in] stack_frame_top, stack_frame_bottom 1078 /// If not LLDB_INVALID_ADDRESS, the bounds for the stack frame 1079 /// in which the expression ran. A result whose address falls 1080 /// inside this stack frame is dematerialized as a value 1081 /// requiring rematerialization. 1082 /// 1083 /// @param[in] err 1084 /// An Error to populate with any messages related to 1085 /// (de)materializing the persistent variable. 1086 /// 1087 /// @return 1088 /// True on success; false otherwise. 1089 //------------------------------------------------------------------ 1090 bool 1091 DoMaterializeOnePersistentVariable (bool dematerialize, 1092 ExecutionContext &exe_ctx, 1093 lldb::ClangExpressionVariableSP &var_sp, 1094 lldb::addr_t addr, 1095 lldb::addr_t stack_frame_top, 1096 lldb::addr_t stack_frame_bottom, 1097 Error &err); 1098 1099 //------------------------------------------------------------------ 1100 /// Actually do the task of materializing or dematerializing a 1101 /// variable. 1102 /// 1103 /// @param[in] dematerialize 1104 /// True if the variable is to be dematerialized; false if it is to 1105 /// be materialized. 1106 /// 1107 /// @param[in] exe_ctx 1108 /// The execution context to use. 1109 /// 1110 /// @param[in] sym_ctx 1111 /// The symbol context to use (for looking the variable up). 1112 /// 1113 /// @param[in] expr_var 1114 /// The entity that the expression parser uses for the variable. 1115 /// In case the variable needs to be copied into the target's 1116 /// memory, this location is stored in the variable during 1117 /// materialization and cleared when it is demateralized. 1118 /// 1119 /// @param[in] addr 1120 /// The address at which to materialize the variable. 1121 /// 1122 /// @param[in] err 1123 /// An Error to populate with any messages related to 1124 /// (de)materializing the persistent variable. 1125 /// 1126 /// @return 1127 /// True on success; false otherwise. 1128 //------------------------------------------------------------------ 1129 bool 1130 DoMaterializeOneVariable (bool dematerialize, 1131 ExecutionContext &exe_ctx, 1132 const SymbolContext &sym_ctx, 1133 lldb::ClangExpressionVariableSP &expr_var, 1134 lldb::addr_t addr, 1135 Error &err); 1136 1137 //------------------------------------------------------------------ 1138 /// Actually do the task of materializing or dematerializing a 1139 /// register variable. 1140 /// 1141 /// @param[in] dematerialize 1142 /// True if the variable is to be dematerialized; false if it is to 1143 /// be materialized. 1144 /// 1145 /// @param[in] exe_ctx 1146 /// The execution context to use. 1147 /// 1148 /// @param[in] reg_ctx 1149 /// The register context to use. 1150 /// 1151 /// @param[in] reg_info 1152 /// The information for the register to read/write. 1153 /// 1154 /// @param[in] addr 1155 /// The address at which to materialize the variable. 1156 /// 1157 /// @param[in] err 1158 /// An Error to populate with any messages related to 1159 /// (de)materializing the persistent variable. 1160 /// 1161 /// @return 1162 /// True on success; false otherwise. 1163 //------------------------------------------------------------------ 1164 bool 1165 DoMaterializeOneRegister (bool dematerialize, 1166 ExecutionContext &exe_ctx, 1167 RegisterContext ®_ctx, 1168 const RegisterInfo ®_info, 1169 lldb::addr_t addr, 1170 Error &err); 1171}; 1172 1173} // namespace lldb_private 1174 1175#endif // liblldb_ClangExpressionDeclMap_h_ 1176