We consider a general program construction like
one sketched below:

  generic
  package G is
    procedure Test is
    begin              -- slocs below designated as
      if For_I1 then   -- "test_in_g"
        stmt_1_here;   -- "stmt1_in_g"
      else
        stmt_2_here;   -- "stmt2_in_g"
      end if;
    end;
  end;

  package Sensors is
     package I1 is new G (For_I1);
     package I2 is new G (For_I2);

     procedure Dispatch;
  end;

  package body Sensors is
    procedure Dispatch is
    begin             -- slocs below designated as
      if Do_I1 then  -- "test_in_dispatch"
         I1.Test;    -- "call1_in_dispatch"
      else
         I2.Test;    -- "call2_in_dispatch"
      end if;
    end;

    --  The generated code for this body includes the code for
    --  the generic instances, as two low level routines:
    --
    --  sensors__i1__test and sensors__i2__test.

  end;

For -S routine, special care needs to be observed regarding inlining.

WITHOUT inlining, we have machine code like:

  sensors__i1__test:  ## slocs referenced by machine instructions
    if for_i1:          -> test_in_g
    insns for stmt_1    -> stmt1_in_g
    else:
    insns for stmt_2    -> stmt2_in_g

  sensors__i2__test:
    if for_i1:          -> test_in_g
    insns for stmt_1    -> stmt1_in_g
    else:
    insns for stmt_2    -> stmt2_in_g

  sensors_dispatch
    test i1:             -> test_in_dispatch
    call sensors_i1_test -> call1_in_dispatch
    else:
    call sensors_i2_test -> call2_in_dispatch

WITH inlining, the same except for:

  sensors_dispatch
    test i1:                    -> test_in_dispatch
    insns for stmt_1            -> stmt1_in_g
    insns for stmt_2            -> stmt2_in_g
    [insns for arg setup]       -> call1_in_dispatch
    else:
    insns for stmt_1            -> stmt1_in_g
    insns for stmt_2            -> stmt2_in_g
    [insns for arg setup]       -> call2_in_dispatch

Whether instructions for the call statements and for other parts of the
inlined-instanciated code remain in each branch depends on the generic source
code structure and on how much optimization is performed. In general, the call
and the pieces corresponding to the other instances might for example entirely
disappear when the call arguments are constant. In this particular testcase,
the generic source code is structured to make sure that insns for both cases
remain in each inlined copy.

Note that in addition to having references to "g" slocs from
"sensors__dispatch", if all the calls are inlined, no code from the original
instance subpgrograms is executed at all any more.

In expectations, we distinguish four different cases:

-- /stmt1_in_g/ ...    (No separation tag, cflags irrelevant)

-- %cov: -S instance 
-- =/stmt1_in_g/ ...   (Separation on instance, cflags irrelevant)

-- %cov: -S routine %cargs: -O1, -gnatn
-- =/stmt1_in_g/ ...   (Separation on routine name, with inlining)

-- %cov: -S routine %cargs: !-gnatn
-- =/stmt1_in_g/ ...   (Separation on routine name, without inlining)

CB - testing for "C" temp unit, Both in range and out of range

