292   // Represents a divergent construct in the SPIR-V sense.
294   // and possibly a continue block (back-edge). A construct can contain other
305   // An helper class to clean the construct boundaries.
307   // divergent construct, and possibly modify CFG edges when exits would cross
322     // Returns the list of blocks that belong to a SPIR-V loop construct,
323     // including the continue construct.
339     // Returns the list of blocks that belong to a SPIR-V selection construct.
365     // Returns the list of blocks that belong to a SPIR-V switch construct.
385     // Returns the list of blocks that belong to a SPIR-V case construct.
397         // construct’s corresponding merge block.  in getCaseConstructBlocks()
412     // Given nodes A and B in the construct, a node C outside, and the following edges.
416 …// In such cases, we must create a new exit node D, that belong to the construct to make is viable:
425     // A, B, D belongs to the construct. D is the exit. D1 and D2 are empty.
460     // Given a construct defined by |Header|, and a list of exiting edges
765   // Gather all the exit nodes for the construct header by |Header| and
766   // containing the blocks |Construct|.
767   std::vector<Edge> getExitsFrom(const BlockSet &Construct,  in getExitsFrom()  argument
771       if (Construct.count(Item) == 0)  in getExitsFrom()
775         if (Construct.count(Successor) == 0)  in getExitsFrom()
784   // Build a divergent construct tree searching from |BB|.
822   // Returns the blocks belonging to the divergent construct |Node|.
835   // Fixup the construct |Node| to respect a set of rules defined by the SPIR-V
842     // This construct is the root construct. Does not represent any real  in fixupConstruct()
843     // construct, just a way to access the first level of the forest.  in fixupConstruct()
847     // This node's parent is the root. Meaning this is a top-level construct.  in fixupConstruct()
849     // construct since we are at first level.  in fixupConstruct()
860     //  No edges exiting the construct.  in fixupConstruct()
868       // - Breaking from a selection construct: S is a selection construct, S is  in fixupConstruct()
870       //   control-flow construct containing A, and B is the merge block for S  in fixupConstruct()
871       // - Breaking from the innermost loop: S is the innermost loop construct  in fixupConstruct()
877       // Entering the innermost loop’s continue construct: S is the innermost  in fixupConstruct()
878       // loop construct containing A, and B is the continue target for S  in fixupConstruct()
893     // Fixup this construct's merge node to point to the new exit.  in fixupConstruct()
894     // Note: this algorithm fixes inner-most divergence construct first. So  in fixupConstruct()
1138     // Sort selection merge, the largest construct goes first.  in runOnFunction()
1150     // the header, and add headers to divergent construct with no headers.  in runOnFunction()
1153     // STEP 6: At this stage, we have several divergent construct defines by a  in runOnFunction()
1155     // construct exit could be outside of the parents' construct exit. Such  in runOnFunction()
1157     // into several parts. Each part exiting the parent's construct by its merge  in runOnFunction()
1163     // divergent construct tree. Some nodes are still requires (e.g: nodes  in runOnFunction()
1166     // issues. E.g: the SPIR-V spec allows a construct to break to the parents  in runOnFunction()
1167     // loop construct without an OpSelectionMerge, but this requires a straight  in runOnFunction()