Support “in” in node_complexity.

compiler/nutils.pas

@@ -717,28 +717,59 @@ implementation
     { at will, probably best mainly in terms of required memory      }
     { accesses                                                       }
     function node_complexity(p: tnode): cardinal;
+
+    {$ifdef x86}
+      function in_const_set_complexity(cs: tsetconstnode): cardinal;
+        var
+          i,maxranges,lastv: cardinal;
+        begin
+          { maxranges value should match the logic in nx86set.pas:tx86innode.pass_generate_code.analizeset. }
+          if is_smallset(cs.resultdef) then
+            maxranges:=3
+          else if cs_opt_size in current_settings.optimizerswitches then
+            maxranges:=8
+          else
+            maxranges:=5;
+
+          result:=0;
+          lastv:=High(lastv)-1;
+          for i:=tsetdef(cs.resultdef).setbase to tsetdef(cs.resultdef).setmax do
+            if i in cs.value_set^ then
+              begin
+                if i<>lastv+1 then
+                  begin
+                    inc(result);
+                    if result>maxranges then
+                      exit(3);
+                  end;
+                lastv:=i;
+              end;
+        end;
+    {$endif}
+
       var
-        correction: byte;
+        cv : cardinal;
 {$ifdef ARM}
         dummy : byte;
 {$endif ARM}
       begin
-        result := 0;
-        while assigned(p) do
+        cv := 0;
+        result := NODE_COMPLEXITY_INF; { For early exits by default. }
+        while assigned(p) and (cv<NODE_COMPLEXITY_INF) do { break = return cv, exit = return NODE_COMPLEXITY_INF. }
           begin
             case p.nodetype of
               { floating point constants usually need loading from memory }
               realconstn:
                 begin
-                  result:=2;
-                  exit;
+                  cv:=2;
+                  break;
                 end;
               temprefn:
                 begin
                   if (ttemprefnode(p).tempinfo^.typedef.needs_inittable) or
                     not(ti_may_be_in_reg in ttemprefnode(p).tempflags) then
-                    result := 1;
-                  exit;
+                    cv := 1;
+                  break;
                 end;
               rttin,
               setconstn,
@@ -751,39 +782,35 @@ implementation
               { still works with nodeinlining (JM)                         }
               loadparentfpn:
                 begin
-                  result := 1;
-                  exit;
+                  cv := 1;
+                  break;
                 end;
               loadn:
                 begin
                   if assigned(tloadnode(p).left) then
-                    inc(result,node_complexity(tloadnode(p).left));
+                    inc(cv,node_complexity(tloadnode(p).left));
                   { threadvars need a helper call }
                   if (tloadnode(p).symtableentry.typ=staticvarsym) and
                      (vo_is_thread_var in tstaticvarsym(tloadnode(p).symtableentry).varoptions) then
-                    inc(result,5)
+                    inc(cv,5)
                   else if not((tloadnode(p).symtableentry.typ in [staticvarsym,localvarsym,paravarsym,fieldvarsym]) and
                     (tabstractvarsym(tloadnode(p).symtableentry).varregable in [vr_intreg,vr_mmreg,vr_fpureg])) then
-                    inc(result);
+                    inc(cv);
                   if (tloadnode(p).symtableentry.typ=paravarsym) and
                      not(tabstractvarsym(tloadnode(p).symtableentry).varregable=vr_addr) and
                      tloadnode(p).is_addr_param_load then
-                    inc(result);
-                  if (result >= NODE_COMPLEXITY_INF) then
-                    result := NODE_COMPLEXITY_INF;
-                  exit;
+                    inc(cv);
+                  p := nil; { Check for NODE_COMPLEXITY_INF and return cv. }
                 end;
               subscriptn:
                 begin
                   if is_implicit_pointer_object_type(tunarynode(p).left.resultdef) or
                     is_bitpacked_access(p) then
-                    inc(result,2)
+                    inc(cv,2)
                   { non-packed, int. regable records cause no extra
                     overhead no overhead if the fields are aligned to register boundaries }
                   else if tstoreddef(p.resultdef).is_intregable and (tsubscriptnode(p).vs.fieldoffset mod sizeof(aint)<>0) then
-                    inc(result,1);
-                  if (result = NODE_COMPLEXITY_INF) then
-                    exit;
+                    inc(cv,1);
                   p := tunarynode(p).left;
                 end;
               blockn:
@@ -793,31 +820,15 @@ implementation
                   { call to decr? }
                   if is_managed_type(tunarynode(p).left.resultdef) and
                      assigned(tcallparanode(p).parasym) and (tcallparanode(p).parasym.varspez=vs_out) then
-                    begin
-                      result:=NODE_COMPLEXITY_INF;
-                      exit;
-                    end
-                  else
-                    begin
-                      inc(result);
-                      if (result = NODE_COMPLEXITY_INF) then
-                        exit;
-                      p := tunarynode(p).left;
-                    end;
-                end;
-              notn,
-              derefn :
-                begin
-                  inc(result);
-                  if (result = NODE_COMPLEXITY_INF) then
                     exit;
+                  inc(cv);
                   p := tunarynode(p).left;
                 end;
-              addrn:
+              notn,
+              derefn,
+              addrn :
                 begin
-                  inc(result);
-                  if (result = NODE_COMPLEXITY_INF) then
-                    exit;
+                  inc(cv);
                   p := tunarynode(p).left;
                 end;
               typeconvn:
@@ -825,75 +836,60 @@ implementation
                   { may be more complex in some cases }
                   if not(ttypeconvnode(p).retains_value_location) and
                     not((ttypeconvnode(p).convtype=tc_pointer_2_array) and (ttypeconvnode(p).left.expectloc in [LOC_CREGISTER,LOC_REGISTER,LOC_CONSTANT])) then
-                    inc(result);
-                  if result = NODE_COMPLEXITY_INF then
-                    exit;
+                    inc(cv);
                   p := tunarynode(p).left;
                 end;
-              vecn:
-                begin
-                  inc(result,node_complexity(tbinarynode(p).left));
-                  inc(result);
-                  if (result >= NODE_COMPLEXITY_INF) then
-                    begin
-                      result := NODE_COMPLEXITY_INF;
-                      exit;
-                    end;
-                  p := tbinarynode(p).right;
-                end;
               statementn:
                 begin
-                  inc(result,node_complexity(tbinarynode(p).left));
-                  if (result >= NODE_COMPLEXITY_INF) then
-                    begin
-                      result := NODE_COMPLEXITY_INF;
-                      exit;
-                    end;
+                  inc(cv,node_complexity(tbinarynode(p).left));
                   p := tbinarynode(p).right;
                 end;
-              addn,subn,orn,andn,xorn,muln,divn,modn,symdifn,
+              addn,subn,orn,andn,xorn,symdifn,
               shln,shrn,
               equaln,unequaln,gtn,gten,ltn,lten,
-              assignn,
-              slashn:
+              assignn,vecn:
+                begin
+                  inc(cv,node_complexity(tbinarynode(p).left)+1);
+                  p := tbinarynode(p).right;
+                end;
+              muln:
+                begin
+                  inc(cv,node_complexity(tbinarynode(p).left)+{$ifdef CPU64BITALU}4{$else}8{$endif});
+                  p := tbinarynode(p).right;
+                end;
+              divn,modn,slashn:
+                begin
+                  inc(cv,node_complexity(tbinarynode(p).left)+{$ifdef CPU64BITALU}10{$else}20{$endif});
+                  p := tbinarynode(p).right;
+                end;
+              inn:
                 begin
-{$ifdef CPU64BITALU}
-                  correction:=1;
-{$else CPU64BITALU}
-                  correction:=2;
-{$endif CPU64BITALU}
-                  inc(result,node_complexity(tbinarynode(p).left)+1*correction);
-                  if (p.nodetype in [divn,modn,slashn]) then
-                    inc(result,10*correction*correction)
-                  else if p.nodetype=muln then
-                    inc(result,4*correction*correction);
-                  if (result >= NODE_COMPLEXITY_INF) then
+                  inc(cv,node_complexity(tinnode(p).left));
+{$if declared(in_const_set_complexity)}
+                  if tinnode(p).right.nodetype=setconstn then
                     begin
-                      result := NODE_COMPLEXITY_INF;
-                      exit;
+                      inc(cv,in_const_set_complexity(tsetconstnode(tinnode(p).right)));
+                      break;
                     end;
+{$endif in_const_set_complexity}
+                  inc(cv,3);
                   p := tbinarynode(p).right;
                 end;
               ordconstn:
                 begin
 {$ifdef ARM}
                   if not(is_shifter_const(aint(tordconstnode(p).value.svalue),dummy)) then
-                    result:=2;
+                    cv:=2;
 {$endif ARM}
 {$ifdef RISCV}
                   if not(is_imm12(aint(tordconstnode(p).value.svalue))) then
-                    result:=2;
+                    cv:=2;
 {$endif RISCV}
-                  exit;
+                  break;
                 end;
               exitn:
                 begin
-                  inc(result,2);
-                  if (result >= NODE_COMPLEXITY_INF) then
-                    begin
-                      result := NODE_COMPLEXITY_INF;
-                      exit;
-                    end;
+                  inc(cv,2);
                   p:=texitnode(p).left;
                 end;
               tempcreaten,
@@ -901,7 +897,7 @@ implementation
               pointerconstn,
               nothingn,
               niln:
-                exit;
+                break;
               inlinen:
                 begin
                   { this code assumes that the inline node has   }
@@ -930,7 +926,7 @@ implementation
                     in_volatile_x,
                     in_prefetch_var:
                       begin
-                        inc(result);
+                        inc(cv);
                         p:=tunarynode(p).left;
                       end;
                     in_cos_real,
@@ -939,45 +935,30 @@ implementation
                     in_sqrt_real,
                     in_ln_real:
                       begin
-                        inc(result,15);
-                        if (result >= NODE_COMPLEXITY_INF) then
-                          begin
-                            result:=NODE_COMPLEXITY_INF;
-                            exit;
-                          end;
+                        inc(cv,15);
                         p:=tunarynode(p).left;
                       end;
                     in_sqr_real:
                       begin
-                        inc(result,2);
-                        if (result >= NODE_COMPLEXITY_INF) then
-                          begin
-                            result:=NODE_COMPLEXITY_INF;
-                            exit;
-                          end;
+                        inc(cv,2);
                         p:=tunarynode(p).left;
                       end;
                     in_abs_long:
                       begin
-                        inc(result,3);
-                        if (result >= NODE_COMPLEXITY_INF) then
-                          begin
-                            result:=NODE_COMPLEXITY_INF;
-                            exit;
-                          end;
+                        inc(cv,3);
                         p:=tunarynode(p).left;
                       end;
                     in_sizeof_x,
                     in_typeof_x:
                       begin
-                        inc(result);
+                        inc(cv);
                         if (tinlinenode(p).left.nodetype<>typen) then
                           { get instance vmt }
                           p:=tunarynode(p).left
                         else
                           { type vmt = global symbol, result is }
                           { already increased above             }
-                          exit;
+                          break;
                       end;
           {$ifdef SUPPORT_MMX}
                     in_mmx_pcmpeqb..in_mmx_pcmpgtw,
@@ -989,8 +970,8 @@ implementation
                     in_get_caller_frame,
                     in_get_caller_addr:
                       begin
-                        inc(result);
-                        exit;
+                        inc(cv);
+                        break;
                       end;
 
                     in_inc_x,
@@ -1000,33 +981,24 @@ implementation
                     in_assert_x_y :
                       begin
                         { operation (add, sub, or, and }
-                        inc(result);
+                        inc(cv);
                         { left expression }
-                        inc(result,node_complexity(tcallparanode(tunarynode(p).left).left));
-                        if (result >= NODE_COMPLEXITY_INF) then
-                          begin
-                            result := NODE_COMPLEXITY_INF;
-                            exit;
-                          end;
+                        inc(cv,node_complexity(tcallparanode(tunarynode(p).left).left));
                         p:=tcallparanode(tunarynode(p).left).right;
                         if assigned(p) then
                           p:=tcallparanode(p).left;
                       end;
                     else
-                      begin
-                        result := NODE_COMPLEXITY_INF;
-                        exit;
-                      end;
+                      exit;
                   end;
-
                 end;
               else
-                begin
-                  result := NODE_COMPLEXITY_INF;
-                  exit;
-                end;
+                exit;
             end;
         end;
+        if cv>NODE_COMPLEXITY_INF then
+          cv:=NODE_COMPLEXITY_INF;
+        result:=cv;
       end;