[Date Prev][Date Next] [Thread Prev][Thread Next] [Date Index] [Thread Index]

Bug#435546: marked as done (gcc-4.1: Wrong loop code generation using O2)

Your message dated Thu, 2 Aug 2007 00:37:46 +0200
with message-id <20070801223746.GA23700@wavehammer.waldi.eu.org>
and subject line Bug#435546: gcc-4.1: Wrong loop code generation using O2
has caused the attached Bug report to be marked as done.

This means that you claim that the problem has been dealt with.
If this is not the case it is now your responsibility to reopen the
Bug report if necessary, and/or fix the problem forthwith.

(NB: If you are a system administrator and have no idea what I am
talking about this indicates a serious mail system misconfiguration
somewhere.  Please contact me immediately.)

Debian bug tracking system administrator
(administrator, Debian Bugs database)
--- Begin Message --- 
Package: gcc-4.1
Version: 4.1.2-13
Severity: important

void do_pin_processes(int pids[], int n, char pin)
{
  int i;
  for (i = 0; i < n; i++) {
    printf("%d\n", i);
    do_pin_process(pids[i], pin);
  }
}

When I compile the attached program with the following flags the
compiler generates a infinite loop in the function do_pin_processes (the
i variable is not incremented):

gcc -DHAVE_CONFIG_H -I. -I.. -I../include   -pg -g -g -O2 -MT pin-main.o
-MD -MP -MF .deps/pin-main.Tpo -c -o pin-main.o `test -f 'main.c' ||
echo
'./'`main.c
mv -f .deps/pin-main.Tpo .deps/pin-main.Po
gcc -DHAVE_CONFIG_H -I. -I.. -I../include   -pg -g -g -O2 -MT pin-pin.o
-MD -MP -MF .deps/pin-pin.Tpo -c -o pin-pin.o `test -f 'pin.c' || echo
'./'`pin.c
mv -f .deps/pin-pin.Tpo .deps/pin-pin.Po
gcc -DHAVE_CONFIG_H -I. -I.. -I../include   -pg -g -g -O2 -MT
pin-error.o -MD -MP -MF .deps/pin-error.Tpo -c -o pin-error.o `test -f
'error.c' || echo
'./'`error.c
mv -f .deps/pin-error.Tpo .deps/pin-error.Po
gcc -pg -g -g -O2 -pg -g  -o pin pin-main.o pin-pin.o pin-error.o -lpopt

However if I export the CFLAGS variable with -O0 it works properly.

The arguments passed to the program and the obtained outputs are:

(cmd line) $ ./pin -l "1 2 3"

(output bad code) $ Pinning 1 (0): done
0
Pinning 1 (0): done
0
Pinning 1 (0): done
0
Pinning 1 (0): done
0
Pinning 1 (0): done
...

(output correct code) $ 0
Pinning 1 (0): done
1
Pinning 2 (0): failed
Permission denied
2
Pinning 3 (0): failed
Permission denied


I have the same problem if I use gcc-4.2.

Thanks,

Javi

#include <stdio.h>
#include <errno.h>

FILE * error_file;
char err_debug_mode;

__attribute__((constructor)) static void init_error()
{
  error_file = stderr;
  err_debug_mode = 0;
}

__attribute__((destructor)) static void fini_error()
{
  if (error_file != stderr)
    fclose(error_file);
}

int err_set_output_path(char * path)
{
  int ret = 0;

  if (error_file != stderr)
    fclose(error_file);

  error_file = fopen(path, "a+");

  if (!error_file) {
    error_file = stderr;
    ret = errno;
  }

  return ret;
}

int err_set_output_file(FILE * f)
{
  int ret = 0;

  if (error_file != stderr)
    fclose(error_file);

  error_file = f;

  if (!error_file) {
    error_file = stderr;
    ret = errno;
  }

  return ret;
}

/* 
   pin - pin and unpin processes in memory

   Copyright (C) 2007 Javier Cabezas Rodriguez

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  

*/

#include <stdio.h>
#include <sys/types.h>
#include <popt.h>
#include "system.h"
#include "pin.h"
#include "error.h"

#define EXIT_FAILURE 1

/* The name the program was run with, stripped of any leading path. */
char * program_name;

typedef struct {
  char unpin;
  char all;
  char * pids;
} t_cmd_args;

t_cmd_args program_args;

/* Option flags and variables */
static const struct poptOption program_options[] = {
  {"unpin", 'u', POPT_ARG_NONE, 0, 'u', "unpin the listed process/es"},
  {"all", 'a', POPT_ARG_NONE, 0, 'a', "pin/unpin all the processes"},
  {"list", 'l', POPT_ARG_STRING, &program_args.pids, 0, "pin/unpin the processes listed next", "PIDS"},
  POPT_AUTOALIAS
  POPT_AUTOHELP
  POPT_TABLEEND
};

static int parse_args(int argc, char ** argv);

static int get_pids(int ** pids)
{
  int i;
  char error[64];
  char * copy;
  char * str_pid;
  char * end_pid;
  int pid, n = 0;

  copy = strdup(program_args.pids);

  str_pid = strtok(program_args.pids, " \f\n\r\t\v");

  if (!program_args.pids)
    return 0;

  while (str_pid) {
    pid = strtol(str_pid, &end_pid, 10);

    str_pid = strtok(NULL, " \f\n\r\t\v");
    
    if (pid)
      n++;
  }

  *pids = (int *) malloc(n * sizeof(int));
  str_pid = strtok(copy, " \f\n\r\t\v");

  i = 0;
   
  while (str_pid) {
    pid = strtol(str_pid, &end_pid, 10);

    if (!pid) {
      sprintf(error, "Error: %d is not a valid PID", pid);
      ERROR(error);
      str_pid = strtok(NULL, " \f\n\r\t\v");
      continue;
    }

    (*pids)[i] = pid;
    
    str_pid = strtok(NULL, " \f\n\r\t\v");
    i++; 
  }

  free(copy);
  return n;
}

int main(int argc, char * argv[])
{
  int i;

  program_name = argv[0];

  i = parse_args(argc, argv);

  /* do the work */
  if (program_args.all) {
    do_pin_all(!program_args.unpin);
  } else {
    int *pids;
    int n = get_pids(&pids);
    do_pin_processes(pids, n, !program_args.unpin);
    free(pids);
  }

  if (program_args.pids)
    free(program_args.pids);

  return 0;
}

static int parse_args(int argc, char ** argv)
{
  int option;

  poptContext context = poptGetContext(
      NULL,
      argc,
      (const char **) argv,
      program_options,
      0);

  if (argc < 2) {
    poptPrintUsage(context, error_file, 0);
    poptFreeContext(context);
    exit(1);
  }

  while ((option = poptGetNextOpt(context)) >= 0) {
    switch (option) {
      case 'u':
        program_args.unpin = 1;
        break;
      case 'a':
        program_args.all = 1;
        break;
      default:
        poptPrintUsage(context, error_file, 0);
        exit(1);
    }
  } 

  if (program_args.all && program_args.pids) {
    ERROR("Error: -l and -a flags are incompatible\n");
    poptPrintUsage(context, error_file, 0);
    exit(1);
  }

  poptFreeContext(context);
}

/* 
   pin - pin and unpin processes in memory

   Copyright (C) 2007 Javier Cabezas Rodriguez

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  

*/

#include <stdio.h>
#include "error.h"

static inline char is_pinned(int pid)
{
  char path[32];
  char error[64];

  char pinned;
  char read;

  sprintf(path, "/proc/%d/pinned", pid);
  FILE * f = fopen(path, "r");

  if (!f) {
    printf("failed\n");
    STDERROR();
    return;
  }

  read = fscanf(f, "%d", &pinned);
  if (!read || read == EOF) {
    printf("failed\n");
    sprintf(error, "Error reading from %s", path);
    ERROR(error);
    fclose(f);
    return;
  }

  if (fclose(f) == EOF) {
    printf("failed\n");
    STDERROR();
    return;
  }
}

static void do_pin(int pid)
{
  char path[32];
  char error[64];

  printf("Pinning %d (%d): ", pid, is_pinned(pid));

  sprintf(path, "/proc/%d/pinned", pid);
  FILE * f = fopen(path, "a");

  if (!f) {
    printf("failed\n");
    STDERROR();
    return;
  }

  if (fprintf(f, "1") <= 0) {
    printf("failed\n");
    sprintf(error, "Error writing to %s", path);
    ERROR(error);
    fclose(f);
    return;
  }

  if (fclose(f) == EOF) {
    printf("failed\n");
    STDERROR();
    return;
  }

  printf("done\n");
}

static void do_unpin(int pid)
{
  char path[32];
  char error[64];

  printf("Unpinning %d (%d): ", pid, is_pinned(pid));

  sprintf(path, "/proc/%d/pinned", pid);
  FILE * f = fopen(path, "a");

  if (!f) {
    printf("failed\n");
    STDERROR();
    return;
  }

  if (fprintf(f, "0") <= 0) {
    printf("failed\n");
    sprintf(error, "Error writing to %s", path);
    ERROR(error);
    fclose(f);
    return;
  }

  if (fclose(f) == EOF) {
    printf("failed\n");
    STDERROR();
    return;
  }

  printf("done\n");
}

void do_pin_process(int pid, char pin)
{
  if (pin)
    do_pin(pid);
  else
    do_unpin(pid);
}

void do_pin_processes(int pids[], int n, char pin)
{
  int i;
  for (i = 0; i < n; i++) {
    printf("%d\n", i);
    do_pin_process(pids[i], pin);
  }
}

void do_pin_all(char pin)
{
}

Attachment: signature.asc
Description: Esta parte del mensaje =?ISO-8859-1?Q?est=E1?= firmada digitalmente


--- End Message ---
--- Begin Message --- 
On Thu, Aug 02, 2007 at 12:28:37AM +0200, Javier Cabezas Rodríguez wrote:
> If I remove the warnings, the generated code is correct.

So no but, closing.

Bastian

-- 
Bones: "The man's DEAD, Jim!"

--- End Message ---
Reply to: