reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h

  160       auto Sym = findSymbol(SharedFnAST->getName() + "$impl");
  164               mangle(SharedFnAST->getName()), SymAddr)) {
  186             mangle(SharedFnAST->getName()), CCAddr, JITSymbolFlags::Exported))

examples/Kaleidoscope/BuildingAJIT/Chapter5/KaleidoscopeJIT.h

  173       auto Sym = findSymbol(SharedFnAST->getName() + "$impl");
  177               mangle(SharedFnAST->getName()), SymAddr)) {
  199             mangle(SharedFnAST->getName()), CCAddr, JITSymbolFlags::Exported))

examples/SpeculativeJIT/SpeculativeJIT.cpp

  119           auto Work = [SharedMU, &JD]() { SharedMU->doMaterialize(JD); };

include/llvm/ADT/STLExtras.h

 1571 template <class Ptr> auto to_address(const Ptr &P) -> decltype(P.operator->()) {
 1572   return P.operator->();

include/llvm/CodeGen/PBQP/CostAllocator.h

  103     return PoolRef(std::move(P), &P->getValue());

include/llvm/CodeGen/PBQP/Graph.h

  436       assert(getNodeCosts(N1Id).getLength() == Costs->getRows() &&
  437              getNodeCosts(N2Id).getLength() == Costs->getCols() &&

include/llvm/DebugInfo/DWARF/DWARFUnit.h

  396       return DWO->getUnitDIE(ExtractUnitDIEOnly);

include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h

  545               LD.BackingResolver->getResponsibilitySet(NotFoundViaLegacyLookup);
  557           return LD.BackingResolver->lookup(Query, NotFoundViaLegacyLookup);
  715               LD.BackingResolver->getResponsibilitySet(NotFoundViaLegacyLookup);
  726           return LD.BackingResolver->lookup(Q,

include/llvm/ExecutionEngine/Orc/Core.h

  779   SymbolStringPtr intern(StringRef SymName) { return SSP->intern(SymName); }
  967     for (auto &KV : UMI->MU->getSymbols())
  984     for (auto &KV : UMI->MU->getSymbols())

include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h

  229       MemMgr->deregisterEHFrames();

include/llvm/ExecutionEngine/Orc/RemoteObjectLayer.h

  374       return this->jitSymbolToRemote(RI->second->findSymbol(Name));
  384                RI->second->findSymbolInLogicalDylib(Name));

include/llvm/ExecutionEngine/Orc/ThreadSafeModule.h

   42     Lock(std::shared_ptr<State> S) : S(std::move(S)), L(this->S->Mutex) {}
   55     assert(S->Ctx != nullptr &&
   61   LLVMContext *getContext() { return S ? S->Ctx.get() : nullptr; }
   65   const LLVMContext *getContext() const { return S ? S->Ctx.get() : nullptr; }

include/llvm/Support/Automaton.h

  198       M->emplace(std::make_pair(I.FromDfaState, I.Action),
  207       Transcriber->reset();
  226     auto I = M->find({State, A});
  227     if (I == M->end())
  230       Transcriber->transition(I->second.second);
  237     auto I = M->find({State, A});
  238     return I != M->end();
  247     return Transcriber->getPaths();

include/llvm/Support/FileSystem.h

 1311   const directory_entry &operator*() const { return State->CurrentEntry; }
 1312   const directory_entry *operator->() const { return &State->CurrentEntry; }
 1318       return State->CurrentEntry == directory_entry();
 1320       return RHS.State->CurrentEntry == directory_entry();
 1321     return State->CurrentEntry == RHS.State->CurrentEntry;
 1321     return State->CurrentEntry == RHS.State->CurrentEntry;
 1352     State->Stack.push(directory_iterator(path, ec, Follow));
 1353     if (State->Stack.top() == directory_iterator())
 1361     if (State->HasNoPushRequest)
 1362       State->HasNoPushRequest = false;
 1364       file_type type = State->Stack.top()->type();
 1367         ErrorOr<basic_file_status> status = State->Stack.top()->status();
 1373         State->Stack.push(directory_iterator(*State->Stack.top(), ec, Follow));
 1373         State->Stack.push(directory_iterator(*State->Stack.top(), ec, Follow));
 1374         if (State->Stack.top() != end_itr) {
 1375           ++State->Level;
 1378         State->Stack.pop();
 1382     while (!State->Stack.empty()
 1383            && State->Stack.top().increment(ec) == end_itr) {
 1384       State->Stack.pop();
 1385       --State->Level;
 1389     if (State->Stack.empty())
 1395   const directory_entry &operator*() const { return *State->Stack.top(); }
 1396   const directory_entry *operator->() const { return &*State->Stack.top(); }
 1400   int level() const { return State->Level; }
 1403   bool no_push_request() const { return State->HasNoPushRequest; }
 1409     assert(State->Level > 0 && "Cannot pop an iterator with level < 1");
 1416       State->Stack.pop();
 1417       --State->Level;
 1418     } while (!State->Stack.empty()
 1419              && State->Stack.top().increment(ec) == end_itr);
 1422     if (State->Stack.empty())
 1427   void no_push() { State->HasNoPushRequest = true; }

include/llvm/Support/TaskQueue.h

   48       P->set_value(C());
   53       P->set_value();
   88     std::future<ResultTy> F = T.P->get_future();

include/llvm/Support/VirtualFileSystem.h

  165     if (Impl->CurrentEntry.path().empty())
  175     EC = Impl->increment();
  176     if (Impl->CurrentEntry.path().empty())
  181   const directory_entry &operator*() const { return Impl->CurrentEntry; }
  182   const directory_entry *operator->() const { return &Impl->CurrentEntry; }
  186       return Impl->CurrentEntry.path() == RHS.Impl->CurrentEntry.path();
  186       return Impl->CurrentEntry.path() == RHS.Impl->CurrentEntry.path();
  223   const directory_entry &operator*() const { return *State->Stack.top(); }
  224   const directory_entry *operator->() const { return &*State->Stack.top(); }
  235     assert(!State->Stack.empty() &&
  237     return State->Stack.size() - 1;
  240   void no_push() { State->HasNoPushRequest = true; }

include/llvm/Testing/Support/SupportHelpers.h

   44       Info->log(OS);

lib/Bitcode/Writer/BitcodeWriter.cpp

  820   Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_POINTER));
  821   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));
  822   Abbv->Add(BitCodeAbbrevOp(0));  // Addrspace = 0
  827   Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_FUNCTION));
  828   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));  // isvararg
  829   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
  830   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));
  835   Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_STRUCT_ANON));
  836   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));  // ispacked
  837   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
  838   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));
  843   Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_STRUCT_NAME));
  844   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
  845   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
  850   Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_STRUCT_NAMED));
  851   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));  // ispacked
  852   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
  853   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));
  858   Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_ARRAY));
  859   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // size
  860   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));
 1114   Abbv->Add(BitCodeAbbrevOp(bitc::MODULE_CODE_VSTOFFSET));
 1118   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
 1209     Abbv->Add(BitCodeAbbrevOp(bitc::MODULE_CODE_GLOBALVAR));
 1210     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
 1211     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
 1212     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
 1214     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // AddrSpace << 2
 1217     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // Initializer.
 1218     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // Linkage.
 1220       Abbv->Add(BitCodeAbbrevOp(0));
 1223       Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
 1227       Abbv->Add(BitCodeAbbrevOp(0));
 1229       Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
 1247     Abbv->Add(BitCodeAbbrevOp(bitc::MODULE_CODE_SOURCE_FILENAME));
 1248     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 1249     Abbv->Add(AbbrevOpToUse);
 1449   Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_LOCATION));
 1450   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
 1451   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
 1452   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
 1453   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
 1454   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
 1455   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
 1480   Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_GENERIC_DEBUG));
 1481   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
 1482   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
 1483   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
 1484   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
 1485   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 1486   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
 1927   Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_NAME));
 1928   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 1929   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
 1956   Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_STRINGS));
 1957   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of strings
 1958   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // offset to chars
 1959   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
 2055   Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_INDEX_OFFSET));
 2056   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
 2057   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
 2061   Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_INDEX));
 2062   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 2063   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
 2280     Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_AGGREGATE));
 2281     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 2282     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, Log2_32_Ceil(LastVal+1)));
 2287     Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_STRING));
 2288     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 2289     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
 2293     Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_CSTRING));
 2294     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 2295     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
 2299     Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_CSTRING));
 2300     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 2301     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
 3060   Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_FNENTRY));
 3061   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id
 3062   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset
 3253     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));
 3254     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
 3255     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 3256     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
 3264     Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_ENTRY));
 3265     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
 3266     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 3267     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
 3274     Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_ENTRY));
 3275     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
 3276     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 3277     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
 3284     Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_BBENTRY));
 3285     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
 3286     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 3287     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
 3295     Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_SETTYPE));
 3296     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
 3305     Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_INTEGER));
 3306     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
 3314     Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_CE_CAST));
 3315     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4));  // cast opc
 3316     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,       // typeid
 3318     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));    // value id
 3326     Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_NULL));
 3336     Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_LOAD));
 3337     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Ptr
 3338     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,    // dest ty
 3340     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // Align
 3341     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // volatile
 3348     Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_UNOP));
 3349     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LHS
 3350     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc
 3357     Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_UNOP));
 3358     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LHS
 3359     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc
 3360     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); // flags
 3367     Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_BINOP));
 3368     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LHS
 3369     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // RHS
 3370     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc
 3377     Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_BINOP));
 3378     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LHS
 3379     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // RHS
 3380     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc
 3381     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); // flags
 3388     Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_CAST));
 3389     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));    // OpVal
 3390     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,       // dest ty
 3392     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4));  // opc
 3400     Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_RET));
 3407     Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_RET));
 3408     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ValID
 3415     Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_UNREACHABLE));
 3422     Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_GEP));
 3423     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
 3424     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, // dest ty
 3426     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 3427     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
 3445   Abbv->Add(BitCodeAbbrevOp(bitc::MST_CODE_ENTRY));
 3446   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
 3447   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 3448   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
 3453   Abbv->Add(BitCodeAbbrevOp(bitc::MST_CODE_ENTRY));
 3454   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
 3455   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 3456   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
 3461   Abbv->Add(BitCodeAbbrevOp(bitc::MST_CODE_ENTRY));
 3462   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
 3463   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 3464   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
 3469   Abbv->Add(BitCodeAbbrevOp(bitc::MST_CODE_HASH));
 3470   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
 3471   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
 3472   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
 3473   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
 3474   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
 3762   Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE_PROFILE));
 3763   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid
 3764   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // flags
 3765   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // instcount
 3766   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // fflags
 3767   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // numrefs
 3768   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // rorefcnt
 3769   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // worefcnt
 3771   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 3772   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
 3778     Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE_RELBF));
 3780     Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE));
 3781   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid
 3782   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // flags
 3783   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // instcount
 3784   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // fflags
 3785   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // numrefs
 3786   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // rorefcnt
 3787   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // worefcnt
 3789   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 3790   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
 3795   Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE_GLOBALVAR_INIT_REFS));
 3796   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
 3797   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags
 3798   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));  // valueids
 3799   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
 3804   Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE_VTABLE_GLOBALVAR_INIT_REFS));
 3805   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
 3806   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags
 3807   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // numrefs
 3809   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 3810   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
 3815   Abbv->Add(BitCodeAbbrevOp(bitc::FS_ALIAS));
 3816   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid
 3817   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // flags
 3818   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid
 3823   Abbv->Add(BitCodeAbbrevOp(bitc::FS_TYPE_ID_METADATA));
 3824   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // typeid strtab index
 3825   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // typeid length
 3827   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 3828   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
 3911   Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED));
 3912   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid
 3913   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // modid
 3914   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // flags
 3915   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // instcount
 3916   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // fflags
 3917   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // entrycount
 3918   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // numrefs
 3919   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // rorefcnt
 3920   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // worefcnt
 3922   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 3923   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
 3928   Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED_PROFILE));
 3929   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid
 3930   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // modid
 3931   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // flags
 3932   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // instcount
 3933   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // fflags
 3934   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // entrycount
 3935   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // numrefs
 3936   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // rorefcnt
 3937   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // worefcnt
 3939   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 3940   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
 3945   Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED_GLOBALVAR_INIT_REFS));
 3946   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid
 3947   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // modid
 3948   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // flags
 3949   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));    // valueids
 3950   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
 3955   Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED_ALIAS));
 3956   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid
 3957   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // modid
 3958   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // flags
 3959   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid
 4184   Abbv->Add(BitCodeAbbrevOp(bitc::IDENTIFICATION_CODE_STRING));
 4185   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 4186   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
 4193   Abbv->Add(BitCodeAbbrevOp(bitc::IDENTIFICATION_CODE_EPOCH));
 4194   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
 4369   Abbv->Add(BitCodeAbbrevOp(Record));
 4370   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
 4557     Abbv->Add(BitCodeAbbrevOp(bitc::MODULE_CODE_SOURCE_FILENAME));
 4558     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 4559     Abbv->Add(AbbrevOpToUse);

lib/Bitstream/Reader/BitstreamReader.cpp

  390       Abbv->Add(BitCodeAbbrevOp(MaybeOp.get()));
  410         Abbv->Add(BitCodeAbbrevOp(0));
  419       Abbv->Add(BitCodeAbbrevOp(E, Data));
  421       Abbv->Add(BitCodeAbbrevOp(E));
  424   if (Abbv->getNumOperandInfos() == 0)

lib/DebugInfo/CodeView/DebugSubsectionRecord.cpp

   64   uint32_t DataSize = Subsection ? Subsection->calculateSerializedSize()
   76   Header.Kind = uint32_t(Subsection ? Subsection->kind() : Contents.kind());
   79   uint32_t DataSize = Subsection ? Subsection->calculateSerializedSize()
   86     if (auto EC = Subsection->commit(Writer))

lib/DebugInfo/CodeView/StringsAndChecksums.cpp

   38   consumeError(OwnedStrings->initialize(SR.getRecordData()));
   78   consumeError(OwnedChecksums->initialize(FCR.getRecordData()));

lib/DebugInfo/DWARF/DWARFContext.cpp

 1227     DWARFContext *Ctxt = S->Context.get();
 1234     DWARFContext *Ctxt = S->Context.get();
 1266   S->File = std::move(Obj.get());
 1267   S->Context = DWARFContext::create(*S->File.getBinary());
 1267   S->Context = DWARFContext::create(*S->File.getBinary());
 1269   auto *Ctxt = S->Context.get();

lib/DebugInfo/DWARF/DWARFUnit.cpp

  520   DWARFCompileUnit *DWOCU = DWOContext->getDWOCompileUnitForHash(*DWOId);
  525   DWO->setAddrOffsetSection(AddrOffsetSection, AddrOffsetSectionBase);
  527     DWO->setRangesSection(&Context.getDWARFObj().getRnglistsDWOSection(), 0);
  532       DWO->RngListTable = TableOrError.get();
  537     if (DWO->RngListTable)
  538       DWO->RangeSectionBase = DWO->RngListTable->getHeaderSize();
  538       DWO->RangeSectionBase = DWO->RngListTable->getHeaderSize();
  541     DWO->setRangesSection(RangeSection, DWORangesBase ? *DWORangesBase : 0);

lib/ExecutionEngine/MCJIT/MCJIT.cpp

  248   MemMgr->finalizeMemory();
  655   MemMgr->notifyObjectLoaded(this, Obj);
  676   return ClientResolver->findSymbol(Name);

lib/ExecutionEngine/Orc/Core.cpp

  254   assert(!this->Symbols->empty() && "Can not fail to resolve an empty set");
  627       for (auto &KV : QueryInfo->Aliases)
  630           QueryInfo->R.addDependencies(KV.first, PerAliasDepsMap);
  635       auto &ES = QueryInfo->R.getTargetJITDylib().getExecutionSession();
  638         for (auto &KV : QueryInfo->Aliases) {
  644         if (auto Err = QueryInfo->R.notifyResolved(ResolutionMap)) {
  646           QueryInfo->R.failMaterialization();
  649         if (auto Err = QueryInfo->R.notifyEmitted()) {
  651           QueryInfo->R.failMaterialization();
  656         QueryInfo->R.failMaterialization();
  806         for (auto &KV : UMI->MU->getSymbols()) {
  979         Q->notifySymbolMetRequiredState(Name, ResolvedSym);
  980         Q->removeQueryDependence(*this, Name);
  981         if (Q->isComplete())
  999     assert(Q->isComplete() && "Q not completed");
 1000     Q->handleComplete();
 1094               Q->notifySymbolMetRequiredState(
 1096               if (Q->isComplete())
 1098               Q->removeQueryDependence(DependantJD, DependantName);
 1110           Q->notifySymbolMetRequiredState(Name, SymI->second.getSymbol());
 1111           if (Q->isComplete())
 1113           Q->removeQueryDependence(*this, Name);
 1132     assert(Q->isComplete() && "Q is not complete");
 1133     Q->handleComplete();
 1234         Q->detach();
 1249     Q->handleFailed(make_error<FailedToMaterialize>(FailedSymbolsMap));
 1337         UMII->second->MU->doDiscard(*this, UMII->first);
 1472     if (SymI->second.getState() >= Q->getRequiredState()) {
 1473       Q->notifySymbolMetRequiredState(Name, SymI->second.getSymbol());
 1485       auto MU = std::move(UMII->second->MU);
 1506     Q->addQueryDependence(*this, Name);
 1559     Q->handleComplete();
 1595     if (SymI->second.getState() >= Q->getRequiredState()) {
 1596       Q->notifySymbolMetRequiredState(Name, SymI->second.getSymbol());
 1597       if (Q->isComplete())
 1609       auto MU = std::move(UMII->second->MU);
 1631     Q->addQueryDependence(*this, Name);
 1667         OS << I->second->MU.get() << ")\n";
 1679         OS << Q.get() << " (" << Q->getRequiredState() << ") ";
 1694       PendingQueries.rbegin(), PendingQueries.rend(), Q->getRequiredState(),
 1696         return V->getRequiredState() <= S;
 1718     if (PendingQueries.back()->getRequiredState() > RequiredState)
 1771     UMII->second->MU->doDiscard(*this, S);
 1906     RegisterDependencies(Query->QueryRegistrations);
 1909       Query->detach();
 1910       return Query->canStillFail();
 1914       Query->handleFailed(std::move(Err));
 1981       Q->detach();
 1996     QueryComplete = Q->isComplete();
 1999     if (RegisterDependencies && !Q->QueryRegistrations.empty())
 2000       RegisterDependencies(Q->QueryRegistrations);
 2006     Q->handleFailed(std::move(LodgingErr));
 2011     Q->handleComplete();

lib/ExecutionEngine/Orc/LLJIT.cpp

  137           auto Work = [SharedMU, &JD]() { SharedMU->doMaterialize(JD); };

lib/ExecutionEngine/Orc/Legacy.cpp

   45       MR->addDependenciesForAll(Q->QueryRegistrations);

lib/ExecutionEngine/Orc/OrcCBindingsStack.h

  156             Query->notifySymbolMetRequiredState(
  169       if (Query->isComplete())
  170         Query->handleComplete();

lib/ExecutionEngine/Orc/OrcMCJITReplacement.h

   71           ClientMM->allocateCodeSection(Size, Alignment, SectionID,
   80       uint8_t *Addr = ClientMM->allocateDataSection(Size, Alignment, SectionID,
   90       return ClientMM->reserveAllocationSpace(CodeSize, CodeAlign,
   96       return ClientMM->needsToReserveAllocationSpace();
  101       return ClientMM->registerEHFrames(Addr, LoadAddr, Size);
  105       return ClientMM->deregisterEHFrames();
  110       return ClientMM->notifyObjectLoaded(RTDyld, O);
  115       return ClientMM->notifyObjectLoaded(EE, O);
  133         return ClientMM->finalizeMemory(ErrMsg);
  157           if (auto Sym2 = M.ClientResolver->findSymbolInLogicalDylib(*S)) {
  179             Query->notifySymbolMetRequiredState(
  190           if (auto Sym2 = M.ClientResolver->findSymbol(*S)) {
  192               Query->notifySymbolMetRequiredState(
  207       if (NewSymbolsResolved && Query->isComplete())
  208         Query->handleComplete();
  383     if (auto Sym = ClientResolver->findSymbol(Name))
  432       M.MemMgr->notifyObjectLoaded(&M, Obj);

lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp

  102     SharedR->failMaterialization();
  113           InternalSymbols->insert(*SymName);

lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp

 1164       auto NewSymbolsF = NewSymbolsP->get_future();
 1167                         NewSymbolsP->set_value(std::move(Result));
 1211         SharedThis->applyExternalSymbolRelocations(Resolved);
 1212         SharedThis->resolveLocalRelocations();
 1213         SharedThis->registerEHFrames();
 1215         if (SharedThis->MemMgr.finalizeMemory(&ErrMsg))
 1224   for (auto &RelocKV : SharedThis->ExternalSymbolRelocations) {
 1227     assert(!SharedThis->GlobalSymbolTable.count(Name) &&
 1234     SharedThis->Resolver.lookup(Symbols, std::move(PostResolveContinuation));

lib/IR/DiagnosticHandler.cpp

   32       if (!Pattern->isValid(RegexError))
   76           PassRemarksAnalysisOptLoc.Pattern->match(PassName));
   80           PassRemarksMissedOptLoc.Pattern->match(PassName));
   84           PassRemarksPassedOptLoc.Pattern->match(PassName));

lib/ObjectYAML/CodeViewYAMLDebugSections.cpp

  398   Subsection.Subsection->map(IO);
  407     Result->addChecksum(CS.FileName, CS.Kind, CS.ChecksumBytes.Bytes);
  418   Result->setCodeSize(Lines.CodeSize);
  419   Result->setRelocationAddress(Lines.RelocSegment, Lines.RelocOffset);
  420   Result->setFlags(Lines.Flags);
  422     Result->createBlock(LC.FileName);
  423     if (Result->hasColumnInfo()) {
  428         Result->addLineAndColumnInfo(L.Offset,
  435         Result->addLineInfo(L.Offset, LineInfo(L.LineStart, LE, L.IsStatement));
  451     Result->addInlineSite(TypeIndex(Site.Inlinee), Site.FileName,
  457       Result->addExtraFile(EF);
  469     Result->addMapping(M.Local, M.Global);
  483       Result->addImport(M.ModuleName, Id);
  493     Result->addSymbol(
  504     Result->insert(Str);
  524     F.FrameFunc = SC.strings()->insert(YF.FrameFunc);
  525     Result->addFrameData(F);
  536     Result->addRVA(RVA);
  574     Result->Checksums.push_back(*ConvertedCS);
  585   Result->Lines.CodeSize = Lines.header()->CodeSize;
  586   Result->Lines.RelocOffset = Lines.header()->RelocOffset;
  587   Result->Lines.RelocSegment = Lines.header()->RelocSegment;
  588   Result->Lines.Flags = static_cast<LineFlags>(uint16_t(Lines.header()->Flags));
  612     Result->Lines.Blocks.push_back(Block);
  624   Result->InlineeLines.HasExtraFiles = Lines.hasExtraFiles();
  641     Result->InlineeLines.Sites.push_back(Site);
  650   Result->Exports.assign(Exports.begin(), Exports.end());
  666     Result->Imports.push_back(YCMI);
  684     Result->Symbols.push_back(*S);
  702     Result->Strings.push_back(S);
  731     Result->Frames.push_back(YF);
  741     Result->RVAs.push_back(RVA);
  756     CVS = SS.Subsection->toCodeViewSubsection(Allocator, SC);
  936       if (SS.Subsection->Kind != DebugSubsectionKind::StringTable)
  939       auto Result = SS.Subsection->toCodeViewSubsection(Allocator, SC);
  948       if (SS.Subsection->Kind != DebugSubsectionKind::FileChecksums)
  951       auto Result = SS.Subsection->toCodeViewSubsection(Allocator, SC);

lib/ObjectYAML/CodeViewYAMLSymbols.cpp

  568   return Symbol->toCodeViewSymbol(Allocator, Container);
  587   if (auto EC = Impl->fromCodeViewSymbol(Symbol))
  621     Kind = Obj.Symbol->Kind;

lib/ObjectYAML/CodeViewYAMLTypes.cpp

  476     Impl->Record = Record;
  496     Member.Member->writeTo(CRB);
  673   if (auto EC = Impl->fromCodeViewRecord(Type))
  697   return Leaf->toCodeViewRecord(Serializer);
  721     Obj.Leaf->map(IO);
  729     Kind = Obj.Leaf->Kind;
  758     Kind = Obj.Member->Kind;
  802     CVType T = Leaf.Leaf->toCodeViewRecord(TS);

lib/Remarks/BitstreamRemarkSerializer.cpp

   56   Abbrev->Add(BitCodeAbbrevOp(RECORD_META_CONTAINER_INFO));
   57   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Version.
   58   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2));  // Type.
   68   Abbrev->Add(BitCodeAbbrevOp(RECORD_META_REMARK_VERSION));
   69   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Version.
   87   Abbrev->Add(BitCodeAbbrevOp(RECORD_META_STRTAB));
   88   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Raw table.
  111   Abbrev->Add(BitCodeAbbrevOp(RECORD_META_EXTERNAL_FILE));
  112   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Filename.
  133     Abbrev->Add(BitCodeAbbrevOp(RECORD_REMARK_HEADER));
  134     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Type
  135     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // Remark Name
  136     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // Pass name
  137     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // Function name
  147     Abbrev->Add(BitCodeAbbrevOp(RECORD_REMARK_DEBUG_LOC));
  148     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 7));    // File
  149     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Line
  150     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Column
  160     Abbrev->Add(BitCodeAbbrevOp(RECORD_REMARK_HOTNESS));
  161     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Hotness
  172     Abbrev->Add(BitCodeAbbrevOp(RECORD_REMARK_ARG_WITH_DEBUGLOC));
  173     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 7));    // Key
  174     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 7));    // Value
  175     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 7));    // File
  176     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Line
  177     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Column
  188     Abbrev->Add(BitCodeAbbrevOp(RECORD_REMARK_ARG_WITHOUT_DEBUGLOC));
  189     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 7)); // Key
  190     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 7)); // Value

lib/Support/FileCollector.cpp

  202       Collector->addFile(Path);
  210       Collector->addFile(Path);
  220     Collector->addFile(Dir);
  225         Collector->addFile(It->path());
  238       Collector->addFile(Path);
  240         Collector->addFile(Output);

lib/Support/VirtualFileSystem.cpp

 2110     State->Stack.push(I);
 2116   assert(FS && State && !State->Stack.empty() && "incrementing past end");
 2117   assert(!State->Stack.top()->path().empty() && "non-canonical end iterator");
 2120   if (State->HasNoPushRequest)
 2121     State->HasNoPushRequest = false;
 2123     if (State->Stack.top()->type() == sys::fs::file_type::directory_file) {
 2124       vfs::directory_iterator I = FS->dir_begin(State->Stack.top()->path(), EC);
 2126         State->Stack.push(I);
 2132   while (!State->Stack.empty() && State->Stack.top().increment(EC) == End)
 2132   while (!State->Stack.empty() && State->Stack.top().increment(EC) == End)
 2133     State->Stack.pop();
 2135   if (State->Stack.empty())

tools/clang/include/clang/ASTMatchers/Dynamic/VariantValue.h

  178     return Value->getTypedMatcher(TypedMatcherOps<T>()).hasValue();
  190       return Value->isConvertibleTo(Kind, Specificity);
  201     return Value->getTypedMatcher(TypedMatcherOps<T>())

tools/clang/include/clang/Analysis/PathDiagnostic.h

  577       I->flattenLocations();
  677       I->flattenLocations();
  784     Loc = EndPiece->getLocation();
  849       I->flattenLocations();

tools/clang/include/clang/Basic/LangOptions.def

   82 LANGOPT(C99               , 1, 0, "C99")
   83 LANGOPT(C11               , 1, 0, "C11")
   84 LANGOPT(C17               , 1, 0, "C17")
   85 LANGOPT(C2x               , 1, 0, "C2x")
   86 LANGOPT(MSVCCompat        , 1, 0, "Microsoft Visual C++ full compatibility mode")
   87 LANGOPT(MicrosoftExt      , 1, 0, "Microsoft C++ extensions")
   88 LANGOPT(AsmBlocks         , 1, 0, "Microsoft inline asm blocks")
   89 LANGOPT(Borland           , 1, 0, "Borland extensions")
   90 LANGOPT(CPlusPlus         , 1, 0, "C++")
   91 LANGOPT(CPlusPlus11       , 1, 0, "C++11")
   92 LANGOPT(CPlusPlus14       , 1, 0, "C++14")
   93 LANGOPT(CPlusPlus17       , 1, 0, "C++17")
   94 LANGOPT(CPlusPlus2a       , 1, 0, "C++2a")
   95 LANGOPT(ObjC              , 1, 0, "Objective-C")
  102 LANGOPT(AppExt , 1, 0, "Objective-C App Extension")
  103 LANGOPT(Trigraphs         , 1, 0,"trigraphs")
  104 LANGOPT(LineComment       , 1, 0, "'//' comments")
  105 LANGOPT(Bool              , 1, 0, "bool, true, and false keywords")
  106 LANGOPT(Half              , 1, 0, "half keyword")
  107 LANGOPT(WChar             , 1, CPlusPlus, "wchar_t keyword")
  108 LANGOPT(Char8             , 1, 0, "char8_t keyword")
  109 LANGOPT(DeclSpecKeyword   , 1, 0, "__declspec keyword")
  112 LANGOPT(GNUMode           , 1, 1, "GNU extensions")
  113 LANGOPT(GNUKeywords       , 1, 1, "GNU keywords")
  114 VALUE_LANGOPT(GNUCVersion , 32, 0, "GNU C compatibility version")
  116 LANGOPT(Digraphs          , 1, 0, "digraphs")
  118 LANGOPT(CXXOperatorNames  , 1, 0, "C++ operator name keywords")
  119 LANGOPT(AppleKext         , 1, 0, "Apple kext support")
  121 LANGOPT(WritableStrings   , 1, 0, "writable string support")
  122 LANGOPT(ConstStrings      , 1, 0, "const-qualified string support")
  125 LANGOPT(AltiVec           , 1, 0, "AltiVec-style vector initializers")
  126 LANGOPT(ZVector           , 1, 0, "System z vector extensions")
  127 LANGOPT(Exceptions        , 1, 0, "exception handling")
  128 LANGOPT(ObjCExceptions    , 1, 0, "Objective-C exceptions")
  129 LANGOPT(CXXExceptions     , 1, 0, "C++ exceptions")
  130 LANGOPT(DWARFExceptions   , 1, 0, "dwarf exception handling")
  131 LANGOPT(SjLjExceptions    , 1, 0, "setjmp-longjump exception handling")
  132 LANGOPT(SEHExceptions     , 1, 0, "SEH .xdata exception handling")
  133 LANGOPT(WasmExceptions    , 1, 0, "WebAssembly exception handling")
  134 LANGOPT(ExternCNoUnwind   , 1, 0, "Assume extern C functions don't unwind")
  135 LANGOPT(TraditionalCPP    , 1, 0, "traditional CPP emulation")
  136 LANGOPT(RTTI              , 1, 1, "run-time type information")
  137 LANGOPT(RTTIData          , 1, 1, "emit run-time type information data")
  138 LANGOPT(MSBitfields       , 1, 0, "Microsoft-compatible structure layout")
  139 LANGOPT(Freestanding, 1, 0, "freestanding implementation")
  140 LANGOPT(NoBuiltin         , 1, 0, "disable builtin functions")
  141 LANGOPT(NoMathBuiltin     , 1, 0, "disable math builtin functions")
  142 LANGOPT(GNUAsm            , 1, 1, "GNU-style inline assembly")
  143 LANGOPT(Coroutines        , 1, 0, "C++20 coroutines")
  144 LANGOPT(DllExportInlines  , 1, 1, "dllexported classes dllexport inline methods")
  145 LANGOPT(RelaxedTemplateTemplateArgs, 1, 0, "C++17 relaxed matching of template template arguments")
  147 LANGOPT(DoubleSquareBracketAttributes, 1, 0, "'[[]]' attributes extension for all language standard modes")
  150 LANGOPT(POSIXThreads      , 1, 0, "POSIX thread support")
  151 LANGOPT(Blocks            , 1, 0, "blocks extension to C")
  153 LANGOPT(MathErrno         , 1, 1, "errno in math functions")
  155 LANGOPT(Modules           , 1, 0, "modules semantics")
  156 COMPATIBLE_LANGOPT(ModulesTS  , 1, 0, "C++ Modules TS syntax")
  157 COMPATIBLE_LANGOPT(CPlusPlusModules, 1, 0, "C++ modules syntax")
  163 COMPATIBLE_LANGOPT(ModulesDeclUse    , 1, 0, "require declaration of module uses")
  165 COMPATIBLE_LANGOPT(ModulesStrictDeclUse, 1, 0, "requiring declaration of module uses and all headers to be in modules")
  168 COMPATIBLE_LANGOPT(ModulesLocalVisibility, 1, 0, "local submodule visibility")
  169 COMPATIBLE_LANGOPT(Optimize          , 1, 0, "__OPTIMIZE__ predefined macro")
  170 COMPATIBLE_LANGOPT(OptimizeSize      , 1, 0, "__OPTIMIZE_SIZE__ predefined macro")
  171 COMPATIBLE_LANGOPT(Static            , 1, 0, "__STATIC__ predefined macro (as opposed to __DYNAMIC__)")
  172 VALUE_LANGOPT(PackStruct  , 32, 0,
  174 VALUE_LANGOPT(MaxTypeAlign  , 32, 0,
  176 VALUE_LANGOPT(AlignDouble            , 1, 0, "Controls if doubles should be aligned to 8 bytes (x86 only)")
  177 VALUE_LANGOPT(LongDoubleSize        , 32, 0, "width of long double")
  178 LANGOPT(PPCIEEELongDouble            , 1, 0, "use IEEE 754 quadruple-precision for long double")
  179 COMPATIBLE_VALUE_LANGOPT(PICLevel    , 2, 0, "__PIC__ level")
  180 COMPATIBLE_VALUE_LANGOPT(PIE         , 1, 0, "is pie")
  181 LANGOPT(ROPI                         , 1, 0, "Read-only position independence")
  182 LANGOPT(RWPI                         , 1, 0, "Read-write position independence")
  183 COMPATIBLE_LANGOPT(GNUInline         , 1, 0, "GNU inline semantics")
  184 COMPATIBLE_LANGOPT(NoInlineDefine    , 1, 0, "__NO_INLINE__ predefined macro")
  185 COMPATIBLE_LANGOPT(Deprecated        , 1, 0, "__DEPRECATED predefined macro")
  186 COMPATIBLE_LANGOPT(FastMath          , 1, 0, "fast FP math optimizations, and __FAST_MATH__ predefined macro")
  187 COMPATIBLE_LANGOPT(FiniteMathOnly    , 1, 0, "__FINITE_MATH_ONLY__ predefined macro")
  188 COMPATIBLE_LANGOPT(UnsafeFPMath      , 1, 0, "Unsafe Floating Point Math")
  193 LANGOPT(CharIsSigned      , 1, 1, "signed char")
  194 LANGOPT(WCharSize         , 4, 0, "width of wchar_t")
  195 LANGOPT(WCharIsSigned        , 1, 0, "signed or unsigned wchar_t")
  199 LANGOPT(ShortEnums        , 1, 0, "short enum types")
  201 LANGOPT(OpenCL            , 1, 0, "OpenCL")
  202 LANGOPT(OpenCLVersion     , 32, 0, "OpenCL C version")
  203 LANGOPT(OpenCLCPlusPlus   , 1, 0, "C++ for OpenCL")
  204 LANGOPT(OpenCLCPlusPlusVersion     , 32, 0, "C++ for OpenCL version")
  205 LANGOPT(NativeHalfType    , 1, 0, "Native half type support")
  206 LANGOPT(NativeHalfArgsAndReturns, 1, 0, "Native half args and returns")
  207 LANGOPT(HalfArgsAndReturns, 1, 0, "half args and returns")
  208 LANGOPT(CUDA              , 1, 0, "CUDA")
  209 LANGOPT(HIP               , 1, 0, "HIP")
  210 LANGOPT(OpenMP            , 32, 0, "OpenMP support and version of OpenMP (31, 40 or 45)")
  211 LANGOPT(OpenMPSimd        , 1, 0, "Use SIMD only OpenMP support.")
  212 LANGOPT(OpenMPUseTLS      , 1, 0, "Use TLS for threadprivates or runtime calls")
  213 LANGOPT(OpenMPIsDevice    , 1, 0, "Generate code only for OpenMP target device")
  214 LANGOPT(OpenMPCUDAMode    , 1, 0, "Generate code for OpenMP pragmas in SIMT/SPMD mode")
  215 LANGOPT(OpenMPCUDAForceFullRuntime , 1, 0, "Force to use full runtime in all constructs when offloading to CUDA devices")
  216 LANGOPT(OpenMPCUDANumSMs  , 32, 0, "Number of SMs for CUDA devices.")
  217 LANGOPT(OpenMPCUDABlocksPerSM  , 32, 0, "Number of blocks per SM for CUDA devices.")
  218 LANGOPT(OpenMPCUDAReductionBufNum , 32, 1024, "Number of the reduction records in the intermediate reduction buffer used for the teams reductions.")
  219 LANGOPT(OpenMPOptimisticCollapse  , 1, 0, "Use at most 32 bits to represent the collapsed loop nest counter.")
  220 LANGOPT(RenderScript      , 1, 0, "RenderScript")
  222 LANGOPT(CUDAIsDevice      , 1, 0, "compiling for CUDA device")
  223 LANGOPT(CUDAAllowVariadicFunctions, 1, 0, "allowing variadic functions in CUDA device code")
  224 LANGOPT(CUDAHostDeviceConstexpr, 1, 1, "treating unattributed constexpr functions as __host__ __device__")
  225 LANGOPT(CUDADeviceApproxTranscendentals, 1, 0, "using approximate transcendental functions")
  226 LANGOPT(GPURelocatableDeviceCode, 1, 0, "generate relocatable device code")
  227 LANGOPT(GPUAllowDeviceInit, 1, 0, "allowing device side global init functions for HIP")
  229 LANGOPT(SYCLIsDevice      , 1, 0, "Generate code for SYCL device")
  231 LANGOPT(HIPUseNewLaunchAPI, 1, 0, "Use new kernel launching API for HIP")
  233 LANGOPT(SizedDeallocation , 1, 0, "sized deallocation")
  234 LANGOPT(AlignedAllocation , 1, 0, "aligned allocation")
  235 LANGOPT(AlignedAllocationUnavailable, 1, 0, "aligned allocation functions are unavailable")
  236 LANGOPT(NewAlignOverride  , 32, 0, "maximum alignment guaranteed by '::operator new(size_t)'")
  237 LANGOPT(ConceptsTS , 1, 0, "enable C++ Extensions for Concepts")
  244 LANGOPT(NoConstantCFStrings , 1, 0, "no constant CoreFoundation strings")
  246 LANGOPT(GlobalAllocationFunctionVisibilityHidden , 1, 0, "hidden visibility for global operator new and delete declaration")
  253 LANGOPT(SinglePrecisionConstants , 1, 0, "treating double-precision floating point constants as single precision constants")
  254 LANGOPT(FastRelaxedMath , 1, 0, "OpenCL fast relaxed math")
  257 LANGOPT(NoBitFieldTypeAlign , 1, 0, "bit-field type alignment")
  258 LANGOPT(HexagonQdsp6Compat , 1, 0, "hexagon-qdsp6 backward compatibility")
  259 LANGOPT(ObjCAutoRefCount , 1, 0, "Objective-C automated reference counting")
  260 LANGOPT(ObjCWeakRuntime     , 1, 0, "__weak support in the ARC runtime")
  261 LANGOPT(ObjCWeak            , 1, 0, "Objective-C __weak in ARC and MRC files")
  262 LANGOPT(ObjCSubscriptingLegacyRuntime         , 1, 0, "Subscripting support in legacy ObjectiveC runtime")
  263 LANGOPT(CFProtectionBranch , 1, 0, "Control-Flow Branch Protection enabled")
  264 LANGOPT(FakeAddressSpaceMap , 1, 0, "OpenCL fake address space map")
  266 LANGOPT(IncludeDefaultHeader, 1, 0, "Include default header file for OpenCL")
  267 LANGOPT(DeclareOpenCLBuiltins, 1, 0, "Declare OpenCL builtin functions")
  269 LANGOPT(BlocksRuntimeOptional , 1, 0, "optional blocks runtime")
  270 LANGOPT(
  280 LANGOPT(SetVisibilityForExternDecls, 1, 0,
  305 VALUE_LANGOPT(MSCompatibilityVersion, 32, 0, "Microsoft Visual C/C++ Version")
  306 VALUE_LANGOPT(VtorDispMode, 2, 1, "How many vtordisps to insert")
  308 LANGOPT(ApplePragmaPack, 1, 0, "Apple gcc-compatible #pragma pack handling")
  310 LANGOPT(RetainCommentsFromSystemHeaders, 1, 0, "retain documentation comments from system headers in the AST")
  312 LANGOPT(SanitizeAddressFieldPadding, 2, 0, "controls how aggressive is ASan "
  316 LANGOPT(Cmse, 1, 0, "ARM Security extensions support")
  318 LANGOPT(XRayInstrument, 1, 0, "controls whether to do XRay instrumentation")
  319 LANGOPT(XRayAlwaysEmitCustomEvents, 1, 0,
  322 LANGOPT(XRayAlwaysEmitTypedEvents, 1, 0,
  326 LANGOPT(ForceEmitVTables, 1, 0, "whether to emit all vtables")
  335 COMPATIBLE_VALUE_LANGOPT(FunctionAlignment, 5, 0, "Default alignment for functions")
  337 LANGOPT(FixedPoint, 1, 0, "fixed point types")
  338 LANGOPT(PaddingOnUnsignedFixedPoint, 1, 0,
  341 LANGOPT(RegisterStaticDestructors, 1, 1, "Register C++ static destructors")

tools/clang/include/clang/Frontend/CompilerInstance.h

  258     return Invocation->getAnalyzerOpts();
  262     return Invocation->getCodeGenOpts();
  265     return Invocation->getCodeGenOpts();
  269     return Invocation->getDependencyOutputOpts();
  272     return Invocation->getDependencyOutputOpts();
  276     return Invocation->getDiagnosticOpts();
  279     return Invocation->getDiagnosticOpts();
  283     return Invocation->getFileSystemOpts();
  286     return Invocation->getFileSystemOpts();
  290     return Invocation->getFrontendOpts();
  293     return Invocation->getFrontendOpts();
  297     return Invocation->getHeaderSearchOpts();
  300     return Invocation->getHeaderSearchOpts();
  303     return Invocation->getHeaderSearchOptsPtr();
  307     return *Invocation->getLangOpts();
  310     return *Invocation->getLangOpts();
  314     return Invocation->getPreprocessorOpts();
  317     return Invocation->getPreprocessorOpts();
  321     return Invocation->getPreprocessorOutputOpts();
  324     return Invocation->getPreprocessorOutputOpts();
  328     return Invocation->getTargetOpts();
  331     return Invocation->getTargetOpts();
  537     auto *Writer = ThePCHContainerOperations->getWriterOrNull(Format);
  551     auto *Reader = ThePCHContainerOperations->getReaderOrNull(Format);

tools/clang/include/clang/Serialization/ASTWriter.h

  986   SmallVectorImpl<char> &getPCH() const { return Buffer->Data; }
 1001   bool hasEmittedPCH() const { return Buffer->IsComplete; }

tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h

  206       P->addRange(R);

tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConstraintManager.h

   58     return assumeExpr(State, Sym, Assumption ? Exp : Solver->mkNot(Exp));
  126       Solver->reset();
  130       Optional<bool> isSat = Solver->check();
  135       if (!Solver->getInterpretation(Exp, Value))
  141           Ty->isBooleanType() ? Solver->mkBoolean(Value.getBoolValue())
  142                               : Solver->mkBitvector(Value, Value.getBitWidth()),
  145       Solver->addConstraint(NotExp);
  147       Optional<bool> isNotSat = Solver->check();
  266       return Solver->isFPSupported();
  292   LLVM_DUMP_METHOD void dump() const { Solver->dump(); }
  318         Constraint = Solver->mkAnd(Constraint, I++->second);
  321       Solver->addConstraint(Constraint);
  339     Solver->reset();
  342     Optional<bool> res = Solver->check();

tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConv.h

   30       return Solver->getBoolSort();
   33       return Solver->getFloatSort(BitWidth);
   35     return Solver->getBitvectorSort(BitWidth);
   44       return Solver->mkBVNeg(Exp);
   47       return Solver->mkBVNot(Exp);
   50       return Solver->mkNot(Exp);
   63       return Solver->mkFPNeg(Exp);
   84       res = (Op == BO_LAnd) ? Solver->mkAnd(res, ASTs[i])
   85                             : Solver->mkOr(res, ASTs[i]);
   95     assert(*Solver->getSort(LHS) == *Solver->getSort(RHS) &&
   95     assert(*Solver->getSort(LHS) == *Solver->getSort(RHS) &&
  101       return Solver->mkBVMul(LHS, RHS);
  104       return isSigned ? Solver->mkBVSDiv(LHS, RHS) : Solver->mkBVUDiv(LHS, RHS);
  104       return isSigned ? Solver->mkBVSDiv(LHS, RHS) : Solver->mkBVUDiv(LHS, RHS);
  107       return isSigned ? Solver->mkBVSRem(LHS, RHS) : Solver->mkBVURem(LHS, RHS);
  107       return isSigned ? Solver->mkBVSRem(LHS, RHS) : Solver->mkBVURem(LHS, RHS);
  111       return Solver->mkBVAdd(LHS, RHS);
  114       return Solver->mkBVSub(LHS, RHS);
  118       return Solver->mkBVShl(LHS, RHS);
  121       return isSigned ? Solver->mkBVAshr(LHS, RHS) : Solver->mkBVLshr(LHS, RHS);
  121       return isSigned ? Solver->mkBVAshr(LHS, RHS) : Solver->mkBVLshr(LHS, RHS);
  125       return isSigned ? Solver->mkBVSlt(LHS, RHS) : Solver->mkBVUlt(LHS, RHS);
  125       return isSigned ? Solver->mkBVSlt(LHS, RHS) : Solver->mkBVUlt(LHS, RHS);
  128       return isSigned ? Solver->mkBVSgt(LHS, RHS) : Solver->mkBVUgt(LHS, RHS);
  128       return isSigned ? Solver->mkBVSgt(LHS, RHS) : Solver->mkBVUgt(LHS, RHS);
  131       return isSigned ? Solver->mkBVSle(LHS, RHS) : Solver->mkBVUle(LHS, RHS);
  131       return isSigned ? Solver->mkBVSle(LHS, RHS) : Solver->mkBVUle(LHS, RHS);
  134       return isSigned ? Solver->mkBVSge(LHS, RHS) : Solver->mkBVUge(LHS, RHS);
  134       return isSigned ? Solver->mkBVSge(LHS, RHS) : Solver->mkBVUge(LHS, RHS);
  138       return Solver->mkEqual(LHS, RHS);
  146       return Solver->mkBVAnd(LHS, RHS);
  149       return Solver->mkBVXor(LHS, RHS);
  152       return Solver->mkBVOr(LHS, RHS);
  156       return Solver->mkAnd(LHS, RHS);
  159       return Solver->mkOr(LHS, RHS);
  177         return Solver->mkFPIsInfinite(LHS);
  180         return Solver->mkFPIsNaN(LHS);
  183         return Solver->mkFPIsNormal(LHS);
  186         return Solver->mkFPIsZero(LHS);
  205     assert(*Solver->getSort(LHS) == *Solver->getSort(RHS) &&
  205     assert(*Solver->getSort(LHS) == *Solver->getSort(RHS) &&
  211       return Solver->mkFPMul(LHS, RHS);
  214       return Solver->mkFPDiv(LHS, RHS);
  217       return Solver->mkFPRem(LHS, RHS);
  221       return Solver->mkFPAdd(LHS, RHS);
  224       return Solver->mkFPSub(LHS, RHS);
  228       return Solver->mkFPLt(LHS, RHS);
  231       return Solver->mkFPGt(LHS, RHS);
  234       return Solver->mkFPLe(LHS, RHS);
  237       return Solver->mkFPGe(LHS, RHS);
  241       return Solver->mkFPEqual(LHS, RHS);
  273         return Solver->mkIte(
  274             Exp, Solver->mkBitvector(llvm::APSInt("1"), ToBitWidth),
  275             Solver->mkBitvector(llvm::APSInt("0"), ToBitWidth));
  280                    ? Solver->mkBVSignExt(ToBitWidth - FromBitWidth, Exp)
  281                    : Solver->mkBVZeroExt(ToBitWidth - FromBitWidth, Exp);
  284         return Solver->mkBVExtract(ToBitWidth - 1, 0, Exp);
  292         return Solver->mkFPtoFP(Exp, Solver->getFloatSort(ToBitWidth));
  292         return Solver->mkFPtoFP(Exp, Solver->getFloatSort(ToBitWidth));
  298       llvm::SMTSortRef Sort = Solver->getFloatSort(ToBitWidth);
  300                  ? Solver->mkSBVtoFP(Exp, Sort)
  301                  : Solver->mkUBVtoFP(Exp, Sort);
  306                  ? Solver->mkFPtoSBV(Exp, ToBitWidth)
  307                  : Solver->mkFPtoUBV(Exp, ToBitWidth);
  326     return Solver->mkSymbol(Name.str().c_str(), mkSort(Solver, Ty, BitWidth));
  390           Solver->mkBitvector(NewRInt, NewRInt.getBitWidth());
  398           Solver->mkBitvector(NewLInt, NewLInt.getBitWidth());
  481                             Solver->mkFloat(Zero));
  494           Solver->mkBitvector(llvm::APSInt("0"), Ctx.getTypeSize(Ty)),
  511         Solver->mkBitvector(NewFromInt, NewFromInt.getBitWidth());
  526         Solver->mkBitvector(NewToInt, NewToInt.getBitWidth());

tools/clang/include/clang/Tooling/Refactoring/RefactoringActionRulesInternal.h

   78         Option->passToVisitor(Visitor);

tools/clang/include/clang/Tooling/Transformer/Stencil.h

   74     return Impl->eval(Match, Result);
   80     return Impl->toString();

tools/clang/lib/ARCMigrate/ARCMT.cpp

  254       createInvocationForMigration(origCI, PCHContainerOps->getRawReader()));
  525       createInvocationForMigration(OrigCI, PCHContainerOps->getRawReader()));

tools/clang/lib/AST/ASTImporter.cpp

 7830   if (SharedState->getLookupTable()) {
 7832         SharedState->getLookupTable()->lookup(ReDC, Name);
 7854   SharedState->addDeclToLookup(ToD);
 7950     if (auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
 7988         SharedState->removeDeclFromLookup(ToD);
 8006       SharedState->setImportDeclError(Pos->second, ErrOut);
 8017           SharedState->setImportDeclError(Ii->second, ErrOut);
 8042   if (auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {

tools/clang/lib/ASTMatchers/Dynamic/VariantValue.cpp

   73         InnerMatcher.Value->getTypedMatcher(*this);
  239   return Value ? Value->getSingleMatcher() : llvm::Optional<DynTypedMatcher>();
  245   if (Value) return Value->getTypeAsString();

tools/clang/lib/Analysis/CloneDetection.cpp

  157       !IgnoredFilesRegex->isValid())
  164     if (IgnoredFilesRegex->match(Filename))

tools/clang/lib/Analysis/PathDiagnostic.cpp

   84     switch (Piece->getKind()) {
  155     const SourceManager &SMgr = D->path.front()->getLocation().getManager();
 1137     (*I)->dump();

tools/clang/lib/Basic/Targets.cpp

  615   llvm::Triple Triple(Opts->Triple);
  626   if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
  626   if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
  627     Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
  636   if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
  636   if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
  637     Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
  642   if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) {
  642   if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) {
  643     Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath;
  650   if (!Target->initFeatureMap(Features, Diags, Opts->CPU,
  651                               Opts->FeaturesAsWritten))
  655   Opts->Features.clear();
  657     Opts->Features.push_back((F.getValue() ? "+" : "-") + F.getKey().str());
  660   llvm::sort(Opts->Features);
  662   if (!Target->handleTargetFeatures(Opts->Features, Diags))

tools/clang/lib/CodeGen/CodeGenAction.cpp

   63               CodeGenOpts.OptimizationRemarkAnalysisPattern->match(PassName));
   67               CodeGenOpts.OptimizationRemarkMissedPattern->match(PassName));
   71               CodeGenOpts.OptimizationRemarkPattern->match(PassName));
  685         CodeGenOpts.OptimizationRemarkPattern->match(D.getPassName()))
  692         CodeGenOpts.OptimizationRemarkMissedPattern->match(D.getPassName()))
  704          CodeGenOpts.OptimizationRemarkAnalysisPattern->match(D.getPassName())))
  718        CodeGenOpts.OptimizationRemarkAnalysisPattern->match(D.getPassName())))
  731        CodeGenOpts.OptimizationRemarkAnalysisPattern->match(D.getPassName())))

tools/clang/lib/CodeGen/ObjectFilePCHContainerOperations.cpp

  254         Buffer->Signature
  255             ? (uint64_t)Buffer->Signature[1] << 32 | Buffer->Signature[0]
  255             ? (uint64_t)Buffer->Signature[1] << 32 | Buffer->Signature[0]
  270     assert(Buffer->IsComplete && "serialization did not complete");
  271     auto &SerializedAST = Buffer->Data;

tools/clang/lib/CrossTU/CrossTranslationUnit.cpp

  359       ASTFilePath, CI.getPCHContainerOperations()->getRawReader(),

tools/clang/lib/Format/Format.cpp

 1216   auto It = Styles->find(Language);
 1217   if (It == Styles->end())

tools/clang/lib/Frontend/ASTUnit.cpp

  263     PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
  787   AST->HSOpts->ModuleFormat = PCHContainerRdr.getFormat();
  796     AST->PPOpts->addRemappedFile(RemappedFile.first, RemappedFile.second);
 1465   if (Invocation && !Invocation->getFrontendOpts().Inputs.empty()) {
 1466     const FrontendInputFile &Input = Invocation->getFrontendOpts().Inputs[0];
 1501   AST->FileSystemOpts = CI->getFileSystemOpts();
 1535     CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath;
 1554   CI->getPreprocessorOpts().RetainRemappedFileBuffers = true;
 1555   CI->getFrontendOpts().DisableFree = false;
 1556   ProcessWarningOptions(AST->getDiagnostics(), CI->getDiagnosticOpts());
 1668   Invocation->getPreprocessorOpts().RetainRemappedFileBuffers = true;
 1669   Invocation->getFrontendOpts().DisableFree = false;
 1671   ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts());
 1679     ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts());
 1760     CI->getPreprocessorOpts().addRemappedFile(RemappedFile.first,
 1763   PreprocessorOptions &PPOpts = CI->getPreprocessorOpts();
 1770   CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath;
 1772   CI->getFrontendOpts().SkipFunctionBodies =
 1776     CI->getHeaderSearchOpts().ModuleFormat = ModuleFormat.getValue();
 1785   AST->FileSystemOpts = CI->getFileSystemOpts();
 1842   PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
 1846   Invocation->getPreprocessorOpts().clearRemappedFiles();
 1848     Invocation->getPreprocessorOpts().addRemappedFile(RemappedFile.first,
 1862   ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts());
 2154   FrontendOptions &FrontendOpts = CCInvocation->getFrontendOpts();
 2156   PreprocessorOptions &PreprocessorOpts = CCInvocation->getPreprocessorOpts();
 2173   LangOpts = *CCInvocation->getLangOpts();
 2177   CCInvocation->getDiagnosticOpts().IgnoreWarnings = true;
 2603   if (PreprocessingRecord *PPRec = PP->getPreprocessingRecord())

tools/clang/lib/Frontend/ChainedIncludesSource.cpp

  200     assert(Buffer->IsComplete && "serialization did not complete");
  201     auto &serialAST = Buffer->Data;

tools/clang/lib/Frontend/CompilerInstance.cpp

  162     MDC->addFile(Name);
  175     MDC->addFile(PCHInclude);
  193       MDC->addFile(Dir->path());
  214     MDC->addFile(E.VPath, E.RPath);
  389   PP = std::make_shared<Preprocessor>(Invocation->getPreprocessorOptsPtr(),
  395   PP->Initialize(getTarget(), getAuxTarget());
  398     PP->createPreprocessingRecord();
  401   InitializeFileRemapping(PP->getDiagnostics(), PP->getSourceManager(),
  401   InitializeFileRemapping(PP->getDiagnostics(), PP->getSourceManager(),
  402                           PP->getFileManager(), PPOpts);
  411   const llvm::Triple *HeaderSearchTriple = &PP->getTargetInfo().getTriple();
  412   if (PP->getTargetInfo().getTriple().getOS() == llvm::Triple::CUDA &&
  413       PP->getAuxTargetInfo())
  414     HeaderSearchTriple = &PP->getAuxTargetInfo()->getTriple();
  416   ApplyHeaderSearchOptions(PP->getHeaderSearchInfo(), getHeaderSearchOpts(),
  417                            PP->getLangOpts(), *HeaderSearchTriple);
  419   PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP);
  421   if (PP->getLangOpts().Modules && PP->getLangOpts().ImplicitModules)
  421   if (PP->getLangOpts().Modules && PP->getLangOpts().ImplicitModules)
  422     PP->getHeaderSearchInfo().setModuleCachePath(getSpecificModuleCachePath());
  443     collectHeaderMaps(PP->getHeaderSearchInfo(), ModuleDepCollector);
  449     Listener->attachToPreprocessor(*PP);
  533     Listener->attachToASTReader(*Reader);
  924     TO->Triple = llvm::Triple::normalize(getFrontendOpts().AuxTriple);
  925     TO->HostTriple = getTarget().getTriple().str();
 1051   PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
 1055   Invocation->getLangOpts()->resetNonModularOptions();
 1060   HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
 1071   Invocation->getLangOpts()->ModuleName =
 1075   Invocation->getLangOpts()->CurrentModule = ModuleName;
 1090   FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
 1103   Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
 1105          Invocation->getModuleHash() && "Module hash mismatch!");
 1518       Listener->attachToASTReader(*ModuleManager);
 1648     Module = PP->getHeaderSearchInfo().lookupModule(
 1662     Module = PP->getHeaderSearchInfo().lookupModule(ModuleName, true,
 1665         PP->getHeaderSearchInfo().getHeaderSearchOpts();
 1684         PP->getHeaderSearchInfo().getPrebuiltModuleFileName(ModuleName);
 1691       ModuleFileName = PP->getHeaderSearchInfo().getCachedModuleFileName(Module);
 1743         Module = PP->getHeaderSearchInfo().lookupModule(ModuleName, true,
 1797           getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
 1811           getPreprocessorOpts().FailedModules->addFailed(ModuleName);
 1866       if (!Sub && PP->getLangOpts().ImplicitModules && Name == "Private" &&
 1872         auto &II = PP->getIdentifierTable().get(
 1873             PrivateModule, PP->getIdentifierInfo(Module->Name)->getTokenID());
 1876         if (PP->getHeaderSearchInfo().lookupModule(PrivateModule, true,
 2014       InputKind(getLanguageFromOptions(*Invocation->getLangOpts()),

tools/clang/lib/Frontend/CompilerInvocation.cpp

  562   if (!Pattern->isValid(RegexError)) {
 3574   for (StringRef Feature : LangOpts->ModuleFeatures)
 3578   code = hash_combine(code, TargetOpts->Triple, TargetOpts->CPU,
 3578   code = hash_combine(code, TargetOpts->Triple, TargetOpts->CPU,
 3579                       TargetOpts->ABI);
 3580   for (const auto &FeatureAsWritten : TargetOpts->FeaturesAsWritten)
 3637     code = ext->hashExtension(code);
 3648   SanitizerSet SanHash = LangOpts->Sanitize;

tools/clang/lib/Frontend/PrecompiledPreamble.cpp

  245   FrontendOptions &FrontendOpts = PreambleInvocation->getFrontendOpts();
  247       PreambleInvocation->getPreprocessorOpts();
  371   for (auto &Filename : PreambleDepCollector->getDependencies()) {
  429       PreambleInvocation->getPreprocessorOpts();

tools/clang/lib/Frontend/Rewrite/FrontendActions.cpp

  238       OS->write_escaped(MF->ModuleName);

tools/clang/lib/Frontend/SerializedDiagnosticPrinter.cpp

  375   unsigned &entry = State->Files[FileName];
  380   entry = State->Files.size();
  384   State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_FILENAME), Record,
  384   State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_FILENAME), Record,
  392   State->Record.clear();
  393   State->Record.push_back(RECORD_SOURCE_RANGE);
  394   AddCharSourceRangeToRecord(R, State->Record, SM);
  395   State->Stream.EmitRecordWithAbbrev(State->Abbrevs.get(RECORD_SOURCE_RANGE),
  395   State->Stream.EmitRecordWithAbbrev(State->Abbrevs.get(RECORD_SOURCE_RANGE),
  396                                      State->Record);
  402   State->Stream.Emit((unsigned)'D', 8);
  403   State->Stream.Emit((unsigned)'I', 8);
  404   State->Stream.Emit((unsigned)'A', 8);
  405   State->Stream.Emit((unsigned)'G', 8);
  425   State->Stream.EnterBlockInfoBlock();
  428   llvm::BitstreamWriter &Stream = State->Stream;
  429   RecordData &Record = State->Record;
  430   AbbreviationMap &Abbrevs = State->Abbrevs;
  439   Abbrev->Add(BitCodeAbbrevOp(RECORD_VERSION));
  440   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
  457   Abbrev->Add(BitCodeAbbrevOp(RECORD_DIAG));
  458   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));  // Diag level.
  460   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Category.
  461   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped Diag ID.
  462   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // Text size.
  463   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Diagnostc text.
  468   Abbrev->Add(BitCodeAbbrevOp(RECORD_CATEGORY));
  469   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Category ID.
  470   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));  // Text size.
  471   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));      // Category text.
  476   Abbrev->Add(BitCodeAbbrevOp(RECORD_SOURCE_RANGE));
  483   Abbrev->Add(BitCodeAbbrevOp(RECORD_DIAG_FLAG));
  484   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped Diag ID.
  485   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
  486   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Flag name text.
  492   Abbrev->Add(BitCodeAbbrevOp(RECORD_FILENAME));
  493   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped file ID.
  494   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Size.
  495   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // Modification time.
  496   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
  497   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name text.
  503   Abbrev->Add(BitCodeAbbrevOp(RECORD_FIXIT));
  505   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Text size.
  506   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));      // FixIt text.
  514   llvm::BitstreamWriter &Stream = State->Stream;
  515   AbbreviationMap &Abbrevs = State->Abbrevs;
  524   if (!State->Categories.insert(category).second)
  531   State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_CATEGORY), Record,
  531   State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_CATEGORY), Record,
  553   std::pair<unsigned, StringRef> &entry = State->DiagFlags[data];
  555     entry.first = State->DiagFlags.size();
  561     State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_DIAG_FLAG),
  561     State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_DIAG_FLAG),
  574     if (State->EmittedAnyDiagBlocks)
  578     State->EmittedAnyDiagBlocks = true;
  582   State->diagBuf.clear();
  583   Info.FormatDiagnostic(State->diagBuf);
  596                           State->diagBuf, &Info);
  606   SDiagsRenderer Renderer(*this, *LangOpts, &*State->DiagOpts);
  609       State->diagBuf, Info.getRanges(), Info.getFixItHints(), &Info);
  631   llvm::BitstreamWriter &Stream = State->Stream;
  632   RecordData &Record = State->Record;
  633   AbbreviationMap &Abbrevs = State->Abbrevs;
  664   State->Stream.EnterSubblock(BLOCK_DIAG, 4);
  668   State->Stream.ExitBlock();
  688   llvm::BitstreamWriter &Stream = State->Stream;
  689   RecordData &Record = State->Record;
  690   AbbreviationMap &Abbrevs = State->Abbrevs;
  742   if (!State->MetaDiagnostics) {
  745         new TextDiagnosticPrinter(llvm::errs(), State->DiagOpts.get());
  746     State->MetaDiagnostics = std::make_unique<DiagnosticsEngine>(
  747         IDs, State->DiagOpts.get(), Client);
  749   return State->MetaDiagnostics.get();
  753   if (!llvm::sys::fs::remove(State->OutputFile))
  768   if (State->EmittedAnyDiagBlocks)
  772     if (!State->EmittedAnyDiagBlocks)
  777     if (llvm::sys::fs::exists(State->OutputFile))
  778       if (SDiagsMerger(*this).mergeRecordsFromFile(State->OutputFile.c_str()))
  783   auto OS = std::make_unique<llvm::raw_fd_ostream>(State->OutputFile.c_str(),
  787         << State->OutputFile << EC.message();
  792   OS->write((char *)&State->Buffer.front(), State->Buffer.size());
  792   OS->write((char *)&State->Buffer.front(), State->Buffer.size());
  812   Writer.State->Stream.EmitRecordWithAbbrev(
  813       Writer.State->Abbrevs.get(RECORD_SOURCE_RANGE), Record);
  825   Writer.State->Stream.EmitRecordWithBlob(
  826       Writer.State->Abbrevs.get(RECORD_DIAG), Record, Message);
  839   Writer.State->Stream.EmitRecordWithBlob(
  840       Writer.State->Abbrevs.get(RECORD_FIXIT), Record, Text);

tools/clang/lib/Frontend/TestModuleFileExtension.cpp

   27   Abv->Add(BitCodeAbbrevOp(FIRST_EXTENSION_RECORD_ID));
   28   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of characters
   29   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));   // message

tools/clang/lib/Index/IndexingAction.cpp

   35     IndexCtx->handleMacroReference(*MacroNameTok.getIdentifierInfo(),
   41     IndexCtx->handleMacroDefined(*MacroNameTok.getIdentifierInfo(),
   50     IndexCtx->handleMacroUndefined(*MacroNameTok.getIdentifierInfo(),
   77     IndexCtx->setASTContext(Context);
   78     IndexCtx->getDataConsumer().initialize(Context);
   79     IndexCtx->getDataConsumer().setPreprocessor(PP);
   80     PP->addPPCallbacks(std::make_unique<IndexPPCallbacks>(IndexCtx));
   84     return IndexCtx->indexDeclGroupRef(DG);
   92     IndexCtx->indexDeclGroupRef(DG);
   96     DataConsumer->finish();

tools/clang/lib/Lex/HeaderSearch.cpp

  148   auto i (HSOpts->PrebuiltModuleFiles.find(ModuleName));
  149   if (i != HSOpts->PrebuiltModuleFiles.end())
  152   if (FileMapOnly || HSOpts->PrebuiltModulePaths.empty())
  157   for (const std::string &Dir : HSOpts->PrebuiltModulePaths) {
  177   if (HSOpts->DisableModuleHash) {
  210   if (Module || !AllowSearch || !HSOpts->ImplicitModuleMaps)
 1346   if (!HSOpts->ImplicitModuleMaps)
 1554   if (!HSOpts->ImplicitModuleMaps)
 1583     if (HSOpts->ImplicitModuleMaps)
 1632   if (HSOpts->ImplicitModuleMaps) {
 1685   if (!HSOpts->ImplicitModuleMaps)
 1703   assert(HSOpts->ImplicitModuleMaps &&

tools/clang/lib/Lex/PPDirectives.cpp

 1955   if (PPOpts->SingleFileParseMode)
 2902   bool RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks &&
 2906   if (PPOpts->SingleFileParseMode && !MI) {
 2953   bool RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks &&
 2957   if (PPOpts->SingleFileParseMode && DER.IncludedUndefinedIds) {
 3024   bool RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks &&
 3027   if ((PPOpts->SingleFileParseMode && !CI.FoundNonSkip) || RetainExcludedCB) {
 3069   bool RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks &&
 3072   if ((PPOpts->SingleFileParseMode && !CI.FoundNonSkip) || RetainExcludedCB) {

tools/clang/lib/Lex/PPLexerChange.cpp

  510         << PPOpts->PCHThroughHeader << 0;

tools/clang/lib/Lex/Preprocessor.cpp

  155   if (!this->PPOpts->PCHThroughHeader.empty() &&
  156       !this->PPOpts->ImplicitPCHInclude.empty())
  159   if (this->PPOpts->GeneratePreamble)
  163       this->PPOpts->ExcludedConditionalDirectiveSkipMappings;
  567   if (!PPOpts->PCHThroughHeader.empty()) {
  572         SourceLocation(), PPOpts->PCHThroughHeader,
  579           << PPOpts->PCHThroughHeader;
  605   return TUKind == TU_Prefix && !PPOpts->PCHThroughHeader.empty() &&
  610   return TUKind != TU_Prefix && !PPOpts->PCHThroughHeader.empty() &&
  615   return TUKind == TU_Prefix && PPOpts->PCHWithHdrStop;
  619   return TUKind != TU_Prefix && PPOpts->PCHWithHdrStop;
  661           << PPOpts->PCHThroughHeader << 1;
  662     else if (!PPOpts->PCHWithHdrStopCreate)

tools/clang/lib/Sema/CodeCompleteConsumer.cpp

  413     CachedParentName = AllocatorRef->CopyString(OS.str());

tools/clang/lib/Serialization/ASTReader.cpp

 4784       if (auto Reader = Known->second->createExtensionReader(Metadata, *this,
12240     auto BlockName = Ext->getExtensionMetadata().BlockName;

tools/clang/lib/Serialization/ASTWriter.cpp

  886   Abv->Add(BitCodeAbbrevOp(serialization::TYPE_EXT_QUAL));
  887   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // Type
  888   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 3));   // Quals
  893   Abv->Add(BitCodeAbbrevOp(serialization::TYPE_FUNCTION_PROTO));
  895   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // ReturnType
  896   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // NoReturn
  897   Abv->Add(BitCodeAbbrevOp(0));                         // HasRegParm
  898   Abv->Add(BitCodeAbbrevOp(0));                         // RegParm
  899   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // CC
  900   Abv->Add(BitCodeAbbrevOp(0));                         // ProducesResult
  901   Abv->Add(BitCodeAbbrevOp(0));                         // NoCallerSavedRegs
  902   Abv->Add(BitCodeAbbrevOp(0));                         // NoCfCheck
  904   Abv->Add(BitCodeAbbrevOp(0));                         // IsVariadic
  905   Abv->Add(BitCodeAbbrevOp(0));                         // HasTrailingReturn
  906   Abv->Add(BitCodeAbbrevOp(0));                         // TypeQuals
  907   Abv->Add(BitCodeAbbrevOp(0));                         // RefQualifier
  908   Abv->Add(BitCodeAbbrevOp(EST_None));                  // ExceptionSpec
  909   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // NumParams
  910   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
  911   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // Params
 1471   MetadataAbbrev->Add(BitCodeAbbrevOp(METADATA));
 1472   MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Major
 1473   MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Minor
 1474   MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang maj.
 1475   MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang min.
 1476   MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Relocatable
 1477   MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Timestamps
 1478   MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // PCHHasObjectFile
 1479   MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Errors
 1480   MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // SVN branch/tag
 1502     Abbrev->Add(BitCodeAbbrevOp(MODULE_NAME));
 1503     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
 1522       Abbrev->Add(BitCodeAbbrevOp(MODULE_DIRECTORY));
 1523       Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Directory
 1723     FileAbbrev->Add(BitCodeAbbrevOp(ORIGINAL_FILE));
 1724     FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // File ID
 1725     FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
 1741     Abbrev->Add(BitCodeAbbrevOp(ORIGINAL_PCH_DIR));
 1742     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
 1783   IFAbbrev->Add(BitCodeAbbrevOp(INPUT_FILE));
 1784   IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID
 1785   IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 12)); // Size
 1786   IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32)); // Modification time
 1787   IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Overridden
 1788   IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Transient
 1789   IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Module map
 1790   IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
 1795   IFHAbbrev->Add(BitCodeAbbrevOp(INPUT_FILE_HASH));
 1796   IFHAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
 1797   IFHAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
 1892   OffsetsAbbrev->Add(BitCodeAbbrevOp(INPUT_FILE_OFFSETS));
 1893   OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # input files
 1894   OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # non-system
 1896   OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));   // Array
 1915   Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_FILE_ENTRY));
 1916   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset
 1917   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location
 1918   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Characteristic
 1919   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives
 1921   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Input File ID
 1922   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumCreatedFIDs
 1923   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 24)); // FirstDeclIndex
 1924   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumDecls
 1934   Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_ENTRY));
 1935   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset
 1936   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location
 1937   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Characteristic
 1938   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives
 1939   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Buffer name blob
 1950   Abbrev->Add(BitCodeAbbrevOp(Compressed ? SM_SLOC_BUFFER_BLOB_COMPRESSED
 1953     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Uncompressed size
 1954   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Blob
 1964   Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_EXPANSION_ENTRY));
 1965   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset
 1966   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Spelling location
 1967   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Start location
 1968   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // End location
 1969   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Is token range
 1970   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Token length
 2224   Abbrev->Add(BitCodeAbbrevOp(HEADER_SEARCH_TABLE));
 2225   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
 2226   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
 2227   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
 2228   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
 2407   Abbrev->Add(BitCodeAbbrevOp(SOURCE_LOCATION_OFFSETS));
 2408   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // # of slocs
 2409   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // total size
 2410   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // offsets
 2683   Abbrev->Add(BitCodeAbbrevOp(MACRO_OFFSET));
 2684   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of macros
 2685   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID
 2686   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
 2713     Abbrev->Add(BitCodeAbbrevOp(PPD_INCLUSION_DIRECTIVE));
 2714     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // filename length
 2715     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // in quotes
 2716     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // kind
 2717     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // imported module
 2718     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
 2783     Abbrev->Add(BitCodeAbbrevOp(PPD_ENTITIES_OFFSETS));
 2784     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first pp entity
 2785     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
 2805     Abbrev->Add(BitCodeAbbrevOp(PPD_SKIPPED_RANGES));
 2806     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
 2862   Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_DEFINITION));
 2863   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID
 2864   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Parent
 2865   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Kind
 2866   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework
 2867   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExplicit
 2868   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsSystem
 2869   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExternC
 2870   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferSubmodules...
 2871   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExplicit...
 2872   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExportWild...
 2873   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ConfigMacrosExh...
 2874   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ModuleMapIsPriv...
 2875   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
 2879   Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_HEADER));
 2880   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
 2884   Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_HEADER));
 2885   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
 2889   Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_TOPHEADER));
 2890   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
 2894   Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_DIR));
 2895   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
 2899   Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_REQUIRES));
 2900   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // State
 2901   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));     // Feature
 2905   Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_EXCLUDED_HEADER));
 2906   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
 2910   Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_TEXTUAL_HEADER));
 2911   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
 2915   Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_PRIVATE_HEADER));
 2916   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
 2920   Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_PRIVATE_TEXTUAL_HEADER));
 2921   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
 2925   Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_LINK_LIBRARY));
 2926   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework
 2927   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));     // Name
 2931   Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_CONFIG_MACRO));
 2932   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));    // Macro name
 2936   Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_CONFLICT));
 2937   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));  // Other module
 2938   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));    // Message
 2942   Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_EXPORT_AS));
 2943   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));    // Macro name
 3253   Abbrev->Add(BitCodeAbbrevOp(TYPE_OFFSET));
 3254   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of types
 3255   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base type index
 3256   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // types block
 3266   Abbrev->Add(BitCodeAbbrevOp(DECL_OFFSET));
 3267   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of declarations
 3268   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base decl ID
 3269   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // declarations block
 3295   Abbrev->Add(BitCodeAbbrevOp(FILE_SORTED_DECLS));
 3296   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
 3297   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
 3511     Abbrev->Add(BitCodeAbbrevOp(METHOD_POOL));
 3512     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
 3513     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
 3514     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
 3526     Abbrev->Add(BitCodeAbbrevOp(SELECTOR_OFFSETS));
 3527     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size
 3528     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID
 3529     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
 3826     Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_TABLE));
 3827     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
 3828     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
 3838   Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_OFFSET));
 3839   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of identifiers
 3840   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID
 3841   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
 4441   Abbrev->Add(BitCodeAbbrevOp(OBJC_CATEGORIES_MAP));
 4442   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of entries
 4443   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
 4527   Abv->Add(llvm::BitCodeAbbrevOp(EXTENSION_METADATA));
 4528   Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
 4529   Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
 4530   Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
 4531   Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
 4532   Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
 4675     if (auto Writer = Ext->createExtensionWriter(*this))
 4915   Abv->Add(llvm::BitCodeAbbrevOp(TU_UPDATE_LEXICAL));
 4916   Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
 4926   Abv->Add(llvm::BitCodeAbbrevOp(UPDATE_VISIBLE));
 4927   Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
 4928   Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
 5029     Abbrev->Add(BitCodeAbbrevOp(MODULE_OFFSET_MAP));
 5030     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));

tools/clang/lib/Serialization/ASTWriterDecl.cpp

 1851   Abv->Add(BitCodeAbbrevOp(serialization::DECL_FIELD));
 1853   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
 1854   Abv->Add(BitCodeAbbrevOp(0));                       // LexicalDeclContext
 1855   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
 1856   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
 1857   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
 1858   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
 1859   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
 1860   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
 1861   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2));  // AccessSpecifier
 1862   Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
 1863   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
 1865   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
 1866   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
 1867   Abv->Add(BitCodeAbbrevOp(0));                       // AnonDeclNumber
 1869   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
 1871   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
 1872   Abv->Add(BitCodeAbbrevOp(0));                       // hasExtInfo
 1873   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
 1875   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
 1876   Abv->Add(BitCodeAbbrevOp(0));                       // InitStyle
 1878   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 1879   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
 1884   Abv->Add(BitCodeAbbrevOp(serialization::DECL_OBJC_IVAR));
 1886   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
 1887   Abv->Add(BitCodeAbbrevOp(0));                       // LexicalDeclContext
 1888   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
 1889   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
 1890   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
 1891   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
 1892   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
 1893   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
 1894   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2));  // AccessSpecifier
 1895   Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
 1896   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
 1898   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
 1899   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
 1900   Abv->Add(BitCodeAbbrevOp(0));                       // AnonDeclNumber
 1902   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
 1904   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
 1905   Abv->Add(BitCodeAbbrevOp(0));                       // hasExtInfo
 1906   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
 1908   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
 1909   Abv->Add(BitCodeAbbrevOp(0));                       // InitStyle
 1911   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getAccessControl
 1912   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getSynthesize
 1914   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 1915   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
 1920   Abv->Add(BitCodeAbbrevOp(serialization::DECL_ENUM));
 1922   Abv->Add(BitCodeAbbrevOp(0));                       // No redeclaration
 1924   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
 1925   Abv->Add(BitCodeAbbrevOp(0));                       // LexicalDeclContext
 1926   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
 1927   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
 1928   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
 1929   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
 1930   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
 1931   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
 1932   Abv->Add(BitCodeAbbrevOp(AS_none));                 // C++ AccessSpecifier
 1933   Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
 1934   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
 1936   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
 1937   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
 1938   Abv->Add(BitCodeAbbrevOp(0));                       // AnonDeclNumber
 1940   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
 1941   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
 1943   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // IdentifierNamespace
 1944   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // getTagKind
 1945   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition
 1946   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator
 1947   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding
 1948   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsCompleteDefinitionRequired
 1949   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // SourceLocation
 1950   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // SourceLocation
 1951   Abv->Add(BitCodeAbbrevOp(0));                         // ExtInfoKind
 1953   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // AddTypeRef
 1954   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // IntegerType
 1955   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // getPromotionType
 1956   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // getNumPositiveBits
 1957   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // getNumNegativeBits
 1958   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScoped
 1959   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScopedUsingClassTag
 1960   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isFixed
 1961   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));// ODRHash
 1962   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // InstantiatedMembEnum
 1964   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // LexicalOffset
 1965   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // VisibleOffset
 1970   Abv->Add(BitCodeAbbrevOp(serialization::DECL_RECORD));
 1972   Abv->Add(BitCodeAbbrevOp(0));                       // No redeclaration
 1974   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
 1975   Abv->Add(BitCodeAbbrevOp(0));                       // LexicalDeclContext
 1976   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
 1977   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
 1978   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
 1979   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
 1980   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
 1981   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
 1982   Abv->Add(BitCodeAbbrevOp(AS_none));                 // C++ AccessSpecifier
 1983   Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
 1984   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
 1986   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
 1987   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
 1988   Abv->Add(BitCodeAbbrevOp(0));                       // AnonDeclNumber
 1990   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
 1991   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
 1993   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // IdentifierNamespace
 1994   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // getTagKind
 1995   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition
 1996   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator
 1997   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding
 1998   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsCompleteDefinitionRequired
 1999   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // SourceLocation
 2000   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // SourceLocation
 2001   Abv->Add(BitCodeAbbrevOp(0));                         // ExtInfoKind
 2003   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // FlexibleArrayMember
 2004   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // AnonymousStructUnion
 2005   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasObjectMember
 2006   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasVolatileMember
 2009   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
 2011   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
 2013   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
 2015   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
 2017   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
 2019   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
 2021   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
 2023   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2));
 2026   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // LexicalOffset
 2027   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // VisibleOffset
 2032   Abv->Add(BitCodeAbbrevOp(serialization::DECL_PARM_VAR));
 2034   Abv->Add(BitCodeAbbrevOp(0));                       // No redeclaration
 2036   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
 2037   Abv->Add(BitCodeAbbrevOp(0));                       // LexicalDeclContext
 2038   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
 2039   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
 2040   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
 2041   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
 2042   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
 2043   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
 2044   Abv->Add(BitCodeAbbrevOp(AS_none));                 // C++ AccessSpecifier
 2045   Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
 2046   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
 2048   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
 2049   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
 2050   Abv->Add(BitCodeAbbrevOp(0));                       // AnonDeclNumber
 2052   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
 2054   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
 2055   Abv->Add(BitCodeAbbrevOp(0));                       // hasExtInfo
 2056   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
 2058   Abv->Add(BitCodeAbbrevOp(0));                       // SClass
 2059   Abv->Add(BitCodeAbbrevOp(0));                       // TSCSpec
 2060   Abv->Add(BitCodeAbbrevOp(0));                       // InitStyle
 2061   Abv->Add(BitCodeAbbrevOp(0));                       // ARCPseudoStrong
 2062   Abv->Add(BitCodeAbbrevOp(0));                       // Linkage
 2063   Abv->Add(BitCodeAbbrevOp(0));                       // HasInit
 2064   Abv->Add(BitCodeAbbrevOp(0));                   // HasMemberSpecializationInfo
 2066   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsObjCMethodParameter
 2067   Abv->Add(BitCodeAbbrevOp(0));                       // ScopeDepth
 2068   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ScopeIndex
 2069   Abv->Add(BitCodeAbbrevOp(0));                       // ObjCDeclQualifier
 2070   Abv->Add(BitCodeAbbrevOp(0));                       // KNRPromoted
 2071   Abv->Add(BitCodeAbbrevOp(0));                       // HasInheritedDefaultArg
 2072   Abv->Add(BitCodeAbbrevOp(0));                   // HasUninstantiatedDefaultArg
 2074   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 2075   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
 2080   Abv->Add(BitCodeAbbrevOp(serialization::DECL_TYPEDEF));
 2082   Abv->Add(BitCodeAbbrevOp(0));                       // No redeclaration
 2084   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
 2085   Abv->Add(BitCodeAbbrevOp(0));                       // LexicalDeclContext
 2086   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
 2087   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
 2088   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
 2089   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isUsed
 2090   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isReferenced
 2091   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
 2092   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // C++ AccessSpecifier
 2093   Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
 2094   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
 2096   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
 2097   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
 2098   Abv->Add(BitCodeAbbrevOp(0));                       // AnonDeclNumber
 2100   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
 2101   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
 2103   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 2104   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
 2109   Abv->Add(BitCodeAbbrevOp(serialization::DECL_VAR));
 2111   Abv->Add(BitCodeAbbrevOp(0));                       // No redeclaration
 2113   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
 2114   Abv->Add(BitCodeAbbrevOp(0));                       // LexicalDeclContext
 2115   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
 2116   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
 2117   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
 2118   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
 2119   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
 2120   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
 2121   Abv->Add(BitCodeAbbrevOp(AS_none));                 // C++ AccessSpecifier
 2122   Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
 2123   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
 2125   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
 2126   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
 2127   Abv->Add(BitCodeAbbrevOp(0));                       // AnonDeclNumber
 2129   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
 2131   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
 2132   Abv->Add(BitCodeAbbrevOp(0));                       // hasExtInfo
 2133   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
 2135   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // SClass
 2136   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // TSCSpec
 2137   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // InitStyle
 2138   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isARCPseudoStrong
 2139   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsThisDeclarationADemotedDefinition
 2140   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isExceptionVariable
 2141   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isNRVOVariable
 2142   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCXXForRangeDecl
 2143   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isObjCForDecl
 2144   Abv->Add(BitCodeAbbrevOp(0));                         // isInline
 2145   Abv->Add(BitCodeAbbrevOp(0));                         // isInlineSpecified
 2146   Abv->Add(BitCodeAbbrevOp(0));                         // isConstexpr
 2147   Abv->Add(BitCodeAbbrevOp(0));                         // isInitCapture
 2148   Abv->Add(BitCodeAbbrevOp(0));                         // isPrevDeclInSameScope
 2149   Abv->Add(BitCodeAbbrevOp(0));                         // ImplicitParamKind
 2150   Abv->Add(BitCodeAbbrevOp(0));                         // EscapingByref
 2151   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Linkage
 2152   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // IsInitICE (local)
 2153   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // VarKind (local enum)
 2155   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 2156   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
 2161   Abv->Add(BitCodeAbbrevOp(serialization::DECL_CXX_METHOD));
 2163   Abv->Add(BitCodeAbbrevOp(0));                         // CanonicalDecl
 2165   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // DeclContext
 2166   Abv->Add(BitCodeAbbrevOp(0));                         // LexicalDeclContext
 2167   Abv->Add(BitCodeAbbrevOp(0));                         // Invalid
 2168   Abv->Add(BitCodeAbbrevOp(0));                         // HasAttrs
 2169   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Implicit
 2170   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Used
 2171   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Referenced
 2172   Abv->Add(BitCodeAbbrevOp(0));                         // InObjCContainer
 2173   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Access
 2174   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ModulePrivate
 2175   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // SubmoduleID
 2177   Abv->Add(BitCodeAbbrevOp(DeclarationName::Identifier)); // NameKind
 2178   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // Identifier
 2179   Abv->Add(BitCodeAbbrevOp(0));                         // AnonDeclNumber
 2181   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // Type
 2183   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // InnerLocStart
 2184   Abv->Add(BitCodeAbbrevOp(0));                         // HasExtInfo
 2185   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // TSIType
 2187   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 11)); // IDNS
 2188   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // StorageClass
 2189   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Inline
 2190   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InlineSpecified
 2191   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // VirtualAsWritten
 2192   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Pure
 2193   Abv->Add(BitCodeAbbrevOp(0));                         // HasInheritedProto
 2194   Abv->Add(BitCodeAbbrevOp(1));                         // HasWrittenProto
 2195   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Deleted
 2196   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Trivial
 2197   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // TrivialForCall
 2198   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Defaulted
 2199   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ExplicitlyDefaulted
 2200   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ImplicitReturnZero
 2201   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Constexpr
 2202   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // UsesSEHTry
 2203   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // SkippedBody
 2204   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // MultiVersion
 2205   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // LateParsed
 2206   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Linkage
 2207   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // LocEnd
 2208   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // ODRHash
 2209   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // TemplateKind
 2218   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
 2219   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
 2224   Abv->Add(BitCodeAbbrevOp(serialization::EXPR_DECL_REF));
 2226   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsOMPStructuredBlock
 2228   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
 2229   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
 2230   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
 2231   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
 2232   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
 2233   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
 2234   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
 2236   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HasQualifier
 2237   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //GetDeclFound
 2238   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ExplicitTemplateArgs
 2239   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HadMultipleCandidates
 2240   Abv->Add(BitCodeAbbrevOp(0)); // RefersToEnclosingVariableOrCapture
 2241   Abv->Add(BitCodeAbbrevOp(0)); // NonOdrUseReason
 2242   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclRef
 2243   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
 2248   Abv->Add(BitCodeAbbrevOp(serialization::EXPR_INTEGER_LITERAL));
 2250   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsOMPStructuredBlock
 2252   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
 2253   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
 2254   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
 2255   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
 2256   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
 2257   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
 2258   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
 2260   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
 2261   Abv->Add(BitCodeAbbrevOp(32));                      // Bit Width
 2262   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Value
 2267   Abv->Add(BitCodeAbbrevOp(serialization::EXPR_CHARACTER_LITERAL));
 2269   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsOMPStructuredBlock
 2271   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
 2272   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
 2273   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
 2274   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
 2275   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
 2276   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
 2277   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
 2279   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getValue
 2280   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
 2281   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // getKind
 2286   Abv->Add(BitCodeAbbrevOp(serialization::EXPR_IMPLICIT_CAST));
 2288   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsOMPStructuredBlock
 2290   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
 2291   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
 2292   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
 2293   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
 2294   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
 2295   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
 2296   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
 2298   Abv->Add(BitCodeAbbrevOp(0)); // PathSize
 2299   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 6)); // CastKind
 2300   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // PartOfExplicitCast
 2305   Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_LEXICAL));
 2306   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
 2310   Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_VISIBLE));
 2311   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));

tools/clang/lib/Serialization/GeneratePCH.cpp

   30       SemaPtr(nullptr), Buffer(std::move(Buffer)), Stream(this->Buffer->Data),
   31       Writer(Stream, this->Buffer->Data, ModuleCache, Extensions,
   35   this->Buffer->IsComplete = false;
   62   Buffer->Signature =
   69   Buffer->IsComplete = true;

tools/clang/lib/Serialization/GlobalModuleIndex.cpp

  837     Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_INDEX));
  838     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
  839     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));

tools/clang/lib/Serialization/PCHContainerOperations.cpp

   40     if (Buffer->IsComplete) {
   42       *OS << Buffer->Data;
   47     Buffer->Data = std::move(Empty);

tools/clang/lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp

 1029   Piece->addRange(LiteralExpr->getSourceRange());

tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp

  599         P->addRange(Exp->getSourceRange());

tools/clang/lib/StaticAnalyzer/Core/BugReporter.cpp

  380     switch (piece->getKind()) {
  431     switch (piece->getKind()) {
  565     if (!(*I)->getLocation().isValid() ||
  566         !(*I)->getLocation().asLocation().isValid()) {
 1197     assert(!C.isInLocCtxMap(&Call->path) &&
 1200     C.updateLocCtxMap(&Call->path, CE->getCalleeContext());
 1204       addEdgeToPath(C.getActivePath(), PrevLoc, Call->callReturn);
 1256       p->setPrunable(true);
 1258       addEdgeToPath(C.getActivePath(), PrevLoc, p->getLocation());
 1298           PE->setPrunable(true);
 1299           addEdgeToPath(C.getActivePath(), PrevLoc, PE->getLocation());
 1958     FullSourceLoc Loc = P->getLocation().asLocation().getExpansionLoc();
 2030       Note->Profile(ID);
 2035         addEdgeToPath(Construct.getActivePath(), PrevLoc, Note->getLocation());
 2619     const FullSourceLoc Loc = piece->getLocation().asLocation();
 2637       MacroStack.back().first->subPieces.push_back(piece);
 2667           PathDiagnosticLocation::createSingleLocation(piece->getLocation()));
 2670         MacroGroup->subPieces.push_back(NewGroup);
 2681     MacroGroup->subPieces.push_back(piece);
 2725           assert(Piece->getKind() == PathDiagnosticPiece::Kind::Event &&
 3023           ConvertedPiece->addRange(R);
 3034       Pieces.back()->addFixit(I);

tools/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

  319     P->addRange(Range);
 1123       EventPiece->setPrunable(true);
 1591     X->setTag(getTag());
 2144     piece->setTag(getTag());
 2520     event->setPrunable(shouldPrune.getValue());
 2546     event->setPrunable(false);
 2582     event->setPrunable(false);
 2621     event->setPrunable(false);
 2838       Constraints = RefutationSolver->mkOr(
 2844     RefutationSolver->addConstraint(Constraints);
 2848   Optional<bool> isSat = RefutationSolver->check();
 2903     Piece->setPrunable(T->isPrunable());

tools/clang/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp

  183   const SourceManager &SMgr = path.front()->getLocation().getManager();
  191   FileID ReportFile = path.front()->getLocation().asLocation().getExpansionLoc().getFileID();
  204               SMgr.getExpansionLoc(path.back()->getLocation().asLocation()),
  276     FileID FID = I->getLocation().asLocation().getExpansionLoc().getFileID();
  332       path.back()->getLocation().asLocation().getExpansionLoc().getFileID();
  449   int LineNumber = path.back()->getLocation().asLocation().getExpansionLineNumber();
  450   int ColumnNumber = path.back()->getLocation().asLocation().getExpansionColumnNumber();

tools/clang/lib/StaticAnalyzer/Core/PlistDiagnostics.cpp

  530                                return E->getKind() == PathDiagnosticPiece::Note;
  536         return E->getKind() == PathDiagnosticPiece::Note;

tools/clang/lib/StaticAnalyzer/Core/SarifDiagnostics.cpp

  218   const SourceManager &SMgr = Pieces.front()->getLocation().getManager();
  221     const PathDiagnosticLocation &P = Piece->getLocation();
  227                        Piece->getString()),
  243   const SourceManager &SMgr = Path.front()->getLocation().getManager();

tools/clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp

  142                   PD->getShortDescription(), PD->path.back()->getRanges(),
  143                   PD->path.back()->getFixits());
  150         reportPiece(NoteID, Piece->getLocation().asLocation(),
  151                     Piece->getString(), Piece->getRanges(), Piece->getFixits());
  151                     Piece->getString(), Piece->getRanges(), Piece->getFixits());
  151                     Piece->getString(), Piece->getRanges(), Piece->getFixits());
  163         reportPiece(NoteID, Piece->getLocation().asLocation(),
  164                     Piece->getString(), Piece->getRanges(), Piece->getFixits());
  164                     Piece->getString(), Piece->getRanges(), Piece->getFixits());
  164                     Piece->getString(), Piece->getRanges(), Piece->getFixits());

tools/clang/lib/StaticAnalyzer/Frontend/ModelInjector.cpp

   68   FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
   74   Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;

tools/clang/lib/Tooling/Tooling.cpp

  366   if (Invocation->getHeaderSearchOpts().Verbose) {
  582         CompilerInstance::createDiagnostics(&Invocation->getDiagnosticOpts(),

tools/clang/tools/c-index-test/core_main.cpp

  162     SourceManager &SM = PP->getSourceManager();
  253   pchContOps->registerReader(std::make_unique<ObjectFilePCHContainerReader>());
  254   auto pchRdr = pchContOps->getReaderOrNull(format);

tools/clang/tools/driver/cc1_main.cpp

  197   PCHOps->registerWriter(std::make_unique<ObjectFilePCHContainerWriter>());
  198   PCHOps->registerReader(std::make_unique<ObjectFilePCHContainerReader>());

tools/clang/tools/extra/clang-doc/BitcodeWriter.cpp

   36     Abbrev->Add(Op);
  296   Abbrev->Add(llvm::BitCodeAbbrevOp(ID));

tools/clang/tools/extra/clang-include-fixer/IncludeFixer.cpp

   88   assert(Invocation->getFrontendOpts().Inputs.size() == 1);

tools/clang/tools/extra/clang-include-fixer/plugin/IncludeFixerPlugin.cpp

   82     SymbolIndexMgr->addSymbolIndex(std::move(CreateYamlIdx));

tools/clang/tools/extra/clang-tidy/ClangTidy.cpp

   79           << PD->path.back()->getRanges();
   83         Context.diag(CheckName, DiagPiece->getLocation().asLocation(),
   84                      DiagPiece->getString(), DiagnosticIDs::Note)
   85             << DiagPiece->getRanges();
  544       Invocation->getPreprocessorOpts().SetUpStaticAnalyzer = true;

tools/clang/tools/extra/clangd/IncludeFixer.cpp

  154     auto Spelled = Inserter->calculateIncludePath(*ResolvedInserted, File);
  160         Inserter->shouldInsertInclude(*ResolvedDeclaring, *ResolvedInserted));
  175           if (auto Edit = Inserter->insert(ToInclude->first))

tools/clang/tools/extra/clangd/ParsedAST.cpp

  229       Preamble ? &Preamble->Preamble : nullptr;
  320       for (const auto &Inc : Preamble->Includes.MainFileIncludes)
  321         Inserter->addExisting(Inc);
  334   auto Includes = Preamble ? Preamble->Includes : IncludeStructure{};
  347     Macros = Preamble->Macros;
  356     CanonIncludes = Preamble->CanonIncludes;
  397     Diags.insert(Diags.end(), Preamble->Diags.begin(), Preamble->Diags.end());
  397     Diags.insert(Diags.end(), Preamble->Diags.begin(), Preamble->Diags.end());
  513   if (Preamble && Preamble->StatCache)
  514     VFS = Preamble->StatCache->getConsumingFS(std::move(VFS));

tools/clang/tools/extra/clangd/Preamble.cpp

  103       OldPreamble->Preamble.CanReuse(CI, ContentsBuffer.get(), Bounds,

tools/clang/tools/extra/clangd/TUScheduler.cpp

  303       Worker->stop();
  336                     [Worker]() { Worker->run(); });
  355   Inputs->CompileCommand = CDB.getFallbackCommand(FileName);
  393         std::tie(PrevInputs->CompileCommand, PrevInputs->Contents) ==
  393         std::tie(PrevInputs->CompileCommand, PrevInputs->Contents) ==
  396     tooling::CompileCommand OldCommand = PrevInputs->CompileCommand;
  601   return FileInputs->CompileCommand;
  610     Result += Preamble->Preamble.getSize();
  980                Command = Worker->getCurrentCompileCommand(),
  992         Worker->waitForFirstPreamble();
  994       Preamble = Worker->getPossiblyStalePreamble();

tools/clang/tools/extra/clangd/index/FileIndex.cpp

  211     StorageSize += Slab->bytes();
  213     StorageSize += RefSlab->bytes();
  215     StorageSize += RelationSlab->bytes();

tools/clang/tools/extra/clangd/index/Index.cpp

   62   return snapshot()->fuzzyFind(R, CB);
   66   return snapshot()->lookup(R, CB);
   70   return snapshot()->refs(R, CB);
   75   return snapshot()->relations(R, CB);
   79   return snapshot()->estimateMemoryUsage();

tools/clang/tools/extra/clangd/index/IndexAction.cpp

  156           return !Collector->shouldIndexFile(FID);
  175     SymbolsCallback(Collector->takeSymbols());
  177       RefsCallback(Collector->takeRefs());
  179       RelationsCallback(Collector->takeRelations());

tools/clang/tools/extra/clangd/index/SymbolCollector.cpp

  351   const auto &SM = PP->getSourceManager();
  400           getTokenLocation(DefLoc, SM, Opts, PP->getLangOpts(), FileURI))
  454           PP->getSourceManager().getDecomposedExpansionLoc(Loc).first;
  475       if (const auto *MI = PP->getMacroDefinition(II).getMacroInfo())
  476         if (auto ID = getSymbolID(*II, MI, PP->getSourceManager()))
  482       if (const auto *MI = PP->getMacroDefinition(II).getMacroInfo())
  483         if (auto ID = getSymbolID(*II, MI, PP->getSourceManager()))
  683     if (!PP->getHeaderSearchInfo().isFileMultipleIncludeGuarded(FE))

tools/clang/tools/extra/clangd/unittests/SymbolCollectorTests.cpp

  281     Symbols = Factory->Collector->takeSymbols();
  282     Refs = Factory->Collector->takeRefs();
  283     Relations = Factory->Collector->takeRelations();

tools/clang/tools/libclang/CIndex.cpp

 3371       ast_filename, CXXIdx->getPCHContainerOperations()->getRawReader(),
 3536       CXXIdx->getPCHContainerOperations()->getRawReader().getFormat(),

tools/clang/tools/libclang/Indexing.cpp

  354         DataConsumer->importedPCH(*File);
  357     DataConsumer->setASTContext(CI.getASTContext());
  360     DataConsumer->setPreprocessor(CI.getPreprocessorPtr());
  405     if (DataConsumer->shouldIndexImplicitTemplateInsts())
  523   if (CInvok->getFrontendOpts().Inputs.empty())
  536     CInvok->getPreprocessorOpts().addRemappedFile(UF.Filename, MB.get());
  544   CInvok->getLangOpts()->SpellChecking = false;
  547     CInvok->getDiagnosticOpts().IgnoreWarnings = true;
  550   CInvok->getHeaderSearchOpts().ModuleFormat =
  551     CXXIdx->getPCHContainerOperations()->getRawReader().getFormat();
  569       CInvok->getLangOpts()->CPlusPlus;
  571     CInvok->getFrontendOpts().SkipFunctionBodies = true;
  589   PreprocessorOptions &PPOpts = CInvok->getPreprocessorOpts(); 
  606   if (!requestedToGetTU && !CInvok->getLangOpts()->Modules)

tools/clang/unittests/AST/ASTImporterTest.cpp

 3029       SharedStatePtr->getLookupTable()->remove(Method);
 5170       SharedStatePtr->getImportDeclErrorIfAny(ToXDef);
 5177   OptErr = SharedStatePtr->getImportDeclErrorIfAny(ToXFwd);

tools/clang/unittests/AST/ExternalASTSourceTest.cpp

   52   Invocation->getPreprocessorOpts().addRemappedFile(

tools/clang/unittests/Basic/SourceManagerTest.cpp

   38     TargetOpts->Triple = "x86_64-apple-darwin11.1.0";

tools/clang/unittests/CodeGen/IRMatchers.h

  165     bool Result = Next->match(C);
  263         if (!OperandMatchers[N]->match(C)) {
  275           if (MetaMatcher->match(C)) {
  305     bool Res = TyM->match(Ctx);
  344         if (!Operands[I]->match(C)) {
  420     if (M->match(MC))
  442     if (M->match(MC))

tools/clang/unittests/Frontend/ASTUnitTest.cpp

   90       ASTFileName.str(), PCHContainerOps->getRawReader(),

tools/clang/unittests/Frontend/CodeGenActionTest.cpp

   45   Invocation->getPreprocessorOpts().addRemappedFile(
   48   Invocation->getFrontendOpts().Inputs.push_back(
   50   Invocation->getFrontendOpts().ProgramAction = EmitLLVM;
   51   Invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu";

tools/clang/unittests/Frontend/FrontendActionTest.cpp

   84   invocation->getPreprocessorOpts().addRemappedFile(
   87   invocation->getFrontendOpts().Inputs.push_back(
   89   invocation->getFrontendOpts().ProgramAction = frontend::ParseSyntaxOnly;
   90   invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu";
  104   invocation->getPreprocessorOpts().addRemappedFile(
  107   invocation->getFrontendOpts().Inputs.push_back(
  109   invocation->getFrontendOpts().ProgramAction = frontend::ParseSyntaxOnly;
  110   invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu";
  124   invocation->getLangOpts()->CPlusPlus = true;
  125   invocation->getLangOpts()->DelayedTemplateParsing = true;
  126   invocation->getPreprocessorOpts().addRemappedFile(
  134   invocation->getFrontendOpts().Inputs.push_back(
  136   invocation->getFrontendOpts().ProgramAction = frontend::ParseSyntaxOnly;
  137   invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu";
  177   Invocation->getPreprocessorOpts().addRemappedFile(
  180   Invocation->getFrontendOpts().Inputs.push_back(
  182   Invocation->getFrontendOpts().ProgramAction = frontend::ParseSyntaxOnly;
  183   Invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu";
  236   Invocation->getLangOpts()->CPlusPlus = true;
  237   Invocation->getPreprocessorOpts().addRemappedFile(
  241   Invocation->getFrontendOpts().Inputs.push_back(
  243   Invocation->getFrontendOpts().ProgramAction = frontend::ParseSyntaxOnly;
  244   Invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu";
  269     Invocation->getLangOpts()->CacheGeneratedPCH = ShouldCache;
  270     Invocation->getPreprocessorOpts().addRemappedFile(
  273     Invocation->getFrontendOpts().Inputs.push_back(
  275     Invocation->getFrontendOpts().OutputFile = StringRef(PCHFilename);
  276     Invocation->getFrontendOpts().ProgramAction = frontend::GeneratePCH;
  277     Invocation->getTargetOpts().Triple = "x86_64-apple-darwin19.0.0";

tools/clang/unittests/Frontend/OutputStreamTest.cpp

   26   Invocation->getPreprocessorOpts().addRemappedFile(
   28   Invocation->getFrontendOpts().Inputs.push_back(
   30   Invocation->getFrontendOpts().ProgramAction = EmitBC;
   31   Invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu";
   50   Invocation->getPreprocessorOpts().addRemappedFile(
   52   Invocation->getFrontendOpts().Inputs.push_back(
   54   Invocation->getFrontendOpts().ProgramAction = EmitBC;
   55   Invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu";
   79     Invocation->getPreprocessorOpts().addRemappedFile(
   81     Invocation->getFrontendOpts().Inputs.push_back(
   83     Invocation->getFrontendOpts().ProgramAction = EmitBC;
   84     Invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu";

tools/clang/unittests/Frontend/PCHPreambleTest.cpp

   82     CI->getFrontendOpts().Inputs.push_back(
   86     CI->getTargetOpts().Triple = "i386-unknown-linux-gnu";
   88     CI->getPreprocessorOpts().RemappedFileBuffers = GetRemappedFiles();
   90     PreprocessorOptions &PPOpts = CI->getPreprocessorOpts();

tools/clang/unittests/Index/IndexTests.cpp

  160   EXPECT_THAT(Index->Symbols, UnorderedElementsAre(QName("X"), QName("f")));
  169   EXPECT_THAT(Index->Symbols, Contains(QName("INDEX_MAC")));
  172   Index->Symbols.clear();
  174   EXPECT_THAT(Index->Symbols, UnorderedElementsAre());
  184   EXPECT_THAT(Index->Symbols, Contains(QName("bar")));
  187   Index->Symbols.clear();
  189   EXPECT_THAT(Index->Symbols, Not(Contains(QName("bar"))));
  206   EXPECT_THAT(Index->Symbols,
  227   EXPECT_THAT(Index->Symbols,
  243   EXPECT_THAT(Index->Symbols, AllOf(Not(Contains(QName("Foo::T"))),
  249   Index->Symbols.clear();
  251   EXPECT_THAT(Index->Symbols,
  266   EXPECT_THAT(Index->Symbols,
  281       Index->Symbols,

tools/clang/unittests/Lex/HeaderSearchTest.cpp

   35     TargetOpts->Triple = "x86_64-apple-darwin11.1.0";

tools/clang/unittests/Lex/LexerTest.cpp

   44     TargetOpts->Triple = "x86_64-apple-darwin11.1.0";

tools/clang/unittests/Lex/PPCallbacksTest.cpp

  124     TargetOpts->Triple = "x86_64-apple-darwin11.1.0";

tools/clang/unittests/Lex/PPConditionalDirectiveRecordTest.cpp

   38     TargetOpts->Triple = "x86_64-apple-darwin11.1.0";

tools/clang/utils/TableGen/MveEmitter.cpp

  577     OS << "Builder.CreateIntCast(" << V->varname() << ", "
  612         assert(Arg->hasIntegerConstantValue());
  615                                     utostr(Arg->integerConstantValue()));
  617         OS << Sep << Arg->varname();
  660       OS << Sep << Arg->varname();
  707     if (!V->needsVisiting(Pass))
  710     for (Result::Ptr W : V->prerequisites())
  745       if (V->varnameUsed())
  746         V->setVarname("Val" + utostr(varindex++));
  751         assert(!V->varnameUsed());
  753       } else if (V->varnameUsed()) {
  754         std::string Type = V->typeName();
  755         OS << V->typeName();
  758         OS << V->varname() << " = ";
  760       V->genCode(OS, ParamAlloc);
 1002         V->setPredecessor(PrevV);
 1013         if (Arg->hasIntegerConstantValue())
 1015               ST, Arg->integerConstantValue());

tools/dsymutil/dsymutil.cpp

  595         Stream->flush();

tools/lld/COFF/Driver.cpp

  233     auto mbOrErr = future->get();
  308     auto mbOrErr = future->get();

tools/lld/COFF/PDB.cpp

 1094     newInlineeLines->addInlineSite(inlinee, filename, sourceLine);
 1100         newInlineeLines->addExtraFile(filename);

tools/lld/lib/ReaderWriter/FileArchive.cpp

  128     _archive.reset(new Archive(_mb->getMemBufferRef(), Err));

tools/lldb/include/lldb/Core/Debugger.h

  125   File &GetOutputFile() { return m_output_stream_sp->GetFile(); }
  127   File &GetErrorFile() { return m_error_stream_sp->GetFile(); }

tools/lldb/include/lldb/Core/IOHandler.h

  510       sp->SetPopped(false);
  537       sp->SetPopped(true);
  555             m_stack[num_io_handlers - 1]->GetType() == top_type &&
  556             m_stack[num_io_handlers - 2]->GetType() == second_top_type);

tools/lldb/include/lldb/Core/Module.h

  124     module_sp->m_objfile_sp =
  126     module_sp->m_did_load_objfile.store(true, std::memory_order_relaxed);
  131     ArchSpec arch = module_sp->m_objfile_sp->GetArchitecture();
  131     ArchSpec arch = module_sp->m_objfile_sp->GetArchitecture();
  134     module_sp->m_arch = arch;
  137     module_sp->m_file = module_sp->m_objfile_sp->GetFileSpec();
  137     module_sp->m_file = module_sp->m_objfile_sp->GetFileSpec();
  137     module_sp->m_file = module_sp->m_objfile_sp->GetFileSpec();

tools/lldb/include/lldb/Core/StructuredDataImpl.h

   58     m_data_sp->Serialize(s);
   80     return plugin_sp->GetDescription(m_data_sp, stream);
   88     return (m_data_sp ? m_data_sp->GetType() :
   96     if (m_data_sp->GetType() == lldb::eStructuredDataTypeDictionary) {
   97       auto dict = m_data_sp->GetAsDictionary();
   99     } else if (m_data_sp->GetType() == lldb::eStructuredDataTypeArray) {
  100       auto array = m_data_sp->GetAsArray();
  108       auto dict = m_data_sp->GetAsDictionary();
  117       auto array = m_data_sp->GetAsArray();
  125     return (m_data_sp ? m_data_sp->GetIntegerValue(fail_value) : fail_value);
  129     return (m_data_sp ? m_data_sp->GetFloatValue(fail_value) : fail_value);
  133     return (m_data_sp ? m_data_sp->GetBooleanValue(fail_value) : fail_value);
  140     llvm::StringRef result = m_data_sp->GetStringValue();

tools/lldb/include/lldb/DataFormatters/FormatClasses.h

   69     if (formatter_sp->Cascades() == false && DidStripTypedef())
   71     if (formatter_sp->SkipsPointers() && DidStripPointer())
   73     if (formatter_sp->SkipsReferences() && DidStripReference())
  124       m_type.m_type_name = type->GetName().GetStringRef();
  125       m_type.m_compiler_type = type->GetForwardCompilerType();

tools/lldb/include/lldb/DataFormatters/FormatManager.h

   72         category_sp->AddLanguage(lang);

tools/lldb/include/lldb/DataFormatters/FormattersContainer.h

   77       entry->GetRevision() = listener->GetCurrentRevision();
   79       entry->GetRevision() = 0;

tools/lldb/include/lldb/DataFormatters/TypeCategory.h

  221     GetTypeFormatsContainer()->ForEach(foreach.GetFormatExactCallback());
  222     GetRegexTypeFormatsContainer()->ForEach(foreach.GetFormatRegexCallback());
  224     GetTypeSummariesContainer()->ForEach(foreach.GetSummaryExactCallback());
  225     GetRegexTypeSummariesContainer()->ForEach(
  228     GetTypeFiltersContainer()->ForEach(foreach.GetFilterExactCallback());
  229     GetRegexTypeFiltersContainer()->ForEach(foreach.GetFilterRegexCallback());
  231     GetTypeSyntheticsContainer()->ForEach(foreach.GetSynthExactCallback());
  232     GetRegexTypeSyntheticsContainer()->ForEach(foreach.GetSynthRegexCallback());
  234     GetTypeValidatorsContainer()->ForEach(foreach.GetValidatorExactCallback());
  235     GetRegexTypeValidatorsContainer()->ForEach(

tools/lldb/include/lldb/Expression/ExpressionVariable.h

  167       if (var_sp->GetName() == name)
  180       llvm::StringRef var_name_str = var_sp->GetName().GetStringRef();

tools/lldb/include/lldb/Expression/Materializer.h

   54         m_thread_wp = frame_sp->GetThread();
   55         m_stack_id = frame_sp->GetStackID();

tools/lldb/include/lldb/Host/MainLoopBase.h

   58     return ReadHandleUP(new ReadHandle(*this, object_sp->GetWaitableHandle()));

tools/lldb/include/lldb/Host/TaskPool.h

   62   return task_sp->get_future();

tools/lldb/include/lldb/Interpreter/CommandObject.h

   47         descriptions->AppendString(iter->second->GetHelp());

tools/lldb/include/lldb/Interpreter/CommandReturnObject.h

   34       return static_pointer_cast<StreamString>(stream_sp)->GetString();
   41       return static_pointer_cast<StreamString>(stream_sp)->GetString();

tools/lldb/include/lldb/Interpreter/OptionValueArray.h

   74     if (value_sp && (m_type_mask & value_sp->GetTypeAsMask())) {
   84     if (value_sp && (m_type_mask & value_sp->GetTypeAsMask())) {
   97     if (value_sp && (m_type_mask & value_sp->GetTypeAsMask())) {

tools/lldb/include/lldb/Symbol/ClangASTImporter.h

  207     context_md->m_map_completer = &completer;
  374     DelegateMap &delegates = context_md->m_delegates;

tools/lldb/include/lldb/Symbol/Type.h

  354       m_name = m_type_impl_sp->GetName();

tools/lldb/include/lldb/Symbol/UnwindPlan.h

  433     return m_row_list.front()->GetCFAValue().GetRegisterNumber();

tools/lldb/include/lldb/Target/Language.h

  109         if (scavenger && scavenger->Find(exe_scope, key, results, append))

tools/lldb/include/lldb/Target/ProcessStructReader.h

   74     process->ReadMemoryFromInferior(base_addr, buffer_sp->GetBytes(),

tools/lldb/include/lldb/Target/Thread.h

  392     return GetStackFrameList()->GetNumFrames();
  396     return GetStackFrameList()->GetFrameAtIndex(idx);
  403     return GetStackFrameList()->DecrementCurrentInlinedDepth();
  407     return GetStackFrameList()->GetCurrentInlinedDepth();
  423       return GetStackFrameList()->GetFrameWithStackID(stack_id);
  428     return GetStackFrameList()->GetSelectedFrameIndex();
  442     GetStackFrameList()->SetDefaultFileAndLineToSelectedFrame();

tools/lldb/include/lldb/Target/ThreadPlan.h

  376   Target &GetTarget() { return m_thread.GetProcess()->GetTarget(); }
  378   const Target &GetTarget() const { return m_thread.GetProcess()->GetTarget(); }
  406       return m_tracer_sp->TracerExplainsStop();
  487     if (m_tracer_sp && m_tracer_sp->TracingEnabled())
  488       m_tracer_sp->Log();

tools/lldb/include/lldb/Utility/Broadcaster.h

  277     m_broadcaster_sp->BroadcastEvent(event_sp);
  281     m_broadcaster_sp->BroadcastEventIfUnique(event_sp);
  286     m_broadcaster_sp->BroadcastEvent(event_type, event_data_sp);
  290     m_broadcaster_sp->BroadcastEvent(event_type, event_data);
  295     m_broadcaster_sp->BroadcastEventIfUnique(event_type, event_data);
  298   void Clear() { m_broadcaster_sp->Clear(); }
  324     return m_broadcaster_sp->AddListener(listener_sp, event_mask);
  342     return m_broadcaster_sp->GetEventNames(s, event_mask,
  355     m_broadcaster_sp->SetEventName(event_mask, name);
  359     return m_broadcaster_sp->GetEventName(event_mask);
  363     return m_broadcaster_sp->EventTypeHasListeners(event_type);
  384     return m_broadcaster_sp->RemoveListener(listener_sp, event_mask);
  407     return m_broadcaster_sp->HijackBroadcaster(listener_sp, event_mask);
  411     return m_broadcaster_sp->IsHijackedForEvent(event_mask);
  415   void RestoreBroadcaster() { m_broadcaster_sp->RestoreBroadcaster(); }
  543     return m_broadcaster_sp->GetHijackingListenerName();

tools/lldb/include/lldb/Utility/Event.h

  210       return broadcaster_impl_sp->GetBroadcaster();
  219       return broadcaster_impl_sp->GetBroadcaster() == broadcaster;

tools/lldb/include/lldb/Utility/Reproducer.h

  104     if (auto ec = m_collector->copyFiles(/*stop_on_error=*/false))
  106     m_collector->writeMapping(mapping.GetPath());

tools/lldb/include/lldb/Utility/StructuredData.h

  199         if (auto int_value = value_sp->GetAsInteger()) {
  219         if (auto string_value = value_sp->GetAsString()) {
  238         if (auto string_value = value_sp->GetAsString()) {
  258         result = value_sp->GetAsDictionary();
  268         result = value_sp->GetAsArray();
  373         key_object_sp->SetValue(iter->first.AsCString());
  374         object_sp->Push(key_object_sp);
  394         Boolean *result_ptr = value_sp->GetAsBoolean();
  406         if (auto int_value = value_sp->GetAsInteger()) {
  427         if (auto string_value = value_sp->GetAsString()) {
  451         if (auto string_value = value_sp->GetAsString()) {
  472         result = value_sp->GetAsDictionary();
  482         result = value_sp->GetAsArray();

tools/lldb/source/API/SBAddress.cpp

  128       std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());

tools/lldb/source/API/SBAttachInfo.cpp

   27   m_opaque_sp->SetProcessID(pid);
   35     m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
   36   m_opaque_sp->SetWaitForLaunch(wait_for);
   45     m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
   46   m_opaque_sp->SetWaitForLaunch(wait_for);
   47   m_opaque_sp->SetAsync(async);
   73   return m_opaque_sp->GetProcessID();
   79   m_opaque_sp->SetProcessID(pid);
   85   return m_opaque_sp->GetResumeCount();
   91   m_opaque_sp->SetResumeCount(c);
   97   return m_opaque_sp->GetProcessPluginName();
  104   return m_opaque_sp->SetProcessPluginName(plugin_name);
  111     m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
  113     m_opaque_sp->GetExecutableFile().Clear();
  121     m_opaque_sp->GetExecutableFile() = exe_file.ref();
  123     m_opaque_sp->GetExecutableFile().Clear();
  129   return m_opaque_sp->GetWaitForLaunch();
  135   m_opaque_sp->SetWaitForLaunch(b);
  142   m_opaque_sp->SetWaitForLaunch(b);
  143   m_opaque_sp->SetAsync(async);
  149   return m_opaque_sp->GetIgnoreExisting();
  155   m_opaque_sp->SetIgnoreExisting(b);
  161   return m_opaque_sp->GetUserID();
  167   return m_opaque_sp->GetGroupID();
  173   return m_opaque_sp->UserIDIsValid();
  179   return m_opaque_sp->GroupIDIsValid();
  185   m_opaque_sp->SetUserID(uid);
  191   m_opaque_sp->SetGroupID(gid);
  197   return m_opaque_sp->GetEffectiveUserID();
  203   return m_opaque_sp->GetEffectiveGroupID();
  209   return m_opaque_sp->EffectiveUserIDIsValid();
  215   return m_opaque_sp->EffectiveGroupIDIsValid();
  221   m_opaque_sp->SetEffectiveUserID(uid);
  227   m_opaque_sp->SetEffectiveGroupID(gid);
  233   return m_opaque_sp->GetParentProcessID();
  240   m_opaque_sp->SetParentProcessID(pid);
  246   return m_opaque_sp->ParentProcessIDIsValid();
  252   return LLDB_RECORD_RESULT(SBListener(m_opaque_sp->GetListener()));
  259   m_opaque_sp->SetListener(listener.GetSP());

tools/lldb/source/API/SBBlock.cpp

  261       const size_t num_variables = variable_list_sp->GetSize();
  264           VariableSP variable_sp(variable_list_sp->GetVariableAtIndex(i));
  267             switch (variable_sp->GetScope()) {
  288                     frame_sp->GetValueObjectForFrameVariable(variable_sp,
  318       const size_t num_variables = variable_list_sp->GetSize();
  321           VariableSP variable_sp(variable_list_sp->GetVariableAtIndex(i));
  324             switch (variable_sp->GetScope()) {

tools/lldb/source/API/SBBreakpoint.cpp

   90     break_id = bkpt_sp->GetID();
  105   else if (bkpt_sp->GetTarget().GetBreakpointByID(bkpt_sp->GetID()))
  105   else if (bkpt_sp->GetTarget().GetBreakpointByID(bkpt_sp->GetID()))
  117         bkpt_sp->GetTarget().GetAPIMutex());
  118     bkpt_sp->ClearAllBreakpointSites();
  132           bkpt_sp->GetTarget().GetAPIMutex());
  134       Target &target = bkpt_sp->GetTarget();
  138       sb_bp_location.SetLocation(bkpt_sp->FindLocationByAddress(address));
  153         bkpt_sp->GetTarget().GetAPIMutex());
  155     Target &target = bkpt_sp->GetTarget();
  159     break_id = bkpt_sp->FindLocationIDByAddress(address);
  174         bkpt_sp->GetTarget().GetAPIMutex());
  175     sb_bp_location.SetLocation(bkpt_sp->FindLocationByID(bp_loc_id));
  190         bkpt_sp->GetTarget().GetAPIMutex());
  191     sb_bp_location.SetLocation(bkpt_sp->GetLocationAtIndex(index));
  204         bkpt_sp->GetTarget().GetAPIMutex());
  205     bkpt_sp->SetEnabled(enable);
  215         bkpt_sp->GetTarget().GetAPIMutex());
  216     return bkpt_sp->IsEnabled();
  228         bkpt_sp->GetTarget().GetAPIMutex());
  229     bkpt_sp->SetOneShot(one_shot);
  239         bkpt_sp->GetTarget().GetAPIMutex());
  240     return bkpt_sp->IsOneShot();
  251         bkpt_sp->GetTarget().GetAPIMutex());
  252     return bkpt_sp->IsInternal();
  264         bkpt_sp->GetTarget().GetAPIMutex());
  265     bkpt_sp->SetIgnoreCount(count);
  276         bkpt_sp->GetTarget().GetAPIMutex());
  277     bkpt_sp->SetCondition(condition);
  287         bkpt_sp->GetTarget().GetAPIMutex());
  288     return bkpt_sp->GetConditionText();
  300         bkpt_sp->GetTarget().GetAPIMutex());
  301     bkpt_sp->SetAutoContinue(auto_continue);
  311         bkpt_sp->GetTarget().GetAPIMutex());
  312     return bkpt_sp->IsAutoContinue();
  324         bkpt_sp->GetTarget().GetAPIMutex());
  325     count = bkpt_sp->GetHitCount();
  338         bkpt_sp->GetTarget().GetAPIMutex());
  339     count = bkpt_sp->GetIgnoreCount();
  351         bkpt_sp->GetTarget().GetAPIMutex());
  352     bkpt_sp->SetThreadID(tid);
  363         bkpt_sp->GetTarget().GetAPIMutex());
  364     tid = bkpt_sp->GetThreadID();
  376         bkpt_sp->GetTarget().GetAPIMutex());
  377     bkpt_sp->GetOptions()->GetThreadSpec()->SetIndex(index);
  388         bkpt_sp->GetTarget().GetAPIMutex());
  390         bkpt_sp->GetOptions()->GetThreadSpecNoCreate();
  406         bkpt_sp->GetTarget().GetAPIMutex());
  407     bkpt_sp->GetOptions()->GetThreadSpec()->SetName(thread_name);
  418         bkpt_sp->GetTarget().GetAPIMutex());
  420         bkpt_sp->GetOptions()->GetThreadSpecNoCreate();
  435         bkpt_sp->GetTarget().GetAPIMutex());
  436     bkpt_sp->GetOptions()->GetThreadSpec()->SetQueueName(queue_name);
  447         bkpt_sp->GetTarget().GetAPIMutex());
  449         bkpt_sp->GetOptions()->GetThreadSpecNoCreate();
  465         bkpt_sp->GetTarget().GetAPIMutex());
  466     num_resolved = bkpt_sp->GetNumResolvedLocations();
  478         bkpt_sp->GetTarget().GetAPIMutex());
  479     num_locs = bkpt_sp->GetNumLocations();
  495       bkpt_sp->GetTarget().GetAPIMutex());
  499   bkpt_sp->GetOptions()->SetCommandDataCallback(cmd_data_up);
  511       bkpt_sp->GetOptions()->GetCommandLineCallbacks(command_list);
  530         bkpt_sp->GetTarget().GetAPIMutex());
  531     s.Printf("SBBreakpoint: id = %i, ", bkpt_sp->GetID());
  532     bkpt_sp->GetResolverDescription(s.get());
  533     bkpt_sp->GetFilterDescription(s.get());
  535       const size_t num_locations = bkpt_sp->GetNumLocations();
  561   if (!llvm::isa<BreakpointResolverScripted>(bkpt_sp->GetResolver().get())) {
  566   if (bkpt_sp->GetSearchFilter()->AddressPasses(address.ref()))
  566   if (bkpt_sp->GetSearchFilter()->AddressPasses(address.ref()))
  567     bkpt_sp->AddLocation(address.ref());
  570     address.get()->Dump(&s, &bkpt_sp->GetTarget(),
  586         bkpt_sp->GetTarget().GetAPIMutex());
  588     bkpt_sp->SetCallback(SBBreakpointCallbackBaton
  613         bkpt_sp->GetTarget().GetAPIMutex());
  614     BreakpointOptions *bp_options = bkpt_sp->GetOptions();
  615     error = bkpt_sp->GetTarget()
  638         bkpt_sp->GetTarget().GetAPIMutex());
  639     BreakpointOptions *bp_options = bkpt_sp->GetOptions();
  641         bkpt_sp->GetTarget()
  659         bkpt_sp->GetTarget().GetAPIMutex());
  662     bkpt_sp->GetTarget().AddNameToBreakpoint(bkpt_sp, new_name, error);
  678         bkpt_sp->GetTarget().GetAPIMutex());
  679     bkpt_sp->GetTarget().RemoveNameFromBreakpoint(bkpt_sp,
  691         bkpt_sp->GetTarget().GetAPIMutex());
  692     return bkpt_sp->MatchesName(name);
  706         bkpt_sp->GetTarget().GetAPIMutex());
  708     bkpt_sp->GetNames(names_vec);
  781     return bkpt_sp->IsHardware();
  791     if (target_sp && target_sp->IsValid())
  806     return target_sp->GetBreakpointList().FindBreakpointByID(bp_id);
  816         return target_sp->GetBreakpointList().FindBreakpointByID(break_id);
  825     if (bkpt->GetTargetSP() != target_sp)
  827     m_break_ids.push_back(bkpt->GetID());
  835     if (bkpt->GetTargetSP() != target_sp)
  837     lldb::break_id_t bp_id = bkpt->GetID();
  842     m_break_ids.push_back(bkpt->GetID());
  884     return m_opaque_sp->GetSize();
  894   BreakpointSP bkpt_sp = m_opaque_sp->GetBreakpointAtIndex(idx);
  904   BreakpointSP bkpt_sp = m_opaque_sp->FindBreakpointByID(id);
  916   m_opaque_sp->Append(sb_bkpt.m_opaque_wp.lock());
  925   m_opaque_sp->AppendByID(id);
  936   return m_opaque_sp->AppendIfUnique(sb_bkpt.GetSP());
  943     m_opaque_sp->Clear();
  949     m_opaque_sp->CopyToBreakpointIDList(bp_id_list);

tools/lldb/source/API/SBBreakpointLocation.cpp

   83     return LLDB_RECORD_RESULT(SBAddress(&loc_sp->GetAddress()));
   98         loc_sp->GetTarget().GetAPIMutex());
   99     ret_addr = loc_sp->GetLoadAddress();
  111         loc_sp->GetTarget().GetAPIMutex());
  112     loc_sp->SetEnabled(enabled);
  122         loc_sp->GetTarget().GetAPIMutex());
  123     return loc_sp->IsEnabled();
  134         loc_sp->GetTarget().GetAPIMutex());
  135     return loc_sp->GetHitCount();
  146         loc_sp->GetTarget().GetAPIMutex());
  147     return loc_sp->GetIgnoreCount();
  158         loc_sp->GetTarget().GetAPIMutex());
  159     loc_sp->SetIgnoreCount(n);
  170         loc_sp->GetTarget().GetAPIMutex());
  171     loc_sp->SetCondition(condition);
  181         loc_sp->GetTarget().GetAPIMutex());
  182     return loc_sp->GetConditionText();
  194         loc_sp->GetTarget().GetAPIMutex());
  195     loc_sp->SetAutoContinue(auto_continue);
  205         loc_sp->GetTarget().GetAPIMutex());
  206     return loc_sp->IsAutoContinue();
  229         loc_sp->GetTarget().GetAPIMutex());
  230     BreakpointOptions *bp_options = loc_sp->GetLocationOptions();
  231     error = loc_sp->GetBreakpoint()
  256         loc_sp->GetTarget().GetAPIMutex());
  257     BreakpointOptions *bp_options = loc_sp->GetLocationOptions();
  259         loc_sp->GetBreakpoint()
  282       loc_sp->GetTarget().GetAPIMutex());
  286   loc_sp->GetLocationOptions()->SetCommandDataCallback(cmd_data_up);
  298       loc_sp->GetLocationOptions()->GetCommandLineCallbacks(command_list);
  311         loc_sp->GetTarget().GetAPIMutex());
  312     loc_sp->SetThreadID(thread_id);
  323         loc_sp->GetTarget().GetAPIMutex());
  324     return loc_sp->GetThreadID();
  336         loc_sp->GetTarget().GetAPIMutex());
  337     loc_sp->SetThreadIndex(index);
  349         loc_sp->GetTarget().GetAPIMutex());
  350     return loc_sp->GetThreadIndex();
  362         loc_sp->GetTarget().GetAPIMutex());
  363     loc_sp->SetThreadName(thread_name);
  374         loc_sp->GetTarget().GetAPIMutex());
  375     return loc_sp->GetThreadName();
  387         loc_sp->GetTarget().GetAPIMutex());
  388     loc_sp->SetQueueName(queue_name);
  399         loc_sp->GetTarget().GetAPIMutex());
  400     loc_sp->GetQueueName();
  411         loc_sp->GetTarget().GetAPIMutex());
  412     return loc_sp->IsResolved();
  434         loc_sp->GetTarget().GetAPIMutex());
  435     loc_sp->GetDescription(&strm, level);
  449         loc_sp->GetTarget().GetAPIMutex());
  450     return loc_sp->GetID();
  464         loc_sp->GetTarget().GetAPIMutex());
  465     sb_bp = loc_sp->GetBreakpoint().shared_from_this();

tools/lldb/source/API/SBBreakpointName.cpp

  105   return target_sp->FindBreakpointName(ConstString(m_name), true, error);
  134   Target &target = bkpt_sp->GetTarget();
  146   target.ConfigureBreakpointName(*bp_name, *bkpt_sp->GetOptions(),
  221         m_impl_up->GetTarget()->GetAPIMutex());
  233   target_sp->ApplyNameToBreakpoints(bp_name);
  245         m_impl_up->GetTarget()->GetAPIMutex());
  258         m_impl_up->GetTarget()->GetAPIMutex());
  272         m_impl_up->GetTarget()->GetAPIMutex());
  285         m_impl_up->GetTarget()->GetAPIMutex());
  299         m_impl_up->GetTarget()->GetAPIMutex());
  313         m_impl_up->GetTarget()->GetAPIMutex());
  327         m_impl_up->GetTarget()->GetAPIMutex());
  341         m_impl_up->GetTarget()->GetAPIMutex());
  355         m_impl_up->GetTarget()->GetAPIMutex());
  368         m_impl_up->GetTarget()->GetAPIMutex());
  382         m_impl_up->GetTarget()->GetAPIMutex());
  395         m_impl_up->GetTarget()->GetAPIMutex());
  409         m_impl_up->GetTarget()->GetAPIMutex());
  423         m_impl_up->GetTarget()->GetAPIMutex());
  438         m_impl_up->GetTarget()->GetAPIMutex());
  452         m_impl_up->GetTarget()->GetAPIMutex());
  467         m_impl_up->GetTarget()->GetAPIMutex());
  484         m_impl_up->GetTarget()->GetAPIMutex());
  529         m_impl_up->GetTarget()->GetAPIMutex());
  545         m_impl_up->GetTarget()->GetAPIMutex());
  559         m_impl_up->GetTarget()->GetAPIMutex());
  591         m_impl_up->GetTarget()->GetAPIMutex());
  596       ->GetDebugger()
  618         m_impl_up->GetTarget()->GetAPIMutex());
  623           ->GetDebugger()

tools/lldb/source/API/SBBreakpointOptionCommon.cpp

   67         sb_location.SetLocation(bp_sp->FindLocationByID(break_loc_id));

tools/lldb/source/API/SBCommandInterpreter.cpp

  168     bool ret = m_backend->DoExecute(
  474       std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
  475       process_sp = target_sp->GetProcessSP();
  569       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
  588       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
  730   return (IsValid() ? ConstString(m_opaque_sp->GetCommandName()).AsCString() : nullptr);
  736   return (IsValid() ? ConstString(m_opaque_sp->GetHelp()).AsCString()
  743   return (IsValid() ? ConstString(m_opaque_sp->GetHelpLong()).AsCString()
  751     m_opaque_sp->SetHelp(help);
  758     m_opaque_sp->SetHelpLong(help);
  768   if (!m_opaque_sp->IsMultiwordObject())
  771       m_opaque_sp->GetCommandInterpreter(), name, help);
  774   if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
  789   if (!m_opaque_sp->IsMultiwordObject())
  793       m_opaque_sp->GetCommandInterpreter(), name, impl, help);
  794   if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
  809   if (!m_opaque_sp->IsMultiwordObject())
  813       m_opaque_sp->GetCommandInterpreter(), name, impl, help, syntax);
  814   if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
  822   return (IsValid() ? m_opaque_sp->GetFlags().Get() : 0);
  829     m_opaque_sp->GetFlags().Set(flags);

tools/lldb/source/API/SBCommandReturnObject.cpp

  133   return file_sp->Printf("%s", GetOutput());
  140   return file.m_opaque_sp->Printf("%s", GetOutput());
  158   return file_sp->Printf("%s", GetError());
  165   return file.m_opaque_sp->Printf("%s", GetError());

tools/lldb/source/API/SBCompileUnit.cpp

  141   SymbolFile *symfile = module_sp->GetSymbolFile();

tools/lldb/source/API/SBData.cpp

   53   return m_opaque_sp.operator->();
   75     value = m_opaque_sp->GetAddressByteSize();
   84     m_opaque_sp->SetAddressByteSize(addr_byte_size);
   91     m_opaque_sp->Clear();
   99     value = m_opaque_sp->GetByteSize();
  108     value = m_opaque_sp->GetByteOrder();
  116     m_opaque_sp->SetByteOrder(endian);
  128     value = m_opaque_sp->GetFloat(&offset);
  144     value = m_opaque_sp->GetDouble(&offset);
  160     value = m_opaque_sp->GetLongDouble(&offset);
  176     value = m_opaque_sp->GetAddress(&offset);
  192     value = m_opaque_sp->GetU8(&offset);
  208     value = m_opaque_sp->GetU16(&offset);
  224     value = m_opaque_sp->GetU32(&offset);
  240     value = m_opaque_sp->GetU64(&offset);
  256     value = (int8_t)m_opaque_sp->GetMaxS64(&offset, 1);
  272     value = (int16_t)m_opaque_sp->GetMaxS64(&offset, 2);
  288     value = (int32_t)m_opaque_sp->GetMaxS64(&offset, 4);
  304     value = (int64_t)m_opaque_sp->GetMaxS64(&offset, 8);
  320     value = m_opaque_sp->GetCStr(&offset);
  336                       m_opaque_sp->GetByteSize(), 16, base_addr, 0, 0);
  354     ok = m_opaque_sp->GetU8(&offset, buf, size);
  372     m_opaque_sp->SetData(buf, size, endian);
  373     m_opaque_sp->SetAddressByteSize(addr_size);
  533     m_opaque_sp->SetData(buffer_sp);
  556     m_opaque_sp->SetData(buffer_sp);
  579     m_opaque_sp->SetData(buffer_sp);
  601     m_opaque_sp->SetData(buffer_sp);
  623     m_opaque_sp->SetData(buffer_sp);
  645     m_opaque_sp->SetData(buffer_sp);

tools/lldb/source/API/SBDebugger.cpp

  177     m_opaque_sp->ClearIOHandlers();
  266     m_opaque_sp->SetAsyncExecution(b);
  272   return (m_opaque_sp ? m_opaque_sp->GetAsyncExecution() : false);
  279     m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles(b);
  286     m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles(b);
  331   if (!file_sp || !file_sp->IsValid()) {
  336   m_opaque_sp->SetInputFile(file_sp, recorder);
  362   m_opaque_sp->SetOutputFile(file.m_opaque_sp);
  388   m_opaque_sp->SetErrorFile(file.m_opaque_sp);
  395     File &file_sp = m_opaque_sp->GetInputFile();
  404     return LLDB_RECORD_RESULT(SBFile(m_opaque_sp->GetInputFileSP()));
  412     StreamFile &stream_file = m_opaque_sp->GetOutputStream();
  421     SBFile file(m_opaque_sp->GetOutputStream().GetFileSP());
  431     StreamFile &stream_file = m_opaque_sp->GetErrorStream();
  441     SBFile file(m_opaque_sp->GetErrorStream().GetFileSP());
  451     m_opaque_sp->SaveInputTerminalState();
  458     m_opaque_sp->RestoreInputTerminalState();
  466     sb_interpreter.reset(&m_opaque_sp->GetCommandInterpreter());
  475     TargetSP target_sp(m_opaque_sp->GetSelectedTarget());
  478       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
  485     result.PutError(m_opaque_sp->GetErrorStream().GetFileSP());
  486     result.PutOutput(m_opaque_sp->GetOutputStream().GetFileSP());
  488     if (!m_opaque_sp->GetAsyncExecution()) {
  493         ListenerSP lldb_listener_sp = m_opaque_sp->GetListener();
  494         while (lldb_listener_sp->GetEventForBroadcaster(
  509     sb_listener.reset(m_opaque_sp->GetListener());
  558   std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
  565         out_sp->Write(stdio_buffer, len);
  573         err_sp->Write(stdio_buffer, len);
  733     sb_error.ref() = m_opaque_sp->GetTargetList().CreateTarget(
  767     Status error(m_opaque_sp->GetTargetList().CreateTarget(
  797     error = m_opaque_sp->GetTargetList().CreateTarget(
  803       m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get());
  826     error = m_opaque_sp->GetTargetList().CreateTarget(
  832       m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get());
  849     sb_target.SetSP(m_opaque_sp->GetDummyTarget()->shared_from_this());
  867       result = m_opaque_sp->GetTargetList().DeleteTarget(target_sp);
  868       target_sp->Destroy();
  890     sb_target.SetSP(m_opaque_sp->GetTargetList().GetTargetAtIndex(idx));
  906   return m_opaque_sp->GetTargetList().GetIndexOfTarget(target.GetSP());
  916     sb_target.SetSP(m_opaque_sp->GetTargetList().FindTargetWithProcessID(pid));
  930         m_opaque_sp->GetPlatformList().GetSelectedPlatform().get(), arch_name);
  932         m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture(
  944         m_opaque_sp->GetTargetList().FindTargetWithProcess(process_sp.get()));
  954     return m_opaque_sp->GetTargetList().GetNumTargets();
  968     target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget();
  991     m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get());
 1010     sb_platform.SetSP(debugger_sp->GetPlatformList().GetSelectedPlatform());
 1027     debugger_sp->GetPlatformList().SetSelectedPlatform(sb_platform.GetSP());
 1041     return m_opaque_sp->GetPlatformList().GetSize();
 1053     sb_platform.SetSP(m_opaque_sp->GetPlatformList().GetAtIndex(idx));
 1083         name_str, host_platform_sp->GetPluginName().GetStringRef());
 1085         desc_str, llvm::StringRef(host_platform_sp->GetDescription()));
 1136     m_opaque_sp->DispatchInputInterrupt();
 1143     m_opaque_sp->DispatchInputEndOfFile();
 1159     m_opaque_sp->GetCommandInterpreter().RunCommandInterpreter(
 1178     CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter();
 1195     error.ref() = m_opaque_sp->RunREPL(language, repl_options);
 1229   return (m_opaque_sp ? m_opaque_sp->GetInstanceName().AsCString() : nullptr);
 1244         debugger_sp->GetCommandInterpreter().GetExecutionContext());
 1245     error = debugger_sp->SetPropertyValue(&exe_ctx, eVarSetOperationAssign,
 1269         debugger_sp->GetCommandInterpreter().GetExecutionContext());
 1271         debugger_sp->GetPropertyValue(&exe_ctx, var_name, false, error));
 1274       value_sp->DumpValue(&exe_ctx, value_strm, OptionValue::eDumpOptionValue);
 1289   return (m_opaque_sp ? m_opaque_sp->GetTerminalWidth() : 0);
 1296     m_opaque_sp->SetTerminalWidth(term_width);
 1306             (m_opaque_sp ? m_opaque_sp->GetPrompt().str().c_str() : ""));
 1308   return (m_opaque_sp ? ConstString(m_opaque_sp->GetPrompt()).GetCString()
 1316     m_opaque_sp->SetPrompt(llvm::StringRef::withNullAsEmpty(prompt));
 1323               ? ConstString(m_opaque_sp->GetReproducerPath()).GetCString()
 1331   return (m_opaque_sp ? m_opaque_sp->GetScriptLanguage() : eScriptLanguageNone);
 1339     m_opaque_sp->SetScriptLanguage(script_lang);
 1346   return (m_opaque_sp ? m_opaque_sp->SetUseExternalEditor(value) : false);
 1352   return (m_opaque_sp ? m_opaque_sp->GetUseExternalEditor() : false);
 1358   return (m_opaque_sp ? m_opaque_sp->SetUseColor(value) : false);
 1364   return (m_opaque_sp ? m_opaque_sp->GetUseColor() : false);
 1374     const char *name = m_opaque_sp->GetInstanceName().AsCString();
 1375     user_id_t id = m_opaque_sp->GetID();
 1386   return (m_opaque_sp ? m_opaque_sp->GetID() : LLDB_INVALID_UID);
 1401         m_opaque_sp->GetPlatformList().SetSelectedPlatform(platform_sp);
 1408           m_opaque_sp->GetPlatformList().Append(platform_sp, make_selected);
 1427         m_opaque_sp->GetPlatformList().GetSelectedPlatform());
 1433       platform_sp->SetSDKRootDirectory(ConstString(sysroot));
 1443   return (m_opaque_sp ? m_opaque_sp->GetCloseInputOnEOF() : false);
 1450     m_opaque_sp->SetCloseInputOnEOF(b);
 1588     return m_opaque_sp->EnableLog(channel, GetCategoryArray(categories), "",
 1600     return m_opaque_sp->SetLoggingCallback(log_callback, baton);

tools/lldb/source/API/SBExecutionContext.cpp

   44   m_exe_ctx_sp->SetTargetSP(target.GetSP());
   52   m_exe_ctx_sp->SetProcessSP(process.GetSP());
   59   m_exe_ctx_sp->SetThreadPtr(thread.get());
   66   m_exe_ctx_sp->SetFrameSP(frame.GetFrameSP());
   91     TargetSP target_sp(m_exe_ctx_sp->GetTargetSP());
  104     ProcessSP process_sp(m_exe_ctx_sp->GetProcessSP());
  117     ThreadSP thread_sp(m_exe_ctx_sp->GetThreadSP());
  129     StackFrameSP frame_sp(m_exe_ctx_sp->GetFrameSP());

tools/lldb/source/API/SBFile.cpp

   50     Status status = m_opaque_sp->Read(buf, num_bytes);
   67     Status status = m_opaque_sp->Write(buf, num_bytes);
   80     Status status = m_opaque_sp->Flush();
   88   return m_opaque_sp && m_opaque_sp->IsValid();
   95     Status status = m_opaque_sp->Close();

tools/lldb/source/API/SBFrame.cpp

   85   return (m_opaque_sp ? m_opaque_sp->GetFrameSP() : StackFrameSP());
   89   return m_opaque_sp->SetFrameSP(lldb_object_sp);
  365         ret_val = frame->GetRegisterContext()->SetPC(new_pc);
  388         addr = frame->GetRegisterContext()->GetSP();
  411         addr = frame->GetRegisterContext()->GetFP();
  442   m_opaque_sp->Clear();
  457         frame->CalculateTarget()->GetPreferDynamicValue();
  511         frame->CalculateTarget()->GetPreferDynamicValue();
  564         frame->CalculateTarget()->GetPreferDynamicValue();
  635             const uint32_t num_regs = reg_ctx->GetRegisterCount();
  638                   reg_ctx->GetRegisterInfoAtIndex(reg_idx);
  656             const uint32_t num_sets = reg_ctx->GetRegisterSetCount();
  658               const RegisterSet *reg_set = reg_ctx->GetRegisterSet(set_idx);
  678             value_sp = expr_var_sp->GetValueObject();
  699   return (this_sp && that_sp && this_sp->GetStackID() == that_sp->GetStackID());
  699   return (this_sp && that_sp && this_sp->GetStackID() == that_sp->GetStackID());
  765         frame->CalculateTarget()->GetPreferDynamicValue();
  844                 switch (variable_sp->GetScope()) {
  869                   if (in_scope_only && !variable_sp->IsInScope(frame))
  891                 recognized_frame->GetRecognizedArguments();
  893               for (auto &rec_value_sp : recognized_arg_list->GetObjects()) {
  925           const uint32_t num_sets = reg_ctx->GetRegisterSetCount();
  957           const uint32_t num_regs = reg_ctx->GetRegisterCount();
  960                 reg_ctx->GetRegisterInfoAtIndex(reg_idx);
 1018         frame->CalculateTarget()->GetPreferDynamicValue();

tools/lldb/source/API/SBFunction.cpp

  135       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
  136       target_sp->CalculateExecutionContext(exe_ctx);
  137       exe_ctx.SetProcessSP(target_sp->GetProcessSP());
  144           module_sp->GetArchitecture(), nullptr, flavor, exe_ctx,
  189       variable_list_sp->AppendVariablesWithScope(eValueTypeVariableArgument,
  193         return variable_sp->GetName().GetCString();

tools/lldb/source/API/SBInstruction.cpp

  101   return m_opaque_sp && m_opaque_sp->IsValid();
  109   if (inst_sp && inst_sp->GetAddress().IsValid())
  110     sb_addr.SetAddress(&inst_sp->GetAddress());
  124       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
  126       target_sp->CalculateExecutionContext(exe_ctx);
  127       exe_ctx.SetProcessSP(target_sp->GetProcessSP());
  129     return inst_sp->GetMnemonic(&exe_ctx);
  144       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
  146       target_sp->CalculateExecutionContext(exe_ctx);
  147       exe_ctx.SetProcessSP(target_sp->GetProcessSP());
  149     return inst_sp->GetOperands(&exe_ctx);
  164       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
  166       target_sp->CalculateExecutionContext(exe_ctx);
  167       exe_ctx.SetProcessSP(target_sp->GetProcessSP());
  169     return inst_sp->GetComment(&exe_ctx);
  179     return inst_sp->GetOpcode().GetByteSize();
  191     if (inst_sp->GetData(*data_extractor_sp)) {
  203     return inst_sp->DoesBranch();
  212     return inst_sp->HasDelaySlot();
  221     return inst_sp->CanSetBreakpoint();
  227     return m_opaque_sp->GetSP();
  244     const Address &addr = inst_sp->GetAddress();
  247       module_sp->ResolveSymbolContextForAddress(addr, eSymbolContextEverything,
  253     inst_sp->Dump(&s.ref(), 0, true, false, nullptr, &sc, nullptr, &format, 0);
  273   if (!out_sp || !out_sp->IsValid())
  279     const Address &addr = inst_sp->GetAddress();
  282       module_sp->ResolveSymbolContextForAddress(addr, eSymbolContextEverything,
  287     inst_sp->Dump(&out_stream, 0, true, false, nullptr, &sc, nullptr, &format,
  303       frame_sp->CalculateExecutionContext(exe_ctx);
  307       return inst_sp->Emulate(
  324     return inst_sp->DumpEmulation(HostInfo::GetAugmentedArchSpec(triple));
  341     return inst_sp->TestEmulation(output_stream.get(), test_file);

tools/lldb/source/API/SBInstructionList.cpp

   61     return m_opaque_sp->GetInstructionList().GetSize();
   70   if (m_opaque_sp && idx < m_opaque_sp->GetInstructionList().GetSize())
   73         m_opaque_sp->GetInstructionList().GetInstructionAtIndex(idx));
  139   if (!out_sp || !out_sp->IsValid())
  159           m_opaque_sp->GetInstructionList().GetMaxOpcocdeByteSize();
  166             m_opaque_sp->GetInstructionList().GetInstructionAtIndex(i).get();
  174           module_sp->ResolveSymbolContextForAddress(

tools/lldb/source/API/SBLaunchInfo.cpp

   41   m_opaque_sp->GetFlags().Reset(eLaunchFlagDebug | eLaunchFlagDisableASLR);
   43     m_opaque_sp->GetArguments().SetArguments(argv);
   59   return m_opaque_sp->GetProcessID();
   65   return m_opaque_sp->GetUserID();
   71   return m_opaque_sp->GetGroupID();
   77   return m_opaque_sp->UserIDIsValid();
   83   return m_opaque_sp->GroupIDIsValid();
   89   m_opaque_sp->SetUserID(uid);
   95   m_opaque_sp->SetGroupID(gid);
  101   return LLDB_RECORD_RESULT(SBFileSpec(m_opaque_sp->GetExecutableFile()));
  109   m_opaque_sp->SetExecutableFile(exe_file.ref(), add_as_first_arg);
  115   return LLDB_RECORD_RESULT(SBListener(m_opaque_sp->GetListener()));
  122   m_opaque_sp->SetListener(listener.GetSP());
  128   return m_opaque_sp->GetArguments().GetArgumentCount();
  135   return m_opaque_sp->GetArguments().GetArgumentAtIndex(idx);
  144       m_opaque_sp->GetArguments().AppendArguments(argv);
  147       m_opaque_sp->GetArguments().SetArguments(argv);
  149       m_opaque_sp->GetArguments().Clear();
  156   return m_opaque_sp->GetEnvironment().size();
  165   return m_opaque_sp->GetEnvp()[idx];
  174     m_opaque_sp->GetEnvironment().insert(env.begin(), env.end());
  176     m_opaque_sp->GetEnvironment() = env;
  177   m_opaque_sp->RegenerateEnvp();
  183   m_opaque_sp->Clear();
  190   return m_opaque_sp->GetWorkingDirectory().GetCString();
  197   m_opaque_sp->SetWorkingDirectory(FileSpec(working_dir));
  203   return m_opaque_sp->GetFlags().Get();
  209   m_opaque_sp->GetFlags().Reset(flags);
  215   return m_opaque_sp->GetProcessPluginName();
  222   return m_opaque_sp->SetProcessPluginName(plugin_name);
  230   ConstString shell(m_opaque_sp->GetShell().GetPath().c_str());
  237   m_opaque_sp->SetShell(FileSpec(path));
  243   return m_opaque_sp->GetShellExpandArguments();
  250   m_opaque_sp->SetShellExpandArguments(expand);
  256   return m_opaque_sp->GetResumeCount();
  262   m_opaque_sp->SetResumeCount(c);
  268   return m_opaque_sp->AppendCloseFileAction(fd);
  275   return m_opaque_sp->AppendDuplicateFileAction(fd, dup_fd);
  283   return m_opaque_sp->AppendOpenFileAction(fd, FileSpec(path), read, write);
  290   return m_opaque_sp->AppendSuppressFileAction(fd, read, write);
  297   m_opaque_sp->SetLaunchEventData(data);
  304   return m_opaque_sp->GetLaunchEventData();
  310   m_opaque_sp->SetDetachOnError(enable);
  316   return m_opaque_sp->GetDetachOnError();

tools/lldb/source/API/SBListener.cpp

   69     m_opaque_sp->AddEvent(event_sp);
   76     m_opaque_sp->Clear();
   91     return m_opaque_sp->StartListeningForEventSpec(
  109     return m_opaque_sp->StopListeningForEventSpec(
  124         m_opaque_sp->StartListeningForEvents(broadcaster.get(), event_mask);
  137     return m_opaque_sp->StopListeningForEvents(broadcaster.get(), event_mask);
  156     if (m_opaque_sp->GetEvent(event_sp, timeout)) {
  179     if (m_opaque_sp->GetEventForBroadcaster(broadcaster.get(), event_sp,
  202     if (m_opaque_sp->GetEventForBroadcasterWithType(
  217     event.reset(m_opaque_sp->PeekAtNextEvent());
  231     event.reset(m_opaque_sp->PeekAtNextEventForBroadcaster(broadcaster.get()));
  246     event.reset(m_opaque_sp->PeekAtNextEventForBroadcasterWithType(
  259     if (m_opaque_sp->GetEvent(event_sp, std::chrono::seconds(0))) {
  276     if (m_opaque_sp->GetEventForBroadcaster(broadcaster.get(), event_sp,
  295     if (m_opaque_sp->GetEventForBroadcasterWithType(broadcaster.get(),
  311     return m_opaque_sp->HandleBroadcastEvent(event.GetSP());

tools/lldb/source/API/SBModule.cpp

   59     m_opaque_sp = process_sp->ReadModuleFromMemory(FileSpec(), header_addr);
   61       Target &target = process_sp->GetTarget();
   63       m_opaque_sp->SetLoadAddress(target, 0, true, changed);
  102     file_spec.SetFileSpec(module_sp->GetFileSpec());
  115     file_spec.SetFileSpec(module_sp->GetPlatformFileSpec());
  128     module_sp->SetPlatformFileSpec(*platform_file);
  142     sb_file_spec.SetFileSpec(module_sp->GetRemoteInstallFileSpec());
  152     module_sp->SetRemoteInstallFileSpec(file.ref());
  164     uuid_bytes = module_sp->GetUUID().GetBytes().data();
  179     uuid_cstr = ConstString(module_sp->GetUUID().GetAsString()).GetCString();
  219     if (module_sp->ResolveFileAddress(vm_addr, addr))
  236     module_sp->ResolveSymbolContextForAddress(addr.ref(), scope, *sb_sc);
  248     module_sp->GetDescription(&strm);
  260     return module_sp->GetNumCompileUnits();
  272     CompUnitSP cu_sp = module_sp->GetCompileUnitAtIndex(index);
  285     module_sp->FindCompileUnits(*sb_file_spec, *sb_sc_list);
  292     return module_sp->GetSymtab();
  368     module_sp->GetSymbolFile();
  369     SectionList *section_list = module_sp->GetSectionList();
  384     module_sp->GetSymbolFile();
  385     SectionList *section_list = module_sp->GetSectionList();
  404     module_sp->FindFunctions(ConstString(name), nullptr, type, symbols_ok,
  420     module_sp->FindGlobalVariables(ConstString(name), nullptr, max_matches,
  460     sb_type = SBType(module_sp->FindFirstType(sc, name, exact_match));
  464           module_sp->GetTypeSystemForLanguage(eLanguageTypeC);
  482         module_sp->GetTypeSystemForLanguage(eLanguageTypeC);
  505     module_sp->FindTypes(name, exact_match, UINT32_MAX, searched_symbol_files,
  510           module_sp->GetTypeSystemForLanguage(eLanguageTypeC);
  536     if (SymbolFile *symfile = module_sp->GetSymbolFile()) {
  554   SymbolFile *symfile = module_sp->GetSymbolFile();
  574     module_sp->GetSymbolFile();
  575     SectionList *section_list = module_sp->GetSectionList();
  592     return module_sp->GetArchitecture().GetByteOrder();
  601     std::string triple(module_sp->GetArchitecture().GetTriple().str());
  616     return module_sp->GetArchitecture().GetAddressByteSize();
  626     version = module_sp->GetVersion();
  656     if (SymbolFile *symfile = module_sp->GetSymbolFile())
  669     ObjectFile *objfile_ptr = module_sp->GetObjectFile();
  683     ObjectFile *objfile_ptr = module_sp->GetObjectFile();

tools/lldb/source/API/SBPlatform.cpp

  299     return platform_sp->GetName().GetCString();
  314     return platform_sp->GetWorkingDirectory().GetCString();
  325       platform_sp->SetWorkingDirectory(FileSpec(path));
  327       platform_sp->SetWorkingDirectory(FileSpec());
  343     sb_error.ref() = platform_sp->ConnectRemote(args);
  355     platform_sp->DisconnectRemote();
  363     return platform_sp->IsConnected();
  372     ArchSpec arch(platform_sp->GetSystemArchitecture());
  388     if (platform_sp->GetOSBuildString(s)) {
  405     if (platform_sp->GetOSKernelDescription(s)) {
  421     return platform_sp->GetHostname();
  430     version = platform_sp->GetOSVersion();
  439     version = platform_sp->GetOSVersion();
  448     version = platform_sp->GetOSVersion();
  459     sb_error.ref() = platform_sp->GetFile(src.ref(), dst.ref());
  481           return platform_sp->PutFile(src.ref(), dst.ref(), permissions);
  497           return platform_sp->Install(src.ref(), dst.ref());
  517       working_dir = platform_sp->GetWorkingDirectory().GetCString();
  521     return platform_sp->RunShellCommand(command, FileSpec(working_dir),
  535         Status error = platform_sp->LaunchProcess(info);
  545         return platform_sp->KillProcess(pid);
  554     if (platform_sp->IsConnected())
  572         platform_sp->MakeDirectory(FileSpec(path), file_permissions);
  586     platform_sp->GetFilePermissions(FileSpec(path), file_permissions);
  601         platform_sp->SetFilePermissions(FileSpec(path), file_permissions);

tools/lldb/source/API/SBProcess.cpp

   91     return process_sp->GetPluginName().GetCString();
  101     return process_sp->GetPluginName().GetCString();
  124   return ((bool)process_sp && process_sp->IsValid());
  143         process_sp->GetTarget().GetAPIMutex());
  144     if (process_sp->GetState() == eStateConnected) {
  150       Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer();
  157       error.SetError(process_sp->Launch(launch_info));
  176         process_sp->GetTarget().GetAPIMutex());
  177     if (process_sp->GetState() == eStateConnected) {
  180       error.SetError(process_sp->Attach(attach_info));
  200     const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock());
  202         process_sp->GetTarget().GetAPIMutex());
  203     num_threads = process_sp->GetThreadList().GetSize(can_update);
  218         process_sp->GetTarget().GetAPIMutex());
  219     thread_sp = process_sp->GetThreadList().GetSelectedThread();
  236         process_sp->GetTarget().GetAPIMutex());
  237     thread_sp = process_sp->CreateOSPluginThread(tid, context);
  251     target_sp = process_sp->GetTarget().shared_from_this();
  266     ret_val = process_sp->PutSTDIN(src, src_len, error);
  280     bytes_read = process_sp->GetSTDOUT(dst, dst_len, error);
  294     bytes_read = process_sp->GetSTDERR(dst, dst_len, error);
  308     bytes_read = process_sp->GetAsyncProfileData(dst, dst_len, error);
  328     uid = process_sp->StartTrace(*(options.m_traceoptions_sp), error.ref());
  353   if (!out || !out->IsValid())
  361         process_sp->GetID(), SBDebugger::StateAsCString(event_state));
  376                process_sp->GetID(), SBDebugger::StateAsCString(event_state));
  389         process_sp->GetTarget().GetAPIMutex());
  390     return process_sp->GetThreadList().SetSelectedThreadByID(
  405         process_sp->GetTarget().GetAPIMutex());
  406     ret_val = process_sp->GetThreadList().SetSelectedThreadByID(tid);
  420         process_sp->GetTarget().GetAPIMutex());
  421     ret_val = process_sp->GetThreadList().SetSelectedThreadByIndexID(index_id);
  437     const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock());
  439         process_sp->GetTarget().GetAPIMutex());
  440     thread_sp = process_sp->GetThreadList().GetThreadAtIndex(index, can_update);
  454     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
  456           process_sp->GetTarget().GetAPIMutex());
  457       num_queues = process_sp->GetQueueList().GetSize();
  473     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
  475           process_sp->GetTarget().GetAPIMutex());
  476       queue_sp = process_sp->GetQueueList().GetQueueAtIndex(index);
  491         process_sp->GetTarget().GetAPIMutex());
  493       return process_sp->GetStopID();
  495       return process_sp->GetLastNaturalStopID();
  509         process_sp->GetTarget().GetAPIMutex());
  510     event_sp = process_sp->GetStopEventForStopID(stop_id);
  524         process_sp->GetTarget().GetAPIMutex());
  525     ret_val = process_sp->GetState();
  538         process_sp->GetTarget().GetAPIMutex());
  539     exit_status = process_sp->GetExitStatus();
  552         process_sp->GetTarget().GetAPIMutex());
  553     exit_desc = process_sp->GetExitDescription();
  564     ret_val = process_sp->GetID();
  575     ret_val = process_sp->GetUniqueID();
  585     byteOrder = process_sp->GetTarget().GetArchitecture().GetByteOrder();
  597     size = process_sp->GetTarget().GetArchitecture().GetAddressByteSize();
  611         process_sp->GetTarget().GetAPIMutex());
  613     if (process_sp->GetTarget().GetDebugger().GetAsyncExecution())
  614       sb_error.ref() = process_sp->Resume();
  616       sb_error.ref() = process_sp->ResumeSynchronous(nullptr);
  630         process_sp->GetTarget().GetAPIMutex());
  631     sb_error.SetError(process_sp->Destroy(false));
  645         process_sp->GetTarget().GetAPIMutex());
  646     sb_error.SetError(process_sp->Halt());
  660         process_sp->GetTarget().GetAPIMutex());
  661     sb_error.SetError(process_sp->Destroy(true));
  683         process_sp->GetTarget().GetAPIMutex());
  684     sb_error.SetError(process_sp->Detach(keep_stopped));
  698         process_sp->GetTarget().GetAPIMutex());
  699     sb_error.SetError(process_sp->Signal(signo));
  720     process_sp->SendAsyncInterrupt();
  733     const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock());
  735         process_sp->GetTarget().GetAPIMutex());
  736     thread_sp = process_sp->GetThreadList().FindThreadByID(tid, can_update);
  752     const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock());
  754         process_sp->GetTarget().GetAPIMutex());
  756         process_sp->GetThreadList().FindThreadByIndexID(index_id, can_update);
  841   EventData *event_data = event_sp ? event_sp->GetData() : nullptr;
  879     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
  881           process_sp->GetTarget().GetAPIMutex());
  882       bytes_read = process_sp->ReadMemory(addr, dst, dst_len, sb_error.ref());
  903     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
  905           process_sp->GetTarget().GetAPIMutex());
  906       bytes_read = process_sp->ReadCStringFromMemory(addr, (char *)buf, size,
  927     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
  929           process_sp->GetTarget().GetAPIMutex());
  930       value = process_sp->ReadUnsignedIntegerFromMemory(addr, byte_size, 0,
  950     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
  952           process_sp->GetTarget().GetAPIMutex());
  953       ptr = process_sp->ReadPointerFromMemory(addr, sb_error.ref());
  975     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
  977           process_sp->GetTarget().GetAPIMutex());
  979           process_sp->WriteMemory(addr, src, src_len, sb_error.ref());
  998     Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer();
 1004                 process_sp->GetID(), lldb_private::StateAsCString(GetState()),
 1023         process_sp->GetTarget().GetAPIMutex());
 1024     sb_error.SetError(process_sp->GetWatchpointSupportInfo(num));
 1051     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
 1053         process_sp->GetTarget().GetAPIMutex());
 1054       PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
 1055       return platform_sp->LoadImage(process_sp.get(), *sb_local_image_spec,
 1078     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
 1080         process_sp->GetTarget().GetAPIMutex());
 1081       PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
 1089       uint32_t token = platform_sp->LoadImageUsingPaths(
 1112     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
 1114           process_sp->GetTarget().GetAPIMutex());
 1115       PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
 1117           platform_sp->UnloadImage(process_sp.get(), image_token));
 1134     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
 1136           process_sp->GetTarget().GetAPIMutex());
 1137       sb_error.SetError(process_sp->SendEventData(event_data));
 1150   if (process_sp && process_sp->GetSystemRuntime()) {
 1151     SystemRuntime *runtime = process_sp->GetSystemRuntime();
 1162   if (process_sp && process_sp->GetSystemRuntime()) {
 1163     SystemRuntime *runtime = process_sp->GetSystemRuntime();
 1180     threads = SBThreadCollection(process_sp->GetHistoryThreads(addr));
 1195       process_sp->GetTarget().GetAPIMutex());
 1198       process_sp->GetInstrumentationRuntime(type);
 1203   return runtime_sp->IsActive();
 1218       process_sp->GetTarget().GetAPIMutex());
 1220   if (process_sp->GetState() != eStateStopped) {
 1241     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
 1243           process_sp->GetTarget().GetAPIMutex());
 1246           process_sp->GetMemoryRegionInfo(load_addr, sb_region_info.ref());
 1264   if (process_sp && stop_locker.TryLock(&process_sp->GetRunLock())) {
 1266         process_sp->GetTarget().GetAPIMutex());
 1268     process_sp->GetMemoryRegions(sb_region_list.ref());
 1280   if (process_sp && process_sp->GetProcessInfo(proc_info)) {

tools/lldb/source/API/SBQueue.cpp

   71       result = queue_sp->GetID();
   80       result = queue_sp->GetIndexID();
   89       name = queue_sp->GetName();
   99         if (stop_locker.TryLock(&queue_sp->GetProcess()->GetRunLock())) {
   99         if (stop_locker.TryLock(&queue_sp->GetProcess()->GetRunLock())) {
  100           const std::vector<ThreadSP> thread_list(queue_sp->GetThreads());
  105             if (thread_sp && thread_sp->IsValid()) {
  119         if (stop_locker.TryLock(&queue_sp->GetProcess()->GetRunLock())) {
  119         if (stop_locker.TryLock(&queue_sp->GetProcess()->GetRunLock())) {
  121               queue_sp->GetPendingItems());
  126             if (item && item->IsValid()) {
  151       ProcessSP process_sp = queue_sp->GetProcess();
  167       result = queue_sp->GetNumPendingWorkItems();
  187       result = queue_sp->GetNumRunningWorkItems();
  195       result.SetSP(queue_sp->GetProcess());
  204       kind = queue_sp->GetKind();
  255   return m_opaque_sp->IsValid();
  261   m_opaque_sp->Clear();
  265   m_opaque_sp->SetQueue(queue_sp);
  271   return m_opaque_sp->GetQueueID();
  277   uint32_t index_id = m_opaque_sp->GetIndexID();
  284   return m_opaque_sp->GetName();
  290   return m_opaque_sp->GetNumThreads();
  297   SBThread th = m_opaque_sp->GetThreadAtIndex(idx);
  304   return m_opaque_sp->GetNumPendingItems();
  311   return LLDB_RECORD_RESULT(m_opaque_sp->GetPendingItemAtIndex(idx));
  317   return m_opaque_sp->GetNumRunningItems();
  323   return LLDB_RECORD_RESULT(m_opaque_sp->GetProcess());
  329   return m_opaque_sp->GetKind();

tools/lldb/source/API/SBQueueItem.cpp

   65     result = m_queue_item_sp->GetKind();
   74     m_queue_item_sp->SetKind(kind);
   83     result.SetAddress(&m_queue_item_sp->GetAddress());
   92     m_queue_item_sp->SetAddress(addr.ref());
  102     ProcessSP process_sp = m_queue_item_sp->GetProcessSP();
  104     if (process_sp && stop_locker.TryLock(&process_sp->GetRunLock())) {
  107       thread_sp = m_queue_item_sp->GetExtendedBacktraceThread(type_const);
  111         process_sp->GetExtendedThreadList().AddThread(thread_sp);

tools/lldb/source/API/SBSection.cpp

   57   return section_sp && section_sp->GetModule().get() != nullptr;
   65     return section_sp->GetName().GetCString();
   75     SectionSP parent_section_sp(section_sp->GetParent());
   92           section_sp->GetChildren().FindSectionByName(const_sect_name));
  103     return section_sp->GetChildren().GetSize();
  114     sb_section.SetSP(section_sp->GetChildren().GetSectionAtIndex(idx));
  130     return section_sp->GetFileAddress();
  142       return section_sp->GetLoadBaseAddress(target_sp.get());
  152     return section_sp->GetByteSize();
  161     ModuleSP module_sp(section_sp->GetModule());
  163       ObjectFile *objfile = module_sp->GetObjectFile();
  165         return objfile->GetFileOffset() + section_sp->GetFileOffset();
  176     return section_sp->GetFileSize();
  193     const uint64_t sect_file_size = section_sp->GetFileSize();
  195       ModuleSP module_sp(section_sp->GetModule());
  197         ObjectFile *objfile = module_sp->GetObjectFile();
  200               objfile->GetFileOffset() + section_sp->GetFileOffset();
  204             file_size = section_sp->GetByteSize();
  212           if (data_buffer_sp && data_buffer_sp->GetByteSize() > 0) {
  231     return section_sp->GetType();
  240     return section_sp->GetPermissions();
  249     return section_sp->GetTargetByteSize();
  281     const addr_t file_addr = section_sp->GetFileAddress();
  283                 file_addr + section_sp->GetByteSize());
  284     section_sp->DumpName(&strm);

tools/lldb/source/API/SBSourceManager.cpp

   50       return target_sp->GetSourceManager().DisplaySourceLinesWithLineNumbers(
   56         return debugger_sp->GetSourceManager()

tools/lldb/source/API/SBStream.cpp

  124   if (!file_sp || !file_sp->IsValid())

tools/lldb/source/API/SBStructuredData.cpp

   70   if (!json_obj || json_obj->GetType() != eStructuredDataTypeDictionary)
  137   StructuredData::Dictionary *dict = obj_sp->GetAsDictionary();
  142   StructuredData::Array *key_arr = array_sp->GetAsArray();

tools/lldb/source/API/SBSymbol.cpp

  133       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
  135       target_sp->CalculateExecutionContext(exe_ctx);
  144             module_sp->GetArchitecture(), nullptr, flavor_string, exe_ctx,

tools/lldb/source/API/SBTarget.cpp

   83     const auto state = process_sp->GetState();
   84     if (process_sp->IsAlive() && state == eStateConnected) {
  173   return m_opaque_sp.get() != nullptr && m_opaque_sp->IsValid();
  183     process_sp = target_sp->GetProcessSP();
  198   platform.m_opaque_sp = target_sp->GetPlatform();
  209     debugger.reset(target_sp->GetDebugger().shared_from_this());
  223   for (auto &Entry : target_sp->GetStatistics()) {
  240   return target_sp->SetCollectingStats(v);
  249   return target_sp->GetCollectingStats();
  269     ProcessSP process_sp(target_sp->CreateProcess(
  270         target_sp->GetDebugger().GetListener(), "", &filespec));
  272       error.SetError(process_sp->LoadCore());
  308     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
  309     sb_error.ref() = target_sp->Install(nullptr);
  332     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
  341     process_sp = target_sp->GetProcessSP();
  343       state = process_sp->GetState();
  345       if (process_sp->IsAlive() && state != eStateConnected) {
  372     Module *exe_module = target_sp->GetExecutableModulePointer();
  383     error.SetError(target_sp->Launch(launch_info, nullptr));
  385     sb_process.SetSP(target_sp->GetProcessSP());
  403     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
  406       ProcessSP process_sp = target_sp->GetProcessSP();
  408         state = process_sp->GetState();
  410         if (process_sp->IsAlive() && state != eStateConnected) {
  423       Module *exe_module = target_sp->GetExecutableModulePointer();
  428     const ArchSpec &arch_spec = target_sp->GetArchitecture();
  432     error.SetError(target_sp->Launch(launch_info, nullptr));
  434     sb_process.SetSP(target_sp->GetProcessSP());
  453       PlatformSP platform_sp = target_sp->GetPlatform();
  455       if (platform_sp && platform_sp->IsConnected()) {
  458         if (platform_sp->GetProcessInfo(attach_pid, instance_info)) {
  469       sb_process.SetSP(target_sp->GetProcessSP());
  496     if (target_sp->GetPlatform()->GetProcessInfo(pid, instance_info))
  496     if (target_sp->GetPlatform()->GetProcessInfo(pid, instance_info))
  501       sb_process.SetSP(target_sp->GetProcessSP());
  530       sb_process.SetSP(target_sp->GetProcessSP());
  550     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
  553           target_sp->CreateProcess(listener.m_opaque_sp, plugin_name, nullptr);
  555       process_sp = target_sp->CreateProcess(
  556           target_sp->GetDebugger().GetListener(), plugin_name, nullptr);
  560       error.SetError(process_sp->ConnectRemote(nullptr, url));
  577     Module *exe_module = target_sp->GetExecutableModulePointer();
  613     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
  614     if (target_sp->ResolveLoadAddress(vm_addr, addr))
  632     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
  633     if (target_sp->ResolveFileAddress(file_addr, addr))
  650     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
  651     if (target_sp->ResolveLoadAddress(vm_addr, addr))
  673       target_sp->GetImages().ResolveSymbolContextForAddress(addr.ref(), scope,
  689     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
  691         target_sp->ReadMemory(addr.ref(), false, buf, size, sb_error.ref());
  753     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
  764     sb_bp = target_sp->CreateBreakpoint(
  780     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
  789       sb_bp = target_sp->CreateBreakpoint(
  793       sb_bp = target_sp->CreateBreakpoint(
  847     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
  849     sb_bp = target_sp->CreateBreakpoint(module_list.get(), comp_unit_list.get(),
  901     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
  906     sb_bp = target_sp->CreateBreakpoint(
  956     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
  962     sb_bp = target_sp->CreateFuncRegexBreakpoint(
  977     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
  979     sb_bp = target_sp->CreateBreakpoint(address, false, hardware);
  996     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
  998     sb_bp = target_sp->CreateBreakpoint(sb_address.ref(), false, hardware);
 1054     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 1063     sb_bp = target_sp->CreateSourceRegexBreakpoint(
 1081     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 1083     sb_bp = target_sp->CreateExceptionBreakpoint(language, catch_bp, throw_bp,
 1103     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 1108         target_sp->CreateScriptedBreakpoint(class_name,
 1126     return target_sp->GetBreakpointList().GetSize();
 1139     sb_breakpoint = target_sp->GetBreakpointList().GetBreakpointAtIndex(idx);
 1151     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 1152     result = target_sp->RemoveBreakpointByID(bp_id);
 1165     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 1166     sb_breakpoint = target_sp->GetBreakpointByID(bp_id);
 1179     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 1182         target_sp->GetBreakpointList().FindBreakpointsByName(name, bkpt_list);
 1186       bkpts.AppendByID(bkpt_sp->GetID());
 1200     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 1203     target_sp->GetBreakpointNames(name_vec);
 1215     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 1216     target_sp->DeleteBreakpointName(ConstString(name));
 1225     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 1226     target_sp->EnableAllowedBreakpoints();
 1237     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 1238     target_sp->DisableAllowedBreakpoints();
 1249     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 1250     target_sp->RemoveAllowedBreakpoints();
 1282   std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 1291   sberr.ref() = target_sp->CreateBreakpointsFromFile(source_file.ref(),
 1332   std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 1335   sberr.ref() = target_sp->SerializeBreakpointsToFile(dest_file.ref(),
 1346     return target_sp->GetWatchpointList().GetSize();
 1359     sb_watchpoint.SetSP(target_sp->GetWatchpointList().GetByIndex(idx));
 1372     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 1374     target_sp->GetWatchpointList().GetListMutex(lock);
 1375     result = target_sp->RemoveWatchpointByID(wp_id);
 1390     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 1392     target_sp->GetWatchpointList().GetListMutex(lock);
 1393     watchpoint_sp = target_sp->GetWatchpointList().FindByID(wp_id);
 1412     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 1429         target_sp->CreateWatchpoint(addr, size, type, watch_type, cw_error);
 1442     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 1444     target_sp->GetWatchpointList().GetListMutex(lock);
 1445     target_sp->EnableAllWatchpoints();
 1456     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 1458     target_sp->GetWatchpointList().GetListMutex(lock);
 1459     target_sp->DisableAllWatchpoints();
 1477     CompilerType ast_type(type.GetSP()->GetCompilerType(true));
 1497     CompilerType ast_type(type.GetSP()->GetCompilerType(true));
 1527     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 1529     target_sp->GetWatchpointList().GetListMutex(lock);
 1530     target_sp->RemoveAllWatchpoints();
 1552   target_sp->GetImageSearchPathList().Append(csFrom, csTo, true);
 1582           target_sp->GetPlatform().get(), triple);
 1584       module_spec.GetArchitecture() = target_sp->GetArchitecture();
 1589     sb_module.SetSP(target_sp->GetOrCreateModule(module_spec, true /* notify */));
 1601     sb_module.SetSP(target_sp->GetOrCreateModule(*module_spec.m_opaque_up, 
 1611     target_sp->GetImages().AppendIfNeeded(module.GetSP());
 1624     num = target_sp->GetImages().GetSize();
 1645     sb_module.SetSP(target_sp->GetImages().FindFirstModule(module_spec));
 1657     target_sp->GetImages().FindCompileUnits(*sb_file_spec, *sb_sc_list);
 1666     return target_sp->GetArchitecture().GetByteOrder();
 1675     std::string triple(target_sp->GetArchitecture().GetTriple().str());
 1690     return target_sp->GetArchitecture().GetDataByteSize();
 1700     return target_sp->GetArchitecture().GetCodeByteSize();
 1710     return target_sp->GetArchitecture().GetAddressByteSize();
 1723     module_sp = target_sp->GetImages().GetModuleAtIndex(idx);
 1735     return target_sp->GetImages().Remove(module.GetSP());
 1761     target_sp->Dump(&strm, description_level);
 1784   target_sp->GetImages().FindFunctions(ConstString(name), mask, symbols_ok,
 1804         target_sp->GetImages().FindFunctions(RegularExpression(name_ref), true,
 1809         target_sp->GetImages().FindFunctions(RegularExpression(regexstr), true,
 1813         target_sp->GetImages().FindFunctions(
 1832     const ModuleList &module_list = target_sp->GetImages();
 1838             module_sp->FindFirstType(sc, const_typename, exact_match));
 1845     if (auto process_sp = target_sp->GetProcessSP()) {
 1846       for (auto *runtime : process_sp->GetLanguageRuntimes()) {
 1856     for (auto *type_system : target_sp->GetScratchTypeSystems())
 1870     for (auto *type_system : target_sp->GetScratchTypeSystems())
 1884     ModuleList &images = target_sp->GetImages();
 1899     if (auto process_sp = target_sp->GetProcessSP()) {
 1900       for (auto *runtime : process_sp->GetLanguageRuntimes()) {
 1912       for (auto *type_system : target_sp->GetScratchTypeSystems())
 1931     target_sp->GetImages().FindGlobalVariables(ConstString(name), max_matches,
 1935       ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get();
 1968       target_sp->GetImages().FindGlobalVariables(ConstString(name), max_matches,
 1972       target_sp->GetImages().FindGlobalVariables(RegularExpression(name_ref),
 1977       target_sp->GetImages().FindGlobalVariables(RegularExpression(regexstr),
 1983       ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get();
 2038           target_sp->GetArchitecture().GetMaximumOpcodeByteSize() * count, 0);
 2043           target_sp->ReadMemory(*addr_ptr, prefer_file_cache, data.GetBytes(),
 2047           target_sp->GetArchitecture(), nullptr, flavor_string, *addr_ptr,
 2086         target_sp->GetArchitecture(), nullptr, flavor_string, addr, buf, size,
 2130         if (section_sp->IsThreadSpecific()) {
 2134           ProcessSP process_sp(target_sp->GetProcessSP());
 2135           if (target_sp->SetSectionLoadAddress(section_sp, section_base_addr)) {
 2136             ModuleSP module_sp(section_sp->GetModule());
 2140               target_sp->ModulesDidLoad(module_list);
 2144               process_sp->Flush();
 2168         ProcessSP process_sp(target_sp->GetProcessSP());
 2169         if (target_sp->SetSectionUnloaded(section_sp)) {
 2170           ModuleSP module_sp(section_sp->GetModule());
 2174             target_sp->ModulesDidUnload(module_list, false);
 2178             process_sp->Flush();
 2202       if (module_sp->SetLoadAddress(*target_sp, slide_offset, true, changed)) {
 2208           target_sp->ModulesDidLoad(module_list);
 2210           ProcessSP process_sp(target_sp->GetProcessSP());
 2212             process_sp->Flush();
 2236       ObjectFile *objfile = module_sp->GetObjectFile();
 2240           ProcessSP process_sp(target_sp->GetProcessSP());
 2247               changed |= target_sp->SetSectionUnloaded(section_sp);
 2252             target_sp->ModulesDidUnload(module_list, false);
 2254             ProcessSP process_sp(target_sp->GetProcessSP());
 2256               process_sp->Flush();
 2259           module_sp->GetFileSpec().GetPath(path, sizeof(path));
 2264         module_sp->GetFileSpec().GetPath(path, sizeof(path));
 2286       target_sp->GetImages().FindSymbolsWithNameAndType(
 2302       target_sp->GetPreferDynamicValue();
 2324     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 2360     ProcessSP process_sp(target_sp->GetProcessSP());
 2362       abi_sp = process_sp->GetABI();
 2364       abi_sp = ABI::FindPlugin(ProcessSP(), target_sp->GetArchitecture());
 2366       return abi_sp->GetRedZoneSize();
 2377     launch_info.set_ref(m_opaque_sp->GetProcessLaunchInfo());
 2387     m_opaque_sp->SetProcessLaunchInfo(launch_info.ref());

tools/lldb/source/API/SBThread.cpp

  127       return m_opaque_sp->GetThreadSP().get() != nullptr;
  136   m_opaque_sp->Clear();
  167         StopReason reason = stop_info_sp->GetStopReason();
  180           break_id_t site_id = stop_info_sp->GetValue();
  185             return bp_site_sp->GetNumberOfOwners() * 2;
  218         StopReason reason = stop_info_sp->GetStopReason();
  231           break_id_t site_id = stop_info_sp->GetValue();
  238                 bp_site_sp->GetOwnerAtIndex(bp_index));
  242                 return bp_loc_sp->GetID();
  245                 return bp_loc_sp->GetBreakpoint().GetID();
  253           return stop_info_sp->GetValue();
  256           return stop_info_sp->GetValue();
  259           return stop_info_sp->GetValue();
  280   StructuredData::ObjectSP info = stop_info->GetExtendedInfo();
  284   info->Dump(strm);
  307   StructuredData::ObjectSP info = stop_info->GetExtendedInfo();
  311   return LLDB_RECORD_RESULT(process_sp->GetInstrumentationRuntime(type)
  312                                 ->GetBacktracesFromExtendedStopInfo(info));
  328         const char *stop_desc = stop_info_sp->GetDescription();
  339           switch (stop_info_sp->GetStopReason()) {
  362                 exe_ctx.GetProcessPtr()->GetUnixSignals()->GetSignalAsCString(
  363                     stop_info_sp->GetValue());
  433   m_opaque_sp->SetThreadSP(lldb_object_sp);
  439   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
  441     return thread_sp->GetID();
  448   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
  450     return thread_sp->GetIndexID();
  520             info_root_sp->GetObjectForDotSeparatedPath(path);
  522           if (node->GetType() == eStructuredDataTypeString) {
  523             strm.Printf("%s", node->GetAsString()->GetValue().str().c_str());
  526           if (node->GetType() == eStructuredDataTypeInteger) {
  527             strm.Printf("0x%" PRIx64, node->GetAsInteger()->GetValue());
  530           if (node->GetType() == eStructuredDataTypeFloat) {
  531             strm.Printf("0x%f", node->GetAsFloat()->GetValue());
  534           if (node->GetType() == eStructuredDataTypeBoolean) {
  535             if (node->GetAsBoolean()->GetValue())
  541           if (node->GetType() == eStructuredDataTypeNull) {
  614     if (frame_sp->HasDebugInformation()) {
  616       SymbolContext sc(frame_sp->GetSymbolContext(eSymbolContextEverything));
  666   if (frame_sp && frame_sp->HasDebugInformation()) {
  667     SymbolContext sc(frame_sp->GetSymbolContext(eSymbolContextEverything));
  769       eVoteNoOpinion, frame_sp->GetFrameIndex(), new_plan_status));
  879     frame_sc = frame_sp->GetSymbolContext(
  885           "frame %u doesn't have debug information", frame_sp->GetFrameIndex());
  948           frame_sp->GetFrameIndex(), new_plan_status));
 1280   return m_opaque_sp->GetThreadSP().get() ==
 1281          rhs.m_opaque_sp->GetThreadSP().get();
 1288   return m_opaque_sp->GetThreadSP().get() !=
 1289          rhs.m_opaque_sp->GetThreadSP().get();
 1376   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
 1378     return thread_sp->GetExtendedBacktraceOriginatingIndexID();
 1385   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
 1389   return LLDB_RECORD_RESULT(SBValue(thread_sp->GetCurrentException()));
 1396   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
 1401       SBThread(thread_sp->GetCurrentExceptionBacktrace()));
 1407   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
 1409     return thread_sp->SafeToCallFunctions();
 1418   return m_opaque_sp->GetThreadSP().get();

tools/lldb/source/API/SBThreadCollection.cpp

   52   return m_opaque_sp.operator->();
   77     return m_opaque_sp->GetSize();
   86   if (m_opaque_sp && idx < m_opaque_sp->GetSize())
   87     thread = m_opaque_sp->GetThreadAtIndex(idx);

tools/lldb/source/API/SBThreadPlan.cpp

  143         SBThread(m_opaque_sp->GetThread().shared_from_this()));
  153     m_opaque_sp->GetDescription(description.get(), eDescriptionLevelFull);
  168     m_opaque_sp->SetPlanComplete(success);
  175     return m_opaque_sp->IsPlanComplete();
  184     return m_opaque_sp->IsPlanStale();
  193     return m_opaque_sp->ValidatePlan(nullptr);
  235         SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepOverRange(
  279         SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepInRange(
  313     sc = m_opaque_sp->GetThread().GetStackFrameAtIndex(0)->GetSymbolContext(
  313     sc = m_opaque_sp->GetThread().GetStackFrameAtIndex(0)->GetSymbolContext(
  318         SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepOut(
  354         SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForRunToAddress(
  388         SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepScripted(
  413         SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepScripted(

tools/lldb/source/API/SBTrace.cpp

   41         process_sp->GetData(GetTraceUID(), thread_id, buffer, offset));
   60         process_sp->GetMetaData(GetTraceUID(), thread_id, buffer, offset));
   76   error.SetError(process_sp->StopTrace(GetTraceUID(), thread_id));
   89     error.SetError(process_sp->GetTraceConfig(GetTraceUID(),
   98     return m_trace_impl_sp->uid;
  104     m_trace_impl_sp->uid = uid;
  112     m_trace_impl_sp->uid = LLDB_INVALID_UID;

tools/lldb/source/API/SBTraceOptions.cpp

   32     return m_traceoptions_sp->getType();
   41     return m_traceoptions_sp->getTraceBufferSize();
   51       m_traceoptions_sp->getTraceParams();
   54     structData.m_impl_up->SetObjectSP(dict_obj->shared_from_this());
   65     return m_traceoptions_sp->getTraceBufferSize();
   75     if (obj_sp && obj_sp->GetAsDictionary() != nullptr)
   76       m_traceoptions_sp->setTraceParams(
   86     m_traceoptions_sp->setType(type);
   94     m_traceoptions_sp->setTraceBufferSize(size);
  102     m_traceoptions_sp->setMetaDataBufferSize(size);
  122     m_traceoptions_sp->setThreadID(thread_id);
  129     return m_traceoptions_sp->getThreadID();

tools/lldb/source/API/SBType.cpp

  118   return m_opaque_sp->IsValid();
  126             m_opaque_sp->GetCompilerType(false).GetByteSize(nullptr))
  136   return m_opaque_sp->GetCompilerType(true).IsPointerType();
  144   return m_opaque_sp->GetCompilerType(true).IsArrayType(nullptr, nullptr,
  153   return m_opaque_sp->GetCompilerType(true).IsVectorType(nullptr, nullptr);
  161   return m_opaque_sp->GetCompilerType(true).IsReferenceType();
  171       SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointerType()))));
  180       SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointeeType()))));
  189       SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetReferenceType()))));
  198       SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetTypedefedType()))));
  207       SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetDereferencedType()))));
  216       new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayElementType()))));
  225       new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayType(size)))));
  234     if (m_opaque_sp->GetCompilerType(true).IsVectorType(&vector_element_type,
  246   return m_opaque_sp->GetCompilerType(true).IsFunctionType();
  254   return m_opaque_sp->GetCompilerType(true).IsPolymorphicClass();
  262   return m_opaque_sp->GetCompilerType(true).IsTypedefType();
  270   return m_opaque_sp->GetCompilerType(true).IsAnonymousType();
  278         m_opaque_sp->GetCompilerType(true).GetFunctionReturnType());
  291     CompilerType func_type(m_opaque_sp->GetCompilerType(true));
  304     return m_opaque_sp->GetCompilerType(true).GetNumMemberFunctions();
  316         m_opaque_sp->GetCompilerType(true).GetMemberFunctionAtIndex(idx)));
  326       SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetUnqualifiedType()))));
  334         SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetCanonicalType()))));
  342     return m_opaque_sp->GetCompilerType(false).GetBasicTypeEnumeration();
  350   if (IsValid() && m_opaque_sp->IsValid())
  352         m_opaque_sp->GetTypeSystem(false)->GetBasicTypeFromAST(basic_type)));
  360     return m_opaque_sp->GetCompilerType(true).GetNumDirectBaseClasses();
  368     return m_opaque_sp->GetCompilerType(true).GetNumVirtualBaseClasses();
  376     return m_opaque_sp->GetCompilerType(true).GetNumFields();
  389     m_opaque_sp->GetDescription(strm, description_level);
  404         m_opaque_sp->GetCompilerType(true).GetDirectBaseClassAtIndex(
  421         m_opaque_sp->GetCompilerType(true).GetVirtualBaseClassAtIndex(
  436     CompilerType this_type(m_opaque_sp->GetCompilerType(true));
  459     CompilerType this_type(m_opaque_sp->GetCompilerType(false));
  485   return m_opaque_sp->GetCompilerType(false).IsCompleteType();
  493   return m_opaque_sp->GetCompilerType(true).GetTypeInfo();
  501   return m_opaque_sp->GetName().GetCString();
  509   return m_opaque_sp->GetDisplayTypeName().GetCString();
  516     return m_opaque_sp->GetCompilerType(true).GetTypeClass();
  524     return m_opaque_sp->GetCompilerType(false).GetNumTemplateArguments();
  538       type = m_opaque_sp->GetCompilerType(false).GetTypeTemplateArgument(idx);
  541       type = m_opaque_sp->GetCompilerType(false)
  558     return m_opaque_sp->GetCompilerType(false).GetTemplateArgumentKind(idx);
  728       type_impl_sp->GetDescription(strm, description_level);
  791     return m_opaque_sp->GetName().GetCString();
  800     ConstString mangled_str = m_opaque_sp->GetMangledName();
  814     return m_opaque_sp->GetMangledName().GetCString();
  823     sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetType())));
  833     sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetReturnType())));
  843     return m_opaque_sp->GetNumArguments();
  854         lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetArgumentAtIndex(i))));
  864     return m_opaque_sp->GetKind();
  877     return m_opaque_sp->GetDescription(strm);

tools/lldb/source/API/SBTypeCategory.cpp

   60   return m_opaque_sp->IsEnabled();
   79   return m_opaque_sp->GetName();
   87     return m_opaque_sp->GetLanguageAtIndex(idx);
   95     return m_opaque_sp->GetNumLanguages();
  104     m_opaque_sp->AddLanguage(language);
  113   return m_opaque_sp->GetTypeFormatsContainer()->GetCount() +
  113   return m_opaque_sp->GetTypeFormatsContainer()->GetCount() +
  114          m_opaque_sp->GetRegexTypeFormatsContainer()->GetCount();
  114          m_opaque_sp->GetRegexTypeFormatsContainer()->GetCount();
  122   return m_opaque_sp->GetTypeSummariesContainer()->GetCount() +
  122   return m_opaque_sp->GetTypeSummariesContainer()->GetCount() +
  123          m_opaque_sp->GetRegexTypeSummariesContainer()->GetCount();
  123          m_opaque_sp->GetRegexTypeSummariesContainer()->GetCount();
  131   return m_opaque_sp->GetTypeFiltersContainer()->GetCount() +
  131   return m_opaque_sp->GetTypeFiltersContainer()->GetCount() +
  132          m_opaque_sp->GetRegexTypeFiltersContainer()->GetCount();
  132          m_opaque_sp->GetRegexTypeFiltersContainer()->GetCount();
  140   return m_opaque_sp->GetTypeSyntheticsContainer()->GetCount() +
  140   return m_opaque_sp->GetTypeSyntheticsContainer()->GetCount() +
  141          m_opaque_sp->GetRegexTypeSyntheticsContainer()->GetCount();
  141          m_opaque_sp->GetRegexTypeSyntheticsContainer()->GetCount();
  152       m_opaque_sp->GetTypeNameSpecifierForFilterAtIndex(index)));
  163       m_opaque_sp->GetTypeNameSpecifierForFormatAtIndex(index)));
  174       m_opaque_sp->GetTypeNameSpecifierForSummaryAtIndex(index)));
  186       m_opaque_sp->GetTypeNameSpecifierForSyntheticAtIndex(index)));
  202     m_opaque_sp->GetRegexTypeFiltersContainer()->GetExact(
  202     m_opaque_sp->GetRegexTypeFiltersContainer()->GetExact(
  205     m_opaque_sp->GetTypeFiltersContainer()->GetExact(
  205     m_opaque_sp->GetTypeFiltersContainer()->GetExact(
  229     m_opaque_sp->GetRegexTypeFormatsContainer()->GetExact(
  229     m_opaque_sp->GetRegexTypeFormatsContainer()->GetExact(
  232     m_opaque_sp->GetTypeFormatsContainer()->GetExact(
  232     m_opaque_sp->GetTypeFormatsContainer()->GetExact(
  254     m_opaque_sp->GetRegexTypeSummariesContainer()->GetExact(
  254     m_opaque_sp->GetRegexTypeSummariesContainer()->GetExact(
  257     m_opaque_sp->GetTypeSummariesContainer()->GetExact(
  257     m_opaque_sp->GetTypeSummariesContainer()->GetExact(
  279     m_opaque_sp->GetRegexTypeSyntheticsContainer()->GetExact(
  279     m_opaque_sp->GetRegexTypeSyntheticsContainer()->GetExact(
  282     m_opaque_sp->GetTypeSyntheticsContainer()->GetExact(
  282     m_opaque_sp->GetTypeSyntheticsContainer()->GetExact(
  301       m_opaque_sp->GetSyntheticAtIndex((index));
  319       SBTypeFormat(m_opaque_sp->GetFormatAtIndex((index))));
  329       SBTypeSummary(m_opaque_sp->GetSummaryAtIndex((index))));
  339       m_opaque_sp->GetSyntheticAtIndex((index));
  366     m_opaque_sp->GetRegexTypeFormatsContainer()->Add(
  366     m_opaque_sp->GetRegexTypeFormatsContainer()->Add(
  371     m_opaque_sp->GetTypeFormatsContainer()->Add(
  371     m_opaque_sp->GetTypeFormatsContainer()->Add(
  388     return m_opaque_sp->GetRegexTypeFormatsContainer()->Delete(
  388     return m_opaque_sp->GetRegexTypeFormatsContainer()->Delete(
  391     return m_opaque_sp->GetTypeFormatsContainer()->Delete(
  391     return m_opaque_sp->GetTypeFormatsContainer()->Delete(
  428             debugger_sp->GetScriptInterpreter();
  445     m_opaque_sp->GetRegexTypeSummariesContainer()->Add(
  445     m_opaque_sp->GetRegexTypeSummariesContainer()->Add(
  450     m_opaque_sp->GetTypeSummariesContainer()->Add(
  450     m_opaque_sp->GetTypeSummariesContainer()->Add(
  467     return m_opaque_sp->GetRegexTypeSummariesContainer()->Delete(
  467     return m_opaque_sp->GetRegexTypeSummariesContainer()->Delete(
  470     return m_opaque_sp->GetTypeSummariesContainer()->Delete(
  470     return m_opaque_sp->GetTypeSummariesContainer()->Delete(
  490     m_opaque_sp->GetRegexTypeFiltersContainer()->Add(
  490     m_opaque_sp->GetRegexTypeFiltersContainer()->Add(
  495     m_opaque_sp->GetTypeFiltersContainer()->Add(
  495     m_opaque_sp->GetTypeFiltersContainer()->Add(
  512     return m_opaque_sp->GetRegexTypeFiltersContainer()->Delete(
  512     return m_opaque_sp->GetRegexTypeFiltersContainer()->Delete(
  515     return m_opaque_sp->GetTypeFiltersContainer()->Delete(
  515     return m_opaque_sp->GetTypeFiltersContainer()->Delete(
  552             debugger_sp->GetScriptInterpreter();
  569     m_opaque_sp->GetRegexTypeSyntheticsContainer()->Add(
  569     m_opaque_sp->GetRegexTypeSyntheticsContainer()->Add(
  574     m_opaque_sp->GetTypeSyntheticsContainer()->Add(
  574     m_opaque_sp->GetTypeSyntheticsContainer()->Add(
  591     return m_opaque_sp->GetRegexTypeSyntheticsContainer()->Delete(
  591     return m_opaque_sp->GetRegexTypeSyntheticsContainer()->Delete(
  594     return m_opaque_sp->GetTypeSyntheticsContainer()->Delete(
  594     return m_opaque_sp->GetTypeSyntheticsContainer()->Delete(
  661   return (strcmp(m_opaque_sp->GetName(), "default") == 0);

tools/lldb/source/API/SBTypeEnumMember.cpp

   66     return m_opaque_sp->GetName().GetCString();
   74     return m_opaque_sp->GetValueAsSigned();
   82     return m_opaque_sp->GetValueAsUnsigned();
   91     sb_type.SetSP(m_opaque_sp->GetIntegerType());
  190     if (m_opaque_sp->GetIntegerType()->GetDescription(strm,
  190     if (m_opaque_sp->GetIntegerType()->GetDescription(strm,
  192       strm.Printf(" %s", m_opaque_sp->GetName().GetCString());

tools/lldb/source/API/SBTypeFilter.cpp

   50     return m_opaque_sp->GetOptions();
   58     m_opaque_sp->SetOptions(value);
   70     description.Printf("%s\n", m_opaque_sp->GetDescription().c_str());
   79     m_opaque_sp->Clear();
   87     return m_opaque_sp->GetCount();
   96     const char *item = m_opaque_sp->GetExpressionPathAtIndex(i);
  109     return m_opaque_sp->SetExpressionPathAtIndex(i, item);
  119     m_opaque_sp->AddExpressionPath(item);
  188     new_sp->AddExpressionPath(GetExpressionPathAtIndex(j));

tools/lldb/source/API/SBTypeFormat.cpp

   58   if (IsValid() && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeFormat)
   66   if (IsValid() && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeEnum)
   77     return m_opaque_sp->GetOptions();
  100     m_opaque_sp->SetOptions(value);
  112     description.Printf("%s\n", m_opaque_sp->GetDescription().c_str());
  174         m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeFormat) ||
  176         m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeEnum)))
  180     if (m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeFormat)

tools/lldb/source/API/SBTypeNameSpecifier.cpp

   39         new TypeNameSpecifierImpl(type.m_opaque_sp->GetCompilerType(true)));
   66   return m_opaque_sp->GetName();
   74   lldb_private::CompilerType c_type = m_opaque_sp->GetCompilerType();
   86   return m_opaque_sp->IsRegex();

tools/lldb/source/API/SBTypeSummary.cpp

  240   return m_opaque_sp->GetKind() == TypeSummaryImpl::Kind::eSummaryString;
  266   return m_opaque_sp->GetOptions();
  274   m_opaque_sp->SetOptions(value);
  325     description.Printf("%s\n", m_opaque_sp->GetDescription().c_str());
  337   return m_opaque_sp->DoesPrintValue(value_sp.get());
  377   if (m_opaque_sp->GetKind() != rhs.m_opaque_sp->GetKind())
  377   if (m_opaque_sp->GetKind() != rhs.m_opaque_sp->GetKind())
  380   switch (m_opaque_sp->GetKind()) {
  456       (m_opaque_sp->GetKind() == TypeSummaryImpl::Kind::eScript)) {
  457     if (m_opaque_sp->GetKind() ==

tools/lldb/source/API/SBTypeSynthetic.cpp

   71   const char *code = m_opaque_sp->GetPythonCode();
   89     return m_opaque_sp->GetPythonCode();
   91     return m_opaque_sp->GetPythonClassName();
   98     m_opaque_sp->SetPythonClassName(data);
  105     m_opaque_sp->SetPythonCode(data);
  113   return m_opaque_sp->GetOptions();
  121   m_opaque_sp->SetOptions(value);
  131     description.Printf("%s\n", m_opaque_sp->GetDescription().c_str());
  165   if (m_opaque_sp->IsScripted() != rhs.m_opaque_sp->IsScripted())
  165   if (m_opaque_sp->IsScripted() != rhs.m_opaque_sp->IsScripted())
  206       m_opaque_sp->GetOptions(), m_opaque_sp->GetPythonClassName(),
  206       m_opaque_sp->GetOptions(), m_opaque_sp->GetPythonClassName(),
  207       m_opaque_sp->GetPythonCode()));

tools/lldb/source/API/SBUnixSignals.cpp

   31     : m_opaque_wp(process_sp ? process_sp->GetUnixSignals() : nullptr) {}
   34     : m_opaque_wp(platform_sp ? platform_sp->GetUnixSignals() : nullptr) {}
   75     return signals_sp->GetSignalAsCString(signo);
   85     return signals_sp->GetSignalNumberFromName(name);
   95     return signals_sp->GetShouldSuppress(signo);
  107     return signals_sp->SetShouldSuppress(signo, value);
  117     return signals_sp->GetShouldStop(signo);
  129     return signals_sp->SetShouldStop(signo, value);
  139     return signals_sp->GetShouldNotify(signo);
  151     return signals_sp->SetShouldNotify(signo, value);
  160     return signals_sp->GetNumSignals();
  170     return signals_sp->GetSignalAtIndex(index);

tools/lldb/source/API/SBValue.cpp

  102       return target_sp && target_sp->IsValid();
  125     if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) {
  254   return m_opaque_sp.get() != nullptr && m_opaque_sp->IsValid() &&
  255          m_opaque_sp->GetRootSP().get() != nullptr;
  551       if (synthetic_sp && !synthetic_sp->IsScripted()) {
  571       if (children_sp && children_sp->IsScripted()) {
  595                          offset, type_sp->GetCompilerType(false), true),
  610     sb_value.SetSP(value_sp->Cast(type_sp->GetCompilerType(false)),
  661     CompilerType ast_type(type_impl_sp->GetCompilerType(true));
  684         name, **data, exe_ctx, type_impl_sp->GetCompilerType(true));
  698     target_sp = m_opaque_sp->GetTargetSP();
  701     use_dynamic = target_sp->GetPreferDynamicValue();
  752     target_sp = m_opaque_sp->GetTargetSP();
  755     use_dynamic_value = target_sp->GetPreferDynamicValue();
  787     ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(), use_dynamic,
  788                                        m_opaque_sp->GetUseSynthetic()));
  799     ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),
  801                                        m_opaque_sp->GetUseSynthetic()));
  812     ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),
  813                                        m_opaque_sp->GetUseDynamic(), false));
  825   return m_opaque_sp->GetUseDynamic();
  833     return m_opaque_sp->SetUseDynamic(use_dynamic);
  841   return m_opaque_sp->GetUseSynthetic();
  849     return m_opaque_sp->SetUseSynthetic(use_synthetic);
 1054     target_sp = m_opaque_sp->GetTargetSP();
 1067     process_sp = m_opaque_sp->GetProcessSP();
 1080     thread_sp = m_opaque_sp->GetThreadSP();
 1093     frame_sp = m_opaque_sp->GetFrameSP();
 1101   if (!m_opaque_sp || !m_opaque_sp->IsValid()) {
 1121       lldb::DynamicValueType use_dynamic = target_sp->GetPreferDynamicValue();
 1123           target_sp->TargetProperties::GetEnableSyntheticValue();
 1137           target_sp->TargetProperties::GetEnableSyntheticValue();
 1149       lldb::DynamicValueType use_dynamic = target_sp->GetPreferDynamicValue();
 1210   options.SetFetchDynamicValue(target_sp->GetPreferDynamicValue());
 1252   std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 1261   target_sp->EvaluateExpression(expr, frame, res_val_sp, options.ref(), nullptr,
 1340           module_sp->ResolveFileAddress(value, addr);
 1368           module_sp->ResolveFileAddress(value, addr);
 1393       if (data_sp->GetByteSize() > 0)
 1504         target_sp->CreateWatchpoint(addr, byte_size, &type, watch_type, rc);
 1515           watchpoint_sp->SetDeclInfo(ss.GetString());

tools/lldb/source/API/SBVariablesOptions.cpp

   42     return target_sp ? target_sp->GetDisplayRecognizedArguments() : false;

tools/lldb/source/API/SBWatchpoint.cpp

   58     watch_id = watchpoint_sp->GetID();
   93     sb_error.SetError(watchpoint_sp->GetError());
  106         watchpoint_sp->GetTarget().GetAPIMutex());
  107     hw_index = watchpoint_sp->GetHardwareIndex();
  121         watchpoint_sp->GetTarget().GetAPIMutex());
  122     ret_addr = watchpoint_sp->GetLoadAddress();
  136         watchpoint_sp->GetTarget().GetAPIMutex());
  137     watch_size = watchpoint_sp->GetByteSize();
  148     Target &target = watchpoint_sp->GetTarget();
  154         process_sp->EnableWatchpoint(watchpoint_sp.get(), notify);
  156         process_sp->DisableWatchpoint(watchpoint_sp.get(), notify);
  158       watchpoint_sp->SetEnabled(enabled, notify);
  169         watchpoint_sp->GetTarget().GetAPIMutex());
  170     return watchpoint_sp->IsEnabled();
  182         watchpoint_sp->GetTarget().GetAPIMutex());
  183     count = watchpoint_sp->GetHitCount();
  195         watchpoint_sp->GetTarget().GetAPIMutex());
  196     return watchpoint_sp->GetIgnoreCount();
  207         watchpoint_sp->GetTarget().GetAPIMutex());
  208     watchpoint_sp->SetIgnoreCount(n);
  218         watchpoint_sp->GetTarget().GetAPIMutex());
  219     return watchpoint_sp->GetConditionText();
  231         watchpoint_sp->GetTarget().GetAPIMutex());
  232     watchpoint_sp->SetCondition(condition);
  247         watchpoint_sp->GetTarget().GetAPIMutex());
  248     watchpoint_sp->GetDescription(&strm, level);

tools/lldb/source/Breakpoint/Breakpoint.cpp

   66   m_resolver_sp = source_bp.m_resolver_sp->CopyForBreakpoint(*this);
   67   m_filter_sp = source_bp.m_filter_sp->CopyForBreakpoint(*this);
   84       names_array_sp->AddItem(
   87     breakpoint_contents_sp->AddItem(Breakpoint::GetKey(OptionNames::Names),
   91   breakpoint_contents_sp->AddBooleanItem(
   95       m_resolver_sp->SerializeToStructuredData());
   99   breakpoint_contents_sp->AddItem(BreakpointResolver::GetSerializationKey(),
  103       m_filter_sp->SerializeToStructuredData());
  107   breakpoint_contents_sp->AddItem(SearchFilter::GetSerializationKey(),
  115   breakpoint_contents_sp->AddItem(BreakpointOptions::GetSerializationKey(),
  118   breakpoint_dict_sp->AddItem(GetSerializationKey(), breakpoint_contents_sp);
  126   StructuredData::Dictionary *breakpoint_dict = object_data->GetAsDictionary();
  194     result_sp->m_options_up = std::move(options_up);
  218   StructuredData::Dictionary *bkpt_dict = bkpt_object_sp->GetAsDictionary();
  455     m_resolver_sp->ResolveBreakpoint(*m_filter_sp);
  462   m_resolver_sp->ResolveBreakpointInModules(*m_filter_sp, module_list);
  485       m_resolver_sp->ResolveBreakpointInModules(*m_filter_sp, module_list);
  523       if (!m_filter_sp->ModulePasses(module_sp))
  533         Address section_addr(break_loc_sp->GetAddress());
  539         if (!break_loc_sp->IsEnabled())
  548         if (section_sp && section_sp->GetModule() == module_sp) {
  552           if (!break_loc_sp->ResolveBreakpointSite()) {
  556                       break_loc_sp->GetID(), GetID());
  588       if (m_filter_sp->ModulePasses(module_sp)) {
  594           SectionSP section_sp(break_loc_sp->GetAddress().GetSection());
  595           if (section_sp && section_sp->GetModule() == module_sp) {
  599             break_loc_sp->ClearBreakpointSite();
  663             old_module_sp->GetSpecificationDescription().c_str());
  668     SectionSP section_sp = break_loc_sp->GetAddress().GetSection();
  669     if (section_sp && section_sp->GetModule() == old_module_sp) {
  712         if (old_loc_sp->GetAddress().CalculateSymbolContext(&old_sc) ==
  713             new_loc_sp->GetAddress().CalculateSymbolContext(&new_sc)) {
  733           lldb::break_id_t loc_id = bp_loc_sp->GetID();
  734           bp_loc_sp->GetAddress().CalculateSymbolContext(&old_sc_map[loc_id]);
  741           lldb::break_id_t loc_id = bp_loc_sp->GetID();
  742           bp_loc_sp->GetAddress().CalculateSymbolContext(&new_sc_map[loc_id]);
  895       if (m_resolver_sp->getResolverID() !=
  903       m_precondition_sp->GetDescription(*s, level);
  930       GetLocationAtIndex(0)->GetDescription(s, level);
  964     m_resolver_sp->GetDescription(s);
  988   m_filter_sp->GetDescription(s);
  995   return m_precondition_sp->EvaluatePrecondition(context);

tools/lldb/source/Breakpoint/BreakpointIDList.cpp

  176           const size_t num_locations = breakpoint_sp->GetNumLocations();
  179                 breakpoint_sp->GetLocationAtIndex(j).get();
  316           if (bkpt_sp->MatchesName(name.c_str())) {
  319                 &canonical_id_str, bkpt_sp->GetID(), LLDB_INVALID_BREAK_ID);

tools/lldb/source/Breakpoint/BreakpointList.cpp

   17   Target &target = bp->GetTarget();
   33   bp_sp->SetID(m_is_internal ? --m_next_break_id : ++m_next_break_id);
   40   return bp_sp->GetID();
   48       [&](const BreakpointSP &bp) { return bp->GetID() == break_id; });
   64     bp_sp->RemoveInvalidLocations(arch);
   70     bp_sp->SetEnabled(enabled);
   76     if (bp_sp->AllowDisable())
   77       bp_sp->SetEnabled(enabled);
   96     if (bp_sp->AllowDelete())
   97       bp_sp->ClearAllBreakpointSites();
  104                      [&](const BreakpointSP &bp) { return bp->AllowDelete(); }),
  112       [&](const BreakpointSP &bp) { return bp->GetID() == break_id; });
  119       [&](const BreakpointSP &bp) { return bp->GetID() == break_id; });
  141     if (bkpt_sp->MatchesName(name)) {
  157     bp_sp->Dump(s);
  172     bp_sp->ModulesChanged(module_list, added, delete_locations);
  179     bp_sp->ModuleReplaced(old_module_sp, new_module_sp);
  185     bp_sp->ClearAllBreakpointSites();

tools/lldb/source/Breakpoint/BreakpointLocation.cpp

  248       !m_user_expression_sp->MatchesContext(exe_ctx)) {
  266     if (!m_user_expression_sp->Parse(diagnostics, exe_ctx,
  297   ExpressionResults result_code = m_user_expression_sp->Execute(
  308     result_value_sp = result_variable_sp->GetValueObject();
  475       process_sp->RemoveOwnerFromBreakpointSite(GetBreakpoint().GetID(),
  478       m_bp_site_sp->RemoveOwner(GetBreakpoint().GetID(), GetID());
  522         sc.module_sp->GetFileSpec().Dump(s);
  582     resolved_address.SetLoadAddress(m_bp_site_sp->GetLoadAddress(), target);
  653   m_address = swap_from->m_address;
  655       swap_from->m_should_resolve_indirect_functions;
  656   m_is_reexported = swap_from->m_is_reexported;
  657   m_is_indirect = swap_from->m_is_indirect;

tools/lldb/source/Breakpoint/BreakpointLocationCollection.cpp

   29       FindByIDPair(bp_loc->GetBreakpoint().GetID(), bp_loc->GetID());
   29       FindByIDPair(bp_loc->GetBreakpoint().GetID(), bp_loc->GetID());
   52     return m_break_id == bp_loc->GetBreakpoint().GetID() &&
   53            m_break_loc_id == bp_loc->GetID();
  127     if (GetByIndex(i)->ShouldStop(context))
  143     if ((*pos)->ValidForThisThread(thread))
  157     if (!(*pos)->GetBreakpoint().IsInternal()) {
  174     (*pos)->GetDescription(s, level);

tools/lldb/source/Breakpoint/BreakpointLocationList.cpp

   49     return bp->ShouldStop(context);
   59     return bp_loc_sp->GetID();
   65   return lhs->GetID() < val;
   74   if (pos != end && (*pos)->GetID() == break_id)
   88     SectionSP section_sp(break_loc->GetAddress().GetSection());
   89     if (section_sp && section_sp->GetModule().get() == module) {
  132     (*pos)->Dump(s);
  158     (*pos)->ClearBreakpointSite();
  166     if ((*pos)->IsEnabled())
  167       (*pos)->ResolveBreakpointSite();
  176     hit_count += (*pos)->GetHitCount();
  185     if ((*pos)->IsResolved())
  198     (*pos)->GetDescription(s, level);
  212       bp_loc_sp->ResolveBreakpointSite();
  230   m_address_to_location.erase(to_location_sp->GetAddress());
  231   to_location_sp->SwapLocation(from_location_sp);
  233   m_address_to_location[to_location_sp->GetAddress()] = to_location_sp;
  234   to_location_sp->ResolveBreakpointSite();
  242     m_address_to_location.erase(bp_loc_sp->GetAddress());
  257   m_address_to_location.erase(m_locations[idx]->GetAddress());
  277         if (!arch.IsCompatibleMatch(module_sp->GetArchitecture())) {
  307     lldb::break_id_t cur_id = loc_sp->GetID();

tools/lldb/source/Breakpoint/BreakpointName.cpp

   84    bp_sp->GetOptions()->CopyOverSetOptions(GetOptions());
   85    bp_sp->GetPermissions().MergeInto(GetPermissions());

tools/lldb/source/Breakpoint/BreakpointOptions.cpp

   42   options_dict_sp->AddBooleanItem(GetKey(OptionNames::StopOnError),
   49     user_source_sp->AddItem(item_sp);
   50     options_dict_sp->AddItem(GetKey(OptionNames::UserSource), user_source_sp);
   53   options_dict_sp->AddStringItem(
  366     options_dict_sp->AddBooleanItem(GetKey(OptionNames::EnabledState),
  369     options_dict_sp->AddBooleanItem(GetKey(OptionNames::OneShotState),
  372     options_dict_sp->AddBooleanItem(GetKey(OptionNames::AutoContinue),
  375     options_dict_sp->AddIntegerItem(GetKey(OptionNames::IgnoreCount),
  378     options_dict_sp->AddStringItem(GetKey(OptionNames::ConditionText),
  385         cmd_baton->getItem()->SerializeToStructuredData();
  387       options_dict_sp->AddItem(
  394     options_dict_sp->AddItem(ThreadSpec::GetSerializationKey(), thread_spec_sp);
  451         return m_callback(m_callback_baton_sp ? m_callback_baton_sp->data()
  474   CommandData *data = cmd_baton->getItem();
  569       m_callback_baton_sp->GetDescription(s, level);
  654       result.GetImmediateOutputStream()->Flush();
  655       result.GetImmediateErrorStream()->Flush();

tools/lldb/source/Breakpoint/BreakpointResolver.cpp

  153   if (!options_dict_sp || !options_dict_sp->IsValid())
  157   type_dict_sp->AddStringItem(GetSerializationSubclassKey(), GetResolverName());
  158   type_dict_sp->AddItem(GetSerializationSubclassOptionsKey(), options_dict_sp);
  161   options_dict_sp->AddIntegerItem(GetKey(OptionNames::Offset), m_offset);
  332     bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);

tools/lldb/source/Breakpoint/BreakpointResolverAddress.cpp

   73     ModuleSP module_sp = section_sp->GetModule();
   78     options_dict_sp->AddStringItem(GetKey(OptionNames::ModuleName),
   80     options_dict_sp->AddIntegerItem(GetKey(OptionNames::AddressOffset),
   83     options_dict_sp->AddIntegerItem(GetKey(OptionNames::AddressOffset),
   86       options_dict_sp->AddStringItem(GetKey(OptionNames::ModuleName),
  138           if (module_sp->ResolveFileAddress(m_addr.GetOffset(), tmp_address))
  147         bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
  158         loc_sp->ClearBreakpointSite();
  159         loc_sp->ResolveBreakpointSite();

tools/lldb/source/Breakpoint/BreakpointResolverFileLine.cpp

  100   options_dict_sp->AddStringItem(GetKey(OptionNames::FileName),
  102   options_dict_sp->AddIntegerItem(GetKey(OptionNames::LineNumber),
  104   options_dict_sp->AddIntegerItem(GetKey(OptionNames::Column),
  106   options_dict_sp->AddBooleanItem(GetKey(OptionNames::Inlines), m_inlines);
  107   options_dict_sp->AddBooleanItem(GetKey(OptionNames::SkipPrologue),
  109   options_dict_sp->AddBooleanItem(GetKey(OptionNames::ExactMatch),
  228   const size_t num_comp_units = context.module_sp->GetNumCompileUnits();
  230     CompUnitSP cu_sp(context.module_sp->GetCompileUnitAtIndex(i));
  233         cu_sp->ResolveSymbolContext(search_file_spec, m_line_number, m_inlines,

tools/lldb/source/Breakpoint/BreakpointResolverFileRegex.cpp

   81   options_dict_sp->AddStringItem(GetKey(OptionNames::RegexString),
   83   options_dict_sp->AddBooleanItem(GetKey(OptionNames::ExactMatch),
   89       names_array_sp->AddItem(item);
   91     options_dict_sp->AddItem(GetKey(OptionNames::LineNumber), names_array_sp);
  107   context.target_sp->GetSourceManager().FindLinesMatchingRegex(

tools/lldb/source/Breakpoint/BreakpointResolverName.cpp

  195     options_dict_sp->AddStringItem(GetKey(OptionNames::RegexString),
  201       names_sp->AddItem(StructuredData::StringSP(
  203       name_masks_sp->AddItem(StructuredData::IntegerSP(
  206     options_dict_sp->AddItem(GetKey(OptionNames::SymbolNameArray), names_sp);
  207     options_dict_sp->AddItem(GetKey(OptionNames::NameMaskArray), name_masks_sp);
  210     options_dict_sp->AddStringItem(
  213   options_dict_sp->AddBooleanItem(GetKey(OptionNames::SkipPrologue),
  280         context.module_sp->FindFunctions(
  293       context.module_sp->FindFunctions(
  384             bp_loc_sp->SetIsReExported(is_reexported);
  388                 bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
  431   ret_sp->SetBreakpoint(&breakpoint);

tools/lldb/source/Breakpoint/BreakpointResolverScripted.cpp

   47     ScriptInterpreter *script_interp = target_sp->GetDebugger()
   96   options_dict_sp->AddStringItem(GetKey(OptionNames::PythonClassName),
   99       options_dict_sp->AddItem(GetKey(OptionNames::ScriptArgs),

tools/lldb/source/Breakpoint/BreakpointSite.cpp

   38     m_owners.GetByIndex(i)->ClearBreakpointSite();
   68     if (m_owners.GetByIndex(i)->GetBreakpoint().GetID() == bp_id)
  155     loc_sp->BumpHitCount();

tools/lldb/source/Breakpoint/BreakpointSiteList.cpp

   25   lldb::addr_t bp_site_load_addr = bp->GetLoadAddress();
   31     return bp->GetID();
   44     return site_sp->ShouldStop(context);
   88     return m_break_id == val_pair.second->GetID();
  146     return pos->second->IsBreakpointAtThisSite(bp_id);
  160     pos->second->Dump(s);
  190     if (prev_bp->GetLoadAddress() + prev_bp->GetByteSize() > lower_bound)
  190     if (prev_bp->GetLoadAddress() + prev_bp->GetByteSize() > lower_bound)

tools/lldb/source/Breakpoint/Watchpoint.cpp

   55     m_target.GetProcessSP()->CalculateExecutionContext(exe_ctx);

tools/lldb/source/Breakpoint/WatchpointList.cpp

   23   wp_sp->SetID(++m_next_wp_id);
   26     if (wp_sp->GetTarget().EventTypeHasListeners(
   28       wp_sp->GetTarget().BroadcastEvent(Target::eBroadcastBitWatchpointChanged,
   32   return wp_sp->GetID();
   49     (*pos)->DumpWithLevel(s, description_level);
   59       lldb::addr_t wp_addr = (*pos)->GetLoadAddress();
   60       uint32_t wp_bytesize = (*pos)->GetByteSize();
   77       if ((*pos)->GetWatchSpec() == spec) {
   91     return m_watch_id == wp->GetID();
  125     return wp_sp->GetID();
  133     return wp_sp->GetID();
  164     IDs.push_back((*pos)->GetID());
  174       if (wp_sp->GetTarget().EventTypeHasListeners(
  176         wp_sp->GetTarget().BroadcastEvent(
  192     hit_count += (*pos)->GetHitCount();
  204     return wp_sp->ShouldStop(context);
  217     (*pos)->Dump(s);
  226     (*pos)->SetEnabled(enabled);
  236         if ((*pos)->GetTarget().EventTypeHasListeners(
  238           (*pos)->GetTarget().BroadcastEvent(

tools/lldb/source/Breakpoint/WatchpointOptions.cpp

   94     return m_callback(m_callback_baton_sp ? m_callback_baton_sp->data()
  124     m_callback_baton_sp->GetDescription(s, level);

tools/lldb/source/Commands/CommandCompletions.cpp

  305       properties_sp->DumpValue(nullptr, strm, OptionValue::eDumpOptionName);
  450     context.module_sp->FindFunctions(m_regex, include_symbols, include_inlines,
  494         context.module_sp->GetFileSpec().GetFilename().GetCString();
  496         context.module_sp->GetFileSpec().GetDirectory().GetCString();

tools/lldb/source/Commands/CommandObjectBreakpoint.cpp

  693         target.RemoveBreakpointByID(bp_sp->GetID());
  709         target.RemoveBreakpointByID(bp_sp->GetID());
  720       bp_sp->GetOptions()->CopyOverSetOptions(m_bp_opts.GetBreakpointOptions());
  729             target.RemoveBreakpointByID(bp_sp->GetID());
  740       bp_sp->GetDescription(&output_stream, lldb::eDescriptionLevelInitial,
  749         if (bp_sp->GetNumLocations() == 0 && break_type != eSetTypeException) {
 1315       BreakIDs.push_back(breakpoints.GetBreakpointAtIndex(i)->GetID());
 1723         target.ConfigureBreakpointName(*bp_name, *bp_sp->GetOptions(),
 1951             if (bp_sp->MatchesName(name)) {
 1954               bp_sp->GetDescription(&s, eDescriptionLevelBrief);
 2250   list_command_object->SetCommandName("breakpoint list");
 2251   enable_command_object->SetCommandName("breakpoint enable");
 2252   disable_command_object->SetCommandName("breakpoint disable");
 2253   clear_command_object->SetCommandName("breakpoint clear");
 2254   delete_command_object->SetCommandName("breakpoint delete");
 2255   set_command_object->SetCommandName("breakpoint set");
 2256   command_command_object->SetCommandName("breakpoint command");
 2257   modify_command_object->SetCommandName("breakpoint modify");
 2258   name_command_object->SetCommandName("breakpoint name");
 2259   write_command_object->SetCommandName("breakpoint write");
 2260   read_command_object->SetCommandName("breakpoint read");
 2300           target->GetLastCreatedBreakpoint()->GetID(), LLDB_INVALID_BREAK_ID));

tools/lldb/source/Commands/CommandObjectBreakpointCommand.cpp

  232       output_sp->PutCString(g_reader_instructions);
  233       output_sp->Flush();
  404               bp_options = bp_loc_sp->GetLocationOptions();
  568               bp_loc_sp->ClearCallback();
  669                ->GetOptionsSpecifyingKind(BreakpointOptions::eCallback)
  716   add_command_object->SetCommandName("breakpoint command add");
  717   delete_command_object->SetCommandName("breakpoint command delete");
  718   list_command_object->SetCommandName("breakpoint command list");

tools/lldb/source/Commands/CommandObjectCommands.cpp

  950       output_sp->PutCString("Enter one or more sed substitution commands in "
  953       output_sp->Flush();
  969               out_stream->Printf("error: %s\n", error.AsCString());
  976         m_interpreter.AddCommand(cmd_sp->GetCommandName(), cmd_sp, true);
 1132         m_interpreter.AddCommand(cmd_sp->GetCommandName(), cmd_sp, true);
 1590       output_sp->PutCString(g_python_command_instructions);
 1591       output_sp->Flush();
 1608             error_sp->Printf("error: unable to obtain a function name, didn't "
 1610             error_sp->Flush();
 1620               error_sp->Printf("error: unable to add selected command, didn't "
 1622               error_sp->Flush();
 1626           error_sp->Printf(
 1628           error_sp->Flush();
 1631         error_sp->Printf("error: empty function, didn't add python command.\n");
 1632         error_sp->Flush();
 1635       error_sp->Printf(
 1637       error_sp->Flush();

tools/lldb/source/Commands/CommandObjectDisassemble.cpp

  113     if (target_sp && (target_sp->GetArchitecture().GetTriple().getArch() ==
  115                       target_sp->GetArchitecture().GetTriple().getArch() ==
  136       auto platform_ptr = target_sp ? target_sp->GetPlatform().get() : nullptr;
  253              !disassembler->FlavorValidForArchSpec(m_options.arch,
  382                 module_sp->ResolveSymbolContextForAddress(
  408                 if (module_sp->ResolveFileAddress(file_addr, file_address)) {
  413                   module_sp->ResolveSymbolContextForAddress(

tools/lldb/source/Commands/CommandObjectExpression.cpp

  180     ignore_breakpoints = process_sp->GetIgnoreBreakpointsInExpressions();
  181     unwind_on_error = process_sp->GetUnwindOnErrorInExpressions();
  354   expr->Complete(exe_ctx, request, cursor_pos);
  506     output_sp->Flush();
  508     error_sp->Flush();
  540   StreamFileSP output_sp = io_handler_sp->GetOutputStreamFileSP();
  542     output_sp->PutCString(
  544     output_sp->Flush();
  606           m_interpreter.GetIOHandler(false)->SetIsDone(true);
  627               repl_sp->SetEvaluateOptions(
  629               repl_sp->SetFormatOptions(m_format_options);
  630               repl_sp->SetValueObjectDisplayOptions(m_varobj_options);
  633             IOHandlerSP io_handler_sp(repl_sp->GetIOHandler());
  635             io_handler_sp->SetIsDone(false);

tools/lldb/source/Commands/CommandObjectFrame.cpp

  159       valobj_sp = frame_sp->GuessValueForAddress(m_options.address.getValue());
  161       valobj_sp = frame_sp->GuessValueForRegisterAndOffset(
  467     switch (var_sp->GetScope()) {
  557                           var_sp->GetDeclaration().GetFile()) {
  560                         if (var_sp->DumpDeclaration(&s, show_fullpaths,
  602                   var_sp->GetDeclaration().GetFile()) {
  603                 var_sp->GetDeclaration().DumpStopContext(&s, false);
  633             switch (var_sp->GetScope()) {
  667                          ->GetDisplayRuntimeSupportValues() &&
  675                     var_sp->GetDeclaration().GetFile()) {
  676                   var_sp->GetDeclaration().DumpStopContext(&s, false);
  684                     var_sp ? var_sp->GetName().AsCString() : nullptr);
  698             recognized_frame->GetRecognizedArguments();
  700           for (auto &rec_value_sp : recognized_arg_list->GetObjects()) {
 1053       output_stream << recognizer->GetName();

tools/lldb/source/Commands/CommandObjectMemory.cpp

  517           compiler_type = type_sp->GetFullCompilerType();
  668       if (data_sp->GetBytes() == nullptr) {
  678       bytes_read = target->ReadMemory(address, false, data_sp->GetBytes(),
  679                                       data_sp->GetByteSize(), error);
  710       if (data_sp->GetBytes() == nullptr) {
  718       uint8_t *data_ptr = data_sp->GetBytes();
  757           std::make_shared<DataBufferHeap>(data_sp->GetBytes(), bytes_read + 1);
  788               outfile_stream_up->Write(data_sp->GetBytes(), bytes_read);
 1014           m_process_sp->ReadMemory(m_base_addr + offset, &retval, 1, error)) {
 1363         length = data_sp->GetByteSize();
 1367               process->WriteMemory(addr, data_sp->GetBytes(), length, error);
 1663     HistoryThreads thread_list = memory_history->GetHistoryThreads(addr);
 1667       thread->GetStatus(*output_stream, 0, UINT32_MAX, 0, stop_format);
 1719         error = process_sp->GetMemoryRegionInfo(load_addr, range_info);
 1724           if (process_sp->GetTarget().ResolveLoadAddress(load_addr, addr)) {
 1728               while (section_sp->GetParent())
 1729                 section_sp = section_sp->GetParent();
 1730               section_name = section_sp->GetName();

tools/lldb/source/Commands/CommandObjectMultiword.cpp

   72     assert((&GetCommandInterpreter() == &cmd_obj->GetCommandInterpreter()) &&
  168     if (pos->second->WantsRawCommandString()) {
  169       std::string help_text(pos->second->GetHelp());
  177                                             pos->second->GetHelp(), max_len);

tools/lldb/source/Commands/CommandObjectPlatform.cpp

  181           platform_sp->GetStatus(result.GetOutputStream());
  219     ostrm.Printf("%s: %s\n", host_platform_sp->GetPluginName().GetCString(),
  220                  host_platform_sp->GetDescription());
  267       platform_sp->GetStatus(ostrm);
  295       Status error(platform_sp->ConnectRemote(args));
  297         platform_sp->GetStatus(ostrm);
  300         platform_sp->ConnectToWaitingProcesses(GetDebugger(), error);
  321       m_platform_options = platform_sp->GetConnectionOptions(m_interpreter);
  347         if (platform_sp->IsConnected()) {
  350           const char *hostname_cstr = platform_sp->GetHostname();
  355           error = platform_sp->DisconnectRemote();
  360                            platform_sp->GetPluginName().GetCString());
  372               platform_sp->GetPluginName().GetCString());
  412         platform_sp->SetWorkingDirectory(
  457       Status error = platform_sp->MakeDirectory(FileSpec(cmd_line), mode);
  507       lldb::user_id_t fd = platform_sp->OpenFile(
  555       bool success = platform_sp->CloseFile(fd, error);
  596       uint32_t retcode = platform_sp->ReadFile(
  683           platform_sp->WriteFile(fd, m_options.m_offset, &m_options.m_data[0],
  822       Status error = platform_sp->GetFile(FileSpec(remote_file_path),
  886       user_id_t size = platform_sp->GetFileSize(FileSpec(remote_file_path));
  928       Status error(platform_sp->PutFile(src_fs, dst_fs));
 1001         ProcessSP process_sp(platform_sp->DebugProcess(
 1003         if (process_sp && process_sp->IsAlive()) {
 1070             if (platform_sp->GetProcessInfo(pid, proc_info)) {
 1073               proc_info.DumpAsTableRow(ostrm, platform_sp->GetUserIDResolver(),
 1084                 platform_sp->FindProcesses(m_options.match_info, proc_infos);
 1116                     platform_sp->GetPluginName().GetCString());
 1120                     platform_sp->GetPluginName().GetCString());
 1126                   platform_sp->GetName().GetCString());
 1135                     ostrm, platform_sp->GetUserIDResolver(),
 1220             target_sp ? target_sp->GetDebugger().shared_from_this()
 1223             debugger_sp ? debugger_sp->GetPlatformList().GetSelectedPlatform()
 1339         if (platform_sp->IsConnected()) {
 1350               if (platform_sp->GetProcessInfo(pid, proc_info)) {
 1353                 proc_info.Dump(ostrm, platform_sp->GetUserIDResolver());
 1366               platform_sp->GetPluginName().GetCString());
 1468       platform_sp->FindProcesses(match_info, process_infos);
 1501       ProcessSP remote_process_sp = platform_sp->Attach(
 1632       error = (platform_sp->RunShellCommand(expr, working_dir, &status, &signo,
 1704     Status error = platform_sp->Install(src, dst);

tools/lldb/source/Commands/CommandObjectProcess.cpp

  204           exe_module_sp->GetPlatformFileSpec(), false);
  207           exe_module_sp->GetPlatformFileSpec(), true);
  229         process_sp->SyncIOHandler(0, std::chrono::seconds(2));
  235             exe_module_sp->GetArchitecture().GetArchitectureName();
  237             "Process %" PRIu64 " launched: '%s' (%s)\n", process_sp->GetID(),
  238             exe_module_sp->GetFileSpec().GetPath().c_str(), archname);
  351       platform_sp->FindProcesses(match_info, process_infos);
  452         new_exec_module_sp->GetFileSpec().GetPath(new_path, PATH_MAX);
  456     } else if (old_exec_module_sp->GetFileSpec() !=
  457                new_exec_module_sp->GetFileSpec()) {
  460       old_exec_module_sp->GetFileSpec().GetPath(old_path, PATH_MAX);
  461       new_exec_module_sp->GetFileSpec().GetPath(new_path, PATH_MAX);
  566           StopInfoSP stop_info_sp = sel_thread_sp->GetStopInfo();
  568               stop_info_sp->GetStopReason() == eStopReasonBreakpoint) {
  570                 (lldb::break_id_t)stop_info_sp->GetValue();
  574               const size_t num_owners = bp_site_sp->GetNumberOfOwners();
  577                     bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint();
  577                     bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint();
  595           process->GetThreadList().GetThreadAtIndex(idx)->SetResumeState(
  822     ProcessSP process_sp = platform_sp->ConnectProcess(
  930         platform->ResolveRemotePath(image_spec, image_spec);
  932             platform->LoadImage(process, FileSpec(), image_spec, error);
  936         platform->ResolveRemotePath(m_options.install_path,
  938         image_token = platform->LoadImage(process, image_spec,
  944             platform->LoadImage(process, image_spec, FileSpec(), error);
  993         Status error(process->GetTarget().GetPlatform()->UnloadImage(
 1050         signo = process->GetUnixSignals()->GetSignalNumberFromName(signal_name);
 1342     if (signals_sp->GetSignalInfo(signo, suppress, stop, notify)) {
 1358         int32_t signo = signals_sp->GetSignalNumberFromName(
 1366       int32_t signo = signals_sp->GetFirstSignalNumber();
 1368         PrintSignal(str, signo, signals_sp->GetSignalAsCString(signo),
 1370         signo = signals_sp->GetNextSignalNumber(signo);
 1417     UnixSignalsSP signals_sp = process_sp->GetUnixSignals();
 1422         int32_t signo = signals_sp->GetSignalNumberFromName(arg.c_str());
 1427             signals_sp->SetShouldStop(signo, stop_action);
 1430             signals_sp->SetShouldSuppress(signo, suppress);
 1433             signals_sp->SetShouldNotify(signo, notify_action);
 1446           int32_t signo = signals_sp->GetFirstSignalNumber();
 1449               signals_sp->SetShouldNotify(signo, notify_action);
 1451               signals_sp->SetShouldStop(signo, stop_action);
 1454               signals_sp->SetShouldSuppress(signo, suppress);
 1456             signo = signals_sp->GetNextSignalNumber(signo);

tools/lldb/source/Commands/CommandObjectQuit.cpp

   40     const TargetList &target_list(debugger_sp->GetTargetList());
   47       ProcessSP process_sp(target_sp->GetProcessSP());
   48       if (process_sp && process_sp->IsValid() && process_sp->IsAlive() &&
   48       if (process_sp && process_sp->IsValid() && process_sp->IsAlive() &&
   49           process_sp->WarnBeforeDetach()) {
   51         if (!process_sp->GetShouldDetach()) {

tools/lldb/source/Commands/CommandObjectRegister.cpp

  163           set_idx = m_command_options.set_indexes[i]->GetUInt64Value(UINT32_MAX,

tools/lldb/source/Commands/CommandObjectSettings.cpp

  164       value_sp->AutoComplete(m_interpreter, request);
  541             GetDebugger().GetValueProperties()->GetPropertyAtPath(

tools/lldb/source/Commands/CommandObjectSource.cpp

  327         if (module_sp->ResolveFileAddress(addr, so_addr)) {
  330           if (module_sp->ResolveSymbolContextForAddress(
  353           if (module_sp->ResolveSymbolContextForAddress(
 1024               module_sp->ResolveFileAddress(m_options.address, so_addr)) {
 1027             if (module_sp->ResolveSymbolContextForAddress(
 1051             if (module_sp->ResolveSymbolContextForAddress(
 1139             m_breakpoint_locations.Reset(last_file_sp->GetFileSpec(), 0,

tools/lldb/source/Commands/CommandObjectTarget.cpp

   87                 platform_sp->GetName().GetCString());
   92     lldb::pid_t pid = process_sp->GetID();
   93     StateType state = process_sp->GetState();
  111     process_sp->GetStatus(strm);
  112     process_sp->GetThreadStatus(strm, only_threads_with_stop_reason,
  335         PlatformSP platform_sp = target_sp->GetPlatform();
  342               if (!platform_sp->GetFileExists(remote_file)) {
  343                 Status err = platform_sp->PutFile(file_spec, remote_file);
  364                 Status err = platform_sp->GetFile(remote_file, file_spec);
  386           ModuleSP module_sp(target_sp->GetExecutableModule());
  389               module_sp->SetSymbolFileFileSpec(symfile);
  392               target_sp->SetArg0(remote_path.c_str());
  393               module_sp->SetPlatformFileSpec(remote_file);
  401           ModuleSP module_sp = target_sp->GetOrCreateModule(main_module_spec,
  404             module_sp->SetPlatformFileSpec(remote_file);
  418             target_sp->AppendExecutableSearchPaths(core_file_dir);
  420             ProcessSP process_sp(target_sp->CreateProcess(
  426               error = process_sp->LoadCore();
  436                     target_sp->GetArchitecture().GetArchitectureName());
  454               target_sp->GetArchitecture().GetArchitectureName());
  667       target_sp->Destroy();
  749     if (!valobj_sp->GetTargetSP()->GetDisplayRuntimeSupportValues() &&
  753     switch (var_sp->GetScope()) {
  786       if (var_sp->DumpDeclaration(&s, show_fullpaths, show_module))
  821                    sc.module_sp->GetFileSpec().GetPath().c_str());
  824                    sc.module_sp->GetFileSpec().GetPath().c_str());
  838                             var_sp->GetName().GetCString());
  896                                 use_var_name ? var_sp->GetName().GetCString()
  921               size_t count = comp_unit_varlist_sp->GetSize();
  957                   module_sp->FindCompileUnits(
  997                 sc.module_sp->FindGlobalVariables(all_globals_regex, UINT32_MAX,
 1653       type_sp->GetFullCompilerType();
 1654       type_sp->GetDescription(&strm, eDescriptionLevelFull, true);
 1657       TypeSP typedefed_type_sp(typedef_type_sp->GetTypedefType());
 1661                     typedef_type_sp->GetName().GetCString());
 1662         typedefed_type_sp->GetFullCompilerType();
 1663         typedefed_type_sp->GetDescription(&strm, eDescriptionLevelFull, true);
 1665         typedefed_type_sp = typedef_type_sp->GetTypedefType();
 1697     type_sp->GetFullCompilerType();
 1698     type_sp->GetDescription(&strm, eDescriptionLevelFull, true);
 1701     TypeSP typedefed_type_sp(typedef_type_sp->GetTypedefType());
 1705                   typedef_type_sp->GetName().GetCString());
 1706       typedefed_type_sp->GetFullCompilerType();
 1707       typedefed_type_sp->GetDescription(&strm, eDescriptionLevelFull, true);
 1709       typedefed_type_sp = typedef_type_sp->GetTypedefType();
 2597         process->Flush();
 2659               module_list.GetModuleAtIndex(0)->GetFileSpec();
 2673             module_list.GetModuleAtIndex(0)->GetFileSpec();
 2741                         if (section_sp->IsThreadSpecific()) {
 2806                 Status error = process->WriteObjectFile(std::move(loadables));
 2812                   ThreadList &thread_list = process->GetThreadList();
 2814                       thread_list.GetSelectedThread()->GetRegisterContext());
 2816                   if (!reg_context->SetPC(file_entry_addr)) {
 3359         module_sp->ResolveSymbolContextForAddress(addr,
 3385       if (!sc.module_sp || sc.module_sp->GetObjectFile() == nullptr)
 3401           sc.module_sp->GetUnwindTable()
 3408           sc.module_sp->GetPlatformFileSpec().GetFilename().AsCString(),
 3412           func_unwinders_sp->GetUnwindPlanAtNonCallSite(*target, *thread);
 3416             non_callsite_unwind_plan->GetSourceName().AsCString());
 3419           func_unwinders_sp->GetUnwindPlanAtCallSite(*target, *thread);
 3423             callsite_unwind_plan->GetSourceName().AsCString());
 3426           func_unwinders_sp->GetUnwindPlanFastUnwind(*target, *thread);
 3430             fast_unwind_plan->GetSourceName().AsCString());
 3436           func_unwinders_sp->GetAssemblyUnwindPlan(*target, *thread);
 3440         assembly_sp->Dump(result.GetOutputStream(), thread.get(),
 3446           func_unwinders_sp->GetObjectFileUnwindPlan(*target);
 3449         of_unwind_sp->Dump(result.GetOutputStream(), thread.get(),
 3455           func_unwinders_sp->GetObjectFileAugmentedUnwindPlan(*target,
 3459         of_unwind_augmented_sp->Dump(result.GetOutputStream(), thread.get(),
 3465           func_unwinders_sp->GetEHFrameUnwindPlan(*target);
 3468         ehframe_sp->Dump(result.GetOutputStream(), thread.get(),
 3474           func_unwinders_sp->GetEHFrameAugmentedUnwindPlan(*target, *thread);
 3477         ehframe_augmented_sp->Dump(result.GetOutputStream(), thread.get(),
 3483               func_unwinders_sp->GetDebugFrameUnwindPlan(*target)) {
 3485         plan_sp->Dump(result.GetOutputStream(), thread.get(),
 3491               func_unwinders_sp->GetDebugFrameAugmentedUnwindPlan(*target,
 3494         plan_sp->Dump(result.GetOutputStream(), thread.get(),
 3500           func_unwinders_sp->GetArmUnwindUnwindPlan(*target);
 3503         arm_unwind_sp->Dump(result.GetOutputStream(), thread.get(),
 3509               func_unwinders_sp->GetSymbolFileUnwindPlan(*thread)) {
 3511         symfile_plan_sp->Dump(result.GetOutputStream(), thread.get(),
 3517           func_unwinders_sp->GetCompactUnwindUnwindPlan(*target);
 3520         compact_unwind_sp->Dump(result.GetOutputStream(), thread.get(),
 3527         fast_unwind_plan->Dump(result.GetOutputStream(), thread.get(),
 3535         if (abi_sp->CreateDefaultUnwindPlan(arch_default)) {
 3543         if (abi_sp->CreateFunctionEntryUnwindPlan(arch_entry)) {
 3734     const SymbolContext &sym_ctx(frame->GetSymbolContext(eSymbolContextModule));
 4133         module_sp->SetSymbolFileFileSpec(symbol_fspec);
 4136             module_sp->GetSymbolFile(true, &result.GetErrorStream());
 4142             const FileSpec &module_fs = module_sp->GetFileSpec();
 4157             module_sp->LoadScriptingResourceInTarget(target, error,
 4163                   module_sp->GetFileSpec()
 4176         module_sp->SetSymbolFileFileSpec(FileSpec());
 4232                           frame_module_sp->GetPlatformFileSpec())) {
 4234                         frame_module_sp->GetArchitecture();
 4236                         frame_module_sp->GetPlatformFileSpec();
 4238                   module_spec.GetUUID() = frame_module_sp->GetUUID();
 4270               module_spec.GetFileSpec() = module_sp->GetFileSpec();
 4272                   module_sp->GetPlatformFileSpec();
 4273               module_spec.GetUUID() = module_sp->GetUUID();
 4274               module_spec.GetArchitecture() = module_sp->GetArchitecture();
 4334                       ->ResolveSymbolFile(*target, module_spec, symfile_spec)
 4577       output_sp->PutCString(
 4579       output_sp->Flush();
 4589           error_sp->Printf("error: stop hook #%" PRIu64
 4591                            m_stop_hook_sp->GetID());
 4592           error_sp->Flush();
 4596           target->RemoveStopHookByID(m_stop_hook_sp->GetID());
 4598         m_stop_hook_sp->GetCommandPointer()->SplitIntoLines(line);
 4601           output_sp->Printf("Stop hook #%" PRIu64 " added.\n",
 4602                             m_stop_hook_sp->GetID());
 4603           output_sp->Flush();
 4659         new_hook_sp->SetSpecifier(specifier_up.release());
 4679         new_hook_sp->SetThreadSpecifier(thread_spec);
 4682       new_hook_sp->SetAutoContinue(m_options.m_auto_continue);
 4686           new_hook_sp->GetCommandPointer()->AppendString(
 4689                                        new_hook_sp->GetID());
 4834         this_hook->GetDescription(&(result.GetOutputStream()),

tools/lldb/source/Commands/CommandObjectThread.cpp

  109         tids.push_back(thread_sp->GetID());
  139         tids.push_back(thread->GetID());
  169         if (!HandleOneThread(thread->GetID(), result)) {
  217       const lldb::addr_t pc = frame_sp->GetStackID().GetPC();
  329     SystemRuntime *runtime = thread->GetProcess()->GetSystemRuntime();
  337         if (ext_thread_sp && ext_thread_sp->IsValid()) {
  340           if (ext_thread_sp->GetStatus(strm, m_options.m_start,
  498     if (target_sp && target_sp->GetNonStopModeEnabled())
  739       new_plan_sp->SetIsMasterPlan(true);
  740       new_plan_sp->SetOkayToDiscard(false);
  743         if (!new_plan_sp->SetIterationCount(m_options.m_step_count)) {
 1245           new_plan_sp->SetIsMasterPlan(true);
 1246           new_plan_sp->SetOkayToDiscard(false);
 1502     ValueObjectSP exception_object_sp = thread_sp->GetCurrentException();
 1507     ThreadSP exception_thread_sp = thread_sp->GetCurrentExceptionBacktrace();
 1508     if (exception_thread_sp && exception_thread_sp->IsValid()) {
 1511       exception_thread_sp->GetStatus(strm, 0, UINT32_MAX,
 1639     uint32_t frame_idx = frame_sp->GetFrameIndex();
 1641     if (frame_sp->IsInlined()) {
 1673     error = thread_sp->ReturnFromFrame(frame_sp, return_valobj_sp, broadcast);
 1677           thread_sp->GetIndexID(), error.AsCString());

tools/lldb/source/Commands/CommandObjectType.cpp

  156       output_sp->PutCString(g_summary_addreader_instructions);
  157       output_sp->Flush();
  184                 error_sp->Printf("unable to obtain a valid function name from "
  186                 error_sp->Flush();
  193                     options->m_flags, funct_name_str.c_str(),
  198                 for (const std::string &type_name : options->m_target_types) {
  201                       (options->m_regex
  204                       options->m_category, &error);
  206                     error_sp->Printf("error: %s", error.AsCString());
  207                     error_sp->Flush();
  211                 if (options->m_name) {
  213                       options->m_name, script_format,
  215                       options->m_category, &error);
  218                         options->m_name, script_format,
  220                         options->m_category, &error);
  222                       error_sp->Printf("error: %s", error.AsCString());
  223                       error_sp->Flush();
  226                     error_sp->Printf("error: %s", error.AsCString());
  227                     error_sp->Flush();
  231                     error_sp->Printf("error: %s", error.AsCString());
  232                     error_sp->Flush();
  237               error_sp->Printf("error: unable to generate a function.\n");
  238               error_sp->Flush();
  241             error_sp->Printf("error: no script interpreter.\n");
  242             error_sp->Flush();
  245           error_sp->Printf("error: internal synchronization information "
  247           error_sp->Flush();
  250         error_sp->Printf("error: empty function, didn't add python command.\n");
  251         error_sp->Flush();
  254       error_sp->Printf(
  256       error_sp->Flush();
  388       output_sp->PutCString(g_synth_addreader_instructions);
  389       output_sp->Flush();
  415                 error_sp->Printf(
  417                 error_sp->Flush();
  425                         .SetCascades(options->m_cascade)
  426                         .SetSkipPointers(options->m_skip_pointers)
  427                         .SetSkipReferences(options->m_skip_references),
  432                     ConstString(options->m_category.c_str()), category);
  436                 for (const std::string &type_name : options->m_target_types) {
  440                             options->m_regex
  443                             options->m_category, &error)) {
  444                       error_sp->Printf("error: %s\n", error.AsCString());
  445                       error_sp->Flush();
  449                     error_sp->Printf("error: invalid type name.\n");
  450                     error_sp->Flush();
  456               error_sp->Printf("error: unable to generate a class.\n");
  457               error_sp->Flush();
  460             error_sp->Printf("error: no script interpreter.\n");
  461             error_sp->Flush();
  464           error_sp->Printf("error: internal synchronization data missing.\n");
  465           error_sp->Flush();
  468         error_sp->Printf("error: empty function, didn't add python command.\n");
  469         error_sp->Flush();
  472       error_sp->Printf(
  474       error_sp->Flush();
  697         category_sp->GetRegexTypeSummariesContainer()->Delete(typeCS);
  697         category_sp->GetRegexTypeSummariesContainer()->Delete(typeCS);
  698         category_sp->GetRegexTypeFormatsContainer()->Add(std::move(typeRX),
  698         category_sp->GetRegexTypeFormatsContainer()->Add(std::move(typeRX),
  701         category_sp->GetTypeFormatsContainer()->Add(std::move(typeCS), entry);
  701         category_sp->GetTypeFormatsContainer()->Add(std::move(typeCS), entry);
  807             category_sp->Delete(typeCS, m_formatter_kind_mask);
  822         delete_category = category->Delete(typeCS, m_formatter_kind_mask);
  829         delete_category = category->Delete(typeCS, m_formatter_kind_mask);
  904             category_sp->Clear(m_formatter_kind_mask);
  917       category->Clear(m_formatter_kind_mask);
 1066           category->GetName(), category->IsEnabled() ? "" : " (disabled)");
 1066           category->GetName(), category->IsEnabled() ? "" : " (disabled)");
 1087                                           format_sp->GetDescription().c_str());
 1110                                           format_sp->GetDescription().c_str());
 1114       category->ForEach(foreach);
 1129               if (category->GetName() == category_regex->GetText()) {
 1133                                  category->GetName()))) {
 1631     category->GetRegexTypeSummariesContainer()->Delete(type_name);
 1631     category->GetRegexTypeSummariesContainer()->Delete(type_name);
 1632     category->GetRegexTypeSummariesContainer()->Add(std::move(typeRX), entry);
 1632     category->GetRegexTypeSummariesContainer()->Add(std::move(typeRX), entry);
 1640     category->GetTypeSummariesContainer()->Add(std::move(type_name), entry);
 1640     category->GetTypeSummariesContainer()->Add(std::move(type_name), entry);
 1697                 summary_sp->GetDescription().c_str());
 1792         category_sp->AddLanguage(m_options.m_cate_language.GetCurrentValue());
 1898           if (cate->GetCount() == 0) {
 2122             if (regex->GetText() == category_sp->GetName()) {
 2125                            category_sp->GetName()))) {
 2134               "Category: %s\n", category_sp->GetDescription().c_str());
 2346   if (category->AnyMatches(type_name, eFormatCategoryItemFilter |
 2365     category->GetRegexTypeSyntheticsContainer()->Delete(type_name);
 2365     category->GetRegexTypeSyntheticsContainer()->Delete(type_name);
 2366     category->GetRegexTypeSyntheticsContainer()->Add(std::move(typeRX), entry);
 2366     category->GetRegexTypeSyntheticsContainer()->Add(std::move(typeRX), entry);
 2370     category->GetTypeSyntheticsContainer()->Add(std::move(type_name), entry);
 2370     category->GetTypeSyntheticsContainer()->Add(std::move(type_name), entry);
 2471     if (category->AnyMatches(type_name, eFormatCategoryItemSynth |
 2491       category->GetRegexTypeFiltersContainer()->Delete(type_name);
 2491       category->GetRegexTypeFiltersContainer()->Delete(type_name);
 2492       category->GetRegexTypeFiltersContainer()->Add(std::move(typeRX), entry);
 2492       category->GetRegexTypeFiltersContainer()->Add(std::move(typeRX), entry);
 2496       category->GetTypeFiltersContainer()->Add(std::move(type_name), entry);
 2496       category->GetTypeFiltersContainer()->Add(std::move(type_name), entry);
 2584       entry->AddExpressionPath(*begin);
 2864     lldb::ExpressionResults expr_result = target_sp->EvaluateExpression(
 2869               target_sp->GetPreferDynamicValue(),
 2870               target_sp->GetEnableSyntheticValue());
 2874         std::string description(formatter_sp->GetDescription());

tools/lldb/source/Commands/CommandObjectWatchpoint.cpp

   44       target->GetProcessSP() && target->GetProcessSP()->IsAlive();
   77       wp_ids.push_back(watch_sp->GetID());
  218     if (target->GetProcessSP() && target->GetProcessSP()->IsAlive()) {
  220       Status error = target->GetProcessSP()->GetWatchpointSupportInfo(
  698       wp_sp->SetCondition(m_options.m_condition.c_str());
  715           wp_sp->SetCondition(m_options.m_condition.c_str());
  890       if (var_sp && var_sp->GetDeclaration().GetFile()) {
  893         var_sp->GetDeclaration().DumpStopContext(&ss, true);
 1130   list_command_object->SetCommandName("watchpoint list");
 1131   enable_command_object->SetCommandName("watchpoint enable");
 1132   disable_command_object->SetCommandName("watchpoint disable");
 1133   delete_command_object->SetCommandName("watchpoint delete");
 1134   ignore_command_object->SetCommandName("watchpoint ignore");
 1135   command_command_object->SetCommandName("watchpoint command");
 1136   modify_command_object->SetCommandName("watchpoint modify");
 1137   set_command_object->SetCommandName("watchpoint set");

tools/lldb/source/Commands/CommandObjectWatchpointCommand.cpp

  212       output_sp->PutCString(
  214       output_sp->Flush();
  304         result.GetImmediateOutputStream()->Flush();
  305         result.GetImmediateErrorStream()->Flush();
  653   add_command_object->SetCommandName("watchpoint command add");
  654   delete_command_object->SetCommandName("watchpoint command delete");
  655   list_command_object->SetCommandName("watchpoint command list");

tools/lldb/source/Core/Address.cpp

   69     return target_sp->ReadMemory(address, prefer_file_cache, dst, dst_len,
   86     byte_order = target_sp->GetArchitecture().GetByteOrder();
   87     addr_size = target_sp->GetArchitecture().GetAddressByteSize();
   93       byte_order = module_sp->GetArchitecture().GetByteOrder();
   94       addr_size = module_sp->GetArchitecture().GetAddressByteSize();
  148       if (module_sp->ResolveFileAddress(deref_addr, deref_so_addr))
  254       assert(section_sp->ContainsFileAddress(file_addr));
  255       m_offset = file_addr - section_sp->GetFileAddress();
  286     module_sp = section_sp->GetModule();
  293     addr_t sect_file_addr = section_sp->GetFileAddress();
  314       addr_t sect_load_addr = section_sp->GetLoadBaseAddress(target);
  342       code_addr = processSP->ResolveIndirectFunction(this, error);
  418       section_sp->DumpName(s);
  432       ModuleSP module_sp = section_sp->GetModule();
  434         s->Printf("%s[", module_sp->GetFileSpec().GetFilename().AsCString(
  488         pointer_size = module_sp->GetArchitecture().GetAddressByteSize();
  492         SectionType sect_type = section_sp->GetType();
  496             if (Symtab *symtab = module_sp->GetSymtab()) {
  646           module_sp->ResolveSymbolContextForAddress(
  692         module_sp->ResolveSymbolContextForAddress(
  804     ModuleSP module_sp(section_sp->GetModule());
  808         return sc->module_sp->ResolveSymbolContextForAddress(
  818     return section_sp->GetModule();
  826     sc.module_sp = section_sp->GetModule();
  828       sc.module_sp->ResolveSymbolContextForAddress(*this,
  840     sc.module_sp = section_sp->GetModule();
  842       sc.module_sp->ResolveSymbolContextForAddress(*this,
  854     sc.module_sp = section_sp->GetModule();
  856       sc.module_sp->ResolveSymbolContextForAddress(*this, eSymbolContextBlock,
  868     sc.module_sp = section_sp->GetModule();
  870       sc.module_sp->ResolveSymbolContextForAddress(*this, eSymbolContextSymbol,
  882     sc.module_sp = section_sp->GetModule();
  884       sc.module_sp->ResolveSymbolContextForAddress(*this,
 1000     ObjectFile *obj_file = module_sp->GetObjectFile();
 1004       module_sp->GetSymtab();

tools/lldb/source/Core/AddressRange.cpp

  185         s->Printf("%s", module_sp->GetFileSpec().GetFilename().AsCString(

tools/lldb/source/Core/AddressResolverName.cpp

   92       context.module_sp->FindSymbolsWithNameAndType(m_func_name,
   94       context.module_sp->FindFunctions(m_func_name, nullptr,
  102       context.module_sp->FindSymbolsMatchingRegExAndType(
  104       context.module_sp->FindFunctions(m_regex, include_symbols,

tools/lldb/source/Core/Communication.cpp

   86     return connection_sp->Connect(url, error_ptr);
   98     ConnectionStatus status = connection_sp->Disconnect(error_ptr);
  116   return (connection_sp ? connection_sp->IsConnected() : false);
  148     listener_sp->StartListeningForEvents(
  151     while (listener_sp->GetEvent(event_sp, timeout)) {
  152       const uint32_t event_type = event_sp->GetType();
  182     return connection_sp->Write(src, src_len, status, error_ptr);
  296     return connection_sp->Read(dst, dst_len, timeout, status, error_ptr);
  388   listener_sp->StartListeningForEvents(this, eBroadcastBitNoMorePendingInput);
  395   m_connection_sp->InterruptRead();
  399   listener_sp->GetEvent(event_sp, llvm::None);

tools/lldb/source/Core/Debugger.cpp

  273         target_sp->TargetProperties::GetLoadScriptFromSymbolFile();
  295       if (target_sp->TargetProperties::GetLoadScriptFromSymbolFile() ==
  299         if (!target_sp->LoadScriptingResources(errors, &feedback_stream)) {
  315   return m_collection_sp->GetPropertyAtIndexAsBoolean(
  321   return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
  326   return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
  331   return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
  336   return m_collection_sp->GetPropertyAtIndexAsBoolean(
  342   return m_collection_sp->GetPropertyAtIndexAsString(
  348   m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, p);
  364   return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
  369   return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
  374   return (lldb::ScriptLanguage)m_collection_sp->GetPropertyAtIndexAsEnumeration(
  380   return m_collection_sp->SetPropertyAtIndexAsEnumeration(nullptr, idx,
  386   return m_collection_sp->GetPropertyAtIndexAsSInt64(
  392   return m_collection_sp->SetPropertyAtIndexAsSInt64(nullptr, idx, term_width);
  397   return m_collection_sp->GetPropertyAtIndexAsBoolean(
  403   return m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
  408   return m_collection_sp->GetPropertyAtIndexAsBoolean(
  414   bool ret = m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
  421   return m_collection_sp->GetPropertyAtIndexAsBoolean(
  427   return (lldb::StopShowColumn)m_collection_sp->GetPropertyAtIndexAsEnumeration(
  433   return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, "");
  438   return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, "");
  444   return m_collection_sp->GetPropertyAtIndexAsSInt64(
  451       m_collection_sp->GetPropertyAtIndexAsEnumeration(
  457   return m_collection_sp->GetPropertyAtIndexAsSInt64(
  463   return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true);
  468   return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true);
  473   return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true);
  478   return m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
  483   return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true);
  488   return m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
  493   return m_collection_sp->GetPropertyAtIndexAsUInt64(
  499   return m_collection_sp->SetPropertyAtIndexAsUInt64(nullptr, idx, tab_size);
  528         debugger->Clear();
  633   debugger_sp->InstanceInitialize();
  641   debugger_sp->Clear();
  661       if ((*pos)->m_instance_name == instance_name) {
  676       target_sp = (*pos)->GetTargetList().FindTargetWithProcessID(pid);
  690       target_sp = (*pos)->GetTargetList().FindTargetWithProcess(process);
  730   m_collection_sp->Initialize(g_debugger_properties);
  731   m_collection_sp->AppendProperty(
  734       Target::GetGlobalProperties()->GetValueProperties());
  735   m_collection_sp->AppendProperty(
  737       Platform::GetGlobalPlatformProperties()->GetValueProperties());
  738   m_collection_sp->AppendProperty(
  742     m_collection_sp->AppendProperty(
  748       m_collection_sp->GetPropertyAtIndexAsOptionValueSInt64(
  783     m_listener_sp->Clear();
  788         ProcessSP process_sp(target_sp->GetProcessSP());
  790           process_sp->Finalize();
  791         target_sp->Destroy();
  794     m_broadcaster_manager_sp->Clear();
  825   assert(file_sp && file_sp->IsValid());
  834   assert(file_sp && file_sp->IsValid());
  839   assert(file_sp && file_sp->IsValid());
  857     ProcessSP process_sp(target_sp->GetProcessSP());
  859     if (process_sp && !process_sp->IsRunning()) {
  860       ThreadSP thread_sp(process_sp->GetThreadList().GetSelectedThread());
  863         exe_ctx.SetFrameSP(thread_sp->GetSelectedFrame());
  865           exe_ctx.SetFrameSP(thread_sp->GetStackFrameAtIndex(0));
  876     reader_sp->Interrupt();
  883     reader_sp->GotEOF();
  903     reader_sp->Run();
  908       if (top_reader_sp && top_reader_sp->GetIsDone())
  949     top_reader_sp->Run();
  958       if (top_reader_sp && top_reader_sp->GetIsDone())
  976   if (!in || !in->IsValid()) {
  978       in = top_reader_sp->GetInputFileSP();
  986   if (!out || !out->GetFile().IsValid()) {
  988       out = top_reader_sp->GetOutputStreamFileSP();
  996   if (!err || !err->GetFile().IsValid()) {
  998       err = top_reader_sp->GetErrorStreamFileSP();
 1023   reader_sp->Activate();
 1028     top_reader_sp->Deactivate();
 1030       top_reader_sp->Cancel();
 1050   reader_sp->Deactivate();
 1051   reader_sp->Cancel();
 1056     reader_sp->Activate();
 1096       if ((*pos)->GetID() == id) {
 1249         output_sp->Printf("%d location%s added to breakpoint %d\n",
 1251                           breakpoint->GetID());
 1252         output_sp->Flush();
 1290   const uint32_t event_type = event_sp->GetType();
 1338               plugin_sp->GetDescription(structured_data_sp, content_stream);
 1346               output_stream_sp->PutCString(content_stream.GetString());
 1349             error_stream_sp->Printf("Failed to print structured "
 1351                                     plugin_sp->GetPluginName().AsCString(),
 1364     output_stream_sp->Flush();
 1365     error_stream_sp->Flush();
 1368       process_sp->PopProcessIOHandler();
 1376   const uint32_t event_type = event_sp->GetType();
 1383       thread_sp->GetStatus(*GetAsyncOutputStream(), 0, 1, 1, stop_format);
 1415   listener_sp->StartListeningForEventSpec(m_broadcaster_manager_sp,
 1417   listener_sp->StartListeningForEventSpec(m_broadcaster_manager_sp,
 1419   listener_sp->StartListeningForEventSpec(m_broadcaster_manager_sp,
 1421   listener_sp->StartListeningForEvents(
 1434     if (listener_sp->GetEvent(event_sp, llvm::None)) {
 1436         Broadcaster *broadcaster = event_sp->GetBroadcaster();
 1438           uint32_t event_type = event_sp->GetType();
 1460                   error_sp->PutCString(data);
 1461                   error_sp->Flush();
 1471                   output_sp->PutCString(data);
 1472                   output_sp->Flush();
 1480           m_forward_listener_sp->AddEvent(event_sp);
 1499     listener_sp->StartListeningForEvents(&m_sync_broadcaster,
 1526     listener_sp->GetEvent(event_sp, llvm::None);
 1625   repl_sp->SetCompilerOptions(repl_options);
 1626   repl_sp->RunLoop();

tools/lldb/source/Core/Disassembler.cpp

  102       flavor = target_sp->GetDisassemblyFlavor();
  209       disasm_sp->ParseInstructions(&exe_ctx, range, nullptr, prefer_file_cache);
  233   (void)disasm_sp->DecodeInstructions(start, data, 0, num_instructions, false,
  261       disasm_sp->ParseInstructions(&exe_ctx, range, &strm, prefer_file_cache);
  290   size_t bytes_disassembled = disasm_sp->ParseInstructions(
  355     avoid_regex = thread_sp->GetSymbolsToAvoidRegexp();
  360       OptionValueSP value_sp = target_sp->GetDebugger().GetPropertyValue(
  362       if (value_sp && value_sp->GetType() == OptionValue::eTypeRegex) {
  363         OptionValueRegex *re = value_sp->GetAsRegex();
  406       target_sp ? target_sp->GetSourceManager() : debugger.GetSourceManager();
  448             module_sp->ResolveSymbolContextForAddress(addr, resolve_mask, sc);
  500         uint32_t resolved_mask = module_sp->ResolveSymbolContextForAddress(
  819         data_value_sp->SetValueFromString(value);
  827       option_value_sp->GetAsArray()->InsertValue(idx, data_value_sp);
  915         value_sp->SetValueFromString(value);
  931         option_value_sp->GetAsDictionary()->SetValueForKey(const_key, value_sp,
  983       data_dictionary_sp->GetAsDictionary();
  995   SetDescription(value_sp->GetStringValue());
 1005   arch.SetTriple(llvm::Triple(value_sp->GetStringValue()));
 1056     uint32_t inst_size = (*pos)->GetOpcode().GetByteSize();
 1089     (*pos)->Dump(s, max_opcode_byte_size, show_address, show_bytes, exe_ctx,
 1110     if (m_instructions[i]->DoesBranch()) {
 1111       if (ignore_calls && m_instructions[i]->IsCall())
 1134       target.ReadMemory(m_instructions[i]->GetAddress(), prefer_file_cache,
 1162     if (m_instructions[i]->GetAddress() == address) {
 1194         range.GetBaseAddress(), prefer_file_cache, data_sp->GetBytes(),
 1195         data_sp->GetByteSize(), error, &load_addr);
 1198       if (bytes_read != data_sp->GetByteSize())
 1199         data_sp->SetByteSize(bytes_read);

tools/lldb/source/Core/DumpDataExtractor.cpp

  156           target_sp->GetArchitecture(),
  157           target_sp->GetDisassemblyFlavor(), nullptr));
  162         if (target_sp->GetSectionLoadList().ResolveLoadAddress(addr, so_addr)) {
  165           if (target_sp->GetSectionLoadList().IsEmpty() ||
  166               !target_sp->GetImages().ResolveFileAddress(addr, so_addr))
  170         size_t bytes_consumed = disassembler_sp->DecodeInstructions(
  179           disassembler_sp->GetInstructionList().Dump(s, show_address,
  559             target_sp->GetScratchTypeSystemForLanguage(eLanguageTypeC);
  568               target_sp->GetMaxZeroPaddingInFloatFormat();
  638           if (target_sp->GetSectionLoadList().ResolveLoadAddress(addr,

tools/lldb/source/Core/DynamicLoader.cpp

   81     if (FileSystem::Instance().Exists(executable->GetFileSpec())) {
   82       ModuleSpec module_spec(executable->GetFileSpec(),
   83                              executable->GetArchitecture());
   88       if (module_sp && module_sp->GetUUID().IsValid() &&
   89           executable->GetUUID().IsValid()) {
   90         if (module_sp->GetUUID() != executable->GetUUID())
   90         if (module_sp->GetUUID() != executable->GetUUID())
   92       } else if (executable->FileHasChanged()) {
  119   module->SetLoadAddress(m_process->GetTarget(), base_addr, base_addr_is_offset,
  144     ObjectFile *obj_file = module->GetObjectFile();

tools/lldb/source/Core/EmulateInstruction.cpp

  260     return process_sp->ReadMemory(addr, dst, dst_len, error);
  277     return process_sp->WriteMemory(addr, src, src_len, error);
  291   return frame->GetRegisterContext()->ReadRegister(reg_info, reg_value);
  302   return frame->GetRegisterContext()->WriteRegister(reg_info, reg_value);

tools/lldb/source/Core/FormatEntity.cpp

  951         target->GetTargetSP()->GetMaximumNumberOfChildrenToDisplay();
 1018       thread_info_dictionary->GetObjectForDotSeparatedPath(path);
 1021     if (value->GetType() == eStructuredDataTypeInteger) {
 1025       s.Printf(token_format, value->GetAsInteger()->GetValue());
 1027     } else if (value->GetType() == eStructuredDataTypeFloat) {
 1028       s.Printf("%f", value->GetAsFloat()->GetValue());
 1030     } else if (value->GetType() == eStructuredDataTypeString) {
 1031       s.Format("{0}", value->GetAsString()->GetValue());
 1033     } else if (value->GetType() == eStructuredDataTypeArray) {
 1034       if (value->GetAsArray()->GetSize() > 0) {
 1035         s.Printf("%zu", value->GetAsArray()->GetSize());
 1038     } else if (value->GetType() == eStructuredDataTypeDictionary) {
 1040                value->GetAsDictionary()->GetKeys()->GetAsArray()->GetSize());
 1040                value->GetAsDictionary()->GetKeys()->GetAsArray()->GetSize());
 1198             Target &target = thread->GetProcess()->GetTarget();
 1275         if (stop_info_sp && stop_info_sp->IsValid()) {
 1276           const char *cstr = stop_info_sp->GetDescription();
 1291         if (stop_info_sp && stop_info_sp->IsValid()) {
 1308         if (stop_info_sp && stop_info_sp->IsValid()) {
 1311           if (expression_var_sp && expression_var_sp->GetValueObject()) {
 1312             expression_var_sp->GetValueObject()->Dump(s);
 1335             object_sp->GetType() == eStructuredDataTypeDictionary) {
 1634             variable_list_sp->AppendVariablesWithScope(
 1688                               ->TargetProperties::GetPreferDynamicValue(),
 1690                               ->TargetProperties::GetEnableSyntheticValue());
 1841         addr_t pc_loadaddr = reg_ctx->GetPC();

tools/lldb/source/Core/IOHandler.cpp

  105   return (m_input_sp ? m_input_sp->GetDescriptor() : -1);
  109   return (m_output_sp ? m_output_sp->GetFile().GetDescriptor() : -1);
  113   return (m_error_sp ? m_error_sp->GetFile().GetDescriptor() : -1);
  117   return (m_input_sp ? m_input_sp->GetStream() : nullptr);
  121   return (m_output_sp ? m_output_sp->GetFile().GetStream() : nullptr);
  125   return (m_error_sp ? m_error_sp->GetFile().GetStream() : nullptr);
  135   return GetInputFileSP() ? GetInputFileSP()->GetIsInteractive() : false;
  139   return GetInputFileSP() ? GetInputFileSP()->GetIsRealTerminal() : false;
  274                  m_input_sp && m_input_sp->GetIsRealTerminal();
  356         m_output_sp->Printf("%s", prompt);
  357         m_output_sp->Flush();
  377       Status error = m_input_sp->Read((void *)buffer, bytes_read);
  523           m_output_sp->Printf("%u%s",
 1011     subwindow_sp->m_is_subwin = subwindow_sp.operator bool();
 1012     subwindow_sp->m_parent = this;
 1018     ::top_panel(subwindow_sp->m_panel);
 1056       if ((*pos)->m_name == name)
 1067       (*pos)->Erase();
 1118     if (m_delegate_sp && m_delegate_sp->WindowDelegateDraw(*this, force))
 1122       subwindow_sp->Draw(force);
 1127       const char *text = m_delegate_sp->WindowDelegateGetHelpText();
 1128       KeyHelp *key_help = m_delegate_sp->WindowDelegateGetKeyHelp();
 1163         help_window_sp->SetDelegate(
 1176       result = active_window_sp->HandleChar(key);
 1182       result = m_delegate_sp->WindowDelegateHandleChar(*this, key);
 1193       if (!subwindow_sp->m_can_activate) {
 1194         HandleCharResult result = subwindow_sp->HandleChar(key);
 1216             if (m_subwindows[i]->GetCanBeActive()) {
 1253         if (subwindow_sp->GetCanBeActive()) {
 1264         if (m_subwindows[idx]->GetCanBeActive()) {
 1272           if (m_subwindows[idx]->GetCanBeActive()) {
 1281         if (m_subwindows[idx]->GetCanBeActive()) {
 1350       result = m_delegate_sp->MenuDelegateAction(menu);
 1454   menu_sp->m_parent = this;
 1455   if (static_cast<size_t>(m_max_submenu_name_length) < menu_sp->m_name.size())
 1456     m_max_submenu_name_length = menu_sp->m_name.size();
 1458       menu_sp->m_key_name.size())
 1459     m_max_submenu_key_name_length = menu_sp->m_key_name.size();
 1559       submenus[i]->DrawMenuTitle(window, is_selected);
 1615         if (submenus[i]->GetKeyValue() == key) {
 1629       if (run_menu_sp->Action() == MenuActionResult::Quit)
 1633       menu_bounds.origin.x = run_menu_sp->GetStartingColumn();
 1635       menu_bounds.size.width = run_menu_sp->GetDrawWidth();
 1636       menu_bounds.size.height = run_menu_sp->GetSubmenus().size() + 2;
 1641           run_menu_sp->GetName().c_str(), menu_bounds, true);
 1642       m_menu_window_sp->SetDelegate(run_menu_sp);
 1652           if (m_submenus[m_selected]->GetType() == Type::Separator)
 1667           if (m_submenus[m_selected]->GetType() == Type::Separator)
 1678         if (submenus[selected_idx]->Action() == MenuActionResult::Quit)
 1762         m_window_sp->Draw(false);
 1770         m_window_sp->MoveCursor(0, 0);
 1814       int ch = m_window_sp->GetChar();
 1823           while (listener_sp->PeekAtNextEvent()) {
 1824             listener_sp->GetEvent(event_sp, std::chrono::seconds(0));
 1827               Broadcaster *broadcaster = event_sp->GetBroadcaster();
 1843         HandleCharResult key_result = m_window_sp->HandleChar(ch);
 1907     auto stop_id = process_sp->GetStopID();
 2403             frame_sp->GetSymbolContext(eSymbolContextEverything);
 2421       thread->GetProcess()->GetThreadList().SetSelectedThreadByID(
 2455       return process_sp->GetThreadList().FindThreadByID(item.GetIdentifier());
 2474     if (process_sp && process_sp->IsAlive()) {
 2475       StateType state = process_sp->GetState();
 2479           if (m_stop_id == process_sp->GetStopID() &&
 2480               thread_sp->GetID() == m_tid)
 2487           m_stop_id = process_sp->GetStopID();
 2488           m_tid = thread_sp->GetID();
 2491           size_t num_frames = thread_sp->GetStackFrameCount();
 2506     if (process_sp && process_sp->IsAlive()) {
 2507       StateType state = process_sp->GetState();
 2511           ThreadList &thread_list = thread_sp->GetProcess()->GetThreadList();
 2511           ThreadList &thread_list = thread_sp->GetProcess()->GetThreadList();
 2514           if (selected_thread_sp->GetID() != thread_sp->GetID()) {
 2514           if (selected_thread_sp->GetID() != thread_sp->GetID()) {
 2515             thread_list.SetSelectedThreadByID(thread_sp->GetID());
 2551     if (process_sp && process_sp->IsAlive()) {
 2564     if (process_sp && process_sp->IsAlive()) {
 2565       StateType state = process_sp->GetState();
 2567         const uint32_t stop_id = process_sp->GetStopID();
 2581         ThreadList &threads = process_sp->GetThreadList();
 2586           item[i].SetIdentifier(threads.GetThreadAtIndex(i)->GetID());
 3057           const uint32_t num_sets = reg_ctx->GetRegisterSetCount();
 3571           thread_menu_title.Printf("Thread %u", thread_sp->GetIndexID());
 3572           const char *thread_name = thread_sp->GetName();
 3576             const char *queue_name = thread_sp->GetQueueName();
 3582                               nullptr, menu_char, thread_sp->GetID())));
 3597       WindowSP source_window_sp = main_window_sp->FindSubWindow("Source");
 3598       WindowSP variables_window_sp = main_window_sp->FindSubWindow("Variables");
 3599       WindowSP registers_window_sp = main_window_sp->FindSubWindow("Registers");
 3600       const Rect source_bounds = source_window_sp->GetBounds();
 3603         const Rect variables_bounds = variables_window_sp->GetBounds();
 3605         main_window_sp->RemoveSubWindow(variables_window_sp.get());
 3612           registers_window_sp->SetBounds(registers_bounds);
 3616           source_window_sp->Resize(source_bounds.size.width,
 3626           const Rect variables_bounds = registers_window_sp->GetBounds();
 3630           registers_window_sp->SetBounds(new_registers_rect);
 3636           source_window_sp->SetBounds(new_source_rect);
 3638         WindowSP new_window_sp = main_window_sp->CreateSubWindow(
 3640         new_window_sp->SetDelegate(
 3649       WindowSP source_window_sp = main_window_sp->FindSubWindow("Source");
 3650       WindowSP variables_window_sp = main_window_sp->FindSubWindow("Variables");
 3651       WindowSP registers_window_sp = main_window_sp->FindSubWindow("Registers");
 3652       const Rect source_bounds = source_window_sp->GetBounds();
 3656           const Rect variables_bounds = variables_window_sp->GetBounds();
 3660           variables_window_sp->Resize(variables_bounds.size.width +
 3661                                           registers_window_sp->GetWidth(),
 3666           source_window_sp->Resize(source_bounds.size.width,
 3668                                        registers_window_sp->GetHeight());
 3670         main_window_sp->RemoveSubWindow(registers_window_sp.get());
 3677           const Rect variables_bounds = variables_window_sp->GetBounds();
 3681           variables_window_sp->SetBounds(new_vars_rect);
 3687           source_window_sp->SetBounds(new_source_rect);
 3690             main_window_sp->CreateSubWindow("Registers", new_regs_rect, false);
 3691         new_window_sp->SetDelegate(
 3699       m_app.GetMainWindow()->CreateHelpSubwindow();
 3857         m_sc = frame_sp->GetSymbolContext(eSymbolContextEverything);
 3860               "%s", m_sc.module_sp->GetFileSpec().GetFilename().GetCString());
 3865         const uint32_t frame_idx = frame_sp->GetFrameIndex();
 3886           if (m_file_sp && m_file_sp->FileSpecMatches(m_sc.line_entry.file)) {
 3904               const size_t num_lines = m_file_sp->GetNumLines();
 3920         if (!m_file_sp || m_file_sp->GetNumLines() == 0) {
 3985           const size_t num_bps_locs = bp_sp->GetNumLocations();
 3988                 bp_sp->GetLocationAtIndex(bp_loc_idx);
 3990             if (bp_loc_sp->GetAddress().CalculateSymbolContextLineEntry(
 3992               if (m_file_sp->GetFileSpec() == bp_loc_line_entry.file) {
 4040               m_file_sp->GetLineLength(curr_line + 1, false);
 4042             window.PutCString(m_file_sp->PeekLineData(curr_line + 1), line_len);
 4045               frame_sp->GetConcreteFrameIndex() == 0) {
 4050               const char *stop_description = stop_info_sp->GetDescription();
 4081             const size_t num_bps_locs = bp_sp->GetNumLocations();
 4085                   bp_sp->GetLocationAtIndex(bp_loc_idx);
 4088                   bp_loc_sp->GetAddress().GetFileAddress();
 4102         InstructionList &insts = m_disassembly_sp->GetInstructionList();
 4106           pc_address = frame_sp->GetFrameCodeAddress();
 4192               frame_sp->GetConcreteFrameIndex() == 0) {
 4197               const char *stop_description = stop_info_sp->GetDescription();
 4228       return m_file_sp->GetNumLines();
 4234       return m_disassembly_sp->GetInstructionList().GetSize();
 4293               m_file_sp->GetFileSpec(), // Source file
 4304           bp_sp->GetOptions()->SetOneShot(true);
 4308         const Instruction *inst = m_disassembly_sp->GetInstructionList()
 4320           bp_sp->GetOptions()->SetOneShot(true);
 4333               m_file_sp->GetFileSpec(), // Source file
 4345         const Instruction *inst = m_disassembly_sp->GetInstructionList()
 4482     exit_menuitem_sp->SetCannedResult(MenuActionResult::Quit);
 4483     lldb_menu_sp->AddSubmenu(MenuSP(new Menu(
 4485     lldb_menu_sp->AddSubmenu(MenuSP(new Menu(Menu::Type::Separator)));
 4486     lldb_menu_sp->AddSubmenu(exit_menuitem_sp);
 4490     target_menu_sp->AddSubmenu(MenuSP(new Menu(
 4492     target_menu_sp->AddSubmenu(MenuSP(new Menu(
 4497     process_menu_sp->AddSubmenu(MenuSP(new Menu(
 4499     process_menu_sp->AddSubmenu(MenuSP(new Menu(
 4501     process_menu_sp->AddSubmenu(MenuSP(new Menu(
 4503     process_menu_sp->AddSubmenu(MenuSP(new Menu(Menu::Type::Separator)));
 4504     process_menu_sp->AddSubmenu(
 4507     process_menu_sp->AddSubmenu(MenuSP(new Menu(
 4509     process_menu_sp->AddSubmenu(MenuSP(new Menu(
 4514     thread_menu_sp->AddSubmenu(MenuSP(new Menu(
 4516     thread_menu_sp->AddSubmenu(
 4519     thread_menu_sp->AddSubmenu(MenuSP(new Menu(
 4524     view_menu_sp->AddSubmenu(
 4527     view_menu_sp->AddSubmenu(
 4530     view_menu_sp->AddSubmenu(MenuSP(new Menu(
 4532     view_menu_sp->AddSubmenu(
 4538     help_menu_sp->AddSubmenu(MenuSP(new Menu(
 4545     menubar_sp->AddSubmenu(lldb_menu_sp);
 4546     menubar_sp->AddSubmenu(target_menu_sp);
 4547     menubar_sp->AddSubmenu(process_menu_sp);
 4548     menubar_sp->AddSubmenu(thread_menu_sp);
 4549     menubar_sp->AddSubmenu(view_menu_sp);
 4550     menubar_sp->AddSubmenu(help_menu_sp);
 4551     menubar_sp->SetDelegate(app_menu_delegate_sp);
 4553     Rect content_bounds = main_window_sp->GetFrame();
 4566         main_window_sp->CreateSubWindow("Menubar", menubar_bounds, false);
 4569     menubar_window_sp->SetCanBeActive(
 4571     menubar_window_sp->SetDelegate(menubar_sp);
 4574         main_window_sp->CreateSubWindow("Source", source_bounds, true));
 4576         main_window_sp->CreateSubWindow("Variables", variables_bounds, false));
 4578         main_window_sp->CreateSubWindow("Threads", threads_bounds, false));
 4580         main_window_sp->CreateSubWindow("Status", status_bounds, false));
 4581     status_window_sp->SetCanBeActive(
 4583     main_window_sp->SetDelegate(
 4585     source_window_sp->SetDelegate(
 4587     variables_window_sp->SetDelegate(
 4590     threads_window_sp->SetDelegate(WindowDelegateSP(
 4592     status_window_sp->SetDelegate(
 4599       main_window_sp->CreateHelpSubwindow();

tools/lldb/source/Core/Module.cpp

  298           process_sp->ReadMemory(header_addr, data_up->GetBytes(),
  312           m_arch = m_objfile_sp->GetArchitecture();
  316           m_arch.MergeFrom(process_sp->GetTarget().GetArchitecture());
  452   if (section_sp && section_sp->GetModule().get() == this) {
  496           if (ObjectFile *obj_file = sc.module_sp->GetObjectFile())
 1240           m_arch.MergeFrom(m_objfile_sp->GetArchitecture());
 1422             if (section_sp->GetObjectFile() == obj_file) {
 1453         if (section_sp->GetLoadBaseAddress(target) != LLDB_INVALID_ADDRESS) {
 1486     FileSpecList file_specs = platform_sp->LocateExecutableScriptingResources(

tools/lldb/source/Core/ModuleList.cpp

   79   m_collection_sp->Initialize(g_modulelist_properties);
   88   return m_collection_sp->GetPropertyAtIndexAsBoolean(
   93   return m_collection_sp->SetPropertyAtIndexAsBoolean(
   99       ->GetPropertyAtIndexAsOptionValueFileSpec(nullptr, false,
  105   return m_collection_sp->SetPropertyAtIndexAsString(
  155     ModuleSpec equivalent_module_spec(module_sp->GetFileSpec(),
  156                                       module_sp->GetArchitecture());
  158         module_sp->GetPlatformFileSpec();
  163       if (module_sp->MatchesModuleSpec(equivalent_module_spec))
  341       (*pos)->FindFunctions(lookup_info.GetLookupName(), nullptr,
  354       (*pos)->FindFunctions(name, nullptr, name_type_mask, include_symbols,
  371       (*pos)->FindFunctionSymbols(lookup_info.GetLookupName(),
  383       (*pos)->FindFunctionSymbols(name, name_type_mask, sc_list);
  394     (*pos)->FindFunctions(name, include_symbols, include_inlines, sc_list);
  403     (*pos)->FindCompileUnits(path, sc_list);
  412     (*pos)->FindGlobalVariables(name, nullptr, max_matches, variable_list);
  422     (*pos)->FindGlobalVariables(regex, max_matches, variable_list);
  432     (*pos)->FindSymbolsWithNameAndType(name, symbol_type, sc_list);
  441     (*pos)->FindSymbolsMatchingRegExAndType(regex, symbol_type, sc_list);
  450     if (module_sp->MatchesModuleSpec(module_spec))
  481       if ((*pos)->GetUUID() == uuid) {
  514       (*pos)->FindTypes(name, name_is_fully_qualified, max_matches,
  527     if ((*pos)->FindSourceFile(orig_spec, new_spec))
  541     (*pos)->FindAddressesForLine(target_sp, file, line, function, output_local,
  552     if (module_sp->MatchesModuleSpec(module_spec))
  575     (*pos)->Dump(s);
  601     if ((*pos)->ResolveFileAddress(vm_addr, so_addr))
  617         module_sp->ResolveSymbolContextForAddress(so_addr, resolve_scope, sc);
  623           (*pos)->ResolveSymbolContextForAddress(so_addr, resolve_scope, sc);
  646     (*pos)->ResolveSymbolContextsForFileSpec(file_spec, line, check_inlines,
  749         if (module_sp->FileHasChanged()) {
  777   if (module_sp->GetObjectFile()) {
  780     if (uuid_ptr && *uuid_ptr != module_sp->GetUUID()) {
  783       if (module_sp->GetObjectFile() &&
  784           module_sp->GetObjectFile()->GetType() ==
  816       if (module_sp->GetObjectFile()) {
  819         if (uuid_ptr && *uuid_ptr != module_sp->GetUUID()) {
  822           if (module_sp->GetObjectFile()->GetType() ==
  903           if (file_spec_mod_time != module_sp->GetModificationTime()) {
  919       if (module_sp && module_sp->GetObjectFile()) {
  920         if (module_sp->GetObjectFile()->GetType() ==
  975       if (!module->LoadScriptingResourceInTarget(target, error,
  980                                          module->GetFileSpec()

tools/lldb/source/Core/PluginManager.cpp

 2363         parent_properties_sp->GetSubProperty(nullptr, g_property_name);
 2367       parent_properties_sp->AppendProperty(
 2374           plugin_properties_sp->GetSubProperty(nullptr, plugin_type_name);
 2378         plugin_properties_sp->AppendProperty(plugin_type_name, plugin_type_desc,
 2398         parent_properties_sp->GetSubProperty(nullptr, plugin_type_name);
 2402       parent_properties_sp->AppendProperty(plugin_type_name, plugin_type_desc,
 2408           plugin_properties_sp->GetSubProperty(nullptr, g_property_name);
 2412         plugin_properties_sp->AppendProperty(
 2440         plugin_type_properties_sp->GetSubProperty(nullptr, setting_name);
 2456       plugin_type_properties_sp->AppendProperty(properties_sp->GetName(),
 2456       plugin_type_properties_sp->AppendProperty(properties_sp->GetName(),
 2564         plugin_type_properties_sp->GetSubProperty(nullptr, setting_name);
 2577       plugin_type_properties_sp->AppendProperty(properties_sp->GetName(),
 2577       plugin_type_properties_sp->AppendProperty(properties_sp->GetName(),

tools/lldb/source/Core/SearchFilter.cpp

  166   ret_sp->SetTarget(target_sp);
  174   if (!options_dict_sp || !options_dict_sp->IsValid())
  178   type_dict_sp->AddStringItem(GetSerializationSubclassKey(), GetFilterName());
  179   type_dict_sp->AddItem(GetSerializationSubclassOptionsKey(), options_dict_sp);
  195     module_array_sp->AddItem(std::make_shared<StructuredData::String>(
  198   options_dict_sp->AddItem(GetKey(name), module_array_sp);
  260       const ModuleList &target_images = m_target_sp->GetImages();
  298     const size_t num_comp_units = module_sp->GetNumCompileUnits();
  300       CompUnitSP cu_sp(module_sp->GetCompileUnitAtIndex(i));
  319           SymbolFile *sym_file = module_sp->GetSymbolFile();
  325           cu_sp->ForeachFunction([&](const FunctionSP &func_sp) {
  377   return !m_target_sp->ModuleIsExcludedForUnconstrainedSearches(module_spec);
  384   else if (m_target_sp->ModuleIsExcludedForUnconstrainedSearches(module_sp))
  406           FileSpec::Equal(module_sp->GetFileSpec(), m_module_spec, false));
  440   const ModuleList &target_modules = m_target_sp->GetImages();
  507   module_array_sp->AddItem(
  509   options_dict_sp->AddItem(GetKey(OptionNames::ModList), module_array_sp);
  540                           0, module_sp->GetFileSpec(), false) != UINT32_MAX;
  577   const ModuleList &target_modules = m_target_sp->GetImages();
  787   const ModuleList &target_images = m_target_sp->GetImages();
  795         m_module_spec_list.FindFileIndex(0, module_sp->GetFileSpec(), false) !=
  805         const size_t num_cu = module_sp->GetNumCompileUnits();
  807           CompUnitSP cu_sp = module_sp->GetCompileUnitAtIndex(cu_idx);

tools/lldb/source/Core/Section.cpp

  202     return parent_sp->GetFileAddress() + m_file_addr;
  212       return parent_sp->SetFileAddress(m_file_addr - file_addr);
  235     load_base_addr = parent_sp->GetLoadBaseAddress(target);
  343     parent_sp->DumpName(s);
  355       name = module_sp->GetFileSpec().GetFilename().AsCString();
  367     return parent_sp->IsDescendant(section);
  471     if ((*sect_iter)->GetID() == sect_id) {
  476               ->GetChildren()
  489       count += (*sect_iter)->GetChildren().GetNumSections(depth - 1);
  532       if ((*sect_iter)->GetID() == sect_id) {
  536         sect_sp = (*sect_iter)->GetChildren().FindSectionByID(sect_id);
  549     if (m_sections[idx]->GetType() == sect_type) {
  553       sect_sp = m_sections[idx]->GetChildren().FindSectionByType(
  609     (*sect_iter)->Dump(s, target_has_loaded_sections ? target : nullptr, depth);
  620     if ((*pos)->Slide(slide_amount, slide_children))

tools/lldb/source/Core/SourceManager.cpp

   56       m_debugger_wp(target_sp->GetDebugger().shared_from_this()) {}
   67       m_last_file_sp && m_last_file_sp->FileSpecMatches(file_spec);
   74     file_sp = debugger_sp->GetSourceFileCache().FindSourceFile(file_spec);
   81       file_sp->GetSourceMapModificationID() !=
   82           target_sp->GetSourcePathMap().GetModificationID())
   87     file_sp->UpdateIfNeeded();
   90   if (!file_sp || !FileSystem::Instance().Exists(file_sp->GetFileSpec())) {
   97       debugger_sp->GetSourceFileCache().AddSourceFile(file_sp);
  108   if (!debugger_sp->GetUseColor())
  111   return debugger_sp->GetHighlightSource();
  122   if (!debugger_sp->GetUseColor())
  128   const auto value = debugger_sp->GetStopShowColumn();
  141   const auto value = debugger_sp->GetStopShowColumn();
  142   if ((value == eStopShowColumnAnsiOrCaret) && !debugger_sp->GetUseColor())
  178       if (!m_last_file_sp->LineIsValid(line)) {
  204           m_last_file_sp->DisplaySourceLines(line, columnToHighlight, 0, 0, s);
  209         m_last_file_sp->GetLine(line, src_line);
  310     file_spec = m_last_file_sp->GetFileSpec();
  321       Module *executable_ptr = target_sp->GetExecutableModulePointer();
  340               file_spec = m_last_file_sp->GetFileSpec();
  361   return file_sp->FindLinesMatchingRegex(regex, start_line, end_line,
  467   if (line_offset < m_data_sp->GetByteSize())
  468     return (const char *)m_data_sp->GetBytes() + line_offset;
  480     end_offset = m_data_sp->GetByteSize();
  486           (const char *)m_data_sp->GetBytes() + start_offset;
  548     style.selected.Set(debugger_sp->GetStopShowColumnAnsiPrefix(),
  549                        debugger_sp->GetStopShowColumnAnsiSuffix());
  564       end_line_offset = m_data_sp->GetByteSize();
  569       const uint8_t *cstr = m_data_sp->GetBytes() + start_line_offset;
  627       const char *start = (char *)m_data_sp->GetBytes();
  629         const char *end = start + m_data_sp->GetByteSize();
  675     end_offset = m_data_sp->GetByteSize();
  677   buffer.assign((char *)m_data_sp->GetBytes() + start_offset,

tools/lldb/source/Core/StreamFile.cpp

   65 void StreamFile::Flush() { m_file_sp->Flush(); }
   68   m_file_sp->Write(s, length);

tools/lldb/source/Core/UserSettingsController.cpp

   39     return properties_sp->GetSubValue(exe_ctx, path, will_modify, error);
   49     return properties_sp->SetSubValue(exe_ctx, op, path, value);
   59     return properties_sp->DumpValue(exe_ctx, strm, dump_mask);
   68     return properties_sp->DumpAllDescriptions(interpreter, strm);
   77     return properties_sp->DumpPropertyValue(exe_ctx, strm, property_path,
   90     properties_sp->Apropos(keyword, matching_properties);
  100     return properties_sp->GetSubProperty(exe_ctx, name);

tools/lldb/source/Core/ValueObject.cpp

  343           process_sp->GetLanguageRuntime(GetObjectRuntimeLanguage())) {
  816         module_sp->ResolveFileAddress(addr, so_addr);
  949   memcpy(destination->GetBytes(), source.GetString().data(), source.GetSize());
 1012         memcpy(buffer_sp->GetBytes(), cstr, cstr_len);
 1104   auto outcome = m_type_validator_sp->FormatObject(this);
 1308         options.SetSourceSize(buffer_sp->GetByteSize());
 1724   if (!GetVariable() || !GetVariable()->IsArtificial())
 1727   if (auto *runtime = process->GetLanguageRuntime(GetVariable()->GetLanguage()))
 1948   if (target_sp && !target_sp->GetEnableSyntheticValue()) {
 2981       process_sp = target_sp->GetProcessSP();
 2984       m_mod_id = process_sp->GetModID();
 2991           thread_sp = process_sp->GetThreadList().GetSelectedThread();
 3000             frame_sp = thread_sp->GetSelectedFrame();
 3093     m_mod_id = process_sp->GetModID();
 3150   target_sp->EvaluateExpression(expression, exe_ctx.GetFrameSP().get(),
 3258               frame_sp->GetSymbolContext(eSymbolContextCompUnit));
 3298       target_sp->GetPersistentExpressionStateForLanguage(
 3313   clang_var_sp->m_live_sp = clang_var_sp->m_frozen_sp;
 3313   clang_var_sp->m_live_sp = clang_var_sp->m_frozen_sp;
 3314   clang_var_sp->m_flags |= ExpressionVariable::EVIsProgramReference;
 3316   return clang_var_sp->GetValueObject();
 3348     return target_sp->IsValid();
 3357   const uint32_t current_stop_id = process_sp->GetLastNaturalStopID();

tools/lldb/source/Core/ValueObjectChild.cpp

  144             if (process_sp && process_sp->IsAlive())

tools/lldb/source/Core/ValueObjectConstResult.cpp

  111   m_value.GetScalar() = (uintptr_t)data_sp->GetBytes();

tools/lldb/source/Core/ValueObjectMemory.cpp

  108     return m_type_sp->GetForwardCompilerType();
  114     return m_type_sp->GetName();
  120     return m_type_sp->GetForwardCompilerType().GetDisplayTypeName();
  126     auto child_count = m_type_sp->GetNumChildren(true);
  139     return m_type_sp->GetByteSize().getValueOr(0);

tools/lldb/source/Core/ValueObjectRegister.cpp

   65   auto reg_set_count = m_reg_ctx_sp->GetRegisterSetCount();
  119   m_reg_set = reg_ctx->GetRegisterSet(m_reg_set_idx);
  138   const RegisterSet *reg_set = m_reg_ctx_sp->GetRegisterSet(m_reg_set_idx);
  158       const RegisterSet *reg_set = m_reg_ctx_sp->GetRegisterSet(m_reg_set_idx);
  195         m_reg_ctx_sp->GetRegisterInfoByName(name.AsCString());
  210         m_reg_ctx_sp->GetRegisterInfoByName(name.AsCString());
  221   const RegisterInfo *reg_info = m_reg_ctx_sp->GetRegisterInfoAtIndex(reg_num);
  304     if (m_reg_ctx_sp->ReadRegister(&m_reg_info, m_reg_value)) {
  331     if (m_reg_ctx_sp->WriteRegister(&m_reg_info, m_reg_value)) {
  343     if (m_reg_ctx_sp->WriteRegister(&m_reg_info, m_reg_value)) {

tools/lldb/source/Core/ValueObjectSyntheticFilter.cpp

  130   if (m_synth_sp->WantsDereference())
  141   m_synth_filter_up = (m_synth_sp->GetFrontEnd(*valobj_for_frontend));

tools/lldb/source/Core/ValueObjectVariable.cpp

   61   m_name = var_sp->GetName();
   67   Type *var_type = m_variable_sp->GetType();
   74   Type *var_type = m_variable_sp->GetType();
   81   Type *var_type = m_variable_sp->GetType();
   88   Type *var_type = m_variable_sp->GetType();
  119     return m_variable_sp->GetScope();
  231       return m_variable_sp->IsInScope(frame);
  245     SymbolContextScope *sc_scope = m_variable_sp->GetSymbolContextScope();
  255     return m_variable_sp->GetSymbolContextScope();
  261     decl = m_variable_sp->GetDeclaration();

tools/lldb/source/DataFormatters/DataVisualization.cpp

  117   GetFormatManager().GetCategory(category)->Clear(
  123   if (GetFormatManager().GetCategory(category)->IsEnabled())
  136   if (GetFormatManager().GetCategory(category)->IsEnabled())
  149     if (category->IsEnabled())
  157   if (category.get() && category->IsEnabled())

tools/lldb/source/DataFormatters/FormatManager.cpp

  301     if (!category_sp->IsEnabled())
  304         category_sp->GetFormatForType(type_sp);
  307          (prio_category > category_sp->GetEnabledPosition()))) {
  308       prio_category = category_sp->GetEnabledPosition();
  325     if (!category_sp->IsEnabled())
  328         category_sp->GetSummaryForType(type_sp);
  331          (prio_category > category_sp->GetEnabledPosition()))) {
  332       prio_category = category_sp->GetEnabledPosition();
  349     if (!category_sp->IsEnabled())
  352         (TypeFilterImpl *)category_sp->GetFilterForType(type_sp).get());
  355          (prio_category > category_sp->GetEnabledPosition()))) {
  356       prio_category = category_sp->GetEnabledPosition();
  373     if (!category_sp->IsEnabled())
  376         (ScriptedSyntheticChildren *)category_sp->GetSyntheticForType(type_sp)
  380          (prio_category > category_sp->GetEnabledPosition()))) {
  381       prio_category = category_sp->GetEnabledPosition();
  398     if (!category_sp->IsEnabled())
  401         category_sp->GetValidatorForType(type_sp).get());
  404          (prio_category > category_sp->GetEnabledPosition()))) {
  405       prio_category = category_sp->GetEnabledPosition();
  471       !valobj.GetTargetSP()->GetDebugger().GetAutoOneLineSummaries())
  476     return valobj.GetSummaryFormat()->IsOneLiner();
  545       if (child_sp->GetSummaryFormat()->DoesPrintChildren(child_sp.get()))
  681   if (match_data.GetTypeForCache() && (!retval || !retval->NonCacheable())) {
  755   if (match_data.GetTypeForCache() && (!retval || !retval->NonCacheable())) {
  830   if (match_data.GetTypeForCache() && (!retval || !retval->NonCacheable())) {
  890   if (match_data.GetTypeForCache() && (!retval || !retval->NonCacheable())) {
  960   sys_category_sp->GetTypeSummariesContainer()->Add(ConstString("char *"),
  960   sys_category_sp->GetTypeSummariesContainer()->Add(ConstString("char *"),
  962   sys_category_sp->GetTypeSummariesContainer()->Add(
  962   sys_category_sp->GetTypeSummariesContainer()->Add(
  964   sys_category_sp->GetRegexTypeSummariesContainer()->Add(
  964   sys_category_sp->GetRegexTypeSummariesContainer()->Add(
  978   sys_category_sp->GetTypeSummariesContainer()->Add(ConstString("OSType"),
  978   sys_category_sp->GetTypeSummariesContainer()->Add(ConstString("OSType"),

tools/lldb/source/DataFormatters/FormattersHelpers.cpp

   31     category_sp->GetRegexTypeFormatsContainer()->Add(
   31     category_sp->GetRegexTypeFormatsContainer()->Add(
   34     category_sp->GetTypeFormatsContainer()->Add(std::move(type_name),
   34     category_sp->GetTypeFormatsContainer()->Add(std::move(type_name),
   42     category_sp->GetRegexTypeSummariesContainer()->Add(
   42     category_sp->GetRegexTypeSummariesContainer()->Add(
   45     category_sp->GetTypeSummariesContainer()->Add(std::move(type_name),
   45     category_sp->GetTypeSummariesContainer()->Add(std::move(type_name),
   55     category_sp->GetRegexTypeSummariesContainer()->Add(
   55     category_sp->GetRegexTypeSummariesContainer()->Add(
   58     category_sp->GetTypeSummariesContainer()->Add(std::move(type_name),
   58     category_sp->GetTypeSummariesContainer()->Add(std::move(type_name),
   69     category_sp->GetRegexTypeSummariesContainer()->Add(
   69     category_sp->GetRegexTypeSummariesContainer()->Add(
   72     category_sp->GetTypeSummariesContainer()->Add(std::move(type_name),
   72     category_sp->GetTypeSummariesContainer()->Add(std::move(type_name),
   83     category_sp->GetRegexTypeSummariesContainer()->Add(
   83     category_sp->GetRegexTypeSummariesContainer()->Add(
   86     category_sp->GetTypeSummariesContainer()->Add(std::move(type_name),
   86     category_sp->GetTypeSummariesContainer()->Add(std::move(type_name),
   98     category_sp->GetRegexTypeSyntheticsContainer()->Add(
   98     category_sp->GetRegexTypeSyntheticsContainer()->Add(
  101     category_sp->GetTypeSyntheticsContainer()->Add(std::move(type_name),
  101     category_sp->GetTypeSyntheticsContainer()->Add(std::move(type_name),
  111     filter_sp->AddExpressionPath(child);
  113     category_sp->GetRegexTypeFiltersContainer()->Add(
  113     category_sp->GetRegexTypeFiltersContainer()->Add(
  116     category_sp->GetTypeFiltersContainer()->Add(std::move(type_name),
  116     category_sp->GetTypeFiltersContainer()->Add(std::move(type_name),

tools/lldb/source/DataFormatters/LanguageCategory.cpp

   52       m_category_sp->Get(valobj, match_data.GetMatchesVector(), format_sp);
   54       (!format_sp || !format_sp->NonCacheable())) {
   75       m_category_sp->Get(valobj, match_data.GetMatchesVector(), format_sp);
   77       (!format_sp || !format_sp->NonCacheable())) {
   98       m_category_sp->Get(valobj, match_data.GetMatchesVector(), format_sp);
  100       (!format_sp || !format_sp->NonCacheable())) {
  121       m_category_sp->Get(valobj, match_data.GetMatchesVector(), format_sp);
  123       (!format_sp || !format_sp->NonCacheable())) {
  143       (!format_sp || !format_sp->NonCacheable())) {
  163       (!format_sp || !format_sp->NonCacheable())) {
  183       (!format_sp || !format_sp->NonCacheable())) {
  203       (!format_sp || !format_sp->NonCacheable())) {
  217     m_category_sp->Enable(true, TypeCategoryMap::Default);
  223     m_category_sp->Disable();

tools/lldb/source/DataFormatters/StringPrinter.cpp

  312       utf8_data_ptr = (llvm::UTF8 *)utf8_data_buffer_sp->GetBytes();
  313       utf8_data_end_ptr = utf8_data_ptr + utf8_data_buffer_sp->GetByteSize();
  321           (llvm::UTF8 *)utf8_data_buffer_sp->GetBytes();
  387       valobj.GetTargetSP()->GetDebugger().GetEscapeNonPrintables());
  394       valobj.GetTargetSP()->GetDebugger().GetEscapeNonPrintables());
  427   const auto max_size = process_sp->GetTarget().GetMaximumSizeOfStringSummary();
  443   process_sp->ReadCStringFromMemory(
  444       options.GetLocation(), (char *)buffer_sp->GetBytes(), size, my_error);
  457   uint8_t *data_end = buffer_sp->GetBytes() + buffer_sp->GetByteSize();
  457   uint8_t *data_end = buffer_sp->GetBytes() + buffer_sp->GetByteSize();
  476   for (uint8_t *data = buffer_sp->GetBytes(); *data && (data < data_end);) {
  544   const auto max_size = process_sp->GetTarget().GetMaximumSizeOfStringSummary();
  560   if (!buffer_sp->GetBytes())
  564   char *buffer = reinterpret_cast<char *>(buffer_sp->GetBytes());
  567     process_sp->ReadStringFromMemory(options.GetLocation(), buffer,
  570     process_sp->ReadMemoryFromInferior(options.GetLocation(),
  571                                        (char *)buffer_sp->GetBytes(),
  579   DataExtractor data(buffer_sp, process_sp->GetByteOrder(),
  580                      process_sp->GetAddressByteSize());

tools/lldb/source/DataFormatters/TypeCategory.cpp

  104   if (GetTypeFormatsContainer()->Get(candidates, entry, reason))
  106   bool regex = GetRegexTypeFormatsContainer()->Get(candidates, entry, reason);
  117   if (GetTypeSummariesContainer()->Get(candidates, entry, reason))
  119   bool regex = GetRegexTypeSummariesContainer()->Get(candidates, entry, reason);
  135   if (!GetTypeFiltersContainer()->Get(candidates, filter_sp, &reason_filter))
  136     regex_filter = GetRegexTypeFiltersContainer()->Get(candidates, filter_sp,
  143   if (!GetTypeSyntheticsContainer()->Get(candidates, synth, &reason_synth))
  144     regex_synth = GetRegexTypeSyntheticsContainer()->Get(candidates, synth,
  156     pick_synth = filter_sp->GetRevision() <= synth->GetRevision();
  156     pick_synth = filter_sp->GetRevision() <= synth->GetRevision();
  177   if (GetTypeValidatorsContainer()->Get(candidates, entry, reason))
  180       GetRegexTypeValidatorsContainer()->Get(candidates, entry, reason);
  188     GetTypeFormatsContainer()->Clear();
  190     GetRegexTypeFormatsContainer()->Clear();
  193     GetTypeSummariesContainer()->Clear();
  196     GetRegexTypeSummariesContainer()->Clear();
  199     GetTypeFiltersContainer()->Clear();
  202     GetRegexTypeFiltersContainer()->Clear();
  205     GetTypeSyntheticsContainer()->Clear();
  207     GetRegexTypeSyntheticsContainer()->Clear();
  210     GetTypeValidatorsContainer()->Clear();
  213     GetRegexTypeValidatorsContainer()->Clear();
  220     success = GetTypeFormatsContainer()->Delete(name) || success;
  222     success = GetRegexTypeFormatsContainer()->Delete(name) || success;
  225     success = GetTypeSummariesContainer()->Delete(name) || success;
  228     success = GetRegexTypeSummariesContainer()->Delete(name) || success;
  231     success = GetTypeFiltersContainer()->Delete(name) || success;
  234     success = GetRegexTypeFiltersContainer()->Delete(name) || success;
  237     success = GetTypeSyntheticsContainer()->Delete(name) || success;
  239     success = GetRegexTypeSyntheticsContainer()->Delete(name) || success;
  242     success = GetTypeValidatorsContainer()->Delete(name) || success;
  245     success = GetRegexTypeValidatorsContainer()->Delete(name) || success;
  254     count += GetTypeFormatsContainer()->GetCount();
  256     count += GetRegexTypeFormatsContainer()->GetCount();
  259     count += GetTypeSummariesContainer()->GetCount();
  262     count += GetRegexTypeSummariesContainer()->GetCount();
  265     count += GetTypeFiltersContainer()->GetCount();
  268     count += GetRegexTypeFiltersContainer()->GetCount();
  271     count += GetTypeSyntheticsContainer()->GetCount();
  273     count += GetRegexTypeSyntheticsContainer()->GetCount();
  276     count += GetTypeValidatorsContainer()->GetCount();
  279     count += GetRegexTypeValidatorsContainer()->GetCount();
  298     if (GetTypeFormatsContainer()->Get(type_name, format_sp)) {
  308     if (GetRegexTypeFormatsContainer()->Get(type_name, format_sp)) {
  318     if (GetTypeSummariesContainer()->Get(type_name, summary_sp)) {
  328     if (GetRegexTypeSummariesContainer()->Get(type_name, summary_sp)) {
  338     if (GetTypeFiltersContainer()->Get(type_name, filter_sp)) {
  348     if (GetRegexTypeFiltersContainer()->Get(type_name, filter_sp)) {
  358     if (GetTypeSyntheticsContainer()->Get(type_name, synth_sp)) {
  368     if (GetRegexTypeSyntheticsContainer()->Get(type_name, synth_sp)) {
  378     if (GetTypeValidatorsContainer()->Get(type_name, validator_sp)) {
  388     if (GetRegexTypeValidatorsContainer()->Get(type_name, validator_sp)) {
  405     if (type_sp->IsRegex())
  406       GetRegexTypeFormatsContainer()->GetExact(ConstString(type_sp->GetName()),
  406       GetRegexTypeFormatsContainer()->GetExact(ConstString(type_sp->GetName()),
  409       GetTypeFormatsContainer()->GetExact(ConstString(type_sp->GetName()),
  409       GetTypeFormatsContainer()->GetExact(ConstString(type_sp->GetName()),
  421     if (type_sp->IsRegex())
  422       GetRegexTypeSummariesContainer()->GetExact(
  423           ConstString(type_sp->GetName()), retval);
  425       GetTypeSummariesContainer()->GetExact(ConstString(type_sp->GetName()),
  425       GetTypeSummariesContainer()->GetExact(ConstString(type_sp->GetName()),
  437     if (type_sp->IsRegex())
  438       GetRegexTypeFiltersContainer()->GetExact(ConstString(type_sp->GetName()),
  438       GetRegexTypeFiltersContainer()->GetExact(ConstString(type_sp->GetName()),
  441       GetTypeFiltersContainer()->GetExact(ConstString(type_sp->GetName()),
  441       GetTypeFiltersContainer()->GetExact(ConstString(type_sp->GetName()),
  453     if (type_sp->IsRegex())
  454       GetRegexTypeSyntheticsContainer()->GetExact(
  455           ConstString(type_sp->GetName()), retval);
  457       GetTypeSyntheticsContainer()->GetExact(ConstString(type_sp->GetName()),
  457       GetTypeSyntheticsContainer()->GetExact(ConstString(type_sp->GetName()),
  469     if (type_sp->IsRegex())
  470       GetRegexTypeValidatorsContainer()->GetExact(
  471           ConstString(type_sp->GetName()), retval);
  473       GetTypeValidatorsContainer()->GetExact(ConstString(type_sp->GetName()),
  473       GetTypeValidatorsContainer()->GetExact(ConstString(type_sp->GetName()),
  482   if (index < GetTypeSummariesContainer()->GetCount())
  483     return GetTypeSummariesContainer()->GetTypeNameSpecifierAtIndex(index);
  485     return GetRegexTypeSummariesContainer()->GetTypeNameSpecifierAtIndex(
  486         index - GetTypeSummariesContainer()->GetCount());
  491   if (index < GetTypeFormatsContainer()->GetCount())
  492     return GetTypeFormatsContainer()->GetAtIndex(index);
  494     return GetRegexTypeFormatsContainer()->GetAtIndex(
  495         index - GetTypeFormatsContainer()->GetCount());
  500   if (index < GetTypeSummariesContainer()->GetCount())
  501     return GetTypeSummariesContainer()->GetAtIndex(index);
  503     return GetRegexTypeSummariesContainer()->GetAtIndex(
  504         index - GetTypeSummariesContainer()->GetCount());
  509   if (index < GetTypeFiltersContainer()->GetCount())
  510     return GetTypeFiltersContainer()->GetAtIndex(index);
  512     return GetRegexTypeFiltersContainer()->GetAtIndex(
  513         index - GetTypeFiltersContainer()->GetCount());
  518   if (index < GetTypeFormatsContainer()->GetCount())
  519     return GetTypeFormatsContainer()->GetTypeNameSpecifierAtIndex(index);
  521     return GetRegexTypeFormatsContainer()->GetTypeNameSpecifierAtIndex(
  522         index - GetTypeFormatsContainer()->GetCount());
  527   if (index < GetTypeFiltersContainer()->GetCount())
  528     return GetTypeFiltersContainer()->GetTypeNameSpecifierAtIndex(index);
  530     return GetRegexTypeFiltersContainer()->GetTypeNameSpecifierAtIndex(
  531         index - GetTypeFiltersContainer()->GetCount());
  536   if (index < GetTypeSyntheticsContainer()->GetCount())
  537     return GetTypeSyntheticsContainer()->GetAtIndex(index);
  539     return GetRegexTypeSyntheticsContainer()->GetAtIndex(
  540         index - GetTypeSyntheticsContainer()->GetCount());
  545   if (index < GetTypeSyntheticsContainer()->GetCount())
  546     return GetTypeSyntheticsContainer()->GetTypeNameSpecifierAtIndex(index);
  548     return GetRegexTypeSyntheticsContainer()->GetTypeNameSpecifierAtIndex(
  549         index - GetTypeSyntheticsContainer()->GetCount());
  554   if (index < GetTypeValidatorsContainer()->GetCount())
  555     return GetTypeValidatorsContainer()->GetAtIndex(index);
  557     return GetRegexTypeValidatorsContainer()->GetAtIndex(
  558         index - GetTypeValidatorsContainer()->GetCount());
  563   if (index < GetTypeValidatorsContainer()->GetCount())
  564     return GetTypeValidatorsContainer()->GetTypeNameSpecifierAtIndex(index);
  566     return GetRegexTypeValidatorsContainer()->GetTypeNameSpecifierAtIndex(
  567         index - GetTypeValidatorsContainer()->GetCount());

tools/lldb/source/DataFormatters/TypeCategoryMap.cpp

   79     category->Enable(true, pos);
   89     category->Disable();
  100     if (iter->second->IsEnabled())
  102     auto pos = iter->second->GetLastEnabledPosition();
  121     m_active_categories.front()->SetEnabledPosition(p);
  165     if (pos->second->AnyMatches(type_name, items, only_enabled,
  199               category_sp->GetName());
  200     if (!category_sp->Get(match_data.GetValueObject(),
  238               category_sp->GetName());
  239     if (!category_sp->Get(match_data.GetValueObject(),
  280               category_sp->GetName());
  281     if (!category_sp->Get(match_data.GetValueObject(),
  320               category_sp->GetName());
  321     if (!category_sp->Get(match_data.GetValueObject(),
  350         if (pos->second->IsEnabled())

tools/lldb/source/DataFormatters/TypeFormat.cpp

   79               size_t max_len = target_sp->GetMaximumSizeOfStringSummary();
   83               if (target_sp->ReadCStringFromMemory(
   84                       address, (char *)buffer_sp->GetBytes(), max_len, error) &&
  153     target_sp = process_sp->GetTarget().shared_from_this();
  162     const ModuleList &images(target_sp->GetImages());
  172       if ((type_sp->GetForwardCompilerType().GetTypeInfo() &
  174         valobj_enum_type = type_sp->GetFullCompilerType();

tools/lldb/source/DataFormatters/TypeSummary.cpp

  170       target_sp->GetDebugger().GetScriptInterpreter();

tools/lldb/source/DataFormatters/TypeSynthetic.cpp

  140   m_interpreter = target_sp->GetDebugger().GetScriptInterpreter();
  158   return (m_wrapper_sp && m_wrapper_sp->IsValid() && m_interpreter);

tools/lldb/source/DataFormatters/ValueObjectPrinter.cpp

  597         m_valobj->GetTargetSP()->GetMaximumNumberOfChildrenToDisplay();
  611           ->GetDebugger()
  770     if (m_printed_instance_pointers->count(instance_ptr_value)) {
  776       m_printed_instance_pointers->emplace(instance_ptr_value);

tools/lldb/source/DataFormatters/VectorType.cpp

  226           target_sp->GetScratchTypeSystemForLanguage(lldb::eLanguageTypeC);

tools/lldb/source/Expression/DWARFExpression.cpp

  539   DataEncoder encoder(heap_data_sp->GetBytes(), heap_data_sp->GetByteSize(),
  539   DataEncoder encoder(heap_data_sp->GetBytes(), heap_data_sp->GetByteSize(),
  796       return_pc = parent_frame->GetFrameCodeAddress().GetLoadAddress(&target);
  804     if (parent_frame->IsInlined())
  810   if (!parent_frame || !parent_frame->GetRegisterContext()) {
  816       parent_frame->GetSymbolContext(eSymbolContextFunction).function;
  833   if (!parent_frame->IsArtificial()) {
  914                            parent_frame->GetRegisterContext().get(),
  958       pc = reg_ctx_sp->GetPC();
 1150         if (!module_sp->ResolveFileAddress(file_addr, so_addr)) {
 2448         bit_size = module_sp->GetArchitecture().GetAddressByteSize() * 8;
 3023     reg = reg_ctx_sp->GetRegisterInfo(m_reg_kind, opcode - DW_OP_reg0);
 3026     reg = reg_ctx_sp->GetRegisterInfo(m_reg_kind, opcode - DW_OP_breg0);
 3029     reg = reg_ctx_sp->GetRegisterInfo(m_reg_kind, reg_num);
 3033     reg = reg_ctx_sp->GetRegisterInfo(m_reg_kind, reg_num);

tools/lldb/source/Expression/ExpressionVariable.cpp

   51        execution_unit_sp->GetJittedFunctions()) {
   53         jitted_function.m_name != execution_unit_sp->GetFunctionName() &&
   66        execution_unit_sp->GetJittedGlobalVariables()) {

tools/lldb/source/Expression/FunctionCaller.cpp

   57       process_sp->GetTarget().GetImages().Remove(jit_module_sp);
   93     lldb::ModuleSP jit_module_sp(m_execution_unit_sp->GetJITModule());
   99       jit_module_sp->SetFileSpecAndObjectName(jit_file, ConstString());
  255   new_plan_sp->SetIsMasterPlan(true);
  256   new_plan_sp->SetOkayToDiscard(false);

tools/lldb/source/Expression/IRExecutionUnit.cpp

  155   process->ReadMemory(func_remote_addr, buffer_sp->GetBytes(),
  156                       buffer_sp->GetByteSize(), err);
  195   disassembler_sp->DecodeInstructions(Address(func_remote_addr), extractor, 0,
  198   InstructionList &instruction_list = disassembler_sp->GetInstructionList();
  318   if (process_sp->GetTarget().GetEnableSaveObjects()) {
  661   lldb_private::SymbolFile *sym_file = sym_ctx.module_sp->GetSymbolFile();
  854       sc.module_sp->FindFunctions(spec.name, nullptr, spec.mask,
  869       sc.target_sp->GetImages().FindFunctions(spec.name, spec.mask,
  882       sc.target_sp->GetImages().FindSymbolsWithNameAndType(
  909   lldb::ProcessSP process_sp = sc.target_sp->GetProcessSP();
  916     for (LanguageRuntime *runtime : process_sp->GetLanguageRuntimes()) {
  933     lldb::addr_t symbol_load_addr = target_sp->GetPersistentSymbol(spec.name);
 1264   jit_module_sp->SetLoadAddress(*target, 0, true, changed);

tools/lldb/source/Expression/IRInterpreter.cpp

 1593       if (!call_plan_sp || !call_plan_sp->ValidatePlan(&ss)) {

tools/lldb/source/Expression/IRMemoryMap.cpp

   24     m_process_wp = target_sp->GetProcessSP();
   61   const bool process_is_alive = process_sp && process_sp->IsAlive();
   67   if (process_is_alive && process_sp->CanJIT()) {
   70     ret = process_sp->AllocateMemory(size, lldb::ePermissionsReadable |
   98     const uint64_t end_of_memory = process_sp->GetAddressByteSize() == 8
  102     lldbassert(process_sp->GetAddressByteSize() == 4 ||
  106     Status err = process_sp->GetMemoryRegionInfo(ret, region_info);
  125         err = process_sp->GetMemoryRegionInfo(
  231     return process_sp->GetByteOrder();
  236     return target_sp->GetArchitecture().GetByteOrder();
  245     return process_sp->GetAddressByteSize();
  250     return target_sp->GetArchitecture().GetAddressByteSize();
  334               process_sp && process_sp->CanJIT() ? "true" : "false",
  335               process_sp && process_sp->IsAlive() ? "true" : "false");
  336     if (process_sp && process_sp->CanJIT() && process_sp->IsAlive()) {
  336     if (process_sp && process_sp->CanJIT() && process_sp->IsAlive()) {
  339             process_sp->AllocateMemory(allocation_size, permissions, error);
  342             process_sp->CallocateMemory(allocation_size, permissions, error);
  363       if (process_sp->CanJIT() && process_sp->IsAlive()) {
  363       if (process_sp->CanJIT() && process_sp->IsAlive()) {
  366               process_sp->AllocateMemory(allocation_size, permissions, error);
  369               process_sp->CallocateMemory(allocation_size, permissions, error);
  464       if (process_sp->CanJIT() && process_sp->IsAlive())
  464       if (process_sp->CanJIT() && process_sp->IsAlive())
  465         process_sp->DeallocateMemory(
  475       process_sp->DeallocateMemory(allocation.m_process_alloc);
  524       process_sp->WriteMemory(process_address, bytes, size, error);
  562       process_sp->WriteMemory(process_address, bytes, size, error);
  570       process_sp->WriteMemory(process_address, bytes, size, error);
  634       process_sp->ReadMemory(process_address, bytes, size, error);
  642       target_sp->ReadMemory(absolute_address, false, bytes, size, error);
  686       process_sp->ReadMemory(process_address, bytes, size, error);
  701       process_sp->ReadMemory(process_address, bytes, size, error);
  819         process_sp->ReadMemory(allocation.m_process_start,

tools/lldb/source/Expression/LLVMUserExpression.cpp

   89       llvm::Module *module = m_execution_unit_sp->GetModule();
   90       llvm::Function *function = m_execution_unit_sp->GetFunction();
  147       if (!call_plan_sp || !call_plan_sp->ValidatePlan(&ss)) {
  183           lldb::StopInfoSP real_stop_info_sp = call_plan_sp->GetRealStopInfo();
  185             error_desc = real_stop_info_sp->GetDescription();
  262   m_dematerializer_sp->Dematerialize(dematerialize_error, function_stack_bottom,
  276     result->TransferAddress();
  307       m_materialized_address = m_execution_unit_sp->Malloc(
  331       m_stack_frame_bottom = m_execution_unit_sp->Malloc(
  364     return m_execution_unit_sp->GetJITModule();

tools/lldb/source/Expression/Materializer.cpp

   70         m_persistent_variable_sp->GetByteSize(), 8,
   77           m_persistent_variable_sp->GetName().GetCString(),
   83               m_persistent_variable_sp->GetName().GetCString(), mem);
   88     m_persistent_variable_sp->m_live_sp = ValueObjectConstResult::Create(
   90         m_persistent_variable_sp->GetCompilerType(),
   91         m_persistent_variable_sp->GetName(), mem, eAddressTypeLoad,
   96     if (m_persistent_variable_sp->m_flags &
  100       m_persistent_variable_sp->m_flags &=
  108     map.WriteMemory(mem, m_persistent_variable_sp->GetValueBytes(),
  109                     m_persistent_variable_sp->GetByteSize(), write_error);
  114           m_persistent_variable_sp->GetName().AsCString(),
  123     map.Free((lldb::addr_t)m_persistent_variable_sp->m_live_sp->GetValue()
  128     m_persistent_variable_sp->m_live_sp.reset();
  133           m_persistent_variable_sp->GetName().GetCString(),
  149                 m_persistent_variable_sp->GetName().AsCString(),
  150                 m_persistent_variable_sp->m_flags);
  153     if (m_persistent_variable_sp->m_flags &
  156       m_persistent_variable_sp->m_flags |=
  163     if ((m_persistent_variable_sp->m_flags &
  165          m_persistent_variable_sp->m_live_sp) ||
  166         m_persistent_variable_sp->m_flags &
  172           m_persistent_variable_sp->m_live_sp->GetValue().GetScalar(),
  178             m_persistent_variable_sp->GetName().AsCString(),
  184           m_persistent_variable_sp->GetName().AsCString());
  201                 m_persistent_variable_sp->GetName().AsCString(),
  202                 m_persistent_variable_sp->m_flags);
  209     if ((m_persistent_variable_sp->m_flags &
  211         (m_persistent_variable_sp->m_flags &
  213       if (m_persistent_variable_sp->m_flags &
  215           !m_persistent_variable_sp->m_live_sp) {
  228               m_persistent_variable_sp->GetName().GetCString(),
  233         m_persistent_variable_sp->m_live_sp = ValueObjectConstResult::Create(
  236             m_persistent_variable_sp->GetName(), location, eAddressTypeLoad,
  237             m_persistent_variable_sp->GetByteSize());
  245           m_persistent_variable_sp->m_flags |=
  247           m_persistent_variable_sp->m_flags |=
  249           m_persistent_variable_sp->m_flags |=
  251           m_persistent_variable_sp->m_flags &=
  256       lldb::addr_t mem = m_persistent_variable_sp->m_live_sp->GetValue()
  260       if (!m_persistent_variable_sp->m_live_sp) {
  263             m_persistent_variable_sp->GetName().GetCString());
  267       if (m_persistent_variable_sp->m_live_sp->GetValue()
  271             m_persistent_variable_sp->GetName().GetCString());
  275       if (m_persistent_variable_sp->m_flags &
  277           m_persistent_variable_sp->m_flags &
  280                   m_persistent_variable_sp->GetName().GetCString(),
  282                   (unsigned long long)m_persistent_variable_sp->GetByteSize());
  286         m_persistent_variable_sp->ValueUpdated();
  290         map.ReadMemory(m_persistent_variable_sp->GetValueBytes(), mem,
  291                        m_persistent_variable_sp->GetByteSize(), read_error);
  296               m_persistent_variable_sp->GetName().GetCString(),
  301         m_persistent_variable_sp->m_flags &=
  307           m_persistent_variable_sp->GetName().AsCString());
  313     if (!process_sp || !process_sp->CanJIT()) {
  317       m_persistent_variable_sp->m_flags |=
  323     } else if (m_persistent_variable_sp->m_flags &
  325                !(m_persistent_variable_sp->m_flags &
  343                        m_persistent_variable_sp->GetName().AsCString());
  372         DataBufferHeap data(m_persistent_variable_sp->GetByteSize(), 0);
  375                        m_persistent_variable_sp->GetByteSize(), err);
  419         m_variable_sp->GetType()->GetForwardCompilerType().IsReferenceType();
  431                 (uint64_t)load_addr, m_variable_sp->GetName().AsCString());
  445           m_variable_sp->GetName().AsCString());
  453                                    m_variable_sp->GetName().AsCString(),
  466             m_variable_sp->GetName().AsCString(), extract_error.AsCString());
  479                                      m_variable_sp->GetName().AsCString(),
  495               m_variable_sp->GetName().AsCString(), write_error.AsCString());
  504                                        m_variable_sp->GetName().AsCString(),
  512               m_variable_sp->GetName().AsCString());
  516         if (data.GetByteSize() < m_variable_sp->GetType()->GetByteSize()) {
  518               !m_variable_sp->LocationExpression().IsValid()) {
  521                                          m_variable_sp->GetName().AsCString());
  526                 m_variable_sp->GetName().AsCString(),
  527                 m_variable_sp->GetType()->GetByteSize().getValueOr(0),
  534             m_variable_sp->GetType()->GetLayoutCompilerType().GetTypeBitAlign(scope);
  537                                        m_variable_sp->GetName().AsCString());
  559               m_variable_sp->GetName().AsCString(), alloc_error.AsCString());
  571               m_variable_sp->GetName().AsCString(), write_error.AsCString());
  583               m_variable_sp->GetName().AsCString(),
  600                 (uint64_t)load_addr, m_variable_sp->GetName().AsCString());
  615             m_variable_sp->GetName().AsCString());
  628                                      m_variable_sp->GetName().AsCString());
  635         if ((data.GetByteSize() == m_original_data->GetByteSize()) &&
  636             !memcmp(m_original_data->GetBytes(), data.GetDataStart(),
  650               m_variable_sp->GetName().AsCString());
  662             m_variable_sp->GetName().AsCString(), free_error.AsCString());
  865         target_sp->GetScratchTypeSystemForLanguage(m_type.GetMinimumLanguage());
  908         (m_is_program_reference && process_sp && process_sp->CanJIT() &&
  912       ret->m_live_sp = ValueObjectConstResult::Create(exe_scope, m_type, name,
  917     ret->ValueUpdated();
  919     const size_t pvar_byte_size = ret->GetByteSize();
  920     uint8_t *pvar_data = ret->GetValueBytes();
  931       ret->m_flags |= ExpressionVariable::EVNeedsAllocation;
  938       ret->m_flags |= ExpressionVariable::EVIsLLDBAllocated;
 1189     lldb::RegisterContextSP reg_context_sp = frame_sp->GetRegisterContext();
 1191     if (!reg_context_sp->ReadRegister(&m_register_info, reg_value)) {
 1254     lldb::RegisterContextSP reg_context_sp = frame_sp->GetRegisterContext();
 1266     if (!memcmp(register_data.GetDataStart(), m_register_contents->GetBytes(),
 1281     if (!reg_context_sp->WriteRegister(&m_register_info, register_value)) {
 1342     dematerializer_sp->Wipe();
 1398     frame_sp = thread_sp->GetFrameWithStackID(m_stack_id);

tools/lldb/source/Expression/REPL.cpp

   83     if (m_io_handler_sp->GetIsInteractive() &&
   84         m_io_handler_sp->GetIsRealTerminal()) {
   97   if (process_sp && process_sp->IsAlive())
  100   error_sp->Printf("REPL requires a running target process.\n");
  198                                  ->GetThreadList()
  200                                  ->GetSelectedFrame()
  238               io_handler_sp->SetIsDone(true);
  254             io_handler_sp->SetIsDone(false);
  270       const bool colorize_err = error_sp->GetFile().GetIsTerminalWithColors();
  301       if (process_sp && process_sp->IsAlive()) {
  312               error_sp->PutCString("(void)\n");
  323             lldb::ValueObjectSP valobj_sp = persistent_var_sp->GetValueObject();
  331           bool useColors = error_sp->GetFile().GetIsTerminalWithColors();
  338             error_sp->Printf("%s\n", error.AsCString());
  345               error_sp->Printf(ANSI_ESCAPE1(ANSI_FG_COLOR_RED));
  346               error_sp->Printf(ANSI_ESCAPE1(ANSI_CTRL_BOLD));
  348             error_sp->Printf("Execution interrupted. ");
  350               error_sp->Printf(ANSI_ESCAPE1(ANSI_CTRL_NORMAL));
  351             error_sp->Printf("Enter code to recover and continue.\nEnter LLDB "
  359               error_sp->Printf(ANSI_ESCAPE1(ANSI_FG_COLOR_RED));
  360               error_sp->Printf(ANSI_ESCAPE1(ANSI_CTRL_BOLD));
  362             output_sp->Printf("Execution stopped at breakpoint.  ");
  364               error_sp->Printf(ANSI_ESCAPE1(ANSI_CTRL_NORMAL));
  365             output_sp->Printf("Enter LLDB commands to investigate (type help "
  370                 io_handler_sp->SetIsDone(false);
  377             error_sp->Printf("error: timeout\n");
  379               error_sp->Printf("error: %s\n", error.AsCString());
  383             error_sp->Printf("error: could not fetch result -- %s\n",
  388             error_sp->Printf("error: stopped for debug -- %s\n",
  414               error_sp->Printf("error: couldn't open %s: %s\n",
  426           output_sp->Printf("\n");
  433     if (!did_quit && (!process_sp || !process_sp->IsAlive())) {
  434       error_sp->Printf(
  503     process_sp->Destroy(false);
  504     process_sp->GetTarget().GetDebugger().ClearIOHandlers();
  552   io_handler_sp->WaitForPop();
  558     if (process_sp && process_sp->IsAlive())
  559       process_sp->Destroy(false);

tools/lldb/source/Expression/UserExpression.cpp

   66     m_address = frame_sp->GetFrameCodeAddress();
   88                                                frame_sp->GetFrameCodeAddress(),
  118   valobj_sp = frame_sp->GetValueForVariableExpressionPath(
  250       user_expression_sp->Parse(diagnostic_manager, exe_ctx, execution_policy,
  258   const char *fixed_text = user_expression_sp->GetFixedText();
  273       parse_success = fixed_expression_sp->Parse(
  307       *jit_module_sp_ptr = user_expression_sp->GetJITModule();
  312         !user_expression_sp->CanInterpret()) {
  340           user_expression_sp->Execute(diagnostic_manager, exe_ctx, options,
  356           result_valobj_sp = expr_result->GetValueObject();

tools/lldb/source/Expression/UtilityFunction.cpp

   54       process_sp->GetTarget().GetImages().Remove(jit_module_sp);
   78   m_caller_up.reset(process_sp->GetTarget().GetFunctionCallerForLanguage(

tools/lldb/source/Host/common/Editline.cpp

  427   if (!m_history_sp || !m_history_sp->IsValid())
  430   HistoryW *pHistory = m_history_sp->GetHistoryPtr();
 1006   if (m_history_sp && m_history_sp->IsValid()) {
 1007     if (!m_history_sp->Load()) {
 1010     el_wset(m_editline, EL_HIST, history, m_history_sp->GetHistoryPtr());
 1349       m_history_sp->Enter(input);
 1391     m_history_sp->Enter(CombineLines(m_input_lines).c_str());

tools/lldb/source/Host/common/FileSystem.cpp

  283     m_collector->addFile(path);
  422     m_collector->addFile(file_spec.GetPath());

tools/lldb/source/Host/common/Host.cpp

  449   shell_info->pid = pid;
  450   shell_info->signo = signo;
  451   shell_info->status = status;
  454   shell_info->process_reaped.SetValue(true, eBroadcastAlways);
  540     if (!shell_info_sp->process_reaped.WaitForValueEqualTo(true, timeout)) {
  546       shell_info_sp->process_reaped.WaitForValueEqualTo(
  550         *status_ptr = shell_info_sp->status;
  553         *signo_ptr = shell_info_sp->signo;
  567               command_output_ptr->assign(Buffer->GetChars(),
  568                                          Buffer->GetByteSize());

tools/lldb/source/Host/common/HostProcess.cpp

   23 Status HostProcess::Terminate() { return m_native_process->Terminate(); }
   26   return m_native_process->GetMainModule(file_spec);
   30   return m_native_process->GetProcessId();
   33 bool HostProcess::IsRunning() const { return m_native_process->IsRunning(); }
   38   return m_native_process->StartMonitoring(callback, monitor_signals);

tools/lldb/source/Host/common/HostThread.cpp

   21   return m_native_thread->Join(result);
   24 Status HostThread::Cancel() { return m_native_thread->Cancel(); }
   26 void HostThread::Reset() { return m_native_thread->Reset(); }
   28 lldb::thread_t HostThread::Release() { return m_native_thread->Release(); }
   30 bool HostThread::IsJoinable() const { return m_native_thread->IsJoinable(); }
   41   return m_native_thread->GetResult();
   45   return m_native_thread->EqualsThread(thread);

tools/lldb/source/Host/common/MainLoop.cpp

  280   if (!object_sp || !object_sp->IsValid()) {
  286       m_read_fds.insert({object_sp->GetWaitableHandle(), callback}).second;
  289                                    object_sp->GetWaitableHandle());

tools/lldb/source/Host/common/ProcessLaunchInfo.cpp

  221   if (!m_pty->OpenFirstAvailableMaster(open_flags, nullptr, 0)) {
  225   const FileSpec slave_file_spec(m_pty->GetSlaveName(nullptr, 0));

tools/lldb/source/Host/linux/Host.cpp

  133           {buffer_sp->GetChars(), size_t(buffer_sp->GetByteSize())})
  133           {buffer_sp->GetChars(), size_t(buffer_sp->GetByteSize())})

tools/lldb/source/Host/posix/ConnectionFileDescriptorPosix.cpp

  145   return (m_read_sp && m_read_sp->IsValid()) ||
  146          (m_write_sp && m_write_sp->IsValid());
  308   if (m_read_sp && m_read_sp->IsValid() &&
  309       m_read_sp->GetFdType() == IOObject::eFDTypeSocket)
  339   Status error = m_read_sp->Close();
  340   Status error2 = m_write_sp->Close();
  386   error = m_read_sp->Read(dst, bytes_read);
  393               static_cast<uint64_t>(m_read_sp->GetWaitableHandle()),
  412       if (m_read_sp->GetFdType() == IOObject::eFDTypeSocket)
  490   error = m_write_sp->Write(src, bytes_sent);
  497               static_cast<uint64_t>(m_write_sp->GetWaitableHandle()),
  560   const IOObject::WaitableHandle handle = m_read_sp->GetWaitableHandle();
  581     while (handle == m_read_sp->GetWaitableHandle()) {

tools/lldb/source/Interpreter/CommandAlias.cpp

   37   Options *options = cmd_obj_sp->GetOptions();
   42         cmd_obj_sp->GetCommandInterpreter().GetExecutionContext();
   63     if (cmd_obj_sp->WantsRawCommandString())
   89          auto cmd_entry = m_underlying_command_sp->GetArgumentEntryAtIndex(i);
  100           GetUnderlyingCommand()->GetHelp().str().c_str());
  108     return m_underlying_command_sp->WantsRawCommandString();
  114     return m_underlying_command_sp->WantsCompletion();
  120     m_underlying_command_sp->HandleCompletion(request);
  126     m_underlying_command_sp->HandleArgumentCompletion(request,
  132     return m_underlying_command_sp->GetOptions();
  142   llvm::StringRef command_name = m_underlying_command_sp->GetCommandName();
  192         (GetUnderlyingCommand()->IsDashDashCommand() ? eLazyBoolYes
  199     return GetUnderlyingCommand()->IsAlias();
  208   if (underlying->IsAlias()) {
  211     options->insert(options->begin(), desugared.second->begin(),
  211     options->insert(options->begin(), desugared.second->begin(),
  211     options->insert(options->begin(), desugared.second->begin(),
  212                     desugared.second->end());
  235     return m_underlying_command_sp->GetHelp();
  243     return m_underlying_command_sp->GetHelpLong();

tools/lldb/source/Interpreter/CommandInterpreter.cpp

  125   m_collection_sp->Initialize(g_interpreter_properties);
  130   return m_collection_sp->GetPropertyAtIndexAsBoolean(
  136   return m_collection_sp->GetPropertyAtIndexAsBoolean(
  142   m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
  147   return m_collection_sp->GetPropertyAtIndexAsBoolean(
  153   m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
  158   return m_collection_sp->GetPropertyAtIndexAsBoolean(
  164   m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
  198   return m_collection_sp->GetPropertyAtIndexAsBoolean(
  204   return m_collection_sp->GetPropertyAtIndexAsBoolean(
  228     AddAlias("attach", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
  243     AddAlias("b", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
  247     AddAlias("tbreak", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
  298     AddAlias("j", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
  299     AddAlias("jump", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
  304     AddAlias("l", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
  305     AddAlias("list", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
  310     AddAlias("env", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
  318     AddAlias("up", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
  322     AddAlias("down", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
  326     AddAlias("display", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
  338     AddAlias("undisplay", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
  342     AddAlias("bt", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
  553       m_command_dict[break_regex_cmd_sp->GetCommandName()] = break_regex_cmd_sp;
  610       m_command_dict[tbreak_regex_cmd_sp->GetCommandName()] =
  630       m_command_dict[attach_regex_cmd_sp->GetCommandName()] =
  646       m_command_dict[down_regex_cmd_sp->GetCommandName()] = down_regex_cmd_sp;
  660       m_command_dict[up_regex_cmd_sp->GetCommandName()] = up_regex_cmd_sp;
  673       m_command_dict[display_regex_cmd_sp->GetCommandName()] =
  688       m_command_dict[undisplay_regex_cmd_sp->GetCommandName()] =
  707       m_command_dict[command_sp->GetCommandName()] = command_sp;
  725       m_command_dict[command_sp->GetCommandName()] = command_sp;
  750       m_command_dict[command_sp->GetCommandName()] = command_sp;
  786       m_command_dict[list_regex_cmd_sp->GetCommandName()] = list_regex_cmd_sp;
  804       m_command_dict[env_regex_cmd_sp->GetCommandName()] = env_regex_cmd_sp;
  827       m_command_dict[jump_regex_cmd_sp->GetCommandName()] = jump_regex_cmd_sp;
  941       descriptions->AppendString(command_sp->GetHelp());
  951     lldbassert((this == &cmd_sp->GetCommandInterpreter()) &&
  960     if (!can_replace || !name_iter->second->IsRemovable())
  973     lldbassert((this == &cmd_sp->GetCommandInterpreter()) &&
  981       if (!m_command_dict[name]->IsRemovable())
  988       if (!m_user_dict[name]->IsRemovable())
 1020         if (cmd_obj_sp->IsMultiwordObject()) {
 1022               cmd_obj_sp->GetSubcommandSP(cmd_words.GetArgumentAtIndex(j));
 1123     lldbassert((this == &command_obj_sp->GetCommandInterpreter()) &&
 1149     if (pos->second->IsRemovable()) {
 1187                               pos->second->GetHelp(), max_len);
 1204                               alias_pos->second->GetHelp(), max_len);
 1216                               pos->second->GetHelp(), max_len);
 1832     m_command_io_handler_sp->SetPrompt(new_prompt);
 2039   return properties->GetLoadCWDlldbinitFile();
 2149   ProcessSP process_sp(target_sp->GetProcessSP());
 2153   if (eStateStopped != process_sp->GetState())
 2156   for (const auto &thread_sp : process_sp->GetThreadList().Threads()) {
 2157     StopInfoSP stop_info = thread_sp->GetStopInfo();
 2161     const StopReason reason = stop_info->GetStopReason();
 2166       const auto stop_signal = static_cast<int32_t>(stop_info->GetValue());
 2167       UnixSignalsSP signals_sp = process_sp->GetUnixSignals();
 2168       if (!signals_sp || !signals_sp->SignalIsValid(stop_signal))
 2172       const auto sigint_num = signals_sp->GetSignalNumberFromName("SIGINT");
 2173       const auto sigstop_num = signals_sp->GetSignalNumberFromName("SIGSTOP");
 2259       result.GetImmediateOutputStream()->Flush();
 2262       result.GetImmediateErrorStream()->Flush();
 2645   if (ProcessSP process_sp = target_sp->GetProcessSP())
 2739       io_handler.GetOutputStreamFileSP()->Printf(
 2843     io_handler_sp->SetUserData(baton);
 2867     io_handler_sp->SetUserData(baton);

tools/lldb/source/Interpreter/OptionGroupFormat.cpp

  204         byte_size = target_sp->GetArchitecture().GetAddressByteSize();

tools/lldb/source/Interpreter/OptionGroupPlatform.cpp

   27           !platform_sp->IsCompatibleArchitecture(arch, false, &platform_arch)) {
   29                                        platform_sp->GetName().GetCString(),
   43       platform_sp->SetOSVersion(m_os_version);
   46       platform_sp->SetSDKRootDirectory(m_sdk_sysroot);
   49       platform_sp->SetSDKBuild(m_sdk_build);
  125       if (platform_sp->GetName() != ConstString(m_platform_name.c_str()))
  129     if (m_sdk_build && m_sdk_build != platform_sp->GetSDKBuild())
  132     if (m_sdk_sysroot && m_sdk_sysroot != platform_sp->GetSDKRootDirectory())
  135     if (!m_os_version.empty() && m_os_version != platform_sp->GetOSVersion())

tools/lldb/source/Interpreter/OptionGroupPythonClassWithDict.cpp

  110           m_dict_sp->AddStringItem(m_current_key, option_arg);

tools/lldb/source/Interpreter/OptionGroupValueObjectDisplay.cpp

  180     use_dynamic = target_sp->GetPreferDynamicValue();

tools/lldb/source/Interpreter/OptionValue.cpp

  543     error = value_sp->SetValueFromString(
  554     if (m_parent_sp->DumpQualifiedName(strm))

tools/lldb/source/Interpreter/OptionValueArgs.cpp

   19     llvm::StringRef string_value = value->GetStringValue();

tools/lldb/source/Interpreter/OptionValueArray.cpp

   48         m_values[i]->DumpValue(exe_ctx, strm, dump_mask | extra_dump_options);
   61         m_values[i]->DumpValue(exe_ctx, strm, (dump_mask & (~eDumpOptionType)) |
  124         return m_values[new_idx]->GetSubValue(exe_ctx, sub_value,
  150     llvm::StringRef string_value = m_values[i]->GetStringValue();
  313     copied_array->AppendValue(m_values[i]->DeepCopy());

tools/lldb/source/Interpreter/OptionValueDictionary.cpp

   90     pos->second->DumpValue(nullptr, strm, eDumpOptionValue | eDumpOptionRaw);
  259   return value_sp->GetSubValue(exe_ctx, sub_name, will_modify, error);
  270     error = value_sp->SetValueFromString(value, op);
  292   if (value_sp && (m_type_mask & value_sp->GetTypeAsMask())) {
  321     copied_dict->SetValueForKey(pos->first, pos->second->DeepCopy(), true);

tools/lldb/source/Interpreter/OptionValueProperties.cpp

   41       lldb::OptionValueSP new_value_sp(m_properties[i].GetValue()->DeepCopy());
   56     property.GetValue()->SetParent(shared_from_this());
   76   value_sp->SetParent(shared_from_this());
  135         value_sp->GetSubValue(exe_ctx, sub_name.drop_front(), will_modify, error);
  141           return_val_sp = value_sp->GetSubValue(
  169             return value_sp->GetSubValue(exe_ctx, rest,
  185     return value_sp->GetSubValue(exe_ctx, sub_name, will_modify, error);
  209     error = value_sp->SetValueFromString(value, op);
  252     return value_sp->GetAsPathMappings();
  261     return value_sp->GetAsFileSpecList();
  269     return property->GetValue()->GetAsArch();
  278     return property->GetValue()->GetAsLanguage();
  349     return property->GetValue()->GetAsDictionary();
  494     return value_sp->GetAsString();
  523     m_properties[i].GetValue()->Clear();
  577     if (!value_sp->ValueIsTransparent()) {
  583     value_sp->DumpValue(exe_ctx, strm, dump_mask);
  613         property->GetValue()->GetAsProperties();
  646           property->GetValue()->GetAsProperties();
  672     OptionValueProperties *ov_properties = option_value_sp->GetAsProperties();

tools/lldb/source/Interpreter/OptionValueUInt64.cpp

   21   error = value_sp->SetValueFromString(value_str);

tools/lldb/source/Interpreter/OptionValueUUID.cpp

   80     const UUID &module_uuid = module_sp->GetUUID();

tools/lldb/source/Interpreter/Options.cpp

 1349         platform_sp = target_sp ? target_sp->GetPlatform() : PlatformSP();

tools/lldb/source/Interpreter/Property.cpp

  228     if (m_value_sp->DumpQualifiedName(strm))
  241     const bool transparent = m_value_sp->ValueIsTransparent();
  260     m_value_sp->DumpValue(exe_ctx, strm, dump_mask);
  275   const OptionValueProperties *sub_properties = m_value_sp->GetAsProperties();
  279     if (m_value_sp->DumpQualifiedName(qualified_name))
  298     m_value_sp->SetValueChangedCallback(callback, baton);

tools/lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp

 1547     const ArchSpec &arch(process_sp->GetTarget().GetArchitecture());
 1608               const ByteOrder byte_order = process_sp->GetByteOrder();
 1632                                      process_sp->GetAddressByteSize());
 1685         thread.GetRegisterContext()->ReadRegisterAsUnsigned(r0_reg_info, 0) &
 1714   Thread *thread = frame_sp->GetThread().get();
 1815   row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0);
 1818   row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num, true);
 1840   row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
 1841   row->SetOffset(0);
 1843   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
 1844   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);

tools/lldb/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp

 1871   Thread *thread = frame_sp->GetThread().get();
 1980   row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0);
 1983   row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num, true);
 2005   row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
 2006   row->SetOffset(0);
 2008   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
 2009   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
 2283               thread.GetRegisterContext()->ReadRegisterAsUnsigned(x0_reg_info,

tools/lldb/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp

  854   Thread *thread = frame_sp->GetThread().get();
  950           thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) &
  953           (thread.GetRegisterContext()->ReadRegisterAsUnsigned(edx_id, 0) &
  964             thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) &
  968             thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) &
  974             thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) &
  978             thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) &
  984             thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) &
  988             thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) &
  996         thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) &
 1023   row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 4);
 1024   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, -4, false);
 1025   row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
 1048   row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
 1049   row->SetOffset(0);
 1051   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
 1052   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
 1053   row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);

tools/lldb/source/Plugins/ABI/SysV-arc/ABISysV_arc.cpp

  202   uint32_t pc_reg = reg_ctx->ConvertRegisterKindToRegisterNumber(
  207   uint32_t ra_reg = reg_ctx->ConvertRegisterKindToRegisterNumber(
  212   uint32_t sp_reg = reg_ctx->ConvertRegisterKindToRegisterNumber(
  231     if (process->WriteMemory(sp, arg.data_up.get(), arg.size, error) < arg.size
  274       if (!reg_ctx->WriteRegister(
  275             reg_ctx->GetRegisterInfo(eRegisterKindGeneric, reg_index),
  287     if (process->WriteMemory(sp - offset, value, size, error) < size ||
  298   reg_ctx->WriteRegisterFromUnsigned(pc_reg, pc);
  299   reg_ctx->WriteRegisterFromUnsigned(ra_reg, ra);
  300   reg_ctx->WriteRegisterFromUnsigned(sp_reg, sp);
  323   auto &reg_ctx = *frame_sp->GetThread()->GetRegisterContext();
  323   auto &reg_ctx = *frame_sp->GetThread()->GetRegisterContext();
  427       reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1);
  431       reg_ctx->ReadRegisterAsUnsigned(reg_info_r0, 0) & UINT32_MAX;
  434     raw_value |= (reg_ctx->ReadRegisterAsUnsigned(
  435                       reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
  470     auto reg_info_r0 = reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
  472     value.GetScalar() = reg_ctx->ReadRegisterAsUnsigned(reg_info_r0, 0);
  534     auto reg_info_r0 = reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
  536     value.GetScalar() = reg_ctx->ReadRegisterAsUnsigned(reg_info_r0, 0);
  562   row->GetCFAValue().SetIsRegisterPlusOffset(dwarf::sp, 0);
  565   row->SetRegisterLocationToRegister(dwarf::pc, dwarf::blink, true);

tools/lldb/source/Plugins/ABI/SysV-arm/ABISysV_arm.cpp

 1532   thread.GetProcess()->ReadMemory(address, buffer.GetBytes(),
 1545     const ArchSpec &arch(process_sp->GetTarget().GetArchitecture());
 1630         thread.GetRegisterContext()->ReadRegisterAsUnsigned(r0_reg_info, 0) &
 1786     ByteOrder byte_order = process_sp->GetByteOrder();
 1811       if ((data_offset + vfp_byte_size) <= data_sp->GetByteSize()) {
 1814             reg_info, data_sp->GetBytes() + data_offset, vfp_byte_size,
 1826       data.SetAddressByteSize(process_sp->GetAddressByteSize());
 1857   Thread *thread = frame_sp->GetThread().get();
 1929   row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0);
 1932   row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num, true);
 1954   row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
 1955   row->SetOffset(0);
 1957   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
 1958   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);

tools/lldb/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp

 1843   Thread *thread = frame_sp->GetThread().get();
 1952   row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0);
 1977   row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
 1978   row->SetOffset(0);
 1980   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
 1981   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
 2254               thread.GetRegisterContext()->ReadRegisterAsUnsigned(x0_reg_info,

tools/lldb/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp

 1105     proc->WriteMemory(sp, arg.data_up.get(), arg.size, error);
 1156     proc->WriteMemory(sp + offs, (void *)&param, sizeof(param), error);
 1218   row->GetCFAValue().SetIsRegisterPlusOffset(LLDB_REGNUM_GENERIC_SP, 4);
 1219   row->SetOffset(0);
 1222   row->SetRegisterLocationToRegister(LLDB_REGNUM_GENERIC_PC,
 1241   row->GetCFAValue().SetIsRegisterPlusOffset(LLDB_REGNUM_GENERIC_FP, 8);
 1243   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, -8, true);
 1244   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, -4, true);
 1245   row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);

tools/lldb/source/Plugins/ABI/SysV-i386/ABISysV_i386.cpp

  339   Thread *thread = frame_sp->GetThread().get();
  504         thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) &
  524           thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) &
  527           (thread.GetRegisterContext()->ReadRegisterAsUnsigned(edx_id, 0) &
  579           thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) &
  624             thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) &
  652             const ByteOrder byte_order = process_sp->GetByteOrder();
  661                                    process_sp->GetTarget()
  677               const ByteOrder byte_order = process_sp->GetByteOrder();
  693                                      process_sp->GetTarget()
  730         reg_ctx_sp->GetRegisterInfoByName("eax", 0)->kinds[eRegisterKindLLDB];
  732         thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) &
  753   row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 4);
  754   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, -4, false);
  755   row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
  778   row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
  779   row->SetOffset(0);
  781   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
  782   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
  783   row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);

tools/lldb/source/Plugins/ABI/SysV-mips/ABISysV_mips.cpp

  711   Thread *thread = frame_sp->GetThread().get();
  852         thread.GetRegisterContext()->ReadRegisterAsUnsigned(r2_reg_info, 0) &
  919                 offset, 4, data_sp->GetBytes(), 4, target_byte_order);
  923                 offset, 4, data_sp->GetBytes() + 4, 4, target_byte_order);
  927                 offset, 4, data_sp->GetBytes() + 4, 4, target_byte_order);
  931                 offset, 4, data_sp->GetBytes(), 4, target_byte_order);
  966   row->GetCFAValue().SetIsRegisterPlusOffset(dwarf_r29, 0);
  969   row->SetRegisterLocationToRegister(dwarf_pc, dwarf_r31, true);
  986   row->GetCFAValue().SetIsRegisterPlusOffset(dwarf_r29, 0);
  988   row->SetRegisterLocationToRegister(dwarf_pc, dwarf_r31, true);

tools/lldb/source/Plugins/ABI/SysV-mips64/ABISysV_mips64.cpp

  672   Thread *thread = frame_sp->GetThread().get();
  873                   0, 8, data_sp->GetBytes(), *byte_size - 8, target_byte_order);
  877                   0, 8, data_sp->GetBytes() + 8, *byte_size - 8,
  882                   0, 8, data_sp->GetBytes() + 8, *byte_size - 8,
  887                   0, 8, data_sp->GetBytes(), *byte_size - 8, target_byte_order);
 1011                 data_sp->GetBytes() + (field_bit_offset / 8), *field_byte_width,
 1093             r2_info, data_sp->GetBytes(), r2_info->byte_size, target_byte_order,
 1102             r3_info, data_sp->GetBytes() + r2_info->byte_size,
 1137   row->GetCFAValue().SetIsRegisterPlusOffset(dwarf_r29, 0);
 1140   row->SetRegisterLocationToRegister(dwarf_pc, dwarf_r31, true);
 1157   row->GetCFAValue().SetIsRegisterPlusOffset(dwarf_r29, 0);
 1159   row->SetRegisterLocationToRegister(dwarf_pc, dwarf_r31, true);

tools/lldb/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp

  289   if (!process_sp->WritePointerToMemory(sp, return_addr, error))
  318     scalar = thread.GetRegisterContext()->ReadRegisterAsUnsigned(
  326     if (thread.GetProcess()->ReadScalarIntegerFromMemory(
  426   Thread *thread = frame_sp->GetThread().get();
  531       uint64_t raw_value = thread.GetRegisterContext()->ReadRegisterAsUnsigned(
  603         (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(r3_id, 0);
  618             const ByteOrder byte_order = process_sp->GetByteOrder();
  627                                    process_sp->GetTarget()
  671       const RegisterInfo *r3_info = reg_ctx_sp->GetRegisterInfoByName("r3", 0);
  673           reg_ctx_sp->GetRegisterInfoByName("rdx", 0);
  676       reg_ctx_sp->ReadRegister(r3_info, r3_value);
  677       reg_ctx_sp->ReadRegister(rdx_info, rdx_value);
  833             data_sp->GetBytes() + field_byte_offset, field_byte_width,
  854           reg_ctx_sp->GetRegisterInfoByName("r3", 0)->kinds[eRegisterKindLLDB];
  856           (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(r3_id,
  877   row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0);
  880   row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num, true);
  901   row->GetCFAValue().SetIsRegisterDereferenced(sp_reg_num);
  903   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * 1, true);
  904   row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);

tools/lldb/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp

   64   return GetProcessSP()->GetByteOrder();
  142   if (!process_sp->WritePointerToMemory(sp + 16, return_addr, error))
  168   if (!process_sp->WritePointerToMemory(sp + stack_offset, reg_value, error))
  177   if (!process_sp->WritePointerToMemory(sp, reg_value, error))
  205     scalar = thread.GetRegisterContext()->ReadRegisterAsUnsigned(
  213     if (thread.GetProcess()->ReadScalarIntegerFromMemory(
  304   Thread *thread = frame_sp->GetThread().get();
  570         m_process_sp(process_sp), m_byte_order(process_sp->GetByteOrder()),
  572             process_sp->GetTarget().GetArchitecture().GetAddressByteSize()) {}
  577     value_sp->SetCompilerType(type);
  578     value_sp->SetValueType(Value::eValueTypeScalar);
  598         value_sp->GetScalar() = (int64_t)(raw_value);
  600         value_sp->GetScalar() = (uint64_t)(raw_value);
  605         value_sp->GetScalar() = (int32_t)(raw_value & UINT32_MAX);
  607         value_sp->GetScalar() = (uint32_t)(raw_value & UINT32_MAX);
  612         value_sp->GetScalar() = (int16_t)(raw_value & UINT16_MAX);
  614         value_sp->GetScalar() = (uint16_t)(raw_value & UINT16_MAX);
  619         value_sp->GetScalar() = (int8_t)(raw_value & UINT8_MAX);
  621         value_sp->GetScalar() = (uint8_t)(raw_value & UINT8_MAX);
  649       value_sp->GetScalar() = (float)de.GetDouble(&offset);
  653       value_sp->GetScalar() = de.GetDouble(&offset);
  672     value_sp->GetScalar() = raw_data;
  757       size_t rc = m_process_sp->ReadMemory(addr, m_data_up->GetBytes(),
  794         size_t rc = val_sp->GetScalar().GetAsMemoryData(
  969   row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0);
  972   row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num, true);
 1003   row->GetCFAValue().SetIsRegisterDereferenced(sp_reg_num);
 1005   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * 2, true);
 1006   row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
 1007   row->SetRegisterLocationToAtCFAPlusOffset(cr_reg_num, ptr_size, true);

tools/lldb/source/Plugins/ABI/SysV-s390x/ABISysV_s390x.cpp

  263       if (!process_sp->WritePointerToMemory(arg_pos, args[i], error))
  302     scalar = thread.GetRegisterContext()->ReadRegisterAsUnsigned(
  310     if (thread.GetProcess()->ReadScalarIntegerFromMemory(
  404   Thread *thread = frame_sp->GetThread().get();
  512       uint64_t raw_value = thread.GetRegisterContext()->ReadRegisterAsUnsigned(
  586         (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(r2_id, 0);
  620         reg_ctx_sp->GetRegisterInfoByName("r2", 0)->kinds[eRegisterKindLLDB];
  622         (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(r2_id, 0);
  637   row->GetCFAValue().SetIsRegisterPlusOffset(dwarf_r15_s390x, 160);
  640   row->SetRegisterLocationToRegister(dwarf_pswa_s390x, dwarf_r14_s390x, true);

tools/lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp

  320   if (!process_sp->WritePointerToMemory(sp, return_addr, error))
  349     scalar = thread.GetRegisterContext()->ReadRegisterAsUnsigned(
  357     if (thread.GetProcess()->ReadScalarIntegerFromMemory(
  454   Thread *thread = frame_sp->GetThread().get();
  564       uint64_t raw_value = thread.GetRegisterContext()->ReadRegisterAsUnsigned(
  640         (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(rax_id,
  660             const ByteOrder byte_order = process_sp->GetByteOrder();
  669                                    process_sp->GetTarget()
  685               const ByteOrder byte_order = process_sp->GetByteOrder();
  702                                      process_sp->GetTarget()
  804           reg_ctx_sp->GetRegisterInfoByName("rax", 0);
  806           reg_ctx_sp->GetRegisterInfoByName("rdx", 0);
  808           reg_ctx_sp->GetRegisterInfoByName("xmm0", 0);
  810           reg_ctx_sp->GetRegisterInfoByName("xmm1", 0);
  813       reg_ctx_sp->ReadRegister(rax_info, rax_value);
  814       reg_ctx_sp->ReadRegister(rdx_info, rdx_value);
  815       reg_ctx_sp->ReadRegister(xmm0_info, xmm0_value);
  816       reg_ctx_sp->ReadRegister(xmm1_info, xmm1_value);
  971             data_sp->GetBytes() + field_byte_offset, field_byte_width,
  991           reg_ctx_sp->GetRegisterInfoByName("rax", 0)->kinds[eRegisterKindLLDB];
  993           (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(rax_id,
 1015   row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 8);
 1016   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, -8, false);
 1017   row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
 1040   row->GetCFAValue().SetIsRegisterPlusOffset(dwarf_rbp, 2 * ptr_size);
 1041   row->SetOffset(0);
 1043   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
 1044   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
 1045   row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);

tools/lldb/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.cpp

 1162   if (!process_sp->WritePointerToMemory(sp, return_addr, error))
 1191     scalar = thread.GetRegisterContext()->ReadRegisterAsUnsigned(
 1200   if (thread.GetProcess()->ReadScalarIntegerFromMemory(
 1287   Thread *thread = frame_sp->GetThread().get();
 1398       uint64_t raw_value = thread.GetRegisterContext()->ReadRegisterAsUnsigned(
 1473         (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(rax_id,
 1493             const ByteOrder byte_order = process_sp->GetByteOrder();
 1502                                    process_sp->GetTarget()
 1629         reg_ctx_sp->GetRegisterInfoByName("rax", 0);
 1631     reg_ctx_sp->ReadRegister(rax_info, rax_value);
 1679           field_byte_width, data_sp->GetBytes() + field_byte_offset,
 1701         reg_ctx_sp->GetRegisterInfoByName("rax", 0)->kinds[eRegisterKindLLDB];
 1703         (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(rax_id,
 1723   row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 8);
 1724   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, -8, false);
 1725   row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
 1746   row->GetCFAValue().SetIsRegisterPlusOffset(dwarf_rbp, 2 * ptr_size);
 1747   row->SetOffset(0);
 1749   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
 1750   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
 1751   row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);

tools/lldb/source/Plugins/Architecture/Arm/ArchitectureArm.cpp

   77   const uint32_t cpsr = reg_ctx_sp->GetFlags(0);

tools/lldb/source/Plugins/Architecture/Mips/ArchitectureMips.cpp

  100     temp_addr_module_sp->ResolveSymbolContextForAddress(resolved_addr,
  175     disasm_sp->ParseInstructions(&exe_ctx, range, nullptr, prefer_file_cache);
  177     uint32_t num_insns = disasm_sp->GetInstructionList().GetSize();
  179       prev_insn = disasm_sp->GetInstructionList().GetInstructionAtIndex(0);
  180       insn_size = prev_insn->GetOpcode().GetByteSize();

tools/lldb/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp

  174       const ArchSpec &arch = disasm->GetArchitecture();
  282           mc_disasm_ptr = disasm->m_alternate_disasm_up.get();
  284           mc_disasm_ptr = disasm->m_disasm_up.get();
  289         const bool data_from_file = disasm->m_data_from_file;
  409       m_disasm->m_mutex.lock();
  410       m_disasm->m_inst = &i;
  411       m_disasm->m_exe_ctx = exe_ctx;
  413     ~DisassemblerScope() { m_disasm->m_mutex.unlock(); }
  837       switch (disasm_sp->GetArchitecture().GetMachine()) {
  911       if (disasm->m_alternate_disasm_up) {
  916           return disasm->m_alternate_disasm_up.get();
  919       return disasm->m_disasm_up.get();
 1282     uint32_t inst_size = inst_sp->Decode(*this, data, data_cursor);
 1370           module_sp->ResolveFileAddress(value, value_so_addr);
 1371           module_sp->ResolveFileAddress(pc, pc_so_addr);
 1382         pc_so_addr.GetModule()->ResolveSymbolContextForAddress(

tools/lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp

  106     m_collection_sp->Initialize(g_dynamicloaderdarwinkernel_properties);
  113     return m_collection_sp->GetPropertyAtIndexAsBoolean(
  120     return (KASLRScanType)m_collection_sp->GetPropertyAtIndexAsEnumeration(
  242   if (GetGlobalProperties()->GetScanType() == eKASLRScanNone)
  293   if (GetGlobalProperties()->GetScanType() == eKASLRScanNone ||
  294       GetGlobalProperties()->GetScanType() == eKASLRScanLowgloAddresses) {
  301   addr_t pc = thread->GetRegisterContext()->GetPC(LLDB_INVALID_ADDRESS);
  301   addr_t pc = thread->GetRegisterContext()->GetPC(LLDB_INVALID_ADDRESS);
  351   if (GetGlobalProperties()->GetScanType() != eKASLRScanExhaustiveScan) {
  470     ObjectFile *exe_objfile = memory_module_sp->GetObjectFile();
  489         if (memory_module_sp->GetUUID().IsValid()) {
  491           uuid_str += memory_module_sp->GetUUID().GetAsString();
  501       return memory_module_sp->GetUUID();
  521   if (platform_sp.get() && GetGlobalProperties()->GetLoadKexts()) {
  574     if (m_module_sp->SetLoadAddress(process->GetTarget(), 0, true, changed))
  582   if (module_sp.get() && module_sp->GetObjectFile()) {
  583     if (module_sp->GetObjectFile()->GetType() == ObjectFile::eTypeExecutable &&
  584         module_sp->GetObjectFile()->GetStrata() == ObjectFile::eStrataKernel) {
  680   if (memory_module_sp->GetObjectFile()) {
  681     if (memory_module_sp->GetObjectFile()->GetType() ==
  683         memory_module_sp->GetObjectFile()->GetStrata() ==
  686     } else if (memory_module_sp->GetObjectFile()->GetType() ==
  696     if (m_uuid != memory_module_sp->GetUUID()) {
  703                   memory_module_sp->GetUUID().GetAsString().c_str());
  710   if (!m_uuid.IsValid() && memory_module_sp->GetUUID().IsValid()) {
  711     m_uuid = memory_module_sp->GetUUID();
  723     if (memory_module_sp->GetArchitecture().IsValid()) {
  724       process->GetTarget().SetArchitecture(memory_module_sp->GetArchitecture());
  728       if (exe_module_sp.get() && exe_module_sp->GetUUID().IsValid()) {
  729         if (m_uuid != exe_module_sp->GetUUID()) {
  801                 m_module_sp->MatchesModuleSpec(module_spec)) {
  815         ConstString platform_name(platform_sp->GetPluginName());
  823           platform_sp->GetSharedModule(kext_bundle_module_spec, process,
  849       if (m_uuid.IsValid() && m_module_sp->GetUUID() == m_uuid) {
  867     if (m_module_sp->GetUUID() == m_memory_module_sp->GetUUID()) {
  867     if (m_module_sp->GetUUID() == m_memory_module_sp->GetUUID()) {
  868       ObjectFile *ondisk_object_file = m_module_sp->GetObjectFile();
  869       ObjectFile *memory_object_file = m_memory_module_sp->GetObjectFile();
  901                   ondisk_section_sp->GetName() == g_section_name_LINKEDIT)
  906                       ->FindSectionByName(ondisk_section_sp->GetName())
  931     ObjectFile *kernel_object_file = m_module_sp->GetObjectFile();
  943                m_module_sp->GetFileSpec().GetPath().c_str());
  953     return m_memory_module_sp->GetArchitecture().GetAddressByteSize();
  955     return m_module_sp->GetArchitecture().GetAddressByteSize();
  961     return m_memory_module_sp->GetArchitecture().GetByteOrder();
  963     return m_module_sp->GetArchitecture().GetByteOrder();
  970     return m_memory_module_sp->GetArchitecture();
  972     return m_module_sp->GetArchitecture();
  986     if (m_kernel.GetModule().get() && m_kernel.GetModule()->GetObjectFile() &&
  988              ->GetObjectFile()
  993           m_kernel.GetModule()->GetObjectFile()->GetFileSpec().GetFilename();
 1003         ObjectFile *kernel_object_file = m_kernel.GetModule()->GetObjectFile();
 1040           m_kernel.GetModule()->FindFirstSymbolWithNameAndType(
 1176   const bool load_kexts = GetGlobalProperties()->GetLoadKexts();
 1473     module_spec_list.Append(m_kernel.GetModule()->GetFileSpec());
 1548         debugger, GetGlobalProperties()->GetValueProperties(),

tools/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp

   53   ObjectFile *exe = module->GetObjectFile();
  180   if (!FileSystem::Instance().Exists(executable->GetFileSpec()))
  184   ModuleSpec module_spec(executable->GetFileSpec(),
  185                          executable->GetArchitecture());
  190   if (module_sp.get() && module_sp->GetUUID().IsValid() &&
  191       executable->GetUUID().IsValid()) {
  193     if (module_sp->GetUUID() != executable->GetUUID())
  193     if (module_sp->GetUUID() != executable->GetUUID())
  195   } else if (executable->FileHasChanged())
  230     lldb::addr_t new_load_addr = section_sp->GetFileAddress() + base_addr;
  298                ->FindLocationByAddress(break_addr)
  299                ->GetBreakpoint()
  427   Target &target = thread.GetProcess()->GetTarget();
  545     ObjectFile *obj_file = module->GetObjectFile();
  581   addr_t tp = thread->GetThreadPointer();

tools/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp

  118       !module_sp->GetUUID().IsValid()) {
  121     if (module_sp->GetModificationTime() !=
  122         FileSystem::Instance().GetModificationTime(module_sp->GetFileSpec()))
  131       if (!module_sp || module_sp->GetObjectFile() == nullptr)
  257                   section_sp->GetName() != g_section_name_LINKEDIT;
  279               if (g_pagezero_section_name == section_sp->GetName()) {
  342       image_details->GetAsDictionary()->GetValueForKey("images");
  346   image_infos.resize(images_sp->GetAsArray()->GetSize());
  350         images_sp->GetAsArray()->GetItemAtIndex(i);
  351     if (image_sp.get() == nullptr || image_sp->GetAsDictionary() == nullptr)
  353     StructuredData::Dictionary *image = image_sp->GetAsDictionary();
  359         image->GetValueForKey("mach_header")->GetAsDictionary() == nullptr ||
  361         image->GetValueForKey("segments")->GetAsArray() == nullptr ||
  367         image->GetValueForKey("load_address")->GetAsInteger()->GetValue();
  369         image->GetValueForKey("mod_date")->GetAsInteger()->GetValue();
  371         image->GetValueForKey("pathname")->GetAsString()->GetValue(),
  375         image->GetValueForKey("mach_header")->GetAsDictionary();
  377         mh->GetValueForKey("magic")->GetAsInteger()->GetValue();
  379         mh->GetValueForKey("cputype")->GetAsInteger()->GetValue();
  381         mh->GetValueForKey("cpusubtype")->GetAsInteger()->GetValue();
  383         mh->GetValueForKey("filetype")->GetAsInteger()->GetValue();
  387                                 ->GetAsString()
  407               ->GetAsString()
  416           mh->GetValueForKey("flags")->GetAsInteger()->GetValue();
  422           mh->GetValueForKey("ncmds")->GetAsInteger()->GetValue();
  428           mh->GetValueForKey("sizeofcmds")->GetAsInteger()->GetValue();
  433         image->GetValueForKey("segments")->GetAsArray();
  438           segments->GetItemAtIndex(j)->GetAsDictionary();
  440           ConstString(seg->GetValueForKey("name")->GetAsString()->GetValue());
  442           seg->GetValueForKey("vmaddr")->GetAsInteger()->GetValue();
  444           seg->GetValueForKey("vmsize")->GetAsInteger()->GetValue();
  446           seg->GetValueForKey("fileoff")->GetAsInteger()->GetValue();
  448           seg->GetValueForKey("filesize")->GetAsInteger()->GetValue();
  450           seg->GetValueForKey("maxprot")->GetAsInteger()->GetValue();
  457             seg->GetValueForKey("initprot")->GetAsInteger()->GetValue();
  463             seg->GetValueForKey("flags")->GetAsInteger()->GetValue();
  469             seg->GetValueForKey("nsects")->GetAsInteger()->GetValue();
  477         image->GetValueForKey("uuid")->GetAsString()->GetValue());
  555                 exe_module_sp->GetFileSpec().GetPath().c_str());
  570                 dyld_sp->GetFileSpec().GetPath().c_str());
  624       ObjectFile *objfile = image_module_sp->GetObjectFile();
  644                   commpage_image_module_sp->GetObjectFile() == nullptr) {
  679         image_module_sp->MergeArchitecture(dyld_spec);
  845         const ModuleList &images = target_sp->GetImages();
  957           addr_t resolved_addr = thread.GetProcess()->ResolveIndirectFunction(
 1024       module_sp->FindSymbolsWithNameAndType(ConstString("pthread_getspecific"),
 1049   if (module_sp->ResolveFileAddress(tls_file_addr, tls_addr)) {
 1065         const tid_t tid = thread_sp->GetID();
 1073         StackFrameSP frame_sp = thread_sp->GetStackFrameAtIndex(0);
 1098                   thread_plan_sp->GetReturnValueObject();

tools/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOS.cpp

  109           lldb::StackFrameSP frame_sp(thread_sp->GetStackFrameAtIndex(0));
  112                 frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol;
  169       all_image_info_json_sp->GetAsDictionary() &&
  170       all_image_info_json_sp->GetAsDictionary()->HasKey("images") &&
  171       all_image_info_json_sp->GetAsDictionary()
  173           ->GetAsArray()) {
  261     if (abi->GetArgumentValues(exe_ctx.GetThreadRef(), argument_values)) {
  297     process->GetTarget().GetDebugger().GetAsyncErrorStream()->Printf(
  316   if (binaries_info_sp.get() && binaries_info_sp->GetAsDictionary() &&
  317       binaries_info_sp->GetAsDictionary()->HasKey("images") &&
  318       binaries_info_sp->GetAsDictionary()
  320           ->GetAsArray() &&
  321       binaries_info_sp->GetAsDictionary()
  323               ->GetAsArray()
  346       symbol = dyld_sp->FindFirstSymbolWithNameAndType(g_symbol_name,
  468     if (info.get() && info->GetAsDictionary()) {
  469       info_dict = info->GetAsDictionary();
  480                          ->GetIntegerValue(LLDB_INVALID_ADDRESS);
  482           info_dict->GetValueForKey("shared_cache_uuid")->GetStringValue();
  485       if (!info_dict->GetValueForKey("no_shared_cache")->GetBooleanValue())
  490               ->GetBooleanValue())

tools/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp

  135           lldb::StackFrameSP frame_sp(thread_sp->GetStackFrameAtIndex(0));
  138                 frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol;
  268         const Symbol *symbol = dyld_module_sp->FindFirstSymbolWithNameAndType(
  365     if (abi->GetArgumentValues(exe_ctx.GetThreadRef(), argument_values)) {
  394     process->GetTarget().GetDebugger().GetAsyncErrorStream()->Printf(
  539   if (image_infos_json_sp.get() && image_infos_json_sp->GetAsDictionary() &&
  540       image_infos_json_sp->GetAsDictionary()->HasKey("images") &&
  541       image_infos_json_sp->GetAsDictionary()
  543           ->GetAsArray() &&
  544       image_infos_json_sp->GetAsDictionary()
  546               ->GetAsArray()
  734       if (!module_sp->IsLoadedInTarget(&target)) {
  737           module_sp->GetDescription(&s);
  804           m_process->ReadMemory(load_cmd_addr, load_cmd_data_sp->GetBytes(),
  805                                 load_cmd_data_sp->GetByteSize(), error);

tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp

   50       ObjectFile *obj_file = target->GetExecutableModule()->GetObjectFile();
  493   unsigned os_major = target.GetPlatform()->GetOSVersion().getMajor();

tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

  110             executable_sp ? executable_sp->GetFileSpec().GetPath().c_str()
  121     lldb_private::ObjectFile *obj = executable_sp->GetObjectFile();
  144               executable_sp->GetFileSpec().GetPath().c_str());
  159                   module_sp ? module_sp->GetFileSpec().GetPath().c_str()
  289       breakpoint_sp->SetEnabled(false);
  346     containingModules.Append(interpreter->GetFileSpec());
  356   if (dyld_break->GetNumResolvedLocations() != 1) {
  361         dyld_break->GetNumResolvedLocations(),
  364     target.RemoveBreakpointByID(dyld_break->GetID());
  368   BreakpointLocationSP location = dyld_break->GetLocationAtIndex(0);
  372            location->GetLoadAddress(),
  375   dyld_break->SetCallback(RendezvousBreakpointHit, this, true);
  376   dyld_break->SetBreakpointKind("shared-library-event");
  377   m_dyld_bid = dyld_break->GetID();
  469   Target &target = thread.GetProcess()->GetTarget();
  609   ObjectFile *exe = module->GetObjectFile();
  672   addr_t tp = thread->GetThreadPointer();
  698             module_sp->GetObjectName().AsCString(""), link_map, tp,
  733   if (module_sp && module_sp->MatchesModuleSpec(module_spec))
  737   auto error = platform_sp->ResolveExecutable(
  765   return module_sp->GetFileSpec().GetPath() == "[vdso]";

tools/lldb/source/Plugins/DynamicLoader/Static/DynamicLoaderStatic.cpp

   83       ObjectFile *image_object_file = module_sp->GetObjectFile();
  103                       section_sp, section_sp->GetFileAddress()))

tools/lldb/source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.cpp

  110   FileSpec file_spec(executable->GetPlatformFileSpec());
  190   uint64_t pc = thread.GetRegisterContext()->GetPC();
  201   InstructionList *insn_list = &disassembler_sp->GetInstructionList();
  216       strcmp(first_insn->GetMnemonic(&exe_ctx), "jmpl") != 0 ||
  217       strcmp(second_insn->GetMnemonic(&exe_ctx), "nop") != 0) {
  221   assert(first_insn->DoesBranch() && !second_insn->DoesBranch());
  221   assert(first_insn->DoesBranch() && !second_insn->DoesBranch());

tools/lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.cpp

  455     Decl *D_scratch = m_target.GetClangASTImporter()->DeportDecl(

tools/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp

   56   if (!target->GetUseModernTypeLookup()) {
   57     m_ast_importer_sp = m_target->GetClangASTImporter();
   66   if (m_target->GetUseModernTypeLookup()) {
   76     for (lldb::ModuleSP module_sp : m_target->GetImages().Modules()) {
   78           module_sp->GetTypeSystemForLanguage(lldb::eLanguageTypeC);
   94       lldb::ProcessSP process(m_target->GetProcessSP());
  111       auto *modules_decl_vendor = m_target->GetClangModulesDeclVendor();
  124           m_target->GetScratchClangASTContext());
  136     m_ast_importer_sp->InstallMapCompleter(&ast_context, *this);
  142     m_ast_importer_sp->ForgetDestination(m_ast_context);
  148       m_target->GetScratchClangASTContext(false);
  160     m_ast_importer_sp->ForgetSource(scratch_ast_context, m_ast_context);
  300   if (!m_ast_importer_sp->CompleteTagDecl(tag_decl)) {
  316           m_ast_importer_sp->GetNamespaceMap(namespace_context);
  321                   static_cast<int>(namespace_map->size()));
  326       for (ClangASTImporter::NamespaceMap::iterator i = namespace_map->begin(),
  327                                                     e = namespace_map->end();
  331                   i->first->GetFileSpec().GetFilename().GetCString());
  337         i->first->FindTypesInNamespace(name, &i->second, UINT32_MAX, types);
  345           CompilerType clang_type(type->GetFullCompilerType());
  359           if (m_ast_importer_sp->CompleteTagDeclWithOrigin(tag_decl,
  370       const ModuleList &module_list = m_target->GetImages();
  383         CompilerType clang_type(type->GetFullCompilerType());
  403         if (m_ast_importer_sp->CompleteTagDeclWithOrigin(tag_decl,
  450   if (m_ast_importer_sp->ResolveDeclOrigin(interface_decl, &original_decl,
  458         m_ast_importer_sp->SetDeclOrigin(interface_decl, complete_iface_decl);
  463   m_ast_importer_sp->CompleteObjCInterfaceDecl(interface_decl);
  478   lldb::ProcessSP process(m_target->GetProcessSP());
  497       TypeFromUser(complete_type_sp->GetFullCompilerType());
  580   if (!m_ast_importer_sp->ResolveDeclOrigin(context_decl, &original_decl,
  600       m_ast_importer_sp->SetDeclOrigin(context_decl, complete_iface_decl);
  648         m_ast_importer_sp->RequireCompleteType(copied_field_type);
  742         m_ast_importer_sp->GetNamespaceMap(namespace_context) : nullptr;
  747                 static_cast<int>(namespace_map->size()));
  752     for (ClangASTImporter::NamespaceMap::iterator i = namespace_map->begin(),
  753                                                   e = namespace_map->end();
  757                 i->first->GetFileSpec().GetFilename().GetCString());
  775   if (!context.m_namespace_map->empty()) {
  780                 static_cast<int>(context.m_namespace_map->size()));
  827     if (SymbolFile *symbol_file = module_sp->GetSymbolFile()) {
  831         context.m_namespace_map->push_back(
  837                   module_sp->GetFileSpec().GetFilename().GetCString());
  841     const ModuleList &target_images = m_target->GetImages();
  852       SymbolFile *symbol_file = image->GetSymbolFile();
  860         context.m_namespace_map->push_back(
  866                   image->GetFileSpec().GetFilename().GetCString());
  879       module_sp->FindTypesInNamespace(name, &namespace_decl, 1, types);
  881       m_target->GetImages().FindTypes(module_sp.get(), name, exact_match, 1,
  890           const char *name_string = type_sp->GetName().GetCString();
  897         CompilerType full_type = type_sp->GetFullCompilerType();
  920                 m_target->GetClangModulesDeclVendor()) {
  966         lldb::ProcessSP process(m_target->GetProcessSP());
 1186     m_ast_importer_sp->ResolveDeclOrigin(interface_decl, &original_decl,
 1241     m_target->GetImages().FindFunctions(
 1254     m_target->GetImages().FindFunctions(
 1267     m_target->GetImages().FindFunctions(
 1394             m_target->GetClangModulesDeclVendor()) {
 1420     lldb::ProcessSP process(m_target->GetProcessSP());
 1578         m_target->GetClangModulesDeclVendor();
 1612     lldb::ProcessSP process(m_target->GetProcessSP());
 1874     if (parent_map && parent_map->size())
 1880                 parent_map->begin()->second.GetName().AsCString());
 1890     for (ClangASTImporter::NamespaceMap::iterator i = parent_map->begin(),
 1891                                                   e = parent_map->end();
 1898       SymbolFile *symbol_file = module_sp->GetSymbolFile();
 1909       namespace_map->push_back(std::pair<lldb::ModuleSP, CompilerDeclContext>(
 1914                 module_sp->GetFileSpec().GetFilename().GetCString());
 1917     const ModuleList &target_images = m_target->GetImages();
 1930       SymbolFile *symbol_file = image->GetSymbolFile();
 1941       namespace_map->push_back(std::pair<lldb::ModuleSP, CompilerDeclContext>(
 1946                 image->GetFileSpec().GetFilename().GetCString());
 1957   const CompilerDeclContext &namespace_decl = namespace_decls->begin()->second;
 1981   m_ast_importer_sp->RegisterNamespaceMap(copied_namespace_decl,
 2009     return m_ast_importer_sp->CopyDecl(m_ast_context, &from_context, src_decl);
 2036     return m_ast_importer_sp->ResolveDeclOrigin(decl, original_decl,
 2065         m_ast_importer_sp->CopyType(m_ast_context, src_ast->getASTContext(),

tools/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

   99         exe_ctx.GetThreadPtr()->GetStackFrameAtIndex(0)->GetSymbolContext(
  211   assert(&target == m_target->GetScratchClangASTContext());
  216     return TypeFromUser(m_ast_importer_sp->DeportType(
  225         m_target->GetScratchClangASTContext());
  497   if (!parser_vars || !jit_vars || !member_sp->GetValueObject())
  503   name = member_sp->GetName();
  645     module->FindGlobalVariables(name, namespace_decl, -1, vars);
  655                 *type, var_sp->GetType()->GetFullCompilerType()))
  740             ? m_ast_importer_sp->GetNamespaceMap(namespace_context)
  749                   (int)namespace_map->size());
  751     for (ClangASTImporter::NamespaceMap::iterator i = namespace_map->begin(),
  752                                                   e = namespace_map->end();
  757                     i->first->GetFileSpec().GetFilename().GetCString());
  932         if (this_var && this_var->IsInScope(frame) &&
  933             this_var->LocationIsValidForFrame(frame)) {
  934           Type *this_type = this_var->GetType();
 1058         if (self_var && self_var->IsInScope(frame) &&
 1059             self_var->LocationIsValidForFrame(frame)) {
 1060           Type *self_type = self_var->GetType();
 1166         for (size_t i = 0; i < vars->GetSize(); i++)
 1167           vars->GetVariableAtIndex(i)->GetDecl();
 1167           vars->GetVariableAtIndex(i)->GetDecl();
 1178           for (size_t vi = 0, ve = vars->GetSize(); vi != ve; ++vi) {
 1179             VariableSP candidate_var = vars->GetVariableAtIndex(vi);
 1180             if (candidate_var->GetDecl() == decl) {
 1223       module_sp->FindFunctions(name, &namespace_decl, eFunctionNameTypeBase,
 1418                 m_target->GetClangModulesDeclVendor()) {
 1521   Type *var_type = var->GetType();
 1555   DWARFExpression &var_location_expr = var->LocationExpression();
 1560   if (var->GetLocationIsConstantValueData()) {
 1590     var->CalculateSymbolContext(&var_sc);
 1596                     var_sc.module_sp->GetSectionList());
 1689               current_id, pvar_sp->GetName().GetCString());
 1709               pvar_sp->GetName().GetCString(), ast_dumper.GetCString());
 1788     if (entity->m_flags & ClangExpressionVariable::EVUnknownType) {
 1810         copied_type = m_ast_importer_sp->CopyType(
 1837       entity->SetCompilerType(user_type);
 1839       entity->m_flags &= ~(ClangExpressionVariable::EVUnknownType);

tools/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

  184     m_passthrough->HandleDiagnostic(DiagLevel, Info);
  185     m_os->flush();
  326   target_arch = target_sp->GetArchitecture();
  339     frame_lang = frame_sp->GetLanguage();
  342     lang_rt = process_sp->GetLanguageRuntime(frame_lang);
  469           process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC) != nullptr;
  584           target_sp->GetClangModulesDeclVendor()) {
  587             target_sp->GetPersistentExpressionStateForLanguage(
 1204     sc = frame_sp->GetSymbolContext(lldb::eSymbolContextEverything);
 1216       auto runtime = process_sp->GetLanguageRuntime(lang);
 1228     custom_passes.EarlyPasses->run(*llvm_module_up);
 1250         ir_for_target.runOnModule(*execution_unit_sp->GetModule());
 1267           *execution_unit_sp->GetModule(), *execution_unit_sp->GetFunction(),
 1267           *execution_unit_sp->GetModule(), *execution_unit_sp->GetFunction(),
 1318           llvm::Module *module = execution_unit_sp->GetModule();
 1331             custom_passes.LatePasses->run(*module);
 1339       execution_unit_sp->GetRunnableInfo(err, func_addr, func_end);
 1342     execution_unit_sp->GetRunnableInfo(err, func_addr, func_end);
 1368   execution_unit_sp->GetStaticInitializers(static_initializers);
 1379         exe_ctx.GetThreadRef().GetProcess()->RunThreadPlan(

tools/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionSourceCode.cpp

  269   for (size_t i = 0; i < var_list_sp->GetSize(); i++) {
  270     lldb::VariableSP var_sp = var_list_sp->GetVariableAtIndex(i);
  272     ConstString var_name = var_sp->GetName();
  312         if (platform_sp->GetPluginName() == g_platform_ios_simulator) {

tools/lldb/source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp

  588   if (!target.GetPlatform()->SupportsModules())
  605   target.GetPlatform()->AddClangModuleCompilationOptions(
  668   invocation->getPreprocessorOpts().addRemappedFile(ModuleImportBufferName,

tools/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.cpp

   52   llvm::StringRef name = variable->GetName().GetStringRef();

tools/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp

  170             variable_list_sp->FindVariable(ConstString("this")));
  172         if (!this_var_sp || !this_var_sp->IsInScope(frame) ||
  173             !this_var_sp->LocationIsValidForFrame(frame)) {
  200             variable_list_sp->FindVariable(ConstString("self"));
  202         if (!self_variable_sp || !self_variable_sp->IsInScope(frame) ||
  203             !self_variable_sp->LocationIsValidForFrame(frame)) {
  243               variable_list_sp->FindVariable(ConstString("this")));
  245           if (!this_var_sp || !this_var_sp->IsInScope(frame) ||
  246               !this_var_sp->LocationIsValidForFrame(frame)) {
  270               variable_list_sp->FindVariable(ConstString("self"));
  272           if (!self_variable_sp || !self_variable_sp->IsInScope(frame) ||
  273               !self_variable_sp->LocationIsValidForFrame(frame)) {
  278           Type *self_type = self_variable_sp->GetType();
  480     for (std::size_t i = 0; i < module->GetNumCompileUnits(); ++i) {
  482           module->GetCompileUnitAtIndex(i)->GetSupportFiles();
  482           module->GetCompileUnitAtIndex(i)->GetSupportFiles();
  675     if (m_execution_unit_sp->GetJittedFunctions().size() > 1) {
  686     lldb::ModuleSP jit_module_sp(m_execution_unit_sp->GetJITModule());
  692       jit_module_sp->SetFileSpecAndObjectName(jit_file, ConstString());
  848       exe_ctx.GetTargetRef().GetDebugger().GetAsyncOutputStream()->Printf(

tools/lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.cpp

  127       lldb::ModuleSP jit_module_sp(m_execution_unit_sp->GetJITModule());
  133         jit_module_sp->SetFileSpecAndObjectName(jit_file, ConstString());

tools/lldb/source/Plugins/ExpressionParser/Clang/IRDynamicChecks.cpp

   59   if (!m_valid_pointer_check->Install(diagnostic_manager, exe_ctx))
   72       if (!m_objc_object_check->Install(diagnostic_manager, exe_ctx))
   85   if (m_valid_pointer_check && m_valid_pointer_check->ContainsAddress(addr)) {
   89              m_objc_object_check->ContainsAddress(addr)) {
  328           BuildPointerValidatorFunc(m_checker_function->StartAddress());
  397           BuildObjectCheckerFunc(m_checker_function->StartAddress());

tools/lldb/source/Plugins/ExpressionParser/Clang/ModuleDependencyCollector.h

   28       m_file_collector->addFile(Filename);

tools/lldb/source/Plugins/Instruction/ARM/EmulateInstructionARM.cpp

14404       (value_sp->GetType() != OptionValue::eTypeUInt64)) {
14408   test_opcode = value_sp->GetUInt64Value();
14430       (value_sp->GetType() != OptionValue::eTypeDictionary)) {
14435   OptionValueDictionary *state_dictionary = value_sp->GetAsDictionary();
14443       (value_sp->GetType() != OptionValue::eTypeDictionary)) {
14448   state_dictionary = value_sp->GetAsDictionary();
14504   row->GetCFAValue().SetIsRegisterPlusOffset(dwarf_sp, 0);

tools/lldb/source/Plugins/Instruction/ARM/EmulationStateARM.cpp

  292     OptionValueDictionary *mem_dict = value_sp->GetAsDictionary();
  297       start_address = value_sp->GetUInt64Value();
  300     OptionValueArray *mem_array = value_sp->GetAsArray();
  311       uint64_t value = value_sp->GetUInt64Value();
  323   OptionValueDictionary *reg_dict = value_sp->GetAsDictionary();
  333     uint64_t reg_value = value_sp->GetUInt64Value();
  341   StorePseudoRegisterValue(dwarf_cpsr, value_sp->GetUInt64Value());
  351     uint64_t reg_value = value_sp->GetUInt64Value();

tools/lldb/source/Plugins/Instruction/ARM64/EmulateInstructionARM64.cpp

  477   row->GetCFAValue().SetIsRegisterPlusOffset(gpr_sp_arm64, 0);

tools/lldb/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp

 1145   row->GetCFAValue().SetIsRegisterPlusOffset(dwarf_sp_mips, 0);
 1148   row->SetRegisterLocationToRegister(dwarf_pc_mips, dwarf_ra_mips, can_replace);

tools/lldb/source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.cpp

 1036   row->GetCFAValue().SetIsRegisterPlusOffset(dwarf_sp_mips64, 0);
 1039   row->SetRegisterLocationToRegister(dwarf_pc_mips64, dwarf_ra_mips64,

tools/lldb/source/Plugins/Instruction/PPC64/EmulateInstructionPPC64.cpp

  132   row->GetCFAValue().SetIsRegisterPlusOffset(gpr_r1_ppc64le, 0);

tools/lldb/source/Plugins/InstrumentationRuntime/ASan/ASanRuntime.cpp

   68   const Symbol *symbol = module_sp->FindFirstSymbolWithNameAndType(
  117       process_sp->GetThreadList().GetExpressionExecutionThread();
  118   StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
  128   options.SetTimeout(process_sp->GetUtilityExpressionTimeout());
  136   frame_sp->CalculateExecutionContext(exe_ctx);
  141     process_sp->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf(
  141     process_sp->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf(
  173   process_sp->ReadCStringFromMemory(description_ptr, description, error);
  193   std::string description = report->GetAsDictionary()
  195                                 ->GetAsString()
  250   if (process_sp->GetModIDRef().IsLastResumeForUserExpression())
  262       thread_sp->SetStopInfo(InstrumentationRuntimeStopInfo::
  267         process_sp->GetTarget().GetDebugger().GetOutputStreamSP());
  269       stream_sp->Printf("AddressSanitizer report breakpoint hit. Use 'thread "
  287   const Symbol *symbol = GetRuntimeModuleSP()->FindFirstSymbolWithNameAndType(
  296   Target &target = process_sp->GetTarget();
  305       process_sp->GetTarget()
  320       process_sp->GetTarget().RemoveBreakpointByID(GetBreakpointID());

tools/lldb/source/Plugins/InstrumentationRuntime/MainThreadChecker/MainThreadCheckerRuntime.cpp

   69       module_sp->FindFirstSymbolWithNameAndType(test_sym, lldb::eSymbolTypeAny);
   80   StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
   82   Target &target = process_sp->GetTarget();
   87   RegisterContextSP regctx_sp = frame_sp->GetRegisterContext();
   91   const RegisterInfo *reginfo = regctx_sp->GetRegisterInfoByName("arg1");
   95   uint64_t apiname_ptr = regctx_sp->ReadRegisterAsUnsigned(reginfo, 0);
  119   for (unsigned I = 0; I < thread_sp->GetStackFrameCount(); ++I) {
  120     StackFrameSP frame = thread_sp->GetStackFrameAtIndex(I);
  121     Address addr = frame->GetFrameCodeAddress();
  146   d->AddIntegerItem("tid", thread_sp->GetIndexID());
  167   if (process_sp->GetModIDRef().IsLastResumeForUserExpression())
  174     std::string description = report->GetAsDictionary()
  176                                 ->GetAsString()
  178     thread_sp->SetStopInfo(
  198   const Symbol *symbol = runtime_module_sp->FindFirstSymbolWithNameAndType(
  207   Target &target = process_sp->GetTarget();
  214       process_sp->GetTarget()
  234     process_sp->GetTarget().RemoveBreakpointByID(BID);
  247   if (info->GetObjectForDotSeparatedPath("instrumentation_class")
  248       ->GetStringValue() != "MainThreadChecker")
  252   auto trace = info->GetObjectForDotSeparatedPath("trace")->GetAsArray();
  252   auto trace = info->GetObjectForDotSeparatedPath("trace")->GetAsArray();
  262       info->GetObjectForDotSeparatedPath("tid");
  263   tid_t tid = thread_id_obj ? thread_id_obj->GetIntegerValue() : 0;
  270   process_sp->GetExtendedThreadList().AddThread(new_thread_sp);
  271   threads->AddThread(new_thread_sp);

tools/lldb/source/Plugins/InstrumentationRuntime/TSan/TSanRuntime.cpp

  259   process_sp->ReadCStringFromMemory(ptr, str, error);
  277         ThreadSP lldb_thread = process_sp->GetThreadList().FindThreadByID(
  280           lldb_user_id = lldb_thread->GetIndexID();
  286           lldb_user_id = process_sp->AssignIndexIDToThread(thread_os_id);
  309   StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
  319   options.SetTimeout(process_sp->GetUtilityExpressionTimeout());
  327   frame_sp->CalculateExecutionContext(exe_ctx);
  332     process_sp->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf(
  332     process_sp->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf(
  359         dict->AddIntegerItem("thread_id", thread_sp->GetIndexID());
  490   std::string description = report->GetAsDictionary()
  492                                 ->GetAsString()
  544   if (!process_sp->GetTarget().GetSectionLoadList().ResolveLoadAddress(addr,
  559   if (!process_sp->GetTarget().GetSectionLoadList().ResolveLoadAddress(addr,
  575   module->FindGlobalVariables(sym_name, nullptr, 1U, var_list);
  580   decl = var->GetDeclaration();
  588   StructuredData::Array *trace_array = trace->GetAsArray();
  598     if (!process_sp->GetTarget().GetSectionLoadList().ResolveLoadAddress(
  615   std::string summary = report->GetAsDictionary()
  617                             ->GetAsString()
  620       report->GetObjectForDotSeparatedPath("issue_type")->GetStringValue() ==
  620       report->GetObjectForDotSeparatedPath("issue_type")->GetStringValue() ==
  624   if (report->GetAsDictionary()
  626           ->GetAsArray()
  628     pc = GetFirstNonInternalFramePc(report->GetAsDictionary()
  630                                         ->GetAsArray()
  632                                         ->GetAsDictionary()
  636   if (report->GetAsDictionary()
  638           ->GetAsArray()
  640     pc = GetFirstNonInternalFramePc(report->GetAsDictionary()
  642                                         ->GetAsArray()
  644                                         ->GetAsDictionary()
  652   if (report->GetAsDictionary()
  654           ->GetAsArray()
  656     StructuredData::ObjectSP loc = report->GetAsDictionary()
  658                                        ->GetAsArray()
  660     std::string object_type = loc->GetAsDictionary()
  662                                   ->GetAsString()
  667     addr_t addr = loc->GetAsDictionary()
  669                       ->GetAsInteger()
  672       addr = loc->GetAsDictionary()
  674                  ->GetAsInteger()
  685       int fd = loc->GetAsDictionary()
  687                    ->GetAsInteger()
  702   report->GetObjectForDotSeparatedPath("mops")->GetAsArray()->ForEach(
  702   report->GetObjectForDotSeparatedPath("mops")->GetAsArray()->ForEach(
  705             o->GetObjectForDotSeparatedPath("address")->GetIntegerValue();
  721   if (report->GetAsDictionary()
  723           ->GetAsArray()
  725     StructuredData::ObjectSP loc = report->GetAsDictionary()
  727                                        ->GetAsArray()
  730         loc->GetAsDictionary()->GetValueForKey("type")->GetStringValue();
  730         loc->GetAsDictionary()->GetValueForKey("type")->GetStringValue();
  732       global_addr = loc->GetAsDictionary()
  734                         ->GetAsInteger()
  751       addr_t addr = loc->GetAsDictionary()
  753                         ->GetAsInteger()
  755       long size = loc->GetAsDictionary()
  757                       ->GetAsInteger()
  759       std::string object_type = loc->GetAsDictionary()
  761                                     ->GetAsString()
  771       int tid = loc->GetAsDictionary()
  773                     ->GetAsInteger()
  777       int tid = loc->GetAsDictionary()
  779                     ->GetAsInteger()
  783       int fd = loc->GetAsDictionary()
  785                    ->GetAsInteger()
  806   if (process_sp->GetModIDRef().IsLastResumeForUserExpression())
  814     report->GetAsDictionary()->AddStringItem("description", issue_description);
  816     report->GetAsDictionary()->AddStringItem("stop_description",
  819     report->GetAsDictionary()->AddStringItem("summary", summary);
  821     report->GetAsDictionary()->AddIntegerItem("memory_address", main_address);
  829     report->GetAsDictionary()->AddStringItem("location_description",
  832       report->GetAsDictionary()->AddIntegerItem("global_address", global_addr);
  835       report->GetAsDictionary()->AddStringItem("global_name", global_name);
  838       report->GetAsDictionary()->AddStringItem("location_filename",
  840       report->GetAsDictionary()->AddIntegerItem("location_line", location_line);
  844     report->GetObjectForDotSeparatedPath("mops")->GetAsArray()->ForEach(
  844     report->GetObjectForDotSeparatedPath("mops")->GetAsArray()->ForEach(
  848               o->GetObjectForDotSeparatedPath("address")->GetIntegerValue();
  853     report->GetAsDictionary()->AddBooleanItem("all_addresses_are_same",
  861       thread_sp->SetStopInfo(
  866     StreamFile &s = process_sp->GetTarget().GetDebugger().GetOutputStream();
  884   const Symbol *symbol = module_sp->FindFirstSymbolWithNameAndType(
  898   const Symbol *symbol = GetRuntimeModuleSP()->FindFirstSymbolWithNameAndType(
  907   Target &target = process_sp->GetTarget();
  916       process_sp->GetTarget()
  931       process_sp->GetTarget().RemoveBreakpointByID(GetBreakpointID());
  943     int size = o->GetObjectForDotSeparatedPath("size")->GetIntegerValue();
  945         o->GetObjectForDotSeparatedPath("thread_id")->GetIntegerValue();
  947         o->GetObjectForDotSeparatedPath("is_write")->GetBooleanValue();
  949         o->GetObjectForDotSeparatedPath("is_atomic")->GetBooleanValue();
  950     addr_t addr = o->GetObjectForDotSeparatedPath("address")->GetIntegerValue();
  954     if (main_info->GetObjectForDotSeparatedPath("all_addresses_are_same")
  955             ->GetBooleanValue()) {
  959     if (main_info->GetObjectForDotSeparatedPath("issue_type")
  960             ->GetStringValue() == "external-race") {
  963     } else if (main_info->GetObjectForDotSeparatedPath("issue_type")
  964                    ->GetStringValue() == "swift-access-race") {
  975         o->GetObjectForDotSeparatedPath("thread_id")->GetIntegerValue();
  981         o->GetAsDictionary()->GetValueForKey("type")->GetStringValue();
  983         o->GetObjectForDotSeparatedPath("thread_id")->GetIntegerValue();
  985         o->GetObjectForDotSeparatedPath("file_descriptor")->GetIntegerValue();
  996         o->GetObjectForDotSeparatedPath("mutex_id")->GetIntegerValue();
 1003         o->GetObjectForDotSeparatedPath("thread_id")->GetIntegerValue();
 1015   info->GetObjectForDotSeparatedPath(path)->GetAsArray()->ForEach(
 1015   info->GetObjectForDotSeparatedPath(path)->GetAsArray()->ForEach(
 1018         o->GetObjectForDotSeparatedPath("trace")->GetAsArray()->ForEach(
 1029         tid_t tid = thread_id_obj ? thread_id_obj->GetIntegerValue() : 0;
 1034         new_thread_sp->SetName(GenerateThreadName(path, o, info).c_str());
 1038         process_sp->GetExtendedThreadList().AddThread(new_thread_sp);
 1039         threads->AddThread(new_thread_sp);
 1051   if (info->GetObjectForDotSeparatedPath("instrumentation_class")
 1052           ->GetStringValue() != "ThreadSanitizer")

tools/lldb/source/Plugins/InstrumentationRuntime/UBSan/UBSanRuntime.cpp

  109   process_sp->ReadCStringFromMemory(ptr, str, error);
  120   StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
  122   Target &target = process_sp->GetTarget();
  134   options.SetTimeout(process_sp->GetUtilityExpressionTimeout());
  142   frame_sp->CalculateExecutionContext(exe_ctx);
  147     target.GetDebugger().GetAsyncOutputStream()->Printf(
  156   for (unsigned I = 0; I < thread_sp->GetStackFrameCount(); ++I) {
  158         thread_sp->GetStackFrameAtIndex(I)->GetFrameCodeAddress();
  158         thread_sp->GetStackFrameAtIndex(I)->GetFrameCodeAddress();
  183   d->AddIntegerItem("tid", thread_sp->GetID());
  190   report->GetAsDictionary()->GetValueForKeyAsString("description",
  221   if (process_sp->GetModIDRef().IsLastResumeForUserExpression())
  228     thread_sp->SetStopInfo(
  246   const Symbol *symbol = module_sp->FindFirstSymbolWithNameAndType(
  263   const Symbol *symbol = runtime_module_sp->FindFirstSymbolWithNameAndType(
  272   Target &target = process_sp->GetTarget();
  279       process_sp->GetTarget()
  299     process_sp->GetTarget().RemoveBreakpointByID(BID);
  312   if (info->GetObjectForDotSeparatedPath("instrumentation_class")
  313           ->GetStringValue() != "UndefinedBehaviorSanitizer")
  317   auto trace = info->GetObjectForDotSeparatedPath("trace")->GetAsArray();
  317   auto trace = info->GetObjectForDotSeparatedPath("trace")->GetAsArray();
  327       info->GetObjectForDotSeparatedPath("tid");
  328   tid_t tid = thread_id_obj ? thread_id_obj->GetIntegerValue() : 0;
  333   new_thread_sp->SetName(stop_reason_description.c_str());
  337   process_sp->GetExtendedThreadList().AddThread(new_thread_sp);
  338   threads->AddThread(new_thread_sp);

tools/lldb/source/Plugins/JITLoader/GDB/JITLoaderGDB.cpp

   96     m_collection_sp->Initialize(g_jitloadergdb_properties);
  100     return (EnableJITLoaderGDB)m_collection_sp->GetPropertyAtIndexAsEnumeration(
  161         debugger, GetGlobalPluginProperties()->GetValueProperties(),
  236       if (section_sp->IsFake()) {
  239         updateSectionLoadAddress(section_sp->GetChildren(), target,
  246         const lldb::addr_t slide_amount = lower - section_sp->GetFileAddress();
  247         section_sp->Slide(slide_amount, false);
  248         section_sp->GetChildren().Slide(-slide_amount, false);
  249         section_sp->SetByteSize(upper - lower);
  251         vmaddrheuristic += 2 << section_sp->GetLog2Align();
  253         if (section_sp->GetFileAddress() > vmaddrheuristic)
  254           lower = section_sp->GetFileAddress();
  256           lower = symbolfile_addr + section_sp->GetFileOffset();
  257           section_sp->SetFileAddress(symbolfile_addr +
  258                                      section_sp->GetFileOffset());
  261         uint64_t upper = lower + section_sp->GetByteSize();
  267         vmaddrheuristic += section_sp->GetByteSize();
  330       if (module_sp && module_sp->GetObjectFile()) {
  333         module_sp->GetObjectFile()->SetType(ObjectFile::eTypeJIT);
  336         module_sp->GetObjectFile()->GetSymtab();
  340                 llvm::dyn_cast<ObjectFileMachO>(module_sp->GetObjectFile())) {
  352           module_sp->SetLoadAddress(target, 0, true, changed);
  373         ObjectFile *image_object_file = module_sp->GetObjectFile();
  413   switch (GetGlobalPluginProperties()->GetEnable()) {

tools/lldb/source/Plugins/Language/CPlusPlus/BlockPointer.cpp

   43     auto type_system_or_err = target_sp->GetScratchTypeSystemForLanguage(
   59     ClangASTImporterSP clang_ast_importer = target_sp->GetClangASTImporter();
   76         clang_ast_importer->CopyType(*clang_ast_context, function_pointer_type);

tools/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

  552   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
  552   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
  703   cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::string"),
  703   cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::string"),
  705   cpp_category_sp->GetTypeSummariesContainer()->Add(
  705   cpp_category_sp->GetTypeSummariesContainer()->Add(
  707   cpp_category_sp->GetTypeSummariesContainer()->Add(
  707   cpp_category_sp->GetTypeSummariesContainer()->Add(
  711   cpp_category_sp->GetTypeSummariesContainer()->Add(
  711   cpp_category_sp->GetTypeSummariesContainer()->Add(
  716   cpp_category_sp->GetTypeSummariesContainer()->Add(
  716   cpp_category_sp->GetTypeSummariesContainer()->Add(
  718   cpp_category_sp->GetTypeSummariesContainer()->Add(
  718   cpp_category_sp->GetTypeSummariesContainer()->Add(
  728   cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::wstring"),
  728   cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::wstring"),
  730   cpp_category_sp->GetTypeSummariesContainer()->Add(
  730   cpp_category_sp->GetTypeSummariesContainer()->Add(
  732   cpp_category_sp->GetTypeSummariesContainer()->Add(
  732   cpp_category_sp->GetTypeSummariesContainer()->Add(
  736   cpp_category_sp->GetTypeSummariesContainer()->Add(
  736   cpp_category_sp->GetTypeSummariesContainer()->Add(
  741   cpp_category_sp->GetTypeSummariesContainer()->Add(
  741   cpp_category_sp->GetTypeSummariesContainer()->Add(
  743   cpp_category_sp->GetTypeSummariesContainer()->Add(
  743   cpp_category_sp->GetTypeSummariesContainer()->Add(
  752   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
  752   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
  757   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
  757   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
  762   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
  762   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
  769   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
  769   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
  773   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
  773   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
  777   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
  777   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
  986             if (fmt_mgr.GetCategory(g_vectortypes)->IsEnabled())
 1036         if (fmt_mgr.GetCategory(g_vectortypes)->IsEnabled())

tools/lldb/source/Plugins/Language/CPlusPlus/LibCxx.cpp

  262         ProcessSP process_sp(target_sp->GetProcessSP());
  264         process_sp->ReadMemory(addr, buffer_sp->GetBytes(),
  264         process_sp->ReadMemory(addr, buffer_sp->GetBytes(),
  265                                buffer_sp->GetByteSize(), error);
  268         DataExtractor extractor(buffer_sp, process_sp->GetByteOrder(),
  269                                 process_sp->GetAddressByteSize());
  416   m_byte_order = target_sp->GetArchitecture().GetByteOrder();
  417   m_ptr_size = target_sp->GetArchitecture().GetAddressByteSize();
  566     const auto max_size = valobj.GetTargetSP()->GetMaximumSizeOfStringSummary();
  576                           ->GetScratchClangASTContext()
  638     const auto max_size = valobj.GetTargetSP()->GetMaximumSizeOfStringSummary();

tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxBitset.cpp

   52     m_byte_order = target_sp->GetArchitecture().GetByteOrder();
   53     m_byte_size = target_sp->GetArchitecture().GetAddressByteSize();
   65   size_t capping_size = target_sp->GetMaximumNumberOfChildrenToDisplay();

tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxList.cpp

  180         m_backend.GetTargetSP()->GetMaximumNumberOfChildrenToDisplay();
  391     addr = addr + 2 * process_sp->GetAddressByteSize();

tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp

   46         m_entry_sp->GetProcessSP()->GetAddressByteSize(),
   55         2 * m_entry_sp->GetProcessSP()->GetAddressByteSize(),

tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp

  210   size_t bytes_read = process_sp->ReadMemory(byte_location, &byte, 1, err);
  219   if (bit_set && buffer_sp && buffer_sp->GetBytes()) {
  221     *(buffer_sp->GetBytes()) = 1;
  227       DataExtractor(buffer_sp, process_sp->GetByteOrder(),
  228                     process_sp->GetAddressByteSize()),

tools/lldb/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp

   96   bool is_64bit = (target_sp->GetArchitecture().GetAddressByteSize() == 8);
  248           process_sp->ReadPointerFromMemory(addr_of_string, error);
  257       lldb::addr_t size_of_data = process_sp->ReadPointerFromMemory(
  258           addr_of_string + process_sp->GetAddressByteSize(), error);
  308           process_sp->ReadPointerFromMemory(addr_of_string, error);
  317       lldb::addr_t size_of_data = process_sp->ReadPointerFromMemory(
  318           addr_of_string + process_sp->GetAddressByteSize(), error);

tools/lldb/source/Plugins/Language/ObjC/CF.cpp

   62   if (!descriptor.get() || !descriptor->IsValid())
   65   uint32_t ptr_size = process_sp->GetAddressByteSize();
   75   if (descriptor->IsCFType()) {
   90     count = process_sp->ReadUnsignedIntegerFromMemory(offset, 4, 0, error);
  124   if (!descriptor.get() || !descriptor->IsValid())
  127   uint32_t ptr_size = process_sp->GetAddressByteSize();
  137   if (descriptor->IsCFType()) {
  150   count = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + 2 * ptr_size,
  155   addr_t data_ptr = process_sp->ReadPointerFromMemory(
  164       process_sp->ReadMemory(data_ptr, buffer_sp->GetBytes(), num_bytes, error);
  164       process_sp->ReadMemory(data_ptr, buffer_sp->GetBytes(), num_bytes, error);
  167   uint8_t *bytes = buffer_sp->GetBytes();
  244   if (!descriptor.get() || !descriptor->IsValid())
  247   uint32_t ptr_size = process_sp->GetAddressByteSize();
  258   if (descriptor->IsCFType()) {
  277     count = process_sp->ReadUnsignedIntegerFromMemory(offset, 4, 0, error);

tools/lldb/source/Plugins/Language/ObjC/Cocoa.cpp

   53   if (!descriptor || !descriptor->IsValid())
   56   uint32_t ptr_size = process_sp->GetAddressByteSize();
   63   llvm::StringRef class_name(descriptor->GetClassName().GetCString());
  101   if (!descriptor || !descriptor->IsValid())
  104   uint32_t ptr_size = process_sp->GetAddressByteSize();
  111   llvm::StringRef class_name(descriptor->GetClassName().GetCString());
  146   if (!descriptor || !descriptor->IsValid())
  149   uint32_t ptr_size = process_sp->GetAddressByteSize();
  156   llvm::StringRef class_name(descriptor->GetClassName().GetCString());
  191   if (!descriptor || !descriptor->IsValid())
  194   uint32_t ptr_size = process_sp->GetAddressByteSize();
  201   llvm::StringRef class_name(descriptor->GetClassName().GetCString());
  211     port_number = process_sp->ReadUnsignedIntegerFromMemory(
  237   if (!descriptor || !descriptor->IsValid())
  240   uint32_t ptr_size = process_sp->GetAddressByteSize();
  247   llvm::StringRef class_name(descriptor->GetClassName().GetCString());
  257       uint32_t mode = process_sp->ReadUnsignedIntegerFromMemory(
  271         count = process_sp->ReadUnsignedIntegerFromMemory(
  277         count = process_sp->ReadUnsignedIntegerFromMemory(
  282         count = process_sp->ReadUnsignedIntegerFromMemory(count + 2 * ptr_size,
  426   if (!descriptor || !descriptor->IsValid())
  429   uint32_t ptr_size = process_sp->GetAddressByteSize();
  436   llvm::StringRef class_name(descriptor->GetClassName().GetCString());
  450     if (descriptor->GetTaggedPointerInfo(&i_bits, &value)) {
  496             process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
  511         process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, 1,
  533         value = process_sp->ReadUnsignedIntegerFromMemory(data_location, 1, 0,
  541         value = process_sp->ReadUnsignedIntegerFromMemory(data_location, 2, 0,
  550         value = process_sp->ReadUnsignedIntegerFromMemory(data_location, 4, 0,
  558         value = process_sp->ReadUnsignedIntegerFromMemory(data_location, 8, 0,
  567         uint32_t flt_as_int = process_sp->ReadUnsignedIntegerFromMemory(
  579         uint64_t dbl_as_lng = process_sp->ReadUnsignedIntegerFromMemory(
  592         words[1] = process_sp->ReadUnsignedIntegerFromMemory(
  596         words[0] = process_sp->ReadUnsignedIntegerFromMemory(
  620   uint32_t ptr_size = process_sp->GetAddressByteSize();
  623   int8_t exponent = process_sp->ReadUnsignedIntegerFromMemory(
  628   uint8_t length_and_negative = process_sp->ReadUnsignedIntegerFromMemory(
  650   uint64_t mantissa = process_sp->ReadUnsignedIntegerFromMemory(
  676   if (!descriptor || !descriptor->IsValid())
  679   uint32_t ptr_size = process_sp->GetAddressByteSize();
  686   llvm::StringRef class_name = descriptor->GetClassName().GetStringRef();
  790   if (!descriptor || !descriptor->IsValid())
  793   uint32_t ptr_size = process_sp->GetAddressByteSize();
  803   ConstString class_name = descriptor->GetClassName();
  816     if (descriptor->GetTaggedPointerInfo(&info_bits, &value_bits)) {
  821           process_sp->GetTarget().GetArchitecture().GetTriple());
  825       date_value_bits = process_sp->ReadUnsignedIntegerFromMemory(
  833     date_value_bits = process_sp->ReadUnsignedIntegerFromMemory(
  885   if (!descriptor || !descriptor->IsValid())
  888   ConstString class_name = descriptor->GetClassName();
  944   if (!descriptor || !descriptor->IsValid())
  947   bool is_64bit = (process_sp->GetAddressByteSize() == 8);
  955   llvm::StringRef class_name = descriptor->GetClassName().GetCString();
  971     value = process_sp->ReadUnsignedIntegerFromMemory(
  978     value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + offset, 2,

tools/lldb/source/Plugins/Language/ObjC/CoreMedia.cpp

   32           ->GetScratchTypeSystemForLanguage(lldb::eLanguageTypeC);

tools/lldb/source/Plugins/Language/ObjC/NSArray.cpp

  355   if (!descriptor || !descriptor->IsValid())
  358   uint32_t ptr_size = process_sp->GetAddressByteSize();
  367   ConstString class_name(descriptor->GetClassName());
  385     value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
  396       value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
  403     value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
  414     value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
  420     value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
  432     value = process_sp->ReadUnsignedIntegerFromMemory(
  466                                   ->GetScratchClangASTContext();
  472       m_ptr_size = valobj_sp->GetProcessSP()->GetAddressByteSize();
  523   m_ptr_size = process_sp->GetAddressByteSize();
  527     process_sp->ReadMemory(data_location, m_data_32, sizeof(D32),
  531     process_sp->ReadMemory(data_location, m_data_64, sizeof(D64),
  615                                     ->GetScratchClangASTContext();
  669   m_ptr_size = process_sp->GetAddressByteSize();
  673     process_sp->ReadMemory(data_location, m_data_32, sizeof(D32),
  677     process_sp->ReadMemory(data_location, m_data_64, sizeof(D64),
  784         m_backend.GetTargetSP()->GetScratchClangASTContext()->GetBasicType(
  787         m_backend.GetProcessSP()->GetAddressByteSize(), id_type, true, g_zero);
  819   if (!descriptor || !descriptor->IsValid())
  822   ConstString class_name(descriptor->GetClassName());

tools/lldb/source/Plugins/Language/ObjC/NSDictionary.cpp

   68   ClangASTContext *target_ast_context = target_sp->GetScratchClangASTContext();
  357   if (!descriptor || !descriptor->IsValid())
  360   uint32_t ptr_size = process_sp->GetAddressByteSize();
  370   ConstString class_name(descriptor->GetClassName());
  385     value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
  399       value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
  457   if (!descriptor || !descriptor->IsValid())
  460   ConstString class_name(descriptor->GetClassName());
  543   m_ptr_size = process_sp->GetAddressByteSize();
  544   m_order = process_sp->GetByteOrder();
  548     process_sp->ReadMemory(data_location, m_data_32, sizeof(DataDescriptor_32),
  552     process_sp->ReadMemory(data_location, m_data_64, sizeof(DataDescriptor_64),
  588       key_at_idx = process_sp->ReadPointerFromMemory(key_at_idx, error);
  591       val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx, error);
  625       uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
  629       uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes();
  681   auto ptr_size = process_sp->GetAddressByteSize();
  689   lldb::addr_t value_at_idx = process_sp->ReadPointerFromMemory(key_ptr, error);
  692   lldb::addr_t key_at_idx = process_sp->ReadPointerFromMemory(value_ptr, error);
  697       GetLLDBNSPairType(process_sp->GetTarget().shared_from_this());
  702     uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
  706     uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes();
  711   DataExtractor data(buffer_sp, process_sp->GetByteOrder(), ptr_size);
  771   m_ptr_size = process_sp->GetAddressByteSize();
  772   m_order = process_sp->GetByteOrder();
  776     process_sp->ReadMemory(data_location, m_data_32, sizeof(D32),
  780     process_sp->ReadMemory(data_location, m_data_64, sizeof(D64),
  832       key_at_idx = process_sp->ReadPointerFromMemory(key_at_idx, error);
  835       val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx, error);
  869       uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
  873       uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes();
  939   m_ptr_size = process_sp->GetAddressByteSize();
  940   m_order = process_sp->GetByteOrder();
  944     process_sp->ReadMemory(data_location, m_data_32, sizeof(DataDescriptor_32),
  948     process_sp->ReadMemory(data_location, m_data_64, sizeof(DataDescriptor_64),
  990       key_at_idx = process_sp->ReadPointerFromMemory(key_at_idx, error);
  993       val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx, error);
 1027       uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
 1031       uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes();

tools/lldb/source/Plugins/Language/ObjC/NSError.cpp

   45           ptr_value = process_sp->ReadPointerFromMemory(ptr_value, error);
   65   size_t ptr_size = process_sp->GetAddressByteSize();
   70   uint64_t code = process_sp->ReadUnsignedIntegerFromMemory(code_location,
   76       process_sp->ReadPointerFromMemory(domain_location, error);
   88       "domain_str", isw.GetAsData(process_sp->GetByteOrder()),
   89       valobj.GetExecutionContextRef(), process_sp->GetTarget()
  147     size_t ptr_size = process_sp->GetAddressByteSize();
  152         process_sp->ReadPointerFromMemory(userinfo_location, error);
  157         "_userInfo", isw.GetAsData(process_sp->GetByteOrder()),
  159         process_sp->GetTarget().GetScratchClangASTContext()->GetBasicType(
  197   if (!descriptor.get() || !descriptor->IsValid())
  200   const char *class_name = descriptor->GetClassName().GetCString();

tools/lldb/source/Plugins/Language/ObjC/NSException.cpp

   51   size_t ptr_size = process_sp->GetAddressByteSize();
   54   auto name = process_sp->ReadPointerFromMemory(ptr + 1 * ptr_size, error);
   57   auto reason = process_sp->ReadPointerFromMemory(ptr + 2 * ptr_size, error);
   60   auto userinfo = process_sp->ReadPointerFromMemory(ptr + 3 * ptr_size, error);
   63   auto reserved = process_sp->ReadPointerFromMemory(ptr + 4 * ptr_size, error);
   72   CompilerType voidstar = process_sp->GetTarget()
   79         "name", name_isw.GetAsData(process_sp->GetByteOrder()),
   83         "reason", reason_isw.GetAsData(process_sp->GetByteOrder()),
   87         "userInfo", userinfo_isw.GetAsData(process_sp->GetByteOrder()),
   91         "reserved", reserved_isw.GetAsData(process_sp->GetByteOrder()),
  189   if (!descriptor.get() || !descriptor->IsValid())
  192   const char *class_name = descriptor->GetClassName().GetCString();

tools/lldb/source/Plugins/Language/ObjC/NSIndexPath.cpp

   38         m_backend.GetTargetSP()->GetArchitecture().GetAddressByteSize();
   58                                ->GetScratchClangASTContext();
   79     if (!descriptor.get() || !descriptor->IsValid())
   84     if (descriptor->GetTaggedPointerInfo(&info_bits, &value_bits, &payload)) {
   93       for (size_t x = 0; x < descriptor->GetNumIVars(); x++) {
   94         const auto &ivar = descriptor->GetIVarAtIndex(x);

tools/lldb/source/Plugins/Language/ObjC/NSSet.cpp

  235   if (!descriptor || !descriptor->IsValid())
  238   uint32_t ptr_size = process_sp->GetAddressByteSize();
  248   ConstString class_name_cs = descriptor->GetClassName();
  257     value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
  269       value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
  321   if (!descriptor || !descriptor->IsValid())
  324   ConstString class_name_cs = descriptor->GetClassName();
  410   m_ptr_size = process_sp->GetAddressByteSize();
  414     process_sp->ReadMemory(data_location, m_data_32, sizeof(DataDescriptor_32),
  418     process_sp->ReadMemory(data_location, m_data_64, sizeof(DataDescriptor_64),
  454       obj_at_idx = process_sp->ReadPointerFromMemory(obj_at_idx, error);
  475     auto ptr_size = process_sp->GetAddressByteSize();
  493                        process_sp->GetByteOrder(),
  494                        process_sp->GetAddressByteSize());
  570   m_ptr_size = process_sp->GetAddressByteSize();
  574     process_sp->ReadMemory(data_location, m_data_32, sizeof(D32),
  578     process_sp->ReadMemory(data_location, m_data_64, sizeof(D64),
  621       obj_at_idx = process_sp->ReadPointerFromMemory(obj_at_idx, error);
  642     auto ptr_size = process_sp->GetAddressByteSize();
  660                        process_sp->GetByteOrder(),
  661                        process_sp->GetAddressByteSize());

tools/lldb/source/Plugins/Language/ObjC/NSString.cpp

   70   if (!descriptor.get() || !descriptor->IsValid())
   73   uint32_t ptr_size = process_sp->GetAddressByteSize();
   80   ConstString class_name_cs = descriptor->GetClassName();
   87                        descriptor->GetTaggedPointerInfo();
  100   if (process_sp->GetByteOrder() != lldb::eByteOrderLittle)
  105   uint8_t info_bits = process_sp->ReadUnsignedIntegerFromMemory(
  133       explicit_length = process_sp->ReadUnsignedIntegerFromMemory(
  165     location = process_sp->ReadPointerFromMemory(location, error);
  216       location = process_sp->ReadPointerFromMemory(location, error);
  259           process_sp->ReadUnsignedIntegerFromMemory(location, 1, 0, error);
  280     location = process_sp->ReadPointerFromMemory(location, error);
  303   uint32_t addr_size = target_sp->GetArchitecture().GetAddressByteSize();
  340   if (!descriptor->GetTaggedPointerInfo(&len_bits, &data_bits, nullptr))

tools/lldb/source/Plugins/Language/ObjC/ObjCLanguage.cpp

  282   objc_category_sp->GetTypeSummariesContainer()->Add(ConstString("BOOL"),
  282   objc_category_sp->GetTypeSummariesContainer()->Add(ConstString("BOOL"),
  284   objc_category_sp->GetTypeSummariesContainer()->Add(ConstString("BOOL &"),
  284   objc_category_sp->GetTypeSummariesContainer()->Add(ConstString("BOOL &"),
  286   objc_category_sp->GetTypeSummariesContainer()->Add(ConstString("BOOL *"),
  286   objc_category_sp->GetTypeSummariesContainer()->Add(ConstString("BOOL *"),
  902       if (ConstString name = objc_class_sp->GetClassName())

tools/lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.cpp

  287   lldb::addr_t curr_pc = thread.GetRegisterContext()->GetPC();
  291   if (target_sp->GetSectionLoadList().IsEmpty())
  298   if (!target_sp->GetSectionLoadList().ResolveLoadAddress(curr_pc,
  302   target_sp->GetImages().ResolveSymbolContextForAddress(
  329     ValueObjectSP value_sp = frame->FindVariable(g_this);

tools/lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp

  102               sc.module_sp->FindTypes(ConstString(lookup_name), exact_match, 1,
  122                         type_sp->GetForwardCompilerType())) {
  129                       type_sp->GetID(), type_sp->GetName().GetCString());
  129                       type_sp->GetID(), type_sp->GetName().GetCString());
  145                         type_sp->GetID(), type_sp->GetName().GetCString());
  145                         type_sp->GetID(), type_sp->GetName().GetCString());
  154                           type_sp->GetForwardCompilerType())) {
  161                         type_sp->GetID(), type_sp->GetName().GetCString());
  161                         type_sp->GetID(), type_sp->GetName().GetCString());
  499     m_cxx_exception_bp_sp->SetEnabled(true);
  504       m_cxx_exception_bp_sp->SetBreakpointKind("c++ exception");
  513     m_cxx_exception_bp_sp->SetEnabled(false);
  518   return m_cxx_exception_bp_sp && m_cxx_exception_bp_sp->IsEnabled();
  526   if (!stop_reason || stop_reason->GetStopReason() != eStopReasonBreakpoint)
  529   uint64_t break_site_id = stop_reason->GetValue();
  531       break_site_id, m_cxx_exception_bp_sp->GetID());
  536   if (!thread_sp->SafeToCallFunctions())
  553   thread_sp->CalculateExecutionContext(exe_ctx);

tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.cpp

  387       metaclass->Describe(
  525         encoding_to_type_sp->RealizeType(type, for_expression);

tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.h

  255     m_name = actual_class_sp->GetClassName();

tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.cpp

  183   ConstString name(descriptor->GetClassName());
  370         ClangUtil::GetQualType(type_realizer_sp->RealizeType(
  388           ClangUtil::GetQualType(type_realizer_sp->RealizeType(
  507     CompilerType ivar_type = m_runtime.GetEncodingToType()->RealizeType(
  534               descriptor->GetClassName().AsCString());
  537   if (!descriptor->Describe(superclass_func, instance_method_func,

tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp

  152         exe_scope->CalculateTarget()->GetFunctionCallerForLanguage(
  289     const FileSpec &module_file_spec = module_sp->GetFileSpec();
  309       if (strcmp(module_sp->GetFileSpec().GetFilename().AsCString(""),
  311         m_Foundation_major = module_sp->GetVersion().getMajor();
  375         module_sp->IsLoadedInTarget(&target)) {
  377       ObjectFile *ofile = module_sp->GetObjectFile();
  381       SectionList *sections = module_sp->GetSectionList();
  406       m_objc_exception_bp_sp->SetBreakpointKind("ObjC exception");
  408     m_objc_exception_bp_sp->SetEnabled(true);
  416     m_objc_exception_bp_sp->SetEnabled(false);
  421   return m_objc_exception_bp_sp && m_objc_exception_bp_sp->IsEnabled();
  429   if (!stop_reason || stop_reason->GetStopReason() != eStopReasonBreakpoint)
  432   uint64_t break_site_id = stop_reason->GetValue();
  434       break_site_id, m_objc_exception_bp_sp->GetID());
  476   if (!descriptor || !descriptor->IsValid()) return ValueObjectSP();
  479     ConstString class_name(descriptor->GetClassName());
  482     descriptor = descriptor->GetSuperclass();
  498       exception_sp->GetTargetSP()->GetScratchClangASTContext()->GetBasicType(
  516     data.SetAddressByteSize(dict_entry->GetProcessSP()->GetAddressByteSize());

tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.cpp

   56     if (class_descriptor && class_descriptor->IsValid() &&
   57         class_descriptor->GetClassName()) {
   60       class_type_or_name.SetName(class_descriptor->GetClassName());
  201   m_isa = process_sp->ReadPointerFromMemory(isa, error);
  208   uint32_t ptr_size = process_sp->GetAddressByteSize();
  215   m_parent_isa = process_sp->ReadPointerFromMemory(m_isa + ptr_size, error);
  228       process_sp->ReadPointerFromMemory(m_isa + 2 * ptr_size, error);
  237   size_t count = process_sp->ReadCStringFromMemory(
  238       name_ptr, (char *)buffer_sp->GetBytes(), 1024, error);
  246     m_name = ConstString((char *)buffer_sp->GetBytes());
  250   m_instance_size = process_sp->ReadUnsignedIntegerFromMemory(
  299     const Symbol *symbol = objc_module_sp->FindFirstSymbolWithNameAndType(

tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

  391       module_sp->FindFirstSymbolWithNameAndType(name, lldb::eSymbolTypeData);
  431       (objc_module_sp->FindFirstSymbolWithNameAndType(
  466       ConstString class_name(objc_class_sp->GetClassName());
  468       TypeSP type_sp(objc_class_sp->GetType());
  474           objc_class_sp->SetType(type_sp);
  611               iterator->second->GetClassName().AsCString("<unknown>");
  618                          iterator->second->GetInstanceSize());
  620                          (uintptr_t)iterator->second->GetNumIVars());
  621           if (auto superclass = iterator->second->GetSuperclass()) {
  623                            superclass->GetClassName().AsCString("<unknown>"));
  627             for (size_t i = 0; i < iterator->second->GetNumIVars(); i++) {
  628               auto ivar = iterator->second->GetIVarAtIndex(i);
  636             iterator->second->Describe(
  725           if (descriptor_sp->GetTaggedPointerInfo(&info_bits, &value_bits,
  732                 descriptor_sp->GetClassName().AsCString("<unknown>"));
 1188         return parent_descriptor_sp->GetSuperclass();
 1238   const Symbol *symbol = objc_module_sp->FindFirstSymbolWithNameAndType(
 1268     const Symbol *symbol = objc_module_sp->FindFirstSymbolWithNameAndType(
 1303   thread_sp->CalculateExecutionContext(exe_ctx);
 1533         AddClass(isa, descriptor_sp, descriptor_sp->GetClassName().AsCString(nullptr));
 1540                   descriptor_sp->GetClassName().AsCString("<unknown>"));
 1565   thread_sp->CalculateExecutionContext(exe_ctx);
 1615               mod_sp->FindFirstSymbolWithNameAndType(g_class_getNameRaw_symbol_name, 
 1845       ObjectFile *objc_object = objc_module_sp->GetObjectFile();
 1848         SectionList *section_list = objc_module_sp->GetSectionList();
 1856                 text_segment_sp->GetChildren().FindSectionByName(
 1860               return objc_opt_section_sp->GetLoadBaseAddress(
 1945   ConstString platform_plugin_name = platform_sp->GetPluginName();
 1972       stream->PutCString("warning: could not find Objective-C class data in "
 1978       stream->PutCString("warning: could not execute support code to read "
 2060           descriptor->Describe(
 2075         ret = descriptor->GetISA();
 2675     ThreadSP thread_sp = frame_sp->GetThread();
 2676     ProcessSP process_sp = thread_sp->GetProcess();
 2678     const lldb::ABISP &abi = process_sp->GetABI();
 2681     CompilerType voidstar = process_sp->GetTarget()
 2691     if (!abi->GetArgumentValues(*thread_sp, args)) return;
 2704     m_arguments->Append(exception);

tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp

  306                      process_sp->GetByteOrder(),
  307                      process_sp->GetAddressByteSize());
  308   size_t actual_size = 8 + process_sp->GetAddressByteSize();
  311       process_sp->ReadMemory(m_header_addr, memory_buffer, actual_size, error);
  348   uint8_t *dst = (uint8_t *)data_sp->GetBytes();
  350   DataExtractor desc_extractor(dst, desc_array_size, process_sp->GetByteOrder(),
  351                                process_sp->GetAddressByteSize());
  352   bytes_read = process_sp->ReadMemory(desc_ptr, dst, desc_array_size, error);
  444       process_sp->GetTarget().RemoveBreakpointByID(m_trampolines_changed_bp_id);
  454     Target &target = process_sp->GetTarget();
  473           m_objc_module_sp->FindFirstSymbolWithNameAndType(trampoline_name,
  483             m_objc_module_sp->FindFirstSymbolWithNameAndType(changed_name,
  496               m_trampolines_changed_bp_id = trampolines_changed_bp_sp->GetID();
  497               trampolines_changed_bp_sp->SetCallback(RefreshTrampolines, this,
  499               trampolines_changed_bp_sp->SetBreakpointKind(
  567         process_sp->ReadPointerFromMemory(m_trampoline_header, error);
  673   Target *target = process_sp ? &process_sp->GetTarget() : nullptr;
  675       m_objc_module_sp->FindFirstSymbolWithNameAndType(get_impl_name,
  678       m_objc_module_sp->FindFirstSymbolWithNameAndType(get_impl_stret_name,
  680   const Symbol *msg_forward = m_objc_module_sp->FindFirstSymbolWithNameAndType(
  683       m_objc_module_sp->FindFirstSymbolWithNameAndType(msg_forward_stret_name,
  706     if (process_sp->CanJIT()) {
  707       process_sp->GetTarget().GetDebugger().GetErrorStream().Printf(
  736         m_objc_module_sp->FindFirstSymbolWithNameAndType(name_const_str,
  805           thread.GetProcess()->GetTarget().GetScratchClangASTContext();
  847   lldb::addr_t curr_pc = thread.GetRegisterContext()->GetPC();
  892       abi = process_sp->GetABI().get();
  898     ClangASTContext *clang_ast_context = target_sp->GetScratchClangASTContext();
 1133         ret_plan_sp->GetDescription(&s, eDescriptionLevelFull);

tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp

   51   m_thread.GetProcess()->AddPreResumeAction(PreResumeInitializeFunctionCaller,
   74     m_func_sp->SetOkayToDiscard(true);
  119     if (!m_func_sp->IsPlanComplete()) {
  122       if (!m_func_sp->PlanSucceeded()) {
  154       SymbolContext sc = m_thread.GetStackFrameAtIndex(0)->GetSymbolContext(
  164         m_run_to_sp->SetPrivate(true);
  185     m_run_to_sp->SetPrivate(true);

tools/lldb/source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.cpp

  124     module_sp->FindTypes(name, exact_match, max_matches, searched_symbol_files,
  131               type_sp->GetForwardCompilerType())) {
  132         if (type_sp->IsCompleteObjCClass()) {
  180         if (pos->second->GetClassName() == name)
  194           if (pos->second->GetClassName() == name)
  218     ClassDescriptorSP objc_super_class_sp(objc_class_sp->GetSuperclass());
  220       return objc_super_class_sp->GetISA();
  229     return objc_class_sp->GetClassName();
  270     if (!objc_class_sp->IsKVO())
  273     ClassDescriptorSP non_kvo_objc_class_sp(objc_class_sp->GetSuperclass());
  274     if (non_kvo_objc_class_sp && non_kvo_objc_class_sp->IsValid())
  296     if (objc_class_sp && objc_class_sp->IsValid()) {
  297       if (!objc_class_sp->IsKVO())
  300       ClassDescriptorSP non_kvo_objc_class_sp(objc_class_sp->GetSuperclass());
  301       if (non_kvo_objc_class_sp && non_kvo_objc_class_sp->IsValid())
  347   for (size_t idx = 0; idx < class_descriptor_sp->GetNumIVars(); idx++) {
  348     const auto &ivar = class_descriptor_sp->GetIVarAtIndex(idx);
  425       complete_objc_class_type_sp->GetFullCompilerType());

tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptExpressionOpts.cpp

  185   EarlyPasses->add(new RenderScriptRuntimeModulePass(process));

tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

  434   return module->FindFirstSymbolWithNameAndType(ConstString(".rs.info"),
  470       module->ResolveSymbolContextForAddress(addr, eSymbolContextFunction, sc);
  803       module->FindFirstSymbolWithNameAndType(m_kernel_name, eSymbolTypeCode);
  807     kernel_sym = module->FindFirstSymbolWithNameAndType(
  839     if (module_desc->m_module != module)
  842     for (const auto &reduction : module_desc->m_reductions) {
  859         const auto symbol = module->FindFirstSymbolWithNameAndType(
  874                     address.GetModule()->GetFileSpec().GetCString());
  909     for (const RSScriptGroupDescriptor::Kernel &k : sg->m_kernels) {
  917           module->FindFirstSymbolWithNameAndType(k.m_name, eSymbolTypeCode);
  973     if (module_sp->GetFileSpec().GetFilename() == rs_lib) {
  978     if (module_sp->GetFileSpec().GetFilename() == rs_driverlib) {
  983     if (module_sp->GetFileSpec().GetFilename() == rs_cpureflib) {
 1176       if (sg->m_name == group_name) {
 1183       group->m_name = group_name;
 1236     group->m_kernels.push_back(kernel);
 1248         if (bp->MatchesName(group_name.AsCString())) {
 1251           bp->ResolveBreakpoint();
 1395       if (uint64_t(args[eRsId]) < rsm->m_globals.size()) {
 1396         auto rsg = rsm->m_globals[uint64_t(args[eRsId])];
 1399                   rsm->m_module->GetFileSpec().GetFilename().AsCString());
 1399                   rsm->m_module->GetFileSpec().GetFilename().AsCString());
 1568     const Symbol *sym = module->FindFirstSymbolWithNameAndType(
 1591     hook->address = addr;
 1592     hook->defn = hook_defn;
 1593     hook->bp_sp = target.CreateBreakpoint(addr, true, false);
 1594     hook->bp_sp->SetCallback(HookCallback, hook.get(), true);
 1594     hook->bp_sp->SetCallback(HookCallback, hook.get(), true);
 1601                 module->GetFileSpec().GetFilename().AsCString(),
 1627   const ModuleSP module = rsmodule_sp->m_module;
 1628   const FileSpec &file = module->GetPlatformFileSpec();
 1655             rsmodule_sp->m_module->GetFileSpec().GetFilename().AsCString());
 1655             rsmodule_sp->m_module->GetFileSpec().GetFilename().AsCString());
 1664         rsmodule_sp->m_resname = res_name;
 1669                 rsmodule_sp->m_module->GetFileSpec().GetFilename().AsCString());
 1669                 rsmodule_sp->m_module->GetFileSpec().GetFilename().AsCString());
 2237     module_sp->m_module->FindGlobalVariables(
 2237     module_sp->m_module->FindGlobalVariables(
 2448   void *file_buf = data_sp->GetBytes();
 2450       data_sp->GetByteSize() < (sizeof(AllocationDetails::FileHeader) +
 2524   size_t size = data_sp->GetByteSize() - file_header->hdr_size;
 2746       if (rs_module->m_module == module_sp) {
 2760       if (module_desc->ParseRSInfo()) {
 2762         module_desc->WarnIfVersionMismatch(GetProcess()
 2792         const Symbol *debug_present = m_libRS->FindFirstSymbolWithNameAndType(
 2966   const Symbol *info_sym = m_module->FindFirstSymbolWithNameAndType(
 2976   const FileSpec fs = m_module->GetFileSpec();
 2986     const llvm::StringRef raw_rs_info((const char *)buffer->GetBytes());
 2989               m_module->GetFileSpec().GetCString(), raw_rs_info.str().c_str());
 3087       strm.Indent(b.second->defn->name);
 3130     strm.Printf("Resource '%s':", module->m_resname.c_str());
 3132     for (const auto &kernel : module->m_kernels) {
 3447   for (const auto &kernel : rsmodule_sp->m_kernels) {
 3554   ValueObjectSP value_sp(frame_sp->GetValueForVariableExpressionPath(
 3607         frame_sp->GetSymbolContext(eSymbolContextFunction);
 3691     breakpoint_sp->SetEnabled(false); // Optimise since conditional breakpoint
 3712   bp->SetCallback(KernelBreakpointHit, baton, true);
 3716   m_conditional_breaks[bp->GetID()] = std::unique_ptr<RSCoordinate>(baton);
 3741   bp->GetDescription(&messages, lldb::eDescriptionLevelInitial, false);
 3771   bp->ResolveBreakpoint();
 3782     bp->GetDescription(&strm, lldb::eDescriptionLevelInitial, false);
 3803   bp->GetDescription(&messages, lldb::eDescriptionLevelInitial, false);
 3813     module->Dump(strm);
 3895   m_module->GetFileSpec().Dump(&strm);
 3896   strm.Indent(m_module->GetNumCompileUnits() ? "Debug info loaded."
 3945   m_module->m_module->FindGlobalVariables(m_name, nullptr, 1U, var_list);
 3948     auto type = var->GetType();
 3957     const Symbol *s = m_module->m_module->FindFirstSymbolWithNameAndType(

tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h

  281       if (ConstString::Compare(sg->m_name, name) == 0)
  399       for (const auto &kernel : module->m_kernels)

tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptScriptGroup.cpp

  120         stream.Printf("%s", g->m_name.AsCString());
  124         for (const auto &k : g->m_kernels) {

tools/lldb/source/Plugins/MemoryHistory/asan/MemoryHistoryASan.cpp

   35   Target &target = process_sp->GetTarget();
  146   process_sp->GetExtendedThreadList().AddThread(new_thread_sp);
  158       process_sp->GetThreadList().GetExpressionExecutionThread();
  162   StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
  177   options.SetTimeout(process_sp->GetUtilityExpressionTimeout());
  185     process_sp->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf(
  185     process_sp->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf(

tools/lldb/source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp

  209         !pos->second->GetArchitecture().IsCompatibleMatch(arch))
  212              pos->second->GetFileOffset() != file_offset)
  215       if (pos->second->GetModificationTime() == time) {
  243     const size_t num_objects = archive_sp->ParseObjects();
  290   ConstString object_name(module_sp->GetObjectName());
  306           module_sp->GetFileSpec().GetPath().c_str(),
  321           *file, module_sp->GetArchitecture(), module_sp->GetModificationTime(),
  321           *file, module_sp->GetArchitecture(), module_sp->GetModificationTime(),
  340         *file, module_sp->GetArchitecture(), module_sp->GetModificationTime(),
  340         *file, module_sp->GetArchitecture(), module_sp->GetModificationTime(),
  386             m_file, module_sp->GetArchitecture(),
  387             module_sp->GetModificationTime(), m_offset, m_data);
  424     if (module_sp->GetObjectName() && m_archive_sp) {
  425       Object *object = m_archive_sp->FindObject(
  426           module_sp->GetObjectName(), module_sp->GetObjectModificationTime());
  426           module_sp->GetObjectName(), module_sp->GetObjectModificationTime());
  431             m_archive_sp->GetData().GetSharedDataBuffer(), data_offset);
  454   data.SetData(data_sp, data_offset, data_sp->GetByteSize());
  468       data.SetData(data_sp, 0, data_sp->GetByteSize());
  475     const size_t num_objects = archive_sp->GetNumObjects();
  477       const Object *object = archive_sp->GetObjectAtIndex(idx);
  507           archive_sp->SetArchitecture(module_spec.GetArchitecture());

tools/lldb/source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.h

   62       return m_archive_sp->GetNumObjects();

tools/lldb/source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.cpp

  170     if (!module_sp->GetArchitecture().IsValid()) {
  175       arch = module_sp->GetArchitecture();
  219   data.SetData(data_sp, data_offset, data_sp->GetByteSize());

tools/lldb/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.cpp

   71   auto text = toStringRef(data_sp->GetData());
   77   if (data_sp->GetByteSize() < length) {
   98   auto text = toStringRef(data_sp->GetData());

tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

  342   if (data_sp->GetByteSize() <= (llvm::ELF::EI_NIDENT + data_offset))
  345   const uint8_t *magic = data_sp->GetBytes() + data_offset;
  350   if (data_sp->GetByteSize() < length) {
  355     magic = data_sp->GetBytes();
  373   if (data_sp && data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT)) {
  374     const uint8_t *magic = data_sp->GetBytes();
  393       data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT + data_offset)) {
  394     const uint8_t *magic = data_sp->GetBytes() + data_offset;
  501   if (ObjectFileELF::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize())) {
  667         if (section_sp->Test(SHF_ALLOC) ||
  668             section_sp->GetType() == eSectionTypeContainer) {
  669           lldb::addr_t load_addr = section_sp->GetFileAddress();
  673           if (section_sp->GetType() != eSectionTypeAbsoluteAddress)
  814   assert(dynsym_section_sp->GetObjectFile() == this);
  816   user_id_t dynsym_id = dynsym_section_sp->GetID();
  836       addr_t dyn_base = dynsym_section_sp->GetLoadBaseAddress(target);
 1740       Range.Slide(-Segment->GetFileAddress());
 1753       Info.Range.Slide(Info.Segment->GetFileAddress());
 1785     Segment->SetPermissions(GetPermissions(PHdr));
 1786     Segment->SetIsThreadSpecific(PHdr.p_type == PT_TLS);
 1833     section_sp->SetPermissions(GetPermissions(header));
 1834     section_sp->SetIsThreadSpecific(header.sh_flags & SHF_TLS);
 1835     (InfoOr->Segment ? InfoOr->Segment->GetChildren() : *m_sections_up)
 1849     if (auto gdd_objfile_section_list = gdd_obj_file->GetSectionList()) {
 1856           unified_section_list.ReplaceSection(module_section_sp->GetID(),
 1875     GetModule()->ReportWarning(
 1882   section->GetSectionData(data);
 1886     GetModule()->ReportWarning(
 1888         section->GetName().AsCString(), llvm::toString(std::move(err)).c_str());
 1898       GetModule(), gdd_data_buf, 0, &fspec, 0, gdd_data_buf->GetByteSize()));
 1901   m_gnu_debug_data_object_file->SetType(ObjectFile::eTypeDebugInfo);
 1903   ArchSpec spec = m_gnu_debug_data_object_file->GetArchitecture();
 1904   if (spec && m_gnu_debug_data_object_file->SetModulesArchitecture(spec))
 1971       module_sp ? module_sp->GetSectionList() : nullptr;
 2058         ConstString sect_name = symbol_section_sp->GetName();
 2194       symbol_value -= symbol_section_sp->GetFileAddress();
 2198       ConstString sect_name = symbol_section_sp->GetName();
 2594               data_buffer_sp->GetBytes() + rel_section->GetFileOffset() +
 2621               data_buffer_sp->GetBytes() + rel_section->GetFileOffset() +
 2691   ObjectFile *module_obj_file = module_sp->GetObjectFile();
 2696     SectionList *section_list = module_sp->GetSectionList();
 2701     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 2763             GetModule()->GetUnwindTable().GetEHFrameInfo()) {
 2890         addr_t offset = file_addr - section_sp->GetFileAddress();
 2933   std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 3328     GetModule()->ReportWarning(
 3339           {reinterpret_cast<char *>(buffer_sp->GetBytes()),
 3340            size_t(buffer_sp->GetByteSize())})) {
 3341     GetModule()->ReportWarning(
 3350   return buffer_sp->GetByteSize();

tools/lldb/source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp

   96     m_data.SetByteOrder(delegate_sp->GetByteOrder());
   97     m_data.SetAddressByteSize(delegate_sp->GetAddressByteSize());
  119     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
  126         delegate_sp->PopulateSymtab(this, *m_symtab_up);
  143       delegate_sp->PopulateSectionList(this, *m_sections_up);
  152     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
  195     return delegate_sp->GetArchitecture();
  217       if (section_sp && section_sp->GetFileSize() > 0 &&
  218           !section_sp->IsThreadSpecific()) {
  220                 section_sp, section_sp->GetFileAddress() + value))
  253     section_data.SetData(data_sp, 0, data_sp->GetByteSize());

tools/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

  791   if (data_sp->GetByteSize() < length) {
  808   if (ObjectFileMachO::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize())) {
  823   if (ObjectFileMachO::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize())) {
  830       if (header_and_load_cmds >= data_sp->GetByteSize()) {
  982   std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 1034       const ArchSpec &module_arch = module_sp->GetArchitecture();
 1049             if (data_sp->GetByteSize() != header_and_lc_size)
 1092         const lldb::SectionType section_type = section_sp->GetType();
 1247     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 1333     GetModule()->ReportWarning(
 1352     GetModule()->ReportWarning(
 1603     segment_sp->SetIsEncrypted(segment_is_encrypted);
 1605     segment_sp->SetPermissions(segment_permissions);
 1609     if (is_dsym && unified_section_sp->GetFileAddress() != load_cmd.vmaddr) {
 1611       if (module_sp->GetObjectFile()->GetBaseAddress().IsValid()) {
 1620         module_sp->GetObjectFile()->GetSymtab();
 1626         unified_section_sp->SetFileAddress(load_cmd.vmaddr);
 1744           segment_sp->SetIsFake(true);
 1745           segment_sp->SetPermissions(segment_permissions);
 1749           segment_sp->SetIsEncrypted(segment_is_encrypted);
 1758           sect_type, sect64.addr - segment_sp->GetFileAddress(), sect64.size,
 1768       section_sp->SetIsEncrypted(segment_is_encrypted || section_is_encrypted);
 1769       section_sp->SetPermissions(segment_permissions);
 1770       segment_sp->GetChildren().AddSection(section_sp);
 1772       if (segment_sp->IsFake()) {
 1784             segment_sp->GetChildren().FindSectionByID(sect_uid));
 1788               segment_sp->GetChildren().FindSectionByID(sect_uid + 1);
 1791           if (curr_section_sp->GetByteSize() == 0) {
 1793               curr_section_sp->SetByteSize(next_section_sp->GetFileAddress() -
 1793               curr_section_sp->SetByteSize(next_section_sp->GetFileAddress() -
 1794                                            curr_section_sp->GetFileAddress());
 1796               curr_section_sp->SetByteSize(load_cmd.vmsize);
 1840     module_sp->SectionFileAddressesChanged();
 1862               section_sp->GetFileAddress());
 1864               section_sp->GetByteSize());
 2083           module_sp->LogMessage(log, "LC_SYMTAB.symoff == 0");
 2089           module_sp->LogMessage(log, "LC_SYMTAB.stroff == 0");
 2095           module_sp->LogMessage(log, "LC_SYMTAB.nsyms == 0");
 2101           module_sp->LogMessage(log, "LC_SYMTAB.strsize == 0");
 2195           linkedit_section_sp->GetLoadBaseAddress(&target);
 2205       const addr_t linkedit_file_offset = linkedit_section_sp->GetFileOffset();
 2278             nlist_data.SetData(nlist_data_sp, 0, nlist_data_sp->GetByteSize());
 2288                   indirect_syms_data_sp->GetByteSize());
 2303                                     strtab_data_sp->GetByteSize());
 2318                                            func_start_data_sp->GetByteSize());
 2347       module_sp->LogMessage(log, "failed to read nlist data");
 2356           module_sp->LogMessage(log, "failed to locate the strtab in memory");
 2361         module_sp->LogMessage(log, "failed to read strtab data");
 2384     eh_frame_section_sp = text_section_sp->GetChildren().FindSectionByName(
 2410     function_start_entry.addr = text_section_sp->GetFileAddress();
 2430       addr_t text_base_addr = text_section_sp->GetFileAddress();
 2461       module_sp->LogMessage(
 2467                                              ? eh_frame_section_sp->GetID()
 2511           text_segment_sp->GetFileAddress();
 3695                           module_sp->GetFileSpec().GetPath().c_str());
 4116             uint32_t section_type = symbol_section->Get() & SECTION_TYPE;
 4161               switch (symbol_section->GetType()) {
 4184                   symbol_section->GetName().AsCString();
 4185               if (symbol_section->IsDescendant(text_section_sp.get())) {
 4186                 if (symbol_section->IsClear(S_ATTR_PURE_INSTRUCTIONS |
 4192               } else if (symbol_section->IsDescendant(data_section_sp.get()) ||
 4193                          symbol_section->IsDescendant(
 4195                          symbol_section->IsDescendant(
 4244               } else if (symbol_section->IsDescendant(objc_section_sp.get())) {
 4301         const addr_t section_file_addr = symbol_section->GetFileAddress();
 4328                 section_file_addr + symbol_section->GetByteSize();
 4525           if (module_sp->ResolveFileAddress(symbol_file_addr, symbol_addr)) {
 4529               const addr_t section_file_addr = symbol_section->GetFileAddress();
 4533                   section_file_addr + symbol_section->GetByteSize();
 4708     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 4994     const ArchSpec &module_arch = module_sp->GetArchitecture();
 5012     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 5023     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 5159     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 5241           start_address = text_segment_sp->GetFileAddress() + entryoffset;
 5282         module_sp->FindSymbolsWithNameAndType(ConstString("start"),
 5312     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 5339     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 5410     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 5464     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 5604     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 5642     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 5850             GetModule()->ReportWarning("minimum OS version load command with "
 5994                 section_sp, section_sp->GetFileAddress() + value))
 6025   Target &target = process_sp->GetTarget();
 6055       Status range_error = process_sp->GetMemoryRegionInfo(0, range_info);
 6103           range_error = process_sp->GetMemoryRegionInfo(
 6123         ThreadList &thread_list = process_sp->GetThreadList();
 6278                 const size_t bytes_read = process_sp->ReadMemoryFromInferior(

tools/lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

  131   if (data_sp->GetByteSize() < length) {
  263             GetModule()->GetSpecificationDescription().c_str(),
  299     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
  339         if (section_sp && !section_sp->IsThreadSpecific()) {
  341                   section_sp, section_sp->GetFileAddress() + value))
  554         process_sp->ReadMemory(m_image_base + offset, data_up->GetBytes(),
  558       data.SetData(buffer_sp, 0, buffer_sp->GetByteSize());
  567     rva = addr.GetSection()->GetFileOffset() + addr.GetOffset();
  630     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
  791     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
  947   std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
  960             module_sp->GetSpecificationDescription().c_str(),
 1039     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());

tools/lldb/source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp

   84   m_interpreter = target_sp->GetDebugger().GetScriptInterpreter();
  108         if (object_sp && object_sp->IsValid())
  192       threads_list->Dump(strm);
  196     const uint32_t num_threads = threads_list->GetSize();
  199           threads_list->GetItemAtIndex(i);
  200       if (auto thread_dict = thread_dict_obj->GetAsDictionary()) {
  275       ThreadSP backing_core_thread_sp(core_thread_sp->GetBackingThread());
  277         thread_sp->SetBackingThread(backing_core_thread_sp);
  279         thread_sp->SetBackingThread(core_thread_sp);
  339       std::string value = reg_context_data->GetValue();
  341       if (data_sp->GetByteSize()) {

tools/lldb/source/Plugins/OperatingSystem/Python/OperatingSystemPython.h

   66     return m_python_object_sp && m_python_object_sp->IsValid();

tools/lldb/source/Plugins/Platform/Android/AdbClient.cpp

  602   m_conn->Write(data_sp->GetBytes(), kSyncPacketLen, status, &error);

tools/lldb/source/Plugins/Platform/Android/PlatformAndroid.cpp

  300   ConstString extension = module_sp->GetFileSpec().GetFileNameExtension();
  306   if (!module_sp->GetPlatformFileSpec())
  314   if (module_sp->GetSectionList()->FindSectionByName(ConstString(".symtab")) !=
  345                  module_sp->GetPlatformFileSpec().GetCString(false),

tools/lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp

  147       return m_remote_platform_sp->GetSupportedArchitectureAtIndex(idx, arch);
  223       addr_class = bp_loc_sp->GetAddress().GetAddressClass();
  225           (bp_loc_sp->GetAddress().GetFileAddress() & 1))
  253       error = m_remote_platform_sp->LaunchProcess(launch_info);
  285         error = process_sp->Attach(attach_info);
  290           m_remote_platform_sp->Attach(attach_info, debugger, target, error);

tools/lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp

  100     default_platform_sp->SetSystemArchitecture(HostInfo::GetArchitecture());
  146       return m_remote_platform_sp->GetSupportedArchitectureAtIndex(idx, arch);
  334     process_sp->HijackProcessEvents(listener_sp);
  351   error = process_sp->Launch(launch_info);
  355       const StateType state = process_sp->WaitForProcessToStop(
  358       LLDB_LOG(log, "pid {0} state {0}", process_sp->GetID(), state);
  365       process_sp->SetSTDIOFileDescriptor(pty_fd);

tools/lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

  260           module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
  278           m_remote_platform_sp->CalculateMD5(module_spec.GetFileSpec(),
  297         module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
  322         module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
  343       error = m_remote_platform_sp->GetSharedModule(
  397                   module_sp->SetPlatformFileSpec(new_file_spec);
  408     module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
  440         bp_is_thumb = bp_loc_sp->GetAddress().GetAddressClass() ==
  475   ObjectFile *obj_file = module_sp->GetObjectFile();
 1170       if (dir_buffer && dir_buffer->GetByteSize() > 0) {
 1171         llvm::StringRef path_ref(dir_buffer->GetChars());
 1232   bp_sp->SetBreakpointKind("thread-creation");
 1545       ObjectFile *object_file = exe_module_sp->GetObjectFile();
 1762             module_sp->SetPlatformFileSpec(path_to_try);

tools/lldb/source/Plugins/Platform/MacOSX/PlatformMacOSX.cpp

  159     ObjectFile *objfile = exe_module_sp->GetObjectFile();
  232       return m_remote_platform_sp->GetFileWithUUID(platform_file, uuid_ptr,
  251     m_remote_platform_sp->GetOSBuildString(remote_os_build);
  309       ObjectFile *objfile = module_sp->GetObjectFile();
  320         if (x86_64_module_sp && x86_64_module_sp->GetObjectFile()) {

tools/lldb/source/Plugins/Platform/MacOSX/PlatformRemoteDarwinDevice.cpp

   86       if (exe_module_sp && exe_module_sp->GetObjectFile())
  101         if (exe_module_sp && exe_module_sp->GetObjectFile())
  636     module_sp->SetPlatformFileSpec(platform_file);

tools/lldb/source/Plugins/Platform/NetBSD/PlatformNetBSD.cpp

  139       return m_remote_platform_sp->GetSupportedArchitectureAtIndex(idx, arch);
  303     process_sp->HijackProcessEvents(listener_sp);
  320   error = process_sp->Launch(launch_info);
  324       const StateType state = process_sp->WaitForProcessToStop(
  327       LLDB_LOG(log, "pid {0} state {0}", process_sp->GetID(), state);
  334       process_sp->SetSTDIOFileDescriptor(pty_fd);

tools/lldb/source/Plugins/Platform/OpenBSD/PlatformOpenBSD.cpp

  138       return m_remote_platform_sp->GetSupportedArchitectureAtIndex(idx, arch);

tools/lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

  159       if (error.Fail() || !exe_module_sp || !exe_module_sp->GetObjectFile()) {
  178           if (exe_module_sp && exe_module_sp->GetObjectFile())
  334                        m_remote_platform_sp->GetHostname(), src_path.c_str(),
  378         const uint64_t n_read = ReadFile(fd_src, offset, buffer_sp->GetBytes(),
  379                                          buffer_sp->GetByteSize(), error);
  385                                                buffer_sp->GetBytes(), n_read,
  439     return m_remote_platform_sp->GetRemoteUnixSignals();
  455       error = m_remote_platform_sp->ConnectRemote(args);
  495       error = m_remote_platform_sp->DisconnectRemote();
  528                   exe_module_sp ? exe_module_sp->GetFileSpec().GetPath().c_str()
  543         process_sp->HijackProcessEvents(listener_sp);
  544         error = process_sp->Attach(attach_info);
  550           m_remote_platform_sp->Attach(attach_info, debugger, target, error);
  575       process_sp = m_remote_platform_sp->DebugProcess(launch_info, debugger,
  601   StackFrameSP frame_sp(thread_sp->GetStackFrameAtIndex(0));
  606   frame_sp->CalculateExecutionContext(exe_ctx);
  765   thread_sp->CalculateExecutionContext(exe_ctx);
 1052     return m_remote_platform_sp->ConnectToWaitingProcesses(debugger, error);

tools/lldb/source/Plugins/Platform/Windows/PlatformWindows.cpp

  212       if (!exe_module_sp || exe_module_sp->GetObjectFile() == nullptr) {
  232           if (exe_module_sp && exe_module_sp->GetObjectFile())
  277           error = m_remote_platform_sp->ConnectRemote(args);
  302       error = m_remote_platform_sp->DisconnectRemote();
  333       return m_remote_platform_sp->DebugProcess(launch_info, debugger, target,
  350       error = process_sp->Launch(launch_info);
  364           m_remote_platform_sp->Attach(attach_info, debugger, target, error);
  389   process_sp->HijackProcessEvents(attach_info.GetHijackListener());
  391     error = process_sp->Attach(attach_info);

tools/lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

  115       if (exe_module_sp && exe_module_sp->GetObjectFile())
  131         if (exe_module_sp && exe_module_sp->GetObjectFile())
  489             error = process_sp->ConnectRemote(nullptr, connect_url.c_str());
  492               error = process_sp->ConnectRemote(nullptr, connect_url.c_str());
  494               error = process_sp->Launch(launch_info);
  575             error = process_sp->ConnectRemote(nullptr, connect_url.c_str());
  579                 process_sp->HijackProcessEvents(listener_sp);
  580               error = process_sp->Attach(attach_info);
  729   if (!object_sp || !object_sp->IsValid())
  732   auto array_sp = object_sp->GetAsArray();
  759         if (object_sp && object_sp->IsValid())
  760           suppress = object_sp->GetBooleanValue();
  764         if (object_sp && object_sp->IsValid())
  765           stop = object_sp->GetBooleanValue();
  769         if (object_sp && object_sp->IsValid())
  770           notify = object_sp->GetBooleanValue();
  774         if (object_sp && object_sp->IsValid())
  775           description = object_sp->GetStringValue();
  777         remote_signals_sp->AddSignal(signo, name.str().c_str(), suppress, stop,

tools/lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_x86_64.cpp

  691   uint8_t *dst = data_sp->GetBytes();
  763   if (data_sp->GetByteSize() != REG_CONTEXT_SIZE) {
  766         REG_CONTEXT_SIZE, data_sp->GetByteSize());
  770   uint8_t *src = data_sp->GetBytes();

tools/lldb/source/Plugins/Process/Linux/ProcessorTrace.cpp

  219       params_dict->AddIntegerItem("cpu_family", cpu_family);
  220       params_dict->AddIntegerItem("cpu_model", model);
  221       params_dict->AddIntegerItem("cpu_stepping", stepping);
  222       params_dict->AddStringItem("cpu_vendor", vendor_id);
  227       intel_custom_params->AddItem(

tools/lldb/source/Plugins/Process/Utility/HistoryThread.cpp

   51         *this, 0, GetProcess()->GetAddressByteSize(), m_pcs[0]);
   75     if (GetProcess()->HasAssignedIndexIDToThread(
   77       return GetProcess()->AssignIndexIDToThread(

tools/lldb/source/Plugins/Process/Utility/HistoryUnwind.cpp

   43         &frame->GetThread()->GetProcess()->GetTarget());
   43         &frame->GetThread()->GetProcess()->GetTarget());
   47           frame->GetThread()->GetProcess()->GetAddressByteSize(), pc);
   47           frame->GetThread()->GetProcess()->GetAddressByteSize(), pc);

tools/lldb/source/Plugins/Process/Utility/InferiorCallPOSIX.cpp

   94             process->GetTarget().GetPlatform()->GetMmapArgumentList(
  111                   call_plan_sp->GetReturnValueObject()->GetValueAsUnsigned(

tools/lldb/source/Plugins/Process/Utility/RegisterContextDarwin_arm.cpp

 1301     uint8_t *dst = data_sp->GetBytes();
 1316   if (data_sp && data_sp->GetByteSize() == REG_CONTEXT_SIZE) {
 1317     const uint8_t *src = data_sp->GetBytes();

tools/lldb/source/Plugins/Process/Utility/RegisterContextDarwin_arm64.cpp

  391       DataExtractor regdata(&gpr.x[reg - gpr_w0], 8, process_sp->GetByteOrder(),
  392                             process_sp->GetAddressByteSize());
  470       DataExtractor regdata(&fpu.v[reg - fpu_s0], 4, process_sp->GetByteOrder(),
  471                             process_sp->GetAddressByteSize());
  511       DataExtractor regdata(&fpu.v[reg - fpu_d0], 8, process_sp->GetByteOrder(),
  512                             process_sp->GetAddressByteSize());
  657     uint8_t *dst = data_sp->GetBytes();
  672   if (data_sp && data_sp->GetByteSize() == REG_CONTEXT_SIZE) {
  673     const uint8_t *src = data_sp->GetBytes();

tools/lldb/source/Plugins/Process/Utility/RegisterContextDarwin_i386.cpp

  834     uint8_t *dst = data_sp->GetBytes();
  849   if (data_sp && data_sp->GetByteSize() == REG_CONTEXT_SIZE) {
  850     const uint8_t *src = data_sp->GetBytes();

tools/lldb/source/Plugins/Process/Utility/RegisterContextDarwin_x86_64.cpp

  898     uint8_t *dst = data_sp->GetBytes();
  913   if (data_sp && data_sp->GetByteSize() == REG_CONTEXT_SIZE) {
  914     const uint8_t *src = data_sp->GetBytes();

tools/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.cpp

   76   if (IsFrameZero() || next_frame->m_frame_type == eTrapHandlerFrame ||
   77       next_frame->m_frame_type == eDebuggerFrame) {
   88   if (unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
  101   if (unwind_plan_sp->PlanValidAtAddress(pc_minus_one)) {
  124   addr_t current_pc = reg_ctx_sp->GetPC();
  207       m_full_unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
  209         m_full_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
  210     row_register_kind = m_full_unwind_plan_sp->GetRegisterKind();
  213       active_row->Dump(active_row_strm, m_full_unwind_plan_sp.get(), &m_thread,
  225   if (!ReadFrameAddress(row_register_kind, active_row->GetCFAValue(), m_cfa)) {
  234           pc_module_sp->GetUnwindTable().GetFuncUnwindersContainingAddress(
  239       call_site_unwind_plan = func_unwinders_sp->GetUnwindPlanAtCallSite(
  253     ReadFrameAddress(row_register_kind, active_row->GetAFAValue(), m_afa);
  260                m_full_unwind_plan_sp->GetSourceName().GetCString());
  275   if (!GetNextFrame().get() || !GetNextFrame()->IsValid()) {
  314   if (GetNextFrame().get() && GetNextFrame()->IsValid() &&
  315       GetNextFrame()->IsTrapHandlerFrame())
  346       if (GetNextFrame().get() && GetNextFrame()->IsValid() &&
  347           GetNextFrame()->IsFrameZero()) {
  375       RegisterKind row_register_kind = m_full_unwind_plan_sp->GetRegisterKind();
  376       UnwindPlan::RowSP row = m_full_unwind_plan_sp->GetRowForFunctionOffset(0);
  378         if (!ReadFrameAddress(row_register_kind, row->GetCFAValue(), m_cfa)) {
  387         ReadFrameAddress(row_register_kind, row->GetAFAValue(), m_afa);
  451   } else if (GetNextFrame()->m_frame_type == eTrapHandlerFrame ||
  452              GetNextFrame()->m_frame_type == eDebuggerFrame) {
  533       m_fast_unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
  535         m_fast_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
  536     row_register_kind = m_fast_unwind_plan_sp->GetRegisterKind();
  540       active_row->Dump(active_row_strm, m_fast_unwind_plan_sp.get(), &m_thread,
  548       active_row = m_full_unwind_plan_sp->GetRowForFunctionOffset(valid_offset);
  549       row_register_kind = m_full_unwind_plan_sp->GetRegisterKind();
  553         active_row->Dump(active_row_strm, m_full_unwind_plan_sp.get(),
  567   if (!ReadFrameAddress(row_register_kind, active_row->GetCFAValue(), m_cfa)) {
  573   ReadFrameAddress(row_register_kind, active_row->GetAFAValue(), m_afa);
  610     RegisterContextLLDB::SharedPtr next_next_frame = next_frame->GetNextFrame();
  612     if (next_next_frame && next_next_frame->GetCFA(next_next_frame_cfa)) {
  640       pc_module_sp->GetObjectFile() == nullptr)
  647       pc_module_sp->GetUnwindTable().GetFuncUnwindersContainingAddress(
  657   unwind_plan_sp = func_unwinders_sp->GetUnwindPlanFastUnwind(
  660     if (unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
  702   if (IsFrameZero() || GetNextFrame()->m_frame_type == eTrapHandlerFrame ||
  703       GetNextFrame()->m_frame_type == eDebuggerFrame) {
  741       pc_module_sp->GetObjectFile() == nullptr) {
  749         pc_module_sp->GetUnwindTable().GetFuncUnwindersContainingAddress(
  761     if (!pc_module_sp || !pc_module_sp->GetObjectFile() ||
  768         pc_module_sp->GetUnwindTable().GetEHFrameInfo();
  778         pc_module_sp->GetUnwindTable().GetArmUnwindInfo();
  789         pc_module_sp->GetUnwindTable().GetObjectFileUnwindInfo();
  809         func_unwinders_sp->GetEHFrameUnwindPlan(process->GetTarget());
  812           func_unwinders_sp->GetObjectFileUnwindPlan(process->GetTarget());
  813     if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(m_current_pc) &&
  814         unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolYes) {
  834         func_unwinders_sp->GetEHFrameUnwindPlan(process->GetTarget());
  837           func_unwinders_sp->GetObjectFileUnwindPlan(process->GetTarget());
  838     if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
  841                           unwind_plan_sp->GetSourceName().GetCString());
  849     unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtNonCallSite(
  851     if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
  852       if (unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolNo) {
  865             func_unwinders_sp->GetUnwindPlanAtCallSite(process->GetTarget(),
  869             call_site_unwind_plan->GetSourceName() !=
  870                 unwind_plan_sp->GetSourceName()) {
  879                           unwind_plan_sp->GetSourceName().GetCString());
  888           func_unwinders_sp->GetUnwindPlanArchitectureDefaultAtFunctionEntry(
  893                             unwind_plan_sp->GetSourceName().GetCString());
  902     unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtCallSite(
  909                         unwind_plan_sp->GetSourceName().GetCString());
  917     unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtNonCallSite(
  921       unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolNo) {
  933         func_unwinders_sp->GetUnwindPlanAtCallSite(process->GetTarget(),
  937         call_site_unwind_plan->GetSourceName() !=
  938             unwind_plan_sp->GetSourceName()) {
  948                         unwind_plan_sp->GetSourceName().GetCString());
  958         arch_default_unwind_plan_sp->GetSourceName().GetCString());
  971   return m_thread.GetRegisterContext()->GetRegisterCount();
  975   return m_thread.GetRegisterContext()->GetRegisterInfoAtIndex(reg);
  979   return m_thread.GetRegisterContext()->GetRegisterSetCount();
  983   return m_thread.GetRegisterContext()->GetRegisterSet(reg_set);
  988   return m_thread.GetRegisterContext()->ConvertRegisterKindToRegisterNumber(
 1008         m_thread.GetRegisterContext()->ReadRegister(other_reg_info, value);
 1019           m_thread.GetRegisterContext()->ReadRegister(other_reg_info, value);
 1021       success = GetNextFrame()->ReadRegister(other_reg_info, value);
 1058         m_thread.GetRegisterContext()->WriteRegister(other_reg_info, value);
 1065           m_thread.GetRegisterContext()->WriteRegister(other_reg_info, value);
 1067       success = GetNextFrame()->WriteRegister(other_reg_info, value);
 1119         platform_sp->GetTrapHandlerSymbolNames());
 1169         m_fast_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
 1170     unwindplan_registerkind = m_fast_unwind_plan_sp->GetRegisterKind();
 1178     if (active_row->GetRegisterInfo(regnum.GetAsKind(unwindplan_registerkind),
 1198           m_full_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
 1199       unwindplan_registerkind = m_full_unwind_plan_sp->GetRegisterKind();
 1207           m_full_unwind_plan_sp->GetReturnAddressRegister() !=
 1211             m_thread, m_full_unwind_plan_sp->GetRegisterKind(),
 1212             m_full_unwind_plan_sp->GetReturnAddressRegister());
 1235           active_row->GetRegisterInfo(regnum.GetAsKind(unwindplan_registerkind),
 1241             m_full_unwind_plan_sp->GetSourceName().GetCString());
 1292           m_full_unwind_plan_sp->GetSourcedFromCompiler() != eLazyBoolYes &&
 1296                      m_full_unwind_plan_sp->GetSourceName().GetCString());
 1301           unwindplan_registerkind = m_full_unwind_plan_sp->GetRegisterKind();
 1303               m_full_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
 1316                 active_row->GetRegisterInfo(
 1322                                  active_row->GetCFAValue(), cfa_value)) {
 1375         unwindplan_name += m_full_unwind_plan_sp->GetSourceName().AsCString();
 1573       m_full_unwind_plan_sp->GetSourceName() ==
 1574           m_fallback_unwind_plan_sp->GetSourceName()) {
 1580   if (m_full_unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolYes)
 1628       m_fallback_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
 1631       active_row->GetCFAValue().GetValueType() !=
 1634     if (!ReadFrameAddress(m_fallback_unwind_plan_sp->GetRegisterKind(),
 1635                             active_row->GetCFAValue(), new_cfa) ||
 1644     ReadFrameAddress(m_fallback_unwind_plan_sp->GetRegisterKind(),
 1645                      active_row->GetAFAValue(), m_afa);
 1683                  m_fallback_unwind_plan_sp->GetSourceName().GetCString(),
 1684                  original_full_unwind_plan_sp->GetSourceName().GetCString());
 1703       m_full_unwind_plan_sp->GetSourceName() ==
 1704           m_fallback_unwind_plan_sp->GetSourceName()) {
 1709       m_fallback_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
 1712       active_row->GetCFAValue().GetValueType() !=
 1715     if (!ReadFrameAddress(m_fallback_unwind_plan_sp->GetRegisterKind(),
 1716                             active_row->GetCFAValue(), new_cfa) ||
 1723     ReadFrameAddress(m_fallback_unwind_plan_sp->GetRegisterKind(),
 1724                      active_row->GetAFAValue(), m_afa);
 1736                  m_full_unwind_plan_sp->GetSourceName().GetCString());
 1744   if (unwind_plan->GetUnwindPlanForSignalTrap() != eLazyBoolYes) {
 1918     if (!next->m_sym_ctx.module_sp || !next->m_sym_ctx.symbol)
 1918     if (!next->m_sym_ctx.module_sp || !next->m_sym_ctx.symbol)
 1921             next->m_sym_ctx.module_sp->GetSymbolFile()->GetParameterStackSize(
 1921             next->m_sym_ctx.module_sp->GetSymbolFile()->GetParameterStackSize(
 1922                 *next->m_sym_ctx.symbol))
 1957   } else if (!m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds(
 1967     if (m_thread.GetRegisterContext()->ReadRegister(reg_info, reg_value)) {
 1979   } else if (m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds(
 2019     return m_thread.GetRegisterContext()->ReadRegister(reg_info, value);
 2050     return m_thread.GetRegisterContext()->WriteRegister(reg_info, value);
 2111                 ABI *abi = process_sp->GetABI().get();
 2129   if (GetNextFrame().get() && GetNextFrame()->IsValid() &&
 2130       GetNextFrame()->IsTrapHandlerFrame())
 2144         ABI *abi = process_sp->GetABI().get();

tools/lldb/source/Plugins/Process/Utility/RegisterContextMacOSXFrameBackchain.cpp

   37   return m_thread.GetRegisterContext()->GetRegisterCount();
   42   return m_thread.GetRegisterContext()->GetRegisterInfoAtIndex(reg);
   46   return m_thread.GetRegisterContext()->GetRegisterSetCount();
   51   return m_thread.GetRegisterContext()->GetRegisterSet(reg_set);
  152   return m_thread.GetRegisterContext()->WriteAllRegisterValues(data_sp);
  158   return m_thread.GetRegisterContext()->ConvertRegisterKindToRegisterNumber(

tools/lldb/source/Plugins/Process/Utility/RegisterContextMemory.cpp

  108       if (process_sp->ReadMemory(m_reg_data_addr, data_sp->GetBytes(),
  108       if (process_sp->ReadMemory(m_reg_data_addr, data_sp->GetBytes(),
  109                                  data_sp->GetByteSize(),
  110                                  error) == data_sp->GetByteSize()) {
  126       if (process_sp->WriteMemory(m_reg_data_addr, data_sp->GetBytes(),
  126       if (process_sp->WriteMemory(m_reg_data_addr, data_sp->GetBytes(),
  127                                   data_sp->GetByteSize(),
  128                                   error) == data_sp->GetByteSize())

tools/lldb/source/Plugins/Process/Utility/RegisterContextThreadMemory.cpp

   30     ProcessSP process_sp(thread_sp->GetProcess());
   33       const uint32_t stop_id = process_sp->GetModID().GetStopID();
   39         ThreadSP backing_thread_sp(thread_sp->GetBackingThread());
   41           m_reg_ctx_sp = backing_thread_sp->GetRegisterContext();
   43           OperatingSystem *os = process_sp->GetOperatingSystem();
   61     m_reg_ctx_sp->InvalidateAllRegisters();
   67     return m_reg_ctx_sp->GetRegisterCount();
   75     return m_reg_ctx_sp->GetRegisterInfoAtIndex(reg);
   82     return m_reg_ctx_sp->GetRegisterSetCount();
   89     return m_reg_ctx_sp->GetRegisterSet(reg_set);
   97     return m_reg_ctx_sp->ReadRegister(reg_info, reg_value);
  105     return m_reg_ctx_sp->WriteRegister(reg_info, reg_value);
  113     return m_reg_ctx_sp->ReadAllRegisterValues(data_sp);
  121     return m_reg_ctx_sp->WriteAllRegisterValues(data_sp);
  129     return m_reg_ctx_sp->CopyFromRegisterContext(reg_ctx_sp);
  137     return m_reg_ctx_sp->ConvertRegisterKindToRegisterNumber(kind, num);
  144     return m_reg_ctx_sp->NumSupportedHardwareBreakpoints();
  152     return m_reg_ctx_sp->SetHardwareBreakpoint(addr, size);
  159     return m_reg_ctx_sp->ClearHardwareBreakpoint(hw_idx);
  166     return m_reg_ctx_sp->NumSupportedHardwareWatchpoints();
  176     return m_reg_ctx_sp->SetHardwareWatchpoint(addr, size, read, write);
  183     return m_reg_ctx_sp->ClearHardwareWatchpoint(hw_index);
  190     return m_reg_ctx_sp->HardwareSingleStep(enable);
  199     return m_reg_ctx_sp->ReadRegisterValueFromMemory(reg_info, src_addr,
  211     return m_reg_ctx_sp->WriteRegisterValueToMemory(reg_info, dst_addr, dst_len,

tools/lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp

  325           DynamicLoader *dynamic_loader = process_sp->GetDynamicLoader();
  360           if (wp_sp && wp_sp->IsEnabled()) {
  365               wp_sp->SetHardwareIndex((uint32_t)exc_sub_sub_code);
  367                                                               wp_sp->GetID());
  393         if (wp_sp && wp_sp->IsEnabled()) {
  398             wp_sp->SetHardwareIndex((uint32_t)exc_sub_sub_code);
  400                                                             wp_sp->GetID());
  436         if (wp_sp && wp_sp->IsEnabled()) {
  441             wp_sp->SetHardwareIndex((uint32_t)exc_sub_sub_code);
  443                                                             wp_sp->GetID());
  462       addr_t pc = reg_ctx_sp->GetPC() - pc_decrement;
  468         bp_site_sp = process_sp->GetBreakpointSiteList().FindByAddress(pc);
  469       if (bp_site_sp && bp_site_sp->IsEnabled()) {
  474           reg_ctx_sp->SetPC(pc);
  485         if (bp_site_sp->ValidForThisThread(&thread) ||
  486             thread.GetProcess()->GetOperatingSystem() != nullptr)
  488               thread, bp_site_sp->GetID());

tools/lldb/source/Plugins/Process/Utility/ThreadMemory.cpp

   39     m_backing_thread_sp->WillResume(resume_state);
   44     m_backing_thread_sp->ClearStackFrames();
   76         m_backing_thread_sp->GetPrivateStopInfo());
   78         backing_stop_info_sp->IsValidForOperatingSystemThread(*this)) {
   79       backing_stop_info_sp->SetThread(shared_from_this());
   87       OperatingSystem *os = process_sp->GetOperatingSystem();
   99     return m_backing_thread_sp->RefreshStateAfterStop();
  102     m_reg_context_sp->InvalidateAllRegisters();

tools/lldb/source/Plugins/Process/Utility/ThreadMemory.h

   36       m_backing_thread_sp->GetInfo();
   44       m_backing_thread_sp->GetName();
   52       m_backing_thread_sp->GetQueueName();
   60       m_backing_thread_sp->DidResume();
   65       return m_backing_thread_sp->GetProtocolID();

tools/lldb/source/Plugins/Process/Utility/UnwindLLDB.cpp

   32     process_sp->GetTarget().GetUserSpecifiedTrapHandlerNames(args);
   53     ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;
   76   ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;
   81       m_thread, RegisterContextLLDBSP(), first_cursor_sp->sctx, 0, *this));
   85   if (!reg_ctx_sp->IsValid())
   88   if (!reg_ctx_sp->GetCFA(first_cursor_sp->cfa))
   88   if (!reg_ctx_sp->GetCFA(first_cursor_sp->cfa))
   91   if (!reg_ctx_sp->ReadPC(first_cursor_sp->start_pc))
   91   if (!reg_ctx_sp->ReadPC(first_cursor_sp->start_pc))
   96   first_cursor_sp->reg_ctx_lldb_sp = reg_ctx_sp;
  130       m_thread, prev_frame->reg_ctx_lldb_sp, cursor_sp->sctx, cur_idx, *this));
  130       m_thread, prev_frame->reg_ctx_lldb_sp, cursor_sp->sctx, cur_idx, *this));
  154     if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
  154     if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
  158       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
  158       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
  158       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
  169   if (!reg_ctx_sp->IsValid()) {
  173     if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
  173     if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
  177       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
  177       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
  177       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
  189   if (!reg_ctx_sp->GetCFA(cursor_sp->cfa)) {
  189   if (!reg_ctx_sp->GetCFA(cursor_sp->cfa)) {
  193     if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
  193     if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
  197       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
  197       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
  197       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
  208   if (abi && !abi->CallFrameAddressIsValid(cursor_sp->cfa)) {
  212     if (!reg_ctx_sp->IsTrapHandlerFrame()) {
  218       if (!reg_ctx_sp->TryFallbackUnwindPlan() ||
  219           !reg_ctx_sp->GetCFA(cursor_sp->cfa) ||
  219           !reg_ctx_sp->GetCFA(cursor_sp->cfa) ||
  220           !abi->CallFrameAddressIsValid(cursor_sp->cfa)) {
  221         if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
  221         if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
  225           if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
  225           if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
  225           if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
  245   if (!reg_ctx_sp->ReadPC(cursor_sp->start_pc)) {
  245   if (!reg_ctx_sp->ReadPC(cursor_sp->start_pc)) {
  249     if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
  249     if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
  253       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
  253       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
  253       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
  264   if (abi && !abi->CodeAddressIsValid(cursor_sp->start_pc)) {
  268     if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
  268     if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
  272       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
  272       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
  272       if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
  283   if (prev_frame->start_pc == cursor_sp->start_pc &&
  283   if (prev_frame->start_pc == cursor_sp->start_pc &&
  284       prev_frame->cfa == cursor_sp->cfa) {
  284       prev_frame->cfa == cursor_sp->cfa) {
  292   cursor_sp->reg_ctx_lldb_sp = reg_ctx_sp;
  353            ->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
  353            ->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
  382     return m_frames[m_frames.size() - 2]->reg_ctx_lldb_sp->GetCFA(
  382     return m_frames[m_frames.size() - 2]->reg_ctx_lldb_sp->GetCFA(
  383         m_frames[m_frames.size() - 2]->cfa);
  401   ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;
  407     cfa = m_frames[idx]->cfa;
  408     pc = m_frames[idx]->start_pc;
  412     } else if (m_frames[idx - 1]->reg_ctx_lldb_sp->IsTrapHandlerFrame()) {
  412     } else if (m_frames[idx - 1]->reg_ctx_lldb_sp->IsTrapHandlerFrame()) {
  417     } else if (m_frames[idx]->reg_ctx_lldb_sp->IsTrapHandlerFrame()) {
  417     } else if (m_frames[idx]->reg_ctx_lldb_sp->IsTrapHandlerFrame()) {
  447   ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;
  466     reg_ctx_sp = m_frames[frame_num]->reg_ctx_lldb_sp;
  482     result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister(
  482     result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister(
  488     result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister(
  488     result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister(

tools/lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp

   63     if (data_sp && data_sp->GetByteSize() == header_size &&
   64         elf::ELFHeader::MagicBytesMatch(data_sp->GetBytes())) {
   82     ModuleSpec core_module_spec(m_core_file, target_sp->GetArchitecture());
   86       ObjectFile *core_objfile = m_core_module_sp->GetObjectFile();
  156   ObjectFileELF *core = (ObjectFileELF *)(m_core_module_sp->GetObjectFile());
  201   ArchSpec arch(m_core_module_sp->GetArchitecture());
  204   ArchSpec core_arch(m_core_module_sp->GetArchitecture());
  229           GetUnixSignals()->GetSignalNumberFromName("SIGSTOP");
  333   ObjectFile *core_objfile = m_core_module_sp->GetObjectFile();
  403   ObjectFile *obj_file = GetTarget().GetExecutableModule()->GetObjectFile();
  887   ArchSpec arch = m_core_module_sp->GetObjectFile()->GetArchitecture();
  916     info.SetExecutableFile(GetTarget().GetExecutableModule()->GetFileSpec(),

tools/lldb/source/Plugins/Process/elf-core/ThreadElfCore.cpp

   54   GetRegisterContext()->InvalidateIfNeeded(false);

tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

 2540   StructuredData::Array *array = data->GetAsArray();
 2552       port = port_osp->GetIntegerValue(0);
 2557       socket_name = socket_name_osp->GetStringValue();
 3215   response.GetHexBytes(buffer_sp->GetData(), '\xcc');
 3230   response.GetHexBytes(buffer_sp->GetData(), '\xcc');
 3452           json_object->GetType() != lldb::eStructuredDataTypeDictionary) {
 3457       auto json_dict = json_object->GetAsDictionary();
 3472         if (custom_params_sp->GetType() !=
 3671   StructuredData::Array *response_array = response_object_sp->GetAsArray();
 3678             response_array->GetItemAtIndex(i)->GetAsDictionary()))
 3938           !m_supported_async_json_packets_sp->GetAsArray()) {
 3957       m_supported_async_json_packets_sp->Dump(stream);
 3966              ? m_supported_async_json_packets_sp->GetAsArray()
 4007     config_sp->Dump(unescaped_stream);

tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationReplayServer.cpp

   85   m_async_listener_sp->StartListeningForEvents(&m_async_broadcaster,
  260     if (server->m_async_listener_sp->GetEvent(event_sp, llvm::None)) {
  261       const uint32_t event_type = event_sp->GetType();
  262       if (event_sp->BroadcasterIs(&server->m_async_broadcaster)) {

tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

 1136   StructuredData::Array *packet_array = object_sp->GetAsArray();
 1143         packet_array->GetItemAtIndex(i)->GetAsDictionary();

tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

 1051       json_object->GetType() != lldb::eStructuredDataTypeDictionary)
 1054   auto json_dict = json_object->GetAsDictionary();
 1071       custom_params_sp->GetType() != lldb::eStructuredDataTypeDictionary)
 1113       json_object->GetType() != lldb::eStructuredDataTypeDictionary)
 1116   auto json_dict = json_object->GetAsDictionary();
 1150       json_object->GetType() != lldb::eStructuredDataTypeDictionary)
 1154   auto json_dict = json_object->GetAsDictionary();
 1218       json_object->GetType() != lldb::eStructuredDataTypeDictionary)
 1221   auto json_dict = json_object->GetAsDictionary();

tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp

  394   for (auto signo = signals->GetFirstSignalNumber();
  396        signo = signals->GetNextSignalNumber(signo)) {
  399     dictionary->AddIntegerItem("signo", signo);
  400     dictionary->AddStringItem("name", signals->GetSignalAsCString(signo));
  400     dictionary->AddStringItem("name", signals->GetSignalAsCString(signo));
  403     signals->GetSignalInfo(signo, suppress, stop, notify);
  404     dictionary->AddBooleanItem("suppress", suppress);
  405     dictionary->AddBooleanItem("stop", stop);
  406     dictionary->AddBooleanItem("notify", notify);

tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp

   46   m_reg_data.SetByteOrder(thread.GetProcess()->GetByteOrder());
   71     const ArchSpec &arch = m_thread.GetProcess()->GetTarget().GetArchitecture();
  175         lldb_reg, llvm::ArrayRef<uint8_t>(buffer_sp->GetBytes(),
  176                                           buffer_sp->GetByteSize()));
  201                buffer_sp->GetBytes(),
  202                std::min(buffer_sp->GetByteSize(), m_reg_data.GetByteSize()));
  203         if (buffer_sp->GetByteSize() >= m_reg_data.GetByteSize()) {
  216               m_reg_data.GetByteSize(), buffer_sp->GetByteSize());
  519   if (!data_sp || data_sp->GetBytes() == nullptr || data_sp->GetByteSize() == 0)
  519   if (!data_sp || data_sp->GetBytes() == nullptr || data_sp->GetByteSize() == 0)
  541               {data_sp->GetBytes(), size_t(data_sp->GetByteSize())}))
  541               {data_sp->GetBytes(), size_t(data_sp->GetByteSize())}))
  639             m_thread.GetProcess()->GetTarget().GetArchitecture();
  666                                    {data_sp->GetBytes() + reg_info->byte_offset,

tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

  130     m_collection_sp->Initialize(g_processgdbremote_properties);
  137     return m_collection_sp->GetPropertyAtIndexAsUInt64(
  143     return m_collection_sp->SetPropertyAtIndexAsUInt64(nullptr, idx, timeout);
  148     return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx);
  153     return m_collection_sp->GetPropertyAtIndexAsBoolean(
  226   Module *exe_module = target_sp->GetExecutableModulePointer();
  290   if (m_async_listener_sp->StartListeningForEvents(
  301   if (m_async_listener_sp->StartListeningForEvents(
  309       GetGlobalPluginProperties()->GetPacketTimeout();
  351           target_definition_sp->GetValueForKey("host-info"));
  353         if (auto host_info_dict = target_object->GetAsDictionary()) {
  356           if (auto triple_string_value = triple_value->GetAsString()) {
  367           target_definition_sp->GetValueForKey("breakpoint-pc-offset");
  370                 breakpoint_pc_offset_value->GetAsInteger())
  392       if (abi_sp->GetRegisterInfoByName(reg_name, abi_reg_info)) {
  442     GetGlobalPluginProperties()->SetPacketTimeout(host_packet_timeout.count());
  452       GetGlobalPluginProperties()->GetTargetDefinitionFile();
  464       stream_sp->Printf("ERROR: target description file %s failed to parse.\n",
  751     if (platform_sp && platform_sp->IsConnected())
  752       SetUnixSignals(platform_sp->GetUnixSignals());
  846       } else if (platform_sp && platform_sp->IsHost()) {
 1295   if (listener_sp->StartListeningForEvents(
 1297     listener_sp->StartListeningForEvents(
 1488       if (!listener_sp->GetEvent(event_sp, std::chrono::seconds(5))) {
 1491       } else if (event_sp->BroadcasterIs(&m_async_broadcaster)) {
 1571     StructuredData::Array *thread_infos = m_jthreadsinfo_sp->GetAsArray();
 1663                   thread_sp.get(), thread_sp->GetID());
 1666                   thread_sp.get(), thread_sp->GetID());
 1680       lldb::tid_t old_thread_id = old_thread_sp->GetProtocolID();
 1693     RegisterContextSP reg_ctx_sp(thread_sp->GetRegisterContext());
 1695       uint32_t pc_regnum = reg_ctx_sp->ConvertRegisterKindToRegisterNumber(
 1709     StructuredData::Array *thread_infos = thread_infos_sp->GetAsArray();
 1715             thread_infos->GetItemAtIndex(i)->GetAsDictionary();
 1741     thread->GetRegisterContext()->InvalidateIfNeeded(true);
 1785       gdb_thread->GetRegisterContext()->InvalidateIfNeeded(true);
 1796         reg_value_extractor.GetHexBytes(buffer_sp->GetData(), '\xcc');
 1797         gdb_thread->PrivateSetRegisterValue(pair.first, buffer_sp->GetData());
 1800       thread_sp->SetName(thread_name.empty() ? nullptr : thread_name.c_str());
 1819       if (!thread_sp->StopInfoIsUpToDate()) {
 1820         thread_sp->SetStopInfo(StopInfoSP());
 1830           thread_sp->SetStopInfo(
 1841               addr_t pc = thread_sp->GetRegisterContext()->GetPC();
 1841               addr_t pc = thread_sp->GetRegisterContext()->GetPC();
 1842               lldb::BreakpointSiteSP bp_site_sp = thread_sp->GetProcess()
 1843                                                       ->GetBreakpointSiteList()
 1850                   bp_site_sp->ValidForThisThread(thread_sp.get())) {
 1851                 thread_sp->SetStopInfo(
 1853                         *thread_sp, bp_site_sp->GetID()));
 1855                 thread_sp->SetStopInfo(
 1859               addr_t pc = thread_sp->GetRegisterContext()->GetPC();
 1859               addr_t pc = thread_sp->GetRegisterContext()->GetPC();
 1860               lldb::BreakpointSiteSP bp_site_sp = thread_sp->GetProcess()
 1861                                                       ->GetBreakpointSiteList()
 1870                 if (bp_site_sp->ValidForThisThread(thread_sp.get())) {
 1871                   thread_sp->SetStopInfo(
 1873                           *thread_sp, bp_site_sp->GetID()));
 1876                   thread_sp->SetStopInfo(invalid_stop_info_sp);
 1900                   wp_sp->SetHardwareIndex(wp_index);
 1901                   watch_id = wp_sp->GetID();
 1909               thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithWatchpointID(
 1913               thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithException(
 1918               thread_sp->SetStopInfo(
 1923             addr_t pc = thread_sp->GetRegisterContext()->GetPC();
 1923             addr_t pc = thread_sp->GetRegisterContext()->GetPC();
 1925                 thread_sp->GetProcess()->GetBreakpointSiteList().FindByAddress(
 1925                 thread_sp->GetProcess()->GetBreakpointSiteList().FindByAddress(
 1933             if (bp_site_sp && bp_site_sp->ValidForThisThread(thread_sp.get())) {
 1934               thread_sp->SetStopInfo(
 1936                       *thread_sp, bp_site_sp->GetID()));
 1946               addr_t pc = thread_sp->GetRegisterContext()->GetPC() +
 1946               addr_t pc = thread_sp->GetRegisterContext()->GetPC() +
 1948               lldb::BreakpointSiteSP bp_site_sp = thread_sp->GetProcess()
 1949                                                       ->GetBreakpointSiteList()
 1958                 if (bp_site_sp->ValidForThisThread(thread_sp.get())) {
 1960                     thread_sp->GetRegisterContext()->SetPC(pc);
 1960                     thread_sp->GetRegisterContext()->SetPC(pc);
 1961                   thread_sp->SetStopInfo(
 1963                           *thread_sp, bp_site_sp->GetID()));
 1966                   thread_sp->SetStopInfo(invalid_stop_info_sp);
 1973                 if (thread_sp->GetTemporaryResumeState() == eStateStepping)
 1974                   thread_sp->SetStopInfo(
 1977                   thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithSignal(
 1982               thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithSignal(
 1987             lldb::StopInfoSP stop_info_sp(thread_sp->GetStopInfo());
 1989               const char *stop_info_desc = stop_info_sp->GetDescription();
 1991                 stop_info_sp->SetDescription(description.c_str());
 1993               thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithException(
 2135                       bytes.GetHexBytes(data_buffer_sp->GetData(), 0);
 2304                 bytes.GetHexBytes(data_buffer_sp->GetData(), 0);
 2320           wp_index = wp_sp->GetHardwareIndex();
 2489     if (platform_sp && platform_sp->GetName() &&
 2490         platform_sp->GetName() == PlatformRemoteiOS::GetPluginNameStatic()) {
 2511             StopInfoSP stop_info_sp = thread_sp->GetPrivateStopInfo();
 2514               reason = stop_info_sp->GetStopReason();
 2520                         thread_sp->GetProtocolID(),
 2521                         stop_info_sp->GetDescription());
 2547               StopInfoSP stop_info_sp = thread_sp->GetPrivateStopInfo();
 2550                 reason = stop_info_sp->GetStopReason();
 2556                           thread_sp->GetProtocolID());
 2557                 thread_sp->SetResumeState(eStateSuspended);
 2707     StructuredData::Array *thread_infos = m_jthreadsinfo_sp->GetAsArray();
 2712             thread_infos->GetItemAtIndex(i)->GetAsDictionary();
 3422   if (platform_sp && !platform_sp->IsHost())
 3550   if (!process_sp || process_sp->m_debugserver_pid != debugserver_pid)
 3560   const StateType state = process_sp->GetState();
 3567           process_sp->GetUnixSignals()->GetSignalAsCString(signo);
 3567           process_sp->GetUnixSignals()->GetSignalAsCString(signo);
 3580     process_sp->SetExitStatus(-1, error_str);
 3584   process_sp->m_debugserver_pid = LLDB_INVALID_PROCESS_ID;
 3611         debugger, GetGlobalPluginProperties()->GetValueProperties(),
 3708     if (process->m_async_listener_sp->GetEvent(event_sp, llvm::None)) {
 3709       const uint32_t event_type = event_sp->GetType();
 3710       if (event_sp->BroadcasterIs(&process->m_async_broadcaster)) {
 3834       } else if (event_sp->BroadcasterIs(&process->m_gdb_comm)) {
 3923   uint64_t new_signals_version = m_unix_signals_sp->GetVersion();
 3931       m_unix_signals_sp->GetFilteredSignals(false, false, false);
 3951     m_thread_create_bp_sp->SetEnabled(true);
 3956           platform_sp->SetThreadCreationBreakpoint(GetTarget());
 3961               m_thread_create_bp_sp->GetID());
 3962         m_thread_create_bp_sp->SetCallback(
 3978     m_thread_create_bp_sp->SetEnabled(false);
 4029     args_dict->GetAsDictionary()->AddIntegerItem("thread", tid);
 4033     args_dict->Dump(packet, false);
 4063   args_dict->GetAsDictionary()->AddIntegerItem("image_list_address",
 4065   args_dict->GetAsDictionary()->AddIntegerItem("image_count", image_count);
 4073   args_dict->GetAsDictionary()->AddBooleanItem("fetch_all_solibs", true);
 4085     addresses->AddItem(addr_sp);
 4088   args_dict->GetAsDictionary()->AddItem("solib_addresses", addresses);
 4105     args_dict->Dump(packet, false);
 4138     args_dict->Dump(packet, false);
 4643   bool can_use_svr4 = GetGlobalPluginProperties()->GetUseSVR4();
 4877       lldb_private::ObjectFile *obj = module_sp->GetObjectFile();
 5092       json_sp->Dump(json_str, true);

tools/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp

   51            process_sp ? process_sp->GetID() : LLDB_INVALID_PROCESS_ID, GetID());
  100       SystemRuntime *runtime = process_sp->GetSystemRuntime();
  130       SystemRuntime *runtime = process_sp->GetSystemRuntime();
  154       SystemRuntime *runtime = process_sp->GetSystemRuntime();
  169       queue = process_sp->GetQueueList().FindQueueByID(queue_id);
  181         SystemRuntime *runtime = process_sp->GetSystemRuntime();
  246       if (gdb_process->GetUnixSignals()->SignalIsValid(signo))
  253       if (gdb_process->GetUnixSignals()->SignalIsValid(signo))
  275   GetRegisterContext()->InvalidateIfNeeded(force);

tools/lldb/source/Plugins/Process/mach-core/ProcessMachCore.cpp

   69     if (data_sp && data_sp->GetByteSize() == header_size) {
  100       ObjectFile *core_objfile = m_core_module_sp->GetObjectFile();
  199   ObjectFile *core_objfile = m_core_module_sp->GetObjectFile();
  228                      m_core_module_sp->GetArchitecture().GetByteOrder(),
  229                      m_core_module_sp->GetArchitecture().GetAddressByteSize());
  369           if (module_sp.get() && module_sp->GetObjectFile()) {
  414       GetTarget().SetArchitecture(m_core_module_sp->GetArchitecture());
  493   ArchSpec arch(m_core_module_sp->GetArchitecture());
  516     ObjectFile *core_objfile = m_core_module_sp->GetObjectFile();
  558   ObjectFile *core_objfile = m_core_module_sp->GetObjectFile();
  675   return m_core_module_sp->GetObjectFile();

tools/lldb/source/Plugins/Process/mach-core/ThreadMachCore.cpp

   55   GetRegisterContext()->InvalidateIfNeeded(force);

tools/lldb/source/Plugins/Process/minidump/MinidumpParser.cpp

   30       llvm::MemoryBufferRef(toStringRef(data_sp->GetData()), "minidump"));
   42   return llvm::ArrayRef<uint8_t>(m_data_sp->GetBytes(),
   43                                  m_data_sp->GetByteSize());

tools/lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp

   91     section_sp->SetPermissions(ePermissionsReadable | ePermissionsExecutable);
  102     GetModule()->GetSectionList();
  147   lldbassert(DataPtr->GetByteSize() == header_size);
  148   if (identify_magic(toStringRef(DataPtr->GetData())) != llvm::file_magic::minidump)
  298   stop_thread->SetStopInfo(stop_info);
  451         const auto mod_bytes = module_sp->GetUUID().GetBytes();
  465       auto *objfile = module_sp->GetObjectFile();
  492     module_sp->SetLoadAddress(GetTarget(), load_addr, false,
  504     info.SetExecutableFile(GetTarget().GetExecutableModule()->GetFileSpec(),

tools/lldb/source/Plugins/Process/minidump/RegisterContextMinidump_x86_32.cpp

   32   uint8_t *result_base = result_context_buf->GetBytes();

tools/lldb/source/Plugins/Process/minidump/RegisterContextMinidump_x86_64.cpp

   55   uint8_t *result_base = result_context_buf->GetBytes();

tools/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp

  272   result->SetValue(std::string(c, size));
  310   result->SetValue(std::string(str, bytes.size()));
  419   result->SetValue(GetString());
  493   result->SetValue(GetInteger());
  517   result->SetValue(GetValue());
  572     result->AddItem(obj.CreateStructuredObject());
  643     result->AddItem(obj.CreateStructuredObject());
  746     result->AddItem(key.Str().GetString(), structured_value);
 1405   if (!file_sp->IsValid())

tools/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

  530       output_sp->PutCString(instructions);
  531       output_sp->Flush();
  568           error_sp->Printf("Warning: No command attached to breakpoint.\n");
  569           error_sp->Flush();
  590         error_sp->Printf("Warning: No command attached to breakpoint.\n");
  591         error_sp->Flush();
  738         SetStdHandle(top_out_sp->GetFileSP(), "stdout", m_saved_stdout, "w");
  743         SetStdHandle(top_err_sp->GetFileSP(), "stderr", m_saved_stderr, "w");
  959           output_file_sp->GetFileSP(), error_file_sp->GetFileSP());
  959           output_file_sp->GetFileSP(), error_file_sp->GetFileSP());
  986       output_file_sp->Flush();
  987       error_file_sp->Flush();
  994       output_file_sp->GetFile().Close();
 1529   StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
 1557         result->Append(valobj_sp);
 1594   StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
 1649   StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
 1737   StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
 1795   StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
 1851   Debugger &debugger = thread_plan_sp->GetTarget().GetDebugger();
 1879     generic = implementor_sp->GetAsGeneric();
 1896     generic = implementor_sp->GetAsGeneric();
 1913     generic = implementor_sp->GetAsGeneric();
 1930     generic = implementor_sp->GetAsGeneric();
 1956   Debugger &debugger = bkpt_sp->GetTarget().GetDebugger();
 1986         implementor_sp->GetValue(), "__callback__", sym_ctx);
 2003         implementor_sp->GetValue(), "__get_depth__", nullptr);
 2040   StructuredData::Generic *generic = plugin_module_sp->GetAsGeneric();
 2202     generic = callee_wrapper_sp->GetAsGeneric();
 2262           breakpoint_sp->FindLocationByID(break_loc_id));
 2336   StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
 2359   StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
 2391   StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
 2416   StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
 2439   StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
 2463   StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
 2503   StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
 2872       m_old_asynch(debugger_sp->GetAsyncExecution()) {
 2874     m_debugger_sp->SetAsyncExecution(false);
 2876     m_debugger_sp->SetAsyncExecution(true);
 2881     m_debugger_sp->SetAsyncExecution(m_old_asynch);
 2933   if (!impl_obj_sp || !impl_obj_sp->IsValid()) {
 2959     ret_val = LLDBSwigPythonCallCommandObject(impl_obj_sp->GetValue(),
 3015                            (PyObject *)cmd_obj_sp->GetValue());
 3070                            (PyObject *)cmd_obj_sp->GetValue());
 3125                            (PyObject *)cmd_obj_sp->GetValue());

tools/lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

  124     m_collection_sp->Initialize(g_darwinlog_properties);
  131     return m_collection_sp->GetPropertyAtIndexAsBoolean(
  137     return m_collection_sp->GetPropertyAtIndexAsString(
  573     config_sp->AddBooleanItem("enabled", enabled);
  582     config_sp->AddItem("source-flags", source_flags_sp);
  584     source_flags_sp->AddBooleanItem("any-process", m_include_any_process);
  585     source_flags_sp->AddBooleanItem("debug-level", m_include_debug_level);
  587     source_flags_sp->AddBooleanItem("info-level", m_include_info_level ||
  589     source_flags_sp->AddBooleanItem("live-stream", m_live_stream);
  592     config_sp->AddBooleanItem("filter-fall-through-accepts",
  599       config_sp->AddItem("filter-rules", json_filter_rules_sp);
  603         json_filter_rules_sp->AddItem(rule_sp->Serialize());
  603         json_filter_rules_sp->AddItem(rule_sp->Serialize());
  802     if (!process_sp->IsAlive()) {
  809         process_sp->GetStructuredDataPlugin(GetDarwinLogTypeName());
  810     if (!plugin_sp || (plugin_sp->GetPluginName() !=
  831     auto config_sp = m_options_sp->BuildConfigurationData(m_enable);
  833         process_sp->ConfigureStructuredData(GetDarwinLogTypeName(), config_sp);
  883           process_sp->GetStructuredDataPlugin(GetDarwinLogTypeName());
  888           plugin_sp ? plugin_sp->GetEnabled(plugin_name) : false;
  907     if (options_sp->GetFilterRules().empty()) {
  913       for (auto rule_sp : options_sp->GetFilterRules()) {
  920         rule_sp->Dump(stream);
  929                   options_sp->GetFallthroughAccepts() ? "accept" : "reject");
  980   options_sp->NotifyOptionParsingStarting(&exe_ctx);
  998       options_property_sp->GetAsString()->GetCurrentValue();
 1010       options_sp->Parse(args, &exe_ctx, PlatformSP(), require_validation);
 1019   if (!options_sp->VerifyOptions(result))
 1030   auto enable_options = GetGlobalProperties()->GetAutoEnableOptions();
 1094       object_sp->Dump(json_stream);
 1125   if (options_sp && options_sp->GetBroadcastEvents()) {
 1159   const StructuredData::Dictionary *dictionary = object_sp->GetAsDictionary();
 1179     object_sp->Dump(stream);
 1244   if (!GetGlobalProperties()->GetEnableOnStartup() &&
 1271       GetGlobalProperties()->GetLoggingModuleName();
 1292     auto &file_spec = module_sp->GetFileSpec();
 1334       process_sp->GetTarget().RemoveBreakpointByID(m_breakpoint_id);
 1391         debugger, GetGlobalProperties()->GetValueProperties(),
 1428   if (!GetGlobalProperties()->GetEnableOnStartup() &&
 1456   if (!options_sp->GetEchoToStdErr()) {
 1474   if (options_sp->GetIncludeDebugLevel())
 1476   else if (options_sp->GetIncludeInfoLevel())
 1516             __FUNCTION__, process_sp->GetUniqueID());
 1518   auto plugin_sp = process_sp->GetStructuredDataPlugin(GetDarwinLogTypeName());
 1524               process_sp->GetUniqueID());
 1530   const auto process_uid = process_sp->GetUniqueID();
 1579               __FUNCTION__, process_sp->GetUniqueID());
 1587   thread_sp->QueueThreadPlan(thread_plan_sp, abort_other_plans);
 1591             __FUNCTION__, process_sp->GetUniqueID());
 1624       FileSpec(GetGlobalProperties()->GetLoggingModuleName());
 1645               __FUNCTION__, GetGlobalProperties()->GetLoggingModuleName(),
 1651   breakpoint_sp->SetCallback(InitCompletionHookCallback, nullptr);
 1652   m_breakpoint_id = breakpoint_sp->GetID();
 1656             __FUNCTION__, GetGlobalProperties()->GetLoggingModuleName(),
 1689       process_sp->GetTarget().GetDebugger().shared_from_this();
 1702   if (!options_sp->GetDisplayAnyHeaderFields())
 1708   if (options_sp->GetDisplayTimestampRelative()) {
 1716   if (options_sp->GetDisplayActivityChain()) {
 1731   if (options_sp->GetDisplaySubsystem()) {
 1743   if (options_sp->GetDisplayCategory()) {
 1811             __FUNCTION__, process_sp->GetUniqueID());
 1818       process_sp->GetTarget().GetDebugger().shared_from_this();
 1823               __FUNCTION__, process_sp->GetUniqueID());
 1831     auto &interpreter = debugger_sp->GetCommandInterpreter();
 1838                   __FUNCTION__, process_sp->GetUniqueID());
 1843                   __FUNCTION__, process_sp->GetUniqueID());
 1846     auto error_stream_sp = debugger_sp->GetAsyncErrorStream();
 1848       error_stream_sp->Printf("failed to configure DarwinLog "
 1850       error_stream_sp->Flush();
 1857   auto config_sp = options_sp->BuildConfigurationData(true);
 1863               __FUNCTION__, process_sp->GetUniqueID());
 1870       process_sp->ConfigureStructuredData(GetDarwinLogTypeName(), config_sp);
 1878               __FUNCTION__, process_sp->GetUniqueID(), error.AsCString());
 1879     auto error_stream_sp = debugger_sp->GetAsyncErrorStream();
 1881       error_stream_sp->Printf("failed to configure DarwinLog "
 1884       error_stream_sp->Flush();
 1892               __FUNCTION__, process_sp->GetUniqueID());

tools/lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp

  214   auto cu_sp = std::make_shared<CompileUnit>(m_objfile_sp->GetModule(),
  315   Module &module = *m_objfile_sp->GetModule();
  340         AddressRange(section_sp, address - section_sp->GetFileAddress(),
  423   ArchSpec arch = m_objfile_sp->GetArchitecture();
  509   plan_sp->SetSourceName("breakpad STACK CFI");
  510   plan_sp->SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
  511   plan_sp->SetUnwindPlanForSignalTrap(eLazyBoolNo);
  512   plan_sp->SetSourcedFromCompiler(eLazyBoolYes);
  513   plan_sp->SetPlanValidAddressRange(
  515                    m_objfile_sp->GetModule()->GetSectionList()));
  515                    m_objfile_sp->GetModule()->GetSectionList()));
  518   row_sp->SetOffset(0);
  521   plan_sp->AppendRow(row_sp);
  530     row_sp->SetOffset(record->Address - init_record->Address);
  533     plan_sp->AppendRow(row_sp);
  552   plan_sp->SetSourceName("breakpad STACK WIN");
  553   plan_sp->SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
  554   plan_sp->SetUnwindPlanForSignalTrap(eLazyBoolNo);
  555   plan_sp->SetSourcedFromCompiler(eLazyBoolYes);
  556   plan_sp->SetPlanValidAddressRange(
  558                    m_objfile_sp->GetModule()->GetSectionList()));
  558                    m_objfile_sp->GetModule()->GetSectionList()));
  561   row_sp->SetOffset(0);
  589     row_sp->GetCFAValue().SetRaSearch(record->LocalSize +
  598     row_sp->GetCFAValue().SetIsDWARFExpression(saved.data(), saved.size());
  623     row_sp->SetRegisterInfo(info->kinds[eRegisterKindLLDB], loc);
  626   plan_sp->AppendRow(row_sp);
  631   return m_objfile_sp->GetModule()
  632       ->GetObjectFile()

tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

  153   dwo_module_sp->GetSymbolFile()->FindTypes(decl_context, languages, dwo_types);
  164       name_module.second->GetSymbolFile()->FindTypes(decl_context,
  180   lldb_private::CompilerType dwo_type = dwo_type_sp->GetForwardCompilerType();
  190       die.GetID(), dwarf, dwo_type_sp->GetName(), dwo_type_sp->GetByteSize(),
  190       die.GetID(), dwarf, dwo_type_sp->GetName(), dwo_type_sp->GetByteSize(),
  192       &dwo_type_sp->GetDeclaration(), type, Type::eResolveStateForward));
  223     die.GetDWARF()->GetObjectFile()->GetModule()->ReportError(
  381     dwarf->GetObjectFile()->GetModule()->LogMessage(
  543                       lldb_function_type_sp->GetForwardCompilerType());
  565               dwarf->GetObjectFile()->GetModule()->LogMessage(
  577               dwarf->GetObjectFile()->GetModule()->LogMessage(
  588               dwarf->GetObjectFile()->GetModule()->LogMessage(
  609                   dwarf->GetObjectFile()->GetModule()->LogMessage(
  667           dwarf->GetObjectFile()->GetModule()->LogMessage(
  673               type_sp->GetID());
  681             GetCachedClangDeclContextForDIE(dwarf->GetDIE(type_sp->GetID()));
  733                               type_sp->GetByteSize().getValueOr(0), die);
  737       dwarf->GetObjectFile()->GetModule()->ReportError(
  838                   complete_objc_class_type_sp->GetForwardCompilerType();
  861               dwarf->GetObjectFile()->GetModule()->ReportError(
  918                 dwarf->GetObjectFile()->GetModule()->ReportWarning(
  937                 dwarf->GetObjectFile()->GetModule()->ReportWarning(
 1179             module_sp->ReportError(
 1187             module_sp->ReportError(
 1206           module_sp->ReportError("DWARF DIE at 0x%8.8x was not able to "
 1237       type_sp->SetEncodingType(element_type);
 1264     dwarf->GetObjectFile()->GetModule()->ReportError(
 1301     type_sp->SetSymbolContextScope(symbol_context_scope);
 1411           dwarf->GetObjectFile()->GetModule()->LogMessage(
 1417               type_sp->GetID());
 1436       dwarf->GetObjectFile()->GetModule()->LogMessage(
 1469         dwarf->GetObjectFile()->GetModule()->LogMessage(
 1475             type_sp->GetID());
 1482           GetCachedClangDeclContextForDIE(dwarf->GetDIE(type_sp->GetID()));
 1525             dwarf->GetObjectFile()->GetModule()->LogMessage(
 1565   type_sp->SetIsCompleteObjCClass(attrs.is_complete_objc_class);
 1614         dwarf->GetObjectFile()->GetModule()->ReportError(
 1892       dwarf->GetObjectFile()->GetModule()->GetMutex());
 1939     dwarf->GetObjectFile()->GetModule()->LogMessageVerboseBacktrace(
 2052                 module->ReportError(":: Class '%s' has a base class '%s' which "
 2057                   module->ReportError(":: Try compiling the source file with "
 2102             module_sp->LogMessage(
 2122                 module_sp->LogMessage(
 2137                 module_sp->LogMessage(
 2151                 module_sp->LogMessage(
 2369           lowest_func_addr, module_sp->GetSectionList());
 2441             func_sp->GetFrameBaseExpression() = frame_base;
 2712                   objfile->GetModule()->ReportWarning(
 2840                       module_sp->ReportError(
 2858                   module_sp->ReportError(
 2866                   module_sp->ReportError(
 2883                   module_sp->ReportError(
 2904                 module_sp->ReportError(
 2910                 module_sp->ReportError(
 3012           module_sp->ReportError("0x%8.8x: DW_TAG_inheritance failed to "
 3227                       auto valobj_sp = frame->GetValueForVariableExpressionPath(
 3557           dwarf->GetObjectFile()->GetModule()->LogMessage(
 3565           dwarf->GetObjectFile()->GetModule()->LogMessage(

tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFContext.cpp

   26   section_sp->GetSectionData(data);

tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp

   89     offset = (*unit_sp)->GetNextUnitOffset();
   93                                              unit_sp.get()->GetID());
  129         return lhs < std::make_pair(rhs->GetDebugSection(), rhs->GetOffset());
  129         return lhs < std::make_pair(rhs->GetDebugSection(), rhs->GetOffset());

tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

   56       cu->GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
  212   unit.GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(

tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugMacro.cpp

   78         debug_macros_sp->AddMacroEntry(
   81         debug_macros_sp->AddMacroEntry(
   93         debug_macros_sp->AddMacroEntry(
   96         debug_macros_sp->AddMacroEntry(
  102       debug_macros_sp->AddMacroEntry(
  107       debug_macros_sp->AddMacroEntry(DebugMacroEntry::CreateEndFileEntry());
  114       debug_macros_sp->AddMacroEntry(DebugMacroEntry::CreateIndirectEntry(

tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

  522       m_unit->GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
  534       m_unit->GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(

tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

  474       GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(

tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

  133     m_collection_sp->Initialize(g_symbolfiledwarf_properties);
  138         m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(
  145     return m_collection_sp->GetPropertyAtIndexAsBoolean(
  211     module->RemapSourceFile(llvm::StringRef(original_file), remapped_file);
  219   return GetGlobalPluginProperties()->GetSymLinkPaths();
  234         debugger, GetGlobalPluginProperties()->GetValueProperties(),
  408       m_context(m_objfile_sp->GetModule()->GetSectionList(), dwo_section_list),
  408       m_context(m_objfile_sp->GetModule()->GetSectionList(), dwo_section_list),
  434       m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
  434       m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
  444   if (!GetGlobalPluginProperties()->IgnoreFileIndexes()) {
  486     const SectionList *section_list = m_objfile_sp->GetSectionList();
  520           m_objfile_sp->GetModule()->ReportWarning(
  520           m_objfile_sp->GetModule()->ReportWarning(
  533           m_objfile_sp->GetFileSpec().GetDirectory().GetCString();
  536           if (m_objfile_sp->GetType() == ObjectFile::eTypeDebugInfo) {
  545               m_objfile_sp->GetModule()->ReportWarning(
  545               m_objfile_sp->GetModule()->ReportWarning(
  575   ModuleSP module_sp(m_objfile_sp->GetModule());
  576   const SectionList *section_list = module_sp->GetSectionList();
  585   m_objfile_sp->ReadSectionData(section_sp.get(), data);
  704       ModuleSP module_sp(m_objfile_sp->GetModule());
  716             if (module_sp->RemapSourceFile(cu_file_spec.GetPath(),
  856     for (std::size_t i = 0; i < module->GetNumCompileUnits(); ++i)
  857       module->GetCompileUnitAtIndex(i)->ForEachExternalModule(f);
  857       module->GetCompileUnitAtIndex(i)->ForEachExternalModule(f);
 1142             GetObjectFile()->GetModule()->ReportError(
 1347       GetObjectFile()->GetModule()->LogMessage(
 1363             GetObjectFile()->GetModule()->LogMessage(
 1439       GetObjectFile()->GetModule()->LogMessageVerboseBacktrace(
 1461       GetObjectFile()->GetModule()->ReportError(
 1630                 m_objfile_sp->GetModule()->GetArchitecture();
 1630                 m_objfile_sp->GetModule()->GetArchitecture();
 1644             if (m_objfile_sp->GetFileSpec().GetFileNameExtension() == ".dwo" &&
 1645                 llvm::StringRef(m_objfile_sp->GetFileSpec().GetPath())
 1653               GetObjectFile()->GetModule()->ReportWarning(
 1676       const size_t num_cus = module_sp->GetNumCompileUnits();
 1678         CompUnitSP cu_sp = module_sp->GetCompileUnitAtIndex(i);
 1680           VariableListSP globals_sp = cu_sp->GetVariableList(true);
 1682             const size_t num_globals = globals_sp->GetSize();
 1684               VariableSP var_sp = globals_sp->GetVariableAtIndex(g);
 1685               if (var_sp && !var_sp->GetLocationIsConstantValueData()) {
 1686                 const DWARFExpression &location = var_sp->LocationExpression();
 1696                     if (var_sp->GetType())
 1698                           var_sp->GetType()->GetByteSize().getValueOr(0);
 1844             GetObjectFile()->GetModule()->ReportWarning(
 1874         SymbolContext sc(m_objfile_sp->GetModule());
 1972     return module_sp->GetMutex();
 1973   return GetObjectFile()->GetModule()->GetMutex();
 2002     GetObjectFile()->GetModule()->LogMessage(
 2015     GetObjectFile()->GetModule()->LogMessage(
 2045     sc.module_sp = m_objfile_sp->GetModule();
 2088                 var_sp->GetName().GetStringRef().contains(name.GetStringRef()))
 2107     GetObjectFile()->GetModule()->LogMessage(
 2123     GetObjectFile()->GetModule()->LogMessage(
 2141   sc.module_sp = m_objfile_sp->GetModule();
 2257     GetObjectFile()->GetModule()->LogMessage(
 2292     GetObjectFile()->GetModule()->LogMessage(
 2312     GetObjectFile()->GetModule()->LogMessage(
 2381       GetObjectFile()->GetModule()->LogMessage(
 2388       GetObjectFile()->GetModule()->LogMessage(
 2430         if (SymbolFile *sym_file = external_module_sp->GetSymbolFile())
 2437       GetObjectFile()->GetModule()->LogMessage(
 2445       GetObjectFile()->GetModule()->LogMessage(
 2499     GetObjectFile()->GetModule()->LogMessage(
 2536     GetObjectFile()->GetModule()->LogMessage(
 2637     Symtab *symtab = m_objfile_sp->GetSymtab();
 2847         GetObjectFile()->GetModule()->LogMessage(
 2923                 GetObjectFile()->GetModule()->LogMessage(
 2945                 GetObjectFile()->GetModule()->LogMessage(
 3119                 variables->AddVariableIfUnique(var_sp);
 3366             GetObjectFile()->GetModule()->ReportError(
 3491         if (const_value.Form() && type_sp && type_sp->GetType())
 3493                                type_sp->GetType()->GetByteSize().getValueOr(0),
 3501         var_sp->SetLocationIsConstantValueData(location_is_const_value_data);
 3601               GetObjectFile()->GetModule()->ReportError(
 3644             GetObjectFile()->GetModule()->ReportError(
 3655             variable_list_sp->AddVariableIfUnique(var_sp);
 3826           (SymbolFileDWARFDebugMap *)module_sp->GetSymbolFile();
 3842     module_spec.GetFileSpec() = m_objfile_sp->GetFileSpec();
 3844         FileSpec(m_objfile_sp->GetFileSpec().GetPath() + ".dwp");

tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

  200           ObjectFile *exe_objfile = exe_module_sp->GetObjectFile();
  201           SymbolFile *exe_symfile = exe_module_sp->GetSymbolFile();
  261   if (m_objfile_sp->IsStripped())
  266   switch (m_objfile_sp->GetType()) {
  287   Symtab *symtab = m_objfile_sp->GetSymtab();
  353             m_objfile_sp->GetModule()->ReportError(
  353             m_objfile_sp->GetModule()->ReportError(
  369             m_objfile_sp->GetModule()->ReportError(
  369             m_objfile_sp->GetModule()->ReportError(
  374             m_objfile_sp->GetModule()->ReportError(
  374             m_objfile_sp->GetModule()->ReportError(
  379             m_objfile_sp->GetModule()->ReportError(
  379             m_objfile_sp->GetModule()->ReportError(
  384             m_objfile_sp->GetModule()->ReportError(
  384             m_objfile_sp->GetModule()->ReportError(
  426           obj_file->GetModule()->ReportError(
  452       oso_arch.SetTriple(m_objfile_sp->GetModule()
  453                              ->GetArchitecture()
  458       comp_unit_info->oso_sp->module_sp = std::make_shared<DebugMapModule>(
  465     return comp_unit_info->oso_sp->module_sp.get();
  581                 m_objfile_sp->GetModule(), nullptr, so_file_spec, cu_id,
  758   Symtab *symtab = m_objfile_sp->GetSymtab();
  994       if (section_sp->GetModule() != module_sp) {
 1018       RemoveFunctionsWithModuleNotEqualTo(m_objfile_sp->GetModule(), sc_list,
 1039       RemoveFunctionsWithModuleNotEqualTo(m_objfile_sp->GetModule(), sc_list,
 1120   ObjectFile *module_objfile = m_objfile_sp->GetModule()->GetObjectFile();
 1120   ObjectFile *module_objfile = m_objfile_sp->GetModule()->GetObjectFile();

tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp

   26     : SymbolFileDWARF(objfile, objfile->GetSectionList(
   35       m_objfile_sp->GetSectionList(false /* update_module_section_list */);
   40       if (m_objfile_sp->ReadSectionData(section_sp.get(), data) != 0)

tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwp.cpp

  125       m_obj_file->GetSectionList(false /* update_module_section_list */);
  130       if (m_obj_file->ReadSectionData(section_sp.get(), data) != 0) {

tools/lldb/source/Plugins/SymbolFile/NativePDB/DWARFLocationExpression.cpp

  109   const ArchSpec &architecture = module->GetArchitecture();
  137             module->GetArchitecture().GetMachine(), reg, register_kind);
  182         const ArchSpec &architecture = module->GetArchitecture();
  207         SectionList *section_list = module->GetSectionList();
  214         stream.PutMaxHex64(section_ptr->GetFileAddress() + offset,
  224   const ArchSpec &architecture = module->GetArchitecture();
  237   buffer->SetByteSize(size);
  248   buffer->CopyData(bytes.data(), size);

tools/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

  286         loadMatchingPDBFile(m_objfile_sp->GetFileSpec().GetPath(), m_allocator);
  289       auto module_sp = m_objfile_sp->GetModule();
  293       FileSpec symfile = module_sp->GetSymbolFileFileSpec();
  322   m_obj_load_address = m_objfile_sp->GetBaseAddress().GetFileAddress();
  326   auto ts_or_err = m_objfile_sp->GetModule()->GetTypeSystemForLanguage(
  326   auto ts_or_err = m_objfile_sp->GetModule()->GetTypeSystemForLanguage(
  362     return GetOrCreateFunction(block_id, *comp_unit)->GetBlock(false);
  400                           comp_unit.GetModule()->GetSectionList());
  440       std::make_shared<CompileUnit>(m_objfile_sp->GetModule(), nullptr, fs,
  461                                 modified_type->GetByteSize(), nullptr,
  585       underlying_type->GetByteSize(), nullptr, LLDB_INVALID_UID,
  600   array_sp->SetEncodingType(element_type.get());
  814   var_sp->SetLocationIsConstantValueData(false);
  842   var_sp->SetLocationIsConstantValueData(true);
 1295       (void)type->GetFullCompilerType();
 1349       std::make_shared<SymbolFileType>(*this, type_sp->GetID());
 1386       toOpaqueUid(id), this, ConstString(udt.Name), target_type->GetByteSize(),
 1387       nullptr, target_type->GetID(), lldb_private::Type::eEncodingIsTypedefUID,
 1388       decl, target_type->GetForwardCompilerType(),
 1465         variables->AddVariableIfUnique(variable);
 1581       m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
 1581       m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);

tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp

  687     type_sp->SetEncodingType(element_type);
 1232       symbol_file.GetObjectFile()->GetModule()->ReportError(
 1296       symbol_file.GetObjectFile()->GetModule()->ReportError(
 1354     symbol_file.GetObjectFile()->GetModule()->ReportError(

tools/lldb/source/Plugins/SymbolFile/PDB/PDBLocationToDWARFExpression.cpp

   74   const ArchSpec &architecture = module->GetArchitecture();
   89     SectionList *section_list = module->GetSectionList();
  100     stream.PutMaxHex64(section->GetFileAddress() + offset, address_size,

tools/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

  138     std::string exePath = m_objfile_sp->GetFileSpec().GetPath();
  143       auto module_sp = m_objfile_sp->GetModule();
  147       FileSpec symfile = module_sp->GetSymbolFileFileSpec();
  187       m_objfile_sp->GetBaseAddress().GetFileAddress();
  285                    GetObjectFile()->GetModule()->GetSectionList());
  592       GetObjectFile()->GetModule()->GetMutex());
  746     lldbassert(sc.module_sp == cu_sp->GetModule());
  826       sc.module_sp = cu->GetModule();
 1024   var_sp->SetLocationIsConstantValueData(is_constant);
 1080           local_variable_list_sp->AddVariableIfUnique(var_sp);
 1122     sc.module_sp = m_objfile_sp->GetModule();
 1165     sc.module_sp = m_objfile_sp->GetModule();
 1386   auto section_list = m_objfile_sp->GetSectionList();
 1399     auto file_addr = section->GetFileAddress() + offset;
 1635         if (auto compiland_up = GetPDBCompilandByUID(cu_sp->GetID()))
 1650       m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
 1650       m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
 1751   auto cu_sp = std::make_shared<CompileUnit>(m_objfile_sp->GetModule(), nullptr,

tools/lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp

   63     const Symtab *symtab = m_objfile_sp->GetSymtab();
  123         m_objfile_sp->GetSymtab()->SymbolAtIndex(m_source_indexes[idx]);
  125       cu_sp = std::make_shared<CompileUnit>(m_objfile_sp->GetModule(), nullptr,
  140   const Symtab *symtab = m_objfile_sp->GetSymtab();
  249   if (m_objfile_sp->GetSymtab() == nullptr)
  254     sc.symbol = m_objfile_sp->GetSymtab()->FindSymbolContainingFileAddress(

tools/lldb/source/Plugins/SymbolVendor/ELF/SymbolVendorELF.cpp

   66       llvm::dyn_cast_or_null<ObjectFileELF>(module_sp->GetObjectFile());
   80   FileSpec fspec = module_sp->GetSymbolFileFileSpec();
   87                      module_sp->GetFileSpec().GetPath().c_str());
  112   dsym_objfile_sp->SetType(ObjectFile::eTypeDebugInfo);
  118   SectionList *module_section_list = module_sp->GetSectionList();
  119   SectionList *objfile_section_list = dsym_objfile_sp->GetSectionList();
  136         module_section_list->ReplaceSection(module_section_sp->GetID(),

tools/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp

  173           thread.GetProcess()->GetTarget().GetScratchTypeSystemForLanguage(
  232   ClangASTContext *clang_ast_context = target_sp->GetScratchClangASTContext();
  297     addr_t bufaddr = process_sp->AllocateMemory(
  340   options.SetTimeout(process_sp->GetUtilityExpressionTimeout());

tools/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.cpp

  180           thread.GetProcess()->GetTarget().GetScratchClangASTContext();
  231   ClangASTContext *clang_ast_context = target_sp->GetScratchClangASTContext();
  300     addr_t bufaddr = process_sp->AllocateMemory(

tools/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.cpp

  194         thread.GetProcess()->GetTarget().GetScratchClangASTContext();
  234   ClangASTContext *clang_ast_context = target_sp->GetScratchClangASTContext();
  297     addr_t bufaddr = process_sp->AllocateMemory(

tools/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetThreadItemInfoHandler.cpp

  189           thread.GetProcess()->GetTarget().GetScratchClangASTContext();
  240   ClangASTContext *clang_ast_context = target_sp->GetScratchClangASTContext();
  303     addr_t bufaddr = process_sp->AllocateMemory(

tools/lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp

  194   StructuredData::Dictionary *dict = dict_sp->GetAsDictionary();
  220   if (thread_sp && thread_sp->GetStackFrameCount() > 0 &&
  221       thread_sp->GetFrameWithConcreteFrameIndex(0)) {
  223         thread_sp->GetFrameWithConcreteFrameIndex(0)->GetSymbolContext(
  223         thread_sp->GetFrameWithConcreteFrameIndex(0)->GetSymbolContext(
  277     dispatch_queue_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType(
  287       dispatch_queue_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType(
  332         module_sp->FindFirstSymbolWithNameAndType(
  379     libdispatch_tsd_indexes_symbol = module_sp->FindFirstSymbolWithNameAndType(
  465     if (real_thread->GetExtendedBacktraceToken() != LLDB_INVALID_ADDRESS) {
  467           real_thread->GetExtendedBacktraceToken());
  473               *cur_thread_sp.get(), real_thread->GetID(), m_page_to_free,
  490           originating_thread_sp->SetExtendedBacktraceToken(
  492           originating_thread_sp->SetQueueName(
  494           originating_thread_sp->SetQueueID(item.enqueuing_queue_serialnum);
  531       return_thread_sp->SetExtendedBacktraceToken(item.item_that_enqueued_this);
  532       return_thread_sp->SetQueueName(item.enqueuing_queue_label.c_str());
  533       return_thread_sp->SetQueueID(item.enqueuing_queue_serialnum);
  552       *m_process, queue_item_sp->GetEnqueueingThreadID(),
  553       queue_item_sp->GetEnqueueingBacktrace());
  554   extended_thread_sp->SetExtendedBacktraceToken(
  555       queue_item_sp->GetItemThatEnqueuedThis());
  556   extended_thread_sp->SetQueueName(queue_item_sp->GetQueueLabel().c_str());
  556   extended_thread_sp->SetQueueName(queue_item_sp->GetQueueLabel().c_str());
  557   extended_thread_sp->SetQueueID(queue_item_sp->GetEnqueueingQueueID());
  557   extended_thread_sp->SetQueueID(queue_item_sp->GetEnqueueingQueueID());
  714     if (thread_sp->GetAssociatedWithLibdispatchQueue() != eLazyBoolNo) {
  715       if (thread_sp->GetQueueID() != LLDB_INVALID_QUEUE_ID) {
  716         if (queue_list.FindQueueByID(thread_sp->GetQueueID()).get() ==
  719                                      thread_sp->GetQueueID(),
  720                                      thread_sp->GetQueueName()));
  721           if (thread_sp->ThreadHasQueueInformation()) {
  722             queue_sp->SetKind(thread_sp->GetQueueKind());
  722             queue_sp->SetKind(thread_sp->GetQueueKind());
  723             queue_sp->SetLibdispatchQueueAddress(
  724                 thread_sp->GetQueueLibdispatchQueueAddress());
  727             queue_sp->SetKind(
  728                 GetQueueKind(thread_sp->GetQueueLibdispatchQueueAddress()));
  729             queue_sp->SetLibdispatchQueueAddress(
  730                 thread_sp->GetQueueLibdispatchQueueAddress());
  940       queue_sp->SetNumRunningWorkItems(running_work_items_count);
  941       queue_sp->SetNumPendingWorkItems(pending_work_items_count);
  942       queue_sp->SetLibdispatchQueueAddress(queue);
  943       queue_sp->SetKind(GetQueueKind(queue));

tools/lldb/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp

   40     if (process_sp->GetTarget().ReadMemory(
   99       const InstructionList &inst_list = disasm_sp->GetInstructionList();
  163             if (it->second.first->GetOffset() != m_curr_row->GetOffset()) {
  163             if (it->second.first->GetOffset() != m_curr_row->GetOffset()) {
  196                 m_curr_row->SetOffset(current_offset);
  232               newrow->SetOffset(current_offset + m_forward_branch_offset);
  246                 m_curr_row->SetOffset(current_offset +
  451         m_curr_row->SetRegisterLocationToAtCFAPlusOffset(reg_num, offset,
  560       m_curr_row->GetCFAValue().IncOffset(-1 * offset);
  595           m_curr_row->SetRegisterLocationToSame(reg_num,
  606           m_curr_row->SetRegisterLocationToSame(reg_num,
  625       m_curr_row->GetCFAValue().SetIsRegisterPlusOffset(
  638       m_curr_row->GetCFAValue().SetIsRegisterPlusOffset(
  648       m_curr_row->GetCFAValue().SetIsRegisterPlusOffset(
  649           m_curr_row->GetCFAValue().GetRegisterNumber(),

tools/lldb/source/Plugins/UnwindAssembly/x86/UnwindAssembly-x86.cpp

   55   if (process_sp->GetTarget().ReadMemory(
   78   wordsize = process_sp->GetTarget().GetArchitecture().GetAddressByteSize();
   91   if (first_row->GetCFAValue().GetValueType() !=
   94                      first_row->GetCFAValue().GetRegisterNumber()) !=
   96       first_row->GetCFAValue().GetOffset() != wordsize) {
  100   if (!first_row->GetRegisterInfo(
  112       first_row->GetOffset() != last_row->GetOffset()) {
  112       first_row->GetOffset() != last_row->GetOffset()) {
  119     if (first_row->GetCFAValue().GetValueType() ==
  120             last_row->GetCFAValue().GetValueType() &&
  121         first_row->GetCFAValue().GetRegisterNumber() ==
  122             last_row->GetCFAValue().GetRegisterNumber() &&
  123         first_row->GetCFAValue().GetOffset() ==
  124             last_row->GetCFAValue().GetOffset()) {
  129       if (last_row->GetRegisterInfo(
  157     if (process_sp->GetTarget().ReadMemory(
  185     Target &target(process_sp->GetTarget());
  197         ABISP abi_sp = process_sp->GetABI();
  199           return abi_sp->CreateDefaultUnwindPlan(unwind_plan);

tools/lldb/source/Plugins/UnwindAssembly/x86/x86AssemblyInspectionEngine.cpp

  131     const RegisterInfo *ri = reg_ctx->GetRegisterInfoByName(it->second.name);
  937   row->SetOffset(current_func_text_offset);
  938   row->GetCFAValue().SetIsRegisterPlusOffset(m_lldb_sp_regnum, m_wordsize);
  942   row->SetRegisterInfo(m_lldb_sp_regnum, initial_regloc);
  947   row->SetRegisterInfo(m_lldb_ip_regnum, initial_regloc);
  990     auto &cfa_value = row->GetCFAValue();
  991     auto &afa_value = row->GetAFAValue();
 1070         row->SetRegisterInfo(lldb_regno, regloc);
 1083         row->RemoveRegisterInfo(lldb_regno);
 1118         row->RemoveRegisterInfo(m_lldb_fp_regnum);
 1168       row->SetRegisterInfo(lldb_regno, regloc);
 1249       if (row->GetRegisterInfo(m_lldb_sp_regnum, sp) &&
 1250           row->GetRegisterInfo(m_lldb_ip_regnum, pc)) {
 1294         row->SetOffset(current_func_text_offset + insn_len);
 1356   if (first_row->GetOffset() != 0)
 1358   uint32_t cfa_reg = first_row->GetCFAValue().GetRegisterNumber();
 1360     cfa_reg = reg_ctx->ConvertRegisterKindToRegisterNumber(
 1362         first_row->GetCFAValue().GetRegisterNumber());
 1365       first_row->GetCFAValue().GetOffset() != m_wordsize)
 1399       new_row->SetOffset(offset);
 1410            unwind_plan.GetRowAtIndex(row_id)->GetOffset() <= offset) {
 1414     if (original_row->GetOffset() == offset) {
 1426     cfa_reg = row->GetCFAValue().GetRegisterNumber();
 1428       cfa_reg = reg_ctx->ConvertRegisterKindToRegisterNumber(
 1430           row->GetCFAValue().GetRegisterNumber());
 1439         row->SetOffset(offset);
 1440         row->GetCFAValue().IncOffset(m_wordsize);
 1451         row->SetOffset(offset);
 1452         row->GetCFAValue().IncOffset(m_wordsize);
 1465         row->SetOffset(offset);
 1466         row->GetCFAValue().IncOffset(-m_wordsize);
 1475         row->SetOffset(offset);
 1476         row->GetCFAValue().IncOffset(-m_wordsize);
 1486         row->SetOffset(offset);
 1487         row->GetCFAValue().IncOffset(m_wordsize);
 1496         row->SetOffset(offset);
 1497         row->GetCFAValue().IncOffset(m_wordsize);
 1507         row->SetOffset(offset);
 1508         row->GetCFAValue().IncOffset(-amount);
 1516         row->SetOffset(offset);
 1517         row->GetCFAValue().IncOffset(amount);
 1527         row->SetOffset(offset);
 1528         row->GetCFAValue().IncOffset(-amount);
 1549           row->SetOffset(offset);
 1550           row->GetCFAValue().SetIsRegisterPlusOffset(
 1551               first_row->GetCFAValue().GetRegisterNumber(), m_wordsize);

tools/lldb/source/Symbol/ArmUnwindInfo.cpp

   55   addr_t exidx_base_addr = m_arm_exidx_sp->GetFileAddress();
  325   row->SetOffset(0);
  326   row->GetCFAValue().SetIsRegisterPlusOffset(vsp_reg, vsp);
  331     row->SetRegisterLocationToAtCFAPlusOffset(offset.first, offset.second - vsp,
  337     if (row->GetRegisterInfo(dwarf_lr, lr_location))
  338       row->SetRegisterInfo(dwarf_pc, lr_location);
  340       row->SetRegisterLocationToRegister(dwarf_pc, dwarf_lr, false);
  369          (data_file_addr - m_arm_extab_sp->GetFileAddress());

tools/lldb/source/Symbol/Block.cpp

   54     m_inlineInfoSP->Dump(s, show_fullpaths);
   77     m_inlineInfoSP->Dump(s, show_fullpaths);
  100       m_variable_list_sp->Dump(s, show_context);
  105       (*pos)->Dump(s, base_addr, depth - 1, show_context);
  118     matching_block = (*pos)->FindBlockByID(block_id);
  347                   module_sp->GetFileSpec().GetPath().c_str());
  356                   module_sp->GetFileSpec().GetPath().c_str());
  368     mem_size += m_inlineInfoSP->MemorySize();
  370     mem_size += m_variable_list_sp->MemorySize();
  376     child_block_sp->SetParentScope(this);
  395       sc.module_sp->GetSymbolFile()->ParseVariablesForContext(sc);
  442     for (size_t i = 0; i < variable_list_sp->GetSize(); ++i) {
  443       VariableSP variable = variable_list_sp->GetVariableAtIndex(i);
  466     return module_sp->GetSymbolFile();
  482       (*pos)->SetBlockInfoHasBeenParsed(b, true);
  491       (*pos)->SetDidParseVariables(b, true);

tools/lldb/source/Symbol/ClangASTContext.cpp

  596         ast_sp->m_scratch_ast_source_up.reset(
  598         lldbassert(ast_sp->getFileManager());
  599         ast_sp->m_scratch_ast_source_up->InstallASTContext(
  600             *ast_sp->getASTContext(), *ast_sp->getFileManager(), true);
  600             *ast_sp->getASTContext(), *ast_sp->getFileManager(), true);
  602             ast_sp->m_scratch_ast_source_up->CreateProxy());
  603         ast_sp->SetExternalSource(proxy_ast_source);
  823       m_target_options_rp->Triple = m_target_triple;
 8987       if (symbol_name != type->GetName().GetStringRef())
 8990     s << type->GetName().AsCString() << "\n";
 8993                  GetAsTagDecl(type->GetFullCompilerType()))
 8996                  GetAsTypedefDecl(type->GetFullCompilerType()))
 8999       GetCanonicalQualType(type->GetFullCompilerType().GetOpaqueQualType())
10320   Process *process = target_sp->GetProcessSP().get();

tools/lldb/source/Symbol/ClangASTImporter.cpp

   68   llvm::Expected<QualType> ret_or_error = delegate_sp->Import(type);
  119   llvm::Expected<clang::Decl *> result = delegate_sp->Import(decl);
  279     m_delegate->SetImportListener(this);
  294       assert(to_context_md->m_origins[decl].ctx == m_src_ctx);
  296       Decl *original_decl = to_context_md->m_origins[decl].decl;
  303             m_delegate->ImportDefinitionTo(tag_decl, original_tag_decl);
  315       to_context_md->m_origins.erase(decl);
  320     m_delegate->RemoveImportListener();
  647     delegate_sp->ImportDefinitionTo(decl, decl_origin.decl);
  665     delegate_sp->ImportDefinitionTo(decl, origin_decl);
  669   OriginMap &origins = context_md->m_origins;
  692     delegate_sp->ImportDefinitionTo(interface_decl, decl_origin.decl);
  724           delegate_sp->Import(origin_child_decl);
  755             delegate_sp->Import(origin_child_decl);
  814   OriginMap &origins = context_md->m_origins;
  828   OriginMap &origins = context_md->m_origins;
  844   context_md->m_namespace_maps[decl] = namespace_map;
  851   NamespaceMetaMap &namespace_maps = context_md->m_namespace_maps;
  877   if (context_md->m_map_completer) {
  880     context_md->m_map_completer->CompleteNamespaceMap(
  884   context_md->m_namespace_maps[decl] = new_map;
  911   md->m_delegates.erase(src_ast);
  913   for (OriginMap::iterator iter = md->m_origins.begin();
  914        iter != md->m_origins.end();) {
  916       md->m_origins.erase(iter++);
 1081     OriginMap &origins = from_context_md->m_origins;
 1086       if (to_context_md->m_origins.find(to) == to_context_md->m_origins.end() ||
 1086       if (to_context_md->m_origins.find(to) == to_context_md->m_origins.end() ||
 1089           to_context_md->m_origins[to] = origin_iter->second;
 1096         direct_completer->ASTImporter::Imported(origin_iter->second.decl, to);
 1110       if (to_context_md->m_origins.find(to) == to_context_md->m_origins.end() ||
 1110       if (to_context_md->m_origins.find(to) == to_context_md->m_origins.end() ||
 1112         to_context_md->m_origins[to] = DeclOrigin(m_source_ctx, from);
 1126       NamespaceMetaMap &namespace_maps = from_context_md->m_namespace_maps;
 1132         to_context_md->m_namespace_maps[to_namespace] =
 1136     to_context_md->m_origins[to] = DeclOrigin(m_source_ctx, from);
 1205   OriginMap::iterator iter = to_context_md->m_origins.find(To);
 1207   if (iter == to_context_md->m_origins.end())

tools/lldb/source/Symbol/CompactUnwindInfo.cpp

  256     m_objfile.GetModule()->LogMessage(
  260     if (m_section_sp->IsEncrypted()) {
  266           std::make_shared<DataBufferHeap>(m_section_sp->GetByteSize(), 0);
  268       if (process_sp->ReadMemory(
  269               m_section_sp->GetLoadBaseAddress(&process_sp->GetTarget()),
  269               m_section_sp->GetLoadBaseAddress(&process_sp->GetTarget()),
  270               m_section_contents_if_encrypted->GetBytes(),
  271               m_section_sp->GetByteSize(),
  272               error) == m_section_sp->GetByteSize() &&
  275             process_sp->GetTarget().GetArchitecture().GetAddressByteSize());
  277             process_sp->GetTarget().GetArchitecture().GetByteOrder());
  283     if (m_unwindinfo_data.GetByteSize() != m_section_sp->GetByteSize())
  353       if (second_level_offset > m_section_sp->GetByteSize() ||
  354           lsda_offset > m_section_sp->GetByteSize()) {
  505       text_section_file_address = text_sect->GetFileAddress();
  753     row->GetCFAValue().SetIsRegisterPlusOffset(
  756     row->SetOffset(0);
  757     row->SetRegisterLocationToAtCFAPlusOffset(x86_64_eh_regnum::rbp,
  759     row->SetRegisterLocationToAtCFAPlusOffset(x86_64_eh_regnum::rip,
  761     row->SetRegisterLocationToIsCFAPlusOffset(x86_64_eh_regnum::rsp, 0, true);
  781         row->SetRegisterLocationToAtCFAPlusOffset(
  825           uint64_t large_stack_size = process_sp->ReadUnsignedIntegerFromMemory(
  844     row->GetCFAValue().SetIsRegisterPlusOffset(x86_64_eh_regnum::rsp, offset);
  846     row->SetOffset(0);
  847     row->SetRegisterLocationToAtCFAPlusOffset(x86_64_eh_regnum::rip,
  849     row->SetRegisterLocationToIsCFAPlusOffset(x86_64_eh_regnum::rsp, 0, true);
  949           row->SetRegisterLocationToAtCFAPlusOffset(
 1025     row->GetCFAValue().SetIsRegisterPlusOffset(
 1027     row->SetOffset(0);
 1028     row->SetRegisterLocationToAtCFAPlusOffset(i386_eh_regnum::ebp,
 1030     row->SetRegisterLocationToAtCFAPlusOffset(i386_eh_regnum::eip,
 1032     row->SetRegisterLocationToIsCFAPlusOffset(i386_eh_regnum::esp, 0, true);
 1052         row->SetRegisterLocationToAtCFAPlusOffset(
 1090           uint64_t large_stack_size = process_sp->ReadUnsignedIntegerFromMemory(
 1108     row->GetCFAValue().SetIsRegisterPlusOffset(i386_eh_regnum::esp, offset);
 1109     row->SetOffset(0);
 1110     row->SetRegisterLocationToAtCFAPlusOffset(i386_eh_regnum::eip,
 1112     row->SetRegisterLocationToIsCFAPlusOffset(i386_eh_regnum::esp, 0, true);
 1212           row->SetRegisterLocationToAtCFAPlusOffset(
 1325     row->SetOffset(0);
 1333     row->GetCFAValue().SetIsRegisterPlusOffset(arm64_eh_regnum::sp, stack_size);
 1336     row->SetRegisterLocationToRegister(arm64_eh_regnum::pc, arm64_eh_regnum::ra,
 1349   row->GetCFAValue().SetIsRegisterPlusOffset(arm64_eh_regnum::fp, 2 * wordsize);
 1350   row->SetOffset(0);
 1351   row->SetRegisterLocationToAtCFAPlusOffset(arm64_eh_regnum::fp, wordsize * -2,
 1353   row->SetRegisterLocationToAtCFAPlusOffset(arm64_eh_regnum::pc, wordsize * -1,
 1355   row->SetRegisterLocationToIsCFAPlusOffset(arm64_eh_regnum::sp, 0, true);
 1364     row->SetRegisterLocationToAtCFAPlusOffset(arm64_eh_regnum::x19, cfa_offset,
 1367     row->SetRegisterLocationToAtCFAPlusOffset(arm64_eh_regnum::x20, cfa_offset,
 1375     row->SetRegisterLocationToAtCFAPlusOffset(arm64_eh_regnum::x21, cfa_offset,
 1378     row->SetRegisterLocationToAtCFAPlusOffset(arm64_eh_regnum::x22, cfa_offset,
 1386     row->SetRegisterLocationToAtCFAPlusOffset(arm64_eh_regnum::x23, cfa_offset,
 1389     row->SetRegisterLocationToAtCFAPlusOffset(arm64_eh_regnum::x24, cfa_offset,
 1397     row->SetRegisterLocationToAtCFAPlusOffset(arm64_eh_regnum::x25, cfa_offset,
 1400     row->SetRegisterLocationToAtCFAPlusOffset(arm64_eh_regnum::x26, cfa_offset,
 1408     row->SetRegisterLocationToAtCFAPlusOffset(arm64_eh_regnum::x27, cfa_offset,
 1411     row->SetRegisterLocationToAtCFAPlusOffset(arm64_eh_regnum::x28, cfa_offset,
 1462   row->GetCFAValue().SetIsRegisterPlusOffset(arm_r7,
 1464   row->SetOffset(0);
 1465   row->SetRegisterLocationToAtCFAPlusOffset(
 1467   row->SetRegisterLocationToAtCFAPlusOffset(
 1469   row->SetRegisterLocationToIsCFAPlusOffset(arm_sp, 0, true);
 1477     row->SetRegisterLocationToAtCFAPlusOffset(arm_r6, cfa_offset, true);
 1482     row->SetRegisterLocationToAtCFAPlusOffset(arm_r5, cfa_offset, true);
 1487     row->SetRegisterLocationToAtCFAPlusOffset(arm_r4, cfa_offset, true);
 1492     row->SetRegisterLocationToAtCFAPlusOffset(arm_r12, cfa_offset, true);
 1497     row->SetRegisterLocationToAtCFAPlusOffset(arm_r11, cfa_offset, true);
 1502     row->SetRegisterLocationToAtCFAPlusOffset(arm_r10, cfa_offset, true);
 1507     row->SetRegisterLocationToAtCFAPlusOffset(arm_r9, cfa_offset, true);
 1512     row->SetRegisterLocationToAtCFAPlusOffset(arm_r8, cfa_offset, true);
 1522       row->SetRegisterLocationToAtCFAPlusOffset(arm_d8, cfa_offset, true);
 1528       row->SetRegisterLocationToAtCFAPlusOffset(arm_d10, cfa_offset, true);
 1530       row->SetRegisterLocationToAtCFAPlusOffset(arm_d8, cfa_offset, true);
 1537       row->SetRegisterLocationToAtCFAPlusOffset(arm_d12, cfa_offset, true);
 1539       row->SetRegisterLocationToAtCFAPlusOffset(arm_d10, cfa_offset, true);
 1541       row->SetRegisterLocationToAtCFAPlusOffset(arm_d8, cfa_offset, true);
 1549       row->SetRegisterLocationToAtCFAPlusOffset(arm_d14, cfa_offset, true);
 1551       row->SetRegisterLocationToAtCFAPlusOffset(arm_d12, cfa_offset, true);
 1553       row->SetRegisterLocationToAtCFAPlusOffset(arm_d10, cfa_offset, true);
 1555       row->SetRegisterLocationToAtCFAPlusOffset(arm_d8, cfa_offset, true);
 1563       row->SetRegisterLocationToAtCFAPlusOffset(arm_d14, cfa_offset, true);
 1565       row->SetRegisterLocationToAtCFAPlusOffset(arm_d12, cfa_offset, true);
 1579       row->SetRegisterLocationToAtCFAPlusOffset(arm_d14, cfa_offset, true);

tools/lldb/source/Symbol/CompileUnit.cpp

   49   GetModule()->CalculateSymbolContext(sc);
   57   GetModule()->DumpSymbolContext(s);
   76                return a->GetID() < b->GetID();
   76                return a->GetID() < b->GetID();
  101     m_variables->Dump(s, show_context);
  108       f->Dump(s, show_context);
  119   m_functions_by_uid[funcSP->GetID()] = funcSP;
  133       if (SymbolFile *symfile = GetModule()->GetSymbolFile())
  144       if (SymbolFile *symfile = GetModule()->GetSymbolFile())
  167       if (SymbolFile *symfile = GetModule()->GetSymbolFile())
  188     sc.module_sp->GetSymbolFile()->ParseVariablesForContext(sc);
  331     if (SymbolFile *symfile = GetModule()->GetSymbolFile()) {
  347     if (SymbolFile *symfile = GetModule()->GetSymbolFile()) {
  357   if (SymbolFile *symfile = GetModule()->GetSymbolFile())
  365       if (SymbolFile *symfile = GetModule()->GetSymbolFile())

tools/lldb/source/Symbol/DWARFCallFrameInfo.cpp

  163   if (module_sp.get() == nullptr || module_sp->GetObjectFile() == nullptr ||
  164       module_sp->GetObjectFile() != &m_objfile)
  177   if (module_sp.get() == nullptr || module_sp->GetObjectFile() == nullptr ||
  178       module_sp->GetObjectFile() != &m_objfile)
  181   if (m_section_sp.get() == nullptr || m_section_sp->IsEncrypted())
  196   if (!m_section_sp || m_section_sp->IsEncrypted())
  266     cie_sp->ptr_encoding = DW_EH_PE_absptr; // default
  267     cie_sp->version = m_cfi_data.GetU8(&offset);
  268     if (cie_sp->version > CFI_VERSION4) {
  271                       cie_sp->version);
  276       cie_sp->augmentation[i] = m_cfi_data.GetU8(&offset);
  277       if (cie_sp->augmentation[i] == '\0') {
  280           cie_sp->augmentation[j] = '\0';
  287         cie_sp->augmentation[CFI_AUG_MAX_SIZE - 1] != '\0') {
  297     if (m_type == DWARF && cie_sp->version >= CFI_VERSION4) {
  298       cie_sp->address_size = m_cfi_data.GetU8(&offset);
  299       cie_sp->segment_size = m_cfi_data.GetU8(&offset);
  302     cie_sp->code_align = (uint32_t)m_cfi_data.GetULEB128(&offset);
  303     cie_sp->data_align = (int32_t)m_cfi_data.GetSLEB128(&offset);
  305     cie_sp->return_addr_reg_num =
  306         m_type == DWARF && cie_sp->version >= CFI_VERSION3
  310     if (cie_sp->augmentation[0]) {
  315       const size_t aug_str_len = strlen(cie_sp->augmentation);
  320       if (cie_sp->augmentation[0] == 'z') {
  324           char aug = cie_sp->augmentation[aug_str_idx];
  334             cie_sp->lsda_addr_encoding = m_cfi_data.GetU8(&offset);
  351               const lldb::addr_t pc_rel_addr = m_section_sp->GetFileAddress();
  352               cie_sp->personality_loc = GetGNUEHPointer(
  364             cie_sp->ptr_encoding = m_cfi_data.GetU8(&offset);
  368       } else if (strcmp(cie_sp->augmentation, "eh") == 0) {
  379       cie_sp->inst_offset = offset;
  380       cie_sp->inst_length = end_offset - offset;
  388                                    cie_sp->data_align, offset,
  389                                    cie_sp->initial_row))
  401       m_objfile.GetModule()->LogMessage(log, "Reading EH frame info");
  411   if (m_section_sp.get() == nullptr || m_section_sp->IsEncrypted())
  499       const lldb::addr_t pc_rel_addr = m_section_sp->GetFileAddress();
  533   if (m_section_sp.get() == nullptr || m_section_sp->IsEncrypted())
  574   const lldb::addr_t pc_rel_addr = m_section_sp->GetFileAddress();
  613     m_objfile.GetModule()->ResolveFileAddress(lsda_data_file_address,
  615     m_objfile.GetModule()->ResolveFileAddress(cie->personality_loc,
  658           row->SlideOffset(extended_opcode * code_align);
  674               unwind_plan.GetRowAtIndex(0)->GetRegisterInfo(reg_num,
  676             row->SetRegisterInfo(reg_num, reg_location);
  693           row->SetOffset(m_cfi_data.GetPointer(&offset) -
  707           row->SlideOffset(m_cfi_data.GetU8(&offset) * code_align);
  720           row->SlideOffset(m_cfi_data.GetU16(&offset) * code_align);
  733           row->SlideOffset(m_cfi_data.GetU32(&offset) * code_align);
  744               unwind_plan.GetRowAtIndex(0)->GetRegisterInfo(reg_num,
  746             row->SetRegisterInfo(reg_num, reg_location);
  784           lldb::addr_t offset = row->GetOffset();
  787           row->SetOffset(offset);

tools/lldb/source/Symbol/FuncUnwinders.cpp

  233     if (!assembly_profiler_sp->AugmentUnwindPlanFromCallSite(
  274     if (!assembly_profiler_sp->AugmentUnwindPlanFromCallSite(
  316     if (!assembly_profiler_sp->AugmentUnwindPlanFromCallSite(
  339     if (!assembly_profiler_sp->GetNonCallSiteUnwindPlanFromAssembly(
  358     UnwindPlan::RowSP a_first_row = a->GetRowAtIndex(0);
  359     UnwindPlan::RowSP b_first_row = b->GetRowAtIndex(0);
  365       a_first_row->GetRegisterInfo(pc_reg_lldb_regnum, a_pc_regloc);
  366       b_first_row->GetRegisterInfo(pc_reg_lldb_regnum, b_pc_regloc);
  370       if (a_first_row->GetCFAValue() != b_first_row->GetCFAValue()) {
  370       if (a_first_row->GetCFAValue() != b_first_row->GetCFAValue()) {
  444     if (!assembly_profiler_sp->GetFastUnwindPlan(m_range, thread,
  462     ABI *abi = process_sp->GetABI().get();
  487     ABI *abi = process_sp->GetABI().get();
  509     assembly_profiler_sp->FirstNonPrologueInsn(m_range, exe_ctx,
  538   if (unwind_plan_sp.get() && unwind_plan_sp->GetLSDAAddress().IsValid()) {
  539     lsda_addr = unwind_plan_sp->GetLSDAAddress();
  555       unwind_plan_sp->GetPersonalityFunctionPtr().IsValid()) {
  556     personality_addr = unwind_plan_sp->GetPersonalityFunctionPtr();

tools/lldb/source/Symbol/Function.cpp

  304       module_sp->GetSymbolFile()->ParseBlocksRecursive(*this);
  368     return section_sp->GetModule();
  385     return Disassembler::DisassembleRange(module_sp->GetArchitecture(), nullptr,
  400     disassembler_sp->GetInstructionList().Dump(&strm, show_address, show_bytes,
  451     if (SymbolFile *sym_file = module_sp->GetSymbolFile())
  466     SymbolFile *sym_file = sc.module_sp->GetSymbolFile();

tools/lldb/source/Symbol/LineEntry.cpp

  258     if (target_sp->GetSourcePathMap().FindFile(original_file, new_file_spec))

tools/lldb/source/Symbol/LineTable.cpp

  259   if (!module_sp->ResolveFileAddress(file_addr,

tools/lldb/source/Symbol/ObjectFile.cpp

   43         module_sp->GetFileSpec().GetPath().c_str(),
   55         if (file_exists && module_sp->GetObjectName()) {
   84       if (!data_sp || data_sp->GetByteSize() == 0) {
   87         module_sp->GetFileSpec().GetPath(path_with_object);
   96             module_sp->SetFileSpecAndObjectName(archive_file, archive_object);
  128       if (data_sp && data_sp->GetByteSize() > 0) {
  182                        module_sp->GetFileSpec().GetPath().c_str(),
  279             module_sp->GetSpecificationDescription().c_str(),
  292     m_data.SetData(header_data_sp, 0, header_data_sp->GetByteSize());
  298             module_sp->GetSpecificationDescription().c_str(),
  310     return module_sp->SetArchitecture(new_arch);
  322           const SectionType section_type = section_sp->GetType();
  467     const size_t bytes_read = process_sp->ReadMemory(
  505           section->GetLoadBaseAddress(&process_sp->GetTarget());
  507         return process_sp->ReadMemory(base_load_addr + section_offset, dst,
  548           section->GetLoadBaseAddress(&process_sp->GetTarget());
  553           section_data.SetData(data_sp, 0, data_sp->GetByteSize());
  554           section_data.SetByteOrder(process_sp->GetByteOrder());
  555           section_data.SetAddressByteSize(process_sp->GetAddressByteSize());
  594     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
  608         std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
  609         CreateSections(*module_sp->GetUnifiedSectionList());
  641   ConstString file_name = GetModule()->GetFileSpec().GetFilename();
  663     if (section_sp->GetFileSize() == 0)
  666     section_sp->GetSectionData(section_data);

tools/lldb/source/Symbol/Symbol.cpp

  275           uint32_t resolved_flags = module_sp->ResolveSymbolContextForAddress(
  291               resolved_flags = module_sp->ResolveSymbolContextForAddress(
  403       module_sp->DumpSymbolContext(s);
  437     module_sp->FindSymbolsWithNameAndType(reexport_name, eSymbolTypeAny,
  455         module_sp->GetObjectFile()->GetReExportedLibraries();
  546     return Disassembler::DisassembleRange(module_sp->GetArchitecture(), nullptr,
  560     disassembler_sp->GetInstructionList().Dump(&strm, show_address, show_bytes,

tools/lldb/source/Symbol/SymbolContext.cpp

   92       *s << module_sp->GetFileSpec();
   94       *s << module_sp->GetFileSpec().GetFilename();
  201     module_sp->GetFileSpec().Dump(s);
  203     if (module_sp->GetArchitecture().IsValid())
  205                 module_sp->GetArchitecture().GetArchitectureName());
  327     module_sp->GetFileSpec().Dump(s);
  586           SymbolContextScope *scs = type_sp->GetSymbolContextScope();
  605       SymbolContextScope *scs = type_sp->GetSymbolContextScope();
  625       SymbolContextScope *scs = type_sp->GetSymbolContextScope();
  644       SymbolContextScope *scs = type_sp->GetSymbolContextScope();
  978         m_target_sp->GetImages().FindFirstModule(module_spec));
 1045         if (!FileSpec::Equal(module_file_spec, sc.module_sp->GetFileSpec(),
 1123     m_target_sp->GetImages().ResolveSymbolContextForAddress(
 1141       m_module_sp->GetFileSpec().GetPath(path_str, PATH_MAX);

tools/lldb/source/Symbol/SymbolFile.cpp

   32   return GetObjectFile()->GetModule()->GetMutex();
   35   return m_objfile_sp->GetModule()->GetObjectFile();
   35   return m_objfile_sp->GetModule()->GetObjectFile();
   44     lldb::ModuleSP module_sp(objfile_sp->GetModule());
   47       ObjectFile *module_obj_file = module_sp->GetObjectFile();
   51         objfile_sp->CreateSections(*module_sp->GetUnifiedSectionList());
   51         objfile_sp->CreateSections(*module_sp->GetUnifiedSectionList());
   91       m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
   91       m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
  225         cu_sp->Dump(&s, /*show_context*/ false);

tools/lldb/source/Symbol/SymbolVendor.cpp

   44   FileSpec sym_spec = module_sp->GetSymbolFileFileSpec();
   45   if (sym_spec && sym_spec != module_sp->GetObjectFile()->GetFileSpec()) {
   53     sym_objfile_sp = module_sp->GetObjectFile()->shared_from_this();
   70     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());

tools/lldb/source/Symbol/Symtab.cpp

   81     object_name = m_objfile->GetModule()->GetObjectName().GetCString();
  837       SectionList &child_sectlist = sect_sp->GetChildren();
  844         size_t size = sect_sp->GetByteSize();
  846           addr_t base_addr = sect_sp->GetFileAddress();

tools/lldb/source/Symbol/Type.cpp

  130     : UserID(type_sp ? type_sp->GetID() : LLDB_INVALID_UID),
  724     m_compiler_type = in_type_sp->GetForwardCompilerType();
  725     m_type_name = in_type_sp->GetName();
  765     m_compiler_type = type_sp->GetForwardCompilerType();
  766     m_type_name = type_sp->GetName();
  815     m_static_type = type_sp->GetForwardCompilerType();
  816     m_module_wp = type_sp->GetModule();

tools/lldb/source/Symbol/TypeMap.cpp

   31     m_types.insert(std::make_pair(type_sp->GetID(), type_sp));
   36     user_id_t type_uid = type_sp->GetID();
   40          pos != end && pos->second->GetID() == type_uid; ++pos) {
  112     lldb::user_id_t uid = type_sp->GetID();
  126     pos->second->Dump(s, show_context);

tools/lldb/source/Symbol/TypeSystem.cpp

  247       if (pair.second && pair.second->SupportsLanguage(language)) {
  316       if (pair.second && pair.second->SupportsLanguage(language)) {

tools/lldb/source/Symbol/UnwindPlan.cpp

   76   ArchSpec arch = process_sp->GetTarget().GetArchitecture();
  361       m_row_list.back()->GetOffset() != row_sp->GetOffset())
  361       m_row_list.back()->GetOffset() != row_sp->GetOffset())
  372     if (row->GetOffset() >= row_sp->GetOffset())
  372     if (row->GetOffset() >= row_sp->GetOffset())
  376   if (it == m_row_list.end() || (*it)->GetOffset() != row_sp->GetOffset())
  376   if (it == m_row_list.end() || (*it)->GetOffset() != row_sp->GetOffset())
  390         if ((*pos)->GetOffset() <= static_cast<lldb::offset_t>(offset))
  457       GetRowAtIndex(0)->GetCFAValue().GetValueType() ==
  544     (*pos)->Dump(s, this, thread, base_addr);

tools/lldb/source/Symbol/UnwindTable.cpp

  128          pos->second->GetFunctionStartAddress() != addr))
  131     if (pos->second->ContainsAddress(addr))

tools/lldb/source/Symbol/Variable.cpp

  100     return m_symfile_type_sp->GetType();
  113     Type *type = m_symfile_type_sp->GetType();
  165         abi = ABI::FindPlugin(ProcessSP(), module_sp->GetArchitecture());
  427               var_sp->GetName().GetCString());
  461           abi = ABI::FindPlugin(ProcessSP(), module_sp->GetArchitecture());

tools/lldb/source/Symbol/VariableList.cpp

   77     if ((*pos)->NameMatches(name)) {
   78       if (include_static_members || !(*pos)->IsStaticMember()) {
   93     if ((*pos)->NameMatches(name) && (*pos)->GetScope() == value_type) {
   93     if ((*pos)->NameMatches(name) && (*pos)->GetScope() == value_type) {
   94       if (include_static_members || !(*pos)->IsStaticMember()) {
  117     if ((*pos)->NameMatches(regex)) {
  134     if ((*pos)->GetScope() == type) {
  161     mem_size += (*pos)->MemorySize();
  174     (*pos)->Dump(s, show_context);

tools/lldb/source/Target/ABI.cpp

  146       expr_variable_sp->m_flags |=
  148       expr_variable_sp->m_flags |=
  150       expr_variable_sp->m_flags |=
  154       expr_variable_sp->m_live_sp = live_valobj_sp;
  155       expr_variable_sp->m_flags |=
  160     return_valobj_sp = expr_variable_sp->GetValueObject();

tools/lldb/source/Target/ExecutionContext.cpp

   88         m_thread_sp = m_process_sp->GetThreadList().GetSelectedThread();
   90           m_frame_sp = m_thread_sp->GetSelectedFrame();
  122         (m_process_sp && StateIsStoppedState(m_process_sp->GetState(), true))) {
  135       lock = std::unique_lock<std::recursive_mutex>(m_target_sp->GetAPIMutex());
  149     lock = std::unique_lock<std::recursive_mutex>(m_target_sp->GetAPIMutex());
  177   if (m_target_sp && m_target_sp->GetArchitecture().IsValid())
  178     return m_target_sp->GetArchitecture().GetAddressByteSize();
  180     return m_process_sp->GetAddressByteSize();
  185   if (m_target_sp && m_target_sp->GetArchitecture().IsValid())
  186     return m_target_sp->GetArchitecture().GetByteOrder();
  188     return m_process_sp->GetByteOrder();
  194     return m_frame_sp->GetRegisterContext().get();
  196     return m_thread_sp->GetRegisterContext().get();
  204     return &m_process_sp->GetTarget();
  212     return m_target_sp->GetProcessSP().get();
  294     m_process_sp = target_sp->GetProcessSP();
  304     m_target_sp = process_sp->GetTarget().shared_from_this();
  315     m_process_sp = thread_sp->GetProcess();
  317       m_target_sp = m_process_sp->GetTarget().shared_from_this();
  329     m_thread_sp = frame_sp->CalculateThread();
  331       m_process_sp = m_thread_sp->GetProcess();
  333         m_target_sp = m_process_sp->GetTarget().shared_from_this();
  363        m_frame_sp->GetStackID() == rhs.m_frame_sp->GetStackID())) {
  363        m_frame_sp->GetStackID() == rhs.m_frame_sp->GetStackID())) {
  369          m_thread_sp->GetID() == rhs.m_thread_sp->GetID())) {
  369          m_thread_sp->GetID() == rhs.m_thread_sp->GetID())) {
  382   return ((bool)m_target_sp && m_target_sp->IsValid());
  386   return (HasTargetScope() && ((bool)m_process_sp && m_process_sp->IsValid()));
  390   return (HasProcessScope() && ((bool)m_thread_sp && m_thread_sp->IsValid()));
  444     m_tid = thread_sp->GetID();
  449     m_stack_id = frame_sp->GetStackID();
  471     SetTargetSP(process_sp->GetTarget().shared_from_this());
  481     m_tid = thread_sp->GetID();
  482     SetProcessSP(thread_sp->GetProcess());
  492     m_stack_id = frame_sp->GetStackID();
  493     SetThreadSP(frame_sp->GetThread());
  509         lldb::ProcessSP process_sp(target_sp->GetProcessSP());
  518             if (stop_locker.TryLock(&process_sp->GetRunLock()) &&
  519                 StateIsStoppedState(process_sp->GetState(), true)) {
  521                   process_sp->GetThreadList().GetSelectedThread());
  523                 thread_sp = process_sp->GetThreadList().GetThreadAtIndex(0);
  527                 lldb::StackFrameSP frame_sp(thread_sp->GetSelectedFrame());
  529                   frame_sp = thread_sp->GetStackFrameAtIndex(0);
  569   if (target_sp && !target_sp->IsValid())
  576   if (process_sp && !process_sp->IsValid())
  588     if (!thread_sp || !thread_sp->IsValid()) {
  590       if (process_sp && process_sp->IsValid()) {
  591         thread_sp = process_sp->GetThreadList().FindThreadByID(m_tid);
  600   if (thread_sp && !thread_sp->IsValid())
  610       return thread_sp->GetFrameWithStackID(m_stack_id);

tools/lldb/source/Target/InstrumentationRuntime.cpp

   53     const FileSpec &file_spec = module_sp->GetFileSpec();
   59         module_sp->IsExecutable()) {

tools/lldb/source/Target/JITLoaderList.cpp

   42     jit_loader->DidLaunch();
   48     jit_loader->DidAttach();
   54     jit_loader->ModulesDidLoad(module_list);

tools/lldb/source/Target/Language.cpp

  411         CompilerType compiler_type(match->GetFullCompilerType());

tools/lldb/source/Target/LanguageRuntime.cpp

   33     return m_filter_sp->ModulePasses(module_sp);
   40     return m_filter_sp->ModulePasses(spec);
   47     m_filter_sp->Search(searcher);
   53     m_filter_sp->GetDescription(s);
   57   ProcessSP process_sp(m_target_sp->GetProcessSP());
   61       m_language_runtime = process_sp->GetLanguageRuntime(m_language);
   65           process_sp->GetLanguageRuntime(m_language);
  118       return m_actual_resolver_sp->SearchCallback(filter, context, addr);
  125       return m_actual_resolver_sp->GetDepth();
  142       m_actual_resolver_sp->GetDescription(s);
  169           m_language_runtime = process_sp->GetLanguageRuntime(m_language);
  173               process_sp->GetLanguageRuntime(m_language);
  259       exc_breakpt_sp->SetPrecondition(precond);
  262       exc_breakpt_sp->SetBreakpointKind("exception");
  291         parent->LoadSubCommand(command->GetCommandName().str().c_str(), command);

tools/lldb/source/Target/Memory.cpp

   66       AddrRange chunk_range(pos->first, pos->second->GetByteSize());
  143     AddrRange chunk_range(pos->first, pos->second->GetByteSize());
  145       memcpy(dst, pos->second->GetBytes() + (addr - chunk_range.GetRangeBase()),
  190                pos->second->GetBytes() + cache_offset, curr_read_size);
  204             curr_read_size = pos->second->GetByteSize();
  208             memcpy(dst_buf + dst_len - bytes_left, pos->second->GetBytes(),
  217             if (pos->second->GetByteSize() != cache_line_byte_size)
  334       m_process.DoDeallocateMemory(pos->second->GetBaseAddress());
  377     addr = (*pos).second->ReserveBlock(byte_size);
  386       addr = block_sp->ReserveBlock(byte_size);
  403     if (pos->second->Contains(addr)) {
  404       success = pos->second->FreeBlock(addr);

tools/lldb/source/Target/ModuleCache.cpp

   88     module_uuid = module_sp->GetUUID();
  258   FileSpec symfile_spec = GetSymbolFileSpec(cached_module_sp->GetFileSpec());
  260     cached_module_sp->SetSymbolFileFileSpec(symfile_spec);
  332   FileSpec symfile_spec = GetSymbolFileSpec(cached_module_sp->GetFileSpec());
  333   cached_module_sp->SetSymbolFileFileSpec(symfile_spec);

tools/lldb/source/Target/OperatingSystem.cpp

   52     return thread_sp->IsOperatingSystemPluginThread();

tools/lldb/source/Target/Platform.cpp

   83   m_collection_sp->Initialize(g_platform_properties);
  101   return m_collection_sp->GetPropertyAtIndexAsBoolean(
  106   return m_collection_sp->SetPropertyAtIndexAsBoolean(
  111   return m_collection_sp->GetPropertyAtIndexAsFileSpec(
  116   return m_collection_sp->SetPropertyAtIndexAsFileSpec(
  248       module_sp->SetPlatformFileSpec(resolved_spec.GetFileSpec());
  276       if (platform_sp->GetName() == name)
  319         if (platform_sp->IsCompatibleArchitecture(arch, true,
  326         if (platform_sp->IsCompatibleArchitecture(arch, false,
  341             platform_sp->IsCompatibleArchitecture(arch, true,
  356             platform_sp->IsCompatibleArchitecture(arch, false,
 1070     lldb_private::TargetList &targets = debugger->GetTargetList();
 1072       ProcessSP process = targets.GetTargetAtIndex(tidx)->GetProcessSP();
 1073       if (process->GetID() == pid)
 1074         return process->Destroy(true);
 1137                   __FUNCTION__, process_sp->GetPluginName().AsCString());
 1144         process_sp->SetShouldDetach(false);
 1152           process_sp->SetSTDIOFileDescriptor(pty_fd);
 1251     size_t bytes_read = buffer_sp->GetByteSize();
 1252     error = source_file.get()->Read(buffer_sp->GetBytes(), bytes_read);
 1257         WriteFile(dest_file, offset, buffer_sp->GetBytes(), bytes_read, error);
 1507     module_spec.GetFileSpec() = module_sp->GetFileSpec();
 1594   if (IsHost() || !GetGlobalPlatformProperties()->GetUseModuleCache() ||
 1595       !GetGlobalPlatformProperties()->GetModuleCacheDirectory())
 1679   auto dir_spec = GetGlobalPlatformProperties()->GetModuleCacheDirectory();
 1799   error = process_sp->ConnectRemote(&debugger.GetOutputStream(), connect_url);
 1843       addr_class = bp_loc_sp->GetAddress().GetAddressClass();
 1845           (bp_loc_sp->GetAddress().GetFileAddress() & 1))

tools/lldb/source/Target/Process.cpp

  131     m_collection_sp->Initialize(g_process_properties);
  132     m_collection_sp->AppendProperty(
  134         true, Thread::GetGlobalProperties()->GetValueProperties());
  138     m_collection_sp->SetValueChangedCallback(
  155   return m_collection_sp->GetPropertyAtIndexAsBoolean(
  161   return m_collection_sp->GetPropertyAtIndexAsUInt64(
  168   m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, args);
  174   m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, args);
  179   return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx);
  184   m_collection_sp->SetPropertyAtIndexAsFileSpec(nullptr, idx, file);
  189   return m_collection_sp->GetPropertyAtIndexAsBoolean(
  195   m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, ignore);
  200   return m_collection_sp->GetPropertyAtIndexAsBoolean(
  206   m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, ignore);
  211   return m_collection_sp->GetPropertyAtIndexAsBoolean(
  217   m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, stop);
  222   return m_collection_sp->GetPropertyAtIndexAsBoolean(
  228   m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, stop);
  233   return m_collection_sp->GetPropertyAtIndexAsBoolean(
  239   return m_collection_sp->GetPropertyAtIndexAsBoolean(
  245   uint64_t value = m_collection_sp->GetPropertyAtIndexAsUInt64(
  314         target_sp ? target_sp->GetPlatform() : PlatformSP();
  434         if (process_sp->CanDebug(target_sp, true)) {
  435           process_sp->m_process_unique_id = ++g_process_unique_id;
  447         if (process_sp->CanDebug(target_sp, false)) {
  448           process_sp->m_process_unique_id = ++g_process_unique_id;
  473       Broadcaster((target_sp->GetDebugger().GetBroadcasterManager()),
  523   m_listener_sp->StartListeningForEvents(
  528   m_private_state_listener_sp->StartListeningForEvents(
  532   m_private_state_listener_sp->StartListeningForEvents(
  542           ->GetPropertyAtIndex(nullptr, true, ePropertyMemCacheLineSize)
  545       target_sp->GetPlatform()->GetDefaultMemoryCacheLineSize();
  545       target_sp->GetPlatform()->GetDefaultMemoryCacheLineSize();
  546   if (!value_sp->OptionWasSet() && platform_cache_line_size != 0)
  547     value_sp->SetUInt64Value(platform_cache_line_size);
  638   m_private_state_listener_sp->Clear();
  690   if (m_listener_sp->GetEventForBroadcaster(this, event_sp,
  812       stream->Printf("Process %" PRIu64 " %s\n", process_sp->GetID(),
  825       process_sp->GetStatus(*stream);
  845                            process_sp->GetID(),
  850                            process_sp->GetID());
  866         ThreadList &thread_list = process_sp->GetThreadList();
  873           curr_thread_stop_reason = curr_thread->GetStopReason();
  874           curr_thread_stop_info_sp = curr_thread->GetStopInfo();
  876         if (!curr_thread || !curr_thread->IsValid() ||
  888             StopReason thread_stop_reason = thread->GetStopReason();
  898               uint64_t signo = thread->GetStopInfo()->GetValue();
  898               uint64_t signo = thread->GetStopInfo()->GetValue();
  899               if (process_sp->GetUnixSignals()->GetShouldStop(signo)) {
  899               if (process_sp->GetUnixSignals()->GetShouldStop(signo)) {
  922             thread_list.SetSelectedThreadByID(plan_thread->GetID());
  924             thread_list.SetSelectedThreadByID(other_thread->GetID());
  926             if (curr_thread && curr_thread->IsValid())
  932               thread_list.SetSelectedThreadByID(thread->GetID());
  941         Debugger &debugger = process_sp->GetTarget().GetDebugger();
  943             &process_sp->GetTarget()) {
  949           process_sp->GetStatus(*stream);
  950           process_sp->GetThreadStatus(*stream, only_threads_with_stop_reason,
  972               process_sp->GetTarget().shared_from_this());
  977           process_sp->GetTarget().Dump(stream, eDescriptionLevelBrief);
  989     process_sp->PopProcessIOHandler();
 1015   if (listener_sp->GetEventForBroadcasterWithType(
 1018     if (event_sp && event_sp->GetType() == eBroadcastBitStateChanged)
 1034   event_ptr = m_listener_sp->PeekAtNextEventForBroadcasterWithType(
 1054   if (m_private_state_listener_sp->GetEventForBroadcasterWithType(
 1058     if (event_sp && event_sp->GetType() == eBroadcastBitStateChanged)
 1073     return m_private_state_listener_sp->GetEventForBroadcaster(
 1076     return m_private_state_listener_sp->GetEvent(event_sp, timeout);
 1168       ProcessSP process_sp(target_sp->GetProcessSP());
 1172           signal_cstr = process_sp->GetUnixSignals()->GetSignalAsCString(signo);
 1172           signal_cstr = process_sp->GetUnixSignals()->GetSignalAsCString(signo);
 1174         process_sp->SetExitStatus(exit_status, signal_cstr);
 1208             old_thread_list.GetThreadAtIndex(i, false)->ClearBackingThread();
 1592     if (bp_site_sp->IsEnabled())
 1606     if (!bp_site_sp->IsEnabled())
 1643   owner->SetIsIndirect(false);
 1645   if (owner->ShouldResolveIndirectFunctions()) {
 1646     Symbol *symbol = owner->GetAddress().CalculateSymbolContextSymbol();
 1656             owner->GetBreakpoint().GetID(), owner->GetID(),
 1656             owner->GetBreakpoint().GetID(), owner->GetID(),
 1662       owner->SetIsIndirect(true);
 1664       load_addr = owner->GetAddress().GetOpcodeLoadAddress(&GetTarget());
 1666     load_addr = owner->GetAddress().GetOpcodeLoadAddress(&GetTarget());
 1677       bp_site_sp->AddOwner(owner);
 1678       owner->SetBreakpointSite(bp_site_sp);
 1679       return bp_site_sp->GetID();
 1686           owner->SetBreakpointSite(bp_site_sp);
 1694                 load_addr, owner->GetBreakpoint().GetID(), owner->GetID(),
 1694                 load_addr, owner->GetBreakpoint().GetID(), owner->GetID(),
 1708   uint32_t num_owners = bp_site_sp->RemoveOwner(owner_id, owner_loc_id);
 1713     m_breakpoint_site_list.RemoveByAddress(bp_site_sp->GetLoadAddress());
 1750     return platform_sp->GetSoftwareBreakpointTrapOpcode(GetTarget(), bp_site);
 2405     ObjectFile *objfile = module_sp->GetMemoryObjectFile(
 2804           platform_sp->FindProcesses(match_info, process_infos);
 2817                     s, platform_sp->GetUserIDResolver(), true, false);
 2900         !platform_sp->IsCompatibleArchitecture(target_arch, false, nullptr)) {
 2903           platform_sp->GetPlatformForArchitecture(target_arch, &platform_arch);
 2910                   __FUNCTION__, platform_sp->GetName().AsCString(""),
 2940                 exe_module_sp ? exe_module_sp->GetFileSpec().GetPath().c_str()
 2957                 exe_module_sp ? exe_module_sp->GetFileSpec().GetPath().c_str()
 2981     if (module_sp && module_sp->IsExecutable()) {
 2996           exe_module_sp ? exe_module_sp->GetFileSpec().GetPath().c_str()
 3282       m_process_input_reader->SetIsDone(true);
 3283       m_process_input_reader->Cancel();
 3588           event_receipt_sp->WaitForEventReceived(GetUtilityExpressionTimeout());
 3763     if (event_sp->BroadcasterIs(&m_private_state_control_broadcaster)) {
 3768                 event_sp->GetType());
 3770       switch (event_sp->GetType()) {
 3785     } else if (event_sp->GetType() == eBroadcastBitInterrupt) {
 3918   process_sp->SetPublicState(
 3925     process_sp->WillPublicStop();
 3937     ThreadList &curr_thread_list = process_sp->GetThreadList();
 3954           curr_thread_list.GetThreadAtIndex(idx)->GetIndexID();
 3972       curr_thread_list = process_sp->GetThreadList();
 3985       if (thread_sp->GetIndexID() != thread_index_array[idx]) {
 3991                   idx, thread_index_array[idx], thread_sp->GetIndexID());
 3995       StopInfoSP stop_info_sp = thread_sp->GetStopInfo();
 3996       if (stop_info_sp && stop_info_sp->IsValid()) {
 3999         if (stop_info_sp->GetOverrideShouldStop()) {
 4001               stop_info_sp->GetOverriddenShouldStopValue();
 4003           stop_info_sp->PerformAction(event_ptr);
 4011           if (stop_info_sp->HasTargetRunSinceMe()) {
 4016           this_thread_wants_to_stop = stop_info_sp->ShouldStop(event_ptr);
 4030         process_sp->PrivateResume();
 4033             process_sp->IsHijackedForEvent(eBroadcastBitStateChanged) &&
 4034             !process_sp->StateChangedIsHijackedForSynchronousResume();
 4042           process_sp->GetTarget().RunStopHooks();
 4043           if (process_sp->GetPrivateState() == eStateRunning)
 4056               static_cast<void *>(process_sp.get()), process_sp->GetID());
 4466     io_handler_sp->SetIsDone(false);
 4501       m_private = m_thread_plan_sp->GetPrivate();
 4502       m_is_master = m_thread_plan_sp->IsMasterPlan();
 4503       m_okay_to_discard = m_thread_plan_sp->OkayToDiscard();
 4512       m_thread_plan_sp->SetPrivate(m_private);
 4513       m_thread_plan_sp->SetIsMasterPlan(m_is_master);
 4514       m_thread_plan_sp->SetOkayToDiscard(m_okay_to_discard);
 4572   if (plan == thread_plan_sp && plan->PlanSucceeded()) {
 4582   if (stop_info_sp && stop_info_sp->GetStopReason() == eStopReasonBreakpoint &&
 4583       stop_info_sp->ShouldNotify(event_sp.get())) {
 4584     LLDB_LOG(log, "stopped for breakpoint: {0}.", stop_info_sp->GetDescription());
 4591       thread_plan_sp->SetPrivate(false);
 4623   if (!thread_plan_sp->ValidatePlan(nullptr)) {
 4653   thread_plan_sp->SetPrivate(false);
 4659   thread_plan_sp->SetIsMasterPlan(true);
 4660   thread_plan_sp->SetOkayToDiscard(false);
 4699   StackID ctx_frame_id = selected_frame_sp->GetStackID();
 4710     selected_tid = selected_thread_sp->GetIndexID();
 4711     selected_stack_id = selected_thread_sp->GetSelectedFrame()->GetStackID();
 4711     selected_stack_id = selected_thread_sp->GetSelectedFrame()->GetStackID();
 4783       thread_plan_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
 4817     Event *other_events = listener_sp->PeekAtNextEvent();
 4872             listener_sp->GetEvent(event_sp, GetUtilityExpressionTimeout());
 4963         got_event = listener_sp->GetEvent(event_sp, timeout);
 4968           if (event_sp->GetType() == eBroadcastBitInterrupt) {
 5101                 listener_sp->GetEvent(event_sp, GetUtilityExpressionTimeout());
 5156                   thread_plan_sp->SetStopOthers(false);
 5225       thread_plan_sp->RestoreThreadState();
 5234           event_sp->Dump(&s);
 5248           } else if (event_sp->GetType() == eBroadcastBitInterrupt) {
 5296                 const char *stop_desc = stop_info_sp->GetDescription();
 5375             GetThreadList().GetSelectedThread()->GetFrameWithStackID(
 5378           GetThreadList().GetSelectedThread()->SetSelectedFrame(
 5472       thread_id_array[idx] = curr_thread_list.GetThreadAtIndex(idx)->GetID();
 5479         StopInfoSP stop_info_sp = thread_sp->GetStopInfo();
 5480         if (!stop_info_sp || !stop_info_sp->IsValid())
 5483       thread_sp->GetStatus(strm, start_frame, num_frames,
 5633     runtime->ModulesDidLoad(module_list);
 5651         language_runtime_sp->ModulesDidLoad(module_list);
 5663       pair.second->ModulesDidLoad(*this, module_list);
 5695     stream_sp->PrintfVarArg(fmt, args);
 5702       !sc.module_sp->GetFileSpec().GetFilename().IsEmpty() && sc.function &&
 5707                  sc.module_sp->GetFileSpec().GetFilename().GetCString());
 5718   return platform_sp->GetProcessInfo(GetID(), info);
 5732       memory_history->GetHistoryThreads(addr));
 5791     insn_list = &disassembler_sp->GetInstructionList();
 5812         insn_list->GetInstructionAtIndex(branch_index)->GetAddress();
 5917       if (plugin_sp->SupportsStructuredDataType(type_name)) {
 5924                   __FUNCTION__, plugin_sp->GetPluginName().GetCString(),
 5943   StructuredData::Dictionary *dictionary = object_sp->GetAsDictionary();
 5960   find_it->second->HandleArrivalOfStructuredData(*this, type_name, object_sp);
 6017             call_plan_sp->GetReturnValueObject()->GetValueAsUnsigned(

tools/lldb/source/Target/Queue.cpp

   44     for (ThreadSP thread_sp : process_sp->Threads()) {
   45       if (thread_sp->GetQueueID() == m_queue_id) {
   80     if (process_sp && process_sp->GetSystemRuntime()) {
   81       process_sp->GetSystemRuntime()->PopulatePendingItemsForQueue(this);

tools/lldb/source/Target/QueueItem.cpp

   48     ProcessSP process_sp = queue_sp->GetProcess();
   49     if (process_sp && process_sp->GetSystemRuntime()) {
   51           process_sp->GetSystemRuntime()->GetExtendedBacktraceForQueueItem(
  100     SystemRuntime *runtime = process_sp->GetSystemRuntime();

tools/lldb/source/Target/QueueList.cpp

   50     if (queue_sp->GetID() == qid) {
   61     if (queue_sp->GetIndexID() == index_id) {

tools/lldb/source/Target/RegisterContext.cpp

   28       m_stop_id(thread.GetProcess()->GetStopID()) {}
   38     process_stop_id = process_sp->GetStopID();
  146       frame_sp->ChangePC(pc);
  234   uint32_t num_register_sets = context->GetRegisterSetCount();
  237   if (context->GetThreadID() != GetThreadID())
  258       if (context->ReadRegister(reg_info, reg_value)) {
  260       } else if (frame_zero_context->ReadRegister(reg_info, reg_value)) {
  337         process_sp->ReadMemory(src_addr, src, src_len, error);
  355                                 process_sp->GetByteOrder(), error);
  377         reg_info, dst, dst_len, process_sp->GetByteOrder(), error);
  384             process_sp->WriteMemory(dst_addr, dst, bytes_copied, error);

tools/lldb/source/Target/RegisterNumber.cpp

   21         m_reg_ctx_sp->GetRegisterInfoAtIndex(
   40         m_reg_ctx_sp->GetRegisterInfoAtIndex(
   95       m_reg_ctx_sp->ConvertBetweenRegisterKinds(m_kind, m_regnum, kind,

tools/lldb/source/Target/RemoteAwarePlatform.cpp

   21     return m_remote_platform_sp->GetModuleSpec(module_file_spec, arch,
   35     return m_remote_platform_sp->RunShellCommand(
   43     return m_remote_platform_sp->MakeDirectory(file_spec, file_permissions);
   50     return m_remote_platform_sp->GetFilePermissions(file_spec,
   58     return m_remote_platform_sp->SetFilePermissions(file_spec,
   69     return m_remote_platform_sp->OpenFile(file_spec, flags, mode, error);
   77     return m_remote_platform_sp->CloseFile(fd, error);
   87     return m_remote_platform_sp->ReadFile(fd, offset, dst, dst_len, error);
   97     return m_remote_platform_sp->WriteFile(fd, offset, src, src_len, error);
  109     return m_remote_platform_sp->GetFileSize(file_spec);
  118     return m_remote_platform_sp->CreateSymlink(src, dst);
  126     return m_remote_platform_sp->GetFileExists(file_spec);
  134     return m_remote_platform_sp->Unlink(file_spec);
  143     return m_remote_platform_sp->CalculateMD5(file_spec, low, high);
  149     return m_remote_platform_sp->GetRemoteWorkingDirectory();
  156     return m_remote_platform_sp->SetRemoteWorkingDirectory(working_dir);
  164     return m_remote_platform_sp->GetFileWithUUID(platform_file, uuid_ptr,
  174     m_os_version = m_remote_platform_sp->GetOSVersion();
  182     return m_remote_platform_sp->GetRemoteOSBuildString(s);
  189     return m_remote_platform_sp->GetRemoteOSKernelDescription(s);
  196     return m_remote_platform_sp->GetRemoteSystemArchitecture();
  204     return m_remote_platform_sp->GetHostname();
  212     return m_remote_platform_sp->GetUserIDResolver();
  219       return m_remote_platform_sp->GetEnvironment();
  229     return m_remote_platform_sp->IsConnected();
  238     return m_remote_platform_sp->GetProcessInfo(pid, process_info);
  248     return m_remote_platform_sp->FindProcesses(match_info, process_infos);
  258     return m_remote_platform_sp->ConnectProcess(connect_url, plugin_name,
  271       error = m_remote_platform_sp->LaunchProcess(launch_info);
  282     return m_remote_platform_sp->KillProcess(pid);

tools/lldb/source/Target/SectionLoadHistory.cpp

  161     pos->second->Dump(s, target);

tools/lldb/source/Target/SectionLoadList.cpp

   67   ModuleSP module_sp(section->GetModule());
   71               section.get(), module_sp->GetFileSpec(), section->GetName(),
   71               section.get(), module_sp->GetFileSpec(), section->GetName(),
   74     if (section->GetByteSize() == 0)
  103         ModuleSP module_sp(section->GetModule());
  105           ModuleSP curr_module_sp(ats_pos->second->GetModule());
  107             module_sp->ReportWarning(
  110                 load_addr, module_sp->GetFileSpec().GetFilename().GetCString(),
  111                 section->GetName().GetCString(),
  112                 curr_module_sp->GetFileSpec().GetFilename().GetCString(),
  113                 ats_pos->second->GetName().GetCString());
  129           section->GetName().AsCString(), load_addr);
  142       ModuleSP module_sp = section_sp->GetModule();
  146             section_sp->GetModule()->GetFileSpec());
  146             section_sp->GetModule()->GetFileSpec());
  151                 section_sp->GetName().AsCString());
  177     ModuleSP module_sp = section_sp->GetModule();
  180       const FileSpec &module_file_spec(section_sp->GetModule()->GetFileSpec());
  180       const FileSpec &module_file_spec(section_sp->GetModule()->GetFileSpec());
  188         module_name.c_str(), section_sp->GetName().AsCString(), load_addr);
  221         if (offset < pos->second->GetByteSize() + (allow_section_end ? 1 : 0)) {
  224           return pos->second->ResolveContainedAddress(offset, so_addr,
  236             rpos->second->GetByteSize() + (allow_section_end ? 1 : 0)) {
  239           return rpos->second->ResolveContainedAddress(offset, so_addr,
  256     pos->second->Dump(&s, target, 0);

tools/lldb/source/Target/StackFrame.cpp

   97     m_sc.target_sp = reg_context_sp->CalculateTarget();
  111       m_id(pc_addr.GetLoadAddress(thread_sp->CalculateTarget().get()), cfa,
  125     m_sc.target_sp = reg_context_sp->CalculateTarget();
  176     return thread_sp->GetStackFrameList()->GetVisibleStackFrameIndex(
  176     return thread_sp->GetStackFrameList()->GetVisibleStackFrameIndex(
  198       TargetSP target_sp(thread_sp->CalculateTarget());
  226     thread_sp->ClearStackFrames();
  309           TargetSP target_sp(thread_sp->CalculateTarget());
  379         resolved |= m_sc.module_sp->ResolveSymbolContextForAddress(
  403         resolved |= m_sc.target_sp->GetImages().ResolveSymbolContextForAddress(
  450         m_variable_list_sp->AddVariables(global_variable_list_sp.get());
  487       var_list_sp->AddVariables(global_variable_list_sp.get());
  580       if (!variable_sp->GetName().IsEmpty())
  583       Type *var_type = variable_sp->GetType();
 1133       m_reg_context_sp = thread_sp->CreateRegisterContextForFrame(this);
 1191     m_variable_list_sp->AddVariable(variable_sp);
 1319   const ArchSpec &target_arch = target_sp->GetArchitecture();
 1334   if (!disassembler_sp || !disassembler_sp->GetInstructionList().GetSize()) {
 1339       disassembler_sp->GetInstructionList().GetInstructionAtIndex(0);
 1343   if (!instruction_sp->ParseOperands(operands)) {
 1364       if (target_sp->ResolveLoadAddress(base_and_offset.first->m_immediate +
 1368             target_sp->GetScratchTypeSystemForLanguage(eLanguageTypeC);
 1519       frame.GetRegisterContext()->GetRegisterInfoByName(reg.AsCString());
 1534     if (var_sp->LocationExpression().MatchesOperand(frame, op)) {
 1553     if (instruction_sp->IsCall()) {
 1554       ABISP abi_sp = frame.CalculateProcess()->GetABI();
 1560       if (!abi_sp->GetPointerReturnRegister(return_register_name)) {
 1565           frame.GetRegisterContext()->GetRegisterInfoByName(
 1584       if (!instruction_sp->ParseOperands(operands) || operands.size() != 1) {
 1594         if (!frame.CalculateTarget()->ResolveLoadAddress(
 1598         frame.CalculateTarget()->GetImages().ResolveSymbolContextForAddress(
 1609         if (!frame.GetRegisterContext()->ReadRegister(return_register_info,
 1627     if (!instruction_sp->ParseOperands(operands) || operands.size() != 2) {
 1653                                    variables, instruction_sp->GetAddress());
 1664                          variables, instruction_sp->GetAddress());
 1685   const ArchSpec &target_arch = target_sp->GetArchitecture();
 1716   if (!disassembler_sp || !disassembler_sp->GetInstructionList().GetSize()) {
 1770     ProcessSP process_sp(thread_sp->CalculateProcess());
 1772       target_sp = process_sp->CalculateTarget();
 1781     process_sp = thread_sp->CalculateProcess();

tools/lldb/source/Target/StackFrameList.cpp

   44     m_current_inlined_depth = prev_frames_sp->m_current_inlined_depth;
   45     m_current_inlined_pc = prev_frames_sp->m_current_inlined_pc;
   64     lldb::addr_t cur_pc = m_thread.GetRegisterContext()->GetPC();
   89   if (!m_frames[0]->IsInlined()) {
  106   Block *block_ptr = m_frames[0]->GetFrameBlock();
  111   lldb::addr_t curr_pc = m_thread.GetRegisterContext()->GetPC();
  112   pc_as_address.SetLoadAddress(curr_pc, &(m_thread.GetProcess()->GetTarget()));
  130   switch (stop_info_sp->GetStopReason()) {
  148     uint32_t bp_site_id = stop_info_sp->GetValue();
  150         m_thread.GetProcess()->GetBreakpointSiteList().FindByID(bp_site_id));
  153       uint32_t num_owners = bp_site_sp->GetNumberOfOwners();
  155         Breakpoint &bp_ref = bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint();
  155         Breakpoint &bp_ref = bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint();
  217     m_current_inlined_pc = m_thread.GetRegisterContext()->GetPC();
  379   addr_t return_pc = next_reg_ctx_sp->GetPC();
  381   ModuleList &images = next_frame.CalculateTarget()->GetImages();
  464             cfa = reg_ctx_sp->GetSP();
  465             pc = reg_ctx_sp->GetPC();
  475         cfa = unwind_frame_sp->m_id.GetCallFrameAddress();
  500     SymbolContext unwind_sc = unwind_frame_sp->GetSymbolContext(
  504       Address curr_frame_address(unwind_frame_sp->GetFrameCodeAddress());
  534             unwind_frame_sp->GetRegisterContextSP(), cfa, next_frame_address,
  675               frame_sp->GetSymbolContext(eSymbolContextFunction).function;
  679             frame_sp->SetSymbolContextScope(&function->GetBlock(false));
  683             frame_sp->SetSymbolContextScope(
  684                 frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol);
  719     if (frame_sp->GetFrameIndex() == unwind_idx)
  728   return stack_sp->GetStackID() < stack_id;
  744         if ((*pos)->GetStackID() == stack_id)
  750       if (frame_sp && frame_sp->GetStackID() == stack_id)
  805       m_thread.GetProcess()->GetThreadList().GetSelectedThread()->GetID()) {
  805       m_thread.GetProcess()->GetThreadList().GetSelectedThread()->GetID()) {
  808       SymbolContext sc = frame_sp->GetSymbolContext(eSymbolContextLineEntry);
  810         m_thread.CalculateTarget()->GetSourceManager().SetDefaultFileAndLine(
  830     previous_lock = std::unique_lock<std::recursive_mutex>(prev_sp->m_mutex);
  855   if (!prev_sp || prev_sp->GetNumFrames(false) == 0) {
  884   StackFrameSP prev_frame_zero_sp(prev_sp->GetFrameAtIndex(0));
  886   StackID curr_stack_id(curr_frame_zero_sp->GetStackID());
  887   StackID prev_stack_id(prev_frame_zero_sp->GetStackID());
  902     curr_frame_zero_sp->UpdateCurrentFrameFromPreviousFrame(
  912     prev_sp->m_frames.insert(prev_sp->m_frames.begin(), curr_frame_zero_sp);
  912     prev_sp->m_frames.insert(prev_sp->m_frames.begin(), curr_frame_zero_sp);
  981     if (!frame_sp->GetStatus(strm, show_frame_info,

tools/lldb/source/Target/StackFrameRecognizer.cpp

   42   for (const auto o : args->GetObjects()) {
   43     args_synthesized->Append(ValueObjectRecognizerSynthesizedValue::Create(
   73         callback(entry.recognizer_id, entry.recognizer->GetName(), entry.module_regexp->GetText(),
   73         callback(entry.recognizer_id, entry.recognizer->GetName(), entry.module_regexp->GetText(),
   74                  entry.symbol_regexp->GetText(), true);
   76         callback(entry.recognizer_id, entry.recognizer->GetName(), entry.module.GetCString(),
   95         frame->GetSymbolContext(eSymbolContextModule | eSymbolContextFunction);
   99     ConstString module_name = module_sp->GetFileSpec().GetFilename();
  103     Address current_addr = frame->GetFrameCodeAddress();
  111         if (!entry.module_regexp->Execute(module_name.GetStringRef())) continue;
  117         if (!entry.symbol_regexp->Execute(function_name.GetStringRef()))
  131     return recognizer->RecognizeFrame(frame);

tools/lldb/source/Target/StopInfo.cpp

   32       m_stop_id(thread.GetProcess()->GetStopID()),
   33       m_resume_id(thread.GetProcess()->GetResumeID()), m_value(value),
   40     return thread_sp->GetProcess()->GetStopID() == m_stop_id;
   40     return thread_sp->GetProcess()->GetStopID() == m_stop_id;
   47     m_stop_id = thread_sp->GetProcess()->GetStopID();
   47     m_stop_id = thread_sp->GetProcess()->GetStopID();
   48     m_resume_id = thread_sp->GetProcess()->GetResumeID();
   48     m_resume_id = thread_sp->GetProcess()->GetResumeID();
   56     lldb::StateType ret_type = thread_sp->GetProcess()->GetPrivateState();
   56     lldb::StateType ret_type = thread_sp->GetProcess()->GetPrivateState();
   68       uint32_t curr_resume_id = thread_sp->GetProcess()->GetResumeID();
   68       uint32_t curr_resume_id = thread_sp->GetProcess()->GetResumeID();
   70           thread_sp->GetProcess()->GetLastUserExpressionResumeID();
   70           thread_sp->GetProcess()->GetLastUserExpressionResumeID();
  108           thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
  108           thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
  110         if (bp_site_sp->GetNumberOfOwners() == 1) {
  111           BreakpointLocationSP bp_loc_sp = bp_site_sp->GetOwnerAtIndex(0);
  113             m_break_id = bp_loc_sp->GetBreakpoint().GetID();
  114             m_was_one_shot = bp_loc_sp->GetBreakpoint().IsOneShot();
  117         m_address = bp_site_sp->GetLoadAddress();
  126           process_sp->GetBreakpointSiteList().FindByID(m_value));
  128         return bp_site_sp->ValidForThisThread(&thread);
  141             thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
  141             thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
  143           ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
  145           bp_site_sp->BumpHitCounts();
  146           m_should_stop = bp_site_sp->ShouldStop(&context);
  168           thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
  168           thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
  172         for (uint32_t i = 0; i < bp_site_sp->GetNumberOfOwners(); i++) {
  173           if (!bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint().IsInternal()) {
  173           if (!bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint().IsInternal()) {
  189             thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
  189             thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
  194           if (bp_site_sp->IsInternal()) {
  195             size_t num_owners = bp_site_sp->GetNumberOfOwners();
  197               const char *kind = bp_site_sp->GetOwnerAtIndex(idx)
  198                                      ->GetBreakpoint()
  208           bp_site_sp->GetDescription(&strm, eDescriptionLevelBrief);
  214                 thread_sp->GetProcess()->GetTarget().GetBreakpointByID(
  214                 thread_sp->GetProcess()->GetTarget().GetBreakpointByID(
  217               if (break_sp->IsInternal()) {
  218                 const char *kind = break_sp->GetBreakpointKind();
  270       if (!thread_sp->IsValid()) {
  281           thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
  281           thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
  289         size_t num_owners = bp_site_sp->CopyOwnersList(site_locations);
  315           ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
  336             if (thread_sp->CompletedPlanOverridesBreakpoint()) {
  338               thread_sp->ResetStopInfo();
  352                     bp_site_sp->GetOwnerAtIndex(j);
  353                 if (bp_loc_sp->GetBreakpoint().IsInternal()) {
  365             process->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf(
  384             location_owners.push_back(loc->GetBreakpoint().shared_from_this());
  391               bp_loc_sp->GetDescription(&loc_desc, eDescriptionLevelBrief);
  395             if (!bp_loc_sp->IsEnabled() ||
  396                 !bp_loc_sp->GetBreakpoint().IsEnabled())
  402             if (!bp_loc_sp->ValidForThisThread(thread_sp.get())) {
  408                           static_cast<unsigned long long>(thread_sp->GetID()));
  413             internal_breakpoint = bp_loc_sp->GetBreakpoint().IsInternal();
  419                     bp_loc_sp->GetBreakpoint().GetID());
  424                 bp_loc_sp->GetBreakpoint().EvaluatePrecondition(context);
  432             if (bp_loc_sp->GetConditionText() != nullptr) {
  435                   bp_loc_sp->ConditionSaysStop(exe_ctx, condition_error);
  440                 error_sp->Printf("Stopped due to an error evaluating condition "
  442                 bp_loc_sp->GetDescription(error_sp.get(),
  444                 error_sp->Printf(": \"%s\"", bp_loc_sp->GetConditionText());
  444                 error_sp->Printf(": \"%s\"", bp_loc_sp->GetConditionText());
  445                 error_sp->EOL();
  450                 error_sp->PutCString(err_str);
  451                 error_sp->EOL();
  452                 error_sp->Flush();
  458                           static_cast<unsigned long long>(thread_sp->GetID()),
  464                   bp_loc_sp->UndoBumpHitCount();
  477             if (bp_loc_sp->IsAutoContinue())
  485                 thread_sp->SetShouldReportStop(eVoteYes);
  497             Debugger &debugger = thread_sp->CalculateTarget()->GetDebugger();
  497             Debugger &debugger = thread_sp->CalculateTarget()->GetDebugger();
  501             callback_says_stop = bp_loc_sp->InvokeCallback(&context);
  511                 bp_loc_sp->GetBreakpoint().IsOneShot()) {
  512               thread_sp->GetProcess()->GetTarget().RemoveBreakpointByID(
  512               thread_sp->GetProcess()->GetTarget().RemoveBreakpointByID(
  513                   bp_loc_sp->GetBreakpoint().GetID());
  540           thread_sp->CompletedPlanOverridesBreakpoint()) {
  549         thread_sp->CalculatePublicStopInfo();
  585         watchpoint_sp->TurnOnEphemeralMode();
  586         process_sp->DisableWatchpoint(watchpoint_sp.get(), notify);
  587         process_sp->AddPreResumeAction(SentryPreResumeAction, this);
  593         bool was_disabled = watchpoint_sp->IsDisabledDuringEphemeralMode();
  594         watchpoint_sp->TurnOffEphemeralMode();
  597           process_sp->DisableWatchpoint(watchpoint_sp.get(), notify);
  599           process_sp->EnableWatchpoint(watchpoint_sp.get(), notify);
  607             process_sp->ClearPreResumeAction(SentryPreResumeAction, this);
  654           thread_sp->CalculateTarget()->GetWatchpointList().FindByID(
  654           thread_sp->CalculateTarget()->GetWatchpointList().FindByID(
  658         ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
  660         m_should_stop = wp_sp->ShouldStop(&context);
  696           thread_sp->CalculateTarget()->GetWatchpointList().FindByID(
  696           thread_sp->CalculateTarget()->GetWatchpointList().FindByID(
  699         ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
  710             if (process_sp->GetWatchpointSupportInfo(num, wp_triggers_after)
  718                 process_sp->DisableWatchpoint(wp, false);
  719                 StopInfoSP stored_stop_info_sp = thread_sp->GetStopInfo();
  724                     thread_sp->QueueThreadPlanForStepSingleInstruction(
  730                   new_plan_sp->SetIsMasterPlan(true);
  731                   new_plan_sp->SetOkayToDiscard(false);
  732                   new_plan_sp->SetPrivate(true);
  734                 process_sp->GetThreadList().SetSelectedThreadByID(
  735                     thread_sp->GetID());
  736                 process_sp->ResumeSynchronous(nullptr);
  737                 process_sp->GetThreadList().SetSelectedThreadByID(
  738                     thread_sp->GetID());
  739                 thread_sp->SetStopInfo(stored_stop_info_sp);
  740                 process_sp->EnableWatchpoint(wp, false);
  767               thread_sp->CalculateTarget()->GetWatchpointList().FindByAddress(
  767               thread_sp->CalculateTarget()->GetWatchpointList().FindByAddress(
  771             wp_sp->IncrementFalseAlarmsAndReviseHitCount();
  785         if (wp_sp->GetHitCount() <= wp_sp->GetIgnoreCount())
  785         if (wp_sp->GetHitCount() <= wp_sp->GetIgnoreCount())
  790         if (m_should_stop && wp_sp->GetConditionText() != nullptr) {
  801               exe_ctx, expr_options, wp_sp->GetConditionText(),
  828             error_sp->Printf(
  830             wp_sp->GetDescription(error_sp.get(), eDescriptionLevelBrief);
  831             error_sp->Printf(": \"%s\"", wp_sp->GetConditionText());
  831             error_sp->Printf(": \"%s\"", wp_sp->GetConditionText());
  832             error_sp->EOL();
  836             error_sp->PutCString(err_str);
  837             error_sp->EOL();
  838             error_sp->Flush();
  857           bool stop_requested = wp_sp->InvokeCallback(&context);
  873           wp_sp->CaptureWatchedValue(exe_ctx);
  877           wp_sp->DumpSnapshots(output_sp.get());
  878           output_sp->EOL();
  879           output_sp->Flush();
  920       return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
  920       return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
  920       return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
  927       return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
  927       return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
  927       return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
  936           thread_sp->GetProcess()->GetUnixSignals()->GetShouldNotify(m_value);
  936           thread_sp->GetProcess()->GetUnixSignals()->GetShouldNotify(m_value);
  936           thread_sp->GetProcess()->GetUnixSignals()->GetShouldNotify(m_value);
  940             "thread %d received signal: %s", thread_sp->GetIndexID(),
  941             thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(
  941             thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(
  941             thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(
  954       if (!thread_sp->GetProcess()->GetUnixSignals()->GetShouldSuppress(
  954       if (!thread_sp->GetProcess()->GetUnixSignals()->GetShouldSuppress(
  954       if (!thread_sp->GetProcess()->GetUnixSignals()->GetShouldSuppress(
  956         thread_sp->SetResumeSignal(m_value);
  966             thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(
  966             thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(
  966             thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(
 1025       : StopInfo(plan_sp->GetThread(), LLDB_INVALID_UID), m_plan_sp(plan_sp),
 1036       m_plan_sp->GetDescription(&strm, eDescriptionLevelBrief);
 1051       return m_plan_sp->ShouldStop(event_ptr);
 1074       return thread_sp->GetProcess()->GetStopOnExec();
 1074       return thread_sp->GetProcess()->GetStopOnExec();
 1090       thread_sp->GetProcess()->DidExec();
 1090       thread_sp->GetProcess()->DidExec();
 1142       stop_info_sp->GetStopReason() == eStopReasonPlanComplete) {
 1152       stop_info_sp->GetStopReason() == eStopReasonPlanComplete) {
 1167   const char *description = stop_info_sp->GetDescription();
 1172   ThreadSP thread_sp = stop_info_sp->GetThread();
 1177   StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
 1197   return frame_sp->GuessValueForAddress(address);

tools/lldb/source/Target/Target.cpp

  132     if (breakpoint_sp->IsInternal())
  182     if (m_process_sp->IsAlive())
  183       m_process_sp->Destroy(false);
  185     m_process_sp->Finalize();
  486     resolver_sp->SetOffset(offset);
  571     BreakpointPreconditionSP precondition_sp = exc_bkpt_sp->GetPrecondition();
  574         *error = precondition_sp->ConfigurePrecondition(*additional_args);
  576         precondition_sp->ConfigurePrecondition(*additional_args);
  625     resolver_sp->SetBreakpoint(bp_sp.get());
  642     bp_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
  644               __FUNCTION__, bp_sp->IsInternal() ? "yes" : "no", s.GetData());
  647   bp_sp->ResolveBreakpoint();
  677   bp_sp->AddName(name);
  713       bp_sp->RemoveName(name_cstr);
  719   bp_sp->RemoveName(name.AsCString());
  748   return (m_process_sp && m_process_sp->IsAlive());
  753   Status rc = target->GetProcessSP()->GetWatchpointSupportInfo(
  812     size_t old_size = matched_sp->GetByteSize();
  814         (matched_sp->WatchpointRead() ? LLDB_WATCH_TYPE_READ : 0) |
  815         (matched_sp->WatchpointWrite() ? LLDB_WATCH_TYPE_WRITE : 0);
  819       wp_sp->SetEnabled(false, notify);
  822       m_process_sp->DisableWatchpoint(matched_sp.get(), notify);
  823       m_watchpoint_list.Remove(matched_sp->GetID(), true);
  829     wp_sp->SetWatchpointType(kind, notify);
  833   error = m_process_sp->EnableWatchpoint(wp_sp.get(), notify);
  836             wp_sp->GetID());
  841     m_watchpoint_list.Remove(wp_sp->GetID(), true);
  918         if (m_last_created_breakpoint->GetID() == break_id)
  940     bp_sp->SetEnabled(false);
  959     bp_sp->SetEnabled(true);
  984       break_store_ptr = input_data_sp->GetAsArray();
 1074   } else if (!input_data_sp || !input_data_sp->IsValid()) {
 1080   StructuredData::Array *bkpt_array = input_data_sp->GetAsArray();
 1093     StructuredData::Dictionary *bkpt_dict = bkpt_object_sp->GetAsDictionary();
 1114     new_bps.AddBreakpointID(BreakpointID(bkpt_sp->GetID()));
 1144     Status rc = m_process_sp->DisableWatchpoint(wp_sp.get());
 1175     Status rc = m_process_sp->DisableWatchpoint(wp_sp.get());
 1204     Status rc = m_process_sp->EnableWatchpoint(wp_sp.get());
 1222     wp_sp->ResetHitCount();
 1238     wp_sp->ResetHistoricValues();
 1258     wp_sp->SetIgnoreCount(ignore_count);
 1273     Status rc = m_process_sp->DisableWatchpoint(wp_sp.get());
 1292     Status rc = m_process_sp->EnableWatchpoint(wp_sp.get());
 1328     wp_sp->SetIgnoreCount(ignore_count);
 1338     lldb_private::ObjectFile *obj = module_sp->GetObjectFile();
 1356   if (module_sp && !module_sp->LoadScriptingResourceInTarget(
 1362           module_sp->GetFileSpec().GetFileNameStrippingExtension().GetCString(),
 1393                        executable_sp->GetFileSpec().GetPath().c_str());
 1402       m_arch = executable_sp->GetArchitecture();
 1410     ObjectFile *executable_objfile = executable_sp->GetObjectFile();
 1414       load_dependents = executable_sp->IsExecutable();
 1432           m_platform_sp->GetFileWithUUID(dependent_file_spec, nullptr,
 1442           ObjectFile *objfile = image_module_sp->GetObjectFile();
 1466           !platform_sp->IsCompatibleArchitecture(other, false, nullptr)) {
 1527     ModuleSpec module_spec(executable_sp->GetFileSpec(), other);
 1613       m_process_sp->ModulesDidLoad(module_list);
 1623       for (LanguageRuntime *runtime : m_process_sp->GetLanguageRuntimes()) {
 1672       return m_platform_sp->ModuleIsExcludedForUnconstrainedSearches(*this,
 1684     if (section_sp->IsEncrypted()) {
 1688     ModuleSP module_sp(section_sp->GetModule());
 1690       ObjectFile *objfile = section_sp->GetModule()->GetObjectFile();
 1690       ObjectFile *objfile = section_sp->GetModule()->GetObjectFile();
 1698                                          section_sp->GetName().GetCString());
 1758       if (addr_module_sp && addr_module_sp->GetFileSpec())
 1761             addr_module_sp->GetFileSpec(), resolved_addr.GetFileAddress());
 1766       bytes_read = m_process_sp->ReadMemory(load_addr, dst, dst_len, error);
 2001           error = m_platform_sp->GetSharedModule(
 2014       ObjectFile *objfile = module_sp->GetObjectFile();
 2071           module_sp->PreloadSymbols();
 2287     return properties_sp->GetExecutableSearchPaths();
 2294     return properties_sp->GetDebugFileSearchPaths();
 2301     return properties_sp->GetDefaultArchitecture();
 2312     return properties_sp->SetDefaultArchitecture(arch);
 2354     m_process_sp->CalculateExecutionContext(exe_ctx);
 2375     result_valobj_sp = persistent_var_sp->GetValueObject();
 2445     if (!module_sp || !module_sp->GetObjectFile())
 2448     Address entry_addr = module_sp->GetObjectFile()->GetEntryPointAddress();
 2533   (*specified_hook_iter).second->SetIsActive(active_state);
 2540     (*pos).second->SetIsActive(active_state);
 2552   if (m_process_sp->GetState() != eStateStopped)
 2558   if (m_process_sp->GetModIDRef().IsLastResumeForUserExpression())
 2571     if (hook.second->IsActive()) {
 2573       auto_continue |= hook.second->GetAutoContinue();
 2584   ThreadList &cur_threadlist = m_process_sp->GetThreadList();
 2588     if (cur_thread_sp->ThreadStoppedForAReason()) {
 2589       lldb::StackFrameSP cur_frame_sp = cur_thread_sp->GetStackFrameAtIndex(0);
 2593           cur_frame_sp->GetSymbolContext(eSymbolContextEverything));
 2614     if (!cur_hook_sp->IsActive())
 2619       if ((cur_hook_sp->GetSpecifier() == nullptr ||
 2620            cur_hook_sp->GetSpecifier()->SymbolContextMatches(
 2622           (cur_hook_sp->GetThreadSpecifier() == nullptr ||
 2623            cur_hook_sp->GetThreadSpecifier()->ThreadPassesBasicTests(
 2630               (cur_hook_sp->GetCommands().GetSize() == 1
 2631                    ? cur_hook_sp->GetCommands().GetStringAtIndex(0)
 2635                                            cur_hook_sp->GetID(), cmd);
 2638                                            cur_hook_sp->GetID());
 2659             cur_hook_sp->GetCommands(), &exc_ctx_with_reasons[i], options,
 2674                 cur_hook_sp->GetID());
 2683     m_process_sp->PrivateResume();
 2685   result.GetImmediateOutputStream()->Flush();
 2686   result.GetImmediateErrorStream()->Flush();
 2701     if (platform_sp->IsRemote()) {
 2702       if (platform_sp->IsConnected()) {
 2711             FileSpec local_file(module_sp->GetFileSpec());
 2713               FileSpec remote_file(module_sp->GetRemoteInstallFileSpec());
 2719                   remote_file = platform_sp->GetRemoteWorkingDirectory();
 2721                       module_sp->GetFileSpec().GetFilename().GetCString());
 2725                 error = platform_sp->Install(local_file, remote_file);
 2727                   module_sp->SetPlatformFileSpec(remote_file);
 2729                     platform_sp->SetFilePermissions(remote_file, 0700);
 2765       stop_id = process_sp->GetStopID();
 2789     stop_id = process_sp->GetStopID();
 2792   SectionList *sections = module_sp->GetSectionList();
 2808     stop_id = process_sp->GetStopID();
 2819     stop_id = process_sp->GetStopID();
 2844       state = process_sp->GetState();
 2881       platform_sp->CanDebugProcess()) {
 2892         GetPlatform()->DebugProcess(launch_info, debugger, this, error);
 2910       error = m_process_sp->Launch(launch_info);
 2927         m_process_sp->HijackProcessEvents(hijack_listener_sp);
 2930       StateType state = m_process_sp->WaitForProcessToStop(
 2939             m_process_sp->RestoreProcessEvents();
 2940             m_process_sp->ResumeSynchronous(stream);
 2942             m_process_sp->RestoreProcessEvents();
 2943             error = m_process_sp->PrivateResume();
 2954         const int exit_status = m_process_sp->GetExitStatus();
 2955         const char *exit_desc = m_process_sp->GetExitDescription();
 2982     m_process_sp->RestoreProcessEvents();
 2996     state = process_sp->GetState();
 2997     if (process_sp->IsAlive() && state != eStateConnected) {
 3011           old_exec_module_sp->GetPlatformFileSpec().GetFilename();
 3031       platform_sp->CanDebugProcess()) {
 3033     process_sp = platform_sp->Attach(attach_info, GetDebugger(), this, error);
 3048       process_sp->HijackProcessEvents(hijack_listener_sp);
 3049     error = process_sp->Attach(attach_info);
 3054       process_sp->RestoreProcessEvents();
 3056       state = process_sp->WaitForProcessToStop(
 3058       process_sp->RestoreProcessEvents();
 3061         const char *exit_desc = process_sp->GetExitDescription();
 3067         process_sp->Destroy(false);
 3081       m_platform_sp ? m_platform_sp->IsHost() : false;
 3086       platform_sp ? (platform_sp->IsHost() ? "true" : "false") : "n/a",
 3197     m_specifier_sp->GetDescription(s, level);
 3380       : OptionValueProperties(*target_properties_sp->GetValueProperties()),
 3417             Environment env = platform_sp->GetEnvironment();
 3460   m_collection_sp->Initialize(g_experimental_properties);
 3472     m_collection_sp->SetValueChangedCallback(
 3474     m_collection_sp->SetValueChangedCallback(
 3476     m_collection_sp->SetValueChangedCallback(
 3478     m_collection_sp->SetValueChangedCallback(
 3481     m_collection_sp->SetValueChangedCallback(
 3484     m_collection_sp->SetValueChangedCallback(
 3487     m_collection_sp->SetValueChangedCallback(
 3490     m_collection_sp->SetValueChangedCallback(
 3493     m_collection_sp->SetValueChangedCallback(
 3498     m_collection_sp->AppendProperty(
 3518     m_collection_sp->Initialize(g_target_properties);
 3520     m_collection_sp->AppendProperty(
 3525     m_collection_sp->AppendProperty(
 3527         true, Process::GetGlobalProperties()->GetValueProperties());
 3535   const Property *exp_property = m_collection_sp->GetPropertyAtIndex(
 3538       exp_property->GetValue()->GetAsProperties();
 3549       m_collection_sp->GetPropertyAtIndex(exe_ctx, true, ePropertyExperimental);
 3551       exp_property->GetValue()->GetAsProperties();
 3558   const Property *exp_property = m_collection_sp->GetPropertyAtIndex(
 3561       exp_property->GetValue()->GetAsProperties();
 3570   OptionValueArch *value = m_collection_sp->GetPropertyAtIndexAsOptionValueArch(
 3578   OptionValueArch *value = m_collection_sp->GetPropertyAtIndexAsOptionValueArch(
 3586   return m_collection_sp->GetPropertyAtIndexAsBoolean(
 3593       m_collection_sp->GetPropertyAtIndexAsEnumeration(
 3599   return m_collection_sp->SetPropertyAtIndexAsEnumeration(nullptr, idx, d);
 3604   return m_collection_sp->GetPropertyAtIndexAsBoolean(
 3610   m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
 3615   return m_collection_sp->GetPropertyAtIndexAsBoolean(
 3621   m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
 3626   return m_collection_sp->GetPropertyAtIndexAsBoolean(
 3632   m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
 3637   return m_collection_sp->GetPropertyAtIndexAsBoolean(
 3643   m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
 3651       (x86DisassemblyFlavor)m_collection_sp->GetPropertyAtIndexAsEnumeration(
 3659   return (InlineStrategy)m_collection_sp->GetPropertyAtIndexAsEnumeration(
 3665   return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx,
 3671   m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, arg);
 3677   return m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, args);
 3682   m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, args);
 3690   m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, env);
 3697   m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, Args(env));
 3703   return m_collection_sp->GetPropertyAtIndexAsBoolean(
 3710       m_collection_sp->GetPropertyAtIndexAsOptionValuePathMappings(nullptr,
 3719       m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(nullptr,
 3728       m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(nullptr,
 3737       m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(nullptr,
 3746       m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(nullptr,
 3754   return m_collection_sp->GetPropertyAtIndexAsBoolean(
 3760   return m_collection_sp->GetPropertyAtIndexAsBoolean(
 3766   return m_collection_sp->GetPropertyAtIndexAsBoolean(
 3772   return m_collection_sp->GetPropertyAtIndexAsBoolean(
 3778   return m_collection_sp->GetPropertyAtIndexAsBoolean(
 3784   return m_collection_sp->GetPropertyAtIndexAsBoolean(
 3790   return m_collection_sp->GetPropertyAtIndexAsUInt64(
 3796   return m_collection_sp->GetPropertyAtIndexAsSInt64(
 3802   return m_collection_sp->GetPropertyAtIndexAsSInt64(
 3808   return m_collection_sp->GetPropertyAtIndexAsSInt64(
 3814   return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx);
 3819   m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, path);
 3824   return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx);
 3829   m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, path);
 3834   return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx);
 3839   m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, path);
 3844       m_collection_sp->GetPropertyAtIndexAsOptionValueLanguage(
 3854       m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpec(nullptr, false,
 3860           reinterpret_cast<const char *>(data_sp->GetBytes()),
 3861           data_sp->GetByteSize());
 3868   return m_collection_sp->GetPropertyAtIndexAsBoolean(
 3874   return m_collection_sp->GetPropertyAtIndexAsBoolean(
 3880   return m_collection_sp->GetPropertyAtIndexAsBoolean(
 3886   return m_collection_sp->GetPropertyAtIndexAsBoolean(
 3893       m_collection_sp->GetPropertyAtIndexAsEnumeration(
 3899   return (LoadCWDlldbinitFile)m_collection_sp->GetPropertyAtIndexAsEnumeration(
 3906       m_collection_sp->GetPropertyAtIndexAsEnumeration(
 3913       m_collection_sp->GetPropertyAtIndexAsEnumeration(
 3919   return m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, args);
 3924   m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, args);
 3929   return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, false);
 3934   m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
 3939   return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, false);
 3944   m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
 3949   return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, false);
 3954   m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
 3990   return m_collection_sp->GetPropertyAtIndexAsBoolean(
 3996   m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
 4096     m_module_list.GetModuleAtIndex(i)->GetDescription(
 4130   if (GetProcessSP() && GetProcessSP()->CurrentThreadIsPrivateStateThread())

tools/lldb/source/Target/TargetList.cpp

  184                 if (platform_sp->IsCompatibleArchitecture(
  195                    host_platform_sp->GetName() != platform_sp->GetName())) {
  195                    host_platform_sp->GetName() != platform_sp->GetName())) {
  196                 if (host_platform_sp->IsCompatibleArchitecture(
  218               if (platform_ptr->GetName() != the_platform_sp->GetName()) {
  249                 error_strm.PutCString(the_platform_sp->GetName().GetCString());
  266     if (!platform_sp->IsCompatibleArchitecture(arch, false, &platform_arch)) {
  275     if (!platform_sp->IsCompatibleArchitecture(platform_arch, false,
  295   if (!m_dummy_target_sp || !m_dummy_target_sp->IsValid()) {
  332         !platform_sp->IsCompatibleArchitecture(arch, false, nullptr))
  378       error = platform_sp->ResolveExecutable(module_spec, exe_module_sp,
  385       if (exe_module_sp->GetObjectFile() == nullptr) {
  397       target_sp->SetExecutableModule(exe_module_sp, load_dependent_files);
  399         exe_module_sp->GetFileSpec().GetPath(resolved_bundle_exe_path,
  416         target_sp->SetArg0(resolved_bundle_exe_path);
  419         target_sp->SetArg0(file.GetPath().c_str());
  425       target_sp->AppendExecutableSearchPaths(file_dir);
  434       target_sp->PrimeFromDummyTarget(debugger.GetDummyTarget());
  464     Module *exe_module = (*pos)->GetExecutableModulePointer();
  486     Process *process = (*pos)->GetProcessSP().get();
  501       if (process == (*pos)->GetProcessSP().get()) {
  531       Process *process = target_sp->GetProcessSP().get();
  554       process = (*pos)->GetProcessSP().get();
  566       process = target_sp->GetProcessSP().get();

tools/lldb/source/Target/Thread.cpp

  110     m_collection_sp->Initialize(g_thread_properties);
  120   return m_collection_sp->GetPropertyAtIndexAsOptionValueRegex(nullptr, idx);
  126       m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(nullptr,
  134   return m_collection_sp->GetPropertyAtIndexAsBoolean(
  140   return m_collection_sp->GetPropertyAtIndexAsBoolean(
  146   return m_collection_sp->GetPropertyAtIndexAsBoolean(
  152   return m_collection_sp->GetPropertyAtIndexAsUInt64(
  210       frame_sp = thread_sp->GetStackFrameList()->GetFrameWithStackID(
  210       frame_sp = thread_sp->GetStackFrameList()->GetFrameWithStackID(
  263     plan->ThreadDestroyed();
  266     plan->ThreadDestroyed();
  269     plan->ThreadDestroyed();
  299   StackFrameSP frame_sp = stack_frame_list_sp->GetFrameAtIndex(
  300       stack_frame_list_sp->GetSelectedFrameIndex());
  307   uint32_t ret_value = GetStackFrameList()->SetSelectedFrame(frame);
  315   StackFrameSP frame_sp(GetStackFrameList()->GetFrameAtIndex(frame_idx));
  317     GetStackFrameList()->SetSelectedFrame(frame_sp.get());
  319       BroadcastSelectedFrameChange(frame_sp->GetStackID());
  335           frame_sp->GetSymbolContext(eSymbolContextLineEntry));
  336       if (GetProcess()->GetTarget().GetDebugger().GetUseExternalEditor() &&
  345       return frame_sp->GetStatus(output_stream, show_frame_info, show_source);
  354       GetProcess()->GetWarningsOptimization()) {
  357     GetProcess()->PrintWarningOptimization(sc);
  367   const uint32_t stop_id = process_sp ? process_sp->GetStopID() : UINT32_MAX;
  375       m_stop_info_sp ->IsValid() &&
  377   bool have_valid_completed_plan = completed_plan_sp && completed_plan_sp->PlanSucceeded();
  378   bool plan_failed = completed_plan_sp && !completed_plan_sp->PlanSucceeded();
  381     && (m_stop_info_sp->GetStopReason() == eStopReasonTrace);
  405     const uint32_t process_stop_id = process_sp->GetStopID();
  408         if (m_stop_info_sp->IsValid() || IsStillAtLastBreakpointHit() ||
  432                 process_sp->GetTarget().GetArchitecturePlugin())
  443     return stop_info_sp->GetStopReason();
  450     return m_stop_info_stop_id == process_sp->GetStopID();
  465     m_stop_info_sp->MakeStopInfoValid();
  468       m_stop_info_sp->OverrideShouldNotify(m_override_should_notify ==
  474     m_stop_info_stop_id = process_sp->GetStopID();
  480             stop_info_sp ? stop_info_sp->GetDescription() : "<NULL>",
  490       m_stop_info_sp->OverrideShouldNotify(m_override_should_notify ==
  514       lldb::RegisterContextSP reg_ctx_sp(frame_sp->GetRegisterContext());
  515       if (reg_ctx_sp && reg_ctx_sp->ReadAllRegisterValues(*reg_checkpoint_sp))
  525     saved_state.orig_stop_id = process_sp->GetStopID();
  537       lldb::RegisterContextSP reg_ctx_sp(frame_sp->GetRegisterContext());
  540             reg_ctx_sp->WriteAllRegisterValues(*saved_state.register_backup_sp);
  544         reg_ctx_sp->InvalidateIfNeeded(true);
  557     saved_state.stop_info_sp->MakeStopInfoValid();
  559   GetStackFrameList()->SetCurrentInlinedDepth(
  596       const addr_t thread_pc = reg_ctx_sp->GetPC();
  598           GetProcess()->GetBreakpointSiteList().FindByAddress(thread_pc);
  617             step_bp_plan_sp->SetPrivate(true);
  645     backing_thread_sp->SetTemporaryResumeState(resume_state);
  657   const uint32_t process_stop_id = GetProcess()->GetStopID();
  659       (m_stop_info_sp && m_stop_info_sp->IsValid())) {
  732               GetRegisterContext() ? GetRegisterContext()->GetPC()
  742               GetRegisterContext() ? GetRegisterContext()->GetPC()
  760       !private_stop_info->ShouldStopSynchronous(event_ptr)) {
  773   GetStackFrameList()->CalculateCurrentInlinedDepth();
  956     return m_completed_plan_stack.back()->ShouldReportStop(event_ptr);
  994               m_completed_plan_stack.back()->GetName());
  996     return m_completed_plan_stack.back()->ShouldReportRun(event_ptr);
 1017     if (!thread_plan_sp->GetThreadPlanTracer()) {
 1019       thread_plan_sp->SetThreadPlanTracer(
 1020           m_plan_stack.back()->GetThreadPlanTracer());
 1024     thread_plan_sp->DidPush();
 1029       thread_plan_sp->GetDescription(&s, lldb::eDescriptionLevelFull);
 1032                 thread_plan_sp->GetThread().GetID());
 1046                 plan->GetName(), plan->GetThread().GetID());
 1046                 plan->GetName(), plan->GetThread().GetID());
 1049     plan->WillPop();
 1059               plan->GetName(), plan->GetThread().GetID());
 1059               plan->GetName(), plan->GetThread().GetID());
 1062     plan->WillPop();
 1079       if (!completed_plan_sp->GetPrivate())
 1090       return_valobj_sp = m_completed_plan_stack[i]->GetReturnValueObject();
 1103           m_completed_plan_stack[i]->GetExpressionVariable();
 1161   if (!thread_plan_sp->ValidatePlan(&s)) {
 1177   if (!thread_plan_sp->ValidatePlan(&s)) {
 1190     if (m_plan_stack[i]->GetThreadPlanTracer()) {
 1191       m_plan_stack[i]->GetThreadPlanTracer()->EnableTracing(value);
 1191       m_plan_stack[i]->GetThreadPlanTracer()->EnableTracing(value);
 1192       m_plan_stack[i]->GetThreadPlanTracer()->EnableSingleStep(single_stepping);
 1192       m_plan_stack[i]->GetThreadPlanTracer()->EnableSingleStep(single_stepping);
 1200     m_plan_stack[i]->SetThreadPlanTracer(tracer_sp);
 1211     if (plan_sp->GetPrivate())
 1288       if (m_plan_stack[master_plan_idx]->IsMasterPlan()) {
 1289         discard = m_plan_stack[master_plan_idx]->OkayToDiscard();
 1334     if (m_plan_stack[i]->GetKind() == ThreadPlan::eKindCallFunction) {
 1457   if (!thread_plan_sp || !thread_plan_sp->ValidatePlan(nullptr))
 1511   plan->GetDescription(s, desc_level);
 1522     if (include_internal || !plan_sp->GetPrivate()) {
 1576     target_sp = process_sp->CalculateTarget();
 1612   if (m_curr_frames_sp && m_curr_frames_sp->GetAllFramesFetched())
 1621   return GetStackFrameList()->GetFrameWithConcreteFrameIndex(unwind_idx);
 1649   Thread *thread = frame_sp->GetThread().get();
 1650   uint32_t older_frame_idx = frame_sp->GetFrameIndex() + 1;
 1658     lldb::ABISP abi = thread->GetProcess()->GetABI();
 1663     SymbolContext sc = frame_sp->GetSymbolContext(eSymbolContextFunction);
 1685     return_error = abi->SetReturnValueObject(older_frame_sp, return_value_sp);
 1696     lldb::RegisterContextSP reg_ctx_sp(youngest_frame_sp->GetRegisterContext());
 1698       bool copy_success = reg_ctx_sp->CopyFromRegisterContext(
 1699           older_frame_sp->GetRegisterContext());
 1798       frame_sc = frame_sp->GetSymbolContext(eSymbolContextEverything);
 1824   DynamicLoader *loader = GetProcess()->GetDynamicLoader();
 1845   return GetStackFrameList()->GetStackFrameSPForStackFramePtr(stack_frame_ptr);
 1915             frame_sp->GetSymbolContext(eSymbolContextLineEntry));
 1934         (GetID() != GetProcess()->GetThreadList().GetSelectedThread()->GetID()))
 1934         (GetID() != GetProcess()->GetThreadList().GetSelectedThread()->GetID()))
 1939     num_frames_shown = GetStackFrameList()->GetStatus(
 1959       thread_info->Dump(strm);
 1964       StructuredData::ObjectSP stop_info = m_stop_info_sp->GetExtendedInfo();
 1966         stop_info->Dump(strm);
 1976         thread_info->GetObjectForDotSeparatedPath("activity");
 1978         thread_info->GetObjectForDotSeparatedPath("breadcrumb");
 1980         thread_info->GetObjectForDotSeparatedPath("trace_messages");
 1983     if (activity && activity->GetType() == eStructuredDataTypeDictionary) {
 1984       StructuredData::Dictionary *activity_dict = activity->GetAsDictionary();
 1987       if (name && name->GetType() == eStructuredDataTypeString && id &&
 1988           id->GetType() == eStructuredDataTypeInteger) {
 1990                     name->GetAsString()->GetValue(),
 1991                     id->GetAsInteger()->GetValue());
 1996     if (breadcrumb && breadcrumb->GetType() == eStructuredDataTypeDictionary) {
 2000           breadcrumb->GetAsDictionary();
 2004           breadcrumb_text->GetType() == eStructuredDataTypeString) {
 2006                     breadcrumb_text->GetAsString()->GetValue());
 2010     if (messages && messages->GetType() == eStructuredDataTypeArray) {
 2013       StructuredData::Array *messages_array = messages->GetAsArray();
 2019           if (message && message->GetType() == eStructuredDataTypeDictionary) {
 2021                 message->GetAsDictionary();
 2025                 message_text->GetType() == eStructuredDataTypeString) {
 2026               strm.Format("    {0}\n", message_text->GetAsString()->GetValue());
 2040   return GetStackFrameList()->GetStatus(
 2046     const ArchSpec target_arch(CalculateTarget()->GetArchitecture());
 2087     StopReason stop_reason = m_stop_info_sp->GetStopReason();
 2089       uint64_t value = m_stop_info_sp->GetValue();
 2092         lldb::addr_t pc = reg_ctx_sp->GetPC();
 2094             GetProcess()->GetBreakpointSiteList().FindByAddress(pc);
 2095         if (bp_site_sp && static_cast<break_id_t>(value) == bp_site_sp->GetID())
 2116     if (source_step && frame_sp && frame_sp->HasDebugInformation()) {
 2117       SymbolContext sc(frame_sp->GetSymbolContext(eSymbolContextEverything));
 2127     new_plan_sp->SetIsMasterPlan(true);
 2128     new_plan_sp->SetOkayToDiscard(false);
 2150     if (source_step && frame_sp && frame_sp->HasDebugInformation()) {
 2151       SymbolContext sc(frame_sp->GetSymbolContext(eSymbolContextEverything));
 2160     new_plan_sp->SetIsMasterPlan(true);
 2161     new_plan_sp->SetOkayToDiscard(false);
 2184     new_plan_sp->SetIsMasterPlan(true);
 2185     new_plan_sp->SetOkayToDiscard(false);
 2198     if (auto recognized_frame = frame_sp->GetRecognizedFrame())
 2199       if (auto e = recognized_frame->GetExceptionObject())
 2204   for (LanguageRuntime *runtime : GetProcess()->GetLanguageRuntimes()) {
 2219   for (LanguageRuntime *runtime : GetProcess()->GetLanguageRuntimes()) {

tools/lldb/source/Target/ThreadCollection.cpp

   32   const uint32_t thread_index_id = thread_sp->GetIndexID();
   33   if (m_threads.empty() || m_threads.back()->GetIndexID() < thread_index_id)
   39                            return lhs->GetIndexID() < rhs->GetIndexID();
   39                            return lhs->GetIndexID() < rhs->GetIndexID();

tools/lldb/source/Target/ThreadList.cpp

  112     if (m_threads[idx]->GetID() == tid) {
  130     if (m_threads[idx]->GetProtocolID() == tid) {
  148     if (m_threads[idx]->GetID() == tid) {
  168     if (m_threads[idx]->GetProtocolID() == tid) {
  200     if (m_threads[idx]->GetBackingThread() == real_thread) {
  217     if (m_threads[idx]->GetIndexID() == index_id) {
  253       if (thread_sp->GetTemporaryResumeState() != eStateSuspended ||
  254           thread_sp->IsStillAtLastBreakpointHit())
  299     thread_sp->GetStopInfo();
  325     if (thread_sp->GetProcess()->GetStopID() > 1)
  325     if (thread_sp->GetProcess()->GetStopID() > 1)
  328       did_anybody_stop_for_a_reason |= thread_sp->ThreadStoppedForAReason();
  330     const bool thread_should_stop = thread_sp->ShouldStop(event_ptr);
  349       thread_sp->WillStop();
  373     const Vote vote = thread_sp->ShouldReportStop(event_ptr);
  388           thread_sp->GetID(), vote, result);
  404     thread_sp->SetShouldReportStop(vote);
  422     if ((*pos)->GetResumeState() != eStateSuspended) {
  423       switch ((*pos)->ShouldReportRun(event_ptr)) {
  434                   (*pos)->GetIndexID(), (*pos)->GetID());
  434                   (*pos)->GetIndexID(), (*pos)->GetID());
  454     m_threads[idx]->DestroyThread();
  471     (*pos)->RefreshStateAfterStop();
  481     (*pos)->DiscardThreadPlans(true);
  504     lldbassert((*pos)->GetCurrentPlan() &&
  506     if ((*pos)->GetResumeState() != eStateSuspended &&
  507         (*pos)->GetCurrentPlan()->StopOthers()) {
  508       if ((*pos)->IsOperatingSystemPluginThread() &&
  509           !(*pos)->GetBackingThread())
  536     if ((*pos)->GetResumeState() != eStateSuspended &&
  537         (!wants_solo_run || (*pos)->GetCurrentPlan()->StopOthers())) {
  538       if ((*pos)->IsOperatingSystemPluginThread() &&
  539           !(*pos)->GetBackingThread())
  541       (*pos)->SetupForResume();
  556     if (thread_sp->GetResumeState() != eStateSuspended &&
  557         thread_sp->GetCurrentPlan()->StopOthers()) {
  558       if ((*pos)->IsOperatingSystemPluginThread() &&
  559           !(*pos)->GetBackingThread())
  563       assert(thread_sp->GetCurrentPlan()->RunState() != eStateSuspended);
  585       if (thread_sp->GetResumeState() != eStateSuspended)
  586         run_state = thread_sp->GetCurrentPlan()->RunState();
  589       if (!thread_sp->ShouldResume(run_state))
  609         if (!thread_sp->ShouldResume(thread_sp->GetCurrentPlan()->RunState()))
  609         if (!thread_sp->ShouldResume(thread_sp->GetCurrentPlan()->RunState()))
  612         thread_sp->ShouldResume(eStateSuspended);
  626     if (thread_sp->GetResumeState() != eStateSuspended)
  627       thread_sp->DidResume();
  643     if (StateIsRunningState(thread_sp->GetState()))
  644       thread_sp->DidStop();
  654     m_selected_tid = m_threads[0]->GetID();
  665     selected_thread_sp->SetDefaultFileAndLineToSelectedFrame();
  679     m_selected_tid = selected_thread_sp->GetID();
  680     selected_thread_sp->SetDefaultFileAndLineToSelectedFrame();
  692   if (selected_thread_sp->EventTypeHasListeners(
  694     selected_thread_sp->BroadcastEvent(
  718       const lldb::tid_t tid = (*rhs_pos)->GetID();
  722         ThreadSP backing_thread = m_threads[idx]->GetBackingThread();
  723         if (m_threads[idx]->GetID() == tid ||
  724             (backing_thread && backing_thread->GetID() == tid)) {
  730         (*rhs_pos)->DestroyThread();
  739     (*pos)->Flush();
  750     m_tid = thread_sp->GetID();
  751     m_thread_list = &thread_sp->GetProcess()->GetThreadList();
  751     m_thread_list = &thread_sp->GetProcess()->GetThreadList();

tools/lldb/source/Target/ThreadPlan.cpp

  139   if (m_tracer_sp && m_tracer_sp->TracingEnabled() &&
  140       m_tracer_sp->SingleStepEnabled())

tools/lldb/source/Target/ThreadPlanBase.cpp

   41   new_tracer_sp->EnableTracing(m_thread.GetTraceEnabledState());
   63     bool should_notify = stop_info_sp->ShouldNotify(event_ptr);
   80     StopReason reason = stop_info_sp->GetStopReason();
   91       if (stop_info_sp->ShouldStopSynchronous(event_ptr)) {
  108       if (stop_info_sp->ShouldNotify(event_ptr)) {
  129           m_thread.GetID(), stop_info_sp->GetDescription());
  147       if (stop_info_sp->ShouldStop(event_ptr)) {
  152             m_thread.GetID(), stop_info_sp->GetDescription());
  158         if (stop_info_sp->ShouldNotify(event_ptr))

tools/lldb/source/Target/ThreadPlanCallFunction.cpp

   44   abi = process_sp->GetABI().get();
   53   m_function_sp = thread.GetRegisterContext()->GetSP() - abi->GetRedZoneSize();
   57   process_sp->ReadUnsignedIntegerFromMemory(m_function_sp, 4, 0, error);
  191         m_thread.GetStackFrameAtIndex(0)->GetRegisterContext()->GetPC();
  191         m_thread.GetStackFrameAtIndex(0)->GetRegisterContext()->GetPC();
  253   if (m_subplan_sp && m_subplan_sp->PlanExplainsStop(event_ptr)) {
  264     stop_reason = m_real_stop_info_sp->GetStopReason();
  287     uint64_t break_site_id = m_real_stop_info_sp->GetValue();
  290       bp_site_sp = process_sp->GetBreakpointSiteList().FindByID(break_site_id);
  292       uint32_t num_owners = bp_site_sp->GetNumberOfOwners();
  295         Breakpoint &bp = bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint();
  295         Breakpoint &bp = bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint();
  318       m_real_stop_info_sp->OverrideShouldStop(false);
  324       m_real_stop_info_sp->OverrideShouldStop(true);
  341         m_real_stop_info_sp->ShouldStopSynchronous(event_ptr)) {
  381   m_subplan_sp->SetPrivate(true);
  405         process_sp->GetLanguageRuntime(eLanguageTypeC_plus_plus);
  406     m_objc_language_runtime = process_sp->GetLanguageRuntime(eLanguageTypeObjC);
  449       stop_info_sp->OverrideShouldStop(true);
  458   m_subplan_sp->SetStopOthers(new_value);
  467   const ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;

tools/lldb/source/Target/ThreadPlanCallFunctionUsingABI.cpp

   60   const ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;

tools/lldb/source/Target/ThreadPlanCallOnFunctionExit.cpp

   63   if (m_step_out_threadplan_sp && m_step_out_threadplan_sp->IsPlanComplete()) {

tools/lldb/source/Target/ThreadPlanCallUserExpression.cpp

   59     m_user_expression_sp->WillStartExecuting();
   87       m_user_expression_sp->FinalizeJITExecution(
  105         m_thread.GetProcess()->GetDynamicCheckers();
  109       stop_info_sp->SetDescription(s.GetData());
  117   m_user_expression_sp->DidFinishExecuting();

tools/lldb/source/Target/ThreadPlanPython.cpp

   64                                            ->GetTarget()
   83                                            ->GetTarget()
  105                                            ->GetTarget()
  127                                            ->GetTarget()
  163                                            ->GetTarget()

tools/lldb/source/Target/ThreadPlanRunToAddress.cpp

   39       m_thread.CalculateTarget()->GetOpcodeLoadAddress(address));
   51   Target &target = thread.GetProcess()->GetTarget();
   66                      ->CreateBreakpoint(m_addresses[i], true, false)
   81     m_thread.CalculateTarget()->RemoveBreakpointByID(m_break_ids[i]);
  122           m_thread.CalculateTarget()->GetBreakpointByID(m_break_ids[i]).get();
  181         m_thread.CalculateTarget()->RemoveBreakpointByID(m_break_ids[i]);
  193   lldb::addr_t current_address = m_thread.GetRegisterContext()->GetPC();

tools/lldb/source/Target/ThreadPlanShouldStopHere.cpp

   47           m_owner->GetThread().GetRegisterContext()->GetPC(0);

tools/lldb/source/Target/ThreadPlanStepInRange.cpp

  149         m_thread.GetRegisterContext()->GetPC(),
  150         m_thread.CalculateTarget()->GetArchitecture().GetAddressByteSize());
  158   if (m_sub_plan_sp && m_sub_plan_sp->IsPlanComplete()) {
  159     if (!m_sub_plan_sp->PlanSucceeded()) {
  242                   m_sub_plan_sp->GetName());
  260         lldb::addr_t curr_addr = m_thread.GetRegisterContext()->GetPC();
  263         SymbolContext sc = curr_frame->GetSymbolContext(eSymbolContextFunction |
  282           const Architecture *arch = target->GetArchitecturePlugin();
  285             target->GetSectionLoadList().ResolveLoadAddress(curr_addr,
  309     m_sub_plan_sp->SetPrivate(true);
  337     FileSpec frame_library(sc.module_sp->GetFileSpec());
  463       StopReason reason = stop_info_sp->GetStopReason();

tools/lldb/source/Target/ThreadPlanStepInstruction.cpp

   39   m_instruction_addr = m_thread.GetRegisterContext()->GetPC(0);
   41   m_stack_id = start_frame_sp->GetStackID();
   44       start_frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol != nullptr;
   48     m_parent_frame_id = parent_frame_sp->GetStackID();
   90     StopReason reason = stop_info_sp->GetStopReason();
   98   StackID cur_frame_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
  101     uint64_t pc = m_thread.GetRegisterContext()->GetPC(0);
  103         ->GetArchitecture().GetMaximumOpcodeByteSize();
  109     return (m_thread.GetRegisterContext()->GetPC(0) != m_instruction_addr);
  138     StackID cur_frame_zero_id = cur_frame_sp->GetStackID();
  141       if (m_thread.GetRegisterContext()->GetPC(0) != m_instruction_addr) {
  163           if (cur_frame_sp->IsInlined()) {
  168                 parent_frame_sp->GetConcreteFrameIndex() ==
  169                     cur_frame_sp->GetConcreteFrameIndex()) {
  184                 m_thread.GetStackFrameAtIndex(0)->GetRegisterContext()->GetPC();
  184                 m_thread.GetStackFrameAtIndex(0)->GetRegisterContext()->GetPC();
  186                                      ->GetArchitecture()
  189             addr_t return_addr = return_frame->GetRegisterContext()->GetPC();
  191                                        ->GetArchitecture()
  220     lldb::addr_t pc_addr = m_thread.GetRegisterContext()->GetPC(0);

tools/lldb/source/Target/ThreadPlanStepOut.cpp

   50   m_step_from_insn = m_thread.GetRegisterContext()->GetPC(0);
   62   while (return_frame_sp->IsArtificial()) {
   76   m_step_out_to_id = return_frame_sp->GetStackID();
   77   m_immediate_step_from_id = immediate_return_from_sp->GetStackID();
   83   if (immediate_return_from_sp->IsInlined()) {
   92       m_step_out_to_inline_plan_sp->SetPrivate(true);
  102     Address return_address(return_frame_sp->GetFrameCodeAddress());
  118               m_thread.GetProcess()->AdvanceAddressToNextBranchInstruction(
  124         return_address.GetLoadAddress(&m_thread.GetProcess()->GetTarget());
  130                                 ->CreateBreakpoint(m_return_addr, true, false)
  143           immediate_return_from_sp->GetSymbolContext(eSymbolContextFunction);
  180     m_thread.CalculateTarget()->RemoveBreakpointByID(m_return_bp_id);
  222     frame_sp->DumpUsingSettingsFormat(s);
  228     return m_step_out_to_inline_plan_sp->ValidatePlan(error);
  231     return m_step_through_inline_plan_sp->ValidatePlan(error);
  253     return m_step_out_to_inline_plan_sp->MischiefManaged();
  255     if (m_step_through_inline_plan_sp->MischiefManaged()) {
  262     return m_step_out_further_plan_sp->MischiefManaged();
  270     StopReason reason = stop_info_sp->GetStopReason();
  275           m_thread.GetProcess()->GetBreakpointSiteList().FindByID(
  276               stop_info_sp->GetValue()));
  277       if (site_sp && site_sp->IsBreakpointAtThisSite(m_return_bp_id)) {
  280         StackID frame_zero_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
  305         if (site_sp->GetNumberOfOwners() == 1)
  323     if (m_step_out_to_inline_plan_sp->MischiefManaged()) {
  333       return m_step_out_to_inline_plan_sp->ShouldStop(event_ptr);
  335     if (m_step_through_inline_plan_sp->MischiefManaged())
  338       return m_step_through_inline_plan_sp->ShouldStop(event_ptr);
  340     if (m_step_out_further_plan_sp->MischiefManaged())
  343       return m_step_out_further_plan_sp->ShouldStop(event_ptr);
  347     StackID frame_zero_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
  382         m_thread.CalculateTarget()->GetBreakpointByID(m_return_bp_id).get();
  392         m_thread.CalculateTarget()->GetBreakpointByID(m_return_bp_id).get();
  413       m_thread.CalculateTarget()->RemoveBreakpointByID(m_return_bp_id);
  435     immediate_return_from_sp->Dump(&s, true, false);
  439   Block *from_block = immediate_return_from_sp->GetFrameBlock();
  459         m_step_through_inline_plan_sp->SetPrivate(true);
  496       lldb::ABISP abi_sp = m_thread.GetProcess()->GetABI();
  499             abi_sp->GetReturnValueObject(m_thread, return_compiler_type);
  508   StackID frame_zero_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();

tools/lldb/source/Target/ThreadPlanStepOverBreakpoint.cpp

   33   m_breakpoint_addr = m_thread.GetRegisterContext()->GetPC();
   35       m_thread.GetProcess()->GetBreakpointSiteList().FindIDByAddress(
   62     StopReason reason = stop_info_sp->GetStopReason();
   89         lldb::addr_t pc_addr = m_thread.GetRegisterContext()->GetPC();
  123         m_thread.GetProcess()->GetBreakpointSiteList().FindByAddress(
  125     if (bp_site_sp && bp_site_sp->IsEnabled()) {
  126       m_thread.GetProcess()->DisableBreakpointSite(bp_site_sp.get());
  143   lldb::addr_t pc_addr = m_thread.GetRegisterContext()->GetPC();
  164         m_thread.GetProcess()->GetBreakpointSiteList().FindByAddress(
  167       m_thread.GetProcess()->EnableBreakpointSite(bp_site_sp.get());
  184   return m_thread.GetRegisterContext()->GetPC() != m_breakpoint_addr;

tools/lldb/source/Target/ThreadPlanStepOverRange.cpp

  132         m_thread.GetRegisterContext()->GetPC(),
  133         m_thread.CalculateTarget()->GetArchitecture().GetAddressByteSize());
  172           older_frame_sp->GetSymbolContext(eSymbolContextEverything);
  216         sc = frame_sp->GetSymbolContext(eSymbolContextEverything);
  225               Address cur_address = frame_sp->GetFrameCodeAddress();
  282                                                 ->GetRegisterContext()
  283                                                 ->GetPC();
  319     new_plan_sp->SetPrivate(true);
  345     StopReason reason = stop_info_sp->GetStopReason();
  380           Block *frame_block = stack_sp->GetFrameBlock();
  381           lldb::addr_t curr_pc = m_thread.GetRegisterContext()->GetPC();
  384                   curr_pc, m_thread.GetProcess()->GetTarget(), my_range)) {

tools/lldb/source/Target/ThreadPlanStepRange.cpp

   44   m_stack_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
   47     m_parent_stack_id = parent_stack->GetStackID();
  106   lldb::addr_t pc_load_addr = m_thread.GetRegisterContext()->GetPC();
  198   lldb::addr_t cur_pc = m_thread.GetRegisterContext()->GetPC();
  220   StackID cur_frame_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
  230       cur_parent_id = cur_parent_frame->GetStackID();
  273                 ->GetInstructionList()
  279           return &m_instruction_ranges[i]->GetInstructionList();
  291               m_next_branch_bp_sp->GetID());
  292     GetTarget().RemoveBreakpointByID(m_next_branch_bp_sp->GetID());
  308   lldb::addr_t cur_addr = GetThread().GetRegisterContext()->GetPC();
  318     Target &target = GetThread().GetProcess()->GetTarget();
  332         size_t last_inst_size = last_inst->GetOpcode().GetByteSize();
  333         run_to_address = last_inst->GetAddress();
  338           instructions->GetInstructionAtIndex(branch_index)->GetAddress();
  347         if (m_next_branch_bp_sp->IsHardware() &&
  348             !m_next_branch_bp_sp->HasResolvedLocations())
  354               m_next_branch_bp_sp->GetLocationAtIndex(0);
  356             BreakpointSiteSP bp_site = bp_loc->GetBreakpointSite();
  358               bp_site_id = bp_site->GetID();
  364                     m_next_branch_bp_sp->GetID(), bp_site_id,
  366                         &m_thread.GetProcess()->GetTarget()));
  369         m_next_branch_bp_sp->SetThreadID(m_thread.GetID());
  370         m_next_branch_bp_sp->SetBreakpointKind("next-branch-location");
  386   break_id_t bp_site_id = stop_info_sp->GetValue();
  388       m_thread.GetProcess()->GetBreakpointSiteList().FindByID(bp_site_id);
  391   else if (!bp_site_sp->IsBreakpointAtThisSite(m_next_branch_bp_sp->GetID()))
  391   else if (!bp_site_sp->IsBreakpointAtThisSite(m_next_branch_bp_sp->GetID()))
  395     size_t num_owners = bp_site_sp->GetNumberOfOwners();
  402       if (!bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint().IsInternal()) {
  402       if (!bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint().IsInternal()) {
  475       lldb::addr_t addr = m_thread.GetRegisterContext()->GetPC() - 1;

tools/lldb/source/Target/ThreadPlanStepThrough.cpp

   41     m_start_address = GetThread().GetRegisterContext()->GetPC(0);
   50       m_backstop_addr = return_frame_sp->GetFrameCodeAddress().GetLoadAddress(
   54               ->GetTarget()
   82   DynamicLoader *loader = m_thread.GetProcess()->GetDynamicLoader();
   91          m_thread.GetProcess()->GetLanguageRuntimes()) {
  102     lldb::addr_t current_address = GetThread().GetRegisterContext()->GetPC(0);
  105       m_sub_plan_sp->GetDescription(&s, lldb::eDescriptionLevelFull);
  185   if (!m_sub_plan_sp->IsPlanComplete())
  190   if (!m_sub_plan_sp->PlanSucceeded()) {
  226     m_thread.GetProcess()->GetTarget().RemoveBreakpointByID(m_backstop_bkpt_id);
  248   if (stop_info_sp && stop_info_sp->GetStopReason() == eStopReasonBreakpoint) {
  249     break_id_t stop_value = (break_id_t)stop_info_sp->GetValue();
  251         m_thread.GetProcess()->GetBreakpointSiteList().FindByID(stop_value);
  253         cur_site_sp->IsBreakpointAtThisSite(m_backstop_bkpt_id)) {
  255           m_thread.GetStackFrameAtIndex(0)->GetStackID();

tools/lldb/source/Target/ThreadPlanStepUntil.cpp

   41     m_step_from_insn = frame_sp->GetStackID().GetPC();
   50       m_return_addr = return_frame_sp->GetStackID().GetPC();
   52           target_sp->CreateBreakpoint(m_return_addr, true, false).get();
   63     m_stack_id = frame_sp->GetStackID();
   68           target_sp->CreateBreakpoint(address_list[i], true, false).get();
   86       target_sp->RemoveBreakpointByID(m_return_bp_id);
   92       target_sp->RemoveBreakpointByID((*pos).second);
  155     StopReason reason = stop_info_sp->GetStopReason();
  161           m_thread.GetProcess()->GetBreakpointSiteList().FindByID(
  162               stop_info_sp->GetValue());
  168       if (this_site->IsBreakpointAtThisSite(m_return_bp_id)) {
  188         if (this_site->GetNumberOfOwners() == 1)
  197           if (this_site->IsBreakpointAtThisSite((*pos).second)) {
  202                 m_thread.GetStackFrameAtIndex(0)->GetStackID();
  215                     older_frame_sp->GetSymbolContext(eSymbolContextEverything);
  234             if (this_site->GetNumberOfOwners() == 1)
  269   if (!stop_info_sp || stop_info_sp->GetStopReason() == eStopReasonNone)
  286           target_sp->GetBreakpointByID(m_return_bp_id).get();
  293             target_sp->GetBreakpointByID((*pos).second).get();
  309     Breakpoint *return_bp = target_sp->GetBreakpointByID(m_return_bp_id).get();
  315       Breakpoint *until_bp = target_sp->GetBreakpointByID((*pos).second).get();

tools/lldb/source/Target/ThreadPlanTracer.cpp

   49       return &(target_sp->GetDebugger().GetOutputStream());
   61     m_thread.GetStackFrameAtIndex(0)->Dump(stream, show_frame_index,
   71     return (stop_info->GetStopReason() == eStopReasonTrace);
   90         m_thread.GetProcess()->GetTarget().GetArchitecture(), nullptr, nullptr);
   98           target_sp->GetScratchTypeSystemForLanguage(eLanguageTypeC);
  108                 target_sp->GetArchitecture().GetAddressByteSize() * 8));
  139   addr_valid = process_sp->GetTarget().GetSectionLoadList().ResolveLoadAddress(
  149     process_sp->ReadMemory(pc, buffer, sizeof(buffer), err);
  153                               process_sp->GetByteOrder(),
  154                               process_sp->GetAddressByteSize());
  175                 ->GetTarget()
  185   const ABI *abi = process_sp->GetABI().get();

tools/lldb/source/Target/ThreadSpec.cpp

   59     data_dict_sp->AddIntegerItem(GetKey(OptionNames::ThreadIndex), m_index);
   61     data_dict_sp->AddIntegerItem(GetKey(OptionNames::ThreadID), m_tid);
   63     data_dict_sp->AddStringItem(GetKey(OptionNames::ThreadName), m_name);
   65     data_dict_sp->AddStringItem(GetKey(OptionNames::QueueName), m_queue_name);

tools/lldb/source/Utility/Broadcaster.cpp

   51     m_manager_sp->SignUpListenersForBroadcaster(*this);
   78     pair.first->BroadcasterWillDestruct(&m_broadcaster);
  199   event_sp->SetBroadcaster(&m_broadcaster);
  201   const uint32_t event_type = event_sp->GetType();
  216     event_sp->Dump(&event_description);
  226     if (unique && hijacking_listener_sp->PeekAtNextEventForBroadcasterWithType(
  229     hijacking_listener_sp->AddEvent(event_sp);
  234       if (unique && pair.first->PeekAtNextEventForBroadcasterWithType(
  238       pair.first->AddEvent(event_sp);
  270       listener_sp->m_name.c_str(), static_cast<void *>(listener_sp.get()));
  286     return m_hijacking_listeners.back()->GetName();
  301              listener_sp->m_name.c_str(),
  454     (*iter).second->StartListeningForEvents(&broadcaster,
  466     (*iter)->BroadcasterManagerWillDestruct(this->shared_from_this());

tools/lldb/source/Utility/DataEncoder.cpp

  118       const size_t data_size = data_sp->GetByteSize();
  120         m_start = data_sp->GetBytes() + data_offset;

tools/lldb/source/Utility/DataExtractor.cpp

  292       const size_t data_size = data_sp->GetByteSize();
  294         m_start = data_sp->GetBytes() + data_offset;

tools/lldb/source/Utility/Event.cpp

   51     broadcaster = broadcaster_impl_sp->GetBroadcaster();
   74     m_data_sp->Dump(s);
   82     m_data_sp->DoOnRemoval(this);
  214     m_object_sp->Dump(*s);

tools/lldb/source/Utility/Listener.cpp

   66       broadcaster_sp->RemoveListener(this, pos->second.event_mask);
   77       manager_sp->RemoveListener(this);
  180       if ((*pos)->GetBroadcaster() == broadcaster)
  220     return event_sp->BroadcasterIs(m_broadcaster);
  236     if (m_broadcaster && !event_sp->BroadcasterIs(m_broadcaster))
  242           event_sp->GetBroadcaster()->GetBroadcasterName();
  253     return m_event_type_mask == 0 || m_event_type_mask & event_sp->GetType();
  309       event_sp->DoOnRemoval();
  405   Broadcaster *broadcaster = event_sp->GetBroadcaster();
  415     if (event_sp->GetType() & info.event_mask) {
  434       manager_sp->m_manager_mutex);
  437   uint32_t bits_acquired = manager_sp->RegisterListenerForEvents(
  460   return manager_sp->UnregisterListenerForEvents(this->shared_from_this(),

tools/lldb/source/Utility/Log.cpp

  333     stream_sp->flush();
  336     stream_sp->flush();

tools/lldb/source/Utility/StructuredData.cpp

  109         return value->GetObjectForDotSeparatedPath(match.second);
  139     item_sp->Serialize(s);
  164     pair.second->Serialize(s);

tools/lldb/tools/lldb-instr/Instrument.cpp

  351   PCHOpts->registerWriter(std::make_unique<ObjectFilePCHContainerWriter>());
  352   PCHOpts->registerReader(std::make_unique<ObjectFilePCHContainerReader>());

tools/lldb/tools/lldb-test/lldb-test.cpp

  313     P.formatLine("Breakpoint ID {0}:", BP->GetID());
  315     P.formatLine("{0} location{1}.", BP->GetNumLocations(),
  316                  plural(BP->GetNumLocations()));
  317     if (BP->GetNumLocations() > 0)
  319     P.formatLine("{0} resolved location{1}.", BP->GetNumResolvedLocations(),
  320                  plural(BP->GetNumResolvedLocations()));
  321     if (BP->GetNumResolvedLocations() > 0)
  323     for (size_t l = 0, le = BP->GetNumLocations(); l < le; ++l) {
  324       BreakpointLocationSP Loc = BP->GetLocationAtIndex(l);
  325       P.formatLine("Location ID {0}:", Loc->GetID());
  327       P.formatLine("Enabled: {0}", Loc->IsEnabled());
  328       P.formatLine("Resolved: {0}", Loc->IsResolved());
  330       Loc->GetAddress().CalculateSymbolContext(&sc);
  332       sc.DumpStopContext(&S, BP->GetTarget().GetProcessSP().get(),
  333                          Loc->GetAddress(), false, true, false, true, true);
  376       Target->RemoveAllBreakpoints(/*internal_also*/ true);
  388     dumpState(Target->GetBreakpointList(/*internal*/ false), P);
  403   return List.GetVariableAtIndex(0)->GetDeclContext();
  420       cu_sp->FindLineEntry(0, Line, &src_file, false, &le);
  474     cu_sp->FindLineEntry(0, Line, &src_file, false, &le);
  552       if (!Candidate || Candidate->GetFilename().GetStringRef() != File)
  563     List.AddVariables(CU->GetVariableList(true).get());
  656     outs() << "Processing '" << comp_unit->GetFilename().AsCString()
  659     LineTable *lt = comp_unit->GetLineTable();
  809   SymbolFile *Symfile = ModulePtr->GetSymbolFile();
  836     Printer.formatLine("ID: {0:x}", S->GetID());
  837     Printer.formatLine("Name: {0}", S->GetName().GetStringRef());
  838     Printer.formatLine("Type: {0}", S->GetTypeAsCString());
  839     Printer.formatLine("Permissions: {0}", GetPermissionsAsCString(S->GetPermissions()));
  840     Printer.formatLine("Thread specific: {0:y}", S->IsThreadSpecific());
  841     Printer.formatLine("VM address: {0:x}", S->GetFileAddress());
  842     Printer.formatLine("VM size: {0}", S->GetByteSize());
  843     Printer.formatLine("File size: {0}", S->GetFileSize());
  847       S->GetSectionData(Data);
  852     if (S->GetType() == eSectionTypeContainer)
  853       dumpSectionList(Printer, S->GetChildren(), true);
  867     ObjectFile *ObjectPtr = ModulePtr->GetObjectFile();
  876     ModulePtr->GetSymbolFile();
  877     SectionList *Sections = ModulePtr->GetSectionList();
  886                        ModulePtr->GetArchitecture().GetTriple().getTriple());
  887     Printer.formatLine("UUID: {0}", ModulePtr->GetUUID().GetAsString());
  899       auto Obj = ModulePtr->GetObjectFile();
 1031   ProcessSP Process = Target->GetProcessSP();
 1032   if (!Process || !Process->IsAlive() || !Process->CanJIT()) {
 1032   if (!Process || !Process->IsAlive() || !Process->CanJIT()) {
 1085   Dbg->GetCommandInterpreter().HandleCommand(
 1090     Dbg->EnableLog("lldb", {"all"}, opts::Log, 0, errs());

tools/lldb/unittests/Core/MangledTest.cpp

  166     M->FindFunctionSymbols(ConstString(Name), Type, SymList);

tools/lldb/unittests/Disassembler/TestArm64Disassembly.cpp

   66     const InstructionList inst_list (disass_sp->GetInstructionList());
   73     mnemonic = inst_sp->GetMnemonic(&exe_ctx);
   77     mnemonic = inst_sp->GetMnemonic(&exe_ctx);

tools/lldb/unittests/Disassembler/TestArmv7Disassembly.cpp

   74     const InstructionList inst_list (disass_sp->GetInstructionList());
   81     mnemonic = inst_sp->GetMnemonic(&exe_ctx);
   85     mnemonic = inst_sp->GetMnemonic(&exe_ctx);
   89     mnemonic = inst_sp->GetMnemonic(&exe_ctx);

tools/lldb/unittests/Editline/EditlineTest.cpp

  269       _sp_output_thread->join();

tools/lldb/unittests/Expression/DWARFExpressionTest.cpp

   61       : ObjectFile(module_sp, &module_sp->GetFileSpec(), /*file_offset*/ 0,
  146         m_objfile_sp->GetByteOrder(), m_objfile_sp->GetAddressByteSize());
  146         m_objfile_sp->GetByteOrder(), m_objfile_sp->GetAddressByteSize());

tools/lldb/unittests/Host/MainLoopTest.cpp

   75   ASSERT_TRUE(socketpair[0]->Write(&X, len).Success());
   90   ASSERT_TRUE(socketpair[0]->Write(&X, len).Success());
   91   ASSERT_TRUE(socketpair[1]->Write(&X, len).Success());

tools/lldb/unittests/ObjectFile/ELF/TestObjectFileELF.cpp

  111   SectionList *list = module_sp->GetSectionList();
  121   const Symbol *X = module_sp->FindFirstSymbolWithNameAndType(ConstString("X"),
  126   const Symbol *Y = module_sp->FindFirstSymbolWithNameAndType(ConstString("Y"),
  131   const Symbol *start = module_sp->FindFirstSymbolWithNameAndType(
  233   auto entry_point_addr = module_sp->GetObjectFile()->GetEntryPointAddress();
  298   auto entry_point_addr = module_sp->GetObjectFile()->GetEntryPointAddress();

tools/lldb/unittests/ObjectFile/PECOFF/TestPECallFrameInfo.cpp

  204   ObjectFile *object_file = module_sp->GetObjectFile();

tools/lldb/unittests/Process/POSIX/NativeProcessELFTest.cpp

   46       llvm::toStringRef(buffer_sp->GetData()), "");

tools/lldb/unittests/Process/gdb-remote/GDBRemoteClientBaseTest.cpp

   53               listener_sp->StartListeningForEvents(
   70     listener_sp->GetEventForBroadcasterWithType(

tools/lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp

  129             memcmp(buffer_sp->GetBytes(), one_register, sizeof one_register));
  137             memcmp(buffer_sp->GetBytes(), all_registers, sizeof all_registers));
  293   auto dict_sp = object_sp->GetAsDictionary();
  298   dict_sp = object_sp->GetAsDictionary();
  376   custom_params->AddStringItem("tracetech", "intel-pt");
  377   custom_params->AddIntegerItem("psb", 0x01);
  515   ASSERT_EQ(custom_params->GetType(), eStructuredDataTypeDictionary);
  516   ASSERT_TRUE(custom_params->GetValueForKeyAsInteger("psb", psb_value));
  519       custom_params->GetValueForKeyAsString("tracetech", trace_tech_value));

tools/lldb/unittests/Process/minidump/RegisterContextMinidumpTest.cpp

   59   ASSERT_EQ(RegInterface->GetGPRSize(), Buf->GetByteSize());
  120   ASSERT_EQ(RegInterface->GetGPRSize(), Buf->GetByteSize());

tools/lldb/unittests/ScriptInterpreter/Python/PythonDataObjectsTests.cpp

  301   EXPECT_EQ(7U, int_sp->GetValue());
  309   EXPECT_EQ(test_string, string_sp->GetStringValue());
  384             array_sp->GetItemAtIndex(0)->GetType());
  384             array_sp->GetItemAtIndex(0)->GetType());
  386             array_sp->GetItemAtIndex(1)->GetType());
  386             array_sp->GetItemAtIndex(1)->GetType());
  388   auto int_sp = array_sp->GetItemAtIndex(0)->GetAsInteger();
  388   auto int_sp = array_sp->GetItemAtIndex(0)->GetAsInteger();
  389   auto string_sp = array_sp->GetItemAtIndex(1)->GetAsString();
  389   auto string_sp = array_sp->GetItemAtIndex(1)->GetAsString();
  451   EXPECT_EQ(tuple.GetSize(), array_sp->GetSize());
  453             array_sp->GetItemAtIndex(0)->GetType());
  453             array_sp->GetItemAtIndex(0)->GetType());
  455             array_sp->GetItemAtIndex(1)->GetType());
  455             array_sp->GetItemAtIndex(1)->GetType());
  546   EXPECT_EQ(2U, dict_sp->GetSize());
  548   EXPECT_TRUE(dict_sp->HasKey(string_key0));
  549   EXPECT_TRUE(dict_sp->HasKey(string_key1));
  551   auto string_sp = dict_sp->GetValueForKey(string_key0)->GetAsString();
  551   auto string_sp = dict_sp->GetValueForKey(string_key0)->GetAsString();
  552   auto int_sp = dict_sp->GetValueForKey(string_key1)->GetAsInteger();
  552   auto int_sp = dict_sp->GetValueForKey(string_key1)->GetAsInteger();
  616         structured_data_sp->GetAsDictionary();
  623           structured_addr_value_sp->GetIntegerValue(123);

tools/lldb/unittests/Symbol/TestDWARFCallFrameInfo.cpp

  236   SectionList *list = module_sp->GetSectionList();
  245   DWARFCallFrameInfo cfi(*module_sp->GetObjectFile(), section_sp, type);
  247   const Symbol *sym = module_sp->FindFirstSymbolWithNameAndType(

tools/lldb/unittests/Symbol/TestLineEntry.cpp

   69   m_module_sp->ResolveSymbolContextsForFileSpec(file_spec, line, check_inlines,

tools/lldb/unittests/SymbolFile/DWARF/SymbolFileDWARFTests.cpp

   77   SymbolFile *symfile = module->GetSymbolFile();

tools/lldb/unittests/Target/ExecutionContextTest.cpp

   86   Status error = debugger_sp->GetTargetList().CreateTarget(
   89   ASSERT_TRUE(target_sp->GetArchitecture().IsValid());
   93   EXPECT_EQ(target_sp->GetArchitecture().GetByteOrder(),
  108   Status error = debugger_sp->GetTargetList().CreateTarget(
  111   ASSERT_TRUE(target_sp->GetArchitecture().IsValid());
  119   EXPECT_EQ(process_sp->GetByteOrder(), process_ctx.GetByteOrder());

tools/lldb/unittests/Target/ModuleCacheTest.cpp

  132   module_sp->FindFunctionSymbols(ConstString("boom"), eFunctionNameTypeFull,
  136                module_sp->GetPlatformFileSpec().GetCString());
  137   EXPECT_STREQ(module_uuid, module_sp->GetUUID().GetAsString().c_str());

tools/lldb/unittests/UnwindAssembly/ARM64/TestArm64InstEmulation.cpp

   94   EXPECT_EQ(0ull, row_sp->GetOffset());
   95   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
   96   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
   97   EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
  101   EXPECT_EQ(4ull, row_sp->GetOffset());
  102   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
  103   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  104   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
  106   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_fp_arm64, regloc));
  110   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_lr_arm64, regloc));
  116   EXPECT_EQ(8ull, row_sp->GetOffset());
  117   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_fp_arm64);
  118   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  119   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
  121   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_fp_arm64, regloc));
  125   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_lr_arm64, regloc));
  131   EXPECT_EQ(16ull, row_sp->GetOffset());
  132   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
  133   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  134   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
  136   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_fp_arm64, regloc));
  140   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_lr_arm64, regloc));
  146   EXPECT_EQ(20ull, row_sp->GetOffset());
  147   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
  148   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  149   EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
  211   EXPECT_EQ(0ull, row_sp->GetOffset());
  212   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
  213   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  214   EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
  218   EXPECT_EQ(4ull, row_sp->GetOffset());
  219   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
  220   EXPECT_EQ(48, row_sp->GetCFAValue().GetOffset());
  222   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_x21_arm64, regloc));
  226   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_x22_arm64, regloc));
  232   EXPECT_EQ(8ull, row_sp->GetOffset());
  233   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
  234   EXPECT_EQ(48, row_sp->GetCFAValue().GetOffset());
  236   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_x19_arm64, regloc));
  240   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_x20_arm64, regloc));
  247   EXPECT_EQ(12ull, row_sp->GetOffset());
  248   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
  249   EXPECT_EQ(48, row_sp->GetCFAValue().GetOffset());
  251   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_fp_arm64, regloc));
  255   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_lr_arm64, regloc));
  262   EXPECT_EQ(16ull, row_sp->GetOffset());
  263   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_fp_arm64);
  264   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  265   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
  270   EXPECT_EQ(28ull, row_sp->GetOffset());
  271   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
  272   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  273   EXPECT_EQ(48, row_sp->GetCFAValue().GetOffset());
  278   EXPECT_EQ(32ull, row_sp->GetOffset());
  282   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_fp_arm64, regloc));
  285   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_lr_arm64, regloc));
  291   EXPECT_EQ(36ull, row_sp->GetOffset());
  293   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_x19_arm64, regloc));
  296   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_x20_arm64, regloc));
  302   EXPECT_EQ(40ull, row_sp->GetOffset());
  303   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
  304   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  305   EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
  307   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_x21_arm64, regloc));
  310   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_x22_arm64, regloc));
  365   EXPECT_EQ(0ull, row_sp->GetOffset());
  366   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
  367   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  368   EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
  371   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
  372   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  373   EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
  375   EXPECT_FALSE(row_sp->GetRegisterInfo(gpr_x19_arm64, regloc));
  376   EXPECT_FALSE(row_sp->GetRegisterInfo(gpr_x20_arm64, regloc));
  377   EXPECT_FALSE(row_sp->GetRegisterInfo(gpr_x21_arm64, regloc));
  378   EXPECT_FALSE(row_sp->GetRegisterInfo(gpr_x22_arm64, regloc));
  379   EXPECT_FALSE(row_sp->GetRegisterInfo(gpr_x23_arm64, regloc));
  380   EXPECT_FALSE(row_sp->GetRegisterInfo(gpr_x24_arm64, regloc));
  381   EXPECT_FALSE(row_sp->GetRegisterInfo(gpr_x25_arm64, regloc));
  382   EXPECT_FALSE(row_sp->GetRegisterInfo(gpr_x26_arm64, regloc));
  383   EXPECT_FALSE(row_sp->GetRegisterInfo(gpr_x27_arm64, regloc));
  384   EXPECT_FALSE(row_sp->GetRegisterInfo(gpr_x28_arm64, regloc));
  385   EXPECT_FALSE(row_sp->GetRegisterInfo(gpr_fp_arm64, regloc));
  386   EXPECT_FALSE(row_sp->GetRegisterInfo(gpr_lr_arm64, regloc));
  389   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
  390   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  391   EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
  394   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
  395   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  396   EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
  399   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
  400   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  401   EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
  404   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
  405   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  406   EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
  491   EXPECT_EQ(28ull, row_sp->GetOffset());
  492   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_fp_arm64);
  493   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  494   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
  496   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_x20_arm64, regloc));
  501   EXPECT_EQ(28ull, row_sp->GetOffset());
  502   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_fp_arm64);
  503   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  504   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
  506   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_x20_arm64, regloc));
  607   EXPECT_EQ(28ull, row_sp->GetOffset());
  608   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_fp_arm64);
  609   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  610   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
  612   EXPECT_TRUE(row_sp->GetRegisterInfo(fpu_d15_arm64, regloc));
  616   EXPECT_TRUE(row_sp->GetRegisterInfo(fpu_d14_arm64, regloc));
  620   EXPECT_TRUE(row_sp->GetRegisterInfo(fpu_d13_arm64, regloc));
  624   EXPECT_TRUE(row_sp->GetRegisterInfo(fpu_d12_arm64, regloc));
  628   EXPECT_TRUE(row_sp->GetRegisterInfo(fpu_d11_arm64, regloc));
  632   EXPECT_TRUE(row_sp->GetRegisterInfo(fpu_d10_arm64, regloc));
  636   EXPECT_TRUE(row_sp->GetRegisterInfo(fpu_d9_arm64, regloc));
  640   EXPECT_TRUE(row_sp->GetRegisterInfo(fpu_d8_arm64, regloc));
  646   EXPECT_EQ(60ull, row_sp->GetOffset());
  647   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
  648   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  649   EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
  651   if (row_sp->GetRegisterInfo(fpu_d8_arm64, regloc)) {
  654   if (row_sp->GetRegisterInfo(fpu_d9_arm64, regloc)) {
  657   if (row_sp->GetRegisterInfo(fpu_d10_arm64, regloc)) {
  660   if (row_sp->GetRegisterInfo(fpu_d11_arm64, regloc)) {
  663   if (row_sp->GetRegisterInfo(fpu_d12_arm64, regloc)) {
  666   if (row_sp->GetRegisterInfo(fpu_d13_arm64, regloc)) {
  669   if (row_sp->GetRegisterInfo(fpu_d14_arm64, regloc)) {
  672   if (row_sp->GetRegisterInfo(fpu_d15_arm64, regloc)) {
  675   if (row_sp->GetRegisterInfo(gpr_x27_arm64, regloc)) {
  678   if (row_sp->GetRegisterInfo(gpr_x28_arm64, regloc)) {

tools/lldb/unittests/UnwindAssembly/PPC64/TestPPC64InstEmulation.cpp

  100   EXPECT_EQ(0ull, row_sp->GetOffset());
  101   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_r1_ppc64le);
  102   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  103   EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
  107   EXPECT_EQ(16ull, row_sp->GetOffset());
  108   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_r1_ppc64le);
  109   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  110   EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
  112   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_r31_ppc64le, regloc));
  118   EXPECT_EQ(20ull, row_sp->GetOffset());
  119   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_r1_ppc64le);
  120   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  121   EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
  123   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_lr_ppc64le, regloc));
  129   EXPECT_EQ(24ull, row_sp->GetOffset());
  130   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_r1_ppc64le);
  131   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  132   EXPECT_EQ(112, row_sp->GetCFAValue().GetOffset());
  134   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_r31_ppc64le, regloc));
  138   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_lr_ppc64le, regloc));
  144   EXPECT_EQ(28ull, row_sp->GetOffset());
  145   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_r31_ppc64le);
  146   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  147   EXPECT_EQ(112, row_sp->GetCFAValue().GetOffset());
  149   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_r31_ppc64le, regloc));
  153   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_lr_ppc64le, regloc));
  159   EXPECT_EQ(40ull, row_sp->GetOffset());
  160   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_r1_ppc64le);
  161   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  162   EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
  164   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_r31_ppc64le, regloc));
  168   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_lr_ppc64le, regloc));
  212   EXPECT_EQ(0ull, row_sp->GetOffset());
  213   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_r1_ppc64le);
  214   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  215   EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
  219   EXPECT_EQ(8ull, row_sp->GetOffset());
  220   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_r1_ppc64le);
  221   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  222   EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
  224   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_r31_ppc64le, regloc));
  230   EXPECT_EQ(12ull, row_sp->GetOffset());
  231   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_r1_ppc64le);
  232   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  233   EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
  235   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_lr_ppc64le, regloc));
  241   EXPECT_EQ(16ull, row_sp->GetOffset());
  242   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_r30_ppc64le);
  243   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  244   EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
  247   EXPECT_EQ(16ull, row_sp->GetOffset());
  248   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_r30_ppc64le);
  249   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  250   EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
  254   EXPECT_EQ(36ull, row_sp->GetOffset());
  255   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_r1_ppc64le);
  256   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  257   EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());

tools/lldb/unittests/UnwindAssembly/x86/Testx86AssemblyInspectionEngine.cpp

  176   EXPECT_EQ(0ull, row_sp->GetOffset());
  177   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
  178   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  179   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
  181   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
  187   EXPECT_EQ(1ull, row_sp->GetOffset());
  188   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
  189   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  190   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
  192   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
  198   EXPECT_EQ(4ull, row_sp->GetOffset());
  199   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rbp);
  200   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  201   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
  203   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
  209   EXPECT_EQ(7ull, row_sp->GetOffset());
  210   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
  211   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  212   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
  214   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
  252   EXPECT_EQ(0ull, row_sp->GetOffset());
  253   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
  254   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  255   EXPECT_EQ(4, row_sp->GetCFAValue().GetOffset());
  257   EXPECT_TRUE(row_sp->GetRegisterInfo(k_eip, regloc));
  263   EXPECT_EQ(1ull, row_sp->GetOffset());
  264   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
  265   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  266   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
  268   EXPECT_TRUE(row_sp->GetRegisterInfo(k_eip, regloc));
  274   EXPECT_EQ(3ull, row_sp->GetOffset());
  275   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_ebp);
  276   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  277   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
  279   EXPECT_TRUE(row_sp->GetRegisterInfo(k_eip, regloc));
  285   EXPECT_EQ(6ull, row_sp->GetOffset());
  286   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
  287   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  288   EXPECT_EQ(4, row_sp->GetCFAValue().GetOffset());
  290   EXPECT_TRUE(row_sp->GetRegisterInfo(k_eip, regloc));
  393   EXPECT_EQ(17ull, row_sp->GetOffset());
  394   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
  395   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  396   EXPECT_EQ(14496, row_sp->GetCFAValue().GetOffset());
  398   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
  402   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rbp, regloc));
  406   EXPECT_TRUE(row_sp->GetRegisterInfo(k_r15, regloc));
  410   EXPECT_TRUE(row_sp->GetRegisterInfo(k_r14, regloc));
  414   EXPECT_TRUE(row_sp->GetRegisterInfo(k_r13, regloc));
  418   EXPECT_TRUE(row_sp->GetRegisterInfo(k_r12, regloc));
  422   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rbx, regloc));
  431   EXPECT_EQ(34ull, row_sp->GetOffset());
  432   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
  433   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  434   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
  436   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
  444   EXPECT_FALSE(row_sp->GetRegisterInfo(k_rax, regloc));
  445   EXPECT_FALSE(row_sp->GetRegisterInfo(k_rbx, regloc));
  446   EXPECT_FALSE(row_sp->GetRegisterInfo(k_rcx, regloc));
  447   EXPECT_FALSE(row_sp->GetRegisterInfo(k_rdx, regloc));
  448   EXPECT_FALSE(row_sp->GetRegisterInfo(k_rbp, regloc));
  449   EXPECT_FALSE(row_sp->GetRegisterInfo(k_rsi, regloc));
  450   EXPECT_FALSE(row_sp->GetRegisterInfo(k_rdi, regloc));
  451   EXPECT_FALSE(row_sp->GetRegisterInfo(k_r8, regloc));
  452   EXPECT_FALSE(row_sp->GetRegisterInfo(k_r9, regloc));
  453   EXPECT_FALSE(row_sp->GetRegisterInfo(k_r10, regloc));
  454   EXPECT_FALSE(row_sp->GetRegisterInfo(k_r11, regloc));
  455   EXPECT_FALSE(row_sp->GetRegisterInfo(k_r12, regloc));
  456   EXPECT_FALSE(row_sp->GetRegisterInfo(k_r13, regloc));
  457   EXPECT_FALSE(row_sp->GetRegisterInfo(k_r14, regloc));
  458   EXPECT_FALSE(row_sp->GetRegisterInfo(k_r15, regloc));
  662   EXPECT_EQ(10ull, row_sp->GetOffset());
  663   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
  664   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  665   EXPECT_EQ(14464, row_sp->GetCFAValue().GetOffset());
  670   EXPECT_EQ(15ull, row_sp->GetOffset());
  671   EXPECT_EQ(14468, row_sp->GetCFAValue().GetOffset());
  676   EXPECT_EQ(16ull, row_sp->GetOffset());
  677   EXPECT_EQ(14464, row_sp->GetCFAValue().GetOffset());
  681   EXPECT_TRUE(row_sp->GetRegisterInfo(k_eip, regloc));
  685   EXPECT_TRUE(row_sp->GetRegisterInfo(k_ebp, regloc));
  689   EXPECT_TRUE(row_sp->GetRegisterInfo(k_ebx, regloc));
  693   EXPECT_TRUE(row_sp->GetRegisterInfo(k_edi, regloc));
  697   EXPECT_TRUE(row_sp->GetRegisterInfo(k_esi, regloc));
  707   EXPECT_EQ(23ull, row_sp->GetOffset());
  708   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
  709   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  710   EXPECT_EQ(14472, row_sp->GetCFAValue().GetOffset());
  715   EXPECT_EQ(24ull, row_sp->GetOffset());
  716   EXPECT_EQ(14476, row_sp->GetCFAValue().GetOffset());
  721   EXPECT_EQ(28ull, row_sp->GetOffset());
  722   EXPECT_EQ(14480, row_sp->GetCFAValue().GetOffset());
  727   EXPECT_EQ(36ull, row_sp->GetOffset());
  728   EXPECT_EQ(14464, row_sp->GetCFAValue().GetOffset());
  734   EXPECT_EQ(47ull, row_sp->GetOffset());
  735   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
  736   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  737   EXPECT_EQ(4, row_sp->GetCFAValue().GetOffset());
  739   EXPECT_TRUE(row_sp->GetRegisterInfo(k_eip, regloc));
  743   EXPECT_TRUE(row_sp->GetRegisterInfo(k_esp, regloc));
  749   EXPECT_FALSE(row_sp->GetRegisterInfo(k_eax, regloc));
  750   EXPECT_FALSE(row_sp->GetRegisterInfo(k_ebx, regloc));
  751   EXPECT_FALSE(row_sp->GetRegisterInfo(k_ecx, regloc));
  752   EXPECT_FALSE(row_sp->GetRegisterInfo(k_edx, regloc));
  753   EXPECT_FALSE(row_sp->GetRegisterInfo(k_esi, regloc));
  754   EXPECT_FALSE(row_sp->GetRegisterInfo(k_edi, regloc));
  755   EXPECT_FALSE(row_sp->GetRegisterInfo(k_ebp, regloc));
  813   EXPECT_EQ(1ull, row_sp->GetOffset());
  814   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
  815   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  816   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
  818   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
  824   EXPECT_FALSE(row_sp->GetRegisterInfo(k_rax, regloc));
  825   EXPECT_FALSE(row_sp->GetRegisterInfo(k_rbx, regloc));
  826   EXPECT_FALSE(row_sp->GetRegisterInfo(k_rcx, regloc));
  827   EXPECT_FALSE(row_sp->GetRegisterInfo(k_rdx, regloc));
  828   EXPECT_FALSE(row_sp->GetRegisterInfo(k_rbp, regloc));
  829   EXPECT_FALSE(row_sp->GetRegisterInfo(k_rsi, regloc));
  830   EXPECT_FALSE(row_sp->GetRegisterInfo(k_rdi, regloc));
  831   EXPECT_FALSE(row_sp->GetRegisterInfo(k_r8, regloc));
  832   EXPECT_FALSE(row_sp->GetRegisterInfo(k_r9, regloc));
  833   EXPECT_FALSE(row_sp->GetRegisterInfo(k_r10, regloc));
  834   EXPECT_FALSE(row_sp->GetRegisterInfo(k_r11, regloc));
  835   EXPECT_FALSE(row_sp->GetRegisterInfo(k_r12, regloc));
  836   EXPECT_FALSE(row_sp->GetRegisterInfo(k_r13, regloc));
  837   EXPECT_FALSE(row_sp->GetRegisterInfo(k_r14, regloc));
  838   EXPECT_FALSE(row_sp->GetRegisterInfo(k_r15, regloc));
  845   EXPECT_EQ(22ull, row_sp->GetOffset());
  846   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
  847   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  848   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
  850   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
  922   EXPECT_EQ(3ull, row_sp->GetOffset());
  923   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
  924   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  925   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
  931   EXPECT_EQ(8ull, row_sp->GetOffset());
  932   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
  933   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  934   EXPECT_EQ(20, row_sp->GetCFAValue().GetOffset());
  940   EXPECT_EQ(9ull, row_sp->GetOffset());
  941   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
  942   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  943   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
  947   EXPECT_FALSE(row_sp->GetRegisterInfo(k_eax, regloc));
  948   EXPECT_FALSE(row_sp->GetRegisterInfo(k_ebx, regloc));
  949   EXPECT_FALSE(row_sp->GetRegisterInfo(k_ecx, regloc));
  950   EXPECT_FALSE(row_sp->GetRegisterInfo(k_edx, regloc));
  951   EXPECT_FALSE(row_sp->GetRegisterInfo(k_esi, regloc));
  952   EXPECT_FALSE(row_sp->GetRegisterInfo(k_edi, regloc));
  953   EXPECT_FALSE(row_sp->GetRegisterInfo(k_ebp, regloc));
  959   EXPECT_EQ(34ull, row_sp->GetOffset());
  960   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
  961   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  962   EXPECT_EQ(4, row_sp->GetCFAValue().GetOffset());
  983   EXPECT_EQ(1ull, row_sp->GetOffset());
  984   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
  985   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
  986   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
  988   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rbp, regloc));
  998   EXPECT_EQ(1ull, row_sp->GetOffset());
  999   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1000   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1001   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 1003   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rbp, regloc));
 1026   EXPECT_EQ(5ull, row_sp->GetOffset());
 1027   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1028   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1029   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
 1032   EXPECT_EQ(7ull, row_sp->GetOffset());
 1033   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1034   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1035   EXPECT_EQ(24, row_sp->GetCFAValue().GetOffset());
 1042   EXPECT_EQ(5ull, row_sp->GetOffset());
 1043   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1044   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1045   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 1048   EXPECT_EQ(7ull, row_sp->GetOffset());
 1049   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1050   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1051   EXPECT_EQ(12, row_sp->GetCFAValue().GetOffset());
 1076   EXPECT_EQ(0ull, row_sp->GetOffset());
 1085   EXPECT_EQ(0ull, row_sp->GetOffset());
 1108   EXPECT_EQ(4ull, row_sp->GetOffset());
 1109   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1110   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1111   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
 1118   EXPECT_EQ(4ull, row_sp->GetOffset());
 1119   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1120   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1121   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 1124   EXPECT_EQ(10ull, row_sp->GetOffset());
 1125   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1126   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1127   EXPECT_EQ(12, row_sp->GetCFAValue().GetOffset());
 1130   EXPECT_EQ(12ull, row_sp->GetOffset());
 1131   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1132   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1133   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
 1154   EXPECT_EQ(2ull, row_sp->GetOffset());
 1155   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1156   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1157   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
 1159   EXPECT_TRUE(row_sp->GetRegisterInfo(k_r15, regloc));
 1182   EXPECT_EQ(2ull, row_sp->GetOffset());
 1183   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1184   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1185   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
 1187   EXPECT_TRUE(row_sp->GetRegisterInfo(k_r14, regloc));
 1210   EXPECT_EQ(2ull, row_sp->GetOffset());
 1211   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1212   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1213   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
 1215   EXPECT_TRUE(row_sp->GetRegisterInfo(k_r13, regloc));
 1238   EXPECT_EQ(2ull, row_sp->GetOffset());
 1239   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1240   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1241   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
 1243   EXPECT_TRUE(row_sp->GetRegisterInfo(k_r12, regloc));
 1266   EXPECT_EQ(1ull, row_sp->GetOffset());
 1267   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1268   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1269   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
 1271   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rbx, regloc));
 1297   EXPECT_EQ(1ull, row_sp->GetOffset());
 1298   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
 1299   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1300   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 1302   EXPECT_FALSE(row_sp->GetRegisterInfo(k_eax, regloc));
 1326   EXPECT_EQ(1ull, row_sp->GetOffset());
 1327   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
 1328   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1329   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 1331   EXPECT_FALSE(row_sp->GetRegisterInfo(k_ecx, regloc));
 1355   EXPECT_EQ(1ull, row_sp->GetOffset());
 1356   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
 1357   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1358   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 1360   EXPECT_FALSE(row_sp->GetRegisterInfo(k_edx, regloc));
 1381   EXPECT_EQ(1ull, row_sp->GetOffset());
 1382   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
 1383   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1384   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 1386   EXPECT_TRUE(row_sp->GetRegisterInfo(k_ebx, regloc));
 1409   EXPECT_EQ(1ull, row_sp->GetOffset());
 1410   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
 1411   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1412   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 1414   EXPECT_TRUE(row_sp->GetRegisterInfo(k_ebp, regloc));
 1437   EXPECT_EQ(2ull, row_sp->GetOffset());
 1438   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1439   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1440   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
 1442   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rbp, regloc));
 1465   EXPECT_EQ(1ull, row_sp->GetOffset());
 1466   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
 1467   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1468   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 1470   EXPECT_TRUE(row_sp->GetRegisterInfo(k_esi, regloc));
 1493   EXPECT_EQ(1ull, row_sp->GetOffset());
 1494   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
 1495   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1496   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 1498   EXPECT_TRUE(row_sp->GetRegisterInfo(k_edi, regloc));
 1521   EXPECT_EQ(3ull, row_sp->GetOffset());
 1522   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rbp);
 1523   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1524   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 1537   EXPECT_EQ(3ull, row_sp->GetOffset());
 1538   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rbp);
 1539   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1540   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 1553   EXPECT_EQ(2ull, row_sp->GetOffset());
 1554   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_ebp);
 1555   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1556   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 1569   EXPECT_EQ(2ull, row_sp->GetOffset());
 1570   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_ebp);
 1571   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1572   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 1593   EXPECT_EQ(7ull, row_sp->GetOffset());
 1594   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1595   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1596   EXPECT_EQ(264, row_sp->GetCFAValue().GetOffset());
 1609   EXPECT_EQ(4ull, row_sp->GetOffset());
 1610   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1611   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1612   EXPECT_EQ(24, row_sp->GetCFAValue().GetOffset());
 1633   EXPECT_EQ(6ull, row_sp->GetOffset());
 1634   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1635   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1636   EXPECT_EQ(260, row_sp->GetCFAValue().GetOffset());
 1649   EXPECT_EQ(3ull, row_sp->GetOffset());
 1650   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1651   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1652   EXPECT_EQ(20, row_sp->GetCFAValue().GetOffset());
 1673   EXPECT_EQ(7ull, row_sp->GetOffset());
 1674   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1675   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1676   EXPECT_EQ(8 - 256, row_sp->GetCFAValue().GetOffset());
 1689   EXPECT_EQ(4ull, row_sp->GetOffset());
 1690   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1691   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1692   EXPECT_EQ(8 - 16, row_sp->GetCFAValue().GetOffset());
 1713   EXPECT_EQ(6ull, row_sp->GetOffset());
 1714   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1715   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1716   EXPECT_EQ(4 - 256, row_sp->GetCFAValue().GetOffset());
 1729   EXPECT_EQ(3ull, row_sp->GetOffset());
 1730   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1731   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1732   EXPECT_EQ(4 - 16, row_sp->GetCFAValue().GetOffset());
 1756   EXPECT_EQ(2ull, row_sp->GetOffset());
 1757   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1758   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1759   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 1760   EXPECT_FALSE(row_sp->GetRegisterInfo(k_rbx, regloc));
 1782   EXPECT_EQ(2ull, row_sp->GetOffset());
 1783   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1784   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1785   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 1786   EXPECT_FALSE(row_sp->GetRegisterInfo(k_rbp, regloc));
 1808   EXPECT_EQ(4ull, row_sp->GetOffset());
 1809   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1810   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1811   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 1812   EXPECT_FALSE(row_sp->GetRegisterInfo(k_r12, regloc));
 1834   EXPECT_EQ(4ull, row_sp->GetOffset());
 1835   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1836   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1837   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 1838   EXPECT_FALSE(row_sp->GetRegisterInfo(k_r13, regloc));
 1860   EXPECT_EQ(4ull, row_sp->GetOffset());
 1861   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1862   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1863   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 1864   EXPECT_FALSE(row_sp->GetRegisterInfo(k_r14, regloc));
 1886   EXPECT_EQ(4ull, row_sp->GetOffset());
 1887   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1888   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1889   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 1890   EXPECT_FALSE(row_sp->GetRegisterInfo(k_r15, regloc));
 1912   EXPECT_EQ(2ull, row_sp->GetOffset());
 1913   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1914   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1915   EXPECT_EQ(4, row_sp->GetCFAValue().GetOffset());
 1916   EXPECT_FALSE(row_sp->GetRegisterInfo(k_ebx, regloc));
 1938   EXPECT_EQ(2ull, row_sp->GetOffset());
 1939   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1940   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1941   EXPECT_EQ(4, row_sp->GetCFAValue().GetOffset());
 1942   EXPECT_FALSE(row_sp->GetRegisterInfo(k_ebp, regloc));
 1964   EXPECT_EQ(4ull, row_sp->GetOffset());
 1965   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1966   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1967   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 1968   EXPECT_FALSE(row_sp->GetRegisterInfo(k_rbp, regloc));
 1990   EXPECT_EQ(2ull, row_sp->GetOffset());
 1991   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 1992   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 1993   EXPECT_EQ(4, row_sp->GetCFAValue().GetOffset());
 1994   EXPECT_FALSE(row_sp->GetRegisterInfo(k_esi, regloc));
 2016   EXPECT_EQ(2ull, row_sp->GetOffset());
 2017   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 2018   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2019   EXPECT_EQ(4, row_sp->GetCFAValue().GetOffset());
 2020   EXPECT_FALSE(row_sp->GetRegisterInfo(k_edi, regloc));
 2051   EXPECT_EQ(4ull, row_sp->GetOffset());
 2052   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 2053   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2054   EXPECT_EQ(20, row_sp->GetCFAValue().GetOffset());
 2057   EXPECT_EQ(7ull, row_sp->GetOffset());
 2058   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 2059   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2060   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 2083   EXPECT_EQ(2ull, row_sp->GetOffset());
 2084   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 2085   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2086   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 2087   EXPECT_FALSE(row_sp->GetRegisterInfo(k_rbp, regloc));
 2093   EXPECT_EQ(2ull, row_sp->GetOffset());
 2094   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 2095   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2096   EXPECT_EQ(4, row_sp->GetCFAValue().GetOffset());
 2097   EXPECT_FALSE(row_sp->GetRegisterInfo(k_ebp, regloc));
 2122   EXPECT_EQ(5ull, row_sp->GetOffset());
 2123   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 2124   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2125   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 2126   EXPECT_FALSE(row_sp->GetRegisterInfo(k_ebp, regloc));
 2151   EXPECT_EQ(19ull, row_sp->GetOffset());
 2152   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rbp);
 2153   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
 2155   EXPECT_TRUE(row_sp->GetRegisterInfo(k_r14, regloc));
 2159   EXPECT_TRUE(row_sp->GetRegisterInfo(k_r15, regloc));
 2163   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rbx, regloc));
 2189   EXPECT_EQ(12ull, row_sp->GetOffset());
 2190   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rbp);
 2191   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 2193   EXPECT_TRUE(row_sp->GetRegisterInfo(k_ebx, regloc));
 2197   EXPECT_TRUE(row_sp->GetRegisterInfo(k_esi, regloc));
 2236   row_sp->SetOffset(0);
 2237   row_sp->GetCFAValue().SetIsRegisterPlusOffset(k_rsp, 8);
 2240   row_sp->SetRegisterInfo(k_rip, regloc);
 2250   row_sp->SetOffset(1);
 2251   row_sp->GetCFAValue().SetIsRegisterPlusOffset(k_rsp, 16);
 2253   row_sp->SetRegisterInfo(k_rbp, regloc);
 2262   row_sp->SetOffset(4);
 2263   row_sp->GetCFAValue().SetIsRegisterPlusOffset(k_rsp, 16);
 2273   EXPECT_EQ(4ull, row_sp->GetOffset());
 2277   EXPECT_EQ(12ull, row_sp->GetOffset());
 2278   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 2279   EXPECT_EQ(152, row_sp->GetCFAValue().GetOffset());
 2283   EXPECT_EQ(12ull, row_sp->GetOffset());
 2288   EXPECT_EQ(20ull, row_sp->GetOffset());
 2289   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 2290   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
 2323   row_sp->SetOffset(0);
 2324   row_sp->GetCFAValue().SetIsRegisterPlusOffset(k_rsp, 8);
 2327   row_sp->SetRegisterInfo(k_rip, regloc);
 2337   row_sp->SetOffset(1);
 2338   row_sp->GetCFAValue().SetIsRegisterPlusOffset(k_rsp, 16);
 2340   row_sp->SetRegisterInfo(k_rbp, regloc);
 2349   row_sp->SetOffset(4);
 2350   row_sp->GetCFAValue().SetIsRegisterPlusOffset(k_rbp, 16);
 2358   EXPECT_EQ(6ull, row_sp->GetOffset());
 2359   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 2360   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 2401   row_sp->SetOffset(0);
 2402   row_sp->GetCFAValue().SetIsRegisterPlusOffset(k_esp, 4);
 2405   row_sp->SetRegisterInfo(k_eip, regloc);
 2415   row_sp->SetOffset(1);
 2416   row_sp->GetCFAValue().SetIsRegisterPlusOffset(k_esp, 8);
 2418   row_sp->SetRegisterInfo(k_ebp, regloc);
 2427   row_sp->SetOffset(3);
 2428   row_sp->GetCFAValue().SetIsRegisterPlusOffset(k_ebp, 8);
 2436   EXPECT_EQ(5ull, row_sp->GetOffset());
 2437   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
 2438   EXPECT_EQ(4, row_sp->GetCFAValue().GetOffset());
 2473   EXPECT_EQ(2ull, row_sp->GetOffset());
 2474   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
 2475   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2476   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 2478   EXPECT_TRUE(row_sp->GetRegisterInfo(k_ebp, regloc));
 2488   EXPECT_EQ(0ull, row_sp->GetOffset());
 2489   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 2490   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2491   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 2493   EXPECT_FALSE(row_sp->GetRegisterInfo(k_rbp, regloc));
 2521   EXPECT_EQ(esp_plus_4, plan.GetRowForFunctionOffset(0)->GetCFAValue());
 2522   EXPECT_EQ(esp_plus_8, plan.GetRowForFunctionOffset(1)->GetCFAValue());
 2524     EXPECT_EQ(ebp_plus_8, plan.GetRowForFunctionOffset(i)->GetCFAValue())
 2527             plan.GetRowForFunctionOffset(sizeof(data) - 1)->GetCFAValue());
 2555   EXPECT_EQ(rsp_plus_8, plan.GetRowForFunctionOffset(0)->GetCFAValue());
 2556   EXPECT_EQ(rsp_plus_16, plan.GetRowForFunctionOffset(1)->GetCFAValue());
 2558     EXPECT_EQ(rbp_plus_16, plan.GetRowForFunctionOffset(i)->GetCFAValue())
 2561             plan.GetRowForFunctionOffset(sizeof(data) - 1)->GetCFAValue());
 2599   EXPECT_EQ(esp_plus_4, plan.GetRowForFunctionOffset(0)->GetCFAValue());
 2600   EXPECT_EQ(esp_plus_8, plan.GetRowForFunctionOffset(1)->GetCFAValue());
 2602     EXPECT_EQ(ebx_plus_8, plan.GetRowForFunctionOffset(i)->GetCFAValue())
 2604   EXPECT_EQ(esp_plus_4, plan.GetRowForFunctionOffset(33)->GetCFAValue());
 2607   EXPECT_EQ(esp_plus_0, plan.GetRowForFunctionOffset(12)->GetAFAValue());
 2608   EXPECT_EQ(esp_minus_4, plan.GetRowForFunctionOffset(15)->GetAFAValue());
 2609   EXPECT_EQ(esp_plus_0, plan.GetRowForFunctionOffset(16)->GetAFAValue());
 2611     EXPECT_EQ(ebp_plus_0, plan.GetRowForFunctionOffset(i)->GetAFAValue())
 2613   EXPECT_EQ(esp_minus_4, plan.GetRowForFunctionOffset(30)->GetAFAValue());
 2618       plan.GetRowForFunctionOffset(27)->GetRegisterInfo(k_edi, reg_loc));
 2698   EXPECT_EQ(0ull, row_sp->GetOffset());
 2699   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 2700   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2701   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 2703   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
 2709   EXPECT_EQ(1ull, row_sp->GetOffset());
 2710   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 2711   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2712   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
 2714   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
 2720   EXPECT_EQ(4ull, row_sp->GetOffset());
 2721   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rbp);
 2722   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2723   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
 2725   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
 2731   EXPECT_EQ(7ull, row_sp->GetOffset());
 2732   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 2733   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2734   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 2736   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
 2742   EXPECT_EQ(8ull, row_sp->GetOffset());
 2743   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rbp);
 2744   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2745   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
 2747   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
 2753   EXPECT_EQ(11ull, row_sp->GetOffset());
 2754   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 2755   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2756   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 2758   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
 2764   EXPECT_EQ(12ull, row_sp->GetOffset());
 2765   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rbp);
 2766   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2767   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
 2769   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
 2775   EXPECT_EQ(15ull, row_sp->GetOffset());
 2776   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 2777   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2778   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 2780   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
 2786   EXPECT_EQ(18ull, row_sp->GetOffset());
 2787   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rbp);
 2788   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2789   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
 2791   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
 2797   EXPECT_EQ(21ull, row_sp->GetOffset());
 2798   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 2799   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2800   EXPECT_EQ(8, row_sp->GetCFAValue().GetOffset());
 2802   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
 2808   EXPECT_EQ(24ull, row_sp->GetOffset());
 2809   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rbp);
 2810   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2811   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
 2813   EXPECT_TRUE(row_sp->GetRegisterInfo(k_rip, regloc));
 2863   EXPECT_EQ(16ull, row_sp->GetOffset());
 2864   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
 2865   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2866   EXPECT_EQ(wordsize, row_sp->GetCFAValue().GetOffset());
 2872   EXPECT_EQ(18ull, row_sp->GetOffset());
 2873   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_ebp);
 2874   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2875   EXPECT_EQ(wordsize * 2, row_sp->GetCFAValue().GetOffset());
 2881   EXPECT_EQ(27ull, row_sp->GetOffset());
 2882   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_ebp);
 2883   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2884   EXPECT_EQ(wordsize * 2, row_sp->GetCFAValue().GetOffset());
 2890   EXPECT_EQ(33ull, row_sp->GetOffset());
 2891   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_esp);
 2892   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2893   EXPECT_EQ(wordsize, row_sp->GetCFAValue().GetOffset());
 2905   EXPECT_EQ(16ull, row_sp->GetOffset());
 2906   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 2907   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2908   EXPECT_EQ(wordsize, row_sp->GetCFAValue().GetOffset());
 2914   EXPECT_EQ(18ull, row_sp->GetOffset());
 2915   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rbp);
 2916   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2917   EXPECT_EQ(wordsize * 2, row_sp->GetCFAValue().GetOffset());
 2923   EXPECT_EQ(27ull, row_sp->GetOffset());
 2924   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rbp);
 2925   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2926   EXPECT_EQ(wordsize * 2, row_sp->GetCFAValue().GetOffset());
 2932   EXPECT_EQ(33ull, row_sp->GetOffset());
 2933   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == k_rsp);
 2934   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
 2935   EXPECT_EQ(wordsize, row_sp->GetCFAValue().GetOffset());

tools/lldb/unittests/Utility/BroadcasterTest.cpp

   30             listener1_sp->StartListeningForEvents(&broadcaster, event_mask1));
   32   EXPECT_TRUE(listener1_sp->GetEvent(event_sp, timeout));
   33   EXPECT_EQ(event_mask1, event_sp->GetType());
   39     EXPECT_EQ(event_mask2, listener2_sp->StartListeningForEvents(
   42     EXPECT_TRUE(listener2_sp->GetEvent(event_sp, timeout));
   43     EXPECT_EQ(event_mask2, event_sp->GetType());
   47     EXPECT_TRUE(listener1_sp->GetEvent(event_sp, timeout));
   48     EXPECT_EQ(event_mask1, event_sp->GetType());
   49     EXPECT_TRUE(listener2_sp->GetEvent(event_sp, timeout));
   50     EXPECT_EQ(event_mask2, event_sp->GetType());
   55   EXPECT_TRUE(listener1_sp->GetEvent(event_sp, timeout));
   56   EXPECT_EQ(event_mask1, event_sp->GetType());
   69               listener_sp->StartListeningForEvents(&broadcaster, event_mask));

tools/lldb/unittests/Utility/ListenerTest.cpp

   27             listener_sp->StartListeningForEvents(&broadcaster, event_mask));
   31   EXPECT_FALSE(listener_sp->GetEvent(event_sp, timeout));
   32   EXPECT_FALSE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
   34       listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, timeout));
   35   EXPECT_FALSE(listener_sp->GetEventForBroadcasterWithType(
   40   EXPECT_TRUE(listener_sp->GetEvent(event_sp, timeout));
   43   EXPECT_TRUE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
   47       listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, timeout));
   50   EXPECT_FALSE(listener_sp->GetEventForBroadcasterWithType(
   52   EXPECT_TRUE(listener_sp->GetEventForBroadcasterWithType(
   64             listener_sp->StartListeningForEvents(&broadcaster, event_mask));
   68   EXPECT_FALSE(listener_sp->GetEvent(event_sp, timeout));
   69   EXPECT_FALSE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
   71       listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, timeout));
   72   EXPECT_FALSE(listener_sp->GetEventForBroadcasterWithType(
   77   EXPECT_TRUE(listener_sp->GetEvent(event_sp, timeout));
   80   EXPECT_TRUE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
   84       listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, timeout));
   87   EXPECT_FALSE(listener_sp->GetEventForBroadcasterWithType(
   89   EXPECT_TRUE(listener_sp->GetEventForBroadcasterWithType(
  101   EXPECT_TRUE(listener_sp->GetEvent(event_sp, llvm::None));
  106       listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, llvm::None));
  110   EXPECT_TRUE(listener_sp->GetEventForBroadcasterWithType(

tools/lldb/unittests/Utility/LogTest.cpp

  101   llvm::StringRef result = m_stream_sp->str().drop_front(m_consumed_bytes);

tools/lldb/unittests/Utility/StructuredDataTest.cpp

   45   object_sp->Dump(S, false);

tools/lldb/unittests/tools/lldb-server/tests/MessageObjects.cpp

   77   auto Keys = KeysObj->GetAsArray();
  100   StructuredData::Array *array = json->GetAsArray();

tools/lli/RemoteJITUtils.h

  137     return Resolver->findSymbol(Name);
  142     return Resolver->findSymbolInLogicalDylib(Name);

tools/llvm-objcopy/CopyConfig.h

  119     return R ? R->match(S) : G ? G->match(S) : Name == S;
  119     return R ? R->match(S) : G ? G->match(S) : Name == S;

tools/llvm-pdbutil/InputFile.cpp

  186   Subsections = DebugStream->getSubsectionsArray();

tools/llvm-pdbutil/llvm-pdbutil.cpp

  780       Strings.strings()->insert(S);

tools/llvm-rtdyld/llvm-rtdyld.cpp

  816       auto ResultF = ResultP->get_future();
  820                       ResultP->set_value(std::move(Result));

tools/polly/lib/Analysis/ScopBuilder.cpp

 1698   Sizes.insert(Sizes.end(), AccItr->second.Shape->DelinearizedSizes.begin(),
 1699                AccItr->second.Shape->DelinearizedSizes.end());

tools/polly/lib/Analysis/ScopDetection.cpp

  393     LLVM_DEBUG(dbgs() << RejectReason->getMessage());
  429   return RR->getMessage();
  987       if (Shape->DelinearizedSizes.size() == 0) {
  991                                   Shape->DelinearizedSizes);
 1025   SE.findArrayDimensions(Terms, Shape->DelinearizedSizes,
 1028   if (!hasValidArraySizes(Context, Shape->DelinearizedSizes, BasePointer,

tools/polly/lib/Analysis/ScopDetectionDiagnostic.cpp

  145     if (const DebugLoc &Loc = RR->getDebugLoc())
  146       ORE.emit(OptimizationRemarkMissed(DEBUG_TYPE, RR->getRemarkName(), Loc,
  147                                         RR->getRemarkBB())
  148                << RR->getEndUserMessage());
  150       ORE.emit(OptimizationRemarkMissed(DEBUG_TYPE, RR->getRemarkName(), Begin,
  151                                         RR->getRemarkBB())
  152                << RR->getEndUserMessage());
  184     OS.indent(level) << "[" << j++ << "] " << Reason->getMessage() << "\n";

unittests/Bitstream/BitstreamReaderTest.cpp

  107       Abbrev->Add(BitCodeAbbrevOp(RecordID));
  108       Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));

unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp

   51   cantFail(FooMR->notifyResolved({{Foo, FooSym}}));
   55   cantFail(FooMR->notifyEmitted());

unittests/ExecutionEngine/Orc/LegacyRTDyldObjectLinkingLayerTest.cpp

  208   EXPECT_EQ(MM->FinalizationCount, 1)
  276   EXPECT_EQ(MM->NeedsToReserveAllocationSpaceCount, 1)

unittests/ExecutionEngine/Orc/QueueChannel.h

  109     std::unique_lock<std::mutex> Lock(InQueue->getMutex());
  112         Error Err = InQueue->checkReadError();
  113         while (!Err && InQueue->empty()) {
  114           InQueue->getCondVar().wait(Lock);
  115           Err = InQueue->checkReadError();
  120       *Dst++ = InQueue->front();
  123       InQueue->pop();
  129     std::unique_lock<std::mutex> Lock(OutQueue->getMutex());
  131       if (Error Err = OutQueue->checkWriteError())
  133       OutQueue->push(*Src++);
  136     OutQueue->getCondVar().notify_one();
  147     InQueue->setReadError(ChannelClosed);
  148     InQueue->setWriteError(ChannelClosed);
  149     OutQueue->setReadError(ChannelClosed);
  150     OutQueue->setWriteError(ChannelClosed);

unittests/Support/FileCollectorTest.cpp

  202   EXPECT_TRUE(Collector->hasSeen(a.Path));
  205   EXPECT_TRUE(Collector->hasSeen(b.Path));
  208   EXPECT_TRUE(Collector->hasSeen(subdir.Path));
  214   EXPECT_TRUE(Collector->hasSeen(subdir3.Path));
  215   EXPECT_TRUE(Collector->hasSeen(subdir3a.Path));
  216   EXPECT_TRUE(Collector->hasSeen(subdir3b.Path));
  218   EXPECT_FALSE(Collector->hasSeen(RemovedFileName));
  296   EXPECT_TRUE(Collector->hasSeen(a.Path));
  297   EXPECT_TRUE(Collector->hasSeen(symlink.Path));

usr/include/c++/7.4.0/bits/regex.tcc

   59       __m._M_resize(__re._M_automaton->_M_sub_count());
   66 	      && !__re._M_automaton->_M_has_backref))

usr/include/c++/7.4.0/bits/regex_compiler.tcc

   77       _M_traits(_M_nfa->_M_traits),
   80       _StateSeqT __r(*_M_nfa, _M_nfa->_M_start());
   81       __r._M_append(_M_nfa->_M_insert_subexpr_begin());
   87       __r._M_append(_M_nfa->_M_insert_subexpr_end());
   88       __r._M_append(_M_nfa->_M_insert_accept());
   89       _M_nfa->_M_eliminate_dummy();
  103 	  auto __end = _M_nfa->_M_insert_dummy();
  110 				   _M_nfa->_M_insert_alt(
  129 	_M_stack.push(_StateSeqT(*_M_nfa, _M_nfa->_M_insert_dummy()));
  153 	_M_stack.push(_StateSeqT(*_M_nfa, _M_nfa->_M_insert_line_begin()));
  155 	_M_stack.push(_StateSeqT(*_M_nfa, _M_nfa->_M_insert_line_end()));
  158 	_M_stack.push(_StateSeqT(*_M_nfa, _M_nfa->
  168 	  __tmp._M_append(_M_nfa->_M_insert_accept());
  172 		_M_nfa->_M_insert_lookahead(__tmp._M_start, __neg)));
  197 			 _M_nfa->_M_insert_repeat(_S_invalid_state_id,
  206 	  __e._M_append(_M_nfa->_M_insert_repeat(_S_invalid_state_id,
  214 	  auto __end = _M_nfa->_M_insert_dummy();
  216 			 _M_nfa->_M_insert_repeat(_S_invalid_state_id,
  231 	  _StateSeqT __e(*_M_nfa, _M_nfa->_M_insert_dummy());
  257 			     _M_nfa->_M_insert_repeat(_S_invalid_state_id,
  267 	      auto __end = _M_nfa->_M_insert_dummy();
  275 		  auto __alt = _M_nfa->_M_insert_repeat(__tmp._M_start,
  324 	_M_stack.push(_StateSeqT(*_M_nfa, _M_nfa->
  330 	  _StateSeqT __r(*_M_nfa, _M_nfa->_M_insert_dummy());
  340 	  _StateSeqT __r(*_M_nfa, _M_nfa->_M_insert_subexpr_begin());
  346 	  __r._M_append(_M_nfa->_M_insert_subexpr_end());
  375 	_M_nfa->_M_insert_matcher
  387 	_M_nfa->_M_insert_matcher
  399 	_M_nfa->_M_insert_matcher
  416 	_M_nfa->_M_insert_matcher(std::move(__matcher))));
  447 		      _M_nfa->_M_insert_matcher(std::move(__matcher))));

usr/include/c++/7.4.0/bits/regex_executor.h

  161 	return _M_re._M_automaton->_M_traits.isctype
  162 	  (__ch, _M_re._M_automaton->_M_traits.lookup_classname(__s, __s+1));

usr/include/c++/7.4.0/bits/regex_executor.tcc

  358       if (_M_re._M_automaton->_M_traits.transform(__submatch.first,
  360 	  == _M_re._M_automaton->_M_traits.transform(_M_current, __last))

usr/include/c++/7.4.0/future

  692         _M_state->wait();
  700           return _M_state->wait_for(__rel);
  708           return _M_state->wait_until(__abs);
  717         _Result_base& __res = _M_state->wait();
  733         _M_state->_M_set_retrieved_flag();
 1082           _M_future->_M_break_promise(std::move(_M_storage));
 1110       { _M_future->_M_set_result(_State::__setter(this, __r)); }
 1114       { _M_future->_M_set_result(_State::__setter(this, std::move(__r))); }
 1118       { _M_future->_M_set_result(_State::__setter(__p, this)); }
 1123 	_M_future->_M_set_delayed_result(_State::__setter(this, __r),
 1130 	_M_future->_M_set_delayed_result(
 1137 	_M_future->_M_set_delayed_result(_State::__setter(__p, this),
 1193           _M_future->_M_break_promise(std::move(_M_storage));
 1221       { _M_future->_M_set_result(_State::__setter(this, __r)); }
 1225       { _M_future->_M_set_result(_State::__setter(__p, this)); }
 1230 	_M_future->_M_set_delayed_result(_State::__setter(this, __r),
 1237 	_M_future->_M_set_delayed_result(_State::__setter(__p, this),
 1285           _M_future->_M_break_promise(std::move(_M_storage));
 1313       { _M_future->_M_set_result(_State::__setter(this)); }
 1317       { _M_future->_M_set_result(_State::__setter(__p, this)); }
 1321       { _M_future->_M_set_delayed_result(_State::__setter(this), _M_future); }
 1326 	_M_future->_M_set_delayed_result(_State::__setter(__p, this),
 1512 	  _M_state->_M_break_promise(std::move(_M_state->_M_result));
 1512 	  _M_state->_M_break_promise(std::move(_M_state->_M_result));
 1556 	_M_state->_M_run(std::forward<_ArgTypes>(__args)...);

utils/TableGen/CodeGenDAGPatterns.cpp

 1308   if (PatFragRec->getOnlyTree()->isLeaf())
 1311     Record *Op = PatFragRec->getOnlyTree()->getOperator();
 1664     if (C->hasProperTypeByHwMode())
 1674     if (!C->hasPossibleType())
 1687     if (!C->setDefaultMode(Mode))
 1763         NumResults = std::max(NumResults, T->getNumTypes());
 1903   New->setName(getName());
 1904   New->setNamesAsPredicateArg(getNamesAsPredicateArg());
 1905   New->Types = Types;
 1906   New->setPredicateCalls(getPredicateCalls());
 1907   New->setTransformFn(getTransformFn());
 1939                 NewChild->getPredicateCalls() == Child->getPredicateCalls()) &&
 1978       Child->InlinePatternFragments(Child, TP, ChildAlternatives[i]);
 1985         assert((Child->getPredicateCalls().empty() ||
 1986                 NewChild->getPredicateCalls() == Child->getPredicateCalls()) &&
 1986                 NewChild->getPredicateCalls() == Child->getPredicateCalls()) &&
 2003       R->setName(getName());
 2004       R->setNamesAsPredicateArg(getNamesAsPredicateArg());
 2005       R->setPredicateCalls(getPredicateCalls());
 2006       R->setTransformFn(getTransformFn());
 2008         R->setType(i, getExtType(i));
 2010         R->setResultIndex(i, getResultIndex(i));
 2052       Child = Child->clone();
 2053       Child->addNameAsPredicateArg(ScopedName(Scope, Frag->getArgName(i)));
 2060     TreePatternNodePtr FragTree = Alternative->clone();
 2063       FragTree->addPredicateCall(PredFn, Scope);
 2067       FragTree->SubstituteFormalArguments(ArgMap);
 2071     FragTree->setName(getName());
 2072     for (unsigned i = 0, e = FragTree->getNumTypes(); i != e; ++i)
 2073       FragTree->UpdateNodeType(i, getExtType(i), TP);
 2077       FragTree->addPredicateCall(Pred);
 2081     FragTree->InlinePatternFragments(FragTree, TP, OutAlternatives);
 2720     Res->setName(OpName);
 2730     Res->setName(OpName);
 2769     assert(New->getNumTypes() == 1 && "FIXME: Unhandled");
 2771     New->UpdateNodeType(0, getValueTypeByHwMode(Operator, CGH), *this);
 2850       if (Child->getName().empty())
 2857       auto PrevOp = ComplexPatternOperands.find(Child->getName());
 2863         ComplexPatternOperands[Child->getName()] = OperandId;
 2870   Result->setName(OpName);
 2873     assert(Result->getName().empty());
 2874     Result->setName(Dag->getNameStr());
 2886   if (N->isLeaf())
 2891   if (N->getOperator()->getName() == "bitconvert" &&
 2892       N->getExtType(0).isValueTypeByHwMode(false) &&
 2893       N->getExtType(0) == N->getChild(0)->getExtType(0) &&
 2893       N->getExtType(0) == N->getChild(0)->getExtType(0) &&
 2894       N->getName().empty()) {
 2895     N = N->getChildShared(0);
 2902   for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) {
 2903     TreePatternNodePtr Child = N->getChildShared(i);
 2905     N->setChild(i, std::move(Child));
 2924       MadeChange |= Tree->ApplyTypeConstraints(*this, false);
 2983     HasUnresolvedTypes |= Tree->ContainsUnresolvedType(*this);
 3001     Tree->print(OS);
 3162         T->setTransformFn(Transform);
 3217     for (unsigned op = 0, e = T->getNumChildren(); op != e; ++op) {
 3218       TreePatternNodePtr TPN = T->getChildShared(op);
 3219       while (TPN->ApplyTypeConstraints(P, false))
 3222       if (TPN->ContainsUnresolvedType(P)) {
 3240   if (Pat->getName().empty()) {
 3241     if (Pat->isLeaf()) {
 3242       DefInit *DI = dyn_cast<DefInit>(Pat->getLeafValue());
 3251   if (Pat->isLeaf()) {
 3252     DefInit *DI = dyn_cast<DefInit>(Pat->getLeafValue());
 3254       I.error("Input $" + Pat->getName() + " must be an identifier!");
 3257     Rec = Pat->getOperator();
 3264   TreePatternNodePtr &Slot = InstInputs[Pat->getName()];
 3270   if (Slot->isLeaf()) {
 3271     SlotRec = cast<DefInit>(Slot->getLeafValue())->getDef();
 3273     assert(Slot->getNumChildren() == 0 && "can't be a use with children!");
 3274     SlotRec = Slot->getOperator();
 3279     I.error("All $" + Pat->getName() + " inputs must agree with each other");
 3281   Slot->UpdateNodeType(0, Pat->getExtType(0), I);
 3281   Slot->UpdateNodeType(0, Pat->getExtType(0), I);
 3282   Pat->UpdateNodeType(0, Slot->getExtType(0), I);
 3282   Pat->UpdateNodeType(0, Slot->getExtType(0), I);
 3283   if (Slot->getExtTypes() != Pat->getExtTypes())
 3283   if (Slot->getExtTypes() != Pat->getExtTypes())
 3284     I.error("All $" + Pat->getName() + " inputs must agree with each other");
 3301   if (!Pat->getName().empty()) {
 3308   if (Pat->isLeaf()) {
 3310     if (!isUse && Pat->getTransformFn())
 3315   if (Pat->getOperator()->getName() == "implicit") {
 3316     for (unsigned i = 0, e = Pat->getNumChildren(); i != e; ++i) {
 3317       TreePatternNode *Dest = Pat->getChild(i);
 3329   if (Pat->getOperator()->getName() != "set") {
 3332     for (unsigned i = 0, e = Pat->getNumChildren(); i != e; ++i) {
 3333       if (Pat->getChild(i)->getNumTypes() == 0)
 3335       FindPatternInputsAndOutputs(I, Pat->getChildShared(i), InstInputs,
 3343     if (!isUse && Pat->getTransformFn())
 3349   if (Pat->getNumChildren() == 0)
 3352   if (Pat->getTransformFn())
 3356   unsigned NumDests = Pat->getNumChildren()-1;
 3358     TreePatternNodePtr Dest = Pat->getChildShared(i);
 3365     if (!Dest->isLeaf())
 3368     DefInit *Val = dyn_cast<DefInit>(Dest->getLeafValue());
 3378       if (Dest->getName().empty())
 3380       if (InstResults.count(Dest->getName()))
 3381         I.error("cannot set '" + Dest->getName() + "' multiple times");
 3382       InstResults[Dest->getName()] = Dest;
 3391   FindPatternInputsAndOutputs(I, Pat->getChildShared(NumDests), InstInputs,
 3626     if (Pat->getNumTypes() != 0) {
 3628       for (unsigned k = 0, ke = Pat->getNumTypes(); k != ke; ++k) {
 3631         Pat->getExtType(k).writeToStream(OS);
 3675     Record *R = cast<DefInit>(RNode->getLeafValue())->getDef();
 3718     if (InVal->isLeaf() && isa<DefInit>(InVal->getLeafValue())) {
 3718     if (InVal->isLeaf() && isa<DefInit>(InVal->getLeafValue())) {
 3719       Record *InRec = static_cast<DefInit*>(InVal->getLeafValue())->getDef();
 3727     TreePatternNodePtr OpNode = InVal->clone();
 3730     OpNode->clearPredicateCalls();
 3733     if (Record *Xform = OpNode->getTransformFn()) {
 3734       OpNode->setTransformFn(nullptr);
 3738                                                  OpNode->getNumTypes());
 3753     assert(ResNodes[i]->getNumTypes() == 1 && "FIXME: Unhandled");
 3754     ResultPattern->setType(i, ResNodes[i]->getExtType(0));
 3754     ResultPattern->setType(i, ResNodes[i]->getExtType(0));
 3755     ResultPattern->setResultIndex(i, ResultIndices[i]);
 3762   if (Pattern->getOperator()->getName() == "set") {
 3763     SrcPattern = Pattern->getChild(Pattern->getNumChildren()-1)->clone();
 3763     SrcPattern = Pattern->getChild(Pattern->getNumChildren()-1)->clone();
 4081   if (Record *Xform = N->getTransformFn()) {
 4082       N->setTransformFn(nullptr);
 4086                                                N->getNumTypes());
 4089   if (!N->isLeaf())
 4090     for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) {
 4091       TreePatternNodePtr Child = N->getChildShared(i);
 4092       N->setChild(i, PromoteXForms(Child));
 4129       for (unsigned i = 0, e = std::min(Result.getOnlyTree()->getNumTypes(),
 4130                                         T->getNumTypes());
 4132         IterateInference |= T->UpdateNodeType(
 4133             i, Result.getOnlyTree()->getExtType(i), Result);
 4134         IterateInference |= Result.getOnlyTree()->UpdateNodeType(
 4135             i, T->getExtType(i), Result);
 4181   if (Temp.getOnlyTree()->hasPossibleType())
 4183       if (T->hasPossibleType())
 4242     TreePatternNodePtr NewSrc = P.SrcPattern->clone();
 4243     TreePatternNodePtr NewDst = P.DstPattern->clone();
 4244     if (!NewSrc->setDefaultMode(Mode) || !NewDst->setDefaultMode(Mode)) {
 4244     if (!NewSrc->setDefaultMode(Mode) || !NewDst->setDefaultMode(Mode)) {
 4259     if (P.SrcPattern->hasProperTypeByHwMode())
 4261     if (P.DstPattern->hasProperTypeByHwMode())
 4371       errs() << Orig->getOperator()->getName() << ": Idxs = [ ";
 4383         Orig->getOperator(), std::move(NewChildren), Orig->getNumTypes());
 4383         Orig->getOperator(), std::move(NewChildren), Orig->getNumTypes());
 4386     R->setName(Orig->getName());
 4386     R->setName(Orig->getName());
 4387     R->setNamesAsPredicateArg(Orig->getNamesAsPredicateArg());
 4387     R->setNamesAsPredicateArg(Orig->getNamesAsPredicateArg());
 4388     R->setPredicateCalls(Orig->getPredicateCalls());
 4388     R->setPredicateCalls(Orig->getPredicateCalls());
 4389     R->setTransformFn(Orig->getTransformFn());
 4389     R->setTransformFn(Orig->getTransformFn());
 4390     for (unsigned i = 0, e = Orig->getNumTypes(); i != e; ++i)
 4391       R->setType(i, Orig->getExtType(i));
 4391       R->setType(i, Orig->getExtType(i));
 4399     if (R->canPatternMatch(ErrString, CDP) &&
 4401           return R->isIsomorphicTo(Variant.get(), DepVars);
 4436   assert(N->getNumChildren()==2 &&"Associative but doesn't have 2 children!");
 4437   Record *Operator = N->getOperator();
 4440   if (!N->getName().empty() || !N->getPredicateCalls().empty() ||
 4440   if (!N->getName().empty() || !N->getPredicateCalls().empty() ||
 4441       N->getTransformFn()) {
 4446   if (N->getChild(0)->isLeaf() || N->getChild(0)->getOperator() != Operator)
 4446   if (N->getChild(0)->isLeaf() || N->getChild(0)->getOperator() != Operator)
 4447     Children.push_back(N->getChildShared(0));
 4449     GatherChildrenOfAssociativeOpcode(N->getChildShared(0), Children);
 4451   if (N->getChild(1)->isLeaf() || N->getChild(1)->getOperator() != Operator)
 4451   if (N->getChild(1)->isLeaf() || N->getChild(1)->getOperator() != Operator)
 4452     Children.push_back(N->getChildShared(1));
 4454     GatherChildrenOfAssociativeOpcode(N->getChildShared(1), Children);
 4465   if (N->isLeaf() || N->getOperator()->isSubClassOf("ComplexPattern")) {
 4465   if (N->isLeaf() || N->getOperator()->isSubClassOf("ComplexPattern")) {
 4471   const SDNodeInfo &NodeInfo = CDP.getSDNodeInfo(N->getOperator());
 4527   ChildVariants.resize(N->getNumChildren());
 4528   for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i)
 4529     GenerateVariantsOf(N->getChildShared(i), ChildVariants[i], CDP, DepVars);
 4535   bool isCommIntrinsic = N->isCommutativeIntrinsic(CDP);
 4537     assert((N->getNumChildren()>=2 || isCommIntrinsic) &&
 4541     for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) {
 4542       TreePatternNode *Child = N->getChild(i);
 4565     } else if (NC == N->getNumChildren()) {
 4653       LLVM_DEBUG(errs() << "  VAR#" << v << ": "; Variant->dump();
 4663         if (Variant->isIsomorphicTo(PatternsToMatch[p].getSrcPattern(),

utils/TableGen/CodeGenDAGPatterns.h

  953       Copy[i]->InlinePatternFragments(Copy[i], *this, Trees);

utils/TableGen/DAGISelMatcherGen.cpp

  163   PatWithNoTypes->RemoveAllTypes();
  182     MadeChange = PatWithNoTypes->ApplyTypeConstraints(TP,

utils/TableGen/FastISelEmitter.cpp

  173       ValueTypeByHwMode VVT = TP->getTree(0)->getType(0);