RPCS3/glslang
1
0
Fork 0
mirror of https://github.com/RPCS3/glslang.git synced 2024-12-19 09:16:32 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
5d610ee1dc
glslang/Test/baseResults/precise.tesc.out

397 lines
15 KiB
Plaintext
Raw Normal View History

Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
precise.tesc
Shader version: 450
Requested GL_EXT_gpu_shader5
Requested GL_EXT_shader_io_blocks
Requested GL_EXT_tessellation_shader
vertices = -1
0:? Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:5 Function Definition: minimal( ( global float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:5 Function Parameters:
0:6 Sequence
0:6 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:6 move second child to first child ( temp float)
0:6 'result' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:6 Constant:
0:6 5.000000
0:7 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:7 move second child to first child ( temp float)
0:7 'a' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:7 Constant:
0:7 10.000000
0:8 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:8 move second child to first child ( temp float)
0:8 'b' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:8 Constant:
0:8 20.000000
0:9 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:9 move second child to first child ( temp float)
0:9 'c' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:9 Constant:
0:9 30.000000
0:10 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:10 move second child to first child ( temp float)
0:10 'd' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:10 Constant:
0:10 40.000000
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:11 move second child to first child ( temp float)
0:11 'result' ( noContraction temp float)
0:11 add ( noContraction temp float)
0:11 component-wise multiply ( noContraction temp float)
0:11 'a' ( noContraction temp float)
0:11 'b' ( noContraction temp float)
0:11 component-wise multiply ( noContraction temp float)
0:11 'c' ( noContraction temp float)
0:11 'd' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:12 Branch: Return with expression
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:12 'result' ( noContraction temp float)
0:15 Function Definition: continuous_assignment( ( global void)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:15 Function Parameters:
0:16 Sequence
0:16 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:16 move second child to first child ( temp float)
0:16 'result' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:16 Constant:
0:16 5.000000
0:17 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:17 move second child to first child ( temp float)
0:17 'a' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:17 Constant:
integer type operation should not be noContraction
2016-05-07 01:52:28 +00:00
0:17 10.000000
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:18 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:18 move second child to first child ( temp float)
0:18 'b' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:18 Constant:
integer type operation should not be noContraction
2016-05-07 01:52:28 +00:00
0:18 20.000000
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:19 move second child to first child ( temp float)
0:19 'result' ( noContraction temp float)
0:19 move second child to first child ( temp float)
0:19 'a' ( noContraction temp float)
0:19 add ( noContraction temp float)
0:19 'b' ( noContraction temp float)
integer type operation should not be noContraction
2016-05-07 01:52:28 +00:00
0:19 Constant:
0:19 4.000000
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:22 Function Definition: convert( ( global void)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:22 Function Parameters:
0:? Sequence
0:24 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:24 move second child to first child ( temp float)
0:24 'a' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:24 Constant:
integer type operation should not be noContraction
2016-05-07 01:52:28 +00:00
0:24 10.000000
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:25 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:25 move second child to first child ( temp float)
0:25 'b' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:25 Constant:
integer type operation should not be noContraction
2016-05-07 01:52:28 +00:00
0:25 20.000000
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:26 move second child to first child ( temp float)
0:26 'b' ( noContraction temp float)
0:26 add ( noContraction temp float)
0:26 'a' ( noContraction temp float)
0:26 'b' ( noContraction temp float)
0:27 move second child to first child ( temp double)
0:27 'result' ( noContraction temp double)
0:27 Convert float to double ( temp double)
0:27 'b' ( noContraction temp float)
0:30 Function Definition: loop_for( ( global float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:30 Function Parameters:
0:31 Sequence
0:31 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:31 move second child to first child ( temp float)
0:31 'r1' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:31 Constant:
0:31 5.000000
0:32 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:32 move second child to first child ( temp float)
0:32 'r2' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:32 Constant:
0:32 10.000000
0:33 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:33 move second child to first child ( temp int)
0:33 'a' ( temp int)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:33 Constant:
0:33 10 (const int)
0:34 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:34 move second child to first child ( temp int)
0:34 'b' ( noContraction temp int)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:34 Constant:
0:34 20 (const int)
0:35 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:35 move second child to first child ( temp int)
0:35 'c' ( noContraction temp int)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:35 Constant:
0:35 30 (const int)
0:36 Sequence
0:36 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:36 move second child to first child ( temp int)
0:36 'i' ( noContraction temp int)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:36 Constant:
0:36 0 (const int)
0:36 Loop with condition tested first
0:36 Loop Condition
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:36 Compare Less Than ( temp bool)
0:36 'i' ( temp int)
0:36 'a' ( temp int)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:36 Loop Body
0:37 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:37 add second child into first child ( noContraction temp float)
0:37 'r1' ( noContraction temp float)
0:37 add ( noContraction temp float)
0:37 add ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:37 Constant:
0:37 3.120000
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:37 Convert int to float ( temp float)
0:37 'b' ( noContraction temp int)
0:37 Convert int to float ( temp float)
0:37 'i' ( noContraction temp int)
0:38 add second child into first child ( noContraction temp int)
0:38 'c' ( noContraction temp int)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:38 Constant:
0:38 1 (const int)
0:36 Loop Terminal Expression
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:36 Post-Increment ( noContraction temp int)
0:36 'i' ( noContraction temp int)
0:40 add second child into first child ( temp int)
0:40 'a' ( temp int)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:40 Constant:
0:40 1 (const int)
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:41 move second child to first child ( temp float)
0:41 'r2' ( noContraction temp float)
0:41 Convert int to float ( temp float)
0:41 'c' ( noContraction temp int)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:42 Branch: Return with expression
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:42 Construct float ( temp float)
0:42 add ( temp float)
0:42 'r1' ( noContraction temp float)
0:42 'r2' ( noContraction temp float)
0:45 Function Definition: loop_array( ( global void)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:45 Function Parameters:
integer type operation should not be noContraction
2016-05-07 01:52:28 +00:00
0:? Sequence
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:48 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:48 move second child to first child ( temp int)
0:48 'x' ( noContraction temp int)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:48 Constant:
0:48 22 (const int)
0:49 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:49 move second child to first child ( temp int)
0:49 'y' ( noContraction temp int)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:49 Constant:
0:49 33 (const int)
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:52 add second child into first child ( noContraction temp float)
0:52 'result' ( noContraction temp float)
0:52 add ( noContraction temp float)
0:52 Convert int to float ( temp float)
0:52 'x' ( noContraction temp int)
0:52 Convert int to float ( temp float)
0:52 'y' ( noContraction temp int)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:54 Sequence
0:54 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:54 move second child to first child ( temp int)
0:54 'i' ( temp int)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:54 Constant:
0:54 0 (const int)
0:54 Loop with condition tested first
0:54 Loop Condition
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:54 Compare Less Than ( temp bool)
0:54 'i' ( temp int)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:54 Constant:
0:54 3 (const int)
0:54 Loop Body
0:56 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:56 add second child into first child ( noContraction temp float)
0:56 'result' ( noContraction temp float)
0:56 add ( noContraction temp float)
0:56 indirect index ( noContraction temp float)
0:56 'a0' ( temp 3-element array of float)
0:56 'i' ( temp int)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:56 Constant:
integer type operation should not be noContraction
2016-05-07 01:52:28 +00:00
0:56 2.000000
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:58 move second child to first child ( temp float)
0:58 indirect index ( noContraction temp float)
0:58 'a0' ( noContraction temp 3-element array of float)
0:58 'i' ( temp int)
0:58 subtract ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:58 Constant:
integer type operation should not be noContraction
2016-05-07 01:52:28 +00:00
0:58 3.000000
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:58 Post-Increment ( noContraction temp float)
0:58 'result' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:54 Loop Terminal Expression
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:54 Pre-Increment ( temp int)
0:54 'i' ( temp int)
0:62 Function Definition: loop_while( ( global void)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:62 Function Parameters:
0:63 Sequence
0:63 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:63 move second child to first child ( temp float)
0:63 'result' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:63 Constant:
0:63 5.000000
0:64 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:64 move second child to first child ( temp int)
0:64 'a' ( noContraction temp int)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:64 Constant:
0:64 10 (const int)
0:65 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:65 move second child to first child ( temp int)
0:65 'b' ( noContraction temp int)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:65 Constant:
0:65 20 (const int)
0:66 Loop with condition tested first
0:66 Loop Condition
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:66 Compare Less Than ( temp bool)
0:66 'result' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:66 Constant:
0:66 10.000000
0:66 Loop Body
0:67 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:67 add second child into first child ( noContraction temp float)
0:67 'result' ( noContraction temp float)
0:67 add ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:67 Constant:
0:67 3.120000
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:67 Convert int to float ( temp float)
0:67 'b' ( noContraction temp int)
0:69 move second child to first child ( temp float)
0:69 'result' ( noContraction temp float)
0:69 Convert int to float ( temp float)
0:69 add ( temp int)
0:69 add ( temp int)
0:69 'a' ( noContraction temp int)
0:69 'b' ( noContraction temp int)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:69 Constant:
0:69 5 (const int)
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:70 move second child to first child ( temp float)
0:70 'result' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:70 Constant:
0:70 11.100000
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:73 Function Definition: fma_not_decorated( ( global float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:73 Function Parameters:
0:? Sequence
0:75 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:75 move second child to first child ( temp float)
0:75 'a' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:75 Constant:
0:75 1.000000
0:76 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:76 move second child to first child ( temp float)
0:76 'b' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:76 Constant:
0:76 2.000000
0:77 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:77 move second child to first child ( temp float)
0:77 'c' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:77 Constant:
0:77 3.000000
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:78 move second child to first child ( temp float)
0:78 'b' ( noContraction temp float)
0:78 add ( noContraction temp float)
0:78 'b' ( noContraction temp float)
0:78 'c' ( noContraction temp float)
0:79 move second child to first child ( temp float)
0:79 'result' ( noContraction temp float)
0:79 fma ( global float)
0:79 'a' ( noContraction temp float)
0:79 'b' ( noContraction temp float)
0:79 'c' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:80 Branch: Return with expression
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:80 'result' ( noContraction temp float)
0:83 Function Definition: precise_return_exp_func( ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:83 Function Parameters:
0:84 Sequence
0:84 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:84 move second child to first child ( temp float)
0:84 'a' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:84 Constant:
0:84 1.000000
0:85 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:85 move second child to first child ( temp float)
0:85 'b' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:85 Constant:
0:85 2.000000
0:86 Branch: Return with expression
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:86 add ( noContraction temp float)
0:86 'a' ( noContraction temp float)
0:86 'b' ( noContraction temp float)
0:89 Function Definition: precise_return_val_func( ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:89 Function Parameters:
0:90 Sequence
0:90 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:90 move second child to first child ( temp float)
0:90 'a' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:90 Constant:
0:90 1.000000
0:91 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:91 move second child to first child ( temp float)
0:91 'b' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:91 Constant:
0:91 2.000000
0:92 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:92 move second child to first child ( temp float)
0:92 'result' ( noContraction temp float)
0:92 add ( noContraction temp float)
0:92 'a' ( noContraction temp float)
0:92 'b' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:93 Branch: Return with expression
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:93 'result' ( noContraction temp float)
0:96 Function Definition: precise_func_parameter(f1;f1; ( global float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:96 Function Parameters:
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:96 'b' ( in float)
0:96 'c' ( noContraction out float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:97 Sequence
0:97 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:97 move second child to first child ( temp float)
0:97 'a' ( noContraction temp float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:97 Constant:
0:97 0.500000
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:98 move second child to first child ( temp float)
0:98 'c' ( noContraction out float)
0:98 add ( noContraction temp float)
0:98 'a' ( noContraction temp float)
0:98 'b' ( noContraction in float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:99 Branch: Return with expression
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:99 subtract ( temp float)
0:99 'a' ( temp float)
0:99 'b' ( in float)
0:102 Function Definition: matrix(mf23;mf32; ( global 3X3 matrix of float)
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:102 Function Parameters:
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:102 'a' ( in 2X3 matrix of float)
0:102 'b' ( in 3X2 matrix of float)
add a test for matrix, fix a variable name
2016-05-06 22:56:33 +00:00
0:103 Sequence
0:103 Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:103 move second child to first child ( temp 2X3 matrix of float)
0:103 'c' ( noContraction temp 2X3 matrix of float)
add a test for matrix, fix a variable name
2016-05-06 22:56:33 +00:00
0:103 Constant:
0:103 1.000000
0:103 2.000000
0:103 3.000000
0:103 4.000000
0:103 5.000000
0:103 6.000000
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:105 move second child to first child ( temp 3X3 matrix of float)
0:105 'result' ( noContraction temp 3X3 matrix of float)
0:105 matrix-multiply ( noContraction temp 3X3 matrix of float)
0:105 add ( noContraction temp 2X3 matrix of float)
0:105 'a' ( noContraction in 2X3 matrix of float)
0:105 'c' ( noContraction temp 2X3 matrix of float)
0:105 'b' ( noContraction in 3X2 matrix of float)
add a test for matrix, fix a variable name
2016-05-06 22:56:33 +00:00
0:106 Branch: Return with expression
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:106 'result' ( noContraction temp 3X3 matrix of float)
0:109 Function Definition: main( ( global void)
add a test for matrix, fix a variable name
2016-05-06 22:56:33 +00:00
0:109 Function Parameters:
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:? Linker Objects
Linked tessellation control stage:
ERROR: Linking tessellation control stage: At least one shader must specify an output layout(vertices=...)
Shader version: 450
Requested GL_EXT_gpu_shader5
Requested GL_EXT_shader_io_blocks
Requested GL_EXT_tessellation_shader
vertices = -1
0:? Sequence
GLSL output: Removed fixed-size buffer; fixes #769. Makes some white-space differences in most output, plus a few cases where more could have been put out but was cut short by the previous fix-sized buffer.
2017-03-15 01:43:13 +00:00
0:109 Function Definition: main( ( global void)
add a test for matrix, fix a variable name
2016-05-06 22:56:33 +00:00
0:109 Function Parameters:
Precise and noContraction propagation Reimplement the whole workflow to make that: precise'ness of struct members won't spread to other non-precise members of the same struct instance. Approach: 1. Build the map from symbols to their defining nodes. And for each object node (StructIndex, DirectIndex, Symbol nodes, etc), generates an accesschain path. Different AST nodes that indicating a same object should have the same accesschain path. 2. Along the building phase in step 1, collect the initial set of 'precise' (AST qualifier: 'noContraction') objects' accesschain paths. 3. Start with the initial set of 'precise' accesschain paths, use it as a worklist, do as the following steps until the worklist is empty: 1) Pop an accesschain path from worklist. 2) Get the symbol part from the accesschain path. 3) Find the defining nodes of that symbol. 4) For each defining node, check whether it is defining a 'precise' object, or its assignee has nested 'precise' object. Get the incremental path from assignee to its nested 'precise' object (if any). 5) Traverse the right side of the defining node, obtain the accesschain paths of the corresponding involved 'precise' objects. Update the worklist with those new objects' accesschain paths. Label involved operations with 'noContraction'. In each step, whenever we find the parent object of an nested object is 'precise' (has 'noContraction' qualifier), we let the nested object inherit the 'precise'ness from its parent object.
2016-05-04 21:34:38 +00:00
0:? Linker Objects
Reference in New Issue Copy Permalink