[llvm-dev] [RDF] Question about function argument registers on X86

[Constable, Scott D via llvm-dev]

Right! That really should have occurred to me ;). Thanks again.

Scott

From: Krzysztof Parzyszek <kparzysz at quicinc.com>
Sent: Monday, January 24, 2022 1:19 PM
To: Constable, Scott D <scott.d.constable at intel.com>
Cc: via llvm-dev <llvm-dev at lists.llvm.org>
Subject: RE: [RDF] Question about function argument registers on X86

The reason is that storing to EDI actually overwrites the upper 32 bits of RDI, so the EDI and RDI are considered identical in terms of register units.


--
Krzysztof Parzyszek  kparzysz at quicinc.com<mailto:kparzysz at quicinc.com>   AI tools development

From: Constable, Scott D <scott.d.constable at intel.com<mailto:scott.d.constable at intel.com>>
Sent: Monday, January 24, 2022 3:11 PM
To: Krzysztof Parzyszek <kparzysz at quicinc.com<mailto:kparzysz at quicinc.com>>
Cc: via llvm-dev <llvm-dev at lists.llvm.org<mailto:llvm-dev at lists.llvm.org>>
Subject: RE: [RDF] Question about function argument registers on X86


WARNING: This email originated from outside of Qualcomm. Please be wary of any links or attachments, and do not enable macros.
Thank you very much for the explanation, Krzysztof. There is still one part that I am missing. In the example below, RDF generates defs for DIL (bits 0:7 of RDI), DIH (bits 8:15 of RDI), and HDI (bits 16:31 of RDI). Hence bits 32:63 are unaccounted. Could this cause any issues? For example, suppose the program writes to RDI, and then clobbers EAX, but then the upper half of RDI is still defined.

Scott

From: Krzysztof Parzyszek <kparzysz at quicinc.com<mailto:kparzysz at quicinc.com>>
Sent: Monday, January 24, 2022 11:48 AM
To: Constable, Scott D <scott.d.constable at intel.com<mailto:scott.d.constable at intel.com>>
Cc: via llvm-dev <llvm-dev at lists.llvm.org<mailto:llvm-dev at lists.llvm.org>>
Subject: RE: [RDF] Question about function argument registers on X86

Hi Scott,

It used to be the case early on that we'd create an entry for the register as it was specified, but I've been running into all sorts of complications when calculating liveness.  Specifically, when defs/uses of "large" registers were intermingled with defs/uses of their sub-registers, various "interesting" scenarios showed up.  They had to do with representing unions/intersections of registers in terms of actual registers[1]---that was the reason for switching to tracking register units instead (see RegisterAggr class).
The consequence of that is that the graph looks more cluttered, but things are easier to express accurately.

[1] This was before lane masks became popular.  Say we have
AX = def
AH = clobber
Here AX is still "defined" since some part of it is defined.  Now, if we know that AX is "defined" then what can we say about it after executing "AL = clobber"?  Turns out that this is difficult to answer, because we'd have to know the history of how AX was modified, which isn't always analyzed in full: (RDF stop def traversal at a PHI node).


--
Krzysztof Parzyszek  kparzysz at quicinc.com<mailto:kparzysz at quicinc.com>   AI tools development

From: llvm-dev <llvm-dev-bounces at lists.llvm.org<mailto:llvm-dev-bounces at lists.llvm.org>> On Behalf Of Constable, Scott D via llvm-dev
Sent: Saturday, January 22, 2022 3:24 PM
To: llvm-dev at lists.llvm.org<mailto:llvm-dev at lists.llvm.org>
Subject: [llvm-dev] [RDF] Question about function argument registers on X86


WARNING: This email originated from outside of Qualcomm. Please be wary of any links or attachments, and do not enable macros.
Hi,

Given the function:

long simpleExample(long x) {
  return x;
}

RDF produces the following data-flow graph:

DFG dump:[
f1: Function: simpleExample
b2: --- %bb.0 --- preds(0):   succs(0):
p8: phi [+d9<DIH:0000000000000001>(,,u15"):]
p10: phi [+d11<DIL:0000000000000001>(,,u14"):]
p12: phi [+d13<HDI:0000000000000001>(,,u5"):]
s3: COPY [d4<RAX>(,,u7):, u5"<RDI>(+d13):, u14"<RDI>(+d11):, u15"<RDI>(+d9):]
s6: RET [u7<RAX>!(d4):]

]

Why is the argument in RDI split into three lanes that do not fully span RDI? It would seem more natural to just have a single phi for RDI.

I think the RDF code responsible for this behavior is located here: https://github.com/llvm/llvm-project/blob/55d887b833646baeea0e3371fd2cbbd7550a8d4d/llvm/lib/CodeGen/RDFGraph.cpp#L903, but I admit I do not fully understand what is going on.

Thanks in advance,

Scott Constable

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20220124/b08c00fb/attachment.html>