Allow to retrieve id of a module from memory instead of going to disk for iOS.

src/common/mac/macho_walker.cc

 // Copyright (c) 2006, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 34 matching lines @@
 
 #include "common/mac/byteswap.h"
 #include "common/mac/macho_walker.h"
 #include "common/mac/macho_utilities.h"
 
 namespace MacFileUtilities {
 
 MachoWalker::MachoWalker(const char *path, LoadCommandCallback callback,
                          void *context)
     : file_(0),
+      memory_(NULL),
+      memory_size_(0),
       callback_(callback),
       callback_context_(context),
       current_header_(NULL),
       current_header_size_(0),
       current_header_offset_(0) {
   file_ = open(path, O_RDONLY);
 }
 
+MachoWalker::MachoWalker(void *memory, size_t size,
+                         LoadCommandCallback callback, void *context)
+    : file_(0),
+      memory_(memory),
+      memory_size_(size),
+      callback_(callback),
+      callback_context_(context),
+      current_header_(NULL),
+      current_header_size_(0),
+      current_header_offset_(0) {
+}
+
 MachoWalker::~MachoWalker() {
   if (file_ != -1)
     close(file_);
 }
 
 int MachoWalker::ValidateCPUType(int cpu_type) {
   // If the user didn't specify, use the local architecture.
   if (cpu_type == 0) {
     const NXArchInfo *arch = NXGetLocalArchInfo();
     assert(arch);
@@ skipping 10 matching lines @@
     if (cpu_type & CPU_ARCH_ABI64)
       return WalkHeader64AtOffset(offset);
 
     return WalkHeaderAtOffset(offset);
   }
 
   return false;
 }
 
 bool MachoWalker::ReadBytes(void *buffer, size_t size, off_t offset) {
-  return pread(file_, buffer, size, offset) == (ssize_t)size;
+  if (memory_) {
+    bool result = true;
+    if (offset + size > memory_size_) {
+      size = memory_size_ - offset;
+      result = false;
+    }
+    if (size < 0)

[Mark Mentovai, 2011/10/20 15:22:17]

I think this is ineffective, because size is a size_t, which is unsigned. You
can probably just get rid of this. I’m surprised the compiler didn’t complain. I
guess this warning is only enabled with -Wextra with GCC. Clang warns about it
more readily.

+      return false;
+    memcpy(buffer, static_cast<char *>(memory_) + offset, size);
+    return result;
+  } else {
+    return pread(file_, buffer, size, offset) == (ssize_t)size;
+  }
 }
 
 bool MachoWalker::CurrentHeader(struct mach_header_64 *header, off_t *offset) {
   if (current_header_) {
     memcpy(header, current_header_, sizeof(mach_header_64));
     *offset = current_header_offset_;
     return true;
   }
 
   return false;
@@ skipping 126 matching lines @@
     if (callback_ && !callback_(this, &cmd, offset, swap, callback_context_))
       break;
 
     offset += cmd.cmdsize;
   }
 
   return true;
 }
 
 }  // namespace MacFileUtilities