rpm-SIGCHLD.patch

   1 diff -ruN rpm-4.1/lib/psm.c rpm-4.1-9/lib/psm.c
   2 --- rpm-4.1/lib/psm.c   Tue Sep 17 16:18:50 2002
   3 +++ rpm-4.1-9/lib/psm.c Mon Oct  7 12:36:35 2002
   4 @@ -695,15 +695,19 @@
   5         (void) sigaddset(&caught, signum);
   6         switch (signum) {
   7         case SIGCHLD:
   8 -       {   int status = 0;
   9 -           pid_t reaped = waitpid(0, &status, WNOHANG);
  10 -           int i;
  11 -
  12 -           if (psmtbl.psms)
  13 -           for (i = 0; i < psmtbl.npsms; i++) {
  14 -               rpmpsm psm = psmtbl.psms[i];
  15 -               if (psm->child != reaped)
  16 -                   /*@innercontinue@*/ continue;
  17 +           while (1) {
  18 +               int status = 0;
  19 +               pid_t reaped = waitpid(0, &status, WNOHANG);
  20 +               int i;
  21 +
  22 +               if (reaped <= 0)
  23 +                   /*@innerbreak@*/ break;
  24 +
  25 +               if (psmtbl.psms)
  26 +               for (i = 0; i < psmtbl.npsms; i++) {
  27 +                   rpmpsm psm = psmtbl.psms[i];
  28 +                   if (psm->child != reaped)
  29 +                       /*@innercontinue@*/ continue;
  30
  31  #if _PSM_DEBUG
  32  /*@-modfilesys@*/
  33 @@ -712,11 +716,12 @@
  34  /*@=modfilesys@*/
  35  #endif
  36
  37 -               psm->reaped = reaped;
  38 -               psm->status = status;
  39 -               /*@innerbreak@*/ break;
  40 +                   psm->reaped = reaped;
  41 +                   psm->status = status;
  42 +                   /*@innerbreak@*/ break;
  43 +               }
  44             }
  45 -       }   /*@switchbreak@*/ break;
  46 +           /*@switchbreak@*/ break;
  47         default:
  48             /*@switchbreak@*/ break;
  49         }
  50 @@ -782,26 +787,6 @@
  51  }
  52
  53  /**
  54 - * Fork a new process.
  55 - * @param psm          package state machine data
  56 - * @return             fork(2) pid
  57 - */
  58 -static pid_t psmFork(rpmpsm psm)
  59 -       /*@globals fileSystem, internalState @*/
  60 -       /*@modifies fileSystem, internalState @*/
  61 -{
  62 -    pid_t pid;
  63 -
  64 -    if ((pid = fork()) != 0) {
  65 -/*@-modfilesys@*/
  66 -if (_psm_debug)
  67 -fprintf(stderr, "      Fork: %p[%d:%d:%d] = %p child %d\n", psmtbl.psms, 0, psmtbl.npsms, psmtbl.nalloced, psm, pid);
  68 -/*@=modfilesys@*/
  69 -    }
  70 -    return pid;
  71 -}
  72 -
  73 -/**
  74   * Register a child reaper, then fork a child.
  75   * @param psm          package state machine data
  76   * @return             fork(2) pid
  77 @@ -835,7 +820,6 @@
  78         }
  79         empty = psmtbl.npsms++;
  80      }
  81 -    psm->reaped = 0;
  82      if (psmtbl.psms)   /* XXX can't happen */
  83         psmtbl.psms[empty] = rpmpsmLink(psm, "psmRegister");
  84  /*@-modfilesys@*/
  85 @@ -844,15 +828,24 @@
  86  /*@=modfilesys@*/
  87
  88      (void) enableSignal(SIGCHLD);
  89 +
  90 +    psm->reaped = 0;
  91 +    if ((psm->child = fork()) != 0) {
  92 +/*@-modfilesys@*/
  93 +if (_psm_debug)
  94 +fprintf(stderr, "      Fork: %p[%d:%d:%d] = %p child %d\n", psmtbl.psms, 0, psmtbl.npsms, psmtbl.nalloced, psm, psm->child);
  95 +/*@=modfilesys@*/
  96 +    }
  97 +
  98      (void) sigprocmask(SIG_SETMASK, &oldMask, NULL);
  99
 100 -    return psmFork(psm);
 101 +    return psm->child;
 102  }
 103
 104  /**
 105   * Unregister a child reaper.
 106   */
 107 -static int psmUnregister(rpmpsm psm, pid_t child)
 108 +static int psmWaitUnregister(rpmpsm psm, pid_t child)
 109         /*@globals psmtbl, fileSystem, internalState @*/
 110         /*@modifies psmtbl, fileSystem, internalState @*/
 111  {
 112 @@ -862,6 +855,19 @@
 113      (void) sigfillset(&newMask);               /* block all signals */
 114      (void) sigprocmask(SIG_BLOCK, &newMask, &oldMask);
 115
 116 +    /*@-infloops@*/
 117 +    while (psm->reaped != psm->child) {
 118 +       (void) sigprocmask(SIG_SETMASK, &oldMask, NULL);
 119 +       (void) pause();
 120 +       (void) sigprocmask(SIG_BLOCK, &newMask, &oldMask);
 121 +    }
 122 +    /*@=infloops@*/
 123 +
 124 +/*@-modfilesys@*/
 125 +if (_psm_debug)
 126 +fprintf(stderr, "      Wait: %p[%d:%d:%d] = %p child %d\n", psmtbl.psms, 0, psmtbl.npsms, psmtbl.nalloced, psm, psm->child);
 127 +/*@=modfilesys@*/
 128 +
 129      if (psmtbl.psms)
 130      for (i = 0; i < psmtbl.npsms; i++) {
 131         if (psmtbl.psms[i] == NULL)
 132 @@ -893,25 +899,6 @@
 133  }
 134
 135  /**
 136 - * Return reaped pid safely (i.e. with signals blocked).
 137 - * @param psm          package state machine data
 138 - * @return
 139 - */
 140 -static inline pid_t psmGetReaped(rpmpsm psm)
 141 -       /*@globals fileSystem @*/
 142 -       /*@modifies fileSystem @*/
 143 -{
 144 -    sigset_t newMask, oldMask;
 145 -    pid_t reaped;
 146 -
 147 -    (void) sigfillset(&newMask);               /* block all signals */
 148 -    (void) sigprocmask(SIG_BLOCK, &newMask, &oldMask);
 149 -    reaped = psm->reaped;
 150 -    (void) sigprocmask(SIG_SETMASK, &oldMask, NULL);
 151 -    return reaped;
 152 -}
 153 -
 154 -/**
 155   * Wait for child process to be reaped.
 156   * @param psm          package state machine data
 157   * @return
 158 @@ -921,15 +908,7 @@
 159         /*@modifies psm, fileSystem, internalState @*/
 160  {
 161      if (psm->reaper) {
 162 -       /*@-infloops@*/
 163 -       while (psmGetReaped(psm) == 0)
 164 -           (void) pause();
 165 -       /*@=infloops@*/
 166 -/*@-modfilesys@*/
 167 -if (_psm_debug)
 168 -fprintf(stderr, "      Wait: %p[%d:%d:%d] = %p child %d\n", psmtbl.psms, 0, psmtbl.npsms, psmtbl.nalloced, psm, psm->child);
 169 -/*@=modfilesys@*/
 170 -       (void) psmUnregister(psm, psm->child);
 171 +       (void) psmWaitUnregister(psm, psm->child);
 172      } else {
 173         do {
 174             psm->reaped = waitpid(psm->child, &psm->status, 0);
 175 @@ -997,7 +976,6 @@
 176      FD_t out;
 177      rpmRC rc = RPMRC_OK;
 178      const char *n, *v, *r;
 179 -    pid_t pid;
 180
 181      if (progArgv == NULL && script == NULL)
 182         return rc;
 183 @@ -1119,8 +1097,7 @@
 184      if (out == NULL) return RPMRC_FAIL;        /* XXX can't happen */
 185
 186      /*@-branchstate@*/
 187 -    pid = psmRegisterFork(psm);
 188 -    psm->child = pid;
 189 +    (void) psmRegisterFork(psm);
 190      if (psm->child == 0) {
 191         const char * rootDir;
 192         int pipes[2];
 193
 194 diff -ruN rpm-4.1/rpmio/rpmlog.c rpm-4.1-9/rpmio/rpmlog.c
 195 --- rpm-4.1/rpmio/rpmlog.c      Wed Jul  3 01:54:38 2002
 196 +++ rpm-4.1-9/rpmio/rpmlog.c    Fri Sep 20 18:33:06 2002
 197 @@ -179,6 +179,7 @@
 198         else                    /* glibc 2.0 */
 199             msgnb *= 2;
 200         msgbuf = xrealloc(msgbuf, msgnb);
 201 +       va_end(apc);
 202      }
 203      msgbuf[msgnb - 1] = '\0';
 204      msg = msgbuf;
 205 diff -ruN rpm-4.1/tools/sections.c rpm-4.1-9/tools/sections.c
 206 --- rpm-4.1/tools/sections.c    Thu Aug 22 19:57:41 2002
 207 +++ rpm-4.1-9/tools/sections.c  Sun Oct  6 07:30:41 2002
 208 @@ -24,38 +24,168 @@
 209  } UnstripInfo32;
 210
 211  typedef struct {
 212 -  Elf32_Off orig_e_shoff;
 213 -  Elf32_Off n_sections;
 214 +  Elf64_Off orig_e_shoff;
 215 +  Elf64_Off n_sections;
 216    UnstripInfoSection64 sections[1];
 217  } UnstripInfo64;
 218
 219 +static uint32_t
 220 +elf_32_to_file (uint32_t x, int file_is_little_endian)
 221 +{
 222 +  volatile uint32_t out;
 223 +  unsigned char *outbytes;
 224 +
 225 +  outbytes = (unsigned char *)&out;
 226 +  if (file_is_little_endian)
 227 +    {
 228 +      outbytes[0] = (x >> 0) & 0xff;
 229 +      outbytes[1] = (x >> 8) & 0xff;
 230 +      outbytes[2] = (x >> 16) & 0xff;
 231 +      outbytes[3] = (x >> 24) & 0xff;
 232 +    }
 233 +  else /* big endian */
 234 +    {
 235 +      outbytes[0] = (x >> 24) & 0xff;
 236 +      outbytes[1] = (x >> 16) & 0xff;
 237 +      outbytes[2] = (x >> 8) & 0xff;
 238 +      outbytes[3] = (x >> 0) & 0xff;
 239 +    }
 240 +
 241 +  return out;
 242 +}
 243 +
 244 +static uint64_t
 245 +elf_64_to_file (uint64_t x, int file_is_little_endian)
 246 +{
 247 +  volatile uint64_t out;
 248 +  unsigned char *outbytes;
 249 +  int i;
 250 +
 251 +  outbytes = (unsigned char *)&out;
 252 +  if (file_is_little_endian)
 253 +    {
 254 +      for (i = 0; i < 8; i++)
 255 +       outbytes[i] = (x >> (8*i)) & 0xff;
 256 +    }
 257 +  else /* big endian */
 258 +    {
 259 +      for (i = 0; i < 8; i++)
 260 +       outbytes[7-i] = (x >> (8*i)) & 0xff;
 261 +    }
 262 +
 263 +  return out;
 264 +}
 265
 266  static Elf32_Word
 267  word32_to_file (Elf32_Word x, Elf *elf)
 268  {
 269 -  /* FIXME: implement */
 270 -  return x;
 271 +  Elf32_Ehdr *ehdr = elf32_getehdr (elf);
 272 +  return elf_32_to_file (x, ehdr->e_ident[EI_DATA] & ELFDATA2LSB);
 273  }
 274
 275  static Elf32_Off
 276  off32_to_file (Elf32_Off x, Elf *elf)
 277  {
 278 -  /* FIXME: implement */
 279 -  return x;
 280 +  Elf32_Ehdr *ehdr = elf32_getehdr (elf);
 281 +  return elf_32_to_file (x, ehdr->e_ident[EI_DATA] & ELFDATA2LSB);
 282 +}
 283 +
 284 +static Elf64_Word
 285 +word64_to_file (Elf64_Word x, Elf *elf)
 286 +{
 287 +  Elf64_Ehdr *ehdr = elf64_getehdr (elf);
 288 +  return elf_32_to_file (x, ehdr->e_ident[EI_DATA] & ELFDATA2LSB);
 289 +}
 290 +
 291 +static Elf64_Off
 292 +off64_to_file (Elf64_Off x, Elf *elf)
 293 +{
 294 +  Elf64_Ehdr *ehdr = elf64_getehdr (elf);
 295 +  return elf_64_to_file (x, ehdr->e_ident[EI_DATA] & ELFDATA2LSB);
 296 +}
 297 +
 298 +static uint32_t
 299 +elf_32_from_file (uint32_t x, int file_is_little_endian)
 300 +{
 301 +  unsigned char *inbytes;
 302 +
 303 +  inbytes = (unsigned char *)&x;
 304 +  if (file_is_little_endian)
 305 +    {
 306 +      return
 307 +       (inbytes[0] << 0) |
 308 +       (inbytes[1] << 8) |
 309 +       (inbytes[2] << 16) |
 310 +       (inbytes[3] << 24);
 311 +    }
 312 +  else /* big endian */
 313 +    {
 314 +      return
 315 +       (inbytes[0] << 24) |
 316 +       (inbytes[1] << 16) |
 317 +       (inbytes[2] << 8) |
 318 +       (inbytes[3] << 0);
 319 +    }
 320 +}
 321 +
 322 +static uint64_t
 323 +elf_64_from_file (uint64_t x, int file_is_little_endian)
 324 +{
 325 +  unsigned char *inbytes;
 326 +
 327 +  inbytes = (unsigned char *)&x;
 328 +  if (file_is_little_endian)
 329 +    {
 330 +      return
 331 +       ((uint64_t)inbytes[0] << 0) |
 332 +       ((uint64_t)inbytes[1] << 8) |
 333 +       ((uint64_t)inbytes[2] << 16) |
 334 +       ((uint64_t)inbytes[3] << 24) |
 335 +       ((uint64_t)inbytes[4] << 32) |
 336 +       ((uint64_t)inbytes[5] << 40) |
 337 +       ((uint64_t)inbytes[6] << 48) |
 338 +       ((uint64_t)inbytes[7] << 56);
 339 +    }
 340 +  else /* big endian */
 341 +    {
 342 +      return
 343 +       ((uint64_t)inbytes[0] << 56) |
 344 +       ((uint64_t)inbytes[1] << 48) |
 345 +       ((uint64_t)inbytes[2] << 40) |
 346 +       ((uint64_t)inbytes[3] << 32) |
 347 +       ((uint64_t)inbytes[4] << 24) |
 348 +       ((uint64_t)inbytes[5] << 16) |
 349 +       ((uint64_t)inbytes[6] << 8) |
 350 +       ((uint64_t)inbytes[7] << 0);
 351 +    }
 352  }
 353
 354  static Elf32_Word
 355  word32_from_file (Elf32_Word x, Elf *elf)
 356  {
 357 -  /* FIXME: implement */
 358 -  return x;
 359 +  Elf32_Ehdr *ehdr = elf32_getehdr (elf);
 360 +  return elf_32_from_file (x, ehdr->e_ident[EI_DATA] & ELFDATA2LSB);
 361  }
 362
 363  static Elf32_Off
 364  off32_from_file (Elf32_Off x, Elf *elf)
 365  {
 366 -  /* FIXME: implement */
 367 -  return x;
 368 +  Elf32_Ehdr *ehdr = elf32_getehdr (elf);
 369 +  return elf_32_from_file (x, ehdr->e_ident[EI_DATA] & ELFDATA2LSB);
 370 +}
 371 +
 372 +static Elf64_Word
 373 +word64_from_file (Elf64_Word x, Elf *elf)
 374 +{
 375 +  Elf64_Ehdr *ehdr = elf64_getehdr (elf);
 376 +  return elf_32_from_file (x, ehdr->e_ident[EI_DATA] & ELFDATA2LSB);
 377 +}
 378 +
 379 +static Elf64_Off
 380 +off64_from_file (Elf64_Off x, Elf *elf)
 381 +{
 382 +  Elf64_Ehdr *ehdr = elf64_getehdr (elf);
 383 +  return elf_64_from_file (x, ehdr->e_ident[EI_DATA] & ELFDATA2LSB);
 384  }
 385
 386  static void
 387 @@ -93,7 +223,29 @@
 388                         Elf *elf,
 389                         Elf_Data *data)
 390  {
 391 +  UnstripInfo64 *info64;
 392 +  int i;
 393 +
 394    data->d_align = 8;
 395 +
 396 +  data->d_size =
 397 +    /* orig_e_shoff */ sizeof (Elf64_Off) +
 398 +    /* n_sections */ sizeof (Elf64_Off) +
 399 +    /* sections */ info->n_sections * sizeof (UnstripInfoSection64);
 400 +
 401 +  data->d_buf = calloc (1, data->d_size);
 402 +
 403 +  info64 = (UnstripInfo64 *) data->d_buf;
 404 +
 405 +  info64->orig_e_shoff = off64_to_file (info->orig_e_shoff, elf);
 406 +  info64->n_sections = off64_to_file (info->n_sections, elf);
 407 +
 408 +  for (i = 0; i < info->n_sections; i++)
 409 +    {
 410 +      info64->sections[i].debug_section = word64_to_file (info->sections[i].debug_section, elf);
 411 +      info64->sections[i].name = word64_to_file (info->sections[i].name, elf);
 412 +      info64->sections[i].orig_offset = off64_to_file (info->sections[i].orig_offset, elf);
 413 +    }
 414  }
 415
 416  void
 417 @@ -101,11 +253,18 @@
 418                       Elf *elf,
 419                       Elf_Data *data)
 420  {
 421 +  GElf_Ehdr ehdr;
 422 +
 423    data->d_type = ELF_T_BYTE;
 424    data->d_off = 0;
 425
 426 -  /* FIXME: use right version */
 427 -  unstrip_info_to_data32 (info, elf, data);
 428 +  gelf_getehdr (elf, &ehdr);
 429 +  if (ehdr.e_ident[EI_CLASS] == ELFCLASS32)
 430 +    unstrip_info_to_data32 (info, elf, data);
 431 +  else if (ehdr.e_ident[EI_CLASS] == ELFCLASS64)
 432 +    unstrip_info_to_data64 (info, elf, data);
 433 +  else
 434 +    fprintf (stderr, "Warning. unsupported elf class\n");
 435  }
 436
 437  void
 438 @@ -130,23 +289,49 @@
 439      }
 440  }
 441
 442 +void
 443 +unstrip_info_from_data64 (UnstripInfo *info,
 444 +                         Elf *elf,
 445 +                         Elf_Data *data)
 446 +{
 447 +  UnstripInfo64 *info64;
 448 +  int i;
 449 +
 450 +  info64 = (UnstripInfo64 *) data->d_buf;
 451 +
 452 +  info->orig_e_shoff = off64_from_file (info64->orig_e_shoff, elf);
 453 +  info->n_sections = off64_from_file (info64->n_sections, elf);
 454 +
 455 +  info->sections = calloc (info->n_sections, sizeof (UnstripInfoSection));
 456 +  for (i = 0; i < info->n_sections; i++)
 457 +    {
 458 +      info->sections[i].debug_section = word64_from_file (info64->sections[i].debug_section, elf);
 459 +      info->sections[i].name = word64_from_file (info64->sections[i].name, elf);
 460 +      info->sections[i].orig_offset = off64_from_file (info64->sections[i].orig_offset, elf);
 461 +    }
 462 +}
 463 +
 464  UnstripInfo *
 465  unstrip_info_from_data (Elf *elf,
 466                         Elf_Data *data)
 467  {
 468 +  GElf_Ehdr ehdr;
 469 +
 470    UnstripInfo *info;
 471
 472    info = malloc (sizeof (UnstripInfo));
 473
 474 -  /* FIXME: use right version */
 475 -  unstrip_info_from_data32 (info,
 476 -                           elf,
 477 -                           data);
 478 +  gelf_getehdr (elf, &ehdr);
 479 +  if (ehdr.e_ident[EI_CLASS] == ELFCLASS32)
 480 +    unstrip_info_from_data32 (info, elf, data);
 481 +  else if (ehdr.e_ident[EI_CLASS] == ELFCLASS64)
 482 +    unstrip_info_from_data64 (info, elf, data);
 483 +  else
 484 +    fprintf (stderr, "Warning. unsupported elf class\n");
 485
 486    return info;
 487  }
 488
 489 -
 490  static void
 491  debug_link_to_data32 (DebugLink *debuglink,
 492                       Elf *elf,
 493 @@ -169,17 +354,47 @@
 494    p = data->d_buf + namelen_aligned;
 495
 496    *(Elf32_Word *)p = word32_to_file (debuglink->checksum, elf);
 497 -  p += sizeof (Elf32_Word);
 498 +}
 499 +
 500 +static void
 501 +debug_link_to_data64 (DebugLink *debuglink,
 502 +                     Elf *elf,
 503 +                     Elf_Data *data)
 504 +{
 505 +  size_t namelen_aligned;
 506 +  char *p;
 507 +
 508 +  data->d_align = 4;
 509 +
 510 +  namelen_aligned = align_up (strlen(debuglink->filename) + 1, 4);
 511 +
 512 +  data->d_size =
 513 +    /* name */ namelen_aligned +
 514 +    /* checksum */ sizeof (Elf64_Word);
 515 +
 516 +  data->d_buf = calloc (1, data->d_size);
 517 +
 518 +  strcpy (data->d_buf, debuglink->filename);
 519 +  p = data->d_buf + namelen_aligned;
 520 +
 521 +  *(Elf64_Word *)p = word64_to_file (debuglink->checksum, elf);
 522  }
 523
 524  void
 525  debug_link_to_data (DebugLink *debuglink, Elf *elf, Elf_Data *data)
 526  {
 527 +  GElf_Ehdr ehdr;
 528 +
 529    data->d_type = ELF_T_BYTE;
 530    data->d_off = 0;
 531
 532 -  /* FIXME: use right version */
 533 -  debug_link_to_data32 (debuglink, elf, data);
 534 +  gelf_getehdr (elf, &ehdr);
 535 +  if (ehdr.e_ident[EI_CLASS] == ELFCLASS32)
 536 +    debug_link_to_data32 (debuglink, elf, data);
 537 +  else if (ehdr.e_ident[EI_CLASS] == ELFCLASS64)
 538 +    debug_link_to_data64 (debuglink, elf, data);
 539 +  else
 540 +    fprintf (stderr, "Warning. unsupported elf class\n");
 541  }
 542
 543  void
 544 @@ -197,21 +412,41 @@
 545    p = data->d_buf + namelen_aligned;
 546
 547    debuglink->checksum = word32_from_file (*(Elf32_Word *)p, elf);
 548 -  p += sizeof (Elf32_Word);
 549 +}
 550 +
 551 +void
 552 +debug_link_from_data64 (DebugLink *debuglink,
 553 +                       Elf *elf,
 554 +                       Elf_Data *data)
 555 +{
 556 +  size_t namelen_aligned;
 557 +  char *p;
 558 +
 559 +  debuglink->filename = strdup (data->d_buf);
 560 +
 561 +  namelen_aligned = align_up (strlen (debuglink->filename) + 1, 4);
 562 +
 563 +  p = data->d_buf + namelen_aligned;
 564 +
 565 +  debuglink->checksum = word64_from_file (*(Elf64_Word *)p, elf);
 566  }
 567
 568
 569  DebugLink *
 570  debug_link_from_data (Elf *elf, Elf_Data *data)
 571  {
 572 +  GElf_Ehdr ehdr;
 573    DebugLink *debuglink;
 574
 575    debuglink = malloc (sizeof (DebugLink));
 576
 577 -  /* FIXME: use right version */
 578 -  debug_link_from_data32 (debuglink,
 579 -                         elf,
 580 -                         data);
 581 +  gelf_getehdr (elf, &ehdr);
 582 +  if (ehdr.e_ident[EI_CLASS] == ELFCLASS32)
 583 +    debug_link_from_data32 (debuglink, elf, data);
 584 +  else if (ehdr.e_ident[EI_CLASS] == ELFCLASS64)
 585 +    debug_link_from_data64 (debuglink, elf, data);
 586 +  else
 587 +    fprintf (stderr, "Warning. unsupported elf class\n");
 588
 589    return debuglink;
 590  }
 591 diff -ruN rpm-4.1/tools/striptofile.c rpm-4.1-9/tools/striptofile.c
 592 --- rpm-4.1/tools/striptofile.c Thu Aug 22 21:08:25 2002
 593 +++ rpm-4.1-9/tools/striptofile.c       Sun Oct  6 07:30:41 2002
 594 @@ -201,7 +201,7 @@
 595    /* Update section header stringtab ref */
 596    gelf_getehdr (out_elf, &out_ehdr);
 597    out_ehdr.e_shstrndx = section_map[out_ehdr.e_shstrndx];
 598 -  out_ehdr.e_shoff = align_up (last_offset, 4);
 599 +  out_ehdr.e_shoff = align_up (last_offset, 8);
 600    gelf_update_ehdr(out_elf, &out_ehdr);
 601
 602    /* Update section header links */
 603 @@ -402,6 +402,7 @@
 604    Elf *elf, *out_elf;
 605    int fd, out;
 606    const char *origname;
 607 +  char *origname_base;
 608    char *debugname, *strippedname;
 609    DebugLink *debuglink;
 610    poptContext optCon;   /* context for parsing command-line options */
 611 @@ -433,14 +434,13 @@
 612
 613    origname = args[0];
 614
 615 -  if (output_dir) {
 616 -    const char * bn = strrchr(origname, '/');
 617 -    if ((bn = strrchr(origname, '/')) != NULL)
 618 -       bn++;
 619 -    else
 620 -       bn = origname;
 621 -    debugname = strconcat (output_dir, "/", bn, ".debug", NULL);
 622 -  } else
 623 +  if (output_dir)
 624 +    {
 625 +      origname_base = path_basename (origname);
 626 +      debugname = strconcat (output_dir, "/", origname_base, ".debug", NULL);
 627 +      free (origname_base);
 628 +    }
 629 +  else
 630      debugname = strconcat (origname, ".debug", NULL);
 631
 632    strippedname = strconcat (origname, ".XXXXXX", NULL);