In C/C++ dataflow we reuse some dataflow nodes that we know are sementically equivalent to gain a small amount of performance, and to make it easier to select the right dataflow node in sources, sinks, barriers, etc. For example, consider the following snippet of IR:

r1(glval<char **>) = VariableAddress[a]          :
r2(char **)        = Load[a]                     : &:r1, m1
r3(glval<char *>)  = CopyValue                   : r2

For dataflow we have a node that represents &:r1 (i.e, the value of type char***), as well as nodes for the possible indirections of &:r1: *&:r1 (i.e., the value of type char**), **&:r1 (i.e, the value of type char*), and ***&:r1 (i.e., the value of type char).

Similarly, we have a node that represents the r2 operand (i.e., the value of type char**), as well as nodes for the possible indirections of r2: *r2 (i.e., the value of type char*), and **r2 (i.e., the value of type char).

However, some of these nodes represent the semantically same value. For example, both *&:r1 and r2 represent the char** value (i.e., the value you get when you dereference VariableAddress[a]).

The getIRRepresentationOfIndirectOperand and getIRRepresentationOfIndirectInstruction predicates are used to identify such semantically identical representations.

Currently, however, getIRRepresentationOfIndirectOperand and getIRRepresentationOfIndirectInstruction only identified that *&:r1 and r2 represented the same value. But **&:r1 and *r2, and ***&:r1 and **r2 also represent the same values. This PR extends those predicates to identify these cases.

This should (hopefully) give us a small speedup, a reduced memory footprint, and possible even remove some FPs in queries in cases where we selected a equivalent (but until now not identical!) node to the one on the actual dataflow path.