Henrik Olsson via llvm-dev
2020-Mar-25 11:01 UTC
[llvm-dev] Find uses of Metadata / DITypes
I'm looking for a way to efficiently traverse the Metadata structure in reverse, or otherwise find DITypes that refer to another DIType. As an example, say I have a DICompositeType describing a struct. Now I want to find other DITypes containing this type, e.g. a DIDerivedType describing its pointer type, or another struct containing this struct as one of its fields. Is this possible in LLVM today? Would it be unreasonable to save Metadata to Metadata uses, like what is done for Value to Value uses? Any help would be greatly appreciated, Henrik -------------- next part -------------- An HTML attachment was scrubbed... URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20200325/b1f3e905/attachment.html>
Adrian Prantl via llvm-dev
2020-Mar-25 17:10 UTC
[llvm-dev] Find uses of Metadata / DITypes
It might help if you could explain what you are *actually* trying to do, since there are often other solutions for the higher-level problem that fit better into the design and architecture. -- adrian> On Mar 25, 2020, at 4:01 AM, Henrik Olsson via llvm-dev <llvm-dev at lists.llvm.org> wrote: > > I'm looking for a way to efficiently traverse the Metadata structure in reverse, or otherwise find DITypes that refer to another DIType. As an example, say I have a DICompositeType describing a struct. Now I want to find other DITypes containing this type, e.g. a DIDerivedType describing its pointer type, or another struct containing this struct as one of its fields. Is this possible in LLVM today? Would it be unreasonable to save Metadata to Metadata uses, like what is done for Value to Value uses? > > Any help would be greatly appreciated, > Henrik > _______________________________________________ > LLVM Developers mailing list > llvm-dev at lists.llvm.org > https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-dev
Henrik Olsson via llvm-dev
2020-Mar-25 17:49 UTC
[llvm-dev] Find uses of Metadata / DITypes
Ah yes, of course! For our thesis we're trying to reconstruct Value names from the IR to C syntax, to help with clarity in optimisation remarks. To do this for something like a GetElementPointer we first have to find the name of the pointer operand, and then we try to name the offsets. Naming array offsets is relatively straightforward, but for structs we need the DICompositeType which contains the struct field names. So we make the recursive call to name the pointer operand also return the operand's DIType, and from this we get the base type of the pointer. However we're struggling with handling bitcasts properly at the moment. When the pointer operand of a GEP is a bitcast, say from a struct pointer type to a pointer to the struct's first field we can figure that out by diffing the Value types and then traversing the DIType accordingly. When the cast is from smaller to wider type, on the other hand, we cannot just traverse the DIType structure to the wider type as the link is only in one direction. We recognise that there may be several potential wider types matching the Value type, but this is a best effort matching. We have discussed traversing all the DITypes in the module to find uses of the smaller type, and we have also thought about making changes to clang to emit debug variable intrinsics for bitcasts so we can find the correct DIType from the bitcast instruction itself. We're not sure how feasible these are in the grander scheme of things. Would emitting debug variable intrinsics for all bitcasts have a semantics mismatch in later passes when DWARF data is generated? Is it feasible to traverse all of the DITypes without damaging performance too much? Would saving the uses in the reverse direction like for Values have too large of a memory footprint? Obviously we'll make the changes we need to make things work for our thesis, but if possible we would like to not make changes that are invasive enough that it's unmergeable back into mainline LLVM. /Henrik On Wed, 25 Mar 2020, 18:10 Adrian Prantl, <aprantl at apple.com> wrote:> It might help if you could explain what you are *actually* trying to do, > since there are often other solutions for the higher-level problem that fit > better into the design and architecture. > > -- adrian > > > On Mar 25, 2020, at 4:01 AM, Henrik Olsson via llvm-dev < > llvm-dev at lists.llvm.org> wrote: > > > > I'm looking for a way to efficiently traverse the Metadata structure in > reverse, or otherwise find DITypes that refer to another DIType. As an > example, say I have a DICompositeType describing a struct. Now I want to > find other DITypes containing this type, e.g. a DIDerivedType describing > its pointer type, or another struct containing this struct as one of its > fields. Is this possible in LLVM today? Would it be unreasonable to save > Metadata to Metadata uses, like what is done for Value to Value uses? > > > > Any help would be greatly appreciated, > > Henrik > > _______________________________________________ > > LLVM Developers mailing list > > llvm-dev at lists.llvm.org > > https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-dev > >-------------- next part -------------- An HTML attachment was scrubbed... URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20200325/341a5de6/attachment.html>