Attachment #497284 for bug #629786

View | Details | Raw Unified | Return to bug 629786
Collapse All | Expand All




++ gcc-4.9.4-format-security/gcc/c/c-convert.c

  if ((invalid_conv_diag
       = targetm.invalid_conversion (TREE_TYPE (expr), type)))
    {
      error ("%s", invalid_conv_diag);
      return error_mark_node;
    }

++ gcc-4.9.4-format-security/gcc/c/c-decl.c

	    errmsg = targetm.invalid_return_type (type);
	    if (errmsg)
	      {
		error ("%s", errmsg);
		type = integer_type_node;
	      }


	  errmsg = targetm.invalid_parameter_type (type);
	  if (errmsg)
	    {
	      error ("%s", errmsg);
	      TREE_VALUE (typelt) = error_mark_node;
	      TREE_TYPE (parm) = error_mark_node;
	      arg_types = NULL_TREE;
++ gcc-4.9.4-format-security/gcc/c/c-typeck.c

      else if ((invalid_func_diag =
		targetm.calls.invalid_arg_for_unprototyped_fn (typelist, fundecl, val)))
	{
	  error ("%s", invalid_func_diag);
	  return -1;
	}
      else

  if ((invalid_op_diag
       = targetm.invalid_unary_op (code, TREE_TYPE (xarg))))
    {
      error_at (location, "%s", invalid_op_diag);
      return error_mark_node;
    }


  char *ofwhat;

  /* The gmsgid may be a format string with %< and %>. */
  error ("%s", gmsgid);
  ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
  if (*ofwhat)
    error ("(near initialization for %qs)", ofwhat);

  char *ofwhat;

  /* The gmsgid may be a format string with %< and %>. */
  pedwarn (location, opt, "%s", gmsgid);
  ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
  if (*ofwhat)
    pedwarn (location, opt, "(near initialization for %qs)", ofwhat);

  char *ofwhat;

  /* The gmsgid may be a format string with %< and %>. */
  warning (opt, "%s", gmsgid);
  ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
  if (*ofwhat)
    warning (opt, "(near initialization for %qs)", ofwhat);

  if ((invalid_op_diag
       = targetm.invalid_binary_op (code, type0, type1)))
    {
      error_at (location, "%s", invalid_op_diag);
      return error_mark_node;
    }

++ gcc-4.9.4-format-security/gcc/c-family/c-common.c

      message = NULL;
    }
  else
    error ("%s", gmsgid);

  if (message)
    {
      error ("%s", message);
      free (message);
    }
#undef catenate_messages
++ gcc-4.9.4-format-security/gcc/collect2.c

	  fatal_error ("%s: %m", _(errmsg));
	}
      else
	fatal_error ("%s", errmsg);
    }

  free (response_arg);

	  fatal_error ("%s: %m", _(errmsg));
	}
      else
	fatal_error ("%s", errmsg);
    }

  int_handler  = (void (*) (int)) signal (SIGINT,  SIG_IGN);
++ gcc-4.9.4-format-security/gcc/cp/cvt.c

       = targetm.invalid_conversion (TREE_TYPE (expr), type)))
    {
      if (complain & tf_error)
	error ("%s", invalid_conv_diag);
      return error_mark_node;
    }

++ gcc-4.9.4-format-security/gcc/cp/decl.c

	    errmsg = targetm.invalid_return_type (type);
	    if (errmsg)
	      {
		error ("%s", errmsg);
		type = integer_type_node;
	      }


      if (type != error_mark_node
	  && (errmsg = targetm.invalid_parameter_type (type)))
	{
	  error ("%s", errmsg);
	  type = error_mark_node;
	  TREE_TYPE (decl) = error_mark_node;
	}
++ gcc-4.9.4-format-security/gcc/cp/init.c

	    msg = ("non-constant array new length must be specified "
		   "without parentheses around the type-id");
	  pedwarn (EXPR_LOC_OR_LOC (outer_nelts, input_location),
		   OPT_Wvla, "%s", msg);
	}
      else
	return error_mark_node;

  if (VOID_TYPE_P (elt_type))
    {
      if (complain & tf_error)
        error ("%s", "invalid type %<void%> for new");
      return error_mark_node;
    }

++ gcc-4.9.4-format-security/gcc/cp/parser.c

    {
      /* Don't use `%s' to print the string, because quotations (`%<', `%>')
	 in the message need to be interpreted.  */
      error ("%s", parser->type_definition_forbidden_message);
      return false;
    }
  return true;
++ gcc-4.9.4-format-security/gcc/cp/pt.c

				     &error_msg,
				     input_location);
	if (error_msg)
	  error ("%s", error_msg);
	if (!function_p && identifier_p (decl))
	  {
	    if (complain & tf_error)
++ gcc-4.9.4-format-security/gcc/cp/typeck.c

       = targetm.invalid_binary_op (code, type0, type1)))
    {
      if (complain & tf_error)
	error ("%s", invalid_op_diag);
      return error_mark_node;
    }


				   TREE_TYPE (xarg))))
    {
      if (complain & tf_error)
	error ("%s", invalid_op_diag);
      return error_mark_node;
    }

++ gcc-4.9.4-format-security/gcc/dwarf2asm.c

#ifndef ASM_OUTPUT_DWARF_VMS_DELTA
  /* VMS Delta is only special on ia64-vms, but this function also gets
     called on alpha-vms so it has to do something sane.  */
  dw2_asm_output_delta (size, lab1, lab2, "%s", comment);
#else
  ASM_OUTPUT_DWARF_VMS_DELTA (asm_out_file, size, lab1, lab2);
  if (flag_debug_asm && comment)
++ gcc-4.9.4-format-security/gcc/fold-const.c

	}
    }
  else if (issue_strict_overflow_warning (wc))
    warning (OPT_Wstrict_overflow, "%s", gmsgid);
}

/* Return true if the built-in mathematical function specified by CODE
++ gcc-4.9.4-format-security/gcc/fortran/arith.c


  if (rc != ARITH_OK)
    {
      gfc_error ("%s", gfc_arith_error (rc), &op1->where);
      return NULL;
    }

++ gcc-4.9.4-format-security/gcc/fortran/decl.c


  if (msg != NULL)
    {
      gfc_error ("%s", msg);
      m = MATCH_ERROR;
      goto no_match;
    }

  *is_iso_c = e->ts.is_iso_c;
  if (msg != NULL)
    {
      gfc_error ("%s", msg);
      m = MATCH_ERROR;
      goto no_match;
    }


      /* Use upper case to save the actual derived-type symbol.  */
      gfc_get_symbol (dt_name, NULL, &dt_sym);
      dt_sym->name = gfc_get_string ("%s", sym->name);
      head = sym->generic;
      intr = gfc_get_interface ();
      intr->sym = dt_sym;

      gfc_get_symbol (gfc_get_string ("%c%s",
			(char) TOUPPER ((unsigned char) gensym->name[0]),
			&gensym->name[1]), NULL, &sym);
      sym->name = gfc_get_string ("%s", gensym->name);
      head = gensym->generic;
      intr = gfc_get_interface ();
      intr->sym = sym;

	      if (m == MATCH_ERROR)
		goto error;
	      if (m == MATCH_YES)
		ba->pass_arg = gfc_get_string ("%s", arg);
	      gcc_assert ((m == MATCH_YES) == (ba->pass_arg != NULL));

	      found_passing = true;
++ gcc-4.9.4-format-security/gcc/fortran/frontend-passes.c

  strcpy (name, fn->value.function.name);
  p = strstr (name, "loc0");
  p[3] = '1';
  fn->value.function.name = gfc_get_string ("%s", name);
  if (fn->value.function.actual->next)
    {
      a = fn->value.function.actual->next;
++ gcc-4.9.4-format-security/gcc/fortran/intrinsic.c

      break;

    case SZ_NOTHING:
      next_sym->name = gfc_get_string ("%s", name);

      strcpy (buf, "_gfortran_");
      strcat (buf, name);
      next_sym->lib_name = gfc_get_string ("%s", buf);

      next_sym->pure = (cl != CLASS_IMPURE);
      next_sym->elemental = (cl == CLASS_ELEMENTAL);

  /* name may be a user-supplied string, so we must first make sure
     that we're comparing against a pointer into the global string
     table.  */
  const char *p = gfc_get_string ("%s", name);

  while (n > 0)
    {


    case SZ_NOTHING:
      next_sym[0] = next_sym[-1];
      next_sym->name = gfc_get_string ("%s", name);
      next_sym->standard = standard;
      next_sym++;
      break;
++ gcc-4.9.4-format-security/gcc/fortran/iresolve.c

	}
    }

  f->value.function.name = gfc_get_string ("%s", name);
}


++ gcc-4.9.4-format-security/gcc/fortran/match.c


  if (p != NULL)
    {
      gfc_error ("%s", p);
      m = MATCH_ERROR;
    }



  if (p != NULL)
    {
      gfc_error ("%s", p);
      m = MATCH_ERROR;
    }

++ gcc-4.9.4-format-security/gcc/fortran/matchexp.c

  return MATCH_YES;

syntax:
  gfc_error ("%s", expression_syntax);
  return MATCH_ERROR;
}


      m = match_ext_add_operand (&e);
      if (m == MATCH_NO)
	{
	  gfc_error ("%s", expression_syntax);
	  m = MATCH_ERROR;
	}
    }


      m = match_ext_add_operand (&e);
      if (m == MATCH_NO)
	gfc_error ("%s", expression_syntax);
      if (m != MATCH_YES)
	{
	  gfc_free_expr (all);


      m = match_level_2 (&e);
      if (m == MATCH_NO)
	gfc_error ("%s", expression_syntax);
      if (m != MATCH_YES)
	{
	  gfc_free_expr (all);


  m = match_level_3 (&right);
  if (m == MATCH_NO)
    gfc_error ("%s", expression_syntax);
  if (m != MATCH_YES)
    {
      gfc_free_expr (left);


      m = match_and_operand (&e);
      if (m == MATCH_NO)
	gfc_error ("%s", expression_syntax);
      if (m != MATCH_YES)
	{
	  gfc_free_expr (all);


      m = match_or_operand (&e);
      if (m == MATCH_NO)
	gfc_error ("%s", expression_syntax);
      if (m != MATCH_YES)
	{
	  gfc_free_expr (all);


      m = match_equiv_operand (&e);
      if (m == MATCH_NO)
	gfc_error ("%s", expression_syntax);
      if (m != MATCH_YES)
	{
	  gfc_free_expr (all);


      m = match_level_5 (&e);
      if (m == MATCH_NO)
	gfc_error ("%s", expression_syntax);
      if (m != MATCH_YES)
	{
	  gfc_free_expr (all);
++ gcc-4.9.4-format-security/gcc/fortran/module.c

  if (name[0] != (char) TOLOWER ((unsigned char) name[0]))
    return gfc_get_string ("%c%s", (char) TOLOWER ((unsigned char) name[0]),
			   &name[1]);
  return gfc_get_string ("%s", name);
}



  if (name[0] != (char) TOUPPER ((unsigned char) name[0]))
    return gfc_get_string ("%c%s", (char) TOUPPER ((unsigned char) name[0]),
			   &name[1]);
  return gfc_get_string ("%s", name);
}

/* Call here during module reading when we know what pointer to

      return m;
    }

  use_list->module_name = gfc_get_string ("%s", name);

  if (gfc_match_eos () == MATCH_YES)
    goto done;

  gfc_symbol sym;
  int c;

  t.name = gfc_get_string ("%s", name);
  if (module != NULL)
    sym.module = gfc_get_string ("%s", module);
  else
    sym.module = NULL;
  t.sym = &sym;

  else
    {
      require_atom (ATOM_STRING);
      *stringp = atom_string[0] == '\0' ? NULL : gfc_get_string ("%s", atom_string);
      free (atom_string);
    }
}

	    {
	      p->u.rsym.sym = gfc_new_symbol (p->u.rsym.true_name,
					      gfc_current_ns);
	      p->u.rsym.sym->module = gfc_get_string ("%s", p->u.rsym.module);
	    }

	  p->u.rsym.symtree->n.sym = p->u.rsym.sym;

	      if (!sym)
		{
		  gfc_get_symbol (p, NULL, &sym);
		  sym->name = gfc_get_string ("%s", name);
		  sym->module = module_name;
		  sym->attr.flavor = FL_PROCEDURE;
		  sym->attr.generic = 1;


      sym = gfc_new_symbol (p->u.rsym.true_name, ns);
      sym->name = dt_lower_string (p->u.rsym.true_name);
      sym->module = gfc_get_string ("%s", p->u.rsym.module);
      if (p->u.rsym.binding_label)
	sym->binding_label = IDENTIFIER_POINTER (get_identifier 
						 (p->u.rsym.binding_label));

						     gfc_current_ns);
		  info->u.rsym.sym->name = dt_lower_string (info->u.rsym.true_name);
		  sym = info->u.rsym.sym;
		  sym->module = gfc_get_string ("%s", info->u.rsym.module);

		  if (info->u.rsym.binding_label)
		    sym->binding_label = 

	strcpy (name, module_name);
      mio_internal_string (name);
      if (iomode == IO_INPUT)
	module_name = gfc_get_string ("%s", name);
    }
  mio_rparen ();
}


  /* Write the module itself.  */
  iomode = IO_OUTPUT;
  module_name = gfc_get_string ("%s", name);

  init_pi_tree ();


  sym->attr.flavor = FL_PROCEDURE;
  sym->attr.intrinsic = 1;

  sym->module = gfc_get_string ("%s", modname);
  sym->attr.use_assoc = 1;
  sym->from_intmod = module;
  sym->intmod_sym_id = id;


      mod_sym->attr.flavor = FL_MODULE;
      mod_sym->attr.intrinsic = 1;
      mod_sym->module = gfc_get_string ("%s", iso_c_module_name);
      mod_sym->from_intmod = INTMOD_ISO_C_BINDING;
    }


  gfc_get_sym_tree (name, gfc_current_ns, &tmp_symtree, false);
  sym = tmp_symtree->n.sym;

  sym->module = gfc_get_string ("%s", modname);
  sym->attr.flavor = FL_PARAMETER;
  sym->ts.type = BT_INTEGER;
  sym->ts.kind = gfc_default_integer_kind;

  gfc_get_sym_tree (name, gfc_current_ns, &tmp_symtree, false);
  sym = tmp_symtree->n.sym;

  sym->module = gfc_get_string ("%s", modname);
  sym->attr.flavor = FL_PARAMETER;
  sym->ts.type = BT_INTEGER;
  sym->ts.kind = gfc_default_integer_kind;


  gfc_get_sym_tree (name, gfc_current_ns, &tmp_symtree, false);
  sym = tmp_symtree->n.sym;
  sym->module = gfc_get_string ("%s", modname);
  sym->from_intmod = module;
  sym->intmod_sym_id = id;
  sym->attr.flavor = FL_PROCEDURE;

  gfc_get_sym_tree (dt_upper_string (sym->name),
		    gfc_current_ns, &tmp_symtree, false);
  dt_sym = tmp_symtree->n.sym;
  dt_sym->name = gfc_get_string ("%s", sym->name);
  dt_sym->attr.flavor = FL_DERIVED;
  dt_sym->attr.private_comp = 1;
  dt_sym->attr.zero_comp = 1;
  dt_sym->attr.use_assoc = 1;
  dt_sym->module = gfc_get_string ("%s", modname);
  dt_sym->from_intmod = module;
  dt_sym->intmod_sym_id = id;



      mod_sym->attr.flavor = FL_MODULE;
      mod_sym->attr.intrinsic = 1;
      mod_sym->module = gfc_get_string ("%s", mod);
      mod_sym->from_intmod = INTMOD_ISO_FORTRAN_ENV;
    }
  else
++ gcc-4.9.4-format-security/gcc/fortran/openmp.c

	      const char *p = gfc_extract_int (cexpr, &collapse);
	      if (p)
		{
		  gfc_error_now ("%s", p);
		  collapse = 1;
		}
	      else if (collapse <= 0)
++ gcc-4.9.4-format-security/gcc/fortran/primary.c

      msg = gfc_extract_int (e, &num);
      if (msg != NULL)
	{
	  gfc_error ("%s", msg);
	  goto cleanup;
	}
      if (num == 0)

      q = gfc_extract_int (sym->value, &kind);
      if (q != NULL)
	{
	  gfc_error ("%s", q);
	  return MATCH_ERROR;
	}
      gfc_set_sym_referenced (sym);

	  }
    }

  actual->name = gfc_get_string ("%s", name);
  return MATCH_YES;

cleanup:
++ gcc-4.9.4-format-security/gcc/fortran/symbol.c

  else
    tail->next = p;

  p->name = gfc_get_string ("%s", name);
  p->loc = gfc_current_locus;
  p->ts.type = BT_UNKNOWN;


  gfc_symtree *st;

  st = XCNEW (gfc_symtree);
  st->name = gfc_get_string ("%s", name);

  gfc_insert_bbt (root, st, compare_symtree);
  return st;


  st0 = gfc_find_symtree (*root, name);

  st.name = gfc_get_string ("%s", name);
  gfc_delete_bbt (root, &st, compare_symtree);

  free (st0);

  st = gfc_new_symtree (&ns->uop_root, name);

  uop = st->n.uop = XCNEW (gfc_user_op);
  uop->name = gfc_get_string ("%s", name);
  uop->access = ACCESS_UNKNOWN;
  uop->ns = ns;


  if (strlen (name) > GFC_MAX_SYMBOL_LEN)
    gfc_internal_error ("new_symbol(): Symbol name too long");

  p->name = gfc_get_string ("%s", name);

  /* Make sure flags for symbol being C bound are clear initially.  */
  p->attr.is_bind_c = 0;


  s = XCNEW (gfc_gsymbol);
  s->type = GSYM_UNKNOWN;
  s->name = gfc_get_string ("%s", name);

  gfc_insert_bbt (&gfc_gsym_root, s, gsym_compare);


    }

  /* Say what module this symbol belongs to.  */
  tmp_sym->module = gfc_get_string ("%s", mod_name);
  tmp_sym->from_intmod = INTMOD_ISO_C_BINDING;
  tmp_sym->intmod_sym_id = s;
  tmp_sym->attr.is_iso_c = 1;

	    }

	  /* Say what module this symbol belongs to.  */
	  dt_sym->module = gfc_get_string ("%s", mod_name);
	  dt_sym->from_intmod = INTMOD_ISO_C_BINDING;
	  dt_sym->intmod_sym_id = s;
          dt_sym->attr.use_assoc = 1;
++ gcc-4.9.4-format-security/gcc/fortran/trans-decl.c

    {
      struct module_htab_entry *entry = ggc_alloc_cleared_module_htab_entry ();

      entry->name = gfc_get_string ("%s", name);
      entry->decls = htab_create_ggc (10, module_htab_decls_hash,
				      module_htab_decls_eq, NULL);
      *slot = (void *) entry;
++ gcc-4.9.4-format-security/gcc/gcc.c

      if (errmsg != NULL)
	{
	  if (err == 0)
	    fatal_error ("%s", errmsg);
	  else
	    {
	      errno = err;
++ gcc-4.9.4-format-security/gcc/lto-wrapper.c

      if (err != 0)
	{
	  errno = err;
	  fatal_perror ("%s", errmsg);
	}
      else
	fatal ("%s", errmsg);
    }

  return pex;
++ gcc-4.9.4-format-security/gcc/opts.c

		    {
		      if (* (const char **) flag_var != NULL)
			snprintf (new_help + strlen (new_help),
				  sizeof (new_help) - strlen (new_help),"%s",
				  * (const char **) flag_var);
		    }
		  else if (option->var_type == CLVC_ENUM)

		      if (arg == NULL)
			arg = _("[default]");
		      snprintf (new_help + strlen (new_help),
				sizeof (new_help) - strlen (new_help), "%s",
				arg);
		    }
		  else
++ gcc-4.9.4-format-security/gcc/tree-sra.c

{
  basic_block bb;

  fprintf (dump_file, "%s", str);
  FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun),
		  EXIT_BLOCK_PTR_FOR_FN (cfun), next_bb)
    {
++ gcc-4.9.4-format-security/gcc/tree-ssa-uninit.c

{
  size_t i, j;
  pred_chain one_pred_chain = vNULL;
  fprintf (dump_file, "%s", msg);
  print_gimple_stmt (dump_file, usestmt, 0, 0);
  fprintf (dump_file, "is guarded by :\n\n");
  size_t num_preds = preds.length ();
++ gcc-4.9.4-format-security/libcpp/expr.c


	  if (CPP_OPTION (pfile, c99))
            cpp_warning_with_line (pfile, CPP_W_LONG_LONG, virtual_location,
				   0, "%s", message);
          else
            cpp_pedwarning_with_line (pfile, CPP_W_LONG_LONG,
				      virtual_location, 0, "%s", message);
        }

      result |= CPP_N_INTEGER;
++ gcc-4.9.4-format-security/libcpp/macro.c

	     function-like macros, but not at the end.  */
	  if (following_paste_op)
	    {
	      cpp_error (pfile, CPP_DL_ERROR, "%s", paste_op_error_msg);
	      return false;
	    }
	  break;

	     function-like macros, but not at the beginning.  */
	  if (macro->count == 1)
	    {
	      cpp_error (pfile, CPP_DL_ERROR, "%s", paste_op_error_msg);
	      return false;
	    }


Return to bug 629786