pseudo-reloc.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <memory.h>
#include <internal.h>

Include dependency graph for pseudo-reloc.c:

Go to the source code of this file.

Classes
struct	runtime_pseudo_reloc_item_v1
struct	runtime_pseudo_reloc_item_v2
struct	runtime_pseudo_reloc_v2

Macros
#define	NO_COPY
#define	ATTRIBUTE_NORETURN
#define	__MINGW_LSYMBOL(sym)   sym
#define	RP_VERSION_V1   0
#define	RP_VERSION_V2   1

Functions
char	__MINGW_LSYMBOL (_image_base__)
void	_pei386_runtime_relocator (void)
static void ATTRIBUTE_NORETURN	__report_error (const char *msg,...)
static void	__write_memory (void *addr, const void *src, size_t len)
static void	do_pseudo_reloc (void *start, void *end, void *base)

Variables
char	__RUNTIME_PSEUDO_RELOC_LIST__
char	__RUNTIME_PSEUDO_RELOC_LIST_END__

Macro Definition Documentation

__MINGW_LSYMBOL

#define __MINGW_LSYMBOL

(

sym

)

sym

Definition at line 45 of file pseudo-reloc.c.

ATTRIBUTE_NORETURN

#define ATTRIBUTE_NORETURN

Definition at line 41 of file pseudo-reloc.c.

NO_COPY

#define NO_COPY

Definition at line 35 of file pseudo-reloc.c.

RP_VERSION_V1

#define RP_VERSION_V1   0

Definition at line 294 of file pseudo-reloc.c.

RP_VERSION_V2

#define RP_VERSION_V2   1

Definition at line 295 of file pseudo-reloc.c.

Function Documentation

__MINGW_LSYMBOL()

char __MINGW_LSYMBOL

(

_image_base__

)

__report_error()

static void ATTRIBUTE_NORETURN __report_error ( const char *  msg,   ...  )

static

Definition at line 83 of file pseudo-reloc.c.

{
#ifdef __CYGWIN__
  /* This function is used to print short error messages
   * to stderr, which may occur during DLL initialization
   * while fixing up 'pseudo' relocations. This early, we
   * may not be able to use cygwin stdio functions, so we
   * use the win32 WriteFile api. This should work with both
   * normal win32 console IO handles, redirected ones, and
   * cygwin ptys.
   */
  char buf[SHORT_MSG_BUF_SZ];
  wchar_t module[MAX_PATH];
  char * posix_module = NULL;
  static const char   UNKNOWN_MODULE[] = "<unknown module>: ";
  static const size_t UNKNOWN_MODULE_LEN = sizeof (UNKNOWN_MODULE) - 1;
  static const char   CYGWIN_FAILURE_MSG[] = "Cygwin runtime failure: ";
  static const size_t CYGWIN_FAILURE_MSG_LEN = sizeof (CYGWIN_FAILURE_MSG) - 1;
  DWORD len;
  DWORD done;
  va_list args;
  HANDLE errh = GetStdHandle (STD_ERROR_HANDLE);
  ssize_t modulelen = GetModuleFileNameW (NULL, module, sizeof (module));
 
  if (errh == INVALID_HANDLE_VALUE)
    cygwin_internal (CW_EXIT_PROCESS,
                     STATUS_ILLEGAL_DLL_PSEUDO_RELOCATION,
                     1);
 
  if (modulelen > 0)
    posix_module = cygwin_create_path (CCP_WIN_W_TO_POSIX, module);
 
  va_start (args, msg);
  len = (DWORD) vsnprintf (buf, SHORT_MSG_BUF_SZ, msg, args);
  va_end (args);
  buf[SHORT_MSG_BUF_SZ-1] = '\0'; /* paranoia */
 
  if (posix_module)
    {
      WriteFile (errh, (PCVOID)CYGWIN_FAILURE_MSG,
                 CYGWIN_FAILURE_MSG_LEN, &done, NULL);
      WriteFile (errh, (PCVOID)posix_module,
                 strlen(posix_module), &done, NULL);
      WriteFile (errh, (PCVOID)": ", 2, &done, NULL);
      WriteFile (errh, (PCVOID)buf, len, &done, NULL);
      free (posix_module);
    }
  else
    {
      WriteFile (errh, (PCVOID)CYGWIN_FAILURE_MSG,
                 CYGWIN_FAILURE_MSG_LEN, &done, NULL);
      WriteFile (errh, (PCVOID)UNKNOWN_MODULE,
                 UNKNOWN_MODULE_LEN, &done, NULL);
      WriteFile (errh, (PCVOID)buf, len, &done, NULL);
    }
  WriteFile (errh, (PCVOID)"\n", 1, &done, NULL);
 
  cygwin_internal (CW_EXIT_PROCESS,
                   STATUS_ILLEGAL_DLL_PSEUDO_RELOCATION,
                   1);
  /* not reached, but silences noreturn warning */
  abort ();
#else
  va_list argp;
  va_start (argp, msg);
# ifdef __MINGW64_VERSION_MAJOR
  __mingw_fprintf (stderr, "Mingw-w64 runtime failure:\n");
  __mingw_vfprintf (stderr, msg, argp);
# else
  fprintf (stderr, "Mingw runtime failure:\n");
  vfprintf (stderr, msg, argp);
#endif
  va_end (argp);
  abort ();
#endif
}

Referenced by __write_memory(), and do_pseudo_reloc().

__write_memory()

static void __write_memory ( void *  addr, const void *  src, size_t  len  )

static

Definition at line 260 of file pseudo-reloc.c.

{
  MEMORY_BASIC_INFORMATION b;
  DWORD oldprot;
  int call_unprotect = 0;
 
  if (!len)
    return;
 
#ifdef __MINGW64_VERSION_MAJOR
  mark_section_writable ((LPVOID) addr);
#endif
 
  if (!VirtualQuery (addr, &b, sizeof(b)))
    {
      __report_error ("  VirtualQuery failed for %d bytes at address %p",
              (int) sizeof(b), addr);
    }
 
  /* Temporarily allow write access to read-only protected memory.  */
  if (b.Protect != PAGE_EXECUTE_READWRITE && b.Protect != PAGE_READWRITE)
    {
      call_unprotect = 1;
      VirtualProtect (b.BaseAddress, b.RegionSize, PAGE_EXECUTE_READWRITE,
              &oldprot);
    }
 
  /* write the data. */
  memcpy (addr, src, len);
  /* Restore original protection. */
  if (call_unprotect && b.Protect != PAGE_EXECUTE_READWRITE && b.Protect != PAGE_READWRITE)
    VirtualProtect (b.BaseAddress, b.RegionSize, oldprot, &oldprot);
}

Referenced by do_pseudo_reloc().

_pei386_runtime_relocator()

void _pei386_runtime_relocator

(

void

)

Definition at line 455 of file pseudo-reloc.c.

{
  static NO_COPY int was_init = 0;
#ifdef __MINGW64_VERSION_MAJOR
  int mSecs;
#endif /* __MINGW64_VERSION_MAJOR */
 
  if (was_init)
    return;
  ++was_init;
#ifdef __MINGW64_VERSION_MAJOR
  mSecs = __mingw_GetSectionCount ();
  the_secs = (sSecInfo *) alloca (sizeof (sSecInfo) * (size_t) mSecs);
  maxSections = 0;
#endif /* __MINGW64_VERSION_MAJOR */
 
  do_pseudo_reloc (&__RUNTIME_PSEUDO_RELOC_LIST__,
           &__RUNTIME_PSEUDO_RELOC_LIST_END__,
#ifdef __GNUC__
           &__MINGW_LSYMBOL(_image_base__)
#else
           &__ImageBase
#endif
           );
#ifdef __MINGW64_VERSION_MAJOR
  restore_modified_sections ();
#endif /* __MINGW64_VERSION_MAJOR */
}

do_pseudo_reloc()

static void do_pseudo_reloc ( void *  start, void *  end, void *  base  )

static

Definition at line 298 of file pseudo-reloc.c.

{
  ptrdiff_t addr_imp, reldata;
  ptrdiff_t reloc_target = (ptrdiff_t) ((char *)end - (char*)start);
  runtime_pseudo_reloc_v2 *v2_hdr = (runtime_pseudo_reloc_v2 *) start;
  runtime_pseudo_reloc_item_v2 *r;
 
  /* A valid relocation list will contain at least one entry, and
   * one v1 data structure (the smallest one) requires two DWORDs.
   * So, if the relocation list is smaller than 8 bytes, bail.
   */
  if (reloc_target < 8)
    return;
 
  /* Check if this is the old pseudo relocation version.  */
  /* There are two kinds of v1 relocation lists:
   *   1) With a (v2-style) version header. In this case, the
   *      first entry in the list is a 3-DWORD structure, with
   *      value:
   *         { 0, 0, RP_VERSION_V1 }
   *      In this case, we skip to the next entry in the list,
   *      knowing that all elements after the head item can
   *      be cast to runtime_pseudo_reloc_item_v1.
   *   2) Without a (v2-style) version header. In this case, the
   *      first element in the list IS an actual v1 relocation
   *      record, which is two DWORDs.  Because there will never
   *      be a case where a v1 relocation record has both
   *      addend == 0 and target == 0, this case will not be
   *      confused with the prior one.
   * All current binutils, when generating a v1 relocation list,
   * use the second (e.g. original) form -- that is, without the
   * v2-style version header.
   */
  if (reloc_target >= 12
      && v2_hdr->magic1 == 0 && v2_hdr->magic2 == 0
      && v2_hdr->version == RP_VERSION_V1)
    {
      /* We have a list header item indicating that the rest
       * of the list contains v1 entries.  Move the pointer to
       * the first true v1 relocation record.  By definition,
       * that v1 element will not have both addend == 0 and
       * target == 0 (and thus, when interpreted as a
       * runtime_pseudo_reloc_v2, it will not have both
       * magic1 == 0 and magic2 == 0).
       */
      v2_hdr++;
    }
 
  if (v2_hdr->magic1 != 0 || v2_hdr->magic2 != 0)
    {
      /*************************
       * Handle v1 relocations *
       *************************/
      runtime_pseudo_reloc_item_v1 * o;
      for (o = (runtime_pseudo_reloc_item_v1 *) v2_hdr;
       o < (runtime_pseudo_reloc_item_v1 *)end;
           o++)
    {
      DWORD newval;
      reloc_target = (ptrdiff_t) base + o->target;
      newval = (*((DWORD*) reloc_target)) + o->addend;
      __write_memory ((void *) reloc_target, &newval, sizeof(DWORD));
    }
      return;
    }
 
  /* If we got this far, then we have relocations of version 2 or newer */
 
  /* Check if this is a known version.  */
  if (v2_hdr->version != RP_VERSION_V2)
    {
      __report_error ("  Unknown pseudo relocation protocol version %d.\n",
              (int) v2_hdr->version);
      return;
    }
 
  /*************************
   * Handle v2 relocations *
   *************************/
 
  /* Walk over header. */
  r = (runtime_pseudo_reloc_item_v2 *) &v2_hdr[1];
 
  for (; r < (runtime_pseudo_reloc_item_v2 *) end; r++)
    {
      /* location where new address will be written */
      reloc_target = (ptrdiff_t) base + r->target;
 
      /* get sym pointer. It points either to the iat entry
       * of the referenced element, or to the stub function.
       */
      addr_imp = (ptrdiff_t) base + r->sym;
      addr_imp = *((ptrdiff_t *) addr_imp);
 
      /* read existing relocation value from image, casting to the
       * bitsize indicated by the 8 LSBs of flags. If the value is
       * negative, manually sign-extend to ptrdiff_t width. Raise an
       * error if the bitsize indicated by the 8 LSBs of flags is not
       * supported.
       */
      switch ((r->flags & 0xff))
        {
          case 8:
        reldata = (ptrdiff_t) (*((unsigned char *)reloc_target));
        if ((reldata & 0x80) != 0)
          reldata |= ~((ptrdiff_t) 0xff);
        break;
      case 16:
        reldata = (ptrdiff_t) (*((unsigned short *)reloc_target));
        if ((reldata & 0x8000) != 0)
          reldata |= ~((ptrdiff_t) 0xffff);
        break;
      case 32:
        reldata = (ptrdiff_t) (*((unsigned int *)reloc_target));
#ifdef _WIN64
        if ((reldata & 0x80000000) != 0)
          reldata |= ~((ptrdiff_t) 0xffffffff);
#endif
        break;
#ifdef _WIN64
      case 64:
        reldata = (ptrdiff_t) (*((unsigned long long *)reloc_target));
        break;
#endif
      default:
        reldata=0;
        __report_error ("  Unknown pseudo relocation bit size %d.\n",
            (int) (r->flags & 0xff));
        break;
        }
 
      /* Adjust the relocation value */
      reldata -= ((ptrdiff_t) base + r->sym);
      reldata += addr_imp;
 
      /* Write the new relocation value back to *reloc_target */
      switch ((r->flags & 0xff))
    {
         case 8:
           __write_memory ((void *) reloc_target, &reldata, 1);
       break;
     case 16:
           __write_memory ((void *) reloc_target, &reldata, 2);
       break;
     case 32:
           __write_memory ((void *) reloc_target, &reldata, 4);
       break;
#ifdef _WIN64
     case 64:
           __write_memory ((void *) reloc_target, &reldata, 8);
       break;
#endif
    }
     }
}

Referenced by _pei386_runtime_relocator().

Variable Documentation

__RUNTIME_PSEUDO_RELOC_LIST__

char __RUNTIME_PSEUDO_RELOC_LIST__

extern

Definition at line 8 of file pseudo-reloc-list.c.

Referenced by _pei386_runtime_relocator().

__RUNTIME_PSEUDO_RELOC_LIST_END__

char __RUNTIME_PSEUDO_RELOC_LIST_END__

extern

This file has no copyright assigned and is placed in the Public Domain. This file is part of the w64 mingw-runtime package. No warranty is given; refer to the file DISCLAIMER.PD within this package.

Definition at line 7 of file pseudo-reloc-list.c.

Referenced by _pei386_runtime_relocator().