More compatibility changes.

src/platform-linux.cc

 // Copyright 2006-2008 the V8 project authors. 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
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 26 matching lines @@
 #include <stdlib.h>
 
 // Ubuntu Dapper requires memory pages to be marked as
 // executable. Otherwise, OS raises an exception when executing code
 // in that page.
 #include <sys/types.h>  // mmap & munmap
 #include <sys/mman.h>   // mmap & munmap
 #include <sys/stat.h>   // open
 #include <fcntl.h>      // open
 #include <unistd.h>     // sysconf
+#ifdef __GLIBC__
 #include <execinfo.h>   // backtrace, backtrace_symbols
+#endif  // def __GLIBC__
 #include <strings.h>    // index
 #include <errno.h>
 #include <stdarg.h>
 
 #include <arpa/inet.h>
 #include <netinet/in.h>
 #include <netdb.h>
 
 #undef MAP_TYPE
 
@@ skipping 296 matching lines @@
     if (start_of_path == NULL) continue;
     buffer[bytes_read] = 0;
     LOG(SharedLibraryEvent(start_of_path, start, end));
   }
   close(fd);
 #endif
 }
 
 
 int OS::StackWalk(OS::StackFrame* frames, int frames_size) {
+  // backtrace is a glibc extension.
+#ifdef __GLIBC__
   void** addresses = NewArray<void*>(frames_size);
 
   int frames_count = backtrace(addresses, frames_size);
 
   char** symbols;
   symbols = backtrace_symbols(addresses, frames_count);
   if (symbols == NULL) {
     DeleteArray(addresses);
     return kStackWalkError;
   }
 
   for (int i = 0; i < frames_count; i++) {
     frames[i].address = addresses[i];
     // Format a text representation of the frame based on the information
     // available.
     SNPrintF(MutableCStrVector(frames[i].text, kStackWalkMaxTextLen),
              "%s",
              symbols[i]);
     // Make sure line termination is in place.
     frames[i].text[kStackWalkMaxTextLen - 1] = '\0';
   }
 
   DeleteArray(addresses);
   free(symbols);
 
   return frames_count;
+#else  // ndef __GLIBC__
+  return 0;
+#endif  // ndef __GLIBC__
 }
 
 
 // Constants used for mmap.
 static const int kMmapFd = -1;
 static const int kMmapFdOffset = 0;
 
 
 VirtualMemory::VirtualMemory(size_t size) {
   address_ = mmap(NULL, size, PROT_NONE,
@@ skipping 407 matching lines @@
 Socket* OS::CreateSocket() {
   return new LinuxSocket();
 }
 
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
 
 static Sampler* active_sampler_ = NULL;
 
 static void ProfilerSignalHandler(int signal, siginfo_t* info, void* context) {
+  // Ucontext is a glibc extension - no profiling on Android at the moment.
+#ifdef __GLIBC__
   USE(info);
   if (signal != SIGPROF) return;
   if (active_sampler_ == NULL) return;
 
   TickSample sample;
 
   // If profiling, we extract the current pc and sp.
   if (active_sampler_->IsProfiling()) {
     // Extracting the sample from the context is extremely machine dependent.
     ucontext_t* ucontext = reinterpret_cast<ucontext_t*>(context);
     mcontext_t& mcontext = ucontext->uc_mcontext;
 #if defined (__arm__) || defined(__thumb__)
     sample.pc = mcontext.gregs[R15];
     sample.sp = mcontext.gregs[R13];
     sample.fp = mcontext.gregs[R11];
 #else
     sample.pc = mcontext.gregs[REG_EIP];
     sample.sp = mcontext.gregs[REG_ESP];
     sample.fp = mcontext.gregs[REG_EBP];
 #endif
   }
 
   // We always sample the VM state.
   sample.state = Logger::state();
 
   active_sampler_->Tick(&sample);
+#endif
 }
 
 
 class Sampler::PlatformData : public Malloced {
  public:
   PlatformData() {
     signal_handler_installed_ = false;
   }
 
   bool signal_handler_installed_;
@@ skipping 49 matching lines @@
   }
 
   // This sampler is no longer the active sampler.
   active_sampler_ = NULL;
   active_ = false;
 }
 
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 } }  // namespace v8::internal