code review 9033043: cmd/gc: fix some overflows in the compiler

src/cmd/gc/go.h

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 #include        <bio.h>
 
 #undef OAPPEND
 
 // avoid <ctype.h>
 #undef isblank
@@ skipping 138 matching lines @@
         uchar   deferwidth;
         uchar   broke;          // broken type definition.
         uchar   isddd;          // TFIELD is ... argument
         uchar   align;
 
         Node*   nod;            // canonical OTYPE node
         Type*   orig;           // original type (type literal or predefined type)
         int             lineno;
 
         // TFUNC
-        uchar   thistuple;
-        uchar   outtuple;
-        uchar   intuple;
+        int     thistuple;
+        int     outtuple;
+        int     intuple;
         uchar   outnamed;
 
         Type*   method;
         Type*   xmethod;
 
         Sym*    sym;
         int32   vargen;         // unique name for OTYPE/ONAME
 
         Node*   nname;
         vlong   argwid;
@@ skipping 73 matching lines @@
         uchar   ullman;         // sethi/ullman number
         uchar   addable;        // type of addressability - 0 is not addressable
         uchar   trecur;         // to detect loops
         uchar   etype;          // op for OASOP, etype for OTYPE, exclam for export
         uchar   bounded;        // bounds check unnecessary
         uchar   class;          // PPARAM, PAUTO, PEXTERN, etc
         uchar   method;         // OCALLMETH name
         uchar   embedded;       // ODCLFIELD embedded type
         uchar   colas;          // OAS resulting from :=
         uchar   diag;           // already printed error about this
-        uchar   esc;            // EscXXX
         uchar   noescape;       // func arguments do not escape
-        uchar   funcdepth;
         uchar   builtin;        // built-in name, like len or close
         uchar   walkdef;
         uchar   typecheck;
         uchar   local;
         uchar   dodata;
         uchar   initorder;
         uchar   used;
         uchar   isddd;
         uchar   readonly;
         uchar   implicit;
         uchar   addrtaken;      // address taken, even if not moved to heap
         uchar   dupok;  // duplicate definitions ok (for func)
         schar   likely; // likeliness of if statement
         uchar   hasbreak;       // has break statement
+        uint    esc;            // EscXXX
+        int     funcdepth;
 
         // most nodes
         Type*   type;
         Node*   orig;           // original form, for printing, and tracking copies of ONAMEs
 
         // func
         Node*   nname;
         Node*   shortname;
         NodeList*       enter;
         NodeList*       exit;
@@ skipping 814 matching lines @@
 /*
  *      gen.c
  */
 void    addrescapes(Node *n);
 void    cgen_as(Node *nl, Node *nr);
 void    cgen_callmeth(Node *n, int proc);
 void    cgen_eface(Node* n, Node* res);
 void    cgen_slice(Node* n, Node* res);
 void    clearlabels(void);
 void    checklabels(void);
-int     dotoffset(Node *n, int *oary, Node **nn);
+int     dotoffset(Node *n, int64 *oary, Node **nn);
 void    gen(Node *n);
 void    genlist(NodeList *l);
 Node*   sysfunc(char *name);
 void    tempname(Node *n, Type *t);
 Node*   temp(Type*);
 
 /*
  *      init.c
  */
 void    fninit(NodeList *n);
@@ skipping 367 matching lines @@
 #pragma varargck        type    "T"     Type*
 #pragma varargck        type    "lT"    Type*
 #pragma varargck        type    "V"     Val*
 #pragma varargck        type    "Y"     char*
 #pragma varargck        type    "Z"     Strlit*
 
 /*
  *      racewalk.c
  */
 void    racewalk(Node *fn);