CbC/CbC_llvm: lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp comparison

comparison lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp @ 121:803732b1fca8

LLVM 5.0

author	kono
date	Fri, 27 Oct 2017 17:07:41 +0900
parents	1172e4bd9c6f
children	3a76565eade5

comparison

equal deleted inserted replaced

-:1172e4bd9c6f
+:803732b1fca8
-//===-- SelectionDAGDumper.cpp - Implement SelectionDAG::dump() -----------===//
+//===- SelectionDAGDumper.cpp - Implement SelectionDAG::dump() ------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 // This implements the SelectionDAG::dump method and friends.
 //
 //===----------------------------------------------------------------------===//
+#include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/APInt.h"
+#include "llvm/ADT/None.h"
+#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/CodeGen/ISDOpcodes.h"
+#include "llvm/CodeGen/MachineBasicBlock.h"
+#include "llvm/CodeGen/MachineConstantPool.h"
+#include "llvm/CodeGen/MachineMemOperand.h"
+#include "llvm/CodeGen/MachineValueType.h"
 #include "llvm/CodeGen/SelectionDAG.h"
-#include "ScheduleDAGSDNodes.h"
+#include "llvm/CodeGen/SelectionDAGNodes.h"
-#include "llvm/ADT/StringExtras.h"
+#include "llvm/CodeGen/ValueTypes.h"
-#include "llvm/CodeGen/MachineConstantPool.h"
+#include "llvm/IR/BasicBlock.h"
-#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/IR/Constants.h"
-#include "llvm/CodeGen/MachineModuleInfo.h"
+#include "llvm/IR/DebugInfoMetadata.h"
-#include "llvm/IR/DebugInfo.h"
+#include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Intrinsics.h"
+#include "llvm/IR/Value.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
-#include "llvm/Support/GraphWriter.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Printable.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetIntrinsicInfo.h"
+#include "llvm/Target/TargetLowering.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetRegisterInfo.h"
 #include "llvm/Target/TargetSubtargetInfo.h"
+#include <cstdint>
+#include <iterator>
 using namespace llvm;
 static cl::opt<bool>
 VerboseDAGDumping("dag-dump-verbose", cl::Hidden,
 cl::desc("Display more information when dumping selection "
 case ISD::UMAX:                       return "umax";
 case ISD::FPOWI:                      return "fpowi";
 case ISD::SETCC:                      return "setcc";
 case ISD::SETCCE:                     return "setcce";
+case ISD::SETCCCARRY:                 return "setcccarry";
 case ISD::SELECT:                     return "select";
 case ISD::VSELECT:                    return "vselect";
 case ISD::SELECT_CC:                  return "select_cc";
 case ISD::INSERT_VECTOR_ELT:          return "insert_vector_elt";
 case ISD::EXTRACT_VECTOR_ELT:         return "extract_vector_elt";
 case ISD::SCALAR_TO_VECTOR:           return "scalar_to_vector";
 case ISD::VECTOR_SHUFFLE:             return "vector_shuffle";
 case ISD::CARRY_FALSE:                return "carry_false";
 case ISD::ADDC:                       return "addc";
 case ISD::ADDE:                       return "adde";
+case ISD::ADDCARRY:                   return "addcarry";
 case ISD::SADDO:                      return "saddo";
 case ISD::UADDO:                      return "uaddo";
 case ISD::SSUBO:                      return "ssubo";
 case ISD::USUBO:                      return "usubo";
 case ISD::SMULO:                      return "smulo";
 case ISD::UMULO:                      return "umulo";
 case ISD::SUBC:                       return "subc";
 case ISD::SUBE:                       return "sube";
+case ISD::SUBCARRY:                   return "subcarry";
 case ISD::SHL_PARTS:                  return "shl_parts";
 case ISD::SRA_PARTS:                  return "sra_parts";
 case ISD::SRL_PARTS:                  return "srl_parts";
 // Conversion operators.
 case ISD::FP_TO_UINT:                 return "fp_to_uint";
 case ISD::BITCAST:                    return "bitcast";
 case ISD::ADDRSPACECAST:              return "addrspacecast";
 case ISD::FP16_TO_FP:                 return "fp16_to_fp";
 case ISD::FP_TO_FP16:                 return "fp_to_fp16";
-case ISD::CONVERT_RNDSAT: {
-switch (cast<CvtRndSatSDNode>(this)->getCvtCode()) {
-default: llvm_unreachable("Unknown cvt code!");
-case ISD::CVT_FF:                   return "cvt_ff";
-case ISD::CVT_FS:                   return "cvt_fs";
-case ISD::CVT_FU:                   return "cvt_fu";
-case ISD::CVT_SF:                   return "cvt_sf";
-case ISD::CVT_UF:                   return "cvt_uf";
-case ISD::CVT_SS:                   return "cvt_ss";
-case ISD::CVT_SU:                   return "cvt_su";
-case ISD::CVT_US:                   return "cvt_us";
-case ISD::CVT_UU:                   return "cvt_uu";
-}
-}
 // Control flow instructions
 case ISD::BR:                         return "br";
 case ISD::BRIND:                      return "brind";
 case ISD::BR_JT:                      return "br_jt";
 case ISD::GC_TRANSITION_START:        return "gc_transition.start";
 case ISD::GC_TRANSITION_END:          return "gc_transition.end";
 case ISD::GET_DYNAMIC_AREA_OFFSET:    return "get.dynamic.area.offset";
 // Bit manipulation
+case ISD::ABS:                        return "abs";
 case ISD::BITREVERSE:                 return "bitreverse";
 case ISD::BSWAP:                      return "bswap";
 case ISD::CTPOP:                      return "ctpop";
 case ISD::CTTZ:                       return "cttz";
 case ISD::CTTZ_ZERO_UNDEF:            return "cttz_zero_undef";
 case ISD::CTLZ:                       return "ctlz";
 case ISD::CTLZ_ZERO_UNDEF:            return "ctlz_zero_undef";
 // Trampolines
 case ISD::INIT_TRAMPOLINE:            return "init_trampoline";
 case ISD::ADJUST_TRAMPOLINE:          return "adjust_trampoline";
 case ISD::CONDCODE:
 case ISD::SETTRUE:                  return "settrue";
 case ISD::SETTRUE2:                 return "settrue2";
 case ISD::SETFALSE:                 return "setfalse";
 case ISD::SETFALSE2:                return "setfalse2";
 }
+case ISD::VECREDUCE_FADD:             return "vecreduce_fadd";
+case ISD::VECREDUCE_FMUL:             return "vecreduce_fmul";
+case ISD::VECREDUCE_ADD:              return "vecreduce_add";
+case ISD::VECREDUCE_MUL:              return "vecreduce_mul";
+case ISD::VECREDUCE_AND:              return "vecreduce_and";
+case ISD::VECREDUCE_OR:               return "vecreduce_or";
+case ISD::VECREDUCE_XOR:              return "vecreduce_xor";
+case ISD::VECREDUCE_SMAX:             return "vecreduce_smax";
+case ISD::VECREDUCE_SMIN:             return "vecreduce_smin";
+case ISD::VECREDUCE_UMAX:             return "vecreduce_umax";
+case ISD::VECREDUCE_UMIN:             return "vecreduce_umin";
+case ISD::VECREDUCE_FMAX:             return "vecreduce_fmax";
+case ISD::VECREDUCE_FMIN:             return "vecreduce_fmin";
 }
 }
 const char *SDNode::getIndexedModeName(ISD::MemIndexedMode AM) {
 switch (AM) {
 OS << (const void*)&Node;
 #endif
 });
 }
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void SDNode::dump() const { dump(nullptr); }
-void SDNode::dump(const SelectionDAG *G) const {
+LLVM_DUMP_METHOD void SDNode::dump(const SelectionDAG *G) const {
 print(dbgs(), G);
 dbgs() << '\n';
 }
+#endif
 void SDNode::print_types(raw_ostream &OS, const SelectionDAG *G) const {
 for (unsigned i = 0, e = getNumValues(); i != e; ++i) {
 if (i) OS << ",";
 if (getValueType(i) == MVT::Other)
 OS << getValueType(i).getEVTString();
 }
 }
 void SDNode::print_details(raw_ostream &OS, const SelectionDAG *G) const {
+if (getFlags().hasNoUnsignedWrap())
+OS << " nuw";
+if (getFlags().hasNoSignedWrap())
+OS << " nsw";
+if (getFlags().hasExact())
+OS << " exact";
+if (getFlags().hasUnsafeAlgebra())
+OS << " unsafe";
+if (getFlags().hasNoNaNs())
+OS << " nnan";
+if (getFlags().hasNoInfs())
+OS << " ninf";
+if (getFlags().hasNoSignedZeros())
+OS << " nsz";
+if (getFlags().hasAllowReciprocal())
+OS << " arcp";
+if (getFlags().hasAllowContract())
+OS << " contract";
+if (getFlags().hasVectorReduction())
+OS << " vector-reduction";
 if (const MachineSDNode *MN = dyn_cast<MachineSDNode>(this)) {
 if (!MN->memoperands_empty()) {
 OS << "<";
 OS << "Mem:";
 for (MachineSDNode::mmo_iterator i = MN->memoperands_begin(),
 }
 OS << ">";
 } else if (const ConstantSDNode *CSDN = dyn_cast<ConstantSDNode>(this)) {
 OS << '<' << CSDN->getAPIntValue() << '>';
 } else if (const ConstantFPSDNode *CSDN = dyn_cast<ConstantFPSDNode>(this)) {
-if (&CSDN->getValueAPF().getSemantics()==&APFloat::IEEEsingle)
+if (&CSDN->getValueAPF().getSemantics() == &APFloat::IEEEsingle())
 OS << '<' << CSDN->getValueAPF().convertToFloat() << '>';
-else if (&CSDN->getValueAPF().getSemantics()==&APFloat::IEEEdouble)
+else if (&CSDN->getValueAPF().getSemantics() == &APFloat::IEEEdouble())
 OS << '<' << CSDN->getValueAPF().convertToDouble() << '>';
 else {
 OS << "<APFloat(";
-CSDN->getValueAPF().bitcastToAPInt().dump();
+CSDN->getValueAPF().bitcastToAPInt().print(OS, false);
 OS << ")>";
 }
 } else if (const GlobalAddressSDNode *GADN =
 dyn_cast<GlobalAddressSDNode>(this)) {
 int64_t offset = GADN->getOffset();
 if (Node.getOpcode() == ISD::EntryToken)
 return false;
 return Node.getNumOperands() == 0;
 }
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 static void DumpNodes(const SDNode *N, unsigned indent, const SelectionDAG *G) {
 for (const SDValue &Op : N->op_values()) {
 if (shouldPrintInline(*Op.getNode()))
 continue;
 if (Op.getNode()->hasOneUse())
 }
 if (getRoot().getNode()) DumpNodes(getRoot().getNode(), 2, this);
 dbgs() << "\n\n";
 }
+#endif
 void SDNode::printr(raw_ostream &OS, const SelectionDAG *G) const {
 OS << PrintNodeId(*this) << ": ";
 print_types(OS, G);
 OS << " = " << getOperationName(G);
 OS << ':' << RN;
 return false;
 }
 }
-typedef SmallPtrSet<const SDNode *, 32> VisitedSDNodeSet;
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+using VisitedSDNodeSet = SmallPtrSet<const SDNode *, 32>;
 static void DumpNodesr(raw_ostream &OS, const SDNode *N, unsigned indent,
 const SelectionDAG *G, VisitedSDNodeSet &once) {
 if (!once.insert(N).second) // If we've been here before, return now.
 return;
 // Dump children that have grandchildren on their own line(s).
 for (const SDValue &Op : N->op_values())
 DumpNodesr(OS, Op.getNode(), indent+2, G, once);
 }
-void SDNode::dumpr() const {
+LLVM_DUMP_METHOD void SDNode::dumpr() const {
 VisitedSDNodeSet once;
 DumpNodesr(dbgs(), this, 0, nullptr, once);
 }
-void SDNode::dumpr(const SelectionDAG *G) const {
+LLVM_DUMP_METHOD void SDNode::dumpr(const SelectionDAG *G) const {
 VisitedSDNodeSet once;
 DumpNodesr(dbgs(), this, 0, G, once);
 }
+#endif
 static void printrWithDepthHelper(raw_ostream &OS, const SDNode *N,
 const SelectionDAG *G, unsigned depth,
 unsigned indent) {
 if (depth == 0)
 void SDNode::printrFull(raw_ostream &OS, const SelectionDAG *G) const {
 // Don't print impossibly deep things.
 printrWithDepth(OS, G, 10);
 }
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+LLVM_DUMP_METHOD
 void SDNode::dumprWithDepth(const SelectionDAG *G, unsigned depth) const {
 printrWithDepth(dbgs(), G, depth);
 }
-void SDNode::dumprFull(const SelectionDAG *G) const {
+LLVM_DUMP_METHOD void SDNode::dumprFull(const SelectionDAG *G) const {
 // Don't print impossibly deep things.
 dumprWithDepth(G, 10);
 }
+#endif
 void SDNode::print(raw_ostream &OS, const SelectionDAG *G) const {
 printr(OS, G);
 for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
 if (i) OS << ", "; else OS << " ";

Mercurial > hg > CbC > CbC_llvm

comparison lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp @ 121:803732b1fca8