CbC/CbC_llvm: llvm/lib/IR/AsmWriter.cpp comparison

comparison llvm/lib/IR/AsmWriter.cpp @ 174:f935e5e0dbe7

merged

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Mon, 25 May 2020 12:28:41 +0900
parents	e8a9b4f4d755 0572611fdcc8
children	dd44ba33042e

comparison

equal deleted inserted replaced

-:0d65220a63c8
+:f935e5e0dbe7
 if (LID <= ID)
 return LU->getOperandNo() < RU->getOperandNo();
 return LU->getOperandNo() > RU->getOperandNo();
 });
-if (std::is_sorted(
+if (llvm::is_sorted(List, [](const Entry &L, const Entry &R) {
-List.begin(), List.end(),
+return L.second < R.second;
-[](const Entry &L, const Entry &R) { return L.second < R.second; }))
+}))
 // Order is already correct.
 return;
 // Store the shuffle.
 Stack.emplace_back(V, F, List.size());
 static void PrintLLVMName(raw_ostream &OS, const Value *V) {
 PrintLLVMName(OS, V->getName(),
 isa<GlobalValue>(V) ? GlobalPrefix : LocalPrefix);
 }
+static void PrintShuffleMask(raw_ostream &Out, Type *Ty, ArrayRef<int> Mask) {
+Out << ", <";
+if (isa<ScalableVectorType>(Ty))
+Out << "vscale x ";
+Out << Mask.size() << " x i32> ";
+bool FirstElt = true;
+if (all_of(Mask, [](int Elt) { return Elt == 0; })) {
+Out << "zeroinitializer";
+} else if (all_of(Mask, [](int Elt) { return Elt == UndefMaskElem; })) {
+Out << "undef";
+} else {
+Out << "<";
+for (int Elt : Mask) {
+if (FirstElt)
+FirstElt = false;
+else
+Out << ", ";
+Out << "i32 ";
+if (Elt == UndefMaskElem)
+Out << "undef";
+else
+Out << Elt;
+}
+Out << ">";
+}
+}
 namespace {
 class TypePrinting {
 public:
 TypePrinting(const Module *M = nullptr) : DeferredM(M) {}
 case Type::VoidTyID:      OS << "void"; return;
 #ifndef noCbC
 case Type::__CodeTyID:      OS << "void"; return;
 #endif
 case Type::HalfTyID:      OS << "half"; return;
+case Type::BFloatTyID:    OS << "bfloat"; return;
 case Type::FloatTyID:     OS << "float"; return;
 case Type::DoubleTyID:    OS << "double"; return;
 case Type::X86_FP80TyID:  OS << "x86_fp80"; return;
 case Type::FP128TyID:     OS << "fp128"; return;
 case Type::PPC_FP128TyID: OS << "ppc_fp128"; return;
 OS << '[' << ATy->getNumElements() << " x ";
 print(ATy->getElementType(), OS);
 OS << ']';
 return;
 }
-case Type::VectorTyID: {
+case Type::FixedVectorTyID:
+case Type::ScalableVectorTyID: {
 VectorType *PTy = cast<VectorType>(Ty);
+ElementCount EC = PTy->getElementCount();
 OS << "<";
-if (PTy->isScalable())
+if (EC.Scalable)
 OS << "vscale x ";
-OS << PTy->getNumElements() << " x ";
+OS << EC.Min << " x ";
 print(PTy->getElementType(), OS);
 OS << '>';
 return;
 }
 }
 /// GUID map iterators.
 using guid_iterator = DenseMap<GlobalValue::GUID, unsigned>::iterator;
 /// These functions do the actual initialization.
 inline void initializeIfNeeded();
-void initializeIndexIfNeeded();
+int initializeIndexIfNeeded();
 // Implementation Details
 private:
 /// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
 void CreateModuleSlot(const GlobalValue *V);
 void CreateTypeIdSlot(StringRef Id);
 /// Add all of the module level global variables (and their initializers)
 /// and function declarations, but not the contents of those functions.
 void processModule();
-void processIndex();
+// Returns number of allocated slots
+int processIndex();
 /// Add all of the functions arguments, basic blocks, and instructions.
 void processFunction();
 /// Add the metadata directly attached to a GlobalObject.
 if (TheFunction && !FunctionProcessed)
 processFunction();
 }
-void SlotTracker::initializeIndexIfNeeded() {
+int SlotTracker::initializeIndexIfNeeded() {
 if (!TheIndex)
-return;
+return 0;
-processIndex();
+int NumSlots = processIndex();
 TheIndex = nullptr; ///< Prevent re-processing next time we're called.
+return NumSlots;
 }
 // Iterate through all the global variables, functions, and global
 // variable initializers and create slots for them.
 void SlotTracker::processModule() {
 ST_DEBUG("end processFunction!\n");
 }
 // Iterate through all the GUID in the index and create slots for them.
-void SlotTracker::processIndex() {
+int SlotTracker::processIndex() {
 ST_DEBUG("begin processIndex!\n");
 assert(TheIndex);
 // The first block of slots are just the module ids, which start at 0 and are
 // assigned consecutively. Since the StringMap iteration order isn't
 GUIDNext = ModulePathNext;
 for (auto &GlobalList : *TheIndex)
 CreateGUIDSlot(GlobalList.first);
+for (auto &TId : TheIndex->typeIdCompatibleVtableMap())
+CreateGUIDSlot(GlobalValue::getGUID(TId.first));
 // Start numbering the TypeIds after the GUIDs.
 TypeIdNext = GUIDNext;
 for (auto TidIter = TheIndex->typeIds().begin();
 TidIter != TheIndex->typeIds().end(); TidIter++)
 CreateTypeIdSlot(TidIter->second.first);
-for (auto &TId : TheIndex->typeIdCompatibleVtableMap())
-CreateGUIDSlot(GlobalValue::getGUID(TId.first));
 ST_DEBUG("end processIndex!\n");
+return TypeIdNext;
 }
 void SlotTracker::processGlobalObjectMetadata(const GlobalObject &GO) {
 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
 GO.getAllMetadata(MDs);
 &ignored);
 Out << format_hex(apf.bitcastToAPInt().getZExtValue(), 0, /*Upper=*/true);
 return;
 }
-// Either half, or some form of long double.
+// Either half, bfloat or some form of long double.
 // These appear as a magic letter identifying the type, then a
 // fixed number of hex digits.
 Out << "0x";
 APInt API = APF.bitcastToAPInt();
 if (&APF.getSemantics() == &APFloat::x87DoubleExtended()) {
 /*Upper=*/true);
 } else if (&APF.getSemantics() == &APFloat::IEEEhalf()) {
 Out << 'H';
 Out << format_hex_no_prefix(API.getZExtValue(), 4,
 /*Upper=*/true);
+} else if (&APF.getSemantics() == &APFloat::BFloat()) {
+Out << 'R';
+Out << format_hex_no_prefix(API.getZExtValue(), 4,
+/*Upper=*/true);
 } else
 llvm_unreachable("Unsupported floating point type");
 return;
 }
 Out << '>';
 return;
 }
 if (isa<ConstantVector>(CV) || isa<ConstantDataVector>(CV)) {
-Type *ETy = CV->getType()->getVectorElementType();
+auto *CVVTy = cast<VectorType>(CV->getType());
+Type *ETy = CVVTy->getElementType();
 Out << '<';
 TypePrinter.print(ETy, Out);
 Out << ' ';
 WriteAsOperandInternal(Out, CV->getAggregateElement(0U), &TypePrinter,
 Machine, Context);
-for (unsigned i = 1, e = CV->getType()->getVectorNumElements(); i != e;++i){
+for (unsigned i = 1, e = CVVTy->getNumElements(); i != e; ++i) {
 Out << ", ";
 TypePrinter.print(ETy, Out);
 Out << ' ';
 WriteAsOperandInternal(Out, CV->getAggregateElement(i), &TypePrinter,
 Machine, Context);
 if (CE->isCast()) {
 Out << " to ";
 TypePrinter.print(CE->getType(), Out);
 }
+if (CE->getOpcode() == Instruction::ShuffleVector)
+PrintShuffleMask(Out, CE->getType(), CE->getShuffleMask());
 Out << ')';
 return;
 }
 bool ShouldSkipEmpty = true);
 void printMetadata(StringRef Name, const Metadata *MD,
 bool ShouldSkipNull = true);
 template <class IntTy>
 void printInt(StringRef Name, IntTy Int, bool ShouldSkipZero = true);
+void printAPInt(StringRef Name, APInt Int, bool IsUnsigned,
+bool ShouldSkipZero);
 void printBool(StringRef Name, bool Value, Optional<bool> Default = None);
 void printDIFlags(StringRef Name, DINode::DIFlags Flags);
 void printDISPFlags(StringRef Name, DISubprogram::DISPFlags Flags);
 template <class IntTy, class Stringifier>
 void printDwarfEnum(StringRef Name, IntTy Value, Stringifier toString,
 void MDFieldPrinter::printInt(StringRef Name, IntTy Int, bool ShouldSkipZero) {
 if (ShouldSkipZero && !Int)
 return;
 Out << FS << Name << ": " << Int;
+}
+void MDFieldPrinter::printAPInt(StringRef Name, APInt Int, bool IsUnsigned,
+bool ShouldSkipZero) {
+if (ShouldSkipZero && Int.isNullValue())
+return;
+Out << FS << Name << ": ";
+Int.print(Out, !IsUnsigned);
 }
 void MDFieldPrinter::printBool(StringRef Name, bool Value,
 Optional<bool> Default) {
 if (Default && Value == *Default)
 static void writeDIEnumerator(raw_ostream &Out, const DIEnumerator *N,
 TypePrinting *, SlotTracker *, const Module *) {
 Out << "!DIEnumerator(";
 MDFieldPrinter Printer(Out);
 Printer.printString("name", N->getName(), /* ShouldSkipEmpty */ false);
-if (N->isUnsigned()) {
+Printer.printAPInt("value", N->getValue(), N->isUnsigned(),
-auto Value = static_cast<uint64_t>(N->getValue());
+/*ShouldSkipZero=*/false);
-Printer.printInt("value", Value, /* ShouldSkipZero */ false);
+if (N->isUnsigned())
 Printer.printBool("isUnsigned", true);
-} else {
-Printer.printInt("value", N->getValue(), /* ShouldSkipZero */ false);
-}
 Out << ")";
 }
 static void writeDIBasicType(raw_ostream &Out, const DIBasicType *N,
 TypePrinting *, SlotTracker *, const Module *) {
 dwarf::LanguageString);
 Printer.printMetadata("vtableHolder", N->getRawVTableHolder());
 Printer.printMetadata("templateParams", N->getRawTemplateParams());
 Printer.printString("identifier", N->getIdentifier());
 Printer.printMetadata("discriminator", N->getRawDiscriminator());
+Printer.printMetadata("dataLocation", N->getRawDataLocation());
 Out << ")";
 }
 static void writeDISubroutineType(raw_ostream &Out, const DISubroutineType *N,
 TypePrinting *TypePrinter,
 Printer.printBool("debugInfoForProfiling", N->getDebugInfoForProfiling(),
 false);
 Printer.printNameTableKind("nameTableKind", N->getNameTableKind());
 Printer.printBool("rangesBaseAddress", N->getRangesBaseAddress(), false);
 Printer.printString("sysroot", N->getSysRoot());
+Printer.printString("sdk", N->getSDK());
 Out << ")";
 }
 static void writeDISubprogram(raw_ostream &Out, const DISubprogram *N,
 TypePrinting *TypePrinter, SlotTracker *Machine,
 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
 Printer.printString("name", N->getName());
 Printer.printString("configMacros", N->getConfigurationMacros());
 Printer.printString("includePath", N->getIncludePath());
+Printer.printString("apinotes", N->getAPINotesFile());
+Printer.printMetadata("file", N->getRawFile());
+Printer.printInt("line", N->getLineNo());
 Out << ")";
 }
 static void writeDITemplateTypeParameter(raw_ostream &Out,
 const Module *Context) {
 Out << "!DITemplateTypeParameter(";
 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
 Printer.printString("name", N->getName());
 Printer.printMetadata("type", N->getRawType(), /* ShouldSkipNull */ false);
+Printer.printBool("defaulted", N->isDefault(), /* Default= */ false);
 Out << ")";
 }
 static void writeDITemplateValueParameter(raw_ostream &Out,
 const DITemplateValueParameter *N,
 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
 if (N->getTag() != dwarf::DW_TAG_template_value_parameter)
 Printer.printTag(N);
 Printer.printString("name", N->getName());
 Printer.printMetadata("type", N->getRawType());
+Printer.printBool("defaulted", N->isDefault(), /* Default= */ false);
 Printer.printMetadata("value", N->getValue(), /* ShouldSkipNull */ false);
 Out << ")";
 }
 static void writeDIGlobalVariable(raw_ostream &Out, const DIGlobalVariable *N,
 }
 }
 void AssemblyWriter::printModuleSummaryIndex() {
 assert(TheIndex);
-Machine.initializeIndexIfNeeded();
+int NumSlots = Machine.initializeIndexIfNeeded();
 Out << "\n";
 // Print module path entries. To print in order, add paths to a vector
 // indexed by module slot.
 Out << "^" << Machine.getGUIDSlot(GUID)
 << " = typeidCompatibleVTable: (name: \"" << TId.first << "\"";
 printTypeIdCompatibleVtableSummary(TId.second);
 Out << ") ; guid = " << GUID << "\n";
 }
+// Don't emit flags when it's not really needed (value is zero by default).
+if (TheIndex->getFlags())
+Out << "^" << NumSlots << " = flags: " << TheIndex->getFlags() << "\n";
 }
 static const char *
 getWholeProgDevirtResKindName(WholeProgramDevirtResolution::Kind K) {
 switch (K) {
 llvm_unreachable("invalid WholeProgramDevirtResolution::ByArg kind");
 }
 static const char *getTTResKindName(TypeTestResolution::Kind K) {
 switch (K) {
-case TypeTestResolution::Unknown:
-return "unknown";
 case TypeTestResolution::Unsat:
 return "unsat";
 case TypeTestResolution::ByteArray:
 return "byteArray";
 case TypeTestResolution::Inline:
 }
 }
 static void PrintDSOLocation(const GlobalValue &GV,
 formatted_raw_ostream &Out) {
-// GVs with local linkage or non default visibility are implicitly dso_local,
+if (GV.isDSOLocal() && !GV.isImplicitDSOLocal())
-// so we don't print it.
-bool Implicit = GV.hasLocalLinkage() ||
-(!GV.hasExternalWeakLinkage() && !GV.hasDefaultVisibility());
-if (GV.isDSOLocal() && !Implicit)
 Out << "dso_local ";
 }
 static void PrintDLLStorageClass(GlobalValue::DLLStorageClassTypes SCT,
 formatted_raw_ostream &Out) {
 if (CI->getCallingConv() != CallingConv::C) {
 Out << " ";
 PrintCallingConv(CI->getCallingConv(), Out);
 }
-Operand = CI->getCalledValue();
+Operand = CI->getCalledOperand();
 FunctionType *FTy = CI->getFunctionType();
 Type *RetTy = FTy->getReturnType();
 const AttributeList &PAL = CI->getAttributes();
 if (PAL.hasAttributes(AttributeList::ReturnIndex))
 if (PAL.hasAttributes(AttributeList::FunctionIndex))
 Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());
 writeOperandBundles(CI);
 } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
-Operand = II->getCalledValue();
+Operand = II->getCalledOperand();
 FunctionType *FTy = II->getFunctionType();
 Type *RetTy = FTy->getReturnType();
 const AttributeList &PAL = II->getAttributes();
 // Print the calling convention being used.
 Out << "\n          to ";
 writeOperand(II->getNormalDest(), true);
 Out << " unwind ";
 writeOperand(II->getUnwindDest(), true);
 } else if (const CallBrInst *CBI = dyn_cast<CallBrInst>(&I)) {
-Operand = CBI->getCalledValue();
+Operand = CBI->getCalledOperand();
 FunctionType *FTy = CBI->getFunctionType();
 Type *RetTy = FTy->getReturnType();
 const AttributeList &PAL = CBI->getAttributes();
 // Print the calling convention being used.
 } else if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I)) {
 writeAtomic(RMWI->getContext(), RMWI->getOrdering(),
 RMWI->getSyncScopeID());
 } else if (const FenceInst *FI = dyn_cast<FenceInst>(&I)) {
 writeAtomic(FI->getContext(), FI->getOrdering(), FI->getSyncScopeID());
+} else if (const ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(&I)) {
+PrintShuffleMask(Out, SVI->getType(), SVI->getShuffleMask());
 }
 // Print Metadata info.
 SmallVector<std::pair<unsigned, MDNode *>, 4> InstMD;
 I.getAllMetadata(InstMD);
 if (!Attr.isTypeAttribute()) {
 Out << Attr.getAsString(InAttrGroup);
 return;
 }
-assert(Attr.hasAttribute(Attribute::ByVal) && "unexpected type attr");
+assert((Attr.hasAttribute(Attribute::ByVal) ||
+Attr.hasAttribute(Attribute::Preallocated)) &&
-Out << "byval";
+"unexpected type attr");
+if (Attr.hasAttribute(Attribute::ByVal)) {
+Out << "byval";
+} else {
+Out << "preallocated";
+}
 if (Type *Ty = Attr.getValueAsType()) {
 Out << '(';
 TypePrinter.print(Ty, Out);
 Out << ')';
 }

Mercurial > hg > CbC > CbC_llvm

comparison llvm/lib/IR/AsmWriter.cpp @ 174:f935e5e0dbe7