Lines Matching +defs:buffer +defs:file +defs:name
226 // The name field is required to be nul-terminated, and n_namesz includes the
244 LLDB_LOGF(log, "Failed to parse note name lacking nul terminator");
258 // If there aren't any elf flags available (e.g core elf file) then return
260 // 32 or 64 bit arch (without any architecture revision) based on object file's class.
369 const lldb_private::FileSpec *file,
374 data_sp = MapFileDataWritable(*file, length, file_offset);
390 // Update the data to contain the entire file if it doesn't already
392 data_sp = MapFileDataWritable(*file, length, file_offset);
400 // If we didn't map the data as writable take ownership of the buffer.
411 module_sp, data_sp, data_offset, file, file_offset, length));
560 const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp,
574 ModuleSpec spec(file);
576 // load .so file directly from zip file. In that case, .so file is
578 // .so file offset and file size to pass through the information from
579 // lldb-server to LLDB. For normal file, file_offset should be 0,
580 // length should be the size of the file.
594 LLDB_LOGF(log, "ObjectFileELF::%s file '%s' module OSABI: %s",
595 __FUNCTION__, file.GetPath().c_str(),
609 "ObjectFileELF::%s file '%s' set ELF module OS type "
611 __FUNCTION__, file.GetPath().c_str());
614 // When ELF file does not contain GNU build ID, the later code will
616 // important for Android zip .so file, which is a slice of a file,
617 // to not access the outside of the file slice range.
619 data_sp = MapFileData(file, length, file_offset);
643 "ObjectFileELF::%s file '%s' module set to triple: %s "
645 __FUNCTION__, file.GetPath().c_str(),
655 file.GetFilename().AsCString(),
699 const FileSpec *file, lldb::offset_t file_offset,
701 : ObjectFile(module_sp, file, file_offset, length, data_sp, data_offset) {
702 if (file)
703 m_file = *file;
734 // Iterate through the object file sections to find all of the sections
746 // file plug-ins, but until then, we don't want PT_TLS segments to
793 // object file what contains the symtab information.
993 if (!entry.name.empty()) {
994 FileSpec file_spec(entry.name);
1061 LLDB_LOGF(log, "ObjectFileELF::%s parsing note name='%s', type=%" PRIu32,
1228 // The contents look like this in a 64 bit ELF core file:
1495 ConstString name(shstr_data.PeekCStr(I->sh_name));
1497 I->section_name = name;
1574 if (name == g_sect_name_gnu_debuglink) {
1591 if (!is_note_header && name == g_sect_name_android_ident)
1646 lldb::user_id_t ObjectFileELF::GetSectionIndexByName(const char *name) {
1647 if (!name || !name[0] || !ParseSectionHeaders())
1650 if (m_section_headers[i].section_name == ConstString(name))
1771 // we need to compute synthetic addresses in order for "file addresses" from
1790 // When this is a debug file for relocatable file, the address is all zero
1813 LLDB_LOG(Log, "Ignoring zero-sized {0} segment. Corrupt object file?",
1819 LLDB_LOG(Log, "Ignoring overlapping {0} segment. Corrupt object file?",
1839 "Corrupt object file?");
1845 LLDB_LOG(Log, "Ignoring overlapping section. Corrupt object file?");
1878 ConstString name = section->GetName();
1885 if (sect->GetName() == name &&
1942 ConstString &name = I->section_name;
1965 name, // Section name.
1969 header.sh_offset, // Offset of this section in the file.
1970 file_size, // Size of the section as found in the file.
1988 // embedded in there and replace the one in the original object file (if any).
1989 // If there's none in the orignal object file, we add it to it.
2034 // Construct ObjectFileELF object from decompressed buffer
2052 // Find the arm/aarch64 mapping symbol character in the given symbol name.
2055 // because if a symbol prefix added to each symbol in the object file with
2084 // caller may be another object file.
2102 // symbol name to the user and very slow unwinding speed because the
2106 // can't be restricted to Android because this special object file don't
2108 // custom extension and file name makes it highly unlikely that this will
2189 // Conventionally, the symbol's name gives the name of the source file
2190 // associated with the object file. A file symbol has STB_LOCAL
2192 // STB_LOCAL symbols for the file, if it is present.
2420 // If the symbol table section is owned by a different object file, have it
2427 // The other object file returned the changes it made to its address
2434 // Get section list for this object file.
2491 const char *name = dynstr_data->GetCStr(&cursor);
2492 if (name)
2493 entry.name = std::string(name);
2611 symbol_name, // symbol name.
2639 // If the link field doesn't point to the appropriate symbol name table then
2640 // try to find it by name as some compiler don't fill in the link fields.
2753 const char *name = symbol->GetName().GetCString();
2754 LLDB_LOGF(log, "Debug info symbol invalid: %s", name);
2980 // We always want to use the main object file so we (hopefully) only have one
3083 // Don't set the name for any synthetic symbols, the Symbol
3084 // object will generate one if needed when the name is accessed
3089 /*name=*/llvm::StringRef(), // Name will be auto generated.
3189 // Don't set the name for any synthetic symbols, the Symbol
3190 // object will generate one if needed when the name is accessed
3194 /*name=*/llvm::StringRef(), // Name will be auto generated.
3224 // Dump the specifics of the runtime file container (such as any headers
3239 *s << ", file = '" << m_file
3481 s->PutCString("IDX name type flags "
3520 #define AARCH64_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
3528 #define HEXAGON_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
3536 #define MIPS_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
3544 #define PPC_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
3552 #define PPC64_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
3560 #define RISCV_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
3569 #define AARCH64_DYNAMIC_TAG(name, value)
3570 #define MIPS_DYNAMIC_TAG(name, value)
3571 #define HEXAGON_DYNAMIC_TAG(name, value)
3572 #define PPC_DYNAMIC_TAG(name, value)
3573 #define PPC64_DYNAMIC_TAG(name, value)
3574 #define RISCV_DYNAMIC_TAG(name, value)
3576 #define DYNAMIC_TAG_MARKER(name, value)
3577 #define DYNAMIC_TAG(name, value) \
3579 return #name;
3610 if (!entry.name.empty())
3611 s->Printf(" \"%s\"", entry.name.c_str());
3645 // 0 - No file type
3649 // 1 - Relocatable file
3653 // 2 - Executable file
3657 // 3 - Shared object file
3661 // 4 - Core file
3673 // 0 - No file type
3677 // 1 - Relocatable file
3681 // 2 - Executable file
3689 char buffer[256];
3691 ReadSectionData(loader_section.get(), 0, buffer, sizeof(buffer));
3696 llvm::StringRef loader_name(buffer, read_size - 1);
3706 // 3 - Shared object file
3713 // 4 - Core file
3714 // TODO: is there any way to detect that an core file is a kernel
3789 // the file on disk being mmap'ed or from the initial part of the ELF file we
3795 // We have a ELF file in process memory, read the program header data from
3840 ObjectFileELF::MapFileDataWritable(const FileSpec &file, uint64_t Size,
3842 return FileSystem::Instance().CreateWritableDataBuffer(file.GetPath(), Size,
3850 // we have an ELF file read from memory, or it will be a file address if it
3851 // was read from a ELF file. This function will correctly fetch data pointed
3859 // We have an ELF file with no section headers or we didn't find the
3894 // Every ELF file which represents an executable or shared library has
3899 // When loading and ELF file from memory, only the program headers are
4027 // Every ELF file which represents an executable or shared library has
4034 // When loading and ELF file from memory, only the program headers end up
4038 // Get the process in case this is an in memory ELF file.