Merge pull request #635 from ThePortlandGroup/nv_stage

sscalpone · web-flow · commit ab7f15aa1b9a · 2018-12-12T15:22:36.000-08:00
Pull 2018-12-12T13-57 Recent NVIDIA Changes
diff --git a/include/flang/Error/errmsg-in.n b/include/flang/Error/errmsg-in.n
@@ -1508,9 +1508,11 @@ A DO CONCURRENT or FORALL construct or statement may not specify an index name m
 .MS S 1059 "The definition of subprogram $ does not have the same number of arguments as its declaration"
 .MS S 1060 "The $ of the definition and declaration of subprogram $ must match"
 .MS S 1061 "The definition of function return type of $ does not match its declaration type"
+.MS S 1062 "LOCAL_INIT variable does not have an outside variable of the same name - $"
+A DO CONCURRENT variable with LOCAL_INIT locality must have a host variable of the same name.
 .MS S 1200 "OpenMP GPU - [$] is used, it is not implemented yet."
 .MS S 1201 "OpenMP GPU - [$] is used with [$], this usage is not implemented yet."
 .MS S 1202 "OpenMP GPU - [$] is used independently than [$], this usage is not implemented yet."
 .MS S 1203 "OpenMP GPU - Directive target exit data is used, map type [$] cannot be used. It should be one of 'from', 'release', or 'delete'"
 .MS S 1204 "OpenMP GPU - Directive target data is used, map type [$] cannot be used. It should be one of 'to', 'from', 'tofrom', 'alloc', 'release', or 'delete'"
-.MS S 1205 "OpenMP GPU - Directive target enter data is used, map type [$] cannot be used. It should be one of 'to', or 'alloc'"
+.MS S 1205 "OpenMP GPU - Directive target enter data is used, map type [$] cannot be used. It should be one of 'to', or 'alloc'"
diff --git a/runtime/flang/ieee_arithmetic.s b/runtime/flang/ieee_arithmetic.s
diff --git a/runtime/flang/ieee_exceptions.s b/runtime/flang/ieee_exceptions.s
diff --git a/tools/flang1/flang1exe/outconv.c b/tools/flang1/flang1exe/outconv.c
@@ -308,7 +308,7 @@ static void
 convert_omp_workshare(void)
 {
   int std;
-  int newstd;
+  int newstd = 0;
   int ast;
   int lsptr;
   int prevast;
@@ -508,7 +508,8 @@ convert_omp_workshare(void)
         }
         break;
       }
-      STD_PAR(newstd) = 1;
+      if (newstd)
+        STD_PAR(newstd) = 1;
 
       break;
     case IN_CRITICAL:
diff --git a/tools/flang1/flang1exe/semant.c b/tools/flang1/flang1exe/semant.c
@@ -2270,7 +2270,11 @@ semant1(int rednum, SST *top)
       sptr = insert_sym(sptr);
 
     } else if (STYPEG(sptr) == ST_PROC && IN_MODULE_SPEC &&
-               get_seen_contains() && !sem.which_pass) {
+               get_seen_contains() && !sem.which_pass &&
+              /* separate module procedure is allowed to be declared &
+                 defined within the same module
+               */
+               !IS_INTERFACEG(sptr)) {
       LOGICAL err = TYPDG(sptr) && SCOPEG(sptr) != stb.curr_scope;
       if (!err) {
         int dpdsc = 0;
@@ -14028,7 +14032,8 @@ _do_iface(int iface_state, int i)
         goto iface_err;
       }
     }
-    return;
+    if (proc <= NOSYM)
+      return; 
   }
   if (strcmp(SYMNAME(iface), name) != 0)
     iface = getsymbol(name);
diff --git a/tools/flang1/flang1exe/semant3.c b/tools/flang1/flang1exe/semant3.c
@@ -3046,6 +3046,7 @@ semant3(int rednum, SST *top)
         DI_CONC_SYMAVL(doif) = sem.doconcurrent_symavl;
         DI_CONC_BLOCK_SYM(doif) = sptr =
           getccsym('b', sem.blksymnum++, ST_BLOCK);
+        CCSYMP(sptr, true);
         STARTLINEP(sptr, gbl.lineno);
         // If the do concurrent loop is nested in another do concurrent loop,
         // the outer loop is the parent of the block sym.  Otherwise, the
@@ -3405,14 +3406,22 @@ semant3(int rednum, SST *top)
       }
       break;
     }
+    DCLCHK(sptr);
     switch (DI_CONC_KIND(doif)) {
-    case TK_LOCAL:
     case TK_LOCAL_INIT:
+      if (sptr >= DI_CONC_SYMAVL(doif)) {
+        error(1062, ERR_Severe, gbl.lineno, SYMNAME(sptr), CNULL);
+        DI_CONC_ERROR_SYMS(doif) = add_symitem(sptr, DI_CONC_ERROR_SYMS(doif));
+        break;
+      }
+      // fall through
+    case TK_LOCAL:
       if (sptr < DI_CONC_SYMAVL(doif)) {
         // sptr is external to the loop; get a construct instance.
         if (STYPEG(sptr) == ST_PD) {
+          int dcld = DCLDG(sptr);
           sptr = insert_sym(sptr);
-          DCLDP(sptr, 1);
+          DCLDP(sptr, dcld);
         } else {
           sptr = insert_dup_sym(sptr);
         }
diff --git a/tools/flang1/flang1exe/semfunc.c b/tools/flang1/flang1exe/semfunc.c
@@ -947,6 +947,10 @@ func_call2(SST *stktop, ITEM *list, int flag)
 
               SST_ASTP(sp, new_ast);
               SST_IDP(sp, S_EXPR);
+            } else if (A_TYPEG(ARGT_ARG(A_ARGSG(SST_ASTG(sp)), 0)) != A_ID) {
+              // Inlining has problems with an expression in this context.
+              // Downstream code can always handle simple variables.
+              (void)tempify(sp);
             }
             /* else
              * iso_c_loc by reference pointer to pointer */
diff --git a/tools/flang1/flang1exe/semutil.c b/tools/flang1/flang1exe/semutil.c
@@ -1307,6 +1307,7 @@ mklvalue(SST *stkptr, int stmt_type)
         sptr = insert_sym(sptr);
       DTYPEP(sptr, dtype);
       DCLDP(sptr, dcld);
+      DCLCHK(sptr);
     } else if (stmt_type == 5) {
       int doif = sem.doif_depth;
       dtype = DI_FORALL_DTYPE(doif) ? DI_FORALL_DTYPE(doif) : DTYPEG(sptr);
@@ -1315,6 +1316,7 @@ mklvalue(SST *stkptr, int stmt_type)
         sptr = insert_sym(sptr);
       DTYPEP(sptr, dtype);
       DCLDP(sptr, dcld);
+      DCLCHK(sptr);
     }
 
     switch (STYPEG(sptr)) {
@@ -5824,17 +5826,21 @@ do_end(DOINFO *doinfo)
     block_sptr = DI_CONC_BLOCK_SYM(orig_doif);
     ENDLINEP(block_sptr, gbl.lineno);
     ENDLABP(block_sptr, lab);
-    sptr = DI_CONC_SYMAVL(orig_doif);
-    for (i = DI_CONC_COUNT(orig_doif); i; --i, ++sptr)
+    for (i = DI_CONC_COUNT(orig_doif), symi = DI_CONC_SYMS(orig_doif); i;
+         --i, symi = SYMI_NEXT(symi)) {
+      sptr = SYMI_SPTR(symi);
       HIDDENP(sptr, 1); // do concurrent index construct var
-    for (; sptr < stb.stg_avail; ++sptr)
+    }
+    for (++sptr; sptr < stb.stg_avail; ++sptr)
       switch (STYPEG(sptr)) {
       case ST_UNKNOWN:
       case ST_IDENT:
       case ST_VAR:
       case ST_ARRAY:
         if (SAVEG(sptr))
           break;
+        if (!CCSYMG(sptr) && !HCCSYMG(sptr))
+          DCLCHK(sptr);
         HIDDENP(sptr, 1); // do concurrent non-index construct var
         if (ENCLFUNCG(sptr) == 0)
           ENCLFUNCP(sptr, block_sptr);
diff --git a/tools/flang1/flang1exe/semutil2.c b/tools/flang1/flang1exe/semutil2.c
@@ -2668,6 +2668,9 @@ _constructf90(int base_id, int in_indexast, bool in_array, ACL *aclp)
       for (; mem_sptr != NOSYM; mem_sptr = SYMLKG(mem_sptr)) {
         if (!is_unl_poly(mem_sptr) && no_data_components(DTYPEG(mem_sptr)))
           continue;
+        /* skip $td */
+        if (CLASSG(mem_sptr) && DESCARRAYG(mem_sptr))
+          continue;
         if (XBIT(58, 0x10000) && POINTERG(mem_sptr) && !F90POINTERG(mem_sptr)) {
           SST *astkp;
           int aast;
diff --git a/tools/flang2/docs/xflag.n b/tools/flang2/docs/xflag.n
@@ -5239,6 +5239,8 @@ Print array assignments using pointer arithmetic always.
 Don't demote address KMUL operations
 .XB 0x200000:
 in LLVM output, don't output the instruction info (lilix index, opcode)
+.XB 0x400000:
+reserved
 
 .XF "202:"
 Set number of bigbuffers for multi-buffer memory management for AMD GPU.
diff --git a/tools/flang2/flang2exe/cgmain.cpp b/tools/flang2/flang2exe/cgmain.cpp
@@ -9238,14 +9238,6 @@ gen_llvm_expr(int ilix, LL_Type *expected_type)
     mask_ili = ILI_OPND(ilix, 3);
     op_lltype = make_lltype_from_dtype(ili_get_vect_dtype(lhs_ili));
 
-    if ((*vect_lltype->sub_types)->data_type !=
-        (*op_lltype->sub_types)->data_type) {
-      assert(
-          0,
-          "VPERMUTE: result and operand dtypes must have matching base type.",
-          0, ERR_Severe);
-    }
-
     op1 = gen_llvm_expr(lhs_ili, op_lltype);
     if (ILI_OPC(rhs_ili) == IL_NULL) /* a don't care, generate an undef */
       op1->next = make_undef_op(op1->ll_type);
diff --git a/tools/flang2/flang2exe/exp_ftn.cpp b/tools/flang2/flang2exe/exp_ftn.cpp
@@ -83,6 +83,8 @@ static int accreduct_op;
 
 #define mk_prototype mk_prototype_llvm
 
+bool ishft = false;
+
 static int
 forceK(int ili)
 {
@@ -124,6 +126,32 @@ double_is_small_int(int ilix)
   return ret_ili;
 }
 
+/**
+ * \brief check special case for ISHFT(int8)
+ */
+static bool
+is_ishft(int curilm)
+{
+  ILM *ilmp;
+  ILM_OP opc;
+  int len, bsize, ilmx;
+  len = 0;
+  bsize = ilmb.ilm_base[BOS_SIZE - 1];
+  ilmx = 0;
+  do {
+    ilmx += len;
+    ilmp = (ILM *)(ilmb.ilm_base + curilm + ilmx);
+    opc = ILM_OPC(ilmp);
+    len = ilms[opc].oprs + 1;
+    if (IM_VAR(opc))
+        len += ILM_OPND(ilmp, 1);
+    if (opc == IM_JISHFT && (ILM_OPND(ilmp, 1) == curilm)) {
+      return true;
+    }
+  } while (curilm + ilmx + len < bsize);
+  return false;
+}
+
 void
 exp_ac(ILM_OP opc, ILM *ilmp, int curilm)
 {
@@ -364,7 +392,14 @@ exp_ac(ILM_OP opc, ILM *ilmp, int curilm)
       val[1] <<= 3;                      /* difference in bits */
       op2 = ad_icon(val[1]);
       tmp = ad2ili(IL_LSHIFT, op1, op2);
-      op1 = ad2ili(IL_ARSHIFT, tmp, op2);
+      if (is_ishft(curilm)) {
+        /* Special case for ishft(int8) */
+        ishft = true;
+        op1 = ad2ili(IL_URSHIFT, tmp, op2);
+        ishft = false;
+      } else {
+        op1 = ad2ili(IL_ARSHIFT, tmp, op2);
+      }
     }
     ILM_RESULT(curilm) = op1;
     return;
diff --git a/tools/flang2/flang2exe/iliutil.cpp b/tools/flang2/flang2exe/iliutil.cpp
@@ -68,6 +68,7 @@ union ATOMIC_ENCODER {
 
 bool share_proc_ili = false;
 bool share_qjsr_ili = false;
+extern bool ishft;
 
 static int addarth(ILI *);
 static int red_iadd(int, INT);
@@ -5350,7 +5351,11 @@ addarth(ILI *ilip)
     } else if (ncons == 3) {
       tmp = con2v2;
       if (SHIFTOK(tmp)) {
-        res.numi[1] = URSHIFT(con1v2, tmp);
+        if (ishft) {
+          res.numi[1] = ARSHIFT(con1v2, tmp);
+        } else {
+          res.numi[1] = URSHIFT(con1v2, tmp);
+        }
         goto add_icon;
       }
     }
diff --git a/tools/flang2/flang2exe/ll_write.cpp b/tools/flang2/flang2exe/ll_write.cpp
@@ -482,8 +482,10 @@ ll_write_instruction(FILE *out, LL_Instruction *inst, LL_Module *module, int no_
     render_bitcast(out, inst);
     break;
   case LL_RET:
-    if (no_return)
-      fprintf(out, "%scall void @llvm.nvvm.exit()",SPACES);
+    if (no_return) {
+      fprintf(out, "%scall void @llvm.nvvm.exit()\n",SPACES);
+      fprintf(out, "%sunreachable",SPACES);
+    }
     else
       fprintf(out, "%sret %s %s", SPACES, inst->operands[0]->type_struct->str,
                     inst->operands[0]->data);
@@ -726,16 +728,15 @@ ll_write_local_objects(FILE *out, LL_Function *function)
   }
 }
 void
-ll_write_function(FILE *out, LL_Function *function, LL_Module *module, int no_return)
+ll_write_function(FILE *out, LL_Function *function, LL_Module *module, bool no_return, const char *prefix)
 {
   int i;
   char attribute[256];
   LL_BasicBlock *block = function->first;
 
   fprintf(out, "define %s %s %s ", ll_get_linkage_string(function->linkage),
           function->calling_convention, function->return_type->str);
-  fprintf(out, "@%s%s(", no_return?"__no_return_":"",
-          function->name);
+  fprintf(out, "@%s%s(", prefix, function->name);
   for (i = 0; i < function->num_args; i++) {
     fputs(function->arguments[i]->type_struct->str, out);
 
@@ -2159,7 +2160,7 @@ ll_write_global_objects(FILE *out, LLVMModuleRef module)
 }
 
 void
-ll_write_module(FILE *out, LL_Module *module, int generate_no_return_variants)
+ll_write_module(FILE *out, LL_Module *module, int generate_no_return_variants, const char *no_return_prefix)
 {
   int i, j, met_idx;
   LL_Function *function = module->first;
@@ -2274,9 +2275,9 @@ ll_write_module(FILE *out, LL_Module *module, int generate_no_return_variants)
   }
   num_functions = 0;
   while (function) {
-    ll_write_function(out, function, module, 0);
+    ll_write_function(out, function, module, false, "");
     if (generate_no_return_variants) {
-      ll_write_function(out, function, module, 1);
+      ll_write_function(out, function, module, true, no_return_prefix);
     }
     function = function->next;
     num_functions++;
diff --git a/tools/flang2/flang2exe/ll_write.h b/tools/flang2/flang2exe/ll_write.h
@@ -30,8 +30,8 @@ void ll_write_basicblock(FILE *out, LL_Function *function, LL_BasicBlock *block,
 /**
    \brief ...
  */
-void ll_write_function(FILE *out, LL_Function *function, LL_Module *module,
-                       int no_return);
+void ll_write_function(FILE *out, LL_Function *function, LL_Module *module, 
+                       bool no_return, const char *prefix);
 
 /**
    \brief ...
@@ -72,7 +72,8 @@ void ll_write_metadata(FILE *out, LLVMModuleRef module);
 /**
    \brief ...
  */
-void ll_write_module(FILE *out, LL_Module *module, int no_return);
+void ll_write_module(FILE *out, LL_Module *module, int no_return,
+                     const char *no_return_prefix);
 
 /**
    \brief ...

Original file line number	Diff line number	Diff line change
`@@ -308,7 +308,7 @@ static void`
`308`	`308`	`convert_omp_workshare(void)`
`309`	`309`	`{`
`310`	`310`	`int std;`
`311`		`- int newstd;`
	`311`	`+ int newstd = 0;`
`312`	`312`	`int ast;`
`313`	`313`	`int lsptr;`
`314`	`314`	`int prevast;`
`@@ -508,7 +508,8 @@ convert_omp_workshare(void)`
`508`	`508`	`}`
`509`	`509`	`break;`
`510`	`510`	`}`
`511`		`- STD_PAR(newstd) = 1;`
	`511`	`+ if (newstd)`
	`512`	`+ STD_PAR(newstd) = 1;`
`512`	`513`
`513`	`514`	`break;`
`514`	`515`	`case IN_CRITICAL:`