From 099d76cf159a07d35cfb80b79c34127bf2377a0e Mon Sep 17 00:00:00 2001 From: Nate Begeman Date: Mon, 16 Jan 2006 07:54:23 +0000 Subject: Fix up 'adding an intrinsic' section a bit, first draft of 'adding a new sdnode' section. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25354 91177308-0d34-0410-b5e6-96231b3b80d8 --- docs/ExtendingLLVM.html | 147 ++++++++++++++++++++++++++++++++++++------------ 1 file changed, 111 insertions(+), 36 deletions(-) (limited to 'docs/ExtendingLLVM.html') diff --git a/docs/ExtendingLLVM.html b/docs/ExtendingLLVM.html index dbfd4b8..b86d561 100644 --- a/docs/ExtendingLLVM.html +++ b/docs/ExtendingLLVM.html @@ -16,6 +16,7 @@
  • Introduction and Warning
  • Adding a new intrinsic function
  • Adding a new instruction
    • +
  • Adding a new SelectionDAG node
  • Adding a new type
    1. Adding a new fundamental type
      2. @@ -105,9 +106,8 @@ function and then be turned into an instruction if warranted.

      effects, add it to the list of intrinsics in the isInstructionTriviallyDead function. -
    2. Test your intrinsic
      3. - -
    3. llvm/test/Regression/*: add your test cases to the test suite
      4. +
    4. llvm/test/Regression/*: Add test cases for your test cases to the + test suite

    Once the intrinsic has been added to the system, you must add code generator @@ -116,48 +116,123 @@ support for it. Generally you must do the following steps:

    Add support to the C backend in lib/Target/CBackend/
    -
    Depending on the intrinsic, there are a few ways to implement this. First, -if it makes sense to lower the intrinsic to an expanded sequence of C code in -all cases, just emit the expansion in visitCallInst. Second, if the -intrinsic has some way to express it with GCC (or any other compiler) -extensions, it can be conditionally supported based on the compiler compiling -the CBE output (see llvm.prefetch for an example). Third, if the intrinsic -really has no way to be lowered, just have the code generator emit code that -prints an error message and calls abort if executed. +
    Depending on the intrinsic, there are a few ways to implement this. For +most intrinsics, it makes sense to add code to lower your intrinsic in +LowerIntrinsicCall in lib/CodeGen/IntrinsicLowering.cpp. +Second, if it makes sense to lower the intrinsic to an expanded sequence of C +code in all cases, just emit the expansion in visitCallInst in +Writer.cpp. If the intrinsic has some way to express it with GCC +(or any other compiler) extensions, it can be conditionally supported based on +the compiler compiling the CBE output (see llvm.prefetch for an example). +Third, if the intrinsic really has no way to be lowered, just have the code +generator emit code that prints an error message and calls abort if executed.
    -
    Add a enum value for the SelectionDAG node in -include/llvm/CodeGen/SelectionDAGNodes.h
    - -
    Also, add code to lib/CodeGen/SelectionDAG/SelectionDAG.cpp (and -SelectionDAGPrinter.cpp) to print the node.
    +
    +
    Add support to the SelectionDAG Instruction Selector in +lib/CodeGen/SelectionDAG/
    -
    Add code to SelectionDAG/SelectionDAGISel.cpp to recognize the -intrinsic.
    +
    Since most targets in LLVM use the SelectionDAG framework for generating +code, you will likely need to add support for your intrinsic there as well. +This is usually accomplished by adding a new node, and then teaching the +SelectionDAG code how to handle that node. To do this, follow the steps in +the next section, Adding a new SelectionDAG node.
    -
    Presumably the intrinsic should be recognized and turned into the node you -added above.
    +
    +
    Once you have added the new node, add code to +SelectionDAG/SelectionDAGISel.cpp to recognize the intrinsic. In most +cases, the intrinsic will just be turned into the node you just added. For an +example of this, see how visitIntrinsicCall handles Intrinsic::ctpop +
    -
    Add code to SelectionDAG/LegalizeDAG.cpp to legalize, promote, and -expand the node as necessary.
    + -
    If the intrinsic can be expanded to primitive operations, legalize can break -the node down into other elementary operations that are be supported.
    + +
    + Adding a new SelectionDAG node +
    + -
    Add target-specific support to specific code generators.
    +
    -
    Extend the code generators you are interested in to recognize and support -the node, emitting the code you want.
    -
    +

    As with intrinsics, adding a new SelectionDAG node to LLVM is much easier +than adding a new instruction. New nodes are often added to help represent +instructions common to many targets. These nodes often map to an LLVM +instruction (add, sub) or intrinsic (byteswap, population count). In other +cases, new nodes have been added to allow many targets to perform a common task +(converting between floating point and integer representation) or capture more +complicated behavior in a single node (rotate).

    -

    -Unfortunately, the process of extending the code generator to support a new node -is not extremely well documented. As such, it is often helpful to look at other -intrinsics (e.g. llvm.ctpop) to see how they are recognized and turned -into a node by SelectionDAGISel.cpp, legalized by -LegalizeDAG.cpp, then finally emitted by the various code generators. -

    +
      +
    1. include/llvm/CodeGen/SelectionDAGNodes.h: + Add an enum value for the new SelectionDAG node.
      2. +
    2. lib/CodeGen/SelectionDAG/SelectionDAG.cpp: + Add code to print the node to getOperationName. If your new node + can be evaluated at compile time when given constant arguments (such as an + add of a constant with another constant), find the getNode method + that takes the appropriate number of arguments, and add a case for your node + to the switch statement that performs constant folding for nodes that take + the same number of arguments as your new node.
      3. +
    3. lib/CodeGen/SelectionDAG/LegalizeDAG.cpp: + Add code to legalize, + promote, and expand the node as necessary. At a minimum, you will need + to add a case statement for your node in LegalizeOp which calls + LegalizeOp on the node's operands, and returns a new node if any of the + operands changed as a result of being legalized. It is likely that not all + targets supported by the SelectionDAG framework will natively support the + new node. In this case, you must also add code in your node's case + statement in LegalizeOp to Expand your node into simpler, legal + operations. The case for ISD::UREM for expanding a remainder into a + multiply and a subtract is a good example.
      4. +
    4. lib/CodeGen/SelectionDAG/LegalizeDAG.cpp: + If targets may support the new node being added only at certain sizes, you + will also need to add code to your node's case statement in + LegalizeOp to Promote your node's operands to a larger size, and + perform the correct operation. You will also need to add code to + PromoteOp to do this as well. For a good example, see ISD::BSWAP, + which promotes its operand to a wider size, performs the byteswap, and then + shifts the correct bytes right to emulate the narrower byteswap in the + wider type.
      5. +
    5. lib/CodeGen/SelectionDAG/LegalizeDAG.cpp: + Add a case for your node in ExpandOp to teach the legalizer how to + perform the action represented by the new node on a value that has been + split into high and low halves. This case will be used to support your + node with a 64 bit operand on a 32 bit target.
      6. +
    6. lib/CodeGen/SelectionDAG/DAGCombiner.cpp: + If your node can be combined with itself, or other existing nodes in a + peephole-like fashion, add a visit function for it, and call that function + from . There are several good examples for simple combines you + can do; visitFABS and visitSRL are good starting places. +
      7. +
    7. lib/Target/PowerPC/PPCISelLowering.cpp: + Each target has an implementation of the TargetLowering class, + usually in its own file (although some targets include it in the same + file as the DAGToDAGISel). The default behavior for a target is to + assume that your new node is legal for all types that are legal for + that target. If this target does not natively support your node, then + tell the target to either Promote it (if it is supported at a larger + type) or Expand it. This will cause the code you wrote in + LegalizeOp above to decompose your new node into other legal + nodes for this target.
      8. +
    8. lib/Target/TargetSelectionDAG.td: + Most current targets supported by LLVM generate code using the DAGToDAG + method, where SelectionDAG nodes are pattern matched to target-specific + nodes, which represent individual instructions. In order for the targets + to match an instruction to your new node, you must add a def for that node + to the list in this file, with the appropriate type constraints. Look at + add, bswap, and fadd for examples.
      9. +
    9. lib/Target/PowerPC/PPCInstrInfo.td: + Each target has a tablegen file that describes the target's instruction + set. For targets that use the DAGToDAG instruction selection framework, + add a pattern for your new node that uses one or more target nodes. + Documentation for this is a bit sparse right now, but there are several + decent examples. See the patterns for rotl in + PPCInstrInfo.td.
      10. +
    10. TODO: document complex patterns.
      11. +
    11. llvm/test/Regression/CodeGen/*: Add test cases for your new node + to the test suite. llvm/test/Regression/CodeGen/X86/bswap.ll is + a good example.
      12. +
    -- cgit v1.1