1 //===-- IRForTarget.h ---------------------------------------------*- C++ 2 //-*-===// 3 // 4 // The LLVM Compiler Infrastructure 5 // 6 // This file is distributed under the University of Illinois Open Source 7 // License. See LICENSE.TXT for details. 8 // 9 //===----------------------------------------------------------------------===// 10 11 #ifndef liblldb_IRForTarget_h_ 12 #define liblldb_IRForTarget_h_ 13 14 #include "lldb/Core/ConstString.h" 15 #include "lldb/Core/Error.h" 16 #include "lldb/Core/Stream.h" 17 #include "lldb/Core/StreamString.h" 18 #include "lldb/Symbol/TaggedASTType.h" 19 #include "lldb/lldb-public.h" 20 #include "llvm/Pass.h" 21 22 #include <functional> 23 #include <map> 24 25 namespace llvm { 26 class BasicBlock; 27 class CallInst; 28 class Constant; 29 class ConstantInt; 30 class Function; 31 class GlobalValue; 32 class GlobalVariable; 33 class Instruction; 34 class IntegerType; 35 class Module; 36 class StoreInst; 37 class DataLayout; 38 class Type; 39 class Value; 40 } 41 42 namespace lldb_private { 43 class ClangExpressionDeclMap; 44 class IRExecutionUnit; 45 class IRMemoryMap; 46 } 47 48 //---------------------------------------------------------------------- 49 /// @class IRForTarget IRForTarget.h "lldb/Expression/IRForTarget.h" 50 /// @brief Transforms the IR for a function to run in the target 51 /// 52 /// Once an expression has been parsed and converted to IR, it can run 53 /// in two contexts: interpreted by LLDB as a DWARF location expression, 54 /// or compiled by the JIT and inserted into the target process for 55 /// execution. 56 /// 57 /// IRForTarget makes the second possible, by applying a series of 58 /// transformations to the IR which make it relocatable. These 59 /// transformations are discussed in more detail next to their relevant 60 /// functions. 61 //---------------------------------------------------------------------- 62 class IRForTarget : public llvm::ModulePass { 63 public: 64 enum class LookupResult { Success, Fail, Ignore }; 65 66 //------------------------------------------------------------------ 67 /// Constructor 68 /// 69 /// @param[in] decl_map 70 /// The list of externally-referenced variables for the expression, 71 /// for use in looking up globals and allocating the argument 72 /// struct. See the documentation for ClangExpressionDeclMap. 73 /// 74 /// @param[in] resolve_vars 75 /// True if the external variable references (including persistent 76 /// variables) should be resolved. If not, only external functions 77 /// are resolved. 78 /// 79 /// @param[in] execution_policy 80 /// Determines whether an IR interpreter can be used to statically 81 /// evaluate the expression. 82 /// 83 /// @param[in] const_result 84 /// This variable is populated with the statically-computed result 85 /// of the function, if it has no side-effects and the result can 86 /// be computed statically. 87 /// 88 /// @param[in] execution_unit 89 /// The holder for raw data associated with the expression. 90 /// 91 /// @param[in] error_stream 92 /// If non-NULL, a stream on which errors can be printed. 93 /// 94 /// @param[in] func_name 95 /// The name of the function to prepare for execution in the target. 96 //------------------------------------------------------------------ 97 IRForTarget(lldb_private::ClangExpressionDeclMap *decl_map, bool resolve_vars, 98 lldb_private::IRExecutionUnit &execution_unit, 99 lldb_private::Stream &error_stream, 100 const char *func_name = "$__lldb_expr"); 101 102 //------------------------------------------------------------------ 103 /// Destructor 104 //------------------------------------------------------------------ 105 ~IRForTarget() override; 106 107 //------------------------------------------------------------------ 108 /// Run this IR transformer on a single module 109 /// 110 /// Implementation of the llvm::ModulePass::runOnModule() function. 111 /// 112 /// @param[in] llvm_module 113 /// The module to run on. This module is searched for the function 114 /// $__lldb_expr, and that function is passed to the passes one by 115 /// one. 116 /// 117 /// @param[in] interpreter_error 118 /// An error. If the expression fails to be interpreted, this error 119 /// is set to a reason why. 120 /// 121 /// @return 122 /// True on success; false otherwise 123 //------------------------------------------------------------------ 124 bool runOnModule(llvm::Module &llvm_module) override; 125 126 //------------------------------------------------------------------ 127 /// Interface stub 128 /// 129 /// Implementation of the llvm::ModulePass::assignPassManager() 130 /// function. 131 //------------------------------------------------------------------ 132 void assignPassManager(llvm::PMStack &pass_mgr_stack, 133 llvm::PassManagerType pass_mgr_type = 134 llvm::PMT_ModulePassManager) override; 135 136 //------------------------------------------------------------------ 137 /// Returns PMT_ModulePassManager 138 /// 139 /// Implementation of the llvm::ModulePass::getPotentialPassManagerType() 140 /// function. 141 //------------------------------------------------------------------ 142 llvm::PassManagerType getPotentialPassManagerType() const override; 143 144 private: 145 //------------------------------------------------------------------ 146 /// Ensures that the current function's linkage is set to external. 147 /// Otherwise the JIT may not return an address for it. 148 /// 149 /// @param[in] llvm_function 150 /// The function whose linkage is to be fixed. 151 /// 152 /// @return 153 /// True on success; false otherwise. 154 //------------------------------------------------------------------ 155 bool FixFunctionLinkage(llvm::Function &llvm_function); 156 157 //------------------------------------------------------------------ 158 /// A module-level pass to replace all function pointers with their 159 /// integer equivalents. 160 //------------------------------------------------------------------ 161 162 //------------------------------------------------------------------ 163 /// The top-level pass implementation 164 /// 165 /// @param[in] llvm_module 166 /// The module currently being processed. 167 /// 168 /// @param[in] llvm_function 169 /// The function currently being processed. 170 /// 171 /// @return 172 /// True on success; false otherwise. 173 //------------------------------------------------------------------ 174 bool HasSideEffects(llvm::Function &llvm_function); 175 176 //------------------------------------------------------------------ 177 /// A function-level pass to check whether the function has side 178 /// effects. 179 //------------------------------------------------------------------ 180 181 //------------------------------------------------------------------ 182 /// Get the address of a function, and a location to put the complete 183 /// Value of the function if one is available. 184 /// 185 /// @param[in] function 186 /// The function to find the location of. 187 /// 188 /// @param[out] ptr 189 /// The location of the function in the target. 190 /// 191 /// @param[out] name 192 /// The resolved name of the function (matters for intrinsics). 193 /// 194 /// @param[out] value_ptr 195 /// A variable to put the function's completed Value* in, or NULL 196 /// if the Value* shouldn't be stored anywhere. 197 /// 198 /// @return 199 /// The pointer. 200 //------------------------------------------------------------------ 201 LookupResult GetFunctionAddress(llvm::Function *function, uint64_t &ptr, 202 lldb_private::ConstString &name, 203 llvm::Constant **&value_ptr); 204 205 //------------------------------------------------------------------ 206 /// A function-level pass to take the generated global value 207 /// $__lldb_expr_result and make it into a persistent variable. 208 /// Also see ASTResultSynthesizer. 209 //------------------------------------------------------------------ 210 211 //------------------------------------------------------------------ 212 /// Find the NamedDecl corresponding to a Value. This interface is 213 /// exposed for the IR interpreter. 214 /// 215 /// @param[in] module 216 /// The module containing metadata to search 217 /// 218 /// @param[in] global 219 /// The global entity to search for 220 /// 221 /// @return 222 /// The corresponding variable declaration 223 //------------------------------------------------------------------ 224 public: 225 static clang::NamedDecl *DeclForGlobal(const llvm::GlobalValue *global_val, 226 llvm::Module *module); 227 228 private: 229 clang::NamedDecl *DeclForGlobal(llvm::GlobalValue *global); 230 231 //------------------------------------------------------------------ 232 /// Set the constant result variable m_const_result to the provided 233 /// constant, assuming it can be evaluated. The result variable 234 /// will be reset to NULL later if the expression has side effects. 235 /// 236 /// @param[in] initializer 237 /// The constant initializer for the variable. 238 /// 239 /// @param[in] name 240 /// The name of the result variable. 241 /// 242 /// @param[in] type 243 /// The Clang type of the result variable. 244 //------------------------------------------------------------------ 245 void MaybeSetConstantResult(llvm::Constant *initializer, 246 const lldb_private::ConstString &name, 247 lldb_private::TypeFromParser type); 248 249 //------------------------------------------------------------------ 250 /// If the IR represents a cast of a variable, set m_const_result 251 /// to the result of the cast. The result variable will be reset to 252 /// NULL latger if the expression has side effects. 253 /// 254 /// @param[in] type 255 /// The Clang type of the result variable. 256 //------------------------------------------------------------------ 257 void MaybeSetCastResult(lldb_private::TypeFromParser type); 258 259 //------------------------------------------------------------------ 260 /// The top-level pass implementation 261 /// 262 /// @param[in] llvm_function 263 /// The function currently being processed. 264 /// 265 /// @return 266 /// True on success; false otherwise 267 //------------------------------------------------------------------ 268 bool CreateResultVariable(llvm::Function &llvm_function); 269 270 //------------------------------------------------------------------ 271 /// A module-level pass to find Objective-C constant strings and 272 /// transform them to calls to CFStringCreateWithBytes. 273 //------------------------------------------------------------------ 274 275 //------------------------------------------------------------------ 276 /// Rewrite a single Objective-C constant string. 277 /// 278 /// @param[in] NSStr 279 /// The constant NSString to be transformed 280 /// 281 /// @param[in] CStr 282 /// The constant C string inside the NSString. This will be 283 /// passed as the bytes argument to CFStringCreateWithBytes. 284 /// 285 /// @return 286 /// True on success; false otherwise 287 //------------------------------------------------------------------ 288 bool RewriteObjCConstString(llvm::GlobalVariable *NSStr, 289 llvm::GlobalVariable *CStr); 290 291 //------------------------------------------------------------------ 292 /// The top-level pass implementation 293 /// 294 /// @return 295 /// True on success; false otherwise 296 //------------------------------------------------------------------ 297 bool RewriteObjCConstStrings(); 298 299 //------------------------------------------------------------------ 300 /// A basic block-level pass to find all Objective-C method calls and 301 /// rewrite them to use sel_registerName instead of statically allocated 302 /// selectors. The reason is that the selectors are created on the 303 /// assumption that the Objective-C runtime will scan the appropriate 304 /// section and prepare them. This doesn't happen when code is copied 305 /// into the target, though, and there's no easy way to induce the 306 /// runtime to scan them. So instead we get our selectors from 307 /// sel_registerName. 308 //------------------------------------------------------------------ 309 310 //------------------------------------------------------------------ 311 /// Replace a single selector reference 312 /// 313 /// @param[in] selector_load 314 /// The load of the statically-allocated selector. 315 /// 316 /// @return 317 /// True on success; false otherwise 318 //------------------------------------------------------------------ 319 bool RewriteObjCSelector(llvm::Instruction *selector_load); 320 321 //------------------------------------------------------------------ 322 /// The top-level pass implementation 323 /// 324 /// @param[in] basic_block 325 /// The basic block currently being processed. 326 /// 327 /// @return 328 /// True on success; false otherwise 329 //------------------------------------------------------------------ 330 bool RewriteObjCSelectors(llvm::BasicBlock &basic_block); 331 332 //------------------------------------------------------------------ 333 /// A basic block-level pass to find all Objective-C class references that 334 /// use the old-style Objective-C runtime and rewrite them to use 335 /// class_getClass instead of statically allocated class references. 336 //------------------------------------------------------------------ 337 338 //------------------------------------------------------------------ 339 /// Replace a single old-style class reference 340 /// 341 /// @param[in] selector_load 342 /// The load of the statically-allocated selector. 343 /// 344 /// @return 345 /// True on success; false otherwise 346 //------------------------------------------------------------------ 347 bool RewriteObjCClassReference(llvm::Instruction *class_load); 348 349 //------------------------------------------------------------------ 350 /// The top-level pass implementation 351 /// 352 /// @param[in] basic_block 353 /// The basic block currently being processed. 354 /// 355 /// @return 356 /// True on success; false otherwise 357 //------------------------------------------------------------------ 358 bool RewriteObjCClassReferences(llvm::BasicBlock &basic_block); 359 360 //------------------------------------------------------------------ 361 /// A basic block-level pass to find all newly-declared persistent 362 /// variables and register them with the ClangExprDeclMap. This 363 /// allows them to be materialized and dematerialized like normal 364 /// external variables. Before transformation, these persistent 365 /// variables look like normal locals, so they have an allocation. 366 /// This pass excises these allocations and makes references look 367 /// like external references where they will be resolved -- like all 368 /// other external references -- by ResolveExternals(). 369 //------------------------------------------------------------------ 370 371 //------------------------------------------------------------------ 372 /// Handle a single allocation of a persistent variable 373 /// 374 /// @param[in] persistent_alloc 375 /// The allocation of the persistent variable. 376 /// 377 /// @return 378 /// True on success; false otherwise 379 //------------------------------------------------------------------ 380 bool RewritePersistentAlloc(llvm::Instruction *persistent_alloc); 381 382 //------------------------------------------------------------------ 383 /// The top-level pass implementation 384 /// 385 /// @param[in] basic_block 386 /// The basic block currently being processed. 387 //------------------------------------------------------------------ 388 bool RewritePersistentAllocs(llvm::BasicBlock &basic_block); 389 390 //------------------------------------------------------------------ 391 /// A function-level pass to find all external variables and functions 392 /// used in the IR. Each found external variable is added to the 393 /// struct, and each external function is resolved in place, its call 394 /// replaced with a call to a function pointer whose value is the 395 /// address of the function in the target process. 396 //------------------------------------------------------------------ 397 398 //------------------------------------------------------------------ 399 /// Write an initializer to a memory array of assumed sufficient 400 /// size. 401 /// 402 /// @param[in] data 403 /// A pointer to the data to write to. 404 /// 405 /// @param[in] initializer 406 /// The initializer itself. 407 /// 408 /// @return 409 /// True on success; false otherwise 410 //------------------------------------------------------------------ 411 bool MaterializeInitializer(uint8_t *data, llvm::Constant *initializer); 412 413 //------------------------------------------------------------------ 414 /// Move an internal variable into the static allocation section. 415 /// 416 /// @param[in] global_variable 417 /// The variable. 418 /// 419 /// @return 420 /// True on success; false otherwise 421 //------------------------------------------------------------------ 422 bool MaterializeInternalVariable(llvm::GlobalVariable *global_variable); 423 424 //------------------------------------------------------------------ 425 /// Handle a single externally-defined variable 426 /// 427 /// @param[in] value 428 /// The variable. 429 /// 430 /// @return 431 /// True on success; false otherwise 432 //------------------------------------------------------------------ 433 bool MaybeHandleVariable(llvm::Value *value); 434 435 //------------------------------------------------------------------ 436 /// Handle a single externally-defined symbol 437 /// 438 /// @param[in] symbol 439 /// The symbol. 440 /// 441 /// @return 442 /// True on success; false otherwise 443 //------------------------------------------------------------------ 444 bool HandleSymbol(llvm::Value *symbol); 445 446 //------------------------------------------------------------------ 447 /// Handle a single externally-defined Objective-C class 448 /// 449 /// @param[in] classlist_reference 450 /// The reference, usually "01L_OBJC_CLASSLIST_REFERENCES_$_n" 451 /// where n (if present) is an index. 452 /// 453 /// @return 454 /// True on success; false otherwise 455 //------------------------------------------------------------------ 456 bool HandleObjCClass(llvm::Value *classlist_reference); 457 458 //------------------------------------------------------------------ 459 /// Handle all the arguments to a function call 460 /// 461 /// @param[in] C 462 /// The call instruction. 463 /// 464 /// @return 465 /// True on success; false otherwise 466 //------------------------------------------------------------------ 467 bool MaybeHandleCallArguments(llvm::CallInst *call_inst); 468 469 //------------------------------------------------------------------ 470 /// Resolve variable references in calls to external functions 471 /// 472 /// @param[in] basic_block 473 /// The basic block currently being processed. 474 /// 475 /// @return 476 /// True on success; false otherwise 477 //------------------------------------------------------------------ 478 bool ResolveCalls(llvm::BasicBlock &basic_block); 479 480 //------------------------------------------------------------------ 481 /// Remove calls to __cxa_atexit, which should never be generated by 482 /// expressions. 483 /// 484 /// @param[in] call_inst 485 /// The call instruction. 486 /// 487 /// @return 488 /// True if the scan was successful; false if some operation 489 /// failed 490 //------------------------------------------------------------------ 491 bool RemoveCXAAtExit(llvm::BasicBlock &basic_block); 492 493 //------------------------------------------------------------------ 494 /// The top-level pass implementation 495 /// 496 /// @param[in] basic_block 497 /// The function currently being processed. 498 /// 499 /// @return 500 /// True on success; false otherwise 501 //------------------------------------------------------------------ 502 bool ResolveExternals(llvm::Function &llvm_function); 503 504 //------------------------------------------------------------------ 505 /// A basic block-level pass to excise guard variables from the code. 506 /// The result for the function is passed through Clang as a static 507 /// variable. Static variables normally have guard variables to 508 /// ensure that they are only initialized once. 509 //------------------------------------------------------------------ 510 511 //------------------------------------------------------------------ 512 /// Rewrite a load to a guard variable to return constant 0. 513 /// 514 /// @param[in] guard_load 515 /// The load instruction to zero out. 516 //------------------------------------------------------------------ 517 void TurnGuardLoadIntoZero(llvm::Instruction *guard_load); 518 519 //------------------------------------------------------------------ 520 /// The top-level pass implementation 521 /// 522 /// @param[in] basic_block 523 /// The basic block currently being processed. 524 /// 525 /// @return 526 /// True on success; false otherwise 527 //------------------------------------------------------------------ 528 bool RemoveGuards(llvm::BasicBlock &basic_block); 529 530 //------------------------------------------------------------------ 531 /// A function-level pass to make all external variable references 532 /// point at the correct offsets from the void* passed into the 533 /// function. ClangExpressionDeclMap::DoStructLayout() must be called 534 /// beforehand, so that the offsets are valid. 535 //------------------------------------------------------------------ 536 537 //------------------------------------------------------------------ 538 /// The top-level pass implementation 539 /// 540 /// @param[in] llvm_function 541 /// The function currently being processed. 542 /// 543 /// @return 544 /// True on success; false otherwise 545 //------------------------------------------------------------------ 546 bool ReplaceVariables(llvm::Function &llvm_function); 547 548 /// Flags 549 bool m_resolve_vars; ///< True if external variable references and persistent 550 ///variable references should be resolved 551 lldb_private::ConstString 552 m_func_name; ///< The name of the function to translate 553 lldb_private::ConstString 554 m_result_name; ///< The name of the result variable ($0, $1, ...) 555 lldb_private::TypeFromParser 556 m_result_type; ///< The type of the result variable. 557 llvm::Module *m_module; ///< The module being processed, or NULL if that has 558 ///not been determined yet. 559 std::unique_ptr<llvm::DataLayout> m_target_data; ///< The target data for the 560 ///module being processed, or 561 ///NULL if there is no 562 ///module. 563 lldb_private::ClangExpressionDeclMap 564 *m_decl_map; ///< The DeclMap containing the Decls 565 llvm::Constant *m_CFStringCreateWithBytes; ///< The address of the function 566 ///CFStringCreateWithBytes, cast to 567 ///the 568 /// appropriate function pointer type 569 llvm::Constant *m_sel_registerName; ///< The address of the function 570 ///sel_registerName, cast to the 571 ///appropriate 572 /// function pointer type 573 llvm::Constant *m_objc_getClass; ///< The address of the function 574 ///objc_getClass, cast to the 575 ///appropriate 576 /// function pointer type 577 llvm::IntegerType 578 *m_intptr_ty; ///< The type of an integer large enough to hold a pointer. 579 lldb_private::Stream 580 &m_error_stream; ///< The stream on which errors should be printed 581 lldb_private::IRExecutionUnit & 582 m_execution_unit; ///< The execution unit containing the IR being created. 583 584 llvm::StoreInst *m_result_store; ///< If non-NULL, the store instruction that 585 ///writes to the result variable. If 586 /// m_has_side_effects is true, this is NULL. 587 bool m_result_is_pointer; ///< True if the function's result in the AST is a 588 ///pointer (see comments in 589 /// ASTResultSynthesizer::SynthesizeBodyResult) 590 591 llvm::GlobalVariable *m_reloc_placeholder; ///< A placeholder that will be 592 ///replaced by a pointer to the 593 ///final 594 /// location of the static allocation. 595 596 //------------------------------------------------------------------ 597 /// UnfoldConstant operates on a constant [Old] which has just been 598 /// replaced with a value [New]. We assume that new_value has 599 /// been properly placed early in the function, in front of the 600 /// first instruction in the entry basic block 601 /// [FirstEntryInstruction]. 602 /// 603 /// UnfoldConstant reads through the uses of Old and replaces Old 604 /// in those uses with New. Where those uses are constants, the 605 /// function generates new instructions to compute the result of the 606 /// new, non-constant expression and places them before 607 /// FirstEntryInstruction. These instructions replace the constant 608 /// uses, so UnfoldConstant calls itself recursively for those. 609 /// 610 /// @param[in] llvm_function 611 /// The function currently being processed. 612 /// 613 /// @return 614 /// True on success; false otherwise 615 //------------------------------------------------------------------ 616 617 class FunctionValueCache { 618 public: 619 typedef std::function<llvm::Value *(llvm::Function *)> Maker; 620 621 FunctionValueCache(Maker const &maker); 622 ~FunctionValueCache(); 623 llvm::Value *GetValue(llvm::Function *function); 624 625 private: 626 Maker const m_maker; 627 typedef std::map<llvm::Function *, llvm::Value *> FunctionValueMap; 628 FunctionValueMap m_values; 629 }; 630 631 FunctionValueCache m_entry_instruction_finder; 632 633 static bool UnfoldConstant(llvm::Constant *old_constant, 634 llvm::Function *llvm_function, 635 FunctionValueCache &value_maker, 636 FunctionValueCache &entry_instruction_finder, 637 lldb_private::Stream &error_stream); 638 639 //------------------------------------------------------------------ 640 /// Construct a reference to m_reloc_placeholder with a given type 641 /// and offset. This typically happens after inserting data into 642 /// m_data_allocator. 643 /// 644 /// @param[in] type 645 /// The type of the value being loaded. 646 /// 647 /// @param[in] offset 648 /// The offset of the value from the base of m_data_allocator. 649 /// 650 /// @return 651 /// The Constant for the reference, usually a ConstantExpr. 652 //------------------------------------------------------------------ 653 llvm::Constant *BuildRelocation(llvm::Type *type, uint64_t offset); 654 655 //------------------------------------------------------------------ 656 /// Commit the allocation in m_data_allocator and use its final 657 /// location to replace m_reloc_placeholder. 658 /// 659 /// @param[in] module 660 /// The module that m_data_allocator resides in 661 /// 662 /// @return 663 /// True on success; false otherwise 664 //------------------------------------------------------------------ 665 bool CompleteDataAllocation(); 666 }; 667 668 #endif // liblldb_IRForTarget_h_ 669