[LLVM] Add option to store Parent-pointer in ilist_node_base

[SLTozer]

This patch adds a new option for ilist that enables storing an additional pointer in the ilist_node_base type to a specified "parent" type, and uses that option for Instruction.

This is not technically related to the ilist_node_with_parent class; that class has no data, but relies on a getParent method being defined in its subclass to modify how it interacts with the ilist API; this change adds extra data to each node in the ilist. Key to this is that ilist_node_with_parent is inherited by the node class, i.e. Instruction, and is not observed by the ilist itself; the ilist_node_parent option is necessarily declared as part of the ilist, which itself will contain an extra field as a result. We want to keep these separate, because the ilist_node_with_parent is currently used by several classes that don't want the ilist_node_parent-list behaviour.

Currently, we can use BasicBlock::iterator to insert instructions, except when either the iterator is invalid (NodePtr=0x0), or when the iterator points to a sentinel value (BasicBlock::end()). The former can be easily verified from the iterator object itself, but the latter is currently not detectable (as we do not enable explicit sentinel tracking), and even if we know it we have no clean way to get the correct BasicBlock* value from the sentinel node (technically it should exist at a fixed offset from the start of the owning BasicBlock object, but using that fact is tricky without reinterpret_cast and funky pointer arithmetic). Moving the BasicBlock *Parent field from Instruction to ilist_node_base means that we can fetch the owning BB from the end() iterator, which allows us to use iterators for all insertions, without needing to store or pass an extra BasicBlock *BB argument alongside it.

The motivation for this is to move smoothly towards the proposed rewrite of the instruction insertion interface, which itself is needed to reduce the potential for errors to sneak in to the compiler from the use of insertion patterns that behave incorrectly with respect to debug records. This also allows us to greatly deduplicate the code for creating new instructions; in a followup commit here, this behaviour is used to define a simple InsertPosition class that replaces the "insertBefore/insertAtEnd" arguments for all instruction creation/constructor methods, resulting in a significant reduction in the size of that file with essentially neutral performance impact.