sgi_cmd_line.cxx

Go to the documentation of this file.

/*

  Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.

  This program is free software; you can redistribute it and/or modify it
  under the terms of version 2 of the GNU General Public License as
  published by the Free Software Foundation.

  This program is distributed in the hope that it would be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

  Further, this software is distributed without any warranty that it is
  free of the rightful claim of any third person regarding infringement 
  or the like.  Any license provided herein, whether implied or 
  otherwise, applies only to this software file.  Patent licenses, if 
  any, provided herein do not apply to combinations of this program with 
  other software, or any other product whatsoever.  

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

  Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
  Mountain View, CA 94043, or:

  http://www.sgi.com

  For further information regarding this notice, see:

  http://oss.sgi.com/projects/GenInfo/NoticeExplan

*/



static char *source_file = __FILE__;

#include "x_string.h" // for strcasecmp(), strdup()

/* SGI includes */
#include "stamp.h"
#include "defs.h"
#include "config.h"  
#include "config_debug.h"  
#include "file_util.h"
#include "flags.h"
#include "glob.h"
#include "tracing.h"
#include "util.h" 
#include "wn.h"

#include "erglob.h"
#include "erlib.h"
#include "tracing.h"
#include "err_host.tab"

/* conversion includes */
#include "sgi_cmd_line.h"
#include "cwh_mkdepend.h"

/* Get the compiler build data */
extern char * mfef90_compiler_build_date;

#include <cmplrs/make_depend.h> 
#include <stdarg.h>
#include <signal.h>

BOOL IO_Comments = TRUE;  /* Emit I/O comments from lowerer */
BOOL Use_Three_Call= FALSE;

BOOL FE_Full_Split_Set = FALSE;
BOOL FE_Full_Split     = FALSE;
BOOL FE_Endloop_Marker = FALSE;

static BOOL Matmul_Inline = FALSE;
static BOOL Mv_Matmul_Inline = FALSE;
static BOOL Matmul_Inline_Set = FALSE;
static BOOL Mv_Matmul_Inline_Set = FALSE;

char *rii_file_name=NULL;
BOOL enable_dsm_recompile = FALSE;
BOOL enable_dsm_processing = FALSE;
static BOOL enable_mp_processing = FALSE;

BOOL Full_arrayexp = TRUE;
BOOL Full_arrayexp_set = FALSE;
mUINT16  FE_align=8;

char *FE_gdar_filename = NULL;

INT32 global_chunk_pragma_value;
BOOL  global_chunk_pragma_set = FALSE;

INT32 global_schedtype_pragma_val;
BOOL global_schedtype_pragma_set = FALSE;
BOOL cleanUpWhirl = FALSE; 

BOOL process_cri_mp_pragmas=FALSE;

BOOL disable_old_mp = FALSE;
BOOL disable_open_mp = FALSE;

BOOL FE_Call_Never_Return = TRUE;


/*
 *
 * Mempools
 *
 */
static MEM_POOL FE_Mempool_s;
MEM_POOL *FE_Mempool=&FE_Mempool_s;

/* ====================================================================
 *
 * Local data.
 *
 * ====================================================================
 */

/*       MAX_DEBUG_LEVEL        2  :: Defined in flags.h */
# define DEF_DEBUG_LEVEL        0
INT8 Debug_Level = DEF_DEBUG_LEVEL;     /* -gn: debug level */
# define MAX_PROFILE_LEVEL 0
# define DEF_PROFILE_LEVEL 0
INT8 Profile_Level = DEF_PROFILE_LEVEL; /* -pn: profiling level */
# define MAX_MSG_LEVEL 2
# define DEF_MSG_LEVEL 2



static OPTION_DESC Options_FE[] = {
  { OVK_NAME,   OV_INTERNAL,    FALSE, "cmdline",               "cmdline",
    NULL, NULL, NULL, &FE_command_line, NULL },
  { OVK_BOOL,   OV_INTERNAL,    FALSE,  "iocomment",            "ioc",
    0, 0, 0, &IO_Comments  , NULL },
  { OVK_BOOL,   OV_INTERNAL,    FALSE, "three_call",            "three_call",
    0, 0, 0,    &Use_Three_Call, NULL },
  { OVK_BOOL,   OV_INTERNAL,    FALSE, "full_split",            "full",
    0, 0, 0,    &FE_Full_Split,         &FE_Full_Split_Set },
  { OVK_BOOL,   OV_INTERNAL,    FALSE, "arrayexp",              "arrayexp",
    0, 0, 0,    &Full_arrayexp,         &Full_arrayexp_set },
  { OVK_NAME,   OV_INTERNAL,    FALSE, "gdar",                   "gdar",
    NULL, NULL, NULL, &FE_gdar_filename,        NULL },
  { OVK_BOOL,   OV_INTERNAL,    FALSE, "endloop_markers",       "endloop_marker",
    0, 0, 0,    &FE_Endloop_Marker,     NULL },
  { OVK_BOOL,   OV_INTERNAL,    FALSE, "matmul_inline",         "matmul_inline",
    0, 0, 0,    &Matmul_Inline, &Matmul_Inline_Set },
  { OVK_BOOL,   OV_INTERNAL,    FALSE, "mv_matmul_inline",      "mv_matmul_inline",
    0, 0, 0,    &Mv_Matmul_Inline,      &Mv_Matmul_Inline_Set },
  { OVK_BOOL,   OV_INTERNAL,    FALSE, "call_never_return", "call_never_return",
    0, 0, 0,    &FE_Call_Never_Return,  NULL },
  
  { OVK_COUNT, 0, FALSE, NULL, NULL,  /* List terminator -- must be last */
    0, 0, 0, NULL, NULL, NULL }
};

OPTION_GROUP FE_Option_Groups [] = {
  { "FE", ':', '=', Options_FE },
  { NULL }                         /* List terminator -- must be last */
};


INT argc_cray;
char **argv_cray;
INT size_cray_argv;
INT num_cray_args;

char **deferred_argv_cray;
INT size_deferred_cray_argv;
INT num_deferred_cray_args;

char **save_argv;
INT save_argc;

static char *object_file_name=NULL;

static WN_PRAGMA_SCHEDTYPE_KIND
identify_schedtype(char *text)
{
   if (ux_strncasecmp(text, "simple",6)==0  ||
       ux_strncasecmp(text, "static",6)==0) {
      return WN_PRAGMA_SCHEDTYPE_SIMPLE;
   } else if (ux_strncasecmp(text, "dynamic",7)==0) {
      return WN_PRAGMA_SCHEDTYPE_DYNAMIC;
   } else if (ux_strncasecmp(text, "interleaved",11)==0) {
      return WN_PRAGMA_SCHEDTYPE_INTERLEAVE;
   } else if ( ux_strncasecmp(text, "interleave",10)==0) {
      return WN_PRAGMA_SCHEDTYPE_INTERLEAVE;
   } else if (ux_strncasecmp(text, "runtime",7)==0) {
      return WN_PRAGMA_SCHEDTYPE_RUNTIME;
   } else if (ux_strncasecmp(text, "gss",3)==0) {
      return WN_PRAGMA_SCHEDTYPE_GSS;
   } else if (ux_strncasecmp(text, "guided",6)==0) {
      return WN_PRAGMA_SCHEDTYPE_GSS;
   } else if (ux_strncasecmp(text, "pseudolowered",13)==0) {
      return WN_PRAGMA_SCHEDTYPE_PSEUDOLOWERED;
   } else {
      ErrMsg(EC_Unknown_Mpsched,text);
      return WN_PRAGMA_SCHEDTYPE_UNKNOWN;
   }
} 


void add_cray_args(char *arg)
{
   /* Add a string to the Cray args */

   if (num_cray_args >= size_cray_argv) {
      /* Reallocate argv_cray */
      size_cray_argv += 16;
      argv_cray = (char **) realloc(argv_cray,size_cray_argv*sizeof(char *));
   }
   
   if (arg) {
      argv_cray[num_cray_args] = ux_strdup(arg);
   } else {
      argv_cray[num_cray_args] = NULL;
   }
   ++num_cray_args;
}

void add_deferred_cray_args(char *arg)
{
   /* Add a string to the deferred Cray args */

   if (num_deferred_cray_args >= size_deferred_cray_argv) {
      /* Reallocate argv_cray */
      size_deferred_cray_argv += 16;
      deferred_argv_cray = (char **) realloc(deferred_argv_cray,
                                             size_deferred_cray_argv*sizeof(char *));
   }
   
   if (arg) {
      deferred_argv_cray[num_deferred_cray_args] = ux_strdup(arg);
   } else {
      deferred_argv_cray[num_deferred_cray_args] = NULL;
   }      
   ++num_deferred_cray_args;
}

/* ====================================================================
 *
 * Cray_Woff
 *
 * Process a set of warning numbers which are to be disabled.  They are
 * given in the form:
 *
 *      n1,n2,n3-n4,n5-n6,...
 *
 * where an individual number (e.g. n1 or n2) suppresses that numbered
 * warning, and a range (e.g. n3-n4 or n5-n6) disables all warnings
 * numbered in that range.
 *
 * This routine takes such a number list from -DEBUG:woff=... or from
 * -woff ..., converts it to the Cray format option, and passes it to
 * the Cray command line option handler.
 *
 * ====================================================================
 */

void
Cray_Woff ( char *list )
{
   char *temp = (char *) malloc ( strlen(list)+3 );
   
   strcpy ( temp, "-M" );
   strcat ( temp, list );
   add_cray_args ( temp );
   free ( temp );
}

/* ====================================================================
 *
 * Process_Command_Line
 *
 * Process the command line arguments.  Evaluate all flags except per-
 * source file control flags and set up global options.
 *
 * ====================================================================
 */

void Process_Command_Line (INT argc, char ** argv)

{
   INT i;
   char *cp;
   char *temp;
   char ch,c;
   BOOL pass_option;
   BOOL opt_set;
   INT j;
   FILE *f;
   INT  command_line_length;

   argc_cray = argc;
   num_cray_args = 1;
   size_cray_argv = argc + 1;
   
   /* Get the space for (potential) copies of all the command-line options */
   argv_cray = (char **) malloc(size_cray_argv*sizeof(char *));
   argv_cray[0] = argv[0];

   /* Get the space for the deferred cray args */
   num_deferred_cray_args=0;
   size_deferred_cray_argv = 1; /* Pretty arbitrary */
   deferred_argv_cray = (char **)malloc(size_deferred_cray_argv*sizeof(char *));

   /* Process the command line */
   for (i=1; i<argc; i++ ) {
      if ( argv[i] != NULL && *(argv[i]) == '-' )       {
         cp = argv[i]+1;        /* Pointer to next flag character */
         if (Process_Command_Line_Group(cp, Common_Option_Groups)) {
            pass_option = FALSE;
            switch ( *cp++ ) {
              case 'L':
               if ((strncmp(cp, "ANG:IEEE_minus_zero", 19) == 0) &&
                   (strncmp(cp, "ANG:IEEE_minus_zero=off", 23) != 0) &&
                   (strncmp(cp, "ANG:IEEE_minus_zero=OFF", 23) != 0)) {
                  add_cray_args("-ez");
               }
            }
         } else if (Process_Command_Line_Group(cp, FE_Option_Groups)) {
            pass_option = FALSE;
         } else {
            pass_option = TRUE;
            switch ( *cp++ ) {
             case 'a':
               if (strcmp(cp,"lign32")==0) {
                  pass_option = TRUE;
                  FE_align = 4;
               } else if (strcmp(cp,"lign64")==0) {
                  pass_option = TRUE;
                  FE_align = 8;
               } else if (strcmp(cp,"nsi")==0) {
                  pass_option = FALSE;
                  add_cray_args("-en");
               } else if (strncmp(cp,"uto_use=",8)==0) {
                  cp += 8;
                  temp = (char *) malloc (strlen(cp) + 3);
                  strcpy(temp,"-A");
                  strcat(temp,cp);
                  add_cray_args(temp);
                  free(temp);
                  pass_option = FALSE;
               }
               break;

             case 'c':
               if (strcmp(cp,"ol72")==0) {
                  pass_option = FALSE;
                  add_cray_args("-N72");
               } else if (strcmp(cp,"ol80")==0) {
                  pass_option = FALSE;
                  add_cray_args("-N80");
               } else if (strcmp(cp,"ol120")==0) {
                  pass_option = FALSE;
                  add_cray_args("-N120");
               } else if (strcmp(cp,"if")==0) {
                  pass_option = FALSE;
                  add_cray_args("-Ca");
               } else if (strncmp(cp,"hunk=",5)==0) {
                  cp += 5;
                  global_chunk_pragma_set = TRUE;
                  global_chunk_pragma_value = Get_Numeric_Flag ( &cp, 0, INT32_MAX,0,argv[i] );
                  pass_option = FALSE;
               } else if (strcmp(cp,"ray_mp")==0) {
                 pass_option = FALSE;
                 process_cri_mp_pragmas = TRUE;
                 add_cray_args("-Otask1");
               }
               break;

             case 'd':
               if (strcmp(cp,"16")==0) {
                  pass_option = FALSE;
                  add_cray_args("-sdoubleprecision16");
                  add_cray_args("-sdoublecomplex16");
               } else if (strcmp(cp,"8")==0) {
                  pass_option = FALSE;
               } else if (strcmp(cp,"sm")==0) {
                  /* -dsm: enable the DSM directives */
                  enable_dsm_processing = TRUE;
                  add_cray_args("-udsm");
                  pass_option = FALSE;
               } else if (strcmp(cp,"sm_recompile")==0) {
                        /* -dsm_recompile: do not update rii file */
                  enable_dsm_recompile = TRUE;
                  pass_option = FALSE;
               } else if (strcmp(cp,"efault64")==0) {
                  pass_option = FALSE;
                  add_cray_args("-ucray_compatible");
               } else if (strcmp(cp,"isable_old_mp")==0) {
                  pass_option = FALSE;
                  disable_old_mp = TRUE;
               } else if (strcmp(cp,"isable_open_mp")==0) {
                  pass_option = FALSE;
                  disable_open_mp = TRUE;
               }
               else if (strcmp(cp,"_lines")==0) {
                  pass_option = FALSE;
                  add_cray_args("-ed");
               }
               break;

             case 'e':
               if (strcmp(cp,"xtend_source")==0) {
                  pass_option = FALSE;
                  add_cray_args("-N132");
               }
               break;

             case 'E':
                pass_option = FALSE;
                add_cray_args("-eZ");
                break;
               
             case 'f':
               if ( strcmp(cp,"ullwarn") == 0 ) {
                  /* -fullwarn -- similar to -m2: */
                  Min_Error_Severity = ES_ADVISORY; 
                  add_cray_args("-m2");
                  pass_option = FALSE;
               } else if ( strcmp(cp,"tpp") == 0 ) {
                  pass_option = FALSE;
                  add_cray_args("-eT");
               } else { /* Filename options -- ignore these except -fb: */
                  c = *cp++;
                  if ( (ch=*cp++) != ',' && ch != ':' ) {
                     if ( c == 0 ) c = '?';
                     pass_option = TRUE;
                     break;
                  }
                  /* Process the various options: */
                  pass_option = FALSE;
                  switch ( c ) {
                     
                   case 'b': /* Library file already processed -- ignore: */
                     Lib_File_Name = ux_strdup(cp);
                     break;
                     
                   case 'B': /* WHIRL file: */
                     Irb_File_Name = ux_strdup(cp);
                     break;

                   case 'C': /* CIF file */
                      temp = (char *) malloc (strlen(cp) + 4);
                      strcpy(temp,"-CZ");
                      strcat(temp,cp);
                      add_cray_args(temp);
                      free(temp);
                      pass_option = FALSE;
                      break;
                     
                   case 'D': /* Cray debug file */
                      temp = (char *) malloc (strlen(cp) + 8);
                      strcpy(temp,"-ufile=");
                      strcat(temp,cp);
                      add_cray_args(temp);
                      free(temp);
                      pass_option = FALSE;
                      break;
                     
                   case 'S': /* Original source file name (used for -mp option) */
                     Orig_Src_File_Name = ux_strdup(cp);
                     break;
                     
                   case 'e': /* Error file: */
                     Err_File_Name = ux_strdup(cp);
                     break;
                     
                   case 'I': /* Ipa_File_Name: ignore it */
                     break;
                     
                   case 'l': /* Listing file: */
                     Lst_File_Name = ux_strdup(cp);
                     break;

                   case 'o': /* Object file: */
                     object_file_name = ux_strdup(cp);
                     break;

                   case 't': /* Error file: */
                     Tracing_Enabled = TRUE;
                     Trc_File_Name = ux_strdup(cp);
                     break;

                   default:
                     pass_option = TRUE;
                  }
               }
               break;
               
             case 'g':          /* Debug level: */
               Debug_Level = Get_Numeric_Flag
                 ( &cp, 0, MAX_DEBUG_LEVEL,
                  2, argv[i] );
               if (!opt_set)
                 Opt_Level = 0;
               pass_option = FALSE;
               add_cray_args("-Gd");
               break;

             case 'G':          /* Sdata elt size */
               Max_Sdata_Elt_Size = Get_Numeric_Flag
                 ( &cp, 0, MAX_SDATA_ELT_SIZE,
                  DEF_SDATA_ELT_SIZE, argv[i] );
               pass_option = FALSE;
               break;
             
             case 'i':
               if (strcmp(cp, "eee_minus_zero") == 0) {
                  add_cray_args("-ez");
                  pass_option = FALSE;
               }
               else if ( strncmp(cp, "nclude=", 7) == 0) {
                  /* -include= */
                  cp += 7;
                  temp = (char *) malloc (strlen(cp) + 3);
                  strcpy(temp+2,cp);
                  temp[0] = '-'; temp[1] = 'I';
                  add_cray_args(temp);
                  /* Also add -p<path> to pick up the right module information */
                  temp[1] = 'p';
                  add_cray_args(temp);
                  free(temp);
                  pass_option = FALSE;
               } else if (strcmp(cp,"4") == 0) {
                  pass_option = FALSE;
               } else if (strcmp(cp,"8") == 0) {
                  add_cray_args("-sinteger8");
                  add_cray_args("-slogical8");
                  pass_option = FALSE;
               }
                  
               break;

             case 'k':
               if ( strcmp(cp,"eep") == 0 ) {
                  add_cray_args("-ek"); /* set save_dot_i = TRUE */
                  pass_option = FALSE;
               }

               break;

             case 'm': 
               {
                  if (strcmp(cp,"p") == 0) {
                    pass_option = FALSE;
                    enable_mp_processing = TRUE;
                  } else if (strncmp(cp,"p_chunk=",8) == 0) {
                     cp += 8;
                     global_chunk_pragma_set = TRUE;
                     global_chunk_pragma_value = Get_Numeric_Flag ( &cp, 0, INT32_MAX,0,argv[i] );
                     pass_option = FALSE;
                  } else if (strncmp(cp,"p_schedtype=",12) == 0) {
                     cp += 12;
                     global_schedtype_pragma_val = identify_schedtype(cp);
                     if (global_schedtype_pragma_val !=  WN_PRAGMA_SCHEDTYPE_UNKNOWN) {
                        global_schedtype_pragma_set = TRUE;
                     }
                     pass_option = FALSE;
                  } else {
                     int cray_num;
                     char temp[4];
                     /* Message reporting: */
                     cray_num = 3;
                     j = Get_Numeric_Flag ( &cp, 0, MAX_MSG_LEVEL,
                                            MAX_MSG_LEVEL, argv[i] );
                     switch (j) {
                      case 0: 
                         Min_Error_Severity = ES_ERROR;
                         cray_num=4;
                         break;
                      case 1: 
                         Min_Error_Severity = ES_WARNING;  
                         cray_num = 3;
                         break;
                      case 2: 
                         cray_num=0;
                         Min_Error_Severity = ES_ADVISORY; 
                         break;
                     }
                     sprintf(temp,"-m%1d",cray_num);
                     add_cray_args(temp);
                     pass_option = FALSE;
                  }
               }
               break;
             case 'M':
               if (strcmp(cp, "Dtarget") == 0) {
                  mdtarget_file = ux_strdup(argv[i+1]);
                  ++i;
                  pass_option = FALSE;
               } else if (strcmp(cp, "Dupdate") == 0) {
                  mdupdate_file = ux_strdup(argv[i+1]);
                  ++i;
                  pass_option = FALSE;
               }
               break;

             case 'n':
               if ( strcmp(cp, "owarn") == 0) {
                  /* -nowarn, edg's -w */
                  /* Suppress warnings */
                  Min_Error_Severity = ES_ERROR;
                  add_cray_args("-m4");
                  pass_option = FALSE;
               } else if (strcmp(cp,"oextend_source")==0) {
                  add_cray_args("-N72");
                  pass_option = FALSE;
               } else if (strcmp(cp,"ocpp")==0) {
                  add_cray_args("-dT");
                  pass_option = FALSE;
               } else if (strcmp(cp,"oappend")==0) {
                  add_cray_args("-eN");
                  pass_option = FALSE;
               }
               break;

             case 'O':          /* Optimization level: */
               Opt_Level = Get_Numeric_Flag
                 ( &cp, 0, MAX_OPT_LEVEL, DEF_O_LEVEL, argv[i] );
               opt_set = TRUE;
               pass_option = FALSE;
               break;

             case 'p':
               if (strcmp(cp,"ad_char_literals")==0) {
                  pass_option = FALSE;
                  add_cray_args("-ec");
               }
               break;

             case 'P':
               pass_option = FALSE;
               add_cray_args("-dk"); /* set output_pound_lines = FALSE */ 
               break;

             case 'r':
               if (strcmp(cp,"4") == 0) {
                  pass_option = FALSE;
               } else if (strcmp(cp,"8") == 0) {
                  add_cray_args("-sreal8");
                  add_cray_args("-scomplex8");
                  pass_option = FALSE;
               } else if (strncmp(cp,"ii",2) == 0)
               {
                  /* -rii : set rii_file_name */
                  cp += 2;
                  rii_file_name = ux_strdup(cp);
                  pass_option = FALSE;
               }
               break;
               
             case 's': 
               if ( strcmp(cp,"how") == 0) {
                  /* -show: Emit progress reports: */
                  Show_Progress = TRUE;
                  pass_option = FALSE;
               } else if ( strcmp(cp,"tatic_threadprivate") == 0) {
                  /* -static_threadprivate */
                  add_cray_args("-astatic_threadprivate");
                  pass_option = FALSE;
               } else if ( strcmp(cp,"tatic-data") == 0) {
                  /* -static-data, same as -static */
                  add_cray_args("-ev");
                  pass_option = FALSE;
               } else if ( strcmp(cp,"tatic") == 0) {
                  /* -static */
                  add_cray_args("-ev");
                  pass_option = FALSE;
               }
               break;

             case 't':
               /* Trace specification:
                * The config.c routine expects to get a pointer to the
                * full option '-t...', but doesn't check the '-', so
                * point just before the 't':
                */
               Process_Trace_Option ( cp-2 );
               pass_option = FALSE;
               break;

             case 'u':
                if (*cp=='\0') {
                   /* Plain -u */
                   add_cray_args("-eI");
                   pass_option = FALSE;
                }
               break;

             case 'v':
               if ( strcmp(cp,"ersion") == 0) {
                  /* -version, edg's -v */
                  /* Print out compiler version. */
                  fprintf(stderr, "mfef90 version %s\nBuilt:%s\n",INCLUDE_STAMP,
                          mfef90_compiler_build_date);
                  pass_option = FALSE;
               }
               break;

             case 'w':
               if (*cp=='\0') {
                  add_cray_args("-m4");
                  pass_option = FALSE;
                  Min_Error_Severity = ES_ERROR;
               }  else if ( strncmp(cp, "off", 3) == 0) {
                  Cray_Woff(cp+3);
                  pass_option = FALSE;
               } else if ( *cp=='2') { /* -w2 print warnings */
                  Min_Error_Severity = ES_WARNING;
               }
               else if ( *cp=='3') { /* -w3: exit 1 on warnings */
                  Min_Error_Severity = ES_ERROR;
               }
               pass_option = FALSE;
               break;
            case 'z':
              if (*cp=='\0') { 
                pass_option = TRUE; 
                cleanUpWhirl = TRUE; 
              }
              break;
            } /* switch */
            if (pass_option) {
               add_cray_args(argv[i]);
            }
         }
      } else {
         /* add to the non-switch list */
         add_deferred_cray_args(argv[i]);
      }
   }

   /* Add the align switch */
   if (FE_align==8) {
      add_cray_args("-adalign");
   }

   /* Read the command line and pass it along to the Cray front-end */
   if (FE_command_line) {
      f = fopen(FE_command_line,"r");
      command_line_length = 0;
      if (f) {
         while ( getc(f) != '\n' ) ++command_line_length;
         fseek (f,0,SEEK_SET);
         temp = (char *) malloc(command_line_length+2);
         fgets(temp,command_line_length+1,f);
         temp[command_line_length] = 0;
         fclose(f);
         add_cray_args("-CY");
         add_cray_args(temp);
         free(temp);
      }
   }
}   


/* ====================================================================
 * Entry point from Cray compiler
 * ====================================================================
 */

void sgi_cmd_line (INT *argc, char ***argv)
{
   INT          i;
   INT          len;
   char         msg_num[10];
   char        *chp;
   option_list *opt_list;


   /* Set up SGI error handling */

   save_argv = (char **) malloc((*argc) * sizeof(char *));
   save_argc = *argc;

   for(i=0; i < *argc; i++) {
      len = strlen((*argv)[i]);
      save_argv[i] = (char *) malloc((len + 1)*sizeof(char));
      strcpy(save_argv[i], (*argv)[i]);
   }

   Set_Error_Tables (Phases, host_errlist);
   Init_Error_Handler ( 100 );
   Set_Error_Line ( ERROR_LINE_UNKNOWN );
   Set_Error_File ( NULL );
   Set_Error_Phase ( "Front End Parse/Semantic");
   Handle_Signals();

   /* Set the language to be F90 */
   Language = LANG_F90;
   Preconfigure ();

   /* set this so that Cray will open the file for us */
   Process_Command_Line ( *argc, *argv);

   MEM_Initialize() ;
   MEM_POOL_Initialize(FE_Mempool,"FE_Mempool",TRUE);
   MEM_POOL_Push(FE_Mempool);

   Configure ();
   Configure_Source (NULL);
//   Configure_Target() ;
   IPA_Configure_Target ();

   /* Set the target name for MDupdate */
   if (mdtarget_file == NULL ) mdtarget_file = object_file_name;

   /* Add a few more arguments after the target configuration */
   if (Pointer_Size == 8) {
      add_cray_args("-spointer8");
   }

/*
 * Solaris workaround
 * see ../fe90/target.m, since Solaris doesn't accept shortcircuit 
 * options, remove it to avoid a warning message.
 */
#ifndef _SOLARIS_SOLARIS
   if (FTN_Short_Circuit_On) {
      add_cray_args("-Oshortcircuit0");
   } else {
      add_cray_args("-Oshortcircuit1");
   }
#endif

   /* add the Matrix-multiply inline options */
   if (!Mv_Matmul_Inline_Set) {
     Mv_Matmul_Inline = (Opt_Level >= 3);
   } 
   if (!Matmul_Inline_Set) {
     Matmul_Inline = (Opt_Level >= 3);
   }
   if (Matmul_Inline) {
     add_cray_args("-Omatmul_inline");
   }
   if (Mv_Matmul_Inline) {
     add_cray_args("-Omv_matmul_inline");
   }

   /* Bounds checking */

   if (DEBUG_Subscript_Check) {
     add_cray_args("-Rb");
   }

   if (DEBUG_Fullwarn) {
     add_cray_args("-m2");
   }

                  /* Cray_Woff(cp+3); */

   if (Current_DEBUG->error_set) {
      opt_list = Current_DEBUG->error;

      while (opt_list != NULL) {
         chp = strtok(opt_list->val, ",");

         while(chp != NULL) {
            add_cray_args("-M");
            msg_num[0] = 'E';
            strcpy(&msg_num[1], chp);
            add_cray_args(msg_num);
            chp = strtok(NULL, ",");
         }
         opt_list = opt_list->next;
      } 
   } 

   if (Current_DEBUG->warning_set) {
      opt_list = Current_DEBUG->warning;

      while (opt_list != NULL) {
         chp = strtok(opt_list->val, ",");

         while(chp != NULL) {
            add_cray_args("-M");
            msg_num[0] = 'W';
            strcpy(&msg_num[1], chp);
            add_cray_args(msg_num);
            chp = strtok(NULL, ",");
         }
         opt_list = opt_list->next;
      } 
   } 

   if (enable_mp_processing) {

      if (! disable_old_mp) {
         add_cray_args("-ump");
      }

      if (! disable_open_mp) {
         add_cray_args("-uopen_mp");
      }
   }

   /* Add the deferred arguments */
   for (i = 0 ; i < num_deferred_cray_args; i++) {
      add_cray_args(deferred_argv_cray[i]);
   }
   /* Add a final NULL arg */
   add_cray_args(NULL);
   --num_cray_args;
   
   /* Clean up the mess */
   free(deferred_argv_cray);

   argc_cray = num_cray_args;
   *argc = argc_cray;
   *argv = argv_cray;
   
   if (Get_Trace(TP_IRB, 1) != 0) {
      fprintf(TFile,"Cray command line arguments:\n");
      for (i = 0; i < argc_cray; i++) {
         fprintf(TFile,"Arg %d: |%s|\n",i,argv_cray[i]);
      }
      fprintf(TFile,"\n");
   }
   return;
}