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

  601 /// defining instruction.
  602 class WriteRef {
  603   std::pair<unsigned, WriteState *> Data;

  105 // corresponding replacements.
  106 struct RewriteRule {
  107   struct Case {

   30 /// although no methods are overridable.
   31 class BinaryStreamWriter {
   32 public:

   25 
   26   struct AsmWriterOperand {
   27     enum OpType {

   31 /// are involved.
   32 class Rewriter {
   33   SourceManager *SourceMgr = nullptr;

   77 
   78   class AsmWriterInst {
   79   public:

  132 
  133 bool EmulateInstruction::WriteRegisterUnsigned(const Context &context,
  134                                                lldb::RegisterKind reg_kind,

   38 /// should be emitted as part of writeObject().
   39 class MCObjectWriter {
   40 protected:

   50 /// Adapter to write values to a stream in a particular byte order.
   51 struct Writer {
   52   raw_ostream &OS;

   57 
   58 class DirectBufferWriter {
   59 public:

  114 /// target and the object format.
  115 class MCObjectTargetWriter {
  116 public:

   24 /// has a concrete subclass of Writer.
   25 class Writer {
   26 public:

  170 
  171 struct WriterStackLevel {
  172   DocNode Node;

   17 namespace llvm {
   18 class TarWriter {
   19 public:

   26 
   27 class BitstreamWriter {
   28   SmallVectorImpl<char> &Out;

  102 /// instance of the ASTReader class.
  103 class ASTWriter : public ASTDeserializationListener,
  104                   public ASTMutationListener {

  303 
  304 class Writer {
  305 protected:

  261   BinaryStreamReader *Reader = nullptr;
  262   BinaryStreamWriter *Writer = nullptr;
  263   CodeViewRecordStreamer *Streamer = nullptr;

  182 
  183   Error commit(BinaryStreamWriter &Writer) const {
  184     Header H;

   80 
   81 class MachObjectWriter : public MCObjectWriter {
   82   /// Helper struct for containing some precomputed information on symbols.

   28 /// offsets and sizes.
   29 class FileWriter {
   30   llvm::raw_pwrite_stream &OS;

   53 
   54 class MCELFObjectTargetWriter : public MCObjectTargetWriter {
   55   const uint8_t OSABI;

   19 
   20 enum AsmWriterFlavorTy {
   21   // Note: This numbering has to match the GCC assembler dialects for inline

   20 
   21 enum AsmWriterVariantTy {
   22   Default = -1,

  222 
  223 bool RegisterContext::WriteRegisterFromUnsigned(const RegisterInfo *reg_info,
  224                                                 uint64_t uval) {

  656     // case, causing the compiler to hang on certain tests.
  657     DenseMap<const SCEV *, const SCEV *> RewriteResults;
  658 

  183 /// Keep track of merged data and reported errors.
  184 struct WriterContext {
  185   std::mutex Lock;

  362 
  363 class IHexWriter : public Writer {
  364   struct SectionCompare {

   65 template<typename GraphType>
   66 class GraphWriter {
   67   raw_ostream &O;

   28 /// records defined in the FDRRecords.h file.
   29 class FDRTraceWriter : public RecordVisitor {
   30 public:

   28 
   29 class LogWriter {
   30 public:

   42 
   43 class ResourceFileWriter : public Visitor {
   44 public:

  349 
  350 class BinaryWriter : public Writer {
  351 private:

   27 
   28 class MCMachObjectTargetWriter : public MCObjectTargetWriter {
   29   const unsigned Is64Bit : 1;

   44 
   45   virtual bool WriteRegister(const RegisterInfo *reg_info,
   46                              const RegisterValue &reg_value) = 0;

   61 
   62 class FixItRewriter : public DiagnosticConsumer {
   63   /// The diagnostics machinery.

   31 /// Sample-based profile writer. Base class.
   32 class SampleProfileWriter {
   33 public:

  102 void X86MachObjectWriter::RecordX86_64Relocation(
  103     MachObjectWriter *Writer, MCAssembler &Asm, const MCAsmLayout &Layout,
  104     const MCFragment *Fragment, const MCFixup &Fixup, MCValue Target,

   20 
   21 class MCWasmObjectTargetWriter : public MCObjectTargetWriter {
   22   const unsigned Is64Bit : 1;

  216 
  217 struct ASTUnit::ASTWriterData {
  218   SmallString<128> Buffer;

   17 
   18 class MCXCOFFObjectTargetWriter : public MCObjectTargetWriter {
   19 protected:

   22 
   23   class MCWinCOFFObjectTargetWriter : public MCObjectTargetWriter {
   24     virtual void anchor();

   40 
   41 static void writeRegister(const void *reg_src, uint8_t *context,
   42                           const RegisterInfo &reg) {

   22 
   23 void dumpCOFFImportFile(const COFFImportFile *File, ScopedPrinter &Writer) {
   24   Writer.startLine() << '\n';

  374 
  375 void ARMMachObjectWriter::recordRelocation(MachObjectWriter *Writer,
  376                                            MCAssembler &Asm,

  151 void AArch64MachObjectWriter::recordRelocation(
  152     MachObjectWriter *Writer, MCAssembler &Asm, const MCAsmLayout &Layout,
  153     const MCFragment *Fragment, const MCFixup &Fixup, MCValue Target,

   37 /// modules).
   38 class PCHContainerWriter {
   39 public:

  106   unsigned readers = 0;
  107   unsigned writers = 0;
  108 

  176 
  177 class BinarySectionWriter : public SectionWriter {
  178 public:

  502 
  503 void X86MachObjectWriter::RecordX86Relocation(MachObjectWriter *Writer,
  504                                               const MCAssembler &Asm,

   22 /// Writes AVR machine code into an ELF32 object file.
   23 class AVRELFObjectWriter : public MCELFObjectTargetWriter {
   24 public:

   57   void *WriterCtx;
   58 } ProfDataWriter;
   59 

 5128                            const Formula &F, BasicBlock::iterator IP,
 5129                            SCEVExpander &Rewriter,
 5130                            SmallVectorImpl<WeakTrackingVH> &DeadInsts) const {

   26 
   27 class AssemblyAnnotationWriter {
   28 public:

  747 /// An object for streaming information to a record.
  748 class ASTRecordWriter {
  749   ASTWriter *Writer;

  207 
  208 Error PDBStringTableBuilder::commit(BinaryStreamWriter &Writer) const {
  209   BinaryStreamWriter SectionWriter;

   67 /// Implements write operations for a raw pass-through PCH container.
   68 class RawPCHContainerWriter : public PCHContainerWriter {
   69   llvm::StringRef getFormat() const override { return "raw"; }

  103 /// a module file.
  104 class ModuleFileExtensionWriter {
  105   ModuleFileExtension *Extension;

   18 
   19 static void writeRegister(const void *reg_src,
   20                           llvm::MutableArrayRef<uint8_t> reg_dest) {

  252 
  253 void ARMMachObjectWriter::RecordARMScatteredRelocation(MachObjectWriter *Writer,
  254                                                     const MCAssembler &Asm,

   39 /// Writes MessagePack objects to an output stream, one at a time.
   40 class Writer {
   41 public:

  362 
  363 bool X86MachObjectWriter::recordScatteredRelocation(MachObjectWriter *Writer,
  364                                                     const MCAssembler &Asm,

  190 bool PPCMachObjectWriter::recordScatteredRelocation(
  191     MachObjectWriter *Writer, const MCAssembler &Asm, const MCAsmLayout &Layout,
  192     const MCFragment *Fragment, const MCFixup &Fixup, MCValue Target,

  300 void PPCMachObjectWriter::RecordPPCRelocation(
  301     MachObjectWriter *Writer, const MCAssembler &Asm, const MCAsmLayout &Layout,
  302     const MCFragment *Fragment, const MCFixup &Fixup, MCValue Target,

  139 void ARMMachObjectWriter::
  140 RecordARMScatteredHalfRelocation(MachObjectWriter *Writer,
  141                                  const MCAssembler &Asm,

  295 
  296   MCObjectWriter &getWriter() const { return *Writer; }
  297 

   37   AppendingBinaryByteStream Buffer;
   38   BinaryStreamWriter SegmentWriter;
   39   TypeRecordMapping Mapping;

   17 /// wraps Clang modules inside a COFF, ELF, or Mach-O container.
   18 class ObjectFilePCHContainerWriter : public PCHContainerWriter {
   19   StringRef getFormat() const override { return "obj"; }

 1960 
 1961 void llvm::dumpCodeViewMergedTypes(ScopedPrinter &Writer,
 1962                                    ArrayRef<ArrayRef<uint8_t>> IpiRecords,

  437 /// Dumps the specified object file.
  438 static void dumpObject(const ObjectFile *Obj, ScopedPrinter &Writer,
  439                        const Archive *A = nullptr) {

   21 
   22 class MachOWriter {
   23   Object &O;

   63 
   64 Error DebugStringTableSubsection::commit(BinaryStreamWriter &Writer) const {
   65   uint32_t Begin = Writer.getOffset();

  241     const object::MachOObjectFile::LoadCommandInfo &LCI, SegmentTy Segment,
  242     const object::MachOObjectFile &Obj, MachObjectWriter &Writer,
  243     uint64_t LinkeditOffset, uint64_t LinkeditSize, uint64_t DwarfSegmentSize,

   34   MutableBinaryByteStream Stream;
   35   BinaryStreamWriter Writer;
   36   SymbolRecordMapping Mapping;

   76 
   77 class FDRLogWriter {
   78   BufferQueue::Buffer &Buffer;

  344                                            SmallPtrSetImpl<Function *> *Readers,
  345                                            SmallPtrSetImpl<Function *> *Writers,
  346                                            GlobalValue *OkayStoreDest) {

  612 static std::error_code createELFDumper(const ELFObjectFile<ELFT> *Obj,
  613                                        ScopedPrinter &Writer,
  614                                        std::unique_ptr<ObjDumper> &Result) {

 4730 template<typename Vector>
 4731 static void AddLazyVectorDecls(ASTWriter &Writer, Vector &Vec,
 4732                                ASTWriter::RecordData &Record) {

  978   llvm::BitstreamWriter Stream;
  979   ASTWriter Writer;
  980   bool AllowASTWithErrors;

   70 
   71 Error DebugSubsectionRecordBuilder::commit(BinaryStreamWriter &Writer) const {
   72   assert(Writer.getOffset() % alignOf(Container) == 0 &&

  417 static std::error_code createDumper(const ObjectFile *Obj,
  418                                     ScopedPrinter &Writer,
  419                                     std::unique_ptr<ObjDumper> &Result) {

  596 /// Opens \a File and dumps it.
  597 static void dumpInput(StringRef File, ScopedPrinter &Writer) {
  598   // Attempt to open the binary.

  216 
  217 bool RegisterContext::WriteRegisterFromUnsigned(uint32_t reg, uint64_t uval) {
  218   if (reg == LLDB_INVALID_REGNUM)

  124   struct ASTWriterData;
  125   std::unique_ptr<ASTWriterData> WriterData;
  126 

   32 
   33 class InstrProfWriter {
   34 public:

   70   /// The yaml mapping writer.
   71   vfs::YAMLVFSWriter VFSWriter;
   72 

  114 
  115 bool EmulateInstruction::WriteRegister(const Context &context,
  116                                        const RegisterInfo *reg_info,

   90 
   91 class InstrProfRecordWriterTrait {
   92 public:

   29 
   30   class TokenRewriter {
   31     /// TokenList - This is the list of raw tokens that make up this file.  Each

   33 /// methods, which help with writing tests that change files.
   34 class RewriterTestContext {
   35  public:

  195 #endif
  196 typedef SmartScopedWriter<false> ScopedWriter;
  197 

   93 
   94 Error GSIHashStreamBuilder::commit(BinaryStreamWriter &Writer) {
   95   GSIHashHeader Header;

   82 
   83 Error DebugInlineeLinesSubsection::commit(BinaryStreamWriter &Writer) const {
   84   InlineeLinesSignature Sig = InlineeLinesSignature::Normal;

  107 static DWARFExpression MakeLocationExpressionInternal(lldb::ModuleSP module,
  108                                                       StreamWriter &&writer) {
  109   const ArchSpec &architecture = module->GetArchitecture();

  619 std::error_code createELFDumper(const object::ObjectFile *Obj,
  620                                 ScopedPrinter &Writer,
  621                                 std::unique_ptr<ObjDumper> &Result) {

  102 
  103 Error DebugLinesSubsection::commit(BinaryStreamWriter &Writer) const {
  104   LineFragmentHeader Header;

 2304     PTWRITEm	= 2289,
 2305     PTWRITEr	= 2290,
 2306     PUNPCKHBWrm	= 2291,

   30 
   31   class BitcodeWriter {
   32     SmallVectorImpl<char> &Buffer;

   63 typedef struct ProfBufferIO {
   64   ProfDataWriter *FileWriter;
   65   uint32_t OwnFileWriter;

 1037   // Abstract base class for writing strings to a socket.
 1038   class AbstractSocketWriter {
 1039    public: