ReleaseNotes: C API policy; by Eric Christopher

[oota-llvm.git] / tools / llvm-objdump / MachODump.cpp

diff --git a/tools/llvm-objdump/MachODump.cpp b/tools/llvm-objdump/MachODump.cpp
index 2fd0751dd8c06a9bf5c4968bdaa7f7a9dc92dde0..258c0b520a3d4f6ecfcb9f864d9bf9668679fcf7 100644 (file)
--- a/tools/llvm-objdump/MachODump.cpp
+++ b/tools/llvm-objdump/MachODump.cpp
@@ -914,10 +914,7 @@ static void DumpInitTermPointerSection(MachOObjectFile *O, const char *sect,
                                        SymbolAddressMap *AddrMap,
                                        bool verbose) {
   uint32_t stride;
-  if (O->is64Bit())
-    stride = sizeof(uint64_t);
-  else
-    stride = sizeof(uint32_t);
+  stride = (O->is64Bit()) ? sizeof(uint64_t) : sizeof(uint32_t);
   for (uint32_t i = 0; i < sect_size; i += stride) {
     const char *SymbolName = nullptr;
     if (O->is64Bit()) {
@@ -1199,7 +1196,11 @@ static void ProcessMachO(StringRef Filename, MachOObjectFile *MachOOF,
     PrintSymbolTable(MachOOF);
   if (UnwindInfo)
     printMachOUnwindInfo(MachOOF);
-  if (PrivateHeaders)
+  if (PrivateHeaders) {
+    printMachOFileHeader(MachOOF);
+    printMachOLoadCommands(MachOOF);
+  }
+  if (FirstPrivateHeader)
     printMachOFileHeader(MachOOF);
   if (ObjcMetaData)
     printObjcMetaData(MachOOF, !NonVerbose);
@@ -1480,10 +1481,8 @@ void llvm::ParseInputMachO(StringRef Filename) {
 
   // Attempt to open the binary.
   ErrorOr<OwningBinary<Binary>> BinaryOrErr = createBinary(Filename);
-  if (std::error_code EC = BinaryOrErr.getError()) {
-    errs() << "llvm-objdump: '" << Filename << "': " << EC.message() << ".\n";
-    return;
-  }
+  if (std::error_code EC = BinaryOrErr.getError())
+    report_error(Filename, EC);
   Binary &Bin = *BinaryOrErr.get().getBinary();
 
   if (Archive *A = dyn_cast<Archive>(&Bin)) {
@@ -1652,9 +1651,9 @@ void llvm::ParseInputMachO(StringRef Filename) {
     } else
       errs() << "llvm-objdump: '" << Filename << "': "
              << "Object is not a Mach-O file type.\n";
-  } else
-    errs() << "llvm-objdump: '" << Filename << "': "
-           << "Unrecognized file type.\n";
+    return;
+  }
+  llvm_unreachable("Input object can't be invalid at this point");
 }
 
 typedef std::pair<uint64_t, const char *> BindInfoEntry;
@@ -6771,6 +6770,22 @@ static unsigned getSizeForEncoding(bool is64Bit,
   }
 }
 
+static uint64_t readPointer(const char *&Pos, bool is64Bit, unsigned Encoding) {
+  switch (getSizeForEncoding(is64Bit, Encoding)) {
+    case 2:
+      return readNext<uint16_t>(Pos);
+      break;
+    case 4:
+      return readNext<uint32_t>(Pos);
+      break;
+    case 8:
+      return readNext<uint64_t>(Pos);
+      break;
+    default:
+      llvm_unreachable("Illegal data size");
+  }
+}
+
 static void printMachOEHFrameSection(const MachOObjectFile *Obj,
                                      std::map<uint64_t, SymbolRef> &Symbols,
                                      const SectionRef &EHFrame) {
@@ -6867,19 +6882,7 @@ static void printMachOEHFrameSection(const MachOObjectFile *Obj,
             case 'P': {
               assert(!Personality && "Duplicate personality");
               PersonalityEncoding = readNext<uint8_t>(Pos);
-              switch (getSizeForEncoding(is64Bit, *PersonalityEncoding)) {
-                case 2:
-                  Personality = readNext<uint16_t>(Pos);
-                  break;
-                case 4:
-                  Personality = readNext<uint32_t>(Pos);
-                  break;
-                case 8:
-                  Personality = readNext<uint64_t>(Pos);
-                  break;
-                default:
-                  llvm_unreachable("Illegal data size");
-              }
+              Personality = readPointer(Pos, is64Bit, *PersonalityEncoding);
               break;
             }
             case 'R':
@@ -6953,24 +6956,8 @@ static void printMachOEHFrameSection(const MachOObjectFile *Obj,
     uint64_t PCPointerSize = getSizeForEncoding(is64Bit,
                                                 *CIE.FDEPointerEncoding);
 
-    uint64_t PCBegin;
-    uint64_t PCRange;
-    switch (PCPointerSize) {
-      case 2:
-        PCBegin = readNext<uint16_t>(Pos);
-        PCRange = readNext<uint16_t>(Pos);
-        break;
-      case 4:
-        PCBegin = readNext<uint32_t>(Pos);
-        PCRange = readNext<uint32_t>(Pos);
-        break;
-      case 8:
-        PCBegin = readNext<uint64_t>(Pos);
-        PCRange = readNext<uint64_t>(Pos);
-        break;
-      default:
-        llvm_unreachable("Illegal data size");
-    }
+    uint64_t PCBegin = readPointer(Pos, is64Bit, *CIE.FDEPointerEncoding);
+    uint64_t PCRange = readPointer(Pos, is64Bit, *CIE.FDEPointerEncoding);
 
     Optional<uint64_t> AugmentationLength;
     uint32_t LSDAPointerSize;
@@ -6984,19 +6971,7 @@ static void printMachOEHFrameSection(const MachOObjectFile *Obj,
       // Decode the LSDA if the CIE augmentation string said we should.
       if (CIE.LSDAPointerEncoding) {
         LSDAPointerSize = getSizeForEncoding(is64Bit, *CIE.LSDAPointerEncoding);
-        switch (LSDAPointerSize) {
-          case 2:
-            LSDAPointer = readNext<uint16_t>(Pos);
-            break;
-          case 4:
-            LSDAPointer = readNext<uint32_t>(Pos);
-            break;
-          case 8:
-            LSDAPointer = readNext<uint64_t>(Pos);
-            break;
-          default:
-            llvm_unreachable("Illegal data size");
-        }
+        LSDAPointer = readPointer(Pos, is64Bit, *CIE.LSDAPointerEncoding);
       }
     }
 
@@ -8674,31 +8649,40 @@ static void PrintLoadCommands(const MachOObjectFile *Obj, uint32_t filetype,
   }
 }
 
-static void getAndPrintMachHeader(const MachOObjectFile *Obj,
-                                  uint32_t &filetype, uint32_t &cputype,
-                                  bool verbose) {
+static void PrintMachHeader(const MachOObjectFile *Obj, bool verbose) {
   if (Obj->is64Bit()) {
     MachO::mach_header_64 H_64;
     H_64 = Obj->getHeader64();
     PrintMachHeader(H_64.magic, H_64.cputype, H_64.cpusubtype, H_64.filetype,
                     H_64.ncmds, H_64.sizeofcmds, H_64.flags, verbose);
-    filetype = H_64.filetype;
-    cputype = H_64.cputype;
   } else {
     MachO::mach_header H;
     H = Obj->getHeader();
     PrintMachHeader(H.magic, H.cputype, H.cpusubtype, H.filetype, H.ncmds,
                     H.sizeofcmds, H.flags, verbose);
-    filetype = H.filetype;
-    cputype = H.cputype;
   }
 }
 
 void llvm::printMachOFileHeader(const object::ObjectFile *Obj) {
+  const MachOObjectFile *file = dyn_cast<const MachOObjectFile>(Obj);
+  PrintMachHeader(file, !NonVerbose);
+}
+
+void llvm::printMachOLoadCommands(const object::ObjectFile *Obj) {
   const MachOObjectFile *file = dyn_cast<const MachOObjectFile>(Obj);
   uint32_t filetype = 0;
   uint32_t cputype = 0;
-  getAndPrintMachHeader(file, filetype, cputype, !NonVerbose);
+  if (file->is64Bit()) {
+    MachO::mach_header_64 H_64;
+    H_64 = file->getHeader64();
+    filetype = H_64.filetype;
+    cputype = H_64.cputype;
+  } else {
+    MachO::mach_header H;
+    H = file->getHeader();
+    filetype = H.filetype;
+    cputype = H.cputype;
+  }
   PrintLoadCommands(file, filetype, cputype, !NonVerbose);
 }