Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", "{", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "switch", "(", "(", "unsigned", ")", "Kind", ")", "{", "case", "CAHP", "::", "fixup_cahp_hi6", ":", "{", "const", "static", "MCFixupKindInfo", "info", "{", "\"fixup_cahp_hi6\"", ",", "0", ",", "16", ",", "0", "}", ";", "return", "info", ";", "}", "case", "CAHP", "::", "fixup_cahp_lo10", ":", "{", "const", "static", "MCFixupKindInfo", "info", "{", "\"fixup_cahp_lo10\"", ",", "0", ",", "24", ",", "0", "}", ";", "return", "info", ";", "}", "case", "CAHP", "::", "fixup_cahp_pcrel_10", ":", "{", "const", "static", "MCFixupKindInfo", "info", "{", "\"fixup_cahp_pcrel_10\"", ",", "0", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ";", "return", "info", ";", "}", "case", "CAHP", "::", "fixup_cahp_pcrel_11", ":", "{", "const", "static", "MCFixupKindInfo", "info", "{", "\"fixup_cahp_pcrel_11\"", ",", "5", ",", "11", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ";", "return", "info", ";", "}", "default", ":", "llvm_unreachable", "(", "\"Invalid kind!\"", ")", ";", "}", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "CAHP", "CAHP::fixup_cahp_hi6", "\"fixup_cahp_hi6\"", "0", "16", "0", "CAHP::fixup_cahp_lo10", "\"fixup_cahp_lo10\"", "0", "24", "0", "CAHP::fixup_cahp_pcrel_10", "\"fixup_cahp_pcrel_10\"", "0", "24", "CAHP::fixup_cahp_pcrel_11", "\"fixup_cahp_pcrel_11\"", "5", "11", "\"Invalid kind!\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Patmos Assembly Printer\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "Patmos", "\"Patmos Assembly Printer\"" ]

[]

[ "<s>", "static", "MCSymbol", "*", "GetSymbolFromOperand", "(", "const", "MachineOperand", "&", "MO", ",", "AsmPrinter", "&", "AP", ")", "{", "MCContext", "&", "Ctx", "=", "AP", ".", "OutContext", ";", "SmallString", "<", "128", ">", "Name", ";", "if", "(", "!", "MO", ".", "isGlobal", "(", ")", ")", "{", "assert", "(", "MO", ".", "isSymbol", "(", ")", "&&", "\"Isn't a symbol reference\"", ")", ";", "Name", "+=", "AP", ".", "MAI", "->", "getGlobalPrefix", "(", ")", ";", "Name", "+=", "MO", ".", "getSymbolName", "(", ")", ";", "}", "else", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "bool", "isImplicitlyPrivate", "=", "false", ";", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "==", "PPCII", "::", "MO_DARWIN_STUB", "||", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_FLAG", ")", ")", "isImplicitlyPrivate", "=", "true", ";", "AP", ".", "Mang", "->", "getNameWithPrefix", "(", "Name", ",", "GV", ",", "isImplicitlyPrivate", ")", ";", "}", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "==", "PPCII", "::", "MO_DARWIN_STUB", ")", "{", "Name", "+=", "\"$stub\"", ";", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "GetOrCreateSymbol", "(", "Name", ".", "str", "(", ")", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "getMachOMMI", "(", "AP", ")", ".", "getFnStubEntry", "(", "Sym", ")", ";", "if", "(", "StubSym", ".", "getPointer", "(", ")", ")", "return", "Sym", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "AP", ".", "Mang", "->", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "!", "MO", ".", "getGlobal", "(", ")", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "else", "{", "Name", ".", "erase", "(", "Name", ".", "end", "(", ")", "-", "5", ",", "Name", ".", "end", "(", ")", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "Ctx", ".", "GetOrCreateSymbol", "(", "Name", ".", "str", "(", ")", ")", ",", "false", ")", ";", "}", "return", "Sym", ";", "}", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_FLAG", ")", "{", "Name", "+=", "\"$non_lazy_ptr\"", ";", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "GetOrCreateSymbol", "(", "Name", ".", "str", "(", ")", ")", ";", "MachineModuleInfoMachO", "&", "MachO", "=", "getMachOMMI", "(", "AP", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_HIDDEN_FLAG", ")", "?", "MachO", ".", "getHiddenGVStubEntry", "(", "Sym", ")", ":", "MachO", ".", "getGVStubEntry", "(", "Sym", ")", ";", "if", "(", "StubSym", ".", "getPointer", "(", ")", "==", "0", ")", "{", "assert", "(", "MO", ".", "isGlobal", "(", ")", "&&", "\"Extern symbol not handled yet\"", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "AP", ".", "Mang", "->", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "!", "MO", ".", "getGlobal", "(", ")", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "return", "Sym", ";", "}", "return", "Ctx", ".", "GetOrCreateSymbol", "(", "Name", ".", "str", "(", ")", ")", ";", "}", "</s>" ]

[ "Lower", "an", "MO_GlobalAddress", "or", "MO_ExternalSymbol", "operand", "to", "an", "MCSymbol", "." ]

[ "PowerPC", "128", "\"Isn't a symbol reference\"", "PPCII::MO_DARWIN_STUB", "PPCII::MO_NLP_FLAG", "PPCII::MO_DARWIN_STUB", "\"$stub\"", "5", "PPCII::MO_NLP_FLAG", "\"$non_lazy_ptr\"", "PPCII::MO_NLP_HIDDEN_FLAG", "0", "\"Extern symbol not handled yet\"" ]

[]

[ "<s>", "static", "void", "tilepro_asm_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk_fndecl", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "rtx", "this_rtx", ",", "funexp", ";", "rtx_insn", "*", "insn", ";", "reload_completed", "=", "1", ";", "emit_note", "(", "NOTE_INSN_PROLOGUE_END", ")", ";", "if", "(", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", ")", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "else", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "this_rtx", ",", "this_rtx", ",", "GEN_INT", "(", "delta", ")", ")", ")", ";", "if", "(", "vcall_offset", ")", "{", "rtx", "tmp", ";", "tmp", "=", "gen_rtx_REG", "(", "Pmode", ",", "29", ")", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "this_rtx", ")", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "tmp", ",", "tmp", ",", "GEN_INT", "(", "vcall_offset", ")", ")", ")", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "tmp", ")", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "this_rtx", ",", "this_rtx", ",", "tmp", ")", ")", ";", "}", "if", "(", "!", "TREE_USED", "(", "function", ")", ")", "{", "assemble_external", "(", "function", ")", ";", "TREE_USED", "(", "function", ")", "=", "1", ";", "}", "funexp", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "funexp", "=", "gen_rtx_MEM", "(", "FUNCTION_MODE", ",", "funexp", ")", ";", "insn", "=", "emit_call_insn", "(", "gen_sibcall", "(", "funexp", ",", "const0_rtx", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "get_insns", "(", ")", ";", "shorten_branches", "(", "insn", ")", ";", "final_start_function", "(", "insn", ",", "file", ",", "1", ")", ";", "final", "(", "insn", ",", "file", ",", "1", ")", ";", "final_end_function", "(", ")", ";", "reload_completed", "=", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_OUTPUT_MI_THUNK", "." ]

[ "tilepro", "1", "1", "0", "29", "1", "0", "1", "1", "1", "0" ]

[]

[ "<s>", "void", "TPCAsmParser", "::", "flushPendingInstructions", "(", "MCStreamer", "&", "Out", ")", "{", "if", "(", "CurrentSlot", "!=", "SlotParser", "::", "Unknown", ")", "outputBundle", "(", "Out", ",", "SMLoc", "(", ")", ",", "true", ")", ";", "AC", "->", "flushPendingInstructions", "(", "Out", ",", "getSTI", "(", ")", ")", ";", "if", "(", "TPCHeader", ")", "{", "Out", ".", "PushSection", "(", ")", ";", "MCSectionELF", "*", "MetadataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "BinaryTPCMetadataSectionName", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "MetadataSection", "->", "getFragmentList", "(", ")", ".", "clear", "(", ")", ";", "MCDataFragment", "*", "Fragment", "=", "new", "MCDataFragment", "(", "MetadataSection", ")", ";", "const", "TPCMetadataSection", "&", "Header", "=", "TPCHeader", ".", "getValue", "(", ")", ";", "std", "::", "vector", "<", "uint8_t", ">", "BinaryValue", "=", "bianrySerializeTPCProgramHeader", "(", "Header", ")", ";", "Fragment", "->", "getContents", "(", ")", ".", "append", "(", "BinaryValue", ".", "begin", "(", ")", ",", "BinaryValue", ".", "end", "(", ")", ")", ";", "Fragment", "->", "setAlignToBundleEnd", "(", "true", ")", ";", "Out", ".", "SwitchSection", "(", "MetadataSection", ")", ";", "Out", ".", "PopSection", "(", ")", ";", "}", "std", "::", "string", "RootFileName", "=", "getContext", "(", ")", ".", "getMainFileName", "(", ")", ";", "if", "(", "!", "RootFileName", ".", "empty", "(", ")", ")", "{", "Out", ".", "PushSection", "(", ")", ";", "MCSectionELF", "*", "KernelInfoSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "KernelInfoSectionName", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "KernelInfoSection", "->", "getFragmentList", "(", ")", ".", "clear", "(", ")", ";", "MCDataFragment", "*", "Fragment", "=", "new", "MCDataFragment", "(", "KernelInfoSection", ")", ";", "StringRef", "BareFileName", "=", "llvm", "::", "sys", "::", "path", "::", "stem", "(", "RootFileName", ")", ";", "std", "::", "string", "KernelInfo", "=", "GenerateKernelInfo", "(", "BareFileName", ")", ";", "Fragment", "->", "getContents", "(", ")", ".", "append", "(", "KernelInfo", ".", "begin", "(", ")", ",", "KernelInfo", ".", "end", "(", ")", ")", ";", "Fragment", "->", "setAlignToBundleEnd", "(", "true", ")", ";", "Out", ".", "SwitchSection", "(", "KernelInfoSection", ")", ";", "Out", ".", "PopSection", "(", ")", ";", "}", "if", "(", "IndexMap", ")", "{", "Out", ".", "PushSection", "(", ")", ";", "MCSectionELF", "*", "IndexMapSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "IndexMapSectionName", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "IndexMapSection", "->", "getFragmentList", "(", ")", ".", "clear", "(", ")", ";", "MCDataFragment", "*", "Fragment", "=", "new", "MCDataFragment", "(", "IndexMapSection", ")", ";", "Fragment", "->", "getContents", "(", ")", ".", "append", "(", "IndexMap", "->", "begin", "(", ")", ",", "IndexMap", "->", "end", "(", ")", ")", ";", "Fragment", "->", "setAlignToBundleEnd", "(", "true", ")", ";", "Out", ".", "SwitchSection", "(", "IndexMapSection", ")", ";", "Out", ".", "PopSection", "(", ")", ";", "}", "}", "</s>" ]

[ "Ensure", "that", "all", "previously", "parsed", "instructions", "have", "been", "emitted", "to", "the", "output", "streamer", ",", "if", "the", "target", "does", "not", "emit", "them", "immediately", "." ]

[ "TPC", "TPC", "TPC", "TPC", "TPC", "TPC", "TPC" ]

[]

[ "<s>", "static", "rtx", "riscv_unspec_offset_high", "(", "rtx", "temp", ",", "rtx", "addr", ",", "enum", "riscv_symbol_type", "symbol_type", ")", "{", "addr", "=", "gen_rtx_HIGH", "(", "Pmode", ",", "riscv_unspec_address", "(", "addr", ",", "symbol_type", ")", ")", ";", "return", "riscv_force_temporary", "(", "temp", ",", "addr", ")", ";", "}", "</s>" ]

[ "If", "riscv_unspec_address", "(", "ADDR", ",", "SYMBOL_TYPE", ")", "is", "a", "32-bit", "value", ",", "add", "the", "high", "part", "to", "BASE", "and", "return", "the", "result", ".", "Just", "return", "BASE", "otherwise", ".", "TEMP", "is", "as", "for", "riscv_force_temporary", ".", "The", "returned", "expression", "can", "be", "used", "as", "the", "first", "operand", "to", "a", "LO_SUM", "." ]

[ "riscv" ]

[]

[ "<s>", "unsigned", "MipsConstantIslands", "::", "getOffsetOf", "(", "MachineInstr", "*", "MI", ")", "const", "{", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "unsigned", "Offset", "=", "BBInfo", "[", "MBB", "->", "getNumber", "(", ")", "]", ".", "Offset", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", "->", "begin", "(", ")", ";", "&", "*", "I", "!=", "MI", ";", "++", "I", ")", "{", "assert", "(", "I", "!=", "MBB", "->", "end", "(", ")", "&&", "\"Didn't find MI in its own basic block?\"", ")", ";", "Offset", "+=", "TII", "->", "GetInstSizeInBytes", "(", "I", ")", ";", "}", "return", "Offset", ";", "}", "</s>" ]

[ "getOffsetOf", "-", "Return", "the", "current", "offset", "of", "the", "specified", "machine", "instruction", "from", "the", "start", "of", "the", "function", "." ]

[ "Mips", "Mips", "\"Didn't find MI in its own basic block?\"" ]

[]

[ "<s>", "bool", "AlphaFrameInfo", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "MFI", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

[ "Alpha", "Alpha" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "SYSTEMZ_EXPAND_PSEUDO_NAME", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "SystemZ" ]

[]

[ "<s>", "unsigned", "MipsRegisterInfo", "::", "getRARegister", "(", ")", "const", "{", "return", "Mips", "::", "RA", ";", "}", "</s>" ]

[ "This", "method", "should", "return", "the", "register", "where", "the", "return", "address", "can", "be", "found", "." ]

[ "Mips", "Mips", "Mips::RA" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "STRrs", ":", "case", "ARM", "::", "t2STRs", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "==", "0", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "STRi12", ":", "case", "ARM", "::", "t2STRi12", ":", "case", "ARM", "::", "tSpill", ":", "case", "ARM", "::", "VSTRD", ":", "case", "ARM", "::", "VSTRS", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VST1q64Pseudo", ":", "if", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getSubReg", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VSTMQIA", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "ARM", "ARM", "ARM::STRrs", "ARM::t2STRs", "1", "2", "3", "2", "0", "3", "0", "1", "0", "ARM::STRi12", "ARM::t2STRi12", "ARM::tSpill", "ARM::VSTRD", "ARM::VSTRS", "1", "2", "2", "0", "1", "0", "ARM::VST1q64Pseudo", "0", "2", "0", "0", "2", "ARM::VSTMQIA", "1", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "static", "bool", "isF128SoftLibCall", "(", "const", "char", "*", "CallSym", ")", "{", "const", "char", "*", "const", "LibCalls", "[", "]", "=", "{", "\"__addtf3\"", ",", "\"__divtf3\"", ",", "\"__eqtf2\"", ",", "\"__extenddftf2\"", ",", "\"__extendsftf2\"", ",", "\"__fixtfdi\"", ",", "\"__fixtfsi\"", ",", "\"__fixtfti\"", ",", "\"__fixunstfdi\"", ",", "\"__fixunstfsi\"", ",", "\"__fixunstfti\"", ",", "\"__floatditf\"", ",", "\"__floatsitf\"", ",", "\"__floattitf\"", ",", "\"__floatunditf\"", ",", "\"__floatunsitf\"", ",", "\"__floatuntitf\"", ",", "\"__getf2\"", ",", "\"__gttf2\"", ",", "\"__letf2\"", ",", "\"__lttf2\"", ",", "\"__multf3\"", ",", "\"__netf2\"", ",", "\"__powitf2\"", ",", "\"__subtf3\"", ",", "\"__trunctfdf2\"", ",", "\"__trunctfsf2\"", ",", "\"__unordtf2\"", ",", "\"ceill\"", ",", "\"copysignl\"", ",", "\"cosl\"", ",", "\"exp2l\"", ",", "\"expl\"", ",", "\"floorl\"", ",", "\"fmal\"", ",", "\"fmodl\"", ",", "\"log10l\"", ",", "\"log2l\"", ",", "\"logl\"", ",", "\"nearbyintl\"", ",", "\"powl\"", ",", "\"rintl\"", ",", "\"sinl\"", ",", "\"sqrtl\"", ",", "\"truncl\"", "}", ";", "const", "char", "*", "const", "*", "End", "=", "LibCalls", "+", "array_lengthof", "(", "LibCalls", ")", ";", "MipsTargetLowering", "::", "LTStr", "Comp", ";", "for", "(", "const", "char", "*", "const", "*", "I", "=", "LibCalls", ";", "I", "<", "End", "-", "1", ";", "++", "I", ")", "assert", "(", "Comp", "(", "*", "I", ",", "*", "(", "I", "+", "1", ")", ")", ")", ";", "return", "std", "::", "binary_search", "(", "LibCalls", ",", "End", ",", "CallSym", ",", "Comp", ")", ";", "}", "</s>" ]

[ "This", "function", "returns", "true", "if", "CallSym", "is", "a", "long", "double", "emulation", "routine", "." ]

[ "Mips", "\"__addtf3\"", "\"__divtf3\"", "\"__eqtf2\"", "\"__extenddftf2\"", "\"__extendsftf2\"", "\"__fixtfdi\"", "\"__fixtfsi\"", "\"__fixtfti\"", "\"__fixunstfdi\"", "\"__fixunstfsi\"", "\"__fixunstfti\"", "\"__floatditf\"", "\"__floatsitf\"", "\"__floattitf\"", "\"__floatunditf\"", "\"__floatunsitf\"", "\"__floatuntitf\"", "\"__getf2\"", "\"__gttf2\"", "\"__letf2\"", "\"__lttf2\"", "\"__multf3\"", "\"__netf2\"", "\"__powitf2\"", "\"__subtf3\"", "\"__trunctfdf2\"", "\"__trunctfsf2\"", "\"__unordtf2\"", "\"ceill\"", "\"copysignl\"", "\"cosl\"", "\"exp2l\"", "\"expl\"", "\"floorl\"", "\"fmal\"", "\"fmodl\"", "\"log10l\"", "\"log2l\"", "\"logl\"", "\"nearbyintl\"", "\"powl\"", "\"rintl\"", "\"sinl\"", "\"sqrtl\"", "\"truncl\"", "Mips", "1", "1" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "getSqrtEstimate", "(", "SDValue", "Operand", ",", "SelectionDAG", "&", "DAG", ",", "int", "Enabled", ",", "int", "&", "RefinementSteps", ",", "bool", "&", "UseOneConstNR", ",", "bool", "Reciprocal", ")", "const", "{", "EVT", "VT", "=", "Operand", ".", "getValueType", "(", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "{", "RefinementSteps", "=", "0", ";", "return", "DAG", ".", "getNode", "(", "AMDGPUISD", "::", "RSQ", ",", "SDLoc", "(", "Operand", ")", ",", "VT", ",", "Operand", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Hooks", "for", "building", "estimates", "in", "place", "of", "slower", "divisions", "and", "square", "roots", "." ]

[ "AMDGPU", "AMDGPU", "MVT::f32", "0", "AMDGPUISD::RSQ" ]

[]

[ "<s>", "bool", "RISCVDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "switch", "(", "ConstraintID", ")", "{", "case", "InlineAsm", "::", "Constraint_i", ":", "case", "InlineAsm", "::", "Constraint_m", ":", "OutOps", ".", "push_back", "(", "Op", ")", ";", "return", "false", ";", "default", ":", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "SelectInlineAsmMemoryOperand", "-", "Select", "the", "specified", "address", "as", "a", "target", "addressing", "mode", ",", "according", "to", "the", "specified", "constraint", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "BitVector", "XCoreRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "Reserved", ".", "set", "(", "XCore", "::", "CP", ")", ";", "Reserved", ".", "set", "(", "XCore", "::", "DP", ")", ";", "Reserved", ".", "set", "(", "XCore", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "XCore", "::", "LR", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "Reserved", ".", "set", "(", "XCore", "::", "R10", ")", ";", "}", "return", "Reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "XCore", "XCore", "XCore::CP", "XCore::DP", "XCore::SP", "XCore::LR", "XCore::R10" ]

[]

[ "<s>", "const", "uint32_t", "*", "SystemZRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "const", "SystemZSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "SystemZSubtarget", ">", "(", ")", ";", "if", "(", "CC", "==", "CallingConv", "::", "AnyReg", ")", "return", "Subtarget", ".", "hasVector", "(", ")", "?", "CSR_SystemZ_AllRegs_Vector_RegMask", ":", "CSR_SystemZ_AllRegs_RegMask", ";", "if", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", ".", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_SystemZ_SwiftError_RegMask", ";", "return", "CSR_SystemZ_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ" ]

[]

[ "<s>", "static", "void", "aarch64_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "int", "this_regno", "=", "R0_REGNUM", ";", "rtx", "this_rtx", ",", "temp0", ",", "temp1", ",", "addr", ",", "funexp", ";", "rtx_insn", "*", "insn", ";", "reload_completed", "=", "1", ";", "emit_note", "(", "NOTE_INSN_PROLOGUE_END", ")", ";", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "this_regno", ")", ";", "temp0", "=", "gen_rtx_REG", "(", "Pmode", ",", "IP0_REGNUM", ")", ";", "temp1", "=", "gen_rtx_REG", "(", "Pmode", ",", "IP1_REGNUM", ")", ";", "if", "(", "vcall_offset", "==", "0", ")", "aarch64_add_offset", "(", "Pmode", ",", "this_rtx", ",", "this_rtx", ",", "delta", ",", "temp1", ",", "temp0", ",", "false", ")", ";", "else", "{", "gcc_assert", "(", "(", "vcall_offset", "&", "(", "POINTER_BYTES", "-", "1", ")", ")", "==", "0", ")", ";", "addr", "=", "this_rtx", ";", "if", "(", "delta", "!=", "0", ")", "{", "if", "(", "delta", ">=", "-", "256", "&&", "delta", "<", "256", ")", "addr", "=", "gen_rtx_PRE_MODIFY", "(", "Pmode", ",", "this_rtx", ",", "plus_constant", "(", "Pmode", ",", "this_rtx", ",", "delta", ")", ")", ";", "else", "aarch64_add_offset", "(", "Pmode", ",", "this_rtx", ",", "this_rtx", ",", "delta", ",", "temp1", ",", "temp0", ",", "false", ")", ";", "}", "if", "(", "Pmode", "==", "ptr_mode", ")", "aarch64_emit_move", "(", "temp0", ",", "gen_rtx_MEM", "(", "ptr_mode", ",", "addr", ")", ")", ";", "else", "aarch64_emit_move", "(", "temp0", ",", "gen_rtx_ZERO_EXTEND", "(", "Pmode", ",", "gen_rtx_MEM", "(", "ptr_mode", ",", "addr", ")", ")", ")", ";", "if", "(", "vcall_offset", ">=", "-", "256", "&&", "vcall_offset", "<", "4096", "*", "POINTER_BYTES", ")", "addr", "=", "plus_constant", "(", "Pmode", ",", "temp0", ",", "vcall_offset", ")", ";", "else", "{", "aarch64_internal_mov_immediate", "(", "temp1", ",", "GEN_INT", "(", "vcall_offset", ")", ",", "true", ",", "Pmode", ")", ";", "addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "temp0", ",", "temp1", ")", ";", "}", "if", "(", "Pmode", "==", "ptr_mode", ")", "aarch64_emit_move", "(", "temp1", ",", "gen_rtx_MEM", "(", "ptr_mode", ",", "addr", ")", ")", ";", "else", "aarch64_emit_move", "(", "temp1", ",", "gen_rtx_SIGN_EXTEND", "(", "Pmode", ",", "gen_rtx_MEM", "(", "ptr_mode", ",", "addr", ")", ")", ")", ";", "emit_insn", "(", "gen_add2_insn", "(", "this_rtx", ",", "temp1", ")", ")", ";", "}", "if", "(", "!", "TREE_USED", "(", "function", ")", ")", "{", "assemble_external", "(", "function", ")", ";", "TREE_USED", "(", "function", ")", "=", "1", ";", "}", "funexp", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "funexp", "=", "gen_rtx_MEM", "(", "FUNCTION_MODE", ",", "funexp", ")", ";", "insn", "=", "emit_call_insn", "(", "gen_sibcall", "(", "funexp", ",", "const0_rtx", ",", "NULL_RTX", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "get_insns", "(", ")", ";", "shorten_branches", "(", "insn", ")", ";", "final_start_function", "(", "insn", ",", "file", ",", "1", ")", ";", "final", "(", "insn", ",", "file", ",", "1", ")", ";", "final_end_function", "(", ")", ";", "reload_completed", "=", "0", ";", "}", "</s>" ]

[ "Output", "code", "to", "add", "DELTA", "to", "the", "first", "argument", ",", "and", "then", "jump", "to", "FUNCTION", ".", "Used", "for", "C++", "multiple", "inheritance", "." ]

[ "aarch64", "1", "0", "1", "0", "0", "256", "256", "256", "4096", "1", "0", "1", "1", "1", "0" ]

[]

[ "<s>", "AtomicExpansionKind", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "AI", ")", "const", "override", "{", "return", "AtomicExpansionKind", "::", "LLSC", ";", "}", "</s>" ]

[ "Returns", "how", "the", "IR-level", "AtomicExpand", "pass", "should", "expand", "the", "given", "AtomicRMW", ",", "if", "at", "all", "." ]

[ "Hexagon" ]

[]

[ "<s>", "MCSymbol", "*", "WebAssemblyMCInstLower", "::", "GetExternalSymbolSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "const", "char", "*", "Name", "=", "MO", ".", "getSymbolName", "(", ")", ";", "auto", "*", "WasmSym", "=", "cast", "<", "MCSymbolWasm", ">", "(", "Printer", ".", "GetExternalSymbolSymbol", "(", "Name", ")", ")", ";", "const", "WebAssemblySubtarget", "&", "Subtarget", "=", "Printer", ".", "getSubtarget", "(", ")", ";", "if", "(", "strcmp", "(", "Name", ",", "\"__stack_pointer\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__tls_base\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__memory_base\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__table_base\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__tls_size\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__tls_align\"", ")", "==", "0", ")", "{", "bool", "Mutable", "=", "strcmp", "(", "Name", ",", "\"__stack_pointer\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__tls_base\"", ")", "==", "0", ";", "WasmSym", "->", "setType", "(", "wasm", "::", "WASM_SYMBOL_TYPE_GLOBAL", ")", ";", "WasmSym", "->", "setGlobalType", "(", "wasm", "::", "WasmGlobalType", "{", "uint8_t", "(", "Subtarget", ".", "hasAddr64", "(", ")", "?", "wasm", "::", "WASM_TYPE_I64", ":", "wasm", "::", "WASM_TYPE_I32", ")", ",", "Mutable", "}", ")", ";", "return", "WasmSym", ";", "}", "SmallVector", "<", "wasm", "::", "ValType", ",", "4", ">", "Returns", ";", "SmallVector", "<", "wasm", "::", "ValType", ",", "4", ">", "Params", ";", "if", "(", "strcmp", "(", "Name", ",", "\"__cpp_exception\"", ")", "==", "0", ")", "{", "WasmSym", "->", "setType", "(", "wasm", "::", "WASM_SYMBOL_TYPE_EVENT", ")", ";", "WasmSym", "->", "setEventType", "(", "{", "wasm", "::", "WASM_EVENT_ATTRIBUTE_EXCEPTION", ",", "0", "}", ")", ";", "WasmSym", "->", "setWeak", "(", "true", ")", ";", "WasmSym", "->", "setExternal", "(", "true", ")", ";", "Params", ".", "push_back", "(", "Subtarget", ".", "hasAddr64", "(", ")", "?", "wasm", "::", "ValType", "::", "I64", ":", "wasm", "::", "ValType", "::", "I32", ")", ";", "}", "else", "{", "WasmSym", "->", "setType", "(", "wasm", "::", "WASM_SYMBOL_TYPE_FUNCTION", ")", ";", "getLibcallSignature", "(", "Subtarget", ",", "Name", ",", "Returns", ",", "Params", ")", ";", "}", "auto", "Signature", "=", "make_unique", "<", "wasm", "::", "WasmSignature", ">", "(", "std", "::", "move", "(", "Returns", ")", ",", "std", "::", "move", "(", "Params", ")", ")", ";", "WasmSym", "->", "setSignature", "(", "Signature", ".", "get", "(", ")", ")", ";", "Printer", ".", "addSignature", "(", "std", "::", "move", "(", "Signature", ")", ")", ";", "return", "WasmSym", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "for", "the", "specified", "ExternalSymbol", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "\"__stack_pointer\"", "0", "\"__tls_base\"", "0", "\"__memory_base\"", "0", "\"__table_base\"", "0", "\"__tls_size\"", "0", "\"__tls_align\"", "0", "\"__stack_pointer\"", "0", "\"__tls_base\"", "0", "wasm::WASM_SYMBOL_TYPE_GLOBAL", "wasm::WasmGlobalType", "wasm::WASM_TYPE_I64", "wasm::WASM_TYPE_I32", "wasm::ValType", "4", "wasm::ValType", "4", "\"__cpp_exception\"", "0", "wasm::WASM_SYMBOL_TYPE_EVENT", "wasm::WASM_EVENT_ATTRIBUTE_EXCEPTION", "0", "wasm::ValType", "wasm::ValType", "wasm::WASM_SYMBOL_TYPE_FUNCTION", "wasm::WasmSignature" ]

[]

[ "<s>", "static", "bool", "mips_near_type_p", "(", "const_tree", "type", ")", "{", "return", "lookup_attribute", "(", "\"near\"", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", "!=", "NULL", ";", "}", "</s>" ]

[ "Predicates", "to", "test", "for", "presence", "of", "``", "near", "''", "and", "``", "far", "''", "/", "''", "long_call", "''", "attributes", "on", "the", "given", "TYPE", "." ]

[ "mips", "\"near\"" ]

[]

[ "<s>", "bool", "PPCLowerMASSVEntries", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "bool", "Changed", "=", "false", ";", "auto", "*", "TPC", "=", "getAnalysisIfAvailable", "<", "TargetPassConfig", ">", "(", ")", ";", "if", "(", "!", "TPC", ")", "return", "Changed", ";", "auto", "&", "TM", "=", "TPC", "->", "getTM", "<", "PPCTargetMachine", ">", "(", ")", ";", "const", "PPCSubtarget", "*", "Subtarget", ";", "for", "(", "Function", "&", "Func", ":", "M", ")", "{", "if", "(", "!", "Func", ".", "isDeclaration", "(", ")", ")", "continue", ";", "if", "(", "!", "isMASSVFunc", "(", "Func", ".", "getName", "(", ")", ")", ")", "continue", ";", "SmallVector", "<", "User", "*", ",", "4", ">", "MASSVUsers", "(", "Func", ".", "users", "(", ")", ")", ";", "for", "(", "auto", "*", "User", ":", "MASSVUsers", ")", "{", "auto", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "User", ")", ";", "if", "(", "!", "CI", ")", "continue", ";", "Subtarget", "=", "&", "TM", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", "*", "CI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ")", ";", "Changed", "|=", "lowerMASSVCall", "(", "CI", ",", "Func", ",", "M", ",", "Subtarget", ")", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "4", "PPC" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createPostMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "llvm_unreachable", "(", "\"unimplemented\"", ")", ";", "}", "</s>" ]

[ "Similar", "to", "createMachineScheduler", "but", "used", "when", "postRA", "machine", "scheduling", "is", "enabled", "." ]

[ "Patmos", "\"unimplemented\"" ]

[]

[ "<s>", "void", "addDef", "(", "long", "pos", ")", "{", "defs", ".", "set", "(", "pos", ")", ";", "}", "</s>" ]

[ "Add", "a", "virtual", "register", "definition", "operand", "." ]

[ "Patmos" ]

[]

[ "<s>", "static", "void", "visium_print_operand_address", "(", "FILE", "*", "file", ",", "machine_mode", "mode", ",", "rtx", "addr", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "case", "SUBREG", ":", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "true_regnum", "(", "addr", ")", "]", ")", ";", "break", ";", "case", "PLUS", ":", "{", "rtx", "x", "=", "XEXP", "(", "addr", ",", "0", ")", ",", "y", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "case", "SUBREG", ":", "if", "(", "CONST_INT_P", "(", "y", ")", ")", "{", "unsigned", "int", "regno", "=", "true_regnum", "(", "x", ")", ";", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "y", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_SImode", ":", "case", "E_DImode", ":", "case", "E_SFmode", ":", "case", "E_DFmode", ":", "val", ">>=", "2", ";", "break", ";", "case", "E_HImode", ":", "val", ">>=", "1", ";", "break", ";", "case", "E_QImode", ":", "default", ":", "break", ";", "}", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", "\"(%s)\"", ",", "val", ",", "reg_names", "[", "regno", "]", ")", ";", "}", "else", "fatal_insn", "(", "\"illegal operand address (1)\"", ",", "addr", ")", ";", "break", ";", "default", ":", "if", "(", "CONSTANT_P", "(", "x", ")", "&&", "CONSTANT_P", "(", "y", ")", ")", "output_addr_const", "(", "file", ",", "addr", ")", ";", "else", "fatal_insn", "(", "\"illegal operand address (2)\"", ",", "addr", ")", ";", "break", ";", "}", "}", "break", ";", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "case", "CONST_INT", ":", "case", "CONST", ":", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "case", "NOTE", ":", "if", "(", "NOTE_KIND", "(", "addr", ")", "!=", "NOTE_INSN_DELETED_LABEL", ")", "fatal_insn", "(", "\"illegal operand address (3)\"", ",", "addr", ")", ";", "break", ";", "case", "CODE_LABEL", ":", "asm_fprintf", "(", "file", ",", "\"%LL%d\"", ",", "CODE_LABEL_NUMBER", "(", "addr", ")", ")", ";", "break", ";", "default", ":", "fatal_insn", "(", "\"illegal operand address (4)\"", ",", "addr", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_PRINT_OPERAND_ADDRESS", ".", "Output", "to", "stdio", "stream", "FILE", "the", "assembler", "syntax", "for", "an", "instruction", "operand", "that", "is", "a", "memory", "reference", "whose", "address", "is", "ADDR", "." ]

[ "visium", "\"(%s)\"", "0", "1", "2", "1", "\"(%s)\"", "\"illegal operand address (1)\"", "\"illegal operand address (2)\"", "\"illegal operand address (3)\"", "\"%LL%d\"", "\"illegal operand address (4)\"" ]

[]

[ "<s>", "Register", "LanaiTargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "LLT", ",", "const", "MachineFunction", "&", ")", "const", "{", "Register", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"pc\"", ",", "Lanai", "::", "PC", ")", ".", "Case", "(", "\"sp\"", ",", "Lanai", "::", "SP", ")", ".", "Case", "(", "\"fp\"", ",", "Lanai", "::", "FP", ")", ".", "Case", "(", "\"rr1\"", ",", "Lanai", "::", "RR1", ")", ".", "Case", "(", "\"r10\"", ",", "Lanai", "::", "R10", ")", ".", "Case", "(", "\"rr2\"", ",", "Lanai", "::", "RR2", ")", ".", "Case", "(", "\"r11\"", ",", "Lanai", "::", "R11", ")", ".", "Case", "(", "\"rca\"", ",", "Lanai", "::", "RCA", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "\"Invalid register name global variable\"", ")", ";", "}", "</s>" ]

[ "Return", "the", "register", "ID", "of", "the", "name", "passed", "in", "." ]

[ "Lanai", "Lanai", "\"pc\"", "Lanai::PC", "\"sp\"", "Lanai::SP", "\"fp\"", "Lanai::FP", "\"rr1\"", "Lanai::RR1", "\"r10\"", "Lanai::R10", "\"rr2\"", "Lanai::RR2", "\"r11\"", "Lanai::R11", "\"rca\"", "Lanai::RCA", "0", "\"Invalid register name global variable\"" ]

[]

[ "<s>", "static", "std", "::", "string", "getEdgeAttributes", "(", "NodeRef", ",", "ChildIteratorType", "E", ",", "GraphType", "*", ")", "{", "int", "EdgeVal", "=", "(", "*", "E", ".", "getCurrent", "(", ")", ")", ".", "getValue", "(", ")", ";", "return", "EdgeVal", ">=", "0", "?", "\"label = \"", "+", "std", "::", "to_string", "(", "EdgeVal", ")", ":", "\"color = red, style = \\\"dashed\\\"\"", ";", "}", "</s>" ]

[ "If", "you", "want", "to", "override", "the", "dot", "attributes", "printed", "for", "a", "particular", "edge", ",", "override", "this", "method", "." ]

[ "X86", "0", "\"label = \"", "\"color = red, style = \\\"dashed\\\"\"" ]

[]

[ "<s>", "static", "void", "rs6000_density_test", "(", "rs6000_cost_data", "*", "data", ")", "{", "const", "int", "DENSITY_PCT_THRESHOLD", "=", "85", ";", "const", "int", "DENSITY_SIZE_THRESHOLD", "=", "70", ";", "const", "int", "DENSITY_PENALTY", "=", "10", ";", "struct", "loop", "*", "loop", "=", "data", "->", "loop_info", ";", "basic_block", "*", "bbs", "=", "get_loop_body", "(", "loop", ")", ";", "int", "nbbs", "=", "loop", "->", "num_nodes", ";", "int", "vec_cost", "=", "data", "->", "cost", "[", "vect_body", "]", ",", "not_vec_cost", "=", "0", ";", "int", "i", ",", "density_pct", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nbbs", ";", "i", "++", ")", "{", "basic_block", "bb", "=", "bbs", "[", "i", "]", ";", "gimple_stmt_iterator", "gsi", ";", "for", "(", "gsi", "=", "gsi_start_bb", "(", "bb", ")", ";", "!", "gsi_end_p", "(", "gsi", ")", ";", "gsi_next", "(", "&", "gsi", ")", ")", "{", "gimple", "*", "stmt", "=", "gsi_stmt", "(", "gsi", ")", ";", "stmt_vec_info", "stmt_info", "=", "vinfo_for_stmt", "(", "stmt", ")", ";", "if", "(", "!", "STMT_VINFO_RELEVANT_P", "(", "stmt_info", ")", "&&", "!", "STMT_VINFO_IN_PATTERN_P", "(", "stmt_info", ")", ")", "not_vec_cost", "++", ";", "}", "}", "free", "(", "bbs", ")", ";", "density_pct", "=", "(", "vec_cost", "*", "100", ")", "/", "(", "vec_cost", "+", "not_vec_cost", ")", ";", "if", "(", "density_pct", ">", "DENSITY_PCT_THRESHOLD", "&&", "vec_cost", "+", "not_vec_cost", ">", "DENSITY_SIZE_THRESHOLD", ")", "{", "data", "->", "cost", "[", "vect_body", "]", "=", "vec_cost", "*", "(", "100", "+", "DENSITY_PENALTY", ")", "/", "100", ";", "if", "(", "dump_enabled_p", "(", ")", ")", "dump_printf_loc", "(", "MSG_NOTE", ",", "vect_location", ",", "\"density %d%%, cost %d exceeds threshold, penalizing \"", "\"loop body cost by %d%%\"", ",", "density_pct", ",", "vec_cost", "+", "not_vec_cost", ",", "DENSITY_PENALTY", ")", ";", "}", "}", "</s>" ]

[ "Test", "for", "likely", "overcommitment", "of", "vector", "hardware", "resources", ".", "If", "a", "loop", "iteration", "is", "relatively", "large", ",", "and", "too", "large", "a", "percentage", "of", "instructions", "in", "the", "loop", "are", "vectorized", ",", "the", "cost", "model", "may", "not", "adequately", "reflect", "delays", "from", "unavailable", "vector", "resources", ".", "Penalize", "the", "loop", "body", "cost", "for", "this", "case", "." ]

[ "powerpcspe", "85", "70", "10", "0", "0", "100", "100", "100", "\"density %d%%, cost %d exceeds threshold, penalizing \"", "\"loop body cost by %d%%\"" ]

[]

[ "<s>", "static", "void", "replace_constant_pool_ref", "(", "rtx", "*", "x", ",", "rtx", "ref", ",", "rtx", "offset", ")", "{", "int", "i", ",", "j", ";", "const", "char", "*", "fmt", ";", "gcc_assert", "(", "*", "x", "!=", "ref", ")", ";", "if", "(", "GET_CODE", "(", "*", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "*", "x", ",", "1", ")", "==", "UNSPEC_LTREF", "&&", "XVECEXP", "(", "*", "x", ",", "0", ",", "0", ")", "==", "ref", ")", "{", "*", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "XVECEXP", "(", "*", "x", ",", "0", ",", "1", ")", ",", "offset", ")", ";", "return", ";", "}", "if", "(", "GET_CODE", "(", "*", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "*", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "GET_CODE", "(", "XEXP", "(", "*", "x", ",", "0", ")", ")", "==", "UNSPEC", "&&", "XINT", "(", "XEXP", "(", "*", "x", ",", "0", ")", ",", "1", ")", "==", "UNSPEC_LTREF", "&&", "XVECEXP", "(", "XEXP", "(", "*", "x", ",", "0", ")", ",", "0", ",", "0", ")", "==", "ref", ")", "{", "rtx", "addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "XVECEXP", "(", "XEXP", "(", "*", "x", ",", "0", ")", ",", "0", ",", "1", ")", ",", "offset", ")", ";", "*", "x", "=", "plus_constant", "(", "addr", ",", "INTVAL", "(", "XEXP", "(", "*", "x", ",", "1", ")", ")", ")", ";", "return", ";", "}", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "*", "x", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "*", "x", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'e'", ")", "{", "replace_constant_pool_ref", "(", "&", "XEXP", "(", "*", "x", ",", "i", ")", ",", "ref", ",", "offset", ")", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "for", "(", "j", "=", "0", ";", "j", "<", "XVECLEN", "(", "*", "x", ",", "i", ")", ";", "j", "++", ")", "replace_constant_pool_ref", "(", "&", "XVECEXP", "(", "*", "x", ",", "i", ",", "j", ")", ",", "ref", ",", "offset", ")", ";", "}", "}", "}", "</s>" ]

[ "Replace", "every", "reference", "to", "the", "annotated", "literal", "pool", "symbol", "REF", "in", "X", "by", "its", "base", "plus", "OFFSET", "." ]

[ "s390", "1", "0", "0", "0", "1", "1", "0", "0", "1", "0", "0", "0", "0", "0", "1", "1", "1", "0", "0" ]

[]

[ "<s>", "static", "bool", "branch_to_delay_slot_p", "(", "rtx_insn", "*", "insn", ")", "{", "rtx_insn", "*", "jump_insn", ";", "if", "(", "dbr_sequence_length", "(", ")", ")", "return", "FALSE", ";", "jump_insn", "=", "next_active_insn", "(", "JUMP_LABEL_AS_INSN", "(", "insn", ")", ")", ";", "while", "(", "insn", ")", "{", "insn", "=", "next_active_insn", "(", "insn", ")", ";", "if", "(", "jump_insn", "==", "insn", ")", "return", "TRUE", ";", "if", "(", "!", "insn", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ASM_INPUT", "||", "asm_noperands", "(", "PATTERN", "(", "insn", ")", ")", ">=", "0", "||", "get_attr_length", "(", "insn", ")", ">", "0", ")", "break", ";", "}", "return", "FALSE", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "INSN", ",", "a", "jump", "insn", ",", "has", "an", "unfilled", "delay", "slot", "and", "it", "branches", "into", "the", "delay", "slot", ".", "Otherwise", ",", "return", "FALSE", "." ]

[ "pa", "0", "0" ]

[]

[ "<s>", "static", "int", "mips_address_cost", "(", "rtx", "addr", ")", "{", "return", "mips_address_insns", "(", "addr", ",", "SImode", ")", ";", "}", "</s>" ]

[ "Provide", "the", "costs", "of", "an", "addressing", "mode", "that", "contains", "ADDR", ".", "If", "ADDR", "is", "not", "a", "valid", "address", ",", "its", "cost", "is", "irrelevant", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "GCNTTIImpl", "::", "getTgtMemIntrinsic", "(", "IntrinsicInst", "*", "Inst", ",", "MemIntrinsicInfo", "&", "Info", ")", "const", "{", "switch", "(", "Inst", "->", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "amdgcn_atomic_inc", ":", "case", "Intrinsic", "::", "amdgcn_atomic_dec", ":", "case", "Intrinsic", "::", "amdgcn_ds_fadd", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmin", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmax", ":", "{", "auto", "*", "Ordering", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "Inst", "->", "getArgOperand", "(", "2", ")", ")", ";", "auto", "*", "Volatile", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "Inst", "->", "getArgOperand", "(", "4", ")", ")", ";", "if", "(", "!", "Ordering", "||", "!", "Volatile", ")", "return", "false", ";", "unsigned", "OrderingVal", "=", "Ordering", "->", "getZExtValue", "(", ")", ";", "if", "(", "OrderingVal", ">", "static_cast", "<", "unsigned", ">", "(", "AtomicOrdering", "::", "SequentiallyConsistent", ")", ")", "return", "false", ";", "Info", ".", "PtrVal", "=", "Inst", "->", "getArgOperand", "(", "0", ")", ";", "Info", ".", "Ordering", "=", "static_cast", "<", "AtomicOrdering", ">", "(", "OrderingVal", ")", ";", "Info", ".", "ReadMem", "=", "true", ";", "Info", ".", "WriteMem", "=", "true", ";", "Info", ".", "IsVolatile", "=", "!", "Volatile", "->", "isNullValue", "(", ")", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Given", "an", "intrinsic", ",", "checks", "if", "on", "the", "target", "the", "intrinsic", "will", "need", "to", "map", "to", "a", "MemIntrinsicNode", "(", "touches", "memory", ")", "." ]

[ "AMDGPU", "Intrinsic::amdgcn_atomic_inc", "Intrinsic::amdgcn_atomic_dec", "Intrinsic::amdgcn_ds_fadd", "Intrinsic::amdgcn_ds_fmin", "Intrinsic::amdgcn_ds_fmax", "2", "4", "0" ]

[]

[ "<s>", "static", "bool", "csky_legitimate_constant_p", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "return", "(", "!", "csky_cannot_force_const_mem", "(", "mode", ",", "x", ")", "&&", "CONSTANT_P", "(", "x", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMATE_CONSTANT_P", ".", "Returns", "nonzero", "if", "the", "constant", "value", "X", "is", "a", "legitimate", "general", "operand", ".", "It", "is", "given", "that", "X", "satisfies", "CONSTANT_P", "or", "is", "a", "CONST_DOUBLE", "." ]

[ "csky" ]

[]

[ "<s>", "MachineBasicBlock", "*", "mprocTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "mproc", "mproc" ]

[]

[ "<s>", "static", "HOST_WIDEST_INT", "mmix_intval", "(", "rtx", "x", ")", "{", "unsigned", "HOST_WIDEST_INT", "retval", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "return", "INTVAL", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", "&&", "GET_MODE", "(", "x", ")", "==", "VOIDmode", ")", "{", "if", "(", "sizeof", "(", "HOST_WIDE_INT", ")", "<", "sizeof", "(", "HOST_WIDEST_INT", ")", ")", "{", "retval", "=", "(", "unsigned", ")", "CONST_DOUBLE_LOW", "(", "x", ")", "/", "2", ";", "retval", "*=", "2", ";", "retval", "|=", "CONST_DOUBLE_LOW", "(", "x", ")", "&", "1", ";", "retval", "|=", "(", "unsigned", "HOST_WIDEST_INT", ")", "CONST_DOUBLE_HIGH", "(", "x", ")", "<<", "(", "HOST_BITS_PER_LONG", ")", ";", "}", "else", "retval", "=", "CONST_DOUBLE_HIGH", "(", "x", ")", ";", "return", "retval", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", ")", "{", "REAL_VALUE_TYPE", "value", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "value", ",", "x", ")", ";", "if", "(", "GET_MODE", "(", "x", ")", "==", "DFmode", ")", "{", "long", "bits", "[", "2", "]", ";", "REAL_VALUE_TO_TARGET_DOUBLE", "(", "value", ",", "bits", ")", ";", "return", "(", "(", "unsigned", "HOST_WIDEST_INT", ")", "(", "unsigned", "long", ")", "bits", "[", "0", "]", "<<", "(", "unsigned", "HOST_WIDEST_INT", ")", "32U", ")", "|", "(", "unsigned", "HOST_WIDEST_INT", ")", "(", "unsigned", "long", ")", "bits", "[", "1", "]", ";", "}", "else", "if", "(", "GET_MODE", "(", "x", ")", "==", "SFmode", ")", "{", "long", "bits", ";", "REAL_VALUE_TO_TARGET_SINGLE", "(", "value", ",", "bits", ")", ";", "return", "(", "unsigned", "long", ")", "bits", ";", "}", "}", "fatal_insn", "(", "\"MMIX Internal: This is not a constant:\"", ",", "x", ")", ";", "}", "</s>" ]

[ "Return", "the", "bit-value", "for", "a", "const_int", "or", "const_double", "." ]

[ "mmix", "2", "2", "1", "2", "0", "32U", "1", "\"MMIX Internal: This is not a constant:\"" ]

[]

[ "<s>", "bool", "AMDGPUAAResult", "::", "pointsToConstantMemory", "(", "const", "MemoryLocation", "&", "Loc", ",", "AAQueryInfo", "&", "AAQI", ",", "bool", "OrLocal", ")", "{", "unsigned", "AS", "=", "Loc", ".", "Ptr", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "if", "(", "AS", "==", "AMDGPUAS", "::", "CONSTANT_ADDRESS", "||", "AS", "==", "AMDGPUAS", "::", "CONSTANT_ADDRESS_32BIT", ")", "return", "true", ";", "const", "Value", "*", "Base", "=", "getUnderlyingObject", "(", "Loc", ".", "Ptr", ")", ";", "AS", "=", "Base", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "if", "(", "AS", "==", "AMDGPUAS", "::", "CONSTANT_ADDRESS", "||", "AS", "==", "AMDGPUAS", "::", "CONSTANT_ADDRESS_32BIT", ")", "return", "true", ";", "if", "(", "const", "GlobalVariable", "*", "GV", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "Base", ")", ")", "{", "if", "(", "GV", "->", "isConstant", "(", ")", ")", "return", "true", ";", "}", "else", "if", "(", "const", "Argument", "*", "Arg", "=", "dyn_cast", "<", "Argument", ">", "(", "Base", ")", ")", "{", "const", "Function", "*", "F", "=", "Arg", "->", "getParent", "(", ")", ";", "switch", "(", "F", "->", "getCallingConv", "(", ")", ")", "{", "default", ":", "return", "AAResultBase", "::", "pointsToConstantMemory", "(", "Loc", ",", "AAQI", ",", "OrLocal", ")", ";", "case", "CallingConv", "::", "AMDGPU_LS", ":", "case", "CallingConv", "::", "AMDGPU_HS", ":", "case", "CallingConv", "::", "AMDGPU_ES", ":", "case", "CallingConv", "::", "AMDGPU_GS", ":", "case", "CallingConv", "::", "AMDGPU_VS", ":", "case", "CallingConv", "::", "AMDGPU_PS", ":", "case", "CallingConv", "::", "AMDGPU_CS", ":", "case", "CallingConv", "::", "AMDGPU_KERNEL", ":", "case", "CallingConv", "::", "SPIR_KERNEL", ":", "break", ";", "}", "unsigned", "ArgNo", "=", "Arg", "->", "getArgNo", "(", ")", ";", "if", "(", "F", "->", "hasParamAttribute", "(", "ArgNo", ",", "Attribute", "::", "NoAlias", ")", "&&", "(", "F", "->", "hasParamAttribute", "(", "ArgNo", ",", "Attribute", "::", "ReadNone", ")", "||", "F", "->", "hasParamAttribute", "(", "ArgNo", ",", "Attribute", "::", "ReadOnly", ")", ")", ")", "{", "return", "true", ";", "}", "}", "return", "AAResultBase", "::", "pointsToConstantMemory", "(", "Loc", ",", "AAQI", ",", "OrLocal", ")", ";", "}", "</s>" ]

[ "A", "convenience", "wrapper", "around", "the", "primary", "pointsToConstantMemory", "interface", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "const", "MCSymbolRefExpr", "*", "getSymbolExpr", "(", ")", "const", "{", "return", "SymExpr", ";", "}", "</s>" ]

[ "getOpcode", "-", "Get", "the", "kind", "of", "this", "expression", "." ]

[ "NVPTX" ]

[]

[ "<s>", "static", "void", "pru_compute_frame_layout", "(", "void", ")", "{", "int", "regno", ";", "HARD_REG_SET", "*", "save_mask", ";", "int", "total_size", ";", "int", "var_size", ";", "int", "out_args_size", ";", "int", "save_reg_size", ";", "gcc_assert", "(", "!", "cfun", "->", "machine", "->", "initialized", ")", ";", "save_mask", "=", "&", "cfun", "->", "machine", "->", "save_mask", ";", "CLEAR_HARD_REG_SET", "(", "*", "save_mask", ")", ";", "var_size", "=", "PRU_STACK_ALIGN", "(", "(", "HOST_WIDE_INT", ")", "get_frame_size", "(", ")", ")", ";", "out_args_size", "=", "PRU_STACK_ALIGN", "(", "(", "HOST_WIDE_INT", ")", "crtl", "->", "outgoing_args_size", ")", ";", "total_size", "=", "var_size", "+", "out_args_size", ";", "save_reg_size", "=", "0", ";", "for", "(", "regno", "=", "0", ";", "regno", "<=", "LAST_GP_REGNUM", ";", "regno", "++", ")", "if", "(", "prologue_saved_reg_p", "(", "regno", ")", ")", "{", "SET_HARD_REG_BIT", "(", "*", "save_mask", ",", "regno", ")", ";", "save_reg_size", "+=", "1", ";", "}", "save_reg_size", "=", "PRU_STACK_ALIGN", "(", "save_reg_size", ")", ";", "total_size", "+=", "save_reg_size", ";", "total_size", "+=", "PRU_STACK_ALIGN", "(", "crtl", "->", "args", ".", "pretend_args_size", ")", ";", "cfun", "->", "machine", "->", "total_size", "=", "total_size", ";", "cfun", "->", "machine", "->", "var_size", "=", "var_size", ";", "cfun", "->", "machine", "->", "out_args_size", "=", "out_args_size", ";", "cfun", "->", "machine", "->", "save_reg_size", "=", "save_reg_size", ";", "cfun", "->", "machine", "->", "initialized", "=", "reload_completed", ";", "cfun", "->", "machine", "->", "save_regs_offset", "=", "out_args_size", "+", "var_size", ";", "}", "</s>" ]

[ "Implement", "TARGET_COMPUTE_FRAME_LAYOUT", "." ]

[ "pru", "0", "0", "1" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "RISCVRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "auto", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_NoRegs_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "{", "if", "(", "Subtarget", ".", "hasStdExtD", "(", ")", ")", "return", "Subtarget", ".", "hasCheri", "(", ")", "?", "CSR_XLEN_CLEN_F64_Interrupt_SaveList", ":", "CSR_XLEN_F64_Interrupt_SaveList", ";", "if", "(", "Subtarget", ".", "hasStdExtF", "(", ")", ")", "return", "Subtarget", ".", "hasCheri", "(", ")", "?", "CSR_XLEN_CLEN_F32_Interrupt_SaveList", ":", "CSR_XLEN_F32_Interrupt_SaveList", ";", "return", "Subtarget", ".", "hasCheri", "(", ")", "?", "CSR_XLEN_CLEN_Interrupt_SaveList", ":", "CSR_Interrupt_SaveList", ";", "}", "switch", "(", "Subtarget", ".", "getTargetABI", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unrecognized ABI\"", ")", ";", "case", "RISCVABI", "::", "ABI_ILP32", ":", "case", "RISCVABI", "::", "ABI_LP64", ":", "return", "CSR_ILP32_LP64_SaveList", ";", "case", "RISCVABI", "::", "ABI_IL32PC64", ":", "case", "RISCVABI", "::", "ABI_L64PC128", ":", "return", "CSR_IL32PC64_L64PC128_SaveList", ";", "case", "RISCVABI", "::", "ABI_ILP32F", ":", "case", "RISCVABI", "::", "ABI_LP64F", ":", "return", "CSR_ILP32F_LP64F_SaveList", ";", "case", "RISCVABI", "::", "ABI_IL32PC64F", ":", "case", "RISCVABI", "::", "ABI_L64PC128F", ":", "return", "CSR_IL32PC64F_L64PC128F_SaveList", ";", "case", "RISCVABI", "::", "ABI_ILP32D", ":", "case", "RISCVABI", "::", "ABI_LP64D", ":", "return", "CSR_ILP32D_LP64D_SaveList", ";", "case", "RISCVABI", "::", "ABI_IL32PC64D", ":", "case", "RISCVABI", "::", "ABI_L64PC128D", ":", "return", "CSR_IL32PC64D_L64PC128D_SaveList", ";", "}", "}", "</s>" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "RISCV", "RISCV", "RISCV", "\"interrupt\"", "\"Unrecognized ABI\"", "RISCVABI::ABI_ILP32", "RISCVABI::ABI_LP64", "RISCVABI::ABI_IL32PC64", "RISCVABI::ABI_L64PC128", "RISCVABI::ABI_ILP32F", "RISCVABI::ABI_LP64F", "RISCVABI::ABI_IL32PC64F", "RISCVABI::ABI_L64PC128F", "RISCVABI::ABI_ILP32D", "RISCVABI::ABI_LP64D", "RISCVABI::ABI_IL32PC64D", "RISCVABI::ABI_L64PC128D" ]

[]

[ "<s>", "BlockSet", "&", "getBlocks", "(", ")", "{", "return", "Blocks", ";", "}", "</s>" ]

[ "Get", "a", "list", "of", "the", "basic", "blocks", "which", "make", "up", "this", "loop", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "static", "void", "tilegx_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "byte_size", "=", "arg", ".", "promoted_size_in_bytes", "(", ")", ";", "int", "word_size", "=", "(", "byte_size", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "bool", "doubleword_aligned_p", ";", "doubleword_aligned_p", "=", "tilegx_function_arg_boundary", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ">", "BITS_PER_WORD", ";", "if", "(", "doubleword_aligned_p", ")", "*", "cum", "+=", "*", "cum", "&", "1", ";", "if", "(", "*", "cum", "<", "TILEGX_NUM_ARG_REGS", "&&", "*", "cum", "+", "word_size", ">", "TILEGX_NUM_ARG_REGS", ")", "*", "cum", "=", "TILEGX_NUM_ARG_REGS", ";", "*", "cum", "+=", "word_size", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG_ADVANCE", "." ]

[ "tilegx", "1", "1" ]

[]

[ "<s>", "bool", "MOSLegalizerInfo", "::", "legalizeCustom", "(", "LegalizerHelper", "&", "Helper", ",", "MachineInstr", "&", "MI", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getMF", "(", ")", "->", "getRegInfo", "(", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid opcode for custom legalization.\"", ")", ";", "case", "G_CONSTANT", ":", "return", "legalizeConstant", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_SEXT", ":", "return", "legalizeSExt", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_ZEXT", ":", "return", "legalizeZExt", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_BSWAP", ":", "return", "legalizeBSwap", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_ADD", ":", "case", "G_SUB", ":", "return", "legalizeAddSub", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_XOR", ":", "return", "legalizeXor", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_SDIVREM", ":", "case", "G_UDIVREM", ":", "return", "legalizeDivRem", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_LSHR", ":", "case", "G_SHL", ":", "case", "G_ASHR", ":", "case", "G_ROTL", ":", "case", "G_ROTR", ":", "return", "legalizeShiftRotate", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_ICMP", ":", "return", "legalizeICmp", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_SELECT", ":", "return", "legalizeSelect", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_ABS", ":", "return", "legalizeAbs", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_PTR_ADD", ":", "return", "legalizePtrAdd", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_UADDO", ":", "case", "G_SADDO", ":", "case", "G_USUBO", ":", "case", "G_SSUBO", ":", "return", "legalizeAddSubO", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_USUBE", ":", "case", "G_SSUBE", ":", "return", "legalizeSubE", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_SEXTLOAD", ":", "case", "G_ZEXTLOAD", ":", "case", "G_LOAD", ":", "return", "legalizeLoad", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_STORE", ":", "return", "legalizeStore", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_PHI", ":", "return", "legalizePhi", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_BRCOND", ":", "return", "legalizeBrCond", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_BRJT", ":", "return", "legalizeBrJt", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_VAARG", ":", "return", "legalizeVAArg", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_VASTART", ":", "return", "legalizeVAStart", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_DYN_STACKALLOC", ":", "return", "legalizeDynStackAlloc", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_FREEZE", ":", "return", "legalizeFreeze", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "}", "}", "</s>" ]

[ "Called", "for", "instructions", "with", "the", "Custom", "LegalizationAction", "." ]

[ "MOS", "MOS", "\"Invalid opcode for custom legalization.\"" ]

[]

[ "<s>", "rtx", "csky_return_addr", "(", "int", "count", ",", "rtx", "frame", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "count", "!=", "0", ")", "return", "NULL_RTX", ";", "return", "get_hard_reg_initial_val", "(", "Pmode", ",", "CSKY_LR_REGNUM", ")", ";", "}", "</s>" ]

[ "Return", "an", "RTX", "indicating", "where", "the", "return", "address", "to", "the", "calling", "function", "can", "be", "found", "." ]

[ "csky", "0" ]

[]

[ "<s>", "bool", "SparcAsmPrinter", "::", "isBlockOnlyReachableByFallthrough", "(", "const", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "if", "(", "MBB", "->", "isLandingPad", "(", ")", "||", "MBB", "->", "pred_empty", "(", ")", ")", "return", "false", ";", "MachineBasicBlock", "::", "const_pred_iterator", "PI", "=", "MBB", "->", "pred_begin", "(", ")", ",", "PI2", "=", "PI", ";", "++", "PI2", ";", "if", "(", "PI2", "!=", "MBB", "->", "pred_end", "(", ")", ")", "return", "false", ";", "const", "MachineBasicBlock", "*", "Pred", "=", "*", "PI", ";", "if", "(", "!", "Pred", "->", "isLayoutSuccessor", "(", "MBB", ")", ")", "return", "false", ";", "MachineBasicBlock", "::", "const_iterator", "I", "=", "Pred", "->", "end", "(", ")", ";", "while", "(", "I", "!=", "Pred", "->", "begin", "(", ")", "&&", "!", "(", "--", "I", ")", "->", "isTerminator", "(", ")", ")", ";", "return", "I", "==", "Pred", "->", "end", "(", ")", "||", "!", "I", "->", "isBarrier", "(", ")", ";", "}", "</s>" ]

[ "isBlockOnlyReachableByFallthough", "-", "Return", "true", "if", "the", "basic", "block", "has", "exactly", "one", "predecessor", "and", "the", "control", "transfer", "mechanism", "between", "the", "predecessor", "and", "this", "block", "is", "a", "fall-through", "." ]

[ "Sparc", "Sparc" ]

[]

[ "<s>", "void", "aarch64_init_fcmla_laneq_builtins", "(", "void", ")", "{", "unsigned", "int", "i", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "aarch64_fcmla_lane_builtin_data", ")", ";", "++", "i", ")", "{", "aarch64_fcmla_laneq_builtin_datum", "*", "d", "=", "&", "aarch64_fcmla_lane_builtin_data", "[", "i", "]", ";", "tree", "argtype", "=", "aarch64_lookup_simd_builtin_type", "(", "d", "->", "mode", ",", "qualifier_none", ")", ";", "machine_mode", "quadmode", "=", "GET_MODE_2XWIDER_MODE", "(", "d", "->", "mode", ")", ".", "require", "(", ")", ";", "tree", "quadtype", "=", "aarch64_lookup_simd_builtin_type", "(", "quadmode", ",", "qualifier_none", ")", ";", "tree", "lanetype", "=", "aarch64_simd_builtin_std_type", "(", "SImode", ",", "qualifier_lane_pair_index", ")", ";", "tree", "ftype", "=", "build_function_type_list", "(", "argtype", ",", "argtype", ",", "argtype", ",", "quadtype", ",", "lanetype", ",", "NULL_TREE", ")", ";", "tree", "fndecl", "=", "add_builtin_function", "(", "d", "->", "name", ",", "ftype", ",", "d", "->", "fcode", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "aarch64_builtin_decls", "[", "d", "->", "fcode", "]", "=", "fndecl", ";", "}", "}", "</s>" ]

[ "Due", "to", "the", "architecture", "not", "providing", "lane", "variant", "of", "the", "lane", "instructions", "for", "fcmla", "we", "ca", "n't", "use", "the", "standard", "simd", "builtin", "expansion", "code", ",", "but", "we", "still", "want", "the", "majority", "of", "the", "validation", "that", "would", "normally", "be", "done", "." ]

[ "aarch64", "0", "0" ]

[]

[ "<s>", "SDValue", "ARCTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "auto", "*", "AFI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getInfo", "<", "ARCFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFrameInfo", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "if", "(", "!", "IsVarArg", ")", "CCInfo", ".", "AllocateStack", "(", "AFI", "->", "getReturnStackOffset", "(", ")", ",", "Align", "(", "4", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_ARC", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "MemOpChains", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "continue", ";", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "if", "(", "IsVarArg", ")", "{", "report_fatal_error", "(", "\"Can't return value from vararg function in memory\"", ")", ";", "}", "int", "Offset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "ObjSize", "=", "VA", ".", "getLocVT", "(", ")", ".", "getStoreSize", "(", ")", ";", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "ObjSize", ",", "Offset", ",", "false", ")", ";", "SDValue", "FIN", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "MemOpChains", ".", "push_back", "(", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "OutVals", "[", "i", "]", ",", "FIN", ",", "MachinePointerInfo", "::", "getFixedStack", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "FI", ")", ")", ")", ";", "}", "if", "(", "!", "MemOpChains", ".", "empty", "(", ")", ")", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", ",", "MemOpChains", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "if", "(", "!", "VA", ".", "isRegLoc", "(", ")", ")", "continue", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "ARCISD", "::", "RET", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "ARC", "ARC", "ISD::OutputArg", "ARC", "16", "4", "ARC", "4", "1", "4", "0", "\"Can't return value from vararg function in memory\"", "MVT::i32", "ISD::TokenFactor", "MVT::Other", "0", "1", "0", "ARCISD::RET", "MVT::Other" ]

[]

[ "<s>", "void", "XCoreFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "RS", "&&", "\"requiresRegisterScavenging failed\"", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "&", "XCore", "::", "GRRegsRegClass", ";", "XCoreFunctionInfo", "*", "XFI", "=", "MF", ".", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "if", "(", "XFI", "->", "isLargeFrame", "(", "MF", ")", "||", "hasFP", "(", "MF", ")", ")", "RS", "->", "addScavengingFrameIndex", "(", "MFI", "->", "CreateStackObject", "(", "RC", "->", "getSize", "(", ")", ",", "RC", "->", "getAlignment", "(", ")", ",", "false", ")", ")", ";", "if", "(", "XFI", "->", "isLargeFrame", "(", "MF", ")", "&&", "!", "hasFP", "(", "MF", ")", ")", "RS", "->", "addScavengingFrameIndex", "(", "MFI", "->", "CreateStackObject", "(", "RC", "->", "getSize", "(", ")", ",", "RC", "->", "getAlignment", "(", ")", ",", "false", ")", ")", ";", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "XCore", "XCore", "\"requiresRegisterScavenging failed\"", "XCore::GRRegsRegClass", "XCore", "XCore" ]

[]

[ "<s>", "static", "bool", "aarch64_output_addr_const_extra", "(", "FILE", "*", "file", ",", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_SALT_ADDR", ")", "{", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA", "." ]

[ "aarch64", "1", "0", "0" ]

[]

[ "<s>", "static", "bool", "sh_can_follow_jump", "(", "const", "rtx_insn", "*", "branch1", ",", "const", "rtx_insn", "*", "branch2", ")", "{", "if", "(", "TARGET_SH1", "&&", "flag_reorder_blocks_and_partition", "&&", "simplejump_p", "(", "branch2", ")", "&&", "CROSSING_JUMP_P", "(", "branch2", ")", ")", "return", "false", ";", "if", "(", "flag_expensive_optimizations", "&&", "simplejump_p", "(", "branch2", ")", ")", "{", "rtx", "dest", "=", "XEXP", "(", "SET_SRC", "(", "single_set", "(", "branch2", ")", ")", ",", "0", ")", ";", "rtx_insn", "*", "insn", ";", "int", "distance", ";", "for", "(", "distance", "=", "0", ",", "insn", "=", "NEXT_INSN", "(", "branch1", ")", ";", "insn", "&&", "distance", "<", "256", ";", "insn", "=", "PREV_INSN", "(", "insn", ")", ")", "{", "if", "(", "insn", "==", "dest", ")", "return", "true", ";", "else", "distance", "+=", "get_attr_length", "(", "insn", ")", ";", "}", "for", "(", "distance", "=", "0", ",", "insn", "=", "NEXT_INSN", "(", "branch1", ")", ";", "insn", "&&", "distance", "<", "256", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "insn", "==", "dest", ")", "return", "true", ";", "else", "distance", "+=", "get_attr_length", "(", "insn", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "possible", "to", "redirect", "BRANCH1", "to", "the", "destination", "of", "an", "unconditional", "jump", "BRANCH2", ".", "We", "only", "want", "to", "do", "this", "if", "the", "resulting", "branch", "will", "have", "a", "short", "displacement", "." ]

[ "sh", "0", "0", "256", "0", "256" ]

[]

[ "<s>", "int", "lm32_can_use_return", "(", "void", ")", "{", "if", "(", "!", "reload_completed", ")", "return", "0", ";", "if", "(", "df_regs_ever_live_p", "(", "RA_REGNUM", ")", "||", "crtl", "->", "profile", ")", "return", "0", ";", "if", "(", "lm32_compute_frame_size", "(", "get_frame_size", "(", ")", ")", "!=", "0", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "this", "function", "is", "known", "to", "have", "a", "null", "epilogue", ".", "This", "allows", "the", "optimizer", "to", "omit", "jumps", "to", "jumps", "if", "no", "stack", "was", "created", "." ]

[ "lm32", "0", "0", "0", "0", "1" ]

[]

[ "<s>", "static", "const", "char", "*", "gen_prefix", "(", "tree", "decl", ")", "{", "if", "(", "DECL_ONE_ONLY", "(", "decl", ")", ")", "return", "NULL", ";", "if", "(", "has_attr", "(", "\"section\"", ",", "decl", ")", ")", "return", "NULL", ";", "if", "(", "has_attr", "(", "ATTR_LOWER", ",", "decl", ")", ")", "return", "lower_prefix", ";", "if", "(", "!", "msp430x", ")", "return", "NULL", ";", "if", "(", "has_attr", "(", "ATTR_UPPER", ",", "decl", ")", ")", "return", "upper_prefix", ";", "if", "(", "has_attr", "(", "ATTR_EITHER", ",", "decl", ")", ")", "return", "either_prefix", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "{", "if", "(", "msp430_code_region", "==", "MSP430_REGION_LOWER", ")", "return", "lower_prefix", ";", "if", "(", "msp430_code_region", "==", "MSP430_REGION_UPPER", ")", "return", "upper_prefix", ";", "if", "(", "msp430_code_region", "==", "MSP430_REGION_EITHER", ")", "return", "either_prefix", ";", "}", "else", "{", "if", "(", "msp430_data_region", "==", "MSP430_REGION_LOWER", ")", "return", "lower_prefix", ";", "if", "(", "msp430_data_region", "==", "MSP430_REGION_UPPER", ")", "return", "upper_prefix", ";", "if", "(", "msp430_data_region", "==", "MSP430_REGION_EITHER", ")", "return", "either_prefix", ";", "}", "return", "NULL", ";", "}", "</s>" ]

[ "Generate", "a", "prefix", "for", "a", "section", "name", ",", "based", "upon", "the", "region", "into", "which", "the", "object", "should", "be", "placed", "." ]

[ "msp430", "\"section\"" ]

[]

[ "<s>", "void", "clear", "(", ")", "{", "Chain", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "Clear", "all", "timers", "in", "this", "group", "." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "unsigned", "int", "insn_is_load_p", "(", "rtx", "insn", ")", "{", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "body", ")", "==", "SET", ")", "{", "if", "(", "MEM_P", "(", "SET_SRC", "(", "body", ")", ")", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "body", ")", ")", "==", "VEC_SELECT", "&&", "MEM_P", "(", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ")", ")", "return", "1", ";", "if", "(", "pattern_is_rotate64", "(", "body", ")", "&&", "MEM_P", "(", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ")", ")", "return", "1", ";", "return", "0", ";", "}", "if", "(", "GET_CODE", "(", "body", ")", "!=", "PARALLEL", ")", "return", "0", ";", "rtx", "set", "=", "XVECEXP", "(", "body", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "set", ")", "==", "SET", "&&", "MEM_P", "(", "SET_SRC", "(", "set", ")", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "iff", "INSN", "is", "a", "load", "insn", ",", "including", "permuting", "loads", "that", "represent", "an", "lvxd2x", "instruction", ";", "else", "return", "0", "." ]

[ "rs6000", "1", "0", "1", "0", "1", "0", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "void", "mips_output_external", "(", "FILE", "*", "file", ",", "tree", "decl", ",", "const", "char", "*", "name", ")", "{", "default_elf_asm_output_external", "(", "file", ",", "decl", ",", "name", ")", ";", "if", "(", "TREE_SYMBOL_REFERENCED", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ")", "{", "if", "(", "!", "TARGET_EXPLICIT_RELOCS", "&&", "mips_in_small_data_p", "(", "decl", ")", ")", "{", "fputs", "(", "\"\\t.extern\\t\"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\", \"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "int_size_in_bytes", "(", "TREE_TYPE", "(", "decl", ")", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "When", "using", "assembler", "macros", ",", "keep", "track", "of", "all", "of", "small-data", "externs", "so", "that", "mips_file_end", "can", "emit", "the", "appropriate", "declarations", "for", "them", ".", "In", "most", "cases", "it", "would", "be", "safe", "(", "though", "pointless", ")", "to", "emit", ".externs", "for", "other", "symbols", "too", ".", "One", "exception", "is", "when", "an", "object", "is", "within", "the", "-G", "limit", "but", "declared", "by", "the", "user", "to", "be", "in", "a", "section", "other", "than", ".sbss", "or", ".sdata", "." ]

[ "mips", "\"\\t.extern\\t\"", "\", \"", "\"\\n\"" ]

[]

[ "<s>", "Value", "*", "ARMTargetLowering", "::", "emitStoreConditional", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "Value", "*", "Val", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "bool", "IsRelease", "=", "Ord", "==", "Release", "||", "Ord", "==", "AcquireRelease", "||", "Ord", "==", "SequentiallyConsistent", ";", "if", "(", "Val", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", "==", "64", ")", "{", "Intrinsic", "::", "ID", "Int", "=", "IsRelease", "?", "Intrinsic", "::", "arm_stlexd", ":", "Intrinsic", "::", "arm_strexd", ";", "Function", "*", "Strex", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ")", ";", "Type", "*", "Int32Ty", "=", "Type", "::", "getInt32Ty", "(", "M", "->", "getContext", "(", ")", ")", ";", "Value", "*", "Lo", "=", "Builder", ".", "CreateTrunc", "(", "Val", ",", "Int32Ty", ",", "\"lo\"", ")", ";", "Value", "*", "Hi", "=", "Builder", ".", "CreateTrunc", "(", "Builder", ".", "CreateLShr", "(", "Val", ",", "32", ")", ",", "Int32Ty", ",", "\"hi\"", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "Type", "::", "getInt8PtrTy", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "return", "Builder", ".", "CreateCall3", "(", "Strex", ",", "Lo", ",", "Hi", ",", "Addr", ")", ";", "}", "Intrinsic", "::", "ID", "Int", "=", "IsRelease", "?", "Intrinsic", "::", "arm_stlex", ":", "Intrinsic", "::", "arm_strex", ";", "Type", "*", "Tys", "[", "]", "=", "{", "Addr", "->", "getType", "(", ")", "}", ";", "Function", "*", "Strex", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ",", "Tys", ")", ";", "return", "Builder", ".", "CreateCall2", "(", "Strex", ",", "Builder", ".", "CreateZExtOrBitCast", "(", "Val", ",", "Strex", "->", "getFunctionType", "(", ")", "->", "getParamType", "(", "0", ")", ")", ",", "Addr", ")", ";", "}", "</s>" ]

[ "Perform", "a", "store-conditional", "operation", "to", "Addr", "." ]

[ "ARM", "ARM", "64", "Intrinsic::ID", "Intrinsic::arm_stlexd", "Intrinsic::arm_strexd", "Intrinsic::getDeclaration", "\"lo\"", "32", "\"hi\"", "Intrinsic::ID", "Intrinsic::arm_stlex", "Intrinsic::arm_strex", "Intrinsic::getDeclaration", "0" ]

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "isCheapToSpeculateCttz", "(", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "cheap", "to", "speculate", "a", "call", "to", "intrinsic", "cttz", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "void", "ARMAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ",", "IsPCRel", ",", "nullptr", ",", "IsLittleEndian", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "DataSize", "&&", "\"Invalid fixup offset!\"", ")", ";", "unsigned", "FullSizeBytes", ";", "if", "(", "!", "IsLittleEndian", ")", "FullSizeBytes", "=", "getFixupKindContainerSizeBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittleEndian", "?", "i", ":", "(", "FullSizeBytes", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "ARM", "ARM", "\"Invalid fixup offset!\"", "0", "1", "8", "0xff" ]

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "isTruncateFree", "(", "Type", "*", "Source", ",", "Type", "*", "Dest", ")", "const", "{", "return", "Dest", "->", "getPrimitiveSizeInBits", "(", ")", "<", "Source", "->", "getPrimitiveSizeInBits", "(", ")", "&&", "(", "Dest", "->", "getPrimitiveSizeInBits", "(", ")", "%", "32", "==", "0", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "free", "to", "truncate", "a", "value", "of", "type", "Ty1", "to", "type", "Ty2", "." ]

[ "R600", "32", "0" ]

[]

[ "<s>", "bool", "PPCPassConfig", "::", "addInstSelector", "(", ")", "{", "PM", "->", "add", "(", "createPPCISelDag", "(", "getPPCTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "PowerPC", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "static", "bool", "ix86_optab_supported_p", "(", "int", "op", ",", "machine_mode", "mode1", ",", "machine_mode", ",", "optimization_type", "opt_type", ")", "{", "switch", "(", "op", ")", "{", "case", "asin_optab", ":", "case", "acos_optab", ":", "case", "log1p_optab", ":", "case", "exp_optab", ":", "case", "exp10_optab", ":", "case", "exp2_optab", ":", "case", "expm1_optab", ":", "case", "ldexp_optab", ":", "case", "scalb_optab", ":", "case", "round_optab", ":", "return", "opt_type", "==", "OPTIMIZE_FOR_SPEED", ";", "case", "rint_optab", ":", "if", "(", "SSE_FLOAT_MODE_P", "(", "mode1", ")", "&&", "TARGET_SSE_MATH", "&&", "!", "flag_trapping_math", "&&", "!", "TARGET_ROUND", ")", "return", "opt_type", "==", "OPTIMIZE_FOR_SPEED", ";", "return", "true", ";", "case", "floor_optab", ":", "case", "ceil_optab", ":", "case", "btrunc_optab", ":", "if", "(", "SSE_FLOAT_MODE_P", "(", "mode1", ")", "&&", "TARGET_SSE_MATH", "&&", "!", "flag_trapping_math", "&&", "TARGET_ROUND", ")", "return", "true", ";", "return", "opt_type", "==", "OPTIMIZE_FOR_SPEED", ";", "case", "rsqrt_optab", ":", "return", "opt_type", "==", "OPTIMIZE_FOR_SPEED", "&&", "use_rsqrt_p", "(", ")", ";", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Implement", "the", "TARGET_OPTAB_SUPPORTED_P", "hook", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "SystemZ" ]

[]

[ "<s>", "unsigned", "XCoreInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "TBB", "&&", "\"insertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "2", "||", "Cond", ".", "size", "(", ")", "==", "0", ")", "&&", "\"Unexpected number of components!\"", ")", ";", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "if", "(", "!", "FBB", ")", "{", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "XCore", "::", "BRFU_lu6", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "}", "else", "{", "unsigned", "Opc", "=", "GetCondBranchFromCond", "(", "(", "XCore", "::", "CondCode", ")", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Cond", "[", "1", "]", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "}", "return", "1", ";", "}", "assert", "(", "Cond", ".", "size", "(", ")", "==", "2", "&&", "\"Unexpected number of components!\"", ")", ";", "unsigned", "Opc", "=", "GetCondBranchFromCond", "(", "(", "XCore", "::", "CondCode", ")", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Cond", "[", "1", "]", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "XCore", "::", "BRFU_lu6", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "return", "2", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "XCore", "XCore", "\"insertBranch must not be told to insert a fallthrough\"", "2", "0", "\"Unexpected number of components!\"", "\"code size not handled\"", "XCore::BRFU_lu6", "XCore::CondCode", "0", "1", "1", "2", "\"Unexpected number of components!\"", "XCore::CondCode", "0", "1", "XCore::BRFU_lu6", "2" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "SelectAddressRegReg", "(", "SDValue", "N", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Index", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "int16_t", "imm", "=", "0", ";", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", ")", "{", "if", "(", "isIntS16Immediate", "(", "N", ".", "getOperand", "(", "1", ")", ",", "imm", ")", ")", "return", "false", ";", "if", "(", "N", ".", "getOperand", "(", "1", ")", ".", "getOpcode", "(", ")", "==", "PPCISD", "::", "Lo", ")", "return", "false", ";", "Base", "=", "N", ".", "getOperand", "(", "0", ")", ";", "Index", "=", "N", ".", "getOperand", "(", "1", ")", ";", "return", "true", ";", "}", "else", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "OR", ")", "{", "if", "(", "isIntS16Immediate", "(", "N", ".", "getOperand", "(", "1", ")", ",", "imm", ")", ")", "return", "false", ";", "KnownBits", "LHSKnown", ",", "RHSKnown", ";", "DAG", ".", "computeKnownBits", "(", "N", ".", "getOperand", "(", "0", ")", ",", "LHSKnown", ")", ";", "if", "(", "LHSKnown", ".", "Zero", ".", "getBoolValue", "(", ")", ")", "{", "DAG", ".", "computeKnownBits", "(", "N", ".", "getOperand", "(", "1", ")", ",", "RHSKnown", ")", ";", "if", "(", "~", "(", "LHSKnown", ".", "Zero", "|", "RHSKnown", ".", "Zero", ")", "==", "0", ")", "{", "Base", "=", "N", ".", "getOperand", "(", "0", ")", ";", "Index", "=", "N", ".", "getOperand", "(", "1", ")", ";", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "SelectAddressRegReg", "-", "Given", "the", "specified", "addressed", ",", "check", "to", "see", "if", "it", "can", "be", "more", "efficiently", "represented", "as", "[", "r+imm", "]", "." ]

[ "PowerPC", "PPC", "0", "ISD::ADD", "1", "1", "PPCISD::Lo", "0", "1", "ISD::OR", "1", "0", "1", "0", "0", "1" ]

[]

[ "<s>", "unsigned", "SparcInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "TBB", "&&", "\"insertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "1", "||", "Cond", ".", "size", "(", ")", "==", "0", ")", "&&", "\"Sparc branch conditions should have one component!\"", ")", ";", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "assert", "(", "!", "FBB", "&&", "\"Unconditional branch with multiple successors!\"", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "SP", "::", "BA", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "unsigned", "CC", "=", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "if", "(", "IsIntegerCC", "(", "CC", ")", ")", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "SP", "::", "BCOND", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "addImm", "(", "CC", ")", ";", "else", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "SP", "::", "FBCOND", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "addImm", "(", "CC", ")", ";", "if", "(", "!", "FBB", ")", "return", "1", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "SP", "::", "BA", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "return", "2", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "Sparc", "Sparc", "\"insertBranch must not be told to insert a fallthrough\"", "1", "0", "\"Sparc branch conditions should have one component!\"", "\"code size not handled\"", "\"Unconditional branch with multiple successors!\"", "SP::BA", "1", "0", "SP::BCOND", "SP::FBCOND", "1", "SP::BA", "2" ]

[]

[ "<s>", "void", "NVPTXAsmPrinter", "::", "emitHeader", "(", "Module", "&", "M", ",", "raw_ostream", "&", "O", ")", "{", "O", "<<", "\"//\\n\"", ";", "O", "<<", "\"// Generated by LLVM NVPTX Back-End\\n\"", ";", "O", "<<", "\"//\\n\"", ";", "O", "<<", "\"\\n\"", ";", "O", "<<", "\".version 3.0\\n\"", ";", "O", "<<", "\".target \"", ";", "O", "<<", "nvptxSubtarget", ".", "getTargetName", "(", ")", ";", "if", "(", "nvptxSubtarget", ".", "getDrvInterface", "(", ")", "==", "NVPTX", "::", "NVCL", ")", "O", "<<", "\", texmode_independent\"", ";", "if", "(", "nvptxSubtarget", ".", "getDrvInterface", "(", ")", "==", "NVPTX", "::", "CUDA", ")", "{", "if", "(", "!", "nvptxSubtarget", ".", "hasDouble", "(", ")", ")", "O", "<<", "\", map_f64_to_f32\"", ";", "}", "if", "(", "MAI", "->", "doesSupportDebugInformation", "(", ")", ")", "O", "<<", "\", debug\"", ";", "O", "<<", "\"\\n\"", ";", "O", "<<", "\".address_size \"", ";", "if", "(", "nvptxSubtarget", ".", "is64Bit", "(", ")", ")", "O", "<<", "\"64\"", ";", "else", "O", "<<", "\"32\"", ";", "O", "<<", "\"\\n\"", ";", "O", "<<", "\"\\n\"", ";", "}", "</s>" ]

[ "Emit", "the", "header", "for", "this", "unit", ",", "not", "including", "the", "initial", "length", "field", "." ]

[ "NVPTX", "NVPTX", "\"//\\n\"", "\"// Generated by LLVM NVPTX Back-End\\n\"", "\"//\\n\"", "\"\\n\"", "\".version 3.0\\n\"", "\".target \"", "NVPTX::NVCL", "\", texmode_independent\"", "NVPTX::CUDA", "\", map_f64_to_f32\"", "\", debug\"", "\"\\n\"", "\".address_size \"", "\"64\"", "\"32\"", "\"\\n\"", "\"\\n\"" ]

[]

[ "<s>", "MCSection", "*", "getSectionForConstant", "(", "const", "DataLayout", "&", "DL", ",", "SectionKind", "Kind", ",", "const", "Constant", "*", "C", ")", "const", "override", "{", "return", "ReadOnlySection", ";", "}", "</s>" ]

[ "Given", "a", "constant", "with", "the", "SectionKind", ",", "return", "a", "section", "that", "it", "should", "be", "placed", "in", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "Register", "OutgoingValueHandler", "::", "extendRegister", "(", "Register", "ValReg", ",", "const", "CCValAssign", "&", "VA", ")", "{", "LLT", "LocTy", "{", "VA", ".", "getLocVT", "(", ")", "}", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "case", "CCValAssign", "::", "SExt", ":", "{", "Register", "ExtReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "LocTy", ")", ";", "MIRBuilder", ".", "buildSExt", "(", "ExtReg", ",", "ValReg", ")", ";", "return", "ExtReg", ";", "}", "case", "CCValAssign", "::", "ZExt", ":", "{", "Register", "ExtReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "LocTy", ")", ";", "MIRBuilder", ".", "buildZExt", "(", "ExtReg", ",", "ValReg", ")", ";", "return", "ExtReg", ";", "}", "case", "CCValAssign", "::", "AExt", ":", "{", "Register", "ExtReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "LocTy", ")", ";", "MIRBuilder", ".", "buildAnyExt", "(", "ExtReg", ",", "ValReg", ")", ";", "return", "ExtReg", ";", "}", "case", "CCValAssign", "::", "Full", ":", "return", "ValReg", ";", "default", ":", "break", ";", "}", "llvm_unreachable", "(", "\"unable to extend register\"", ")", ";", "}", "</s>" ]

[ "Extend", "a", "register", "to", "the", "location", "type", "given", "in", "VA", ",", "capped", "at", "extending", "to", "at", "most", "MaxSize", "bits", "." ]

[ "Mips", "\"unable to extend register\"" ]

[]

[ "<s>", "Optional", "<", "Value", "*", ">", "GCNTTIImpl", "::", "simplifyDemandedVectorEltsIntrinsic", "(", "InstCombiner", "&", "IC", ",", "IntrinsicInst", "&", "II", ",", "APInt", "DemandedElts", ",", "APInt", "&", "UndefElts", ",", "APInt", "&", "UndefElts2", ",", "APInt", "&", "UndefElts3", ",", "std", "::", "function", "<", "void", "(", "Instruction", "*", ",", "unsigned", ",", "APInt", ",", "APInt", "&", ")", ">", "SimplifyAndSetOp", ")", "const", "{", "switch", "(", "II", ".", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "amdgcn_buffer_load", ":", "case", "Intrinsic", "::", "amdgcn_buffer_load_format", ":", "case", "Intrinsic", "::", "amdgcn_raw_buffer_load", ":", "case", "Intrinsic", "::", "amdgcn_raw_buffer_load_format", ":", "case", "Intrinsic", "::", "amdgcn_raw_tbuffer_load", ":", "case", "Intrinsic", "::", "amdgcn_s_buffer_load", ":", "case", "Intrinsic", "::", "amdgcn_struct_buffer_load", ":", "case", "Intrinsic", "::", "amdgcn_struct_buffer_load_format", ":", "case", "Intrinsic", "::", "amdgcn_struct_tbuffer_load", ":", "case", "Intrinsic", "::", "amdgcn_tbuffer_load", ":", "return", "simplifyAMDGCNMemoryIntrinsicDemanded", "(", "IC", ",", "II", ",", "DemandedElts", ")", ";", "default", ":", "{", "if", "(", "getAMDGPUImageDMaskIntrinsic", "(", "II", ".", "getIntrinsicID", "(", ")", ")", ")", "{", "return", "simplifyAMDGCNMemoryIntrinsicDemanded", "(", "IC", ",", "II", ",", "DemandedElts", ",", "0", ")", ";", "}", "break", ";", "}", "}", "return", "None", ";", "}", "</s>" ]

[ "Can", "be", "used", "to", "implement", "target-specific", "instruction", "combining", "." ]

[ "AMDGPU", "Intrinsic::amdgcn_buffer_load", "Intrinsic::amdgcn_buffer_load_format", "Intrinsic::amdgcn_raw_buffer_load", "Intrinsic::amdgcn_raw_buffer_load_format", "Intrinsic::amdgcn_raw_tbuffer_load", "Intrinsic::amdgcn_s_buffer_load", "Intrinsic::amdgcn_struct_buffer_load", "Intrinsic::amdgcn_struct_buffer_load_format", "Intrinsic::amdgcn_struct_tbuffer_load", "Intrinsic::amdgcn_tbuffer_load", "AMDGPU", "0" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isFPRCopy", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "TargetOpcode", "::", "COPY", ":", "{", "unsigned", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "return", "(", "AArch64", "::", "FPR64RegClass", ".", "contains", "(", "DstReg", ")", "||", "AArch64", "::", "FPR128RegClass", ".", "contains", "(", "DstReg", ")", ")", ";", "}", "case", "AArch64", "::", "ORRv16i8", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", "{", "assert", "(", "MI", ".", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", "==", "3", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", "&&", "\"invalid ORRv16i8 operands\"", ")", ";", "return", "true", ";", "}", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Does", "this", "instruction", "rename", "an", "FPR", "without", "modifying", "bits", "?" ]

[ "AArch64", "AArch64", "0", "AArch64::FPR64RegClass", "AArch64::FPR128RegClass", "AArch64::ORRv16i8", "1", "2", "3", "0", "\"invalid ORRv16i8 operands\"" ]

[]

[ "<s>", "bool", "ARMCodeEmitter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "assert", "(", "(", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Default", "||", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Static", ")", "&&", "\"JIT relocation model must be set to static or default!\"", ")", ";", "JTI", "=", "(", "(", "ARMBaseTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getJITInfo", "(", ")", ";", "II", "=", "(", "const", "ARMBaseInstrInfo", "*", ")", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TD", "=", "MF", ".", "getTarget", "(", ")", ".", "getTargetData", "(", ")", ";", "Subtarget", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "MCPEs", "=", "&", "MF", ".", "getConstantPool", "(", ")", "->", "getConstants", "(", ")", ";", "MJTEs", "=", "0", ";", "if", "(", "MF", ".", "getJumpTableInfo", "(", ")", ")", "MJTEs", "=", "&", "MF", ".", "getJumpTableInfo", "(", ")", "->", "getJumpTables", "(", ")", ";", "IsPIC", "=", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ";", "IsThumb", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", "->", "isThumbFunction", "(", ")", ";", "JTI", "->", "Initialize", "(", "MF", ",", "IsPIC", ")", ";", "MMI", "=", "&", "getAnalysis", "<", "MachineModuleInfo", ">", "(", ")", ";", "MCE", ".", "setModuleInfo", "(", "MMI", ")", ";", "do", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"JITTing function '\"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"'\\n\"", ")", ";", "MCE", ".", "startFunction", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MBB", "!=", "E", ";", "++", "MBB", ")", "{", "MCE", ".", "StartMachineBasicBlock", "(", "MBB", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", "->", "begin", "(", ")", ",", "E", "=", "MBB", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "emitInstruction", "(", "*", "I", ")", ";", "}", "}", "while", "(", "MCE", ".", "finishFunction", "(", "MF", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "ARM", "ARM", "\"JIT relocation model must be set to static or default!\"", "ARM", "ARM", "ARM", "0", "ARM", "\"JITTing function '\"", "\"'\\n\"" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "SystemZRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "MCPhysReg", "CalleeSavedRegs", "[", "]", "=", "{", "SystemZ", "::", "R6D", ",", "SystemZ", "::", "R7D", ",", "SystemZ", "::", "R8D", ",", "SystemZ", "::", "R9D", ",", "SystemZ", "::", "R10D", ",", "SystemZ", "::", "R11D", ",", "SystemZ", "::", "R12D", ",", "SystemZ", "::", "R13D", ",", "SystemZ", "::", "R14D", ",", "SystemZ", "::", "R15D", ",", "SystemZ", "::", "F8D", ",", "SystemZ", "::", "F9D", ",", "SystemZ", "::", "F10D", ",", "SystemZ", "::", "F11D", ",", "SystemZ", "::", "F12D", ",", "SystemZ", "::", "F13D", ",", "SystemZ", "::", "F14D", ",", "SystemZ", "::", "F15D", ",", "0", "}", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "SystemZ", "SystemZ", "SystemZ::R6D", "SystemZ::R7D", "SystemZ::R8D", "SystemZ::R9D", "SystemZ::R10D", "SystemZ::R11D", "SystemZ::R12D", "SystemZ::R13D", "SystemZ::R14D", "SystemZ::R15D", "SystemZ::F8D", "SystemZ::F9D", "SystemZ::F10D", "SystemZ::F11D", "SystemZ::F12D", "SystemZ::F13D", "SystemZ::F14D", "SystemZ::F15D", "0" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isAsCheapAsAMove", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "hasCustomCheapAsMoveHandling", "(", ")", ")", "return", "MI", ".", "isAsCheapAsAMove", "(", ")", ";", "if", "(", "Subtarget", ".", "hasExynosCheapAsMoveHandling", "(", ")", ")", "{", "if", "(", "isExynosResetFast", "(", "MI", ")", "||", "isExynosShiftLeftFast", "(", "MI", ")", ")", "return", "true", ";", "else", "return", "MI", ".", "isAsCheapAsAMove", "(", ")", ";", "}", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "AArch64", "::", "ADDWri", ":", "case", "AArch64", "::", "ADDXri", ":", "case", "AArch64", "::", "SUBWri", ":", "case", "AArch64", "::", "SUBXri", ":", "return", "(", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", ")", ";", "case", "AArch64", "::", "ANDWri", ":", "case", "AArch64", "::", "ANDXri", ":", "case", "AArch64", "::", "EORWri", ":", "case", "AArch64", "::", "EORXri", ":", "case", "AArch64", "::", "ORRWri", ":", "case", "AArch64", "::", "ORRXri", ":", "return", "true", ";", "case", "AArch64", "::", "ANDWrr", ":", "case", "AArch64", "::", "ANDXrr", ":", "case", "AArch64", "::", "BICWrr", ":", "case", "AArch64", "::", "BICXrr", ":", "case", "AArch64", "::", "EONWrr", ":", "case", "AArch64", "::", "EONXrr", ":", "case", "AArch64", "::", "EORWrr", ":", "case", "AArch64", "::", "EORXrr", ":", "case", "AArch64", "::", "ORNWrr", ":", "case", "AArch64", "::", "ORNXrr", ":", "case", "AArch64", "::", "ORRWrr", ":", "case", "AArch64", "::", "ORRXrr", ":", "return", "true", ";", "case", "AArch64", "::", "MOVi32imm", ":", "return", "canBeExpandedToORR", "(", "MI", ",", "32", ")", ";", "case", "AArch64", "::", "MOVi64imm", ":", "return", "canBeExpandedToORR", "(", "MI", ",", "64", ")", ";", "case", "AArch64", "::", "FMOVH0", ":", "case", "AArch64", "::", "FMOVS0", ":", "case", "AArch64", "::", "FMOVD0", ":", "return", "Subtarget", ".", "hasZeroCycleZeroing", "(", ")", ";", "case", "TargetOpcode", "::", "COPY", ":", "return", "(", "Subtarget", ".", "hasZeroCycleZeroing", "(", ")", "&&", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "AArch64", "::", "WZR", "||", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "AArch64", "::", "XZR", ")", ")", ";", "}", "llvm_unreachable", "(", "\"Unknown opcode to check as cheap as a move!\"", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "is", "as", "cheap", "as", "a", "move", "instruction", "." ]

[ "AArch64", "AArch64", "AArch64::ADDWri", "AArch64::ADDXri", "AArch64::SUBWri", "AArch64::SUBXri", "3", "0", "AArch64::ANDWri", "AArch64::ANDXri", "AArch64::EORWri", "AArch64::EORXri", "AArch64::ORRWri", "AArch64::ORRXri", "AArch64::ANDWrr", "AArch64::ANDXrr", "AArch64::BICWrr", "AArch64::BICXrr", "AArch64::EONWrr", "AArch64::EONXrr", "AArch64::EORWrr", "AArch64::EORXrr", "AArch64::ORNWrr", "AArch64::ORNXrr", "AArch64::ORRWrr", "AArch64::ORRXrr", "AArch64::MOVi32imm", "32", "AArch64::MOVi64imm", "64", "AArch64::FMOVH0", "AArch64::FMOVS0", "AArch64::FMOVD0", "1", "AArch64::WZR", "1", "AArch64::XZR", "\"Unknown opcode to check as cheap as a move!\"" ]

[]

[ "<s>", "static", "inline", "tree", "def_builtin", "(", "HOST_WIDE_INT", "mask", ",", "const", "char", "*", "name", ",", "enum", "ix86_builtin_func_type", "tcode", ",", "enum", "ix86_builtins", "code", ")", "{", "tree", "decl", "=", "NULL_TREE", ";", "if", "(", "!", "(", "mask", "&", "OPTION_MASK_ISA_64BIT", ")", "||", "TARGET_64BIT", ")", "{", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "isa", "=", "mask", ";", "mask", "&=", "~", "OPTION_MASK_ISA_64BIT", ";", "if", "(", "(", "mask", "&", "ix86_isa_flags", "&", "OPTION_MASK_ISA_AVX512VL", ")", "&&", "mask", "!=", "OPTION_MASK_ISA_AVX512VL", ")", "mask", "&=", "~", "OPTION_MASK_ISA_AVX512VL", ";", "if", "(", "(", "mask", "&", "ix86_isa_flags", "&", "OPTION_MASK_ISA_AVX512BW", ")", "&&", "mask", "!=", "OPTION_MASK_ISA_AVX512BW", ")", "mask", "&=", "~", "OPTION_MASK_ISA_AVX512BW", ";", "if", "(", "mask", "==", "0", "||", "(", "mask", "&", "ix86_isa_flags", ")", "!=", "0", "||", "(", "lang_hooks", ".", "builtin_function", "==", "lang_hooks", ".", "builtin_function_ext_scope", ")", ")", "{", "tree", "type", "=", "ix86_get_builtin_func_type", "(", "tcode", ")", ";", "decl", "=", "add_builtin_function", "(", "name", ",", "type", ",", "code", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "ix86_builtins", "[", "(", "int", ")", "code", "]", "=", "decl", ";", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "set_and_not_built_p", "=", "false", ";", "}", "else", "{", "deferred_isa_values", "|=", "mask", ";", "ix86_builtins", "[", "(", "int", ")", "code", "]", "=", "NULL_TREE", ";", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "tcode", "=", "tcode", ";", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "name", "=", "name", ";", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "leaf_p", "=", "false", ";", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "nothrow_p", "=", "false", ";", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "const_p", "=", "false", ";", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "pure_p", "=", "false", ";", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "set_and_not_built_p", "=", "true", ";", "}", "}", "return", "decl", ";", "}", "</s>" ]

[ "Add", "a", "SPARC", "builtin", "function", "with", "NAME", ",", "ICODE", ",", "CODE", "and", "TYPE", ".", "Return", "the", "function", "decl", "or", "NULL_TREE", "if", "the", "builtin", "was", "not", "added", "." ]

[ "i386", "0", "0" ]

[]

[ "<s>", "unsigned", "JVMInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "unsigned", "Count", "=", "0", ";", "for", "(", "auto", "ritr", "=", "MBB", ".", "instr_rbegin", "(", ")", ";", "ritr", "!=", "MBB", ".", "instr_rend", "(", ")", ";", "ritr", "++", ")", "{", "MachineInstr", "&", "MI", "=", "*", "ritr", ";", "if", "(", "!", "MI", ".", "isBranch", "(", ")", ")", "break", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "Count", "++", ";", "}", "return", "Count", ";", "}", "</s>" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "JVM", "JVM", "0" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "get_csky_jump_table_size", "(", "rtx", "insn", ")", "{", "if", "(", "JUMP_TABLES_IN_TEXT_SECTION", "||", "readonly_data_section", "==", "text_section", ")", "{", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "int", "elt", "=", "GET_CODE", "(", "body", ")", "==", "ADDR_DIFF_VEC", "?", "1", ":", "0", ";", "HOST_WIDE_INT", "size", ";", "HOST_WIDE_INT", "modesize", ";", "modesize", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "body", ")", ")", ";", "size", "=", "modesize", "*", "XVECLEN", "(", "body", ",", "elt", ")", ";", "switch", "(", "modesize", ")", "{", "case", "1", ":", "size", "=", "(", "size", "+", "1", ")", "&", "~", "(", "HOST_WIDE_INT", ")", "1", ";", "break", ";", "case", "2", ":", "break", ";", "case", "4", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "size", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Compute", "the", "size", "of", "a", "vector", "jump", "table", "." ]

[ "csky", "1", "0", "1", "1", "1", "2", "4", "0" ]

[]

[ "<s>", "MVT", "::", "SimpleValueType", "MBlazeTargetLowering", "::", "getSetCCResultType", "(", "EVT", "VT", ")", "const", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "MBlaze", "MVT::SimpleValueType", "MBlaze", "MVT::i32" ]

[]

[ "<s>", "const", "MCExpr", "*", "AArch64_MachoTargetObjectFile", "::", "getTTypeGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "unsigned", "Encoding", ",", "const", "TargetMachine", "&", "TM", ",", "MachineModuleInfo", "*", "MMI", ",", "MCStreamer", "&", "Streamer", ")", "const", "{", "if", "(", "Encoding", "&", "(", "DW_EH_PE_indirect", "|", "DW_EH_PE_pcrel", ")", ")", "{", "const", "MCSymbol", "*", "Sym", "=", "TM", ".", "getSymbol", "(", "GV", ")", ";", "const", "MCExpr", "*", "Res", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "MCSymbolRefExpr", "::", "VK_GOT", ",", "getContext", "(", ")", ")", ";", "MCSymbol", "*", "PCSym", "=", "getContext", "(", ")", ".", "createTempSymbol", "(", ")", ";", "Streamer", ".", "EmitLabel", "(", "PCSym", ")", ";", "const", "MCExpr", "*", "PC", "=", "MCSymbolRefExpr", "::", "create", "(", "PCSym", ",", "getContext", "(", ")", ")", ";", "return", "MCBinaryExpr", "::", "createSub", "(", "Res", ",", "PC", ",", "getContext", "(", ")", ")", ";", "}", "return", "TargetLoweringObjectFileMachO", "::", "getTTypeGlobalReference", "(", "GV", ",", "Encoding", ",", "TM", ",", "MMI", ",", "Streamer", ")", ";", "}", "</s>" ]

[ "The", "mach-o", "version", "of", "this", "method", "defaults", "to", "returning", "a", "stub", "reference", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "SIRegisterInfo", "::", "requiresFrameIndexReplacementScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "MF", ".", "getFrameInfo", "(", ")", ".", "hasStackObjects", "(", ")", "&&", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ".", "hasScalarStores", "(", ")", "&&", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", "->", "hasSpilledSGPRs", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "requires", "using", "the", "RegScavenger", "directly", "for", "frame", "elimination", "despite", "using", "requiresFrameIndexScavenging", "." ]

[ "AMDGPU", "SI", "SI" ]

[]

[ "<s>", "void", "X86AsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "X86MCInstLower", "MCInstLowering", "(", "Mang", ",", "*", "MF", ",", "*", "this", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "if", "(", "isVerbose", "(", ")", "&&", "OutStreamer", ".", "hasRawTextSupport", "(", ")", ")", "{", "std", "::", "string", "TmpStr", ";", "raw_string_ostream", "OS", "(", "TmpStr", ")", ";", "PrintDebugValueComment", "(", "MI", ",", "OS", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "OS", ".", "str", "(", ")", ")", ")", ";", "}", "return", ";", "case", "X86", "::", "Int_MemBarrier", ":", "if", "(", "OutStreamer", ".", "hasRawTextSupport", "(", ")", ")", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "\"\\t#MEMBARRIER\"", ")", ")", ";", "return", ";", "case", "X86", "::", "EH_RETURN", ":", "case", "X86", "::", "EH_RETURN64", ":", "{", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "OutStreamer", ".", "AddComment", "(", "StringRef", "(", "\"eh_return, addr: %\"", ")", "+", "X86ATTInstPrinter", "::", "getRegisterName", "(", "Reg", ")", ")", ";", "break", ";", "}", "case", "X86", "::", "TAILJMPr", ":", "case", "X86", "::", "TAILJMPd", ":", "case", "X86", "::", "TAILJMPd64", ":", "OutStreamer", ".", "AddComment", "(", "\"TAILCALL\"", ")", ";", "break", ";", "case", "X86", "::", "TLS_addr32", ":", "case", "X86", "::", "TLS_addr64", ":", "case", "X86", "::", "TLS_base_addr32", ":", "case", "X86", "::", "TLS_base_addr64", ":", "return", "LowerTlsAddr", "(", "OutStreamer", ",", "MCInstLowering", ",", "*", "MI", ")", ";", "case", "X86", "::", "MOVPC32r", ":", "{", "MCSymbol", "*", "PICBase", "=", "MF", "->", "getPICBaseSymbol", "(", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "MCInstBuilder", "(", "X86", "::", "CALLpcrel32", ")", ".", "addExpr", "(", "MCSymbolRefExpr", "::", "Create", "(", "PICBase", ",", "OutContext", ")", ")", ")", ";", "OutStreamer", ".", "EmitLabel", "(", "PICBase", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "MCInstBuilder", "(", "X86", "::", "POP32r", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", ";", "return", ";", "}", "case", "X86", "::", "ADD32ri", ":", "{", "if", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getTargetFlags", "(", ")", "!=", "X86II", "::", "MO_GOT_ABSOLUTE_ADDRESS", ")", "break", ";", "MCSymbol", "*", "DotSym", "=", "OutContext", ".", "CreateTempSymbol", "(", ")", ";", "OutStreamer", ".", "EmitLabel", "(", "DotSym", ")", ";", "MCSymbol", "*", "OpSym", "=", "MCInstLowering", ".", "GetSymbolFromOperand", "(", "MI", "->", "getOperand", "(", "2", ")", ")", ";", "const", "MCExpr", "*", "DotExpr", "=", "MCSymbolRefExpr", "::", "Create", "(", "DotSym", ",", "OutContext", ")", ";", "const", "MCExpr", "*", "PICBase", "=", "MCSymbolRefExpr", "::", "Create", "(", "MF", "->", "getPICBaseSymbol", "(", ")", ",", "OutContext", ")", ";", "DotExpr", "=", "MCBinaryExpr", "::", "CreateSub", "(", "DotExpr", ",", "PICBase", ",", "OutContext", ")", ";", "DotExpr", "=", "MCBinaryExpr", "::", "CreateAdd", "(", "MCSymbolRefExpr", "::", "Create", "(", "OpSym", ",", "OutContext", ")", ",", "DotExpr", ",", "OutContext", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "MCInstBuilder", "(", "X86", "::", "ADD32ri", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addExpr", "(", "DotExpr", ")", ")", ";", "return", ";", "}", "}", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst", ")", ";", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "X86", "X86", "X86", "X86::Int_MemBarrier", "\"\\t#MEMBARRIER\"", "X86::EH_RETURN", "X86::EH_RETURN64", "0", "\"eh_return, addr: %\"", "X86", "X86::TAILJMPr", "X86::TAILJMPd", "X86::TAILJMPd64", "\"TAILCALL\"", "X86::TLS_addr32", "X86::TLS_addr64", "X86::TLS_base_addr32", "X86::TLS_base_addr64", "X86::MOVPC32r", "X86::CALLpcrel32", "X86::POP32r", "0", "X86::ADD32ri", "2", "X86II::MO_GOT_ABSOLUTE_ADDRESS", "2", "X86::ADD32ri", "0", "1" ]

[]

[ "<s>", "bool", "constant_address_p", "(", "rtx", "x", ")", "{", "return", "CONSTANT_P", "(", "x", ")", "&&", "legitimate_address_p", "(", "Pmode", ",", "x", ",", "1", ")", ";", "}", "</s>" ]

[ "Determine", "if", "a", "given", "RTX", "is", "a", "valid", "constant", "address", "." ]

[ "i386", "1" ]

[]

[ "<s>", "bool", "isToken", "(", ")", "const", "override", "{", "return", "Kind", "==", "k_Token", ";", "}", "</s>" ]

[ "isToken", "-", "Is", "this", "a", "token", "operand", "?" ]

[ "TL45" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 insert wait instruction\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "X86", "\"X86 insert wait instruction\"" ]

[]

[ "<s>", "void", "HexagonAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MCInst", "MCB", "=", "HexagonMCInstrInfo", "::", "createBundle", "(", ")", ";", "const", "MCInstrInfo", "&", "MCII", "=", "*", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "MII", "=", "MI", "->", "getIterator", "(", ")", ";", "for", "(", "++", "MII", ";", "MII", "!=", "MBB", "->", "instr_end", "(", ")", "&&", "MII", "->", "isInsideBundle", "(", ")", ";", "++", "MII", ")", "if", "(", "!", "MII", "->", "isDebugValue", "(", ")", "&&", "!", "MII", "->", "isImplicitDef", "(", ")", ")", "HexagonLowerToMC", "(", "MCII", ",", "&", "*", "MII", ",", "MCB", ",", "*", "this", ")", ";", "}", "else", "HexagonLowerToMC", "(", "MCII", ",", "MI", ",", "MCB", ",", "*", "this", ")", ";", "bool", "Ok", "=", "HexagonMCInstrInfo", "::", "canonicalizePacket", "(", "MCII", ",", "*", "Subtarget", ",", "OutStreamer", "->", "getContext", "(", ")", ",", "MCB", ",", "nullptr", ")", ";", "assert", "(", "Ok", ")", ";", "(", "void", ")", "Ok", ";", "if", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "MCB", ")", "==", "0", ")", "return", ";", "OutStreamer", "->", "EmitInstruction", "(", "MCB", ",", "getSubtargetInfo", "(", ")", ")", ";", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "0" ]

[]

[ "<s>", "static", "void", "mips_emit_loadgp", "(", "void", ")", "{", "if", "(", "TARGET_ABICALLS", "&&", "TARGET_NEWABI", "&&", "cfun", "->", "machine", "->", "global_pointer", ">", "0", ")", "{", "rtx", "addr", ",", "offset", ",", "incoming_address", ";", "addr", "=", "XEXP", "(", "DECL_RTL", "(", "current_function_decl", ")", ",", "0", ")", ";", "offset", "=", "mips_unspec_address", "(", "addr", ",", "SYMBOL_GOTOFF_LOADGP", ")", ";", "incoming_address", "=", "gen_rtx_REG", "(", "Pmode", ",", "PIC_FUNCTION_ADDR_REGNUM", ")", ";", "emit_insn", "(", "gen_loadgp", "(", "offset", ",", "incoming_address", ")", ")", ";", "if", "(", "!", "TARGET_EXPLICIT_RELOCS", ")", "emit_insn", "(", "gen_loadgp_blockage", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "If", "we", "'re", "generating", "n32", "or", "n64", "abicalls", ",", "emit", "instructions", "to", "set", "up", "the", "global", "pointer", "." ]

[ "mips", "0", "0" ]

[]

[ "<s>", "static", "bool", "flow_dependent_p", "(", "rtx_insn", "*", "insn", ",", "rtx_insn", "*", "dep_insn", ")", "{", "rtx", "tmp", "=", "PATTERN", "(", "insn", ")", ";", "note_stores", "(", "dep_insn", ",", "flow_dependent_p_1", ",", "&", "tmp", ")", ";", "return", "tmp", "==", "NULL_RTX", ";", "}", "</s>" ]

[ "Check", "if", "INSN", "is", "flow-dependent", "on", "DEP_INSN", ".", "Can", "also", "be", "used", "to", "check", "if", "DEP_INSN", "is", "anti-flow", "dependent", "on", "INSN", "." ]

[ "sh" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"PULP Hardware Loops\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "RI5CY", "\"PULP Hardware Loops\"" ]

[]

[ "<s>", "static", "void", "x86_print_call_or_nop", "(", "FILE", "*", "file", ",", "const", "char", "*", "target", ")", "{", "if", "(", "flag_nop_mcount", "||", "!", "strcmp", "(", "target", ",", "\"nop\"", ")", ")", "fprintf", "(", "file", ",", "\"1:\"", "ASM_BYTE", "\"0x0f, 0x1f, 0x44, 0x00, 0x00\\n\"", ")", ";", "else", "fprintf", "(", "file", ",", "\"1:\\tcall\\t%s\\n\"", ",", "target", ")", ";", "}", "</s>" ]

[ "Print", "call", "to", "TARGET", "to", "FILE", "." ]

[ "i386", "\"nop\"", "\"1:\"", "\"0x0f, 0x1f, 0x44, 0x00, 0x00\\n\"", "\"1:\\tcall\\t%s\\n\"" ]

[]

[ "<s>", "HOST_WIDE_INT", "ia64_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "HOST_WIDE_INT", "offset", ";", "ia64_compute_frame_size", "(", "get_frame_size", "(", ")", ")", ";", "switch", "(", "from", ")", "{", "case", "FRAME_POINTER_REGNUM", ":", "switch", "(", "to", ")", "{", "case", "HARD_FRAME_POINTER_REGNUM", ":", "if", "(", "current_function_is_leaf", ")", "offset", "=", "-", "current_frame_info", ".", "total_size", ";", "else", "offset", "=", "-", "(", "current_frame_info", ".", "total_size", "-", "current_function_outgoing_args_size", "-", "16", ")", ";", "break", ";", "case", "STACK_POINTER_REGNUM", ":", "if", "(", "current_function_is_leaf", ")", "offset", "=", "0", ";", "else", "offset", "=", "16", "+", "current_function_outgoing_args_size", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "ARG_POINTER_REGNUM", ":", "switch", "(", "to", ")", "{", "case", "HARD_FRAME_POINTER_REGNUM", ":", "offset", "=", "16", "-", "current_function_pretend_args_size", ";", "break", ";", "case", "STACK_POINTER_REGNUM", ":", "offset", "=", "(", "current_frame_info", ".", "total_size", "+", "16", "-", "current_function_pretend_args_size", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "offset", ";", "}", "</s>" ]

[ "Compute", "the", "initial", "difference", "between", "the", "specified", "pair", "of", "registers", "." ]

[ "ia64", "16", "0", "16", "16", "16" ]

[]

[ "<s>", "DecodeStatus", "ECLairDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "OS", ",", "raw_ostream", "&", "CS", ")", "const", "{", "DecodeStatus", "status", ";", "uint8_t", "opcode", "=", "support", "::", "endian", "::", "read", "<", "uint8_t", ",", "support", "::", "endianness", "::", "big", ">", "(", "Bytes", ".", "data", "(", ")", ")", ";", "uint16_t", "arg", "=", "support", "::", "endian", "::", "read16be", "(", "Bytes", ".", "data", "(", ")", "+", "1", ")", ";", "uint32_t", "bigInst", "=", "opcode", "<<", "16", "|", "arg", ";", "status", "=", "decodeInstruction", "(", "DecoderTable24", ",", "MI", ",", "bigInst", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "status", "==", "Success", ")", "{", "Size", "=", "3", ";", "return", "Success", ";", "}", "uint16_t", "shortInst", "=", "support", "::", "endian", "::", "read16be", "(", "Bytes", ".", "data", "(", ")", ")", ";", "status", "=", "decodeInstruction", "(", "DecoderTable16", ",", "MI", ",", "shortInst", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "status", "==", "Success", ")", "{", "Size", "=", "2", ";", "return", "Success", ";", "}", "uint8_t", "byteInst", "=", "support", "::", "endian", "::", "read", "<", "uint8_t", ",", "support", "::", "endianness", "::", "big", ">", "(", "Bytes", ".", "data", "(", ")", ")", ";", "status", "=", "decodeInstruction", "(", "DecoderTable8", ",", "MI", ",", "byteInst", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "status", "==", "Success", ")", "{", "Size", "=", "1", ";", "return", "Success", ";", "}", "Size", "=", "0", ";", "return", "status", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "ECLair", "ECLair", "support::endian", "support::endianness", "support::endian", "1", "16", "3", "support::endian", "2", "support::endian", "support::endianness", "1", "0" ]

[]

[ "<s>", "void", "MipsPassConfig", "::", "addIRPasses", "(", ")", "{", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "addPass", "(", "createAtomicExpandPass", "(", "&", "getMipsTargetMachine", "(", ")", ")", ")", ";", "if", "(", "getMipsSubtarget", "(", ")", ".", "os16", "(", ")", ")", "addPass", "(", "createMipsOs16", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "if", "(", "getMipsSubtarget", "(", ")", ".", "inMips16HardFloat", "(", ")", ")", "addPass", "(", "createMips16HardFloat", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips" ]

[]

[ "<s>", "void", "DigitalTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "TM", ".", "Options", ".", "UseInitArray", ")", ";", "SmallDataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "SmallBSSSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sbss\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "this", "->", "TM", "=", "&", "static_cast", "<", "const", "DigitalTargetMachine", "&", ">", "(", "TM", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "." ]

[ "Digital", "\".sdata\"", "\".sbss\"" ]

[]

[ "<s>", "void", "X86TargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "APInt", "&", "KnownZero", ",", "APInt", "&", "KnownOne", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "unsigned", "BitWidth", "=", "KnownZero", ".", "getBitWidth", "(", ")", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "assert", "(", "(", "Opc", ">=", "ISD", "::", "BUILTIN_OP_END", "||", "Opc", "==", "ISD", "::", "INTRINSIC_WO_CHAIN", "||", "Opc", "==", "ISD", "::", "INTRINSIC_W_CHAIN", "||", "Opc", "==", "ISD", "::", "INTRINSIC_VOID", ")", "&&", "\"Should use MaskedValueIsZero if you don't know whether Op\"", "\" is a target node!\"", ")", ";", "KnownZero", "=", "KnownOne", "=", "APInt", "(", "BitWidth", ",", "0", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "X86ISD", "::", "ADD", ":", "case", "X86ISD", "::", "SUB", ":", "case", "X86ISD", "::", "ADC", ":", "case", "X86ISD", "::", "SBB", ":", "case", "X86ISD", "::", "SMUL", ":", "case", "X86ISD", "::", "UMUL", ":", "case", "X86ISD", "::", "INC", ":", "case", "X86ISD", "::", "DEC", ":", "case", "X86ISD", "::", "OR", ":", "case", "X86ISD", "::", "XOR", ":", "case", "X86ISD", "::", "AND", ":", "if", "(", "Op", ".", "getResNo", "(", ")", "==", "0", ")", "break", ";", "LLVM_FALLTHROUGH", ";", "case", "X86ISD", "::", "SETCC", ":", "KnownZero", "|=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "1", ")", ";", "break", ";", "case", "X86ISD", "::", "MOVMSK", ":", "{", "unsigned", "NumLoBits", "=", "Op", ".", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", ".", "getVectorNumElements", "(", ")", ";", "KnownZero", "=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "NumLoBits", ")", ";", "break", ";", "}", "case", "X86ISD", "::", "VZEXT", ":", "{", "SDValue", "N0", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "unsigned", "NumElts", "=", "Op", ".", "getValueType", "(", ")", ".", "getVectorNumElements", "(", ")", ";", "unsigned", "InNumElts", "=", "N0", ".", "getValueType", "(", ")", ".", "getVectorNumElements", "(", ")", ";", "unsigned", "InBitWidth", "=", "N0", ".", "getValueType", "(", ")", ".", "getScalarSizeInBits", "(", ")", ";", "KnownZero", "=", "KnownOne", "=", "APInt", "(", "InBitWidth", ",", "0", ")", ";", "APInt", "DemandedElts", "=", "APInt", "::", "getLowBitsSet", "(", "InNumElts", ",", "NumElts", ")", ";", "DAG", ".", "computeKnownBits", "(", "N0", ",", "KnownZero", ",", "KnownOne", ",", "DemandedElts", ",", "Depth", "+", "1", ")", ";", "KnownOne", "=", "KnownOne", ".", "zext", "(", "BitWidth", ")", ";", "KnownZero", "=", "KnownZero", ".", "zext", "(", "BitWidth", ")", ";", "KnownZero", "|=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "InBitWidth", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "Determine", "which", "of", "the", "bits", "specified", "in", "Mask", "are", "known", "to", "be", "either", "zero", "or", "one", "and", "return", "them", "in", "the", "KnownZero/KnownOne", "bitsets", "." ]

[ "X86", "X86", "ISD::BUILTIN_OP_END", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_W_CHAIN", "ISD::INTRINSIC_VOID", "\"Should use MaskedValueIsZero if you don't know whether Op\"", "\" is a target node!\"", "0", "X86ISD::ADD", "X86ISD::SUB", "X86ISD::ADC", "X86ISD::SBB", "X86ISD::SMUL", "X86ISD::UMUL", "X86ISD::INC", "X86ISD::DEC", "X86ISD::OR", "X86ISD::XOR", "X86ISD::AND", "0", "X86ISD::SETCC", "1", "X86ISD::MOVMSK", "0", "X86ISD::VZEXT", "0", "0", "1" ]

[]

[ "<s>", "static", "unsigned", "riscv_pass_aggregate_in_fpr_pair_p", "(", "const_tree", "type", ",", "riscv_aggregate_field", "fields", "[", "2", "]", ")", "{", "static", "int", "warned", "=", "0", ";", "int", "n_old", "=", "riscv_flatten_aggregate_argument", "(", "type", ",", "fields", ",", "false", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "n_old", ";", "i", "++", ")", "if", "(", "!", "SCALAR_FLOAT_TYPE_P", "(", "fields", "[", "i", "]", ".", "type", ")", ")", "{", "n_old", "=", "-", "1", ";", "break", ";", "}", "int", "n_new", "=", "riscv_flatten_aggregate_argument", "(", "type", ",", "fields", ",", "true", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "n_new", ";", "i", "++", ")", "if", "(", "!", "SCALAR_FLOAT_TYPE_P", "(", "fields", "[", "i", "]", ".", "type", ")", ")", "{", "n_new", "=", "-", "1", ";", "break", ";", "}", "if", "(", "(", "n_old", "!=", "n_new", ")", "&&", "(", "warned", "==", "0", ")", ")", "{", "warning", "(", "OPT_Wpsabi", ",", "\"ABI for flattened struct with zero-length \"", "\"bit-fields changed in GCC 10\"", ")", ";", "warned", "=", "1", ";", "}", "return", "n_new", ">", "0", "?", "n_new", ":", "0", ";", "}", "</s>" ]

[ "See", "whether", "TYPE", "is", "a", "record", "whose", "fields", "should", "be", "returned", "in", "one", "or", "two", "floating-point", "registers", ".", "If", "so", ",", "populate", "FIELDS", "accordingly", "." ]

[ "riscv", "2", "0", "0", "1", "0", "1", "0", "\"ABI for flattened struct with zero-length \"", "\"bit-fields changed in GCC 10\"", "1", "0", "0" ]

[]

[ "<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "{", "return", "1", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "BPF", "1" ]

[]

[ "<s>", "bool", "isMem", "(", ")", "const", "{", "return", "Kind", "==", "Memory", ";", "}", "</s>" ]

[ "isMem", "-", "Is", "this", "a", "memory", "operand", "?" ]

[ "Patmos" ]

[]

[ "<s>", "bool", "HSAILTargetLowering", "::", "isDesirableToTransformToIntegerOp", "(", "unsigned", "Opc", ",", "EVT", "VT", ")", "const", "{", "return", "(", "Opc", "==", "ISD", "::", "LOAD", "||", "Opc", "==", "ISD", "::", "STORE", ")", "&&", "(", "VT", ".", "getSimpleVT", "(", ")", "==", "MVT", "::", "f32", "||", "VT", ".", "getSimpleVT", "(", ")", "==", "MVT", "::", "f64", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "for", "dag", "combiner", "to", "transform", "a", "floating", "point", "op", "of", "specified", "opcode", "to", "a", "equivalent", "op", "of", "an", "integer", "type", "." ]

[ "HSAIL", "HSAIL", "ISD::LOAD", "ISD::STORE", "MVT::f32", "MVT::f64" ]

[]

[ "<s>", "bool", "evaluateBranch", "(", "const", "MCInst", "&", "Inst", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ",", "uint64_t", "&", "Target", ")", "const", "override", "{", "unsigned", "OpId", ";", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "OpId", "=", "0", ";", "break", ";", "case", "ARM", "::", "t2WLS", ":", "case", "ARM", "::", "t2LEUpdate", ":", "OpId", "=", "2", ";", "break", ";", "case", "ARM", "::", "t2LE", ":", "OpId", "=", "1", ";", "break", ";", "}", "if", "(", "Info", "->", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ".", "OpInfo", "[", "OpId", "]", ".", "OperandType", "!=", "MCOI", "::", "OPERAND_PCREL", ")", "return", "false", ";", "Target", "=", "Addr", "+", "Inst", ".", "getOperand", "(", "OpId", ")", ".", "getImm", "(", ")", "+", "4", ";", "return", "true", ";", "}", "</s>" ]

[ "Given", "a", "branch", "instruction", "try", "to", "get", "the", "address", "the", "branch", "targets", "." ]

[ "ARM", "0", "ARM::t2WLS", "ARM::t2LEUpdate", "2", "ARM::t2LE", "1", "4" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"SPIRV OCL Regularizer\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "SPIRV", "\"SPIRV OCL Regularizer\"" ]

[]

[ "<s>", "EVT", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsMemset", ",", "bool", "ZeroMemset", ",", "bool", "MemcpyStrSrc", ",", "const", "AttributeList", "&", "FuncAttributes", ")", "const", "override", "{", "return", "Size", ">=", "8", "?", "MVT", "::", "i64", ":", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "BPF", "8", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "int", "AArch64FrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "return", "resolveFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ",", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "SanitizeHWAddress", ")", ",", "false", ")", ".", "getBytes", "(", ")", ";", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "PPCTargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "AI", ")", "const", "{", "unsigned", "Size", "=", "AI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "shouldInlineQuadwordAtomics", "(", ")", "&&", "Size", "==", "128", ")", "return", "AtomicExpansionKind", "::", "MaskedIntrinsic", ";", "return", "TargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AI", ")", ";", "}", "</s>" ]

[ "Returns", "how", "the", "IR-level", "AtomicExpand", "pass", "should", "expand", "the", "given", "AtomicRMW", ",", "if", "at", "all", "." ]

[ "PowerPC", "PPC", "128" ]

[]