Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "SDValue", "Z80TargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "LowerZExt", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "LowerSExt", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SUB", ":", "case", "ISD", "::", "SUBC", ":", "return", "LowerSUB", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "ROTL", ":", "case", "ISD", "::", "ROTR", ":", "return", "LowerShifts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "AND", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "XOR", ":", "return", "LowerBinaryOp", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSelectCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBrCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerStore", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLoad", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unimplemented operation\"", ")", ";", "}", "}", "</s>" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "Z80", "Z80", "ISD::ZERO_EXTEND", "ISD::SIGN_EXTEND", "ISD::SUB", "ISD::SUBC", "ISD::SRL", "ISD::SHL", "ISD::SRA", "ISD::ROTL", "ISD::ROTR", "ISD::AND", "ISD::OR", "ISD::XOR", "ISD::SELECT_CC", "ISD::BR_CC", "ISD::GlobalAddress", "ISD::STORE", "ISD::LOAD", "\"unimplemented operation\"" ]

[]

[ "<s>", "static", "unsigned", "bit_count", "(", "unsigned", "HOST_WIDE_INT", "value", ")", "{", "unsigned", "count", "=", "0", ";", "while", "(", "value", ")", "{", "count", "++", ";", "value", "&=", "value", "-", "1", ";", "}", "return", "count", ";", "}", "</s>" ]

[ "Typical", "stack", "layout", "should", "looks", "like", "this", "after", "the", "function", "'s", "prologue", ":", "|", "|", "--", "^", "|", "|", "\\", "|", "|", "|", "arguments", "saved", "|", "Increasing", "|", "|", "on", "the", "stack", "|", "addresses", "PARENT", "arg", "pointer", "-", ">", "|", "|", "/", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "-", "CHILD", "|ret", "|", "return", "address", "--", "|", "|", "\\", "|", "|", "call", "saved", "|", "|", "registers", "|", "|", "/", "--", "|", "|", "\\", "|", "|", "local", "|", "|", "variables", "frame", "pointer", "-", ">", "|", "|", "/", "--", "|", "|", "\\", "|", "|", "outgoing", "|", "Decreasing", "|", "|", "arguments", "|", "addresses", "current", "stack", "pointer", "-", ">", "|", "|", "/", "|", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "V", "|", "|" ]

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

[]

[ "<s>", "bool", "sh_cfun_interrupt_handler_p", "(", "void", ")", "{", "return", "(", "lookup_attribute", "(", "\"interrupt_handler\"", ",", "DECL_ATTRIBUTES", "(", "current_function_decl", ")", ")", "!=", "NULL_TREE", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "current", "function", "has", "the", "``", "interrupt_handler", "''", "attribute", "set", "." ]

[ "sh", "\"interrupt_handler\"" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "X86RegisterInfo", "::", "getLargestLegalSuperClass", "(", "const", "TargetRegisterClass", "*", "RC", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "RC", "==", "&", "X86", "::", "GR8_NOREXRegClass", ")", "return", "RC", ";", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "const", "TargetRegisterClass", "*", "Super", "=", "RC", ";", "TargetRegisterClass", "::", "sc_iterator", "I", "=", "RC", "->", "getSuperClasses", "(", ")", ";", "do", "{", "switch", "(", "Super", "->", "getID", "(", ")", ")", "{", "case", "X86", "::", "FR32RegClassID", ":", "case", "X86", "::", "FR64RegClassID", ":", "if", "(", "!", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "Super", "->", "getSize", "(", ")", "==", "RC", "->", "getSize", "(", ")", ")", "return", "Super", ";", "break", ";", "case", "X86", "::", "VR128RegClassID", ":", "case", "X86", "::", "VR256RegClassID", ":", "if", "(", "!", "Subtarget", ".", "hasVLX", "(", ")", "&&", "Super", "->", "getSize", "(", ")", "==", "RC", "->", "getSize", "(", ")", ")", "return", "Super", ";", "break", ";", "case", "X86", "::", "FR32XRegClassID", ":", "case", "X86", "::", "FR64XRegClassID", ":", "if", "(", "!", "Subtarget", ".", "hasVLX", "(", ")", ")", "break", ";", "case", "X86", "::", "VR128XRegClassID", ":", "case", "X86", "::", "VR256XRegClassID", ":", "if", "(", "!", "Subtarget", ".", "hasAVX512", "(", ")", ")", "break", ";", "case", "X86", "::", "GR8RegClassID", ":", "case", "X86", "::", "GR16RegClassID", ":", "case", "X86", "::", "GR32RegClassID", ":", "case", "X86", "::", "GR64RegClassID", ":", "case", "X86", "::", "RFP32RegClassID", ":", "case", "X86", "::", "RFP64RegClassID", ":", "case", "X86", "::", "RFP80RegClassID", ":", "case", "X86", "::", "VR512RegClassID", ":", "if", "(", "Super", "->", "getSize", "(", ")", "==", "RC", "->", "getSize", "(", ")", ")", "return", "Super", ";", "}", "Super", "=", "*", "I", "++", ";", "}", "while", "(", "Super", ")", ";", "return", "RC", ";", "}", "</s>" ]

[ "Returns", "the", "largest", "super", "class", "of", "RC", "that", "is", "legal", "to", "use", "in", "the", "current", "sub-target", "and", "has", "the", "same", "spill", "size", "." ]

[ "X86", "X86", "X86::GR8_NOREXRegClass", "X86", "X86", "X86::FR32RegClassID", "X86::FR64RegClassID", "X86::VR128RegClassID", "X86::VR256RegClassID", "X86::FR32XRegClassID", "X86::FR64XRegClassID", "X86::VR128XRegClassID", "X86::VR256XRegClassID", "X86::GR8RegClassID", "X86::GR16RegClassID", "X86::GR32RegClassID", "X86::GR64RegClassID", "X86::RFP32RegClassID", "X86::RFP64RegClassID", "X86::RFP80RegClassID", "X86::VR512RegClassID" ]

[]

[ "<s>", "char", "*", "xstormy16_output_cbranch_hi", "(", "rtx", "op", ",", "const", "char", "*", "label", ",", "int", "reversed", ",", "rtx_insn", "*", "insn", ")", "{", "static", "char", "string", "[", "64", "]", ";", "int", "need_longbranch", "=", "(", "op", "!=", "NULL_RTX", "?", "get_attr_length", "(", "insn", ")", "==", "8", ":", "get_attr_length", "(", "insn", ")", "==", "4", ")", ";", "int", "really_reversed", "=", "reversed", "^", "need_longbranch", ";", "const", "char", "*", "ccode", ";", "const", "char", "*", "templ", ";", "const", "char", "*", "operands", ";", "enum", "rtx_code", "code", ";", "if", "(", "!", "op", ")", "{", "if", "(", "need_longbranch", ")", "ccode", "=", "\"jmpf\"", ";", "else", "ccode", "=", "\"br\"", ";", "sprintf", "(", "string", ",", "\"%s %s\"", ",", "ccode", ",", "label", ")", ";", "return", "string", ";", "}", "code", "=", "GET_CODE", "(", "op", ")", ";", "if", "(", "!", "REG_P", "(", "XEXP", "(", "op", ",", "0", ")", ")", ")", "{", "code", "=", "swap_condition", "(", "code", ")", ";", "operands", "=", "\"%3,%2\"", ";", "}", "else", "operands", "=", "\"%2,%3\"", ";", "if", "(", "really_reversed", ")", "code", "=", "reverse_condition", "(", "code", ")", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "ccode", "=", "\"z\"", ";", "break", ";", "case", "NE", ":", "ccode", "=", "\"nz\"", ";", "break", ";", "case", "GE", ":", "ccode", "=", "\"ge\"", ";", "break", ";", "case", "LT", ":", "ccode", "=", "\"lt\"", ";", "break", ";", "case", "GT", ":", "ccode", "=", "\"gt\"", ";", "break", ";", "case", "LE", ":", "ccode", "=", "\"le\"", ";", "break", ";", "case", "GEU", ":", "ccode", "=", "\"nc\"", ";", "break", ";", "case", "LTU", ":", "ccode", "=", "\"c\"", ";", "break", ";", "case", "GTU", ":", "ccode", "=", "\"hi\"", ";", "break", ";", "case", "LEU", ":", "ccode", "=", "\"ls\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "need_longbranch", ")", "templ", "=", "\"b%s %s,.+8 | jmpf %s\"", ";", "else", "templ", "=", "\"b%s %s,%s\"", ";", "sprintf", "(", "string", ",", "templ", ",", "ccode", ",", "operands", ",", "label", ")", ";", "return", "string", ";", "}", "</s>" ]

[ "Return", "the", "string", "to", "output", "a", "conditional", "branch", "to", "LABEL", ",", "which", "is", "the", "operand", "number", "of", "the", "label", ".", "OP", "is", "the", "conditional", "expression", ",", "or", "NULL", "for", "branch-always", ".", "REVERSED", "is", "non-zero", "if", "we", "should", "reverse", "the", "sense", "of", "the", "comparison", ".", "INSN", "is", "the", "insn", "." ]

[ "stormy16", "64", "8", "4", "\"jmpf\"", "\"br\"", "\"%s %s\"", "0", "\"%3,%2\"", "\"%2,%3\"", "\"z\"", "\"nz\"", "\"ge\"", "\"lt\"", "\"gt\"", "\"le\"", "\"nc\"", "\"c\"", "\"hi\"", "\"ls\"", "\"b%s %s,.+8 | jmpf %s\"", "\"b%s %s,%s\"" ]

[]

[ "<s>", "bool", "MipsLongBranch", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "const", "MipsInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "MipsInstrInfo", "*", ">", "(", "TM", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "inMips16Mode", "(", ")", ")", "return", "false", ";", "if", "(", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "&&", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "isABI_O32", "(", ")", "&&", "F", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", "->", "globalBaseRegSet", "(", ")", ")", "emitGPDisp", "(", "F", ",", "TII", ")", ";", "if", "(", "SkipLongBranch", ")", "return", "true", ";", "MF", "=", "&", "F", ";", "initMBBInfo", "(", ")", ";", "SmallVectorImpl", "<", "MBBInfo", ">", "::", "iterator", "I", ",", "E", "=", "MBBInfos", ".", "end", "(", ")", ";", "bool", "EverMadeChange", "=", "false", ",", "MadeChange", "=", "true", ";", "while", "(", "MadeChange", ")", "{", "MadeChange", "=", "false", ";", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "!", "I", "->", "Br", "||", "I", "->", "HasLongBranch", ")", "continue", ";", "if", "(", "!", "ForceLongBranch", "&&", "isInt", "<", "16", ">", "(", "computeOffset", "(", "I", "->", "Br", ")", "/", "4", ")", ")", "continue", ";", "I", "->", "HasLongBranch", "=", "true", ";", "I", "->", "Size", "+=", "LongBranchSeqSize", "*", "4", ";", "++", "LongBranches", ";", "EverMadeChange", "=", "MadeChange", "=", "true", ";", "}", "}", "if", "(", "!", "EverMadeChange", ")", "return", "true", ";", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "{", "uint64_t", "Address", "=", "0", ";", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "Address", "+=", "I", "->", "Size", ",", "++", "I", ")", "I", "->", "Address", "=", "Address", ";", "}", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "I", "->", "HasLongBranch", ")", "expandToLongBranch", "(", "*", "I", ")", ";", "MF", "->", "RenumberBlocks", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "16", "4", "4", "0" ]

[]

[ "<s>", "unsigned", "char", "X86Subtarget", "::", "classifyLocalReference", "(", "const", "GlobalValue", "*", "GV", ")", "const", "{", "if", "(", "AllowTaggedGlobals", "&&", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Small", "&&", "!", "isa_and_nonnull", "<", "Function", ">", "(", "GV", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "if", "(", "!", "isPositionIndependent", "(", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "is64Bit", "(", ")", ")", "{", "if", "(", "isTargetELF", "(", ")", ")", "{", "switch", "(", "TM", ".", "getCodeModel", "(", ")", ")", "{", "case", "CodeModel", "::", "Tiny", ":", "llvm_unreachable", "(", "\"Tiny codesize model not supported on X86\"", ")", ";", "case", "CodeModel", "::", "Small", ":", "case", "CodeModel", "::", "Kernel", ":", "return", "X86II", "::", "MO_NO_FLAG", ";", "case", "CodeModel", "::", "Large", ":", "return", "X86II", "::", "MO_GOTOFF", ";", "case", "CodeModel", "::", "Medium", ":", "if", "(", "isa_and_nonnull", "<", "Function", ">", "(", "GV", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "return", "X86II", "::", "MO_GOTOFF", ";", "}", "llvm_unreachable", "(", "\"invalid code model\"", ")", ";", "}", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "if", "(", "isTargetCOFF", "(", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "GV", "&&", "(", "GV", "->", "isDeclarationForLinker", "(", ")", "||", "GV", "->", "hasCommonLinkage", "(", ")", ")", ")", "return", "X86II", "::", "MO_DARWIN_NONLAZY_PIC_BASE", ";", "return", "X86II", "::", "MO_PIC_BASE_OFFSET", ";", "}", "return", "X86II", "::", "MO_GOTOFF", ";", "}", "</s>" ]

[ "Classify", "a", "global", "variable", "reference", "for", "the", "current", "subtarget", "according", "to", "how", "we", "should", "reference", "it", "in", "a", "non-pcrel", "context", "." ]

[ "X86", "X86", "X86II::MO_GOTPCREL", "X86II::MO_NO_FLAG", "\"Tiny codesize model not supported on X86\"", "X86II::MO_NO_FLAG", "X86II::MO_GOTOFF", "X86II::MO_NO_FLAG", "X86II::MO_GOTOFF", "\"invalid code model\"", "X86II::MO_NO_FLAG", "X86II::MO_NO_FLAG", "X86II::MO_DARWIN_NONLAZY_PIC_BASE", "X86II::MO_PIC_BASE_OFFSET", "X86II::MO_GOTOFF" ]

[]

[ "<s>", "SDValue", "SparcTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", ")", "return", "LowerReturn_64", "(", "Chain", ",", "CallConv", ",", "IsVarArg", ",", "Outs", ",", "OutVals", ",", "DL", ",", "DAG", ")", ";", "return", "LowerReturn_32", "(", "Chain", ",", "CallConv", ",", "IsVarArg", ",", "Outs", ",", "OutVals", ",", "DL", ",", "DAG", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "ISD::OutputArg" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isLegalICmpImmediate", "(", "int64_t", "Immed", ")", "const", "{", "return", "isLegalAddImmediate", "(", "Immed", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "immediate", "is", "legal", "icmp", "immediate", ",", "that", "is", "the", "target", "has", "icmp", "instructions", "which", "can", "compare", "a", "register", "against", "the", "immediate", "without", "having", "to", "materialize", "the", "immediate", "into", "a", "register", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "EVT", "ARMTargetLowering", "::", "getOptimalMemOpType", "(", "const", "MemOp", "&", "Op", ",", "const", "AttributeList", "&", "FuncAttributes", ")", "const", "{", "if", "(", "(", "Op", ".", "isMemcpy", "(", ")", "||", "Op", ".", "isZeroMemset", "(", ")", ")", "&&", "Subtarget", "->", "hasNEON", "(", ")", "&&", "!", "FuncAttributes", ".", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ")", "{", "bool", "Fast", ";", "if", "(", "Op", ".", "size", "(", ")", ">=", "16", "&&", "(", "Op", ".", "isAligned", "(", "Align", "(", "16", ")", ")", "||", "(", "allowsMisalignedMemoryAccesses", "(", "MVT", "::", "v2f64", ",", "0", ",", "1", ",", "MachineMemOperand", "::", "MONone", ",", "&", "Fast", ")", "&&", "Fast", ")", ")", ")", "{", "return", "MVT", "::", "v2f64", ";", "}", "else", "if", "(", "Op", ".", "size", "(", ")", ">=", "8", "&&", "(", "Op", ".", "isAligned", "(", "Align", "(", "8", ")", ")", "||", "(", "allowsMisalignedMemoryAccesses", "(", "MVT", "::", "f64", ",", "0", ",", "1", ",", "MachineMemOperand", "::", "MONone", ",", "&", "Fast", ")", "&&", "Fast", ")", ")", ")", "{", "return", "MVT", "::", "f64", ";", "}", "}", "return", "MVT", "::", "Other", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "16", "16", "MVT::v2f64", "0", "1", "MVT::v2f64", "8", "8", "MVT::f64", "0", "1", "MVT::f64", "MVT::Other" ]

[]

[ "<s>", "bool", "mips_mem_fits_mode_p", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "return", "(", "MEM_P", "(", "x", ")", "&&", "MEM_SIZE_KNOWN_P", "(", "x", ")", "&&", "MEM_SIZE", "(", "x", ")", "==", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "MEM", "with", "the", "same", "size", "as", "MODE", "." ]

[ "mips" ]

[]

[ "<s>", "static", "bool", "is_cracked_insn", "(", "rtx", "insn", ")", "{", "if", "(", "!", "insn", "||", "!", "INSN_P", "(", "insn", ")", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", ")", "return", "false", ";", "if", "(", "rs6000_sched_groups", ")", "{", "enum", "attr_type", "type", "=", "get_attr_type", "(", "insn", ")", ";", "if", "(", "type", "==", "TYPE_LOAD_U", "||", "type", "==", "TYPE_STORE_U", "||", "type", "==", "TYPE_FPLOAD_U", "||", "type", "==", "TYPE_FPSTORE_U", "||", "type", "==", "TYPE_FPLOAD_UX", "||", "type", "==", "TYPE_FPSTORE_UX", "||", "type", "==", "TYPE_LOAD_EXT", "||", "type", "==", "TYPE_DELAYED_CR", "||", "type", "==", "TYPE_COMPARE", "||", "type", "==", "TYPE_DELAYED_COMPARE", "||", "type", "==", "TYPE_IMUL_COMPARE", "||", "type", "==", "TYPE_LMUL_COMPARE", "||", "type", "==", "TYPE_IDIV", "||", "type", "==", "TYPE_LDIV", "||", "type", "==", "TYPE_INSERT_WORD", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "The", "function", "returns", "true", "if", "INSN", "is", "cracked", "into", "2", "instructions", "by", "the", "processor", "(", "and", "therefore", "occupies", "2", "issue", "slots", ")", "." ]

[ "rs6000" ]

[]

[ "<s>", "unsigned", "AAPInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "unsigned", "Count", "=", "0", ";", "auto", "I", "=", "MBB", ".", "end", "(", ")", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "break", ";", "I", "->", "eraseFromParent", "(", ")", ";", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "+=", "getInstSizeInBytes", "(", "*", "I", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

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

[ "AAP", "AAP", "0" ]

[]

[ "<s>", "static", "reg_class_t", "sh_preferred_reload_class", "(", "rtx", "x", ",", "reg_class_t", "rclass", ")", "{", "if", "(", "rclass", "==", "NO_REGS", "&&", "TARGET_SHMEDIA", "&&", "(", "CONST_DOUBLE_P", "(", "x", ")", "||", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "||", "PIC_ADDR_P", "(", "x", ")", ")", ")", "return", "GENERAL_REGS", ";", "return", "rclass", ";", "}", "</s>" ]

[ "Implement", "TARGET_PREFERRED_RELOAD_CLASS", "." ]

[ "sh" ]

[]

[ "<s>", "void", "MBlazeTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "SmallDataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "SmallBSSSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sbss\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getBSS", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "visium_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "static_chain", ")", "{", "rtx", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "rtx", "addr", "=", "XEXP", "(", "m_tramp", ",", "0", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "addr", ",", "0", ")", ")", ",", "plus_constant", "(", "SImode", ",", "expand_shift", "(", "RSHIFT_EXPR", ",", "SImode", ",", "fnaddr", ",", "16", ",", "NULL_RTX", ",", "1", ")", ",", "0x04a90000", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "addr", ",", "4", ")", ")", ",", "plus_constant", "(", "SImode", ",", "expand_and", "(", "SImode", ",", "fnaddr", ",", "GEN_INT", "(", "0xffff", ")", ",", "NULL_RTX", ")", ",", "0x04890000", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "addr", ",", "8", ")", ")", ",", "plus_constant", "(", "SImode", ",", "expand_shift", "(", "RSHIFT_EXPR", ",", "SImode", ",", "static_chain", ",", "16", ",", "NULL_RTX", ",", "1", ")", ",", "0x04b40000", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "addr", ",", "12", ")", ")", ",", "gen_int_mode", "(", "0xff892404", ",", "SImode", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "addr", ",", "16", ")", ")", ",", "plus_constant", "(", "SImode", ",", "expand_and", "(", "SImode", ",", "static_chain", ",", "GEN_INT", "(", "0xffff", ")", ",", "NULL_RTX", ")", ",", "0x04940000", ")", ")", ";", "emit_library_call", "(", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__set_trampoline_parity\"", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "1", ",", "addr", ",", "SImode", ")", ";", "}", "</s>" ]

[ "Initialize", "a", "trampoline", ".", "M_TRAMP", "is", "an", "RTX", "for", "the", "memory", "block", "for", "the", "trampoline", ",", "FNDECL", "is", "the", "FUNCTION_DECL", "for", "the", "nested", "function", "and", "STATIC_CHAIN", "is", "an", "RTX", "for", "the", "static", "chain", "value", "that", "should", "be", "passed", "to", "the", "function", "when", "it", "is", "called", "." ]

[ "visium", "0", "0", "0", "16", "1", "0x04a90000", "4", "0xffff", "0x04890000", "8", "16", "1", "0x04b40000", "12", "0xff892404", "16", "0xffff", "0x04940000", "\"__set_trampoline_parity\"", "1" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "if", "(", "CallConv", "==", "CallingConv", "::", "MSP430_INTR", "&&", "!", "Outs", ".", "empty", "(", ")", ")", "report_fatal_error", "(", "\"ISRs cannot return any value\"", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "AnalyzeReturnValues", "(", "CCInfo", ",", "RVLocs", ",", "Outs", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasStructRetAttr", "(", ")", ")", "{", "MSP430MachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "Reg", "=", "FuncInfo", "->", "getSRetReturnReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "llvm_unreachable", "(", "\"sret virtual register not created in entry block\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "Reg", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ";", "unsigned", "R12", "=", "MSP430", "::", "R12", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "R12", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "R12", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ")", ";", "}", "unsigned", "Opc", "=", "(", "CallConv", "==", "CallingConv", "::", "MSP430_INTR", "?", "MSP430ISD", "::", "RETI_FLAG", ":", "MSP430ISD", "::", "RET_FLAG", ")", ";", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "ISD::OutputArg", "16", "MSP430", "\"ISRs cannot return any value\"", "4", "1", "0", "\"Can only return in registers!\"", "1", "MSP430", "MSP430", "\"sret virtual register not created in entry block\"", "MSP430::R12", "1", "MSP430", "MSP430ISD::RETI_FLAG", "MSP430ISD::RET_FLAG", "0", "MVT::Other" ]

[]

[ "<s>", "Register", "ARMTargetLowering", "::", "getExceptionPointerRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "{", "return", "Subtarget", "->", "useSjLjEH", "(", ")", "?", "Register", "(", ")", ":", "ARM", "::", "R0", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "address", "on", "entry", "to", "an", "EH", "pad", "." ]

[ "ARM", "ARM", "ARM::R0" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "MSP430RegisterInfo", "::", "getPointerRegClass", "(", ")", "const", "{", "return", "&", "MSP430", "::", "GR16RegClass", ";", "}", "</s>" ]

[ "getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "." ]

[ "MSP430", "MSP430", "MSP430::GR16RegClass" ]

[]

[ "<s>", "unsigned", "SparcCodeEmitter", "::", "getMachineOpValue", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "&", "MO", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "TM", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "emitGlobalAddress", "(", "MO", ".", "getGlobal", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ")", ";", "else", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "emitExternalSymbolAddress", "(", "MO", ".", "getSymbolName", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ")", ";", "else", "if", "(", "MO", ".", "isCPI", "(", ")", ")", "emitConstPoolAddress", "(", "MO", ".", "getIndex", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ")", ";", "else", "if", "(", "MO", ".", "isMBB", "(", ")", ")", "emitMachineBasicBlock", "(", "MO", ".", "getMBB", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ")", ";", "else", "llvm_unreachable", "(", "\"Unable to encode MachineOperand!\"", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "Sparc", "Sparc", "\"Unable to encode MachineOperand!\"", "0" ]

[]

[ "<s>", "SDNode", "*", "MandarinDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "SDLoc", "dl", "(", "N", ")", ";", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", "NULL", ";", "}", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "FrameIndex", ":", "if", "(", "FrameIndexSDNode", "*", "FIN", "=", "dyn_cast", "<", "FrameIndexSDNode", ">", "(", "N", ")", ")", "{", "return", "CurDAG", "->", "getTargetFrameIndex", "(", "FIN", "->", "getIndex", "(", ")", ",", "getTargetLowering", "(", ")", "->", "getPointerTy", "(", ")", ")", ".", "getNode", "(", ")", ";", "}", "}", "return", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "Mandarin", "1", "ISD::FrameIndex" ]

[]

[ "<s>", "static", "void", "riscv_emit_float_compare", "(", "enum", "rtx_code", "*", "code", ",", "rtx", "*", "op0", ",", "rtx", "*", "op1", ")", "{", "rtx", "tmp0", ",", "tmp1", ",", "cmp_op0", "=", "*", "op0", ",", "cmp_op1", "=", "*", "op1", ";", "enum", "rtx_code", "fp_code", "=", "*", "code", ";", "*", "code", "=", "NE", ";", "switch", "(", "fp_code", ")", "{", "case", "UNORDERED", ":", "*", "code", "=", "EQ", ";", "case", "ORDERED", ":", "tmp0", "=", "riscv_force_binary", "(", "word_mode", ",", "EQ", ",", "cmp_op0", ",", "cmp_op0", ")", ";", "tmp1", "=", "riscv_force_binary", "(", "word_mode", ",", "EQ", ",", "cmp_op1", ",", "cmp_op1", ")", ";", "*", "op0", "=", "riscv_force_binary", "(", "word_mode", ",", "AND", ",", "tmp0", ",", "tmp1", ")", ";", "*", "op1", "=", "const0_rtx", ";", "break", ";", "case", "UNEQ", ":", "case", "LTGT", ":", "*", "code", "=", "fp_code", "==", "LTGT", "?", "GTU", ":", "EQ", ";", "tmp0", "=", "riscv_force_binary", "(", "word_mode", ",", "EQ", ",", "cmp_op0", ",", "cmp_op0", ")", ";", "tmp1", "=", "riscv_force_binary", "(", "word_mode", ",", "EQ", ",", "cmp_op1", ",", "cmp_op1", ")", ";", "*", "op0", "=", "riscv_force_binary", "(", "word_mode", ",", "AND", ",", "tmp0", ",", "tmp1", ")", ";", "*", "op1", "=", "riscv_force_binary", "(", "word_mode", ",", "EQ", ",", "cmp_op0", ",", "cmp_op1", ")", ";", "break", ";", "case", "CODE", ":", "\\", "*", "code", "=", "EQ", ";", "\\", "*", "op0", "=", "gen_reg_rtx", "(", "word_mode", ")", ";", "\\", "if", "(", "GET_MODE", "(", "cmp_op0", ")", "==", "SFmode", "&&", "TARGET_64BIT", ")", "\\", "emit_insn", "(", "gen_f", "##", "CMP", "##", "_quietsfdi4", "(", "*", "op0", ",", "cmp_op0", ",", "cmp_op1", ")", ")", ";", "\\", "else", "if", "(", "GET_MODE", "(", "cmp_op0", ")", "==", "SFmode", ")", "\\", "emit_insn", "(", "gen_f", "##", "CMP", "##", "_quietsfsi4", "(", "*", "op0", ",", "cmp_op0", ",", "cmp_op1", ")", ")", ";", "\\", "else", "if", "(", "GET_MODE", "(", "cmp_op0", ")", "==", "DFmode", "&&", "TARGET_64BIT", ")", "\\", "emit_insn", "(", "gen_f", "##", "CMP", "##", "_quietdfdi4", "(", "*", "op0", ",", "cmp_op0", ",", "cmp_op1", ")", ")", ";", "\\", "else", "if", "(", "GET_MODE", "(", "cmp_op0", ")", "==", "DFmode", ")", "\\", "emit_insn", "(", "gen_f", "##", "CMP", "##", "_quietdfsi4", "(", "*", "op0", ",", "cmp_op0", ",", "cmp_op1", ")", ")", ";", "\\", "else", "\\", "gcc_unreachable", "(", ")", ";", "\\", "*", "op1", "=", "const0_rtx", ";", "\\", "break", ";", "case", "UNLT", ":", "std", "::", "swap", "(", "cmp_op0", ",", "cmp_op1", ")", ";", "gcc_fallthrough", "(", ")", ";", "UNORDERED_COMPARISON", "(", "UNGT", ",", "le", ")", "case", "UNLE", ":", "std", "::", "swap", "(", "cmp_op0", ",", "cmp_op1", ")", ";", "gcc_fallthrough", "(", ")", ";", "UNORDERED_COMPARISON", "(", "UNGE", ",", "lt", ")", "case", "NE", ":", "fp_code", "=", "EQ", ";", "*", "code", "=", "EQ", ";", "case", "EQ", ":", "case", "LE", ":", "case", "LT", ":", "case", "GE", ":", "case", "GT", ":", "*", "op0", "=", "riscv_force_binary", "(", "word_mode", ",", "fp_code", ",", "cmp_op0", ",", "cmp_op1", ")", ";", "*", "op1", "=", "const0_rtx", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Like", "riscv_emit_int_compare", ",", "but", "for", "floating-point", "comparisons", "." ]

[ "riscv" ]

[]

[ "<s>", "static", "struct", "constant_pool", "*", "s390_alloc_pool", "(", "void", ")", "{", "struct", "constant_pool", "*", "pool", ";", "int", "i", ";", "pool", "=", "(", "struct", "constant_pool", "*", ")", "xmalloc", "(", "sizeof", "*", "pool", ")", ";", "pool", "->", "next", "=", "NULL", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NR_C_MODES", ";", "i", "++", ")", "pool", "->", "constants", "[", "i", "]", "=", "NULL", ";", "pool", "->", "execute", "=", "NULL", ";", "pool", "->", "label", "=", "gen_label_rtx", "(", ")", ";", "pool", "->", "first_insn", "=", "NULL_RTX", ";", "pool", "->", "pool_insn", "=", "NULL_RTX", ";", "pool", "->", "insns", "=", "BITMAP_ALLOC", "(", "NULL", ")", ";", "pool", "->", "size", "=", "0", ";", "return", "pool", ";", "}", "</s>" ]

[ "Allocate", "new", "constant_pool", "structure", "." ]

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

[]

[ "<s>", "void", "m32r_expand_prologue", "(", ")", "{", "int", "regno", ";", "int", "frame_size", ";", "unsigned", "int", "gmask", ";", "if", "(", "!", "current_frame_info", ".", "initialized", ")", "m32r_compute_frame_size", "(", "get_frame_size", "(", ")", ")", ";", "gmask", "=", "current_frame_info", ".", "gmask", ";", "if", "(", "current_frame_info", ".", "total_size", "==", "0", "&&", "gmask", ")", "abort", "(", ")", ";", "if", "(", "current_frame_info", ".", "pretend_size", "!=", "0", ")", "{", "HOST_WIDE_INT", "pretend_size", "=", "current_frame_info", ".", "pretend_size", ";", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "pretend_size", ")", ")", ")", ";", "}", "if", "(", "current_frame_info", ".", "save_fp", ")", "emit_insn", "(", "gen_movsi_push", "(", "stack_pointer_rtx", ",", "frame_pointer_rtx", ")", ")", ";", "gmask", "&=", "~", "(", "FRAME_POINTER_MASK", "|", "RETURN_ADDR_MASK", ")", ";", "for", "(", "regno", "=", "0", ";", "regno", "<=", "M32R_MAX_INT_REGS", ";", "++", "regno", ")", "{", "if", "(", "(", "gmask", "&", "(", "1", "<<", "regno", ")", ")", "!=", "0", ")", "emit_insn", "(", "gen_movsi_push", "(", "stack_pointer_rtx", ",", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ")", ")", ";", "}", "if", "(", "current_frame_info", ".", "save_lr", ")", "emit_insn", "(", "gen_movsi_push", "(", "stack_pointer_rtx", ",", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ")", ")", ";", "frame_size", "=", "(", "current_frame_info", ".", "total_size", "-", "(", "current_frame_info", ".", "pretend_size", "+", "current_frame_info", ".", "reg_size", ")", ")", ";", "if", "(", "frame_size", "==", "0", ")", ";", "else", "if", "(", "frame_size", "<=", "32768", ")", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "frame_size", ")", ")", ")", ";", "else", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "Pmode", ",", "PROLOGUE_TMP_REGNUM", ")", ";", "emit_insn", "(", "gen_movsi", "(", "tmp", ",", "GEN_INT", "(", "frame_size", ")", ")", ")", ";", "emit_insn", "(", "gen_subsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "tmp", ")", ")", ";", "}", "if", "(", "frame_pointer_needed", ")", "emit_insn", "(", "gen_movsi", "(", "frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ")", ";", "if", "(", "current_function_profile", ")", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "</s>" ]

[ "Expand", "the", "m32r", "prologue", "as", "a", "series", "of", "insns", "." ]

[ "m32r", "0", "0", "0", "1", "0", "0", "32768" ]

[]

[ "<s>", "static", "bool", "msp430_no_hwmult", "(", "void", ")", "{", "static", "const", "char", "*", "cached_match", "=", "NULL", ";", "static", "bool", "cached_result", ";", "int", "i", ";", "if", "(", "msp430_hwmult_type", "==", "NONE", ")", "return", "true", ";", "if", "(", "msp430_hwmult_type", "!=", "AUTO", ")", "return", "false", ";", "if", "(", "target_mcu", "==", "NULL", ")", "return", "true", ";", "if", "(", "target_mcu", "==", "cached_match", ")", "return", "cached_result", ";", "cached_match", "=", "target_mcu", ";", "for", "(", "i", "=", "ARRAY_SIZE", "(", "msp430_mcu_data", ")", ";", "i", "--", ";", ")", "if", "(", "strcasecmp", "(", "target_mcu", ",", "msp430_mcu_data", "[", "i", "]", ".", "name", ")", "==", "0", ")", "return", "cached_result", "=", "msp430_mcu_data", "[", "i", "]", ".", "hwmpy", "==", "0", ";", "return", "cached_result", "=", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "current", "MCU", "does", "not", "have", "a", "hardware", "multiplier", "of", "any", "kind", "." ]

[ "msp430", "0", "0" ]

[]

[ "<s>", "bool", "SPIRVInstructionSelector", "::", "select", "(", "MachineInstr", "&", "I", ")", "{", "assert", "(", "I", ".", "getParent", "(", ")", "&&", "\"Instruction should be in a basic block!\"", ")", ";", "assert", "(", "I", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "&&", "\"Instruction should be in a function!\"", ")", ";", "Register", "Opcode", "=", "I", ".", "getOpcode", "(", ")", ";", "if", "(", "!", "isPreISelGenericOpcode", "(", "Opcode", ")", ")", "{", "if", "(", "Opcode", "==", "SPIRV", "::", "ASSIGN_TYPE", ")", "{", "auto", "*", "Def", "=", "MRI", "->", "getVRegDef", "(", "I", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ";", "if", "(", "isTypeFoldingSupported", "(", "Def", "->", "getOpcode", "(", ")", ")", ")", "{", "auto", "Res", "=", "selectImpl", "(", "I", ",", "*", "CoverageInfo", ")", ";", "assert", "(", "Res", "||", "Def", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_CONSTANT", ")", ";", "if", "(", "Res", ")", "return", "Res", ";", "}", "MRI", "->", "replaceRegWith", "(", "I", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ",", "I", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ";", "I", ".", "removeFromParent", "(", ")", ";", "}", "else", "if", "(", "I", ".", "getNumDefs", "(", ")", "==", "1", ")", "{", "MRI", "->", "setType", "(", "I", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "LLT", "::", "scalar", "(", "32", ")", ")", ";", "}", "return", "true", ";", "}", "if", "(", "I", ".", "getNumOperands", "(", ")", "!=", "I", ".", "getNumExplicitOperands", "(", ")", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"Generic instr has unexpected implicit operands\\n\"", ")", ";", "return", "false", ";", "}", "bool", "HasDefs", "=", "I", ".", "getNumDefs", "(", ")", ">", "0", ";", "Register", "ResVReg", "=", "HasDefs", "?", "I", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ":", "Register", "(", "0", ")", ";", "SPIRVType", "*", "ResType", "=", "HasDefs", "?", "GR", ".", "getSPIRVTypeForVReg", "(", "ResVReg", ")", ":", "nullptr", ";", "assert", "(", "!", "HasDefs", "||", "ResType", "||", "I", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_GLOBAL_VALUE", ")", ";", "if", "(", "spvSelect", "(", "ResVReg", ",", "ResType", ",", "I", ")", ")", "{", "if", "(", "HasDefs", ")", "{", "MRI", "->", "setType", "(", "ResVReg", ",", "LLT", "::", "scalar", "(", "32", ")", ")", ";", "}", "I", ".", "eraseFromParentAndMarkDBGValuesForRemoval", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Select", "the", "(", "possibly", "generic", ")", "instruction", "I", "to", "only", "use", "target-specific", "opcodes", "." ]

[ "SPIRV", "SPIRV", "\"Instruction should be in a basic block!\"", "\"Instruction should be in a function!\"", "SPIRV::ASSIGN_TYPE", "1", "1", "0", "1", "0", "32", "\"Generic instr has unexpected implicit operands\\n\"", "0", "0", "0", "SPIRV", "SPIRV", "32" ]

[]

[ "<s>", "int", "NVPTXRegisterInfo", "::", "getDwarfRegNum", "(", "unsigned", "RegNum", ",", "bool", "isEH", ")", "const", "{", "return", "0", ";", "}", "</s>" ]

[ "Map", "a", "target", "register", "to", "an", "equivalent", "dwarf", "register", "number", "." ]

[ "NVPTX", "NVPTX", "0" ]

[]

[ "<s>", "void", "finish", "(", ")", "override", "{", "for", "(", "auto", "*", "Sym", ":", "UpdateOther", ")", "copyLocalEntry", "(", "Sym", ",", "Sym", "->", "getVariableValue", "(", ")", ")", ";", "}", "</s>" ]

[ "finish", "-", "after", "all", "the", "new", "live", "ranges", "have", "been", "created", ",", "compute", "the", "remaining", "live", "range", ",", "and", "rewrite", "instructions", "to", "use", "the", "new", "registers", "." ]

[ "PowerPC" ]

[]

[ "<s>", "static", "rtx", "rs6000_complex_function_value", "(", "machine_mode", "mode", ")", "{", "unsigned", "int", "regno", ";", "rtx", "r1", ",", "r2", ";", "machine_mode", "inner", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "unsigned", "int", "inner_bytes", "=", "GET_MODE_UNIT_SIZE", "(", "mode", ")", ";", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", "&&", "TARGET_HARD_FLOAT", "&&", "TARGET_FPRS", ")", "regno", "=", "FP_ARG_RETURN", ";", "else", "{", "regno", "=", "GP_ARG_RETURN", ";", "if", "(", "TARGET_32BIT", "&&", "inner_bytes", ">=", "4", ")", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}", "if", "(", "inner_bytes", ">=", "8", ")", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "r1", "=", "gen_rtx_EXPR_LIST", "(", "inner", ",", "gen_rtx_REG", "(", "inner", ",", "regno", ")", ",", "const0_rtx", ")", ";", "r2", "=", "gen_rtx_EXPR_LIST", "(", "inner", ",", "gen_rtx_REG", "(", "inner", ",", "regno", "+", "1", ")", ",", "GEN_INT", "(", "inner_bytes", ")", ")", ";", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "r1", ",", "r2", ")", ")", ";", "}", "</s>" ]

[ "Return", "an", "RTX", "representing", "where", "to", "find", "the", "function", "value", "of", "a", "function", "returning", "MODE", "." ]

[ "rs6000", "4", "8", "1", "2" ]

[]

[ "<s>", "void", "gen_shifty_op", "(", "int", "code", ",", "rtx", "*", "operands", ")", "{", "int", "value", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "int", "max", ",", "i", ";", "value", "=", "value", "&", "0x1f", ";", "if", "(", "value", "==", "31", ")", "{", "if", "(", "code", "==", "LSHIFTRT", ")", "{", "emit_insn", "(", "gen_rotlsi3_1", "(", "operands", "[", "0", "]", ",", "operands", "[", "0", "]", ")", ")", ";", "emit_insn", "(", "gen_movt", "(", "operands", "[", "0", "]", ")", ")", ";", "return", ";", "}", "else", "if", "(", "code", "==", "ASHIFT", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "REG", "&&", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "0", ")", "{", "emit_insn", "(", "gen_andsi3", "(", "operands", "[", "0", "]", ",", "operands", "[", "0", "]", ",", "const1_rtx", ")", ")", ";", "emit_insn", "(", "gen_rotlsi3_31", "(", "operands", "[", "0", "]", ",", "operands", "[", "0", "]", ")", ")", ";", "return", ";", "}", "}", "}", "else", "if", "(", "value", "==", "0", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operands", "[", "0", "]", ",", "operands", "[", "0", "]", ")", ")", ";", "return", ";", "}", "max", "=", "shift_insns", "[", "value", "]", ";", "for", "(", "i", "=", "0", ";", "i", "<", "max", ";", "i", "++", ")", "gen_ashift", "(", "code", ",", "shift_amounts", "[", "value", "]", "[", "i", "]", ",", "operands", "[", "0", "]", ")", ";", "}", "</s>" ]

[ "Output", "RTL", "to", "split", "a", "constant", "shift", "into", "its", "component", "SH", "constant", "shift", "instructions", "." ]

[ "sh", "2", "0x1f", "31", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "Name", "=", "parseMnemonicSuffix", "(", "Name", ")", ";", "Operands", ".", "push_back", "(", "AMDGPUOperand", "::", "CreateToken", "(", "this", ",", "Name", ",", "NameLoc", ")", ")", ";", "while", "(", "!", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "OperandMatchResultTy", "Res", "=", "parseOperand", "(", "Operands", ",", "Name", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "Parser", ".", "Lex", "(", ")", ";", "switch", "(", "Res", ")", "{", "case", "MatchOperand_Success", ":", "break", ";", "case", "MatchOperand_ParseFail", ":", "Error", "(", "getLexer", "(", ")", ".", "getLoc", "(", ")", ",", "\"failed parsing operand.\"", ")", ";", "while", "(", "!", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "}", "return", "true", ";", "case", "MatchOperand_NoMatch", ":", "Error", "(", "getLexer", "(", ")", ".", "getLoc", "(", ")", ",", "\"not a valid operand.\"", ")", ";", "while", "(", "!", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "}", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU", "\"failed parsing operand.\"", "\"not a valid operand.\"" ]

[]

[ "<s>", "bool", "GCNTTIImpl", "::", "areInlineCompatible", "(", "const", "Function", "*", "Caller", ",", "const", "Function", "*", "Callee", ")", "const", "{", "const", "TargetMachine", "&", "TM", "=", "getTLI", "(", ")", "->", "getTargetMachine", "(", ")", ";", "const", "GCNSubtarget", "*", "CallerST", "=", "static_cast", "<", "const", "GCNSubtarget", "*", ">", "(", "TM", ".", "getSubtargetImpl", "(", "*", "Caller", ")", ")", ";", "const", "GCNSubtarget", "*", "CalleeST", "=", "static_cast", "<", "const", "GCNSubtarget", "*", ">", "(", "TM", ".", "getSubtargetImpl", "(", "*", "Callee", ")", ")", ";", "const", "FeatureBitset", "&", "CallerBits", "=", "CallerST", "->", "getFeatureBits", "(", ")", ";", "const", "FeatureBitset", "&", "CalleeBits", "=", "CalleeST", "->", "getFeatureBits", "(", ")", ";", "FeatureBitset", "RealCallerBits", "=", "CallerBits", "&", "~", "InlineFeatureIgnoreList", ";", "FeatureBitset", "RealCalleeBits", "=", "CalleeBits", "&", "~", "InlineFeatureIgnoreList", ";", "if", "(", "(", "RealCallerBits", "&", "RealCalleeBits", ")", "!=", "RealCalleeBits", ")", "return", "false", ";", "AMDGPU", "::", "SIModeRegisterDefaults", "CallerMode", "(", "*", "Caller", ")", ";", "AMDGPU", "::", "SIModeRegisterDefaults", "CalleeMode", "(", "*", "Callee", ")", ";", "if", "(", "!", "CallerMode", ".", "isInlineCompatible", "(", "CalleeMode", ")", ")", "return", "false", ";", "if", "(", "Callee", "->", "hasFnAttribute", "(", "Attribute", "::", "AlwaysInline", ")", "||", "Callee", "->", "hasFnAttribute", "(", "Attribute", "::", "InlineHint", ")", ")", "return", "true", ";", "if", "(", "InlineMaxBB", ")", "{", "if", "(", "Callee", "->", "size", "(", ")", "==", "1", ")", "return", "true", ";", "size_t", "BBSize", "=", "Caller", "->", "size", "(", ")", "+", "Callee", "->", "size", "(", ")", "-", "1", ";", "return", "BBSize", "<=", "InlineMaxBB", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "callee", "with", "the", "given", "TLI", "can", "be", "inlined", "into", "caller", "with", "this", "TLI", ",", "based", "on", "'nobuiltin", "'", "attributes", "." ]

[ "AMDGPU", "AMDGPU::SIModeRegisterDefaults", "AMDGPU::SIModeRegisterDefaults", "1", "1" ]

[]

[ "<s>", "static", "rtx", "gen_rx_popm_vector", "(", "unsigned", "int", "low", ",", "unsigned", "int", "high", ")", "{", "unsigned", "int", "i", ";", "unsigned", "int", "count", "=", "(", "high", "-", "low", ")", "+", "2", ";", "rtx", "vector", ";", "vector", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "count", ")", ")", ";", "XVECEXP", "(", "vector", ",", "0", ",", "0", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "(", "count", "-", "1", ")", "*", "UNITS_PER_WORD", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "count", "-", "1", ";", "i", "++", ")", "XVECEXP", "(", "vector", ",", "0", ",", "i", "+", "1", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "SImode", ",", "low", "+", "i", ")", ",", "gen_rtx_MEM", "(", "SImode", ",", "i", "==", "0", "?", "stack_pointer_rtx", ":", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "i", "*", "UNITS_PER_WORD", ")", ")", ")", ";", "return", "vector", ";", "}", "</s>" ]

[ "Generate", "a", "PARALLEL", "which", "will", "satisfy", "the", "rx_load_multiple_vector", "predicate", "." ]

[ "rx", "2", "0", "0", "1", "0", "1", "0", "1", "0" ]

[]

[ "<s>", "virtual", "void", "scheduleTree", "(", "unsigned", "SubtreeID", ")", "{", "}", "</s>" ]

[ "Scheduler", "callback", "to", "update", "SubtreeConnectLevels", "when", "a", "tree", "is", "initially", "scheduled", "." ]

[ "Patmos" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "getPostIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDNode", "*", "Op", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "BaseFromLDST", ";", "EVT", "VT", ";", "if", "(", "LoadSDNode", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ")", "{", "BaseFromLDST", "=", "LD", "->", "getBasePtr", "(", ")", ";", "VT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "}", "else", "if", "(", "StoreSDNode", "*", "ST", "=", "dyn_cast", "<", "StoreSDNode", ">", "(", "N", ")", ")", "{", "BaseFromLDST", "=", "ST", "->", "getBasePtr", "(", ")", ";", "VT", "=", "ST", "->", "getMemoryVT", "(", ")", ";", "}", "else", "{", "return", "false", ";", "}", "if", "(", "Op", "->", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", ")", "{", "AM", "=", "ISD", "::", "POST_INC", ";", "Base", "=", "Op", "->", "getOperand", "(", "0", ")", ";", "Offset", "=", "Op", "->", "getOperand", "(", "1", ")", ";", "if", "(", "BaseFromLDST", "!=", "Base", "&&", "BaseFromLDST", "==", "Offset", ")", "{", "std", "::", "swap", "(", "Base", ",", "Offset", ")", ";", "}", "if", "(", "!", "(", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i16", "||", "VT", "==", "MVT", "::", "i32", ")", ")", "{", "return", "false", ";", "}", "if", "(", "ConstantSDNode", "*", "ConstOffset", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Offset", ")", ")", "{", "uint64_t", "imm", "=", "ConstOffset", "->", "getZExtValue", "(", ")", ";", "if", "(", "!", "isInt", "<", "12", ">", "(", "imm", ")", ")", "{", "return", "false", ";", "}", "}", "return", "BaseFromLDST", "==", "Base", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "this", "node", "can", "be", "combined", "with", "a", "load", "/", "store", "to", "form", "a", "post-indexed", "load", "/", "store", "." ]

[ "RI5CY", "RISCV", "ISD::MemIndexedMode", "ISD::ADD", "ISD::POST_INC", "0", "1", "MVT::i8", "MVT::i16", "MVT::i32", "12" ]

[]

[ "<s>", "bool", "ARM64TargetLowering", "::", "isUsedByReturnOnly", "(", "SDNode", "*", "N", ",", "SDValue", "&", "Chain", ")", "const", "{", "if", "(", "N", "->", "getNumValues", "(", ")", "!=", "1", ")", "return", "false", ";", "if", "(", "!", "N", "->", "hasNUsesOfValue", "(", "1", ",", "0", ")", ")", "return", "false", ";", "SDValue", "TCChain", "=", "Chain", ";", "SDNode", "*", "Copy", "=", "*", "N", "->", "use_begin", "(", ")", ";", "if", "(", "Copy", "->", "getOpcode", "(", ")", "==", "ISD", "::", "CopyToReg", ")", "{", "if", "(", "Copy", "->", "getOperand", "(", "Copy", "->", "getNumOperands", "(", ")", "-", "1", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "Glue", ")", "return", "false", ";", "TCChain", "=", "Copy", "->", "getOperand", "(", "0", ")", ";", "}", "else", "if", "(", "Copy", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_EXTEND", ")", "return", "false", ";", "bool", "HasRet", "=", "false", ";", "for", "(", "SDNode", "*", "Node", ":", "Copy", "->", "uses", "(", ")", ")", "{", "if", "(", "Node", "->", "getOpcode", "(", ")", "!=", "ARM64ISD", "::", "RET_FLAG", ")", "return", "false", ";", "HasRet", "=", "true", ";", "}", "if", "(", "!", "HasRet", ")", "return", "false", ";", "Chain", "=", "TCChain", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "result", "of", "the", "specified", "node", "is", "used", "by", "a", "return", "node", "only", "." ]

[ "ARM64", "ARM64", "1", "1", "0", "ISD::CopyToReg", "1", "MVT::Glue", "0", "ISD::FP_EXTEND", "ARM64ISD::RET_FLAG" ]

[]

[ "<s>", "static", "int", "spu_sched_issue_rate", "(", "void", ")", "{", "return", "2", ";", "}", "</s>" ]

[ "Insn", "scheduling", "routines", ",", "primarily", "for", "dual", "issue", "." ]

[ "spu", "2" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ",", "MCContext", "&", "Ctx", ")", "const", "override", "{", "unsigned", "Size", "=", "1", "<<", "getFixupKindLog2Size", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "assert", "(", "Fixup", ".", "getOffset", "(", ")", "+", "Size", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "assert", "(", "isIntN", "(", "Size", "*", "8", "+", "1", ",", "Value", ")", "&&", "\"Value does not fit in the Fixup field\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "Size", ";", "++", "i", ")", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "i", "]", "=", "uint8_t", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", ";", "}", "</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", "." ]

[ "X86", "1", "\"Invalid fixup offset!\"", "8", "1", "\"Value does not fit in the Fixup field\"", "0", "8" ]

[]

[ "<s>", "static", "rtx", "bpf_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", "ATTRIBUTE_UNUSED", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "ignore", "ATTRIBUTE_UNUSED", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "int", "code", "=", "DECL_MD_FUNCTION_CODE", "(", "fndecl", ")", ";", "if", "(", "code", "==", "BPF_BUILTIN_LOAD_BYTE", "||", "code", "==", "BPF_BUILTIN_LOAD_HALF", "||", "code", "==", "BPF_BUILTIN_LOAD_WORD", ")", "{", "enum", "insn_code", "abs_icode", "=", "(", "code", "==", "BPF_BUILTIN_LOAD_BYTE", "?", "CODE_FOR_ldabsb", ":", "code", "==", "BPF_BUILTIN_LOAD_HALF", "?", "CODE_FOR_ldabsh", ":", "CODE_FOR_ldabsw", ")", ";", "enum", "insn_code", "ind_icode", "=", "(", "code", "==", "BPF_BUILTIN_LOAD_BYTE", "?", "CODE_FOR_ldindb", ":", "code", "==", "BPF_BUILTIN_LOAD_HALF", "?", "CODE_FOR_ldindh", ":", "CODE_FOR_ldindw", ")", ";", "tree", "offset_arg", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "struct", "expand_operand", "ops", "[", "2", "]", ";", "create_input_operand", "(", "&", "ops", "[", "0", "]", ",", "expand_normal", "(", "offset_arg", ")", ",", "TYPE_MODE", "(", "TREE_TYPE", "(", "offset_arg", ")", ")", ")", ";", "create_input_operand", "(", "&", "ops", "[", "1", "]", ",", "const0_rtx", ",", "SImode", ")", ";", "if", "(", "!", "maybe_expand_insn", "(", "abs_icode", ",", "2", ",", "ops", ")", "&&", "!", "maybe_expand_insn", "(", "ind_icode", ",", "2", ",", "ops", ")", ")", "{", "error", "(", "\"invalid argument to built-in function\"", ")", ";", "return", "gen_rtx_REG", "(", "ops", "[", "0", "]", ".", "mode", ",", "BPF_R0", ")", ";", "}", "return", "gen_rtx_REG", "(", "ops", "[", "0", "]", ".", "mode", ",", "BPF_R0", ")", ";", "}", "else", "if", "(", "code", "==", "-", "1", ")", "{", "tree", "arg", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "if", "(", "arg", "==", "NULL_TREE", ")", "return", "NULL_RTX", ";", "auto_vec", "<", "unsigned", "int", ",", "16", ">", "accessors", ";", "tree", "container", ";", "if", "(", "TREE_CODE", "(", "arg", ")", "==", "SSA_NAME", ")", "{", "gimple", "*", "def_stmt", "=", "SSA_NAME_DEF_STMT", "(", "arg", ")", ";", "if", "(", "is_gimple_assign", "(", "def_stmt", ")", ")", "arg", "=", "gimple_assign_rhs1", "(", "def_stmt", ")", ";", "else", "return", "expand_normal", "(", "arg", ")", ";", "}", "if", "(", "is_attr_preserve_access", "(", "arg", ")", ")", "return", "expand_normal", "(", "arg", ")", ";", "container", "=", "bpf_core_compute", "(", "arg", ",", "&", "accessors", ")", ";", "if", "(", "accessors", ".", "length", "(", ")", "<", "1", ")", "return", "expand_normal", "(", "arg", ")", ";", "accessors", ".", "reverse", "(", ")", ";", "container", "=", "TREE_TYPE", "(", "container", ")", ";", "rtx_code_label", "*", "label", "=", "gen_label_rtx", "(", ")", ";", "LABEL_PRESERVE_P", "(", "label", ")", "=", "1", ";", "emit_label", "(", "label", ")", ";", "const", "char", "*", "section_name", ";", "if", "(", "current_function_decl", "&&", "DECL_SECTION_NAME", "(", "current_function_decl", ")", ")", "section_name", "=", "DECL_SECTION_NAME", "(", "current_function_decl", ")", ";", "else", "section_name", "=", "\".text\"", ";", "bpf_core_reloc_add", "(", "container", ",", "section_name", ",", "&", "accessors", ",", "label", ")", ";", "return", "expand_normal", "(", "arg", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Expand", "a", "call", "to", "a", "BPF-specific", "built-in", "function", "that", "was", "set", "up", "with", "bpf_init_builtins", "." ]

[ "bpf", "0", "0", "2", "0", "1", "2", "2", "\"invalid argument to built-in function\"", "0", "0", "1", "0", "16", "1", "1", "\".text\"" ]

[]

[ "<s>", "inline", "static", "int", "thumb_index_register_rtx_p", "(", "rtx", "x", ",", "int", "strict_p", ")", "{", "return", "thumb_base_register_rtx_p", "(", "x", ",", "QImode", ",", "strict_p", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "x", "is", "a", "legitimate", "index", "register", ".", "This", "is", "the", "case", "for", "any", "base", "register", "that", "can", "access", "a", "QImode", "object", "." ]

[ "arm" ]

[]

[ "<s>", "void", "HexagonPassConfig", "::", "addPreEmitPass", "(", ")", "{", "bool", "NoOpt", "=", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", ";", "if", "(", "!", "NoOpt", ")", "addPass", "(", "createHexagonNewValueJump", "(", ")", ",", "false", ")", ";", "addPass", "(", "createHexagonExpandPredSpillCode", "(", ")", ",", "false", ")", ";", "addPass", "(", "createHexagonSplitTFRCondSets", "(", ")", ",", "false", ")", ";", "if", "(", "!", "NoOpt", ")", "{", "if", "(", "!", "DisableHardwareLoops", ")", "addPass", "(", "createHexagonFixupHwLoops", "(", ")", ",", "false", ")", ";", "addPass", "(", "createHexagonPacketizer", "(", ")", ",", "false", ")", ";", "}", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

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

[]

[ "<s>", "bool", "evaluateBranch", "(", "const", "MCInst", "&", "Inst", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ",", "uint64_t", "&", "Target", ")", "const", "{", "unsigned", "LblOperand", "=", "Inst", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "Bcc", "?", "1", ":", "0", ";", "if", "(", "Info", "->", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ".", "OpInfo", "[", "LblOperand", "]", ".", "OperandType", "!=", "MCOI", "::", "OPERAND_PCREL", ")", "return", "false", ";", "int64_t", "Imm", "=", "Inst", ".", "getOperand", "(", "LblOperand", ")", ".", "getImm", "(", ")", ";", "Target", "=", "Addr", "+", "Imm", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64::Bcc", "1", "0" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "HSAILTargetLowering", "::", "getRepRegClassFor", "(", "MVT", "VT", ")", "const", "{", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "i64", ":", "case", "MVT", "::", "f64", ":", "return", "&", "HSAIL", "::", "GPR64RegClass", ";", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "f32", ":", "return", "&", "HSAIL", "::", "GPR32RegClass", ";", "case", "MVT", "::", "i1", ":", "return", "&", "HSAIL", "::", "CRRegClass", ";", "default", ":", "llvm_unreachable", "(", "\"Cannot find register class for value type\"", ")", ";", "break", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "Return", "the", "'representative", "'", "register", "class", "for", "the", "specified", "value", "type", "." ]

[ "HSAIL", "HSAIL", "MVT::i64", "MVT::f64", "HSAIL::GPR64RegClass", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::f32", "HSAIL::GPR32RegClass", "MVT::i1", "HSAIL::CRRegClass", "\"Cannot find register class for value type\"" ]

[]

[ "<s>", "bool", "ARMBlockPlacement", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "ARMSubtarget", "&", "ST", "=", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "!", "ST", ".", "hasLOB", "(", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "DEBUG_PREFIX", "<<", "\"Running on \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "ST", ".", "getInstrInfo", "(", ")", ")", ";", "BBUtils", "=", "std", "::", "unique_ptr", "<", "ARMBasicBlockUtils", ">", "(", "new", "ARMBasicBlockUtils", "(", "MF", ")", ")", ";", "MF", ".", "RenumberBlocks", "(", ")", ";", "BBUtils", "->", "computeAllBlockSizes", "(", ")", ";", "BBUtils", "->", "adjustBBOffsetsAfter", "(", "&", "MF", ".", "front", "(", ")", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "*", "ML", ":", "*", "MLI", ")", "{", "MachineBasicBlock", "*", "Preheader", "=", "ML", "->", "getLoopPredecessor", "(", ")", ";", "if", "(", "!", "Preheader", ")", "continue", ";", "for", "(", "auto", "&", "Terminator", ":", "Preheader", "->", "terminators", "(", ")", ")", "{", "if", "(", "Terminator", ".", "getOpcode", "(", ")", "!=", "ARM", "::", "t2WhileLoopStart", ")", "continue", ";", "MachineBasicBlock", "*", "LoopExit", "=", "Terminator", ".", "getOperand", "(", "1", ")", ".", "getMBB", "(", ")", ";", "if", "(", "!", "LoopExit", "->", "getPrevNode", "(", ")", ")", "continue", ";", "if", "(", "blockIsBefore", "(", "Preheader", ",", "LoopExit", ")", ")", "continue", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "DEBUG_PREFIX", "<<", "\"Found a backwards WLS from \"", "<<", "Preheader", "->", "getFullName", "(", ")", "<<", "\" to \"", "<<", "LoopExit", "->", "getFullName", "(", ")", "<<", "\"\\n\"", ")", ";", "bool", "CanMove", "=", "true", ";", "for", "(", "auto", "&", "LoopExitTerminator", ":", "LoopExit", "->", "terminators", "(", ")", ")", "{", "if", "(", "LoopExitTerminator", ".", "getOpcode", "(", ")", "!=", "ARM", "::", "t2WhileLoopStart", ")", "continue", ";", "MachineBasicBlock", "*", "LoopExit2", "=", "LoopExitTerminator", ".", "getOperand", "(", "1", ")", ".", "getMBB", "(", ")", ";", "if", "(", "!", "blockIsBefore", "(", "LoopExit2", ",", "LoopExit", ")", "&&", "(", "LoopExit2", "==", "Preheader", "||", "blockIsBefore", "(", "LoopExit2", ",", "Preheader", ")", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "DEBUG_PREFIX", "<<", "\"Can't move the target block as it would \"", "\"introduce a new backwards WLS branch\\n\"", ")", ";", "CanMove", "=", "false", ";", "break", ";", "}", "}", "if", "(", "CanMove", ")", "{", "for", "(", "auto", "It", "=", "LoopExit", "->", "getIterator", "(", ")", ";", "It", "!=", "Preheader", "->", "getIterator", "(", ")", ";", "It", "++", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "&", "*", "It", ";", "for", "(", "auto", "&", "Terminator", ":", "MBB", "->", "terminators", "(", ")", ")", "{", "if", "(", "Terminator", ".", "getOpcode", "(", ")", "!=", "ARM", "::", "t2LoopEnd", "&&", "Terminator", ".", "getOpcode", "(", ")", "!=", "ARM", "::", "t2LoopEndDec", ")", "continue", ";", "MachineBasicBlock", "*", "LETarget", "=", "Terminator", ".", "getOperand", "(", "2", ")", ".", "getMBB", "(", ")", ";", "if", "(", "LETarget", "==", "LoopExit", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "DEBUG_PREFIX", "<<", "\"Can't move the target block as it would \"", "\"introduce a new forwards LE branch\\n\"", ")", ";", "CanMove", "=", "false", ";", "break", ";", "}", "}", "}", "if", "(", "!", "CanMove", ")", "break", ";", "}", "if", "(", "CanMove", ")", "{", "moveBasicBlock", "(", "LoopExit", ",", "Preheader", ")", ";", "Changed", "=", "true", ";", "break", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "\"Running on \"", "\"\\n\"", "ARM", "ARM", "ARM", "ARM::t2WhileLoopStart", "1", "\"Found a backwards WLS from \"", "\" to \"", "\"\\n\"", "ARM::t2WhileLoopStart", "1", "\"Can't move the target block as it would \"", "\"introduce a new backwards WLS branch\\n\"", "ARM::t2LoopEnd", "ARM::t2LoopEndDec", "2", "\"Can't move the target block as it would \"", "\"introduce a new forwards LE branch\\n\"" ]

[]

[ "<s>", "static", "bool", "expand_vec_perm_vpermil", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "rtx", "rperm", "[", "8", "]", ",", "vperm", ";", "unsigned", "i", ";", "if", "(", "!", "TARGET_AVX", "||", "d", "->", "vmode", "!=", "V8SFmode", "||", "!", "d", "->", "one_operand_p", ")", "return", "false", ";", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "++", "i", ")", "{", "unsigned", "e", "=", "d", "->", "perm", "[", "i", "]", ";", "if", "(", "i", "<", "4", "?", "e", ">=", "4", ":", "e", "<", "4", ")", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "++", "i", ")", "{", "unsigned", "e", "=", "d", "->", "perm", "[", "i", "]", ";", "if", "(", "e", ">=", "8", "+", "4", ")", "e", "-=", "8", ";", "else", "if", "(", "e", ">=", "4", ")", "e", "-=", "4", ";", "rperm", "[", "i", "]", "=", "GEN_INT", "(", "e", ")", ";", "}", "vperm", "=", "gen_rtx_CONST_VECTOR", "(", "V8SImode", ",", "gen_rtvec_v", "(", "8", ",", "rperm", ")", ")", ";", "vperm", "=", "force_reg", "(", "V8SImode", ",", "vperm", ")", ";", "emit_insn", "(", "gen_avx_vpermilvarv8sf3", "(", "d", "->", "target", ",", "d", "->", "op0", ",", "vperm", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "ix86_expand_vec_perm_builtin_1", ".", "Try", "to", "implement", "D", "in", "terms", "of", "the", "variable", "form", "of", "vpermilps", ".", "Note", "that", "we", "will", "have", "already", "failed", "the", "immediate", "input", "vpermilps", ",", "which", "requires", "that", "the", "high", "and", "low", "part", "shuffle", "be", "identical", ";", "the", "variable", "form", "does", "n't", "require", "that", "." ]

[ "i386", "8", "0", "8", "4", "4", "4", "0", "8", "8", "4", "8", "4", "4", "8" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "reMaterialize", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "const", "MachineInstr", "&", "Orig", ",", "const", "TargetRegisterInfo", "&", "TRI", ")", "const", "{", "bool", "ClobbersEFLAGS", "=", "false", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "Orig", ".", "operands", "(", ")", ")", "{", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isDef", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "X86", "::", "EFLAGS", ")", "{", "ClobbersEFLAGS", "=", "true", ";", "break", ";", "}", "}", "if", "(", "ClobbersEFLAGS", "&&", "!", "isSafeToClobberEFLAGS", "(", "MBB", ",", "I", ")", ")", "{", "int", "Value", ";", "switch", "(", "Orig", ".", "getOpcode", "(", ")", ")", "{", "case", "X86", "::", "MOV32r0", ":", "Value", "=", "0", ";", "break", ";", "case", "X86", "::", "MOV32r1", ":", "Value", "=", "1", ";", "break", ";", "case", "X86", "::", "MOV32r_1", ":", "Value", "=", "-", "1", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Unexpected instruction!\"", ")", ";", "}", "const", "DebugLoc", "&", "DL", "=", "Orig", ".", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "X86", "::", "MOV32ri", ")", ")", ".", "addOperand", "(", "Orig", ".", "getOperand", "(", "0", ")", ")", ".", "addImm", "(", "Value", ")", ";", "}", "else", "{", "MachineInstr", "*", "MI", "=", "MBB", ".", "getParent", "(", ")", "->", "CloneMachineInstr", "(", "&", "Orig", ")", ";", "MBB", ".", "insert", "(", "I", ",", "MI", ")", ";", "}", "MachineInstr", "*", "NewMI", "=", "std", "::", "prev", "(", "I", ")", ";", "NewMI", "->", "substituteRegister", "(", "Orig", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "DestReg", ",", "SubIdx", ",", "TRI", ")", ";", "}", "</s>" ]

[ "Re-issue", "the", "specified", "'original", "'", "instruction", "at", "the", "specific", "location", "targeting", "a", "new", "destination", "register", "." ]

[ "X86", "X86", "X86::EFLAGS", "X86::MOV32r0", "0", "X86::MOV32r1", "1", "X86::MOV32r_1", "1", "\"Unexpected instruction!\"", "X86::MOV32ri", "0", "0" ]

[]

[ "<s>", "static", "tree", "i386_pe_maybe_mangle_decl_assembler_name", "(", "tree", "decl", ",", "tree", "id", ")", "{", "tree", "new_id", "=", "NULL_TREE", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "{", "unsigned", "int", "ccvt", "=", "ix86_get_callcvt", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "if", "(", "(", "ccvt", "&", "IX86_CALLCVT_STDCALL", ")", "!=", "0", ")", "{", "if", "(", "TARGET_RTD", ")", "return", "NULL_TREE", ";", "new_id", "=", "gen_stdcall_or_fastcall_suffix", "(", "decl", ",", "id", ",", "false", ")", ";", "}", "else", "if", "(", "(", "ccvt", "&", "IX86_CALLCVT_FASTCALL", ")", "!=", "0", ")", "new_id", "=", "gen_stdcall_or_fastcall_suffix", "(", "decl", ",", "id", ",", "true", ")", ";", "}", "return", "new_id", ";", "}", "</s>" ]

[ "Maybe", "decorate", "and", "get", "a", "new", "identifier", "for", "the", "DECL", "of", "a", "stdcall", "or", "fastcall", "function", ".", "The", "original", "identifier", "is", "supplied", "in", "ID", "." ]

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

[]

[ "<s>", "SDValue", "ARMTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "assert", "(", "0", "&&", "\"Don't know how to custom lower this!\"", ")", ";", "abort", "(", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "Subtarget", "->", "isTargetDarwin", "(", ")", "?", "LowerGlobalAddressDarwin", "(", "Op", ",", "DAG", ")", ":", "LowerGlobalAddressELF", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CALL", ":", "return", "LowerCALL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RET", ":", "return", "LowerRET", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "BR_JT", ":", "return", "LowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ",", "VarArgsFrameIndex", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "LowerFP_TO_INT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCOPYSIGN", ":", "return", "LowerFCOPYSIGN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FORMAL_ARGUMENTS", ":", "return", "LowerFORMAL_ARGUMENTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "break", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "return", "LowerGLOBAL_OFFSET_TABLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BIT_CONVERT", ":", "return", "ExpandBIT_CONVERT", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "return", "ExpandSRx", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ",", "Subtarget", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "ARM", "ARM", "0", "\"Don't know how to custom lower this!\"", "ISD::ConstantPool", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::CALL", "ISD::RET", "ISD::SELECT_CC", "ISD::BR_CC", "ISD::BR_JT", "ISD::VASTART", "ISD::SINT_TO_FP", "ISD::UINT_TO_FP", "ISD::FP_TO_SINT", "ISD::FP_TO_UINT", "ISD::FCOPYSIGN", "ISD::FORMAL_ARGUMENTS", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::GLOBAL_OFFSET_TABLE", "ISD::INTRINSIC_WO_CHAIN", "ISD::BIT_CONVERT", "ISD::SRL", "ISD::SRA" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MCAsmInfo", "*", "MAI", "=", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "MI", ".", "getDesc", "(", ")", ";", "if", "(", "MCID", ".", "getSize", "(", ")", ")", "return", "MCID", ".", "getSize", "(", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "TargetOpcode", "::", "BUNDLE", ":", "return", "getInstBundleLength", "(", "MI", ")", ";", "case", "ARM", "::", "MOVi16_ga_pcrel", ":", "case", "ARM", "::", "MOVTi16_ga_pcrel", ":", "case", "ARM", "::", "t2MOVi16_ga_pcrel", ":", "case", "ARM", "::", "t2MOVTi16_ga_pcrel", ":", "return", "4", ";", "case", "ARM", "::", "MOVi32imm", ":", "case", "ARM", "::", "t2MOVi32imm", ":", "return", "8", ";", "case", "ARM", "::", "CONSTPOOL_ENTRY", ":", "case", "ARM", "::", "JUMPTABLE_INSTS", ":", "case", "ARM", "::", "JUMPTABLE_ADDRS", ":", "case", "ARM", "::", "JUMPTABLE_TBB", ":", "case", "ARM", "::", "JUMPTABLE_TBH", ":", "return", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "case", "ARM", "::", "Int_eh_sjlj_longjmp", ":", "return", "16", ";", "case", "ARM", "::", "tInt_eh_sjlj_longjmp", ":", "return", "10", ";", "case", "ARM", "::", "tInt_WIN_eh_sjlj_longjmp", ":", "return", "12", ";", "case", "ARM", "::", "Int_eh_sjlj_setjmp", ":", "case", "ARM", "::", "Int_eh_sjlj_setjmp_nofp", ":", "return", "20", ";", "case", "ARM", "::", "tInt_eh_sjlj_setjmp", ":", "case", "ARM", "::", "t2Int_eh_sjlj_setjmp", ":", "case", "ARM", "::", "t2Int_eh_sjlj_setjmp_nofp", ":", "return", "12", ";", "case", "ARM", "::", "SPACE", ":", "return", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "case", "ARM", "::", "INLINEASM", ":", "case", "ARM", "::", "INLINEASM_BR", ":", "{", "unsigned", "Size", "=", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "MAI", ")", ";", "if", "(", "!", "MF", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", "->", "isThumbFunction", "(", ")", ")", "Size", "=", "alignTo", "(", "Size", ",", "4", ")", ";", "return", "Size", ";", "}", "case", "ARM", "::", "SpeculationBarrierISBDSBEndBB", ":", "case", "ARM", "::", "t2SpeculationBarrierISBDSBEndBB", ":", "return", "8", ";", "case", "ARM", "::", "SpeculationBarrierSBEndBB", ":", "case", "ARM", "::", "t2SpeculationBarrierSBEndBB", ":", "return", "4", ";", "}", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "ARM", "ARM", "0", "ARM::MOVi16_ga_pcrel", "ARM::MOVTi16_ga_pcrel", "ARM::t2MOVi16_ga_pcrel", "ARM::t2MOVTi16_ga_pcrel", "4", "ARM::MOVi32imm", "ARM::t2MOVi32imm", "8", "ARM::CONSTPOOL_ENTRY", "ARM::JUMPTABLE_INSTS", "ARM::JUMPTABLE_ADDRS", "ARM::JUMPTABLE_TBB", "ARM::JUMPTABLE_TBH", "2", "ARM::Int_eh_sjlj_longjmp", "16", "ARM::tInt_eh_sjlj_longjmp", "10", "ARM::tInt_WIN_eh_sjlj_longjmp", "12", "ARM::Int_eh_sjlj_setjmp", "ARM::Int_eh_sjlj_setjmp_nofp", "20", "ARM::tInt_eh_sjlj_setjmp", "ARM::t2Int_eh_sjlj_setjmp", "ARM::t2Int_eh_sjlj_setjmp_nofp", "12", "ARM::SPACE", "1", "ARM::INLINEASM", "ARM::INLINEASM_BR", "0", "ARM", "4", "ARM::SpeculationBarrierISBDSBEndBB", "ARM::t2SpeculationBarrierISBDSBEndBB", "8", "ARM::SpeculationBarrierSBEndBB", "ARM::t2SpeculationBarrierSBEndBB", "4" ]

[]

[ "<s>", "bool", "AArch64A53Fix835769", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64A53Fix835769 *****\\n\"", ")", ";", "bool", "Changed", "=", "false", ";", "TII", "=", "F", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "auto", "&", "MBB", ":", "F", ")", "{", "Changed", "|=", "runOnBasicBlock", "(", "MBB", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"***** AArch64A53Fix835769 *****\\n\"" ]

[]

[ "<s>", "void", "nvptx_declare_object_name", "(", "FILE", "*", "file", ",", "const", "char", "*", "name", ",", "const_tree", "decl", ")", "{", "write_var_marker", "(", "file", ",", "true", ",", "TREE_PUBLIC", "(", "decl", ")", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s\"", ",", "(", "!", "TREE_PUBLIC", "(", "decl", ")", "?", "\"\"", ":", "DECL_WEAK", "(", "decl", ")", "?", "\".weak \"", ":", "\".visible \"", ")", ")", ";", "tree", "type", "=", "TREE_TYPE", "(", "decl", ")", ";", "HOST_WIDE_INT", "obj_size", "=", "tree_to_shwi", "(", "DECL_SIZE_UNIT", "(", "decl", ")", ")", ";", "nvptx_assemble_decl_begin", "(", "file", ",", "name", ",", "section_for_decl", "(", "decl", ")", ",", "type", ",", "obj_size", ",", "DECL_ALIGN", "(", "decl", ")", ")", ";", "}", "</s>" ]

[ "Implement", "the", "ASM_DECLARE_OBJECT_NAME", "macro", ".", "Used", "to", "start", "writing", "a", "variable", "DECL", "with", "NAME", "to", "FILE", "." ]

[ "nvptx", "\"\\t%s\"", "\"\"", "\".weak \"", "\".visible \"" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintType", "SystemZTargetLowering", "::", "getConstraintType", "(", "const", "std", "::", "string", "&", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'a'", ":", "case", "'d'", ":", "case", "'f'", ":", "case", "'h'", ":", "case", "'r'", ":", "return", "C_RegisterClass", ";", "case", "'Q'", ":", "case", "'R'", ":", "case", "'S'", ":", "case", "'T'", ":", "case", "'m'", ":", "return", "C_Memory", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'M'", ":", "return", "C_Other", ";", "default", ":", "break", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

[ "SystemZ", "SystemZ", "1", "0" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", "AddrSpace", ",", "unsigned", "Align", ",", "bool", "*", "IsFast", ")", "const", "{", "if", "(", "IsFast", ")", "*", "IsFast", "=", "false", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", "||", "VT", "==", "MVT", "::", "Other", ")", "return", "false", ";", "if", "(", "AddrSpace", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", ")", "{", "return", "Align", "%", "4", "==", "0", ";", "}", "if", "(", "IsFast", ")", "*", "IsFast", "=", "true", ";", "return", "VT", ".", "bitsGT", "(", "MVT", "::", "i32", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "allows", "unaligned", "memory", "accesses", "of", "the", "specified", "type", "." ]

[ "R600", "SI", "MVT::Other", "AMDGPUAS::LOCAL_ADDRESS", "4", "0", "MVT::i32" ]

[]

[ "<s>", "bool", "AMDGPUAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "AMDGPUSubtarget", "&", "STM", "=", "TM", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "STM", ".", "dumpCode", "(", ")", ")", "{", "MF", ".", "dump", "(", ")", ";", "}", "SetupMachineFunction", "(", "MF", ")", ";", "if", "(", "OutStreamer", ".", "hasRawTextSupport", "(", ")", ")", "{", "OutStreamer", ".", "EmitRawText", "(", "\"@\"", "+", "MF", ".", "getName", "(", ")", "+", "\":\"", ")", ";", "}", "OutStreamer", ".", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getTextSection", "(", ")", ")", ";", "if", "(", "STM", ".", "device", "(", ")", "->", "getGeneration", "(", ")", ">", "AMDGPUDeviceInfo", "::", "HD6XXX", ")", "{", "EmitProgramInfo", "(", "MF", ")", ";", "}", "EmitFunctionBody", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "R600", "\"@\"", "\":\"", "AMDGPUDeviceInfo::HD6XXX" ]

[]

[ "<s>", "WebAssemblySubtarget", "::", "WebAssemblySubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ")", ":", "WebAssemblyGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "TargetTriple", "(", "TT", ")", ",", "FrameLowering", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "TSInfo", "(", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "}", "</s>" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "void", "HexagonShuffler", "::", "append", "(", "MCInst", "const", "*", "ID", ",", "MCInst", "const", "*", "Extender", ",", "unsigned", "S", ",", "bool", "X", ")", "{", "HexagonInstr", "PI", "(", "MCII", ",", "ID", ",", "Extender", ",", "S", ",", "X", ")", ";", "Packet", ".", "push_back", "(", "PI", ")", ";", "}", "</s>" ]

[ "Append", "from", "a", "list", "of", "StringRefs", "." ]

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

[]

[ "<s>", "std", "::", "unique_ptr", "<", "MCObjectWriter", ">", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "override", "{", "return", "createZ80OMFObjectWriter", "(", "OS", ")", ";", "}", "</s>" ]

[ "Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "." ]

[ "Z80", "Z80" ]

[]

[ "<s>", "unsigned", "PIC16RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "int", "*", "Value", ",", "RegScavenger", "*", "RS", ")", "const", "{", "return", "0", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "PIC16", "PIC16", "0" ]

[]

[ "<s>", "void", "s390_asm_output_function_label", "(", "FILE", "*", "out_file", ",", "const", "char", "*", "fname", ",", "tree", "decl", ")", "{", "int", "hw_before", ",", "hw_after", ";", "s390_function_num_hotpatch_hw", "(", "decl", ",", "&", "hw_before", ",", "&", "hw_after", ")", ";", "if", "(", "hw_before", ">", "0", ")", "{", "unsigned", "int", "function_alignment", ";", "int", "i", ";", "asm_fprintf", "(", "out_file", ",", "\"\\tnopr\\t%%r0\"", "\"\\t# pre-label NOPs for hotpatch (%d halfwords)\\n\"", ",", "hw_before", ")", ";", "for", "(", "i", "=", "1", ";", "i", "<", "hw_before", ";", "i", "++", ")", "fputs", "(", "\"\\tnopr\\t%r0\\n\"", ",", "out_file", ")", ";", "function_alignment", "=", "MAX", "(", "8", ",", "DECL_ALIGN", "(", "decl", ")", "/", "BITS_PER_UNIT", ")", ";", "if", "(", "!", "DECL_USER_ALIGN", "(", "decl", ")", ")", "function_alignment", "=", "MAX", "(", "function_alignment", ",", "(", "unsigned", "int", ")", "align_functions", ".", "levels", "[", "0", "]", ".", "get_value", "(", ")", ")", ";", "fputs", "(", "\"\\t# alignment for hotpatch\\n\"", ",", "out_file", ")", ";", "ASM_OUTPUT_ALIGN", "(", "out_file", ",", "align_functions", ".", "levels", "[", "0", "]", ".", "log", ")", ";", "}", "if", "(", "S390_USE_TARGET_ATTRIBUTE", "&&", "TARGET_DEBUG_ARG", ")", "{", "asm_fprintf", "(", "out_file", ",", "\"\\t# fn:%s ar%d\\n\"", ",", "fname", ",", "s390_arch", ")", ";", "asm_fprintf", "(", "out_file", ",", "\"\\t# fn:%s tu%d\\n\"", ",", "fname", ",", "s390_tune", ")", ";", "asm_fprintf", "(", "out_file", ",", "\"\\t# fn:%s sg%d\\n\"", ",", "fname", ",", "s390_stack_guard", ")", ";", "asm_fprintf", "(", "out_file", ",", "\"\\t# fn:%s ss%d\\n\"", ",", "fname", ",", "s390_stack_size", ")", ";", "asm_fprintf", "(", "out_file", ",", "\"\\t# fn:%s bc%d\\n\"", ",", "fname", ",", "s390_branch_cost", ")", ";", "asm_fprintf", "(", "out_file", ",", "\"\\t# fn:%s wf%d\\n\"", ",", "fname", ",", "s390_warn_framesize", ")", ";", "asm_fprintf", "(", "out_file", ",", "\"\\t# fn:%s ba%d\\n\"", ",", "fname", ",", "TARGET_BACKCHAIN", ")", ";", "asm_fprintf", "(", "out_file", ",", "\"\\t# fn:%s hd%d\\n\"", ",", "fname", ",", "TARGET_HARD_DFP", ")", ";", "asm_fprintf", "(", "out_file", ",", "\"\\t# fn:%s hf%d\\n\"", ",", "fname", ",", "!", "TARGET_SOFT_FLOAT", ")", ";", "asm_fprintf", "(", "out_file", ",", "\"\\t# fn:%s ht%d\\n\"", ",", "fname", ",", "TARGET_OPT_HTM", ")", ";", "asm_fprintf", "(", "out_file", ",", "\"\\t# fn:%s vx%d\\n\"", ",", "fname", ",", "TARGET_OPT_VX", ")", ";", "asm_fprintf", "(", "out_file", ",", "\"\\t# fn:%s ps%d\\n\"", ",", "fname", ",", "TARGET_PACKED_STACK", ")", ";", "asm_fprintf", "(", "out_file", ",", "\"\\t# fn:%s se%d\\n\"", ",", "fname", ",", "TARGET_SMALL_EXEC", ")", ";", "asm_fprintf", "(", "out_file", ",", "\"\\t# fn:%s mv%d\\n\"", ",", "fname", ",", "TARGET_MVCLE", ")", ";", "asm_fprintf", "(", "out_file", ",", "\"\\t# fn:%s zv%d\\n\"", ",", "fname", ",", "TARGET_ZVECTOR", ")", ";", "asm_fprintf", "(", "out_file", ",", "\"\\t# fn:%s wd%d\\n\"", ",", "fname", ",", "s390_warn_dynamicstack_p", ")", ";", "}", "ASM_OUTPUT_LABEL", "(", "out_file", ",", "fname", ")", ";", "if", "(", "hw_after", ">", "0", ")", "asm_fprintf", "(", "out_file", ",", "\"\\t# post-label NOPs for hotpatch (%d halfwords)\\n\"", ",", "hw_after", ")", ";", "}", "</s>" ]

[ "Write", "the", "extra", "assembler", "code", "needed", "to", "declare", "a", "function", "properly", "." ]

[ "s390", "0", "\"\\tnopr\\t%%r0\"", "\"\\t# pre-label NOPs for hotpatch (%d halfwords)\\n\"", "1", "\"\\tnopr\\t%r0\\n\"", "8", "0", "\"\\t# alignment for hotpatch\\n\"", "0", "\"\\t# fn:%s ar%d\\n\"", "\"\\t# fn:%s tu%d\\n\"", "\"\\t# fn:%s sg%d\\n\"", "\"\\t# fn:%s ss%d\\n\"", "\"\\t# fn:%s bc%d\\n\"", "\"\\t# fn:%s wf%d\\n\"", "\"\\t# fn:%s ba%d\\n\"", "\"\\t# fn:%s hd%d\\n\"", "\"\\t# fn:%s hf%d\\n\"", "\"\\t# fn:%s ht%d\\n\"", "\"\\t# fn:%s vx%d\\n\"", "\"\\t# fn:%s ps%d\\n\"", "\"\\t# fn:%s se%d\\n\"", "\"\\t# fn:%s mv%d\\n\"", "\"\\t# fn:%s zv%d\\n\"", "\"\\t# fn:%s wd%d\\n\"", "0", "\"\\t# post-label NOPs for hotpatch (%d halfwords)\\n\"" ]

[]

[ "<s>", "CCAssignFn", "*", "AArch64TargetLowering", "::", "CCAssignFnForCall", "(", "CallingConv", "::", "ID", "CC", ",", "bool", "IsVarArg", ")", "const", "{", "switch", "(", "CC", ")", "{", "default", ":", "report_fatal_error", "(", "\"Unsupported calling convention.\"", ")", ";", "case", "CallingConv", "::", "WebKit_JS", ":", "return", "CC_AArch64_WebKit_JS", ";", "case", "CallingConv", "::", "GHC", ":", "return", "CC_AArch64_GHC", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "PreserveMost", ":", "case", "CallingConv", "::", "CXX_FAST_TLS", ":", "case", "CallingConv", "::", "Swift", ":", "if", "(", "Subtarget", "->", "isTargetWindows", "(", ")", "&&", "IsVarArg", ")", "return", "CC_AArch64_Win64_VarArg", ";", "if", "(", "!", "Subtarget", "->", "isTargetDarwin", "(", ")", ")", "return", "CC_AArch64_AAPCS", ";", "return", "IsVarArg", "?", "CC_AArch64_DarwinPCS_VarArg", ":", "CC_AArch64_DarwinPCS", ";", "case", "CallingConv", "::", "Win64", ":", "return", "IsVarArg", "?", "CC_AArch64_Win64_VarArg", ":", "CC_AArch64_AAPCS", ";", "case", "CallingConv", "::", "Mono", ":", "if", "(", "Subtarget", "->", "isTargetDarwin", "(", ")", ")", "return", "CC_AArch64_Mono_DarwinPCS", ";", "else", "if", "(", "Subtarget", "->", "isTargetWindows", "(", ")", ")", "report_fatal_error", "(", "\"Unsupported calling convention.\"", ")", ";", "else", "return", "CC_AArch64_Mono_AAPCS", ";", "}", "}", "</s>" ]

[ "Selects", "the", "correct", "CCAssignFn", "for", "a", "given", "CallingConvention", "value", "." ]

[ "AArch64", "AArch64", "\"Unsupported calling convention.\"", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "\"Unsupported calling convention.\"", "AArch64" ]

[]

[ "<s>", "SMLoc", "getStartLoc", "(", ")", "const", "override", "{", "return", "StartLoc", ";", "}", "</s>" ]

[ "getStartLoc", "-", "Get", "the", "location", "of", "the", "first", "token", "of", "this", "operand", "." ]

[ "RV16K" ]

[]

[ "<s>", "static", "int", "compare_constants", "(", "const", "void", "*", "key", ",", "const", "void", "*", "t", ")", "{", "return", "(", "*", "(", "int", "*", ")", "key", ")", "-", "*", "(", "(", "int", "*", ")", "t", ")", ";", "}", "</s>" ]

[ "bsearch", "helper", "function", "." ]

[ "tilepro" ]

[]

[ "<s>", "unsigned", "get213Opcode", "(", ")", "const", "{", "return", "Opcodes", "[", "Form213", "]", ";", "}", "</s>" ]

[ "Returns", "the", "213", "form", "of", "FMA", "opcode", "." ]

[ "X86" ]

[]

[ "<s>", "SUnit", "*", "R600SchedStrategy", "::", "pickNode", "(", "bool", "&", "IsTopNode", ")", "{", "SUnit", "*", "SU", "=", "0", ";", "NextInstKind", "=", "IDOther", ";", "IsTopNode", "=", "false", ";", "bool", "AllowSwitchToAlu", "=", "(", "CurEmitted", ">=", "InstKindLimit", "[", "CurInstKind", "]", ")", "||", "(", "Available", "[", "CurInstKind", "]", ".", "empty", "(", ")", ")", ";", "bool", "AllowSwitchFromAlu", "=", "(", "CurEmitted", ">=", "InstKindLimit", "[", "CurInstKind", "]", ")", "&&", "(", "!", "Available", "[", "IDFetch", "]", ".", "empty", "(", ")", "||", "!", "Available", "[", "IDOther", "]", ".", "empty", "(", ")", ")", ";", "if", "(", "CurInstKind", "==", "IDAlu", "&&", "!", "Available", "[", "IDFetch", "]", ".", "empty", "(", ")", ")", "{", "float", "ALUFetchRationEstimate", "=", "(", "AluInstCount", "+", "AvailablesAluCount", "(", ")", "+", "Pending", "[", "IDAlu", "]", ".", "size", "(", ")", ")", "/", "(", "FetchInstCount", "+", "Available", "[", "IDFetch", "]", ".", "size", "(", ")", ")", ";", "unsigned", "NeededWF", "=", "62.5f", "/", "ALUFetchRationEstimate", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "NeededWF", "<<", "\" approx. Wavefronts Required\\n\"", ")", ";", "unsigned", "NearRegisterRequirement", "=", "2", "*", "Available", "[", "IDFetch", "]", ".", "size", "(", ")", ";", "if", "(", "NeededWF", ">", "getWFCountLimitedByGPR", "(", "NearRegisterRequirement", ")", ")", "AllowSwitchFromAlu", "=", "true", ";", "}", "if", "(", "!", "SU", "&&", "(", "(", "AllowSwitchToAlu", "&&", "CurInstKind", "!=", "IDAlu", ")", "||", "(", "!", "AllowSwitchFromAlu", "&&", "CurInstKind", "==", "IDAlu", ")", ")", ")", "{", "SU", "=", "pickAlu", "(", ")", ";", "if", "(", "!", "SU", "&&", "!", "PhysicalRegCopy", ".", "empty", "(", ")", ")", "{", "SU", "=", "PhysicalRegCopy", ".", "front", "(", ")", ";", "PhysicalRegCopy", ".", "erase", "(", "PhysicalRegCopy", ".", "begin", "(", ")", ")", ";", "}", "if", "(", "SU", ")", "{", "if", "(", "CurEmitted", ">=", "InstKindLimit", "[", "IDAlu", "]", ")", "CurEmitted", "=", "0", ";", "NextInstKind", "=", "IDAlu", ";", "}", "}", "if", "(", "!", "SU", ")", "{", "SU", "=", "pickOther", "(", "IDFetch", ")", ";", "if", "(", "SU", ")", "NextInstKind", "=", "IDFetch", ";", "}", "if", "(", "!", "SU", ")", "{", "SU", "=", "pickOther", "(", "IDOther", ")", ";", "if", "(", "SU", ")", "NextInstKind", "=", "IDOther", ";", "}", "DEBUG", "(", "if", "(", "SU", ")", "{", "dbgs", "(", ")", "<<", "\" ** Pick node **\\n\"", ";", "SU", "->", "dump", "(", "DAG", ")", ";", "}", "else", "{", "dbgs", "(", ")", "<<", "\"NO NODE \\n\"", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "DAG", "->", "SUnits", ".", "size", "(", ")", ";", "i", "++", ")", "{", "const", "SUnit", "&", "S", "=", "DAG", "->", "SUnits", "[", "i", "]", ";", "if", "(", "!", "S", ".", "isScheduled", ")", "S", ".", "dump", "(", "DAG", ")", ";", "}", "}", "</s>" ]

[ "Pick", "the", "next", "node", "to", "schedule", ",", "or", "return", "NULL", "." ]

[ "R600", "0", "62.5f", "\" approx. Wavefronts Required\\n\"", "2", "0", "\" ** Pick node **\\n\"", "\"NO NODE \\n\"", "0" ]

[]

[ "<s>", "bool", "MipsSEDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Base", ",", "Offset", ";", "switch", "(", "ConstraintID", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected asm memory constraint\"", ")", ";", "case", "InlineAsm", "::", "Constraint_i", ":", "OutOps", ".", "push_back", "(", "Op", ")", ";", "OutOps", ".", "push_back", "(", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "SDLoc", "(", "Op", ")", ",", "MVT", "::", "i32", ")", ")", ";", "return", "false", ";", "case", "InlineAsm", "::", "Constraint_m", ":", "if", "(", "selectAddrRegImm16", "(", "Op", ",", "Base", ",", "Offset", ")", ")", "{", "OutOps", ".", "push_back", "(", "Base", ")", ";", "OutOps", ".", "push_back", "(", "Offset", ")", ";", "return", "false", ";", "}", "OutOps", ".", "push_back", "(", "Op", ")", ";", "OutOps", ".", "push_back", "(", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "SDLoc", "(", "Op", ")", ",", "MVT", "::", "i32", ")", ")", ";", "return", "false", ";", "case", "InlineAsm", "::", "Constraint_R", ":", "if", "(", "selectAddrRegImm9", "(", "Op", ",", "Base", ",", "Offset", ")", ")", "{", "OutOps", ".", "push_back", "(", "Base", ")", ";", "OutOps", ".", "push_back", "(", "Offset", ")", ";", "return", "false", ";", "}", "OutOps", ".", "push_back", "(", "Op", ")", ";", "OutOps", ".", "push_back", "(", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "SDLoc", "(", "Op", ")", ",", "MVT", "::", "i32", ")", ")", ";", "return", "false", ";", "case", "InlineAsm", "::", "Constraint_ZC", ":", "if", "(", "Subtarget", "->", "inMicroMipsMode", "(", ")", ")", "{", "if", "(", "selectAddrRegImm12", "(", "Op", ",", "Base", ",", "Offset", ")", ")", "{", "OutOps", ".", "push_back", "(", "Base", ")", ";", "OutOps", ".", "push_back", "(", "Offset", ")", ";", "return", "false", ";", "}", "}", "else", "if", "(", "Subtarget", "->", "hasMips32r6", "(", ")", ")", "{", "if", "(", "selectAddrRegImm9", "(", "Op", ",", "Base", ",", "Offset", ")", ")", "{", "OutOps", ".", "push_back", "(", "Base", ")", ";", "OutOps", ".", "push_back", "(", "Offset", ")", ";", "return", "false", ";", "}", "}", "else", "if", "(", "selectAddrRegImm16", "(", "Op", ",", "Base", ",", "Offset", ")", ")", "{", "OutOps", ".", "push_back", "(", "Base", ")", ";", "OutOps", ".", "push_back", "(", "Offset", ")", ";", "return", "false", ";", "}", "OutOps", ".", "push_back", "(", "Op", ")", ";", "OutOps", ".", "push_back", "(", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "SDLoc", "(", "Op", ")", ",", "MVT", "::", "i32", ")", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"Unexpected asm memory constraint\"", "0", "MVT::i32", "0", "MVT::i32", "0", "MVT::i32", "Mips", "Mips", "0", "MVT::i32" ]

[]

[ "<s>", "static", "void", "emit_unspec2", "(", "rtx", "target", ",", "int", "code", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "gen_rtx_UNSPEC", "(", "GET_MODE", "(", "target", ")", ",", "gen_rtvec", "(", "2", ",", "op0", ",", "op1", ")", ",", "code", ")", ")", ")", ";", "}", "</s>" ]

[ "Generate", "(", "set", "TARGET", "(", "unspec", "[", "OP0", "OP1", "]", "CODE", ")", ")", "." ]

[ "aarch64", "2" ]

[]

[ "<s>", "void", "bb_sese", "::", "remove", "(", "const", "pseudo_node_t", "&", "pseudo", ")", "{", "unsigned", "removed", "=", "0", ";", "int", "len", "=", "brackets", ".", "length", "(", ")", ";", "for", "(", "int", "ix", "=", "0", ";", "ix", "<", "len", ";", "ix", "++", ")", "{", "if", "(", "brackets", "[", "ix", "]", ".", "back", "==", "pseudo", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Removing backedge %d:%+d\\n\"", ",", "pseudo", ".", "first", "?", "pseudo", ".", "first", "->", "index", ":", "0", ",", "pseudo", ".", "second", ")", ";", "removed", "++", ";", "}", "else", "if", "(", "removed", ")", "brackets", "[", "ix", "-", "removed", "]", "=", "brackets", "[", "ix", "]", ";", "}", "while", "(", "removed", "--", ")", "brackets", ".", "pop", "(", ")", ";", "}", "</s>" ]

[ "Remove", "brackets", "that", "terminate", "at", "PSEUDO", "." ]

[ "nvptx", "0", "0", "\"Removing backedge %d:%+d\\n\"", "0" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Sparc Machine Code Emitter\"", ";", "}", "</s>" ]

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

[ "Sparc", "\"Sparc Machine Code Emitter\"" ]

[]

[ "<s>", "virtual", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "{", "return", "&", "DL", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "CellSPU" ]

[]

[ "<s>", "const", "uint32_t", "*", "X86RegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "bool", "HasSSE", "=", "Subtarget", ".", "hasSSE1", "(", ")", ";", "bool", "HasAVX", "=", "Subtarget", ".", "hasAVX", "(", ")", ";", "bool", "HasAVX512", "=", "Subtarget", ".", "hasAVX512", "(", ")", ";", "switch", "(", "CC", ")", "{", "case", "CallingConv", "::", "GHC", ":", "case", "CallingConv", "::", "HiPE", ":", "return", "CSR_NoRegs_RegMask", ";", "case", "CallingConv", "::", "AnyReg", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_RegMask", ";", "return", "CSR_64_AllRegs_RegMask", ";", "case", "CallingConv", "::", "PreserveMost", ":", "return", "CSR_64_RT_MostRegs_RegMask", ";", "case", "CallingConv", "::", "PreserveAll", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_RT_AllRegs_AVX_RegMask", ";", "return", "CSR_64_RT_AllRegs_RegMask", ";", "case", "CallingConv", "::", "CXX_FAST_TLS", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_TLS_Darwin_RegMask", ";", "break", ";", "case", "CallingConv", "::", "Intel_OCL_BI", ":", "{", "if", "(", "HasAVX512", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX512_RegMask", ";", "if", "(", "HasAVX512", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX512_RegMask", ";", "if", "(", "HasAVX", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX_RegMask", ";", "if", "(", "HasAVX", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX_RegMask", ";", "if", "(", "!", "HasAVX", "&&", "!", "IsWin64", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_RegMask", ";", "break", ";", "}", "case", "CallingConv", "::", "HHVM", ":", "return", "CSR_64_HHVM_RegMask", ";", "case", "CallingConv", "::", "Cold", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_MostRegs_RegMask", ";", "break", ";", "case", "CallingConv", "::", "X86_64_Win64", ":", "return", "CSR_Win64_RegMask", ";", "case", "CallingConv", "::", "X86_64_SysV", ":", "return", "CSR_64_RegMask", ";", "case", "CallingConv", "::", "X86_INTR", ":", "if", "(", "Is64Bit", ")", "{", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_RegMask", ";", "else", "return", "CSR_64_AllRegs_RegMask", ";", "}", "else", "{", "if", "(", "HasSSE", ")", "return", "CSR_32_AllRegs_SSE_RegMask", ";", "else", "return", "CSR_32_AllRegs_RegMask", ";", "}", "default", ":", "break", ";", "}", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "return", "CSR_Win64_RegMask", ";", "return", "CSR_64_RegMask", ";", "}", "return", "CSR_32_RegMask", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "void", "BTFTypeDeclTag", "::", "completeType", "(", "BTFDebug", "&", "BDebug", ")", "{", "if", "(", "IsCompleted", ")", "return", ";", "IsCompleted", "=", "true", ";", "BTFType", ".", "NameOff", "=", "BDebug", ".", "addString", "(", "Tag", ")", ";", "}", "</s>" ]

[ "Complete", "BTF", "type", "generation", "after", "all", "related", "DebugInfo", "types", "have", "been", "visited", "so", "their", "BTF", "type", "id", "'s", "are", "available", "for", "cross", "referece", "." ]

[ "BPF" ]

[]

[ "<s>", "bool", "SIInsertSkips", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "SkipThreshold", "=", "SkipThresholdFlag", ";", "SmallVector", "<", "MachineInstr", "*", ",", "4", ">", "KillInstrs", ";", "SmallVector", "<", "MachineInstr", "*", ",", "4", ">", "EarlyTermInstrs", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "MachineBasicBlock", "::", "iterator", "I", ",", "Next", ";", "for", "(", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_MASK_BRANCH", ":", "MadeChange", "|=", "skipMaskBranch", "(", "MI", ",", "MBB", ")", ";", "break", ";", "case", "AMDGPU", "::", "S_BRANCH", ":", "if", "(", "MBB", ".", "isLayoutSuccessor", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ")", "{", "assert", "(", "&", "MI", "==", "&", "MBB", ".", "back", "(", ")", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "MadeChange", "=", "true", ";", "}", "break", ";", "case", "AMDGPU", "::", "SI_KILL_F32_COND_IMM_TERMINATOR", ":", "case", "AMDGPU", "::", "SI_KILL_I1_TERMINATOR", ":", "{", "MadeChange", "=", "true", ";", "bool", "CanKill", "=", "kill", "(", "MI", ")", ";", "if", "(", "CanKill", "&&", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AMDGPU_PS", "&&", "dominatesAllReachable", "(", "MBB", ")", ")", "{", "KillInstrs", ".", "push_back", "(", "&", "MI", ")", ";", "}", "else", "{", "MI", ".", "eraseFromParent", "(", ")", ";", "}", "break", ";", "}", "case", "AMDGPU", "::", "SI_KILL_CLEANUP", ":", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AMDGPU_PS", "&&", "dominatesAllReachable", "(", "MBB", ")", ")", "{", "KillInstrs", ".", "push_back", "(", "&", "MI", ")", ";", "}", "else", "{", "MI", ".", "eraseFromParent", "(", ")", ";", "}", "break", ";", "case", "AMDGPU", "::", "SI_EARLY_TERMINATE_SCC0", ":", "EarlyTermInstrs", ".", "push_back", "(", "&", "MI", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "}", "for", "(", "MachineInstr", "*", "Instr", ":", "EarlyTermInstrs", ")", "{", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "!=", "CallingConv", "::", "AMDGPU_GS", ")", "earlyTerm", "(", "*", "Instr", ")", ";", "Instr", "->", "eraseFromParent", "(", ")", ";", "}", "for", "(", "MachineInstr", "*", "Kill", ":", "KillInstrs", ")", "{", "skipIfDead", "(", "*", "Kill", "->", "getParent", "(", ")", ",", "std", "::", "next", "(", "Kill", "->", "getIterator", "(", ")", ")", ",", "Kill", "->", "getDebugLoc", "(", ")", ")", ";", "Kill", "->", "eraseFromParent", "(", ")", ";", "}", "KillInstrs", ".", "clear", "(", ")", ";", "EarlyTermInstrs", ".", "clear", "(", ")", ";", "EarlyExitBlock", "=", "nullptr", ";", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "4", "4", "AMDGPU::SI_MASK_BRANCH", "AMDGPU::S_BRANCH", "0", "AMDGPU::SI_KILL_F32_COND_IMM_TERMINATOR", "AMDGPU::SI_KILL_I1_TERMINATOR", "AMDGPU", "AMDGPU::SI_KILL_CLEANUP", "AMDGPU", "AMDGPU::SI_EARLY_TERMINATE_SCC0", "AMDGPU" ]

[]

[ "<s>", "SDValue", "PIC16TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "{", "unsigned", "NumRet", "=", "Outs", ".", "size", "(", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "std", "::", "string", "FuncName", "=", "F", "->", "getName", "(", ")", ";", "const", "char", "*", "tmpName", "=", "ESNames", "::", "createESName", "(", "PAN", "::", "getFrameLabel", "(", "FuncName", ")", ")", ";", "SDValue", "ES", "=", "DAG", ".", "getTargetExternalSymbol", "(", "tmpName", ",", "MVT", "::", "i8", ")", ";", "SDValue", "BS", "=", "DAG", ".", "getConstant", "(", "1", ",", "MVT", "::", "i8", ")", ";", "SDValue", "RetVal", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "NumRet", ";", "++", "i", ")", "{", "RetVal", "=", "Outs", "[", "i", "]", ".", "Val", ";", "Chain", "=", "DAG", ".", "getNode", "(", "PIC16ISD", "::", "PIC16Store", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "RetVal", ",", "ES", ",", "BS", ",", "DAG", ".", "getConstant", "(", "i", ",", "MVT", "::", "i8", ")", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "PIC16ISD", "::", "RET", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

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

[ "PIC16", "PIC16", "ISD::OutputArg", "MVT::i8", "1", "MVT::i8", "0", "PIC16ISD::PIC16Store", "MVT::Other", "MVT::i8", "PIC16ISD::RET", "MVT::Other" ]

[]

[ "<s>", "void", "MipsRegisterInfo", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "bool", "isPIC", "=", "(", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", ";", "adjustMipsStackFrame", "(", "MF", ")", ";", "unsigned", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", "->", "hasCalls", "(", ")", ")", "return", ";", "int", "FPOffset", "=", "MipsFI", "->", "getFPStackOffset", "(", ")", ";", "int", "RAOffset", "=", "MipsFI", "->", "getRAStackOffset", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "NOREORDER", ")", ")", ";", "if", "(", "isPIC", "&&", "Subtarget", ".", "isABI_O32", "(", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "CPLOAD", ")", ")", ".", "addReg", "(", "getPICCallReg", "(", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "NOMACRO", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ADDiu", ")", ",", "Mips", "::", "SP", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ".", "addImm", "(", "-", "StackSize", ")", ";", "if", "(", "MFI", "->", "hasCalls", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "SW", ")", ")", ".", "addReg", "(", "Mips", "::", "RA", ")", ".", "addImm", "(", "RAOffset", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "SW", ")", ")", ".", "addReg", "(", "Mips", "::", "FP", ")", ".", "addImm", "(", "FPOffset", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ADDu", ")", ",", "Mips", "::", "FP", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ".", "addReg", "(", "Mips", "::", "ZERO", ")", ";", "}", "if", "(", "MipsFI", "->", "needGPSaveRestore", "(", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "CPRESTORE", ")", ")", ".", "addImm", "(", "MipsFI", "->", "getGPStackOffset", "(", ")", ")", ";", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "0", "Mips", "Mips", "Mips::NOREORDER", "Mips::CPLOAD", "Mips::NOMACRO", "Mips::ADDiu", "Mips::SP", "Mips::SP", "Mips::SW", "Mips::RA", "Mips::SP", "Mips::SW", "Mips::FP", "Mips::SP", "Mips::ADDu", "Mips::FP", "Mips::SP", "Mips::ZERO", "Mips", "Mips::CPRESTORE", "Mips" ]

[]

[ "<s>", "StackOffset", "X86FrameLowering", "::", "getFrameIndexReferencePreferSP", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ",", "bool", "IgnoreSPUpdates", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", "&&", "TRI", "->", "hasStackRealignment", "(", "MF", ")", "&&", "!", "STI", ".", "isTargetWin64", "(", ")", ")", "return", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ")", ";", "if", "(", "!", "IgnoreSPUpdates", "&&", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "return", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ")", ";", "assert", "(", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getTCReturnAddrDelta", "(", ")", ">=", "0", "&&", "\"we don't handle this case!\"", ")", ";", "return", "getFrameIndexReferenceSP", "(", "MF", ",", "FI", ",", "FrameReg", ",", "StackSize", ")", ";", "}", "</s>" ]

[ "Same", "as", "getFrameIndexReference", ",", "except", "that", "the", "stack", "pointer", "(", "as", "opposed", "to", "the", "frame", "pointer", ")", "will", "be", "the", "preferred", "value", "for", "FrameReg", "." ]

[ "X86", "X86", "X86", "0", "\"we don't handle this case!\"" ]

[]

[ "<s>", "static", "void", "rx_print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "\"[\"", ")", ";", "rx_print_operand", "(", "file", ",", "addr", ",", "0", ")", ";", "fprintf", "(", "file", ",", "\"]\"", ")", ";", "break", ";", "case", "PRE_DEC", ":", "fprintf", "(", "file", ",", "\"[-\"", ")", ";", "rx_print_operand", "(", "file", ",", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ";", "fprintf", "(", "file", ",", "\"]\"", ")", ";", "break", ";", "case", "POST_INC", ":", "fprintf", "(", "file", ",", "\"[\"", ")", ";", "rx_print_operand", "(", "file", ",", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ";", "fprintf", "(", "file", ",", "\"+]\"", ")", ";", "break", ";", "case", "PLUS", ":", "{", "rtx", "arg1", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "rtx", "arg2", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "rtx", "base", ",", "index", ";", "if", "(", "REG_P", "(", "arg1", ")", "&&", "RTX_OK_FOR_BASE", "(", "arg1", ",", "true", ")", ")", "base", "=", "arg1", ",", "index", "=", "arg2", ";", "else", "if", "(", "REG_P", "(", "arg2", ")", "&&", "RTX_OK_FOR_BASE", "(", "arg2", ",", "true", ")", ")", "base", "=", "arg2", ",", "index", "=", "arg1", ";", "else", "{", "rx_print_operand", "(", "file", ",", "arg1", ",", "0", ")", ";", "fprintf", "(", "file", ",", "\" + \"", ")", ";", "rx_print_operand", "(", "file", ",", "arg2", ",", "0", ")", ";", "break", ";", "}", "if", "(", "REG_P", "(", "index", ")", "||", "GET_CODE", "(", "index", ")", "==", "MULT", ")", "{", "fprintf", "(", "file", ",", "\"[\"", ")", ";", "rx_print_operand", "(", "file", ",", "index", ",", "'A'", ")", ";", "fprintf", "(", "file", ",", "\",\"", ")", ";", "}", "else", "{", "rx_print_operand", "(", "file", ",", "index", ",", "'A'", ")", ";", "fprintf", "(", "file", ",", "\"[\"", ")", ";", "}", "rx_print_operand", "(", "file", ",", "base", ",", "0", ")", ";", "fprintf", "(", "file", ",", "\"]\"", ")", ";", "break", ";", "}", "case", "CONST", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "UNSPEC", ")", "{", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "gcc_assert", "(", "XINT", "(", "addr", ",", "1", ")", "==", "UNSPEC_CONST", ")", ";", "case", "UNSPEC", ":", "addr", "=", "XVECEXP", "(", "addr", ",", "0", ",", "0", ")", ";", "gcc_assert", "(", "CONST_INT_P", "(", "addr", ")", ")", ";", "}", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "fprintf", "(", "file", ",", "\"#\"", ")", ";", "default", ":", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "A", "C", "compound", "statement", "to", "output", "to", "stdio", "stream", "FILE", "the", "assembler", "syntax", "for", "an", "instruction", "operand", "that", "is", "a", "memory", "reference", "whose", "address", "is", "ADDR", "." ]

[ "rx", "\"[\"", "0", "\"]\"", "\"[-\"", "0", "0", "\"]\"", "\"[\"", "0", "0", "\"+]\"", "0", "1", "0", "\" + \"", "0", "\"[\"", "\",\"", "\"[\"", "0", "\"]\"", "0", "0", "1", "0", "0", "\"#\"" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "const", "MachineInstr", "&", "MIa", ",", "const", "MachineInstr", "&", "MIb", ")", "const", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "const", "MachineOperand", "*", "BaseOpA", "=", "nullptr", ",", "*", "BaseOpB", "=", "nullptr", ";", "int64_t", "OffsetA", "=", "0", ",", "OffsetB", "=", "0", ";", "unsigned", "WidthA", "=", "0", ",", "WidthB", "=", "0", ";", "assert", "(", "MIa", ".", "mayLoadOrStore", "(", ")", "&&", "\"MIa must be a load or store.\"", ")", ";", "assert", "(", "MIb", ".", "mayLoadOrStore", "(", ")", "&&", "\"MIb must be a load or store.\"", ")", ";", "if", "(", "MIa", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIa", ".", "hasOrderedMemoryRef", "(", ")", "||", "MIb", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "if", "(", "getMemOperandWithOffsetWidth", "(", "MIa", ",", "BaseOpA", ",", "OffsetA", ",", "WidthA", ",", "TRI", ")", "&&", "getMemOperandWithOffsetWidth", "(", "MIb", ",", "BaseOpB", ",", "OffsetB", ",", "WidthB", ",", "TRI", ")", ")", "{", "if", "(", "BaseOpA", "->", "isIdenticalTo", "(", "*", "BaseOpB", ")", ")", "{", "int", "LowOffset", "=", "OffsetA", "<", "OffsetB", "?", "OffsetA", ":", "OffsetB", ";", "int", "HighOffset", "=", "OffsetA", "<", "OffsetB", "?", "OffsetB", ":", "OffsetA", ";", "int", "LowWidth", "=", "(", "LowOffset", "==", "OffsetA", ")", "?", "WidthA", ":", "WidthB", ";", "if", "(", "LowOffset", "+", "LowWidth", "<=", "HighOffset", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Sometimes", ",", "it", "is", "possible", "for", "the", "target", "to", "tell", ",", "even", "without", "aliasing", "information", ",", "that", "two", "MIs", "access", "different", "memory", "addresses", "." ]

[ "AArch64", "AArch64", "0", "0", "0", "0", "\"MIa must be a load or store.\"", "\"MIb must be a load or store.\"" ]

[]

[ "<s>", "void", "MBlazeFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "MBlazeInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MBlazeInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "int", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", "+", "4", ";", "if", "(", "Amount", "!=", "0", ")", "{", "unsigned", "Align", "=", "getStackAlignment", "(", ")", ";", "Amount", "=", "(", "Amount", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "MachineInstr", "*", "New", ";", "if", "(", "Old", "->", "getOpcode", "(", ")", "==", "MBlaze", "::", "ADJCALLSTACKDOWN", ")", "{", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MBlaze", "::", "ADDIK", ")", ",", "MBlaze", "::", "R1", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addImm", "(", "-", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Old", "->", "getOpcode", "(", ")", "==", "MBlaze", "::", "ADJCALLSTACKUP", ")", ";", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MBlaze", "::", "ADDIK", ")", ",", "MBlaze", "::", "R1", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "MBlaze", "MBlaze", "MBlaze", "MBlaze", "0", "4", "0", "1", "MBlaze::ADJCALLSTACKDOWN", "MBlaze::ADDIK", "MBlaze::R1", "MBlaze::R1", "MBlaze::ADJCALLSTACKUP", "MBlaze::ADDIK", "MBlaze::R1", "MBlaze::R1" ]

[]

[ "<s>", "HOST_WIDE_INT", "mips_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "HOST_WIDE_INT", "offset", ";", "mips_compute_frame_info", "(", ")", ";", "switch", "(", "from", ")", "{", "case", "FRAME_POINTER_REGNUM", ":", "if", "(", "FRAME_GROWS_DOWNWARD", ")", "offset", "=", "(", "cfun", "->", "machine", "->", "frame", ".", "args_size", "+", "cfun", "->", "machine", "->", "frame", ".", "cprestore_size", "+", "cfun", "->", "machine", "->", "frame", ".", "var_size", ")", ";", "else", "offset", "=", "0", ";", "break", ";", "case", "ARG_POINTER_REGNUM", ":", "offset", "=", "cfun", "->", "machine", "->", "frame", ".", "arg_pointer_offset", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "offset", "-=", "cfun", "->", "machine", "->", "frame", ".", "hard_frame_pointer_offset", ";", "return", "offset", ";", "}", "</s>" ]

[ "Implement", "INITIAL_ELIMINATION_OFFSET", ".", "FROM", "is", "either", "the", "frame", "pointer", "or", "argument", "pointer", ".", "TO", "is", "either", "the", "stack", "pointer", "or", "hard", "frame", "pointer", "." ]

[ "mips", "0" ]

[]

[ "<s>", "void", "NVPTXTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "report_fatal_error", "(", "\"Unhandled custom legalization\"", ")", ";", "case", "ISD", "::", "LOAD", ":", "ReplaceLoadVector", "(", "N", ",", "DAG", ",", "Results", ")", ";", "return", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "ReplaceINTRINSIC_W_CHAIN", "(", "N", ",", "DAG", ",", "Results", ")", ";", "return", ";", "}", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "NVPTX", "NVPTX", "\"Unhandled custom legalization\"", "ISD::LOAD", "ISD::INTRINSIC_W_CHAIN" ]

[]

[ "<s>", "static", "void", "msp430_print_operand_raw", "(", "FILE", "*", "file", ",", "rtx", "op", ")", "{", "HOST_WIDE_INT", "i", ";", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "op", ")", "]", ")", ";", "break", ";", "case", "CONST_INT", ":", "i", "=", "INTVAL", "(", "op", ")", ";", "if", "(", "TARGET_ASM_HEX", ")", "fprintf", "(", "file", ",", "\"%#\"", "HOST_WIDE_INT_PRINT", "\"x\"", ",", "i", ")", ";", "else", "fprintf", "(", "file", ",", "\"%\"", "HOST_WIDE_INT_PRINT", "\"d\"", ",", "i", ")", ";", "break", ";", "case", "CONST", ":", "case", "PLUS", ":", "case", "MINUS", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "output_addr_const", "(", "file", ",", "op", ")", ";", "break", ";", "default", ":", "print_rtl", "(", "file", ",", "op", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Common", "code", "for", "msp430_print_operand", "..." ]

[ "msp430", "\"%s\"", "\"%#\"", "\"x\"", "\"%\"", "\"d\"" ]

[]

[ "<s>", "unsigned", "PPCFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ",", "bool", "UpdateMF", ",", "bool", "UseEstimate", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "UseEstimate", "?", "MFI", "->", "estimateStackSize", "(", "MF", ")", ":", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "TargetAlign", "=", "getStackAlignment", "(", ")", ";", "unsigned", "MaxAlign", "=", "MFI", "->", "getMaxAlignment", "(", ")", ";", "unsigned", "AlignMask", "=", "std", "::", "max", "(", "MaxAlign", ",", "TargetAlign", ")", "-", "1", ";", "const", "PPCRegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "PPCRegisterInfo", "*", ">", "(", "Subtarget", ".", "getRegisterInfo", "(", ")", ")", ";", "bool", "DisableRedZone", "=", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "NoRedZone", ")", ";", "unsigned", "LR", "=", "RegInfo", "->", "getRARegister", "(", ")", ";", "if", "(", "!", "DisableRedZone", "&&", "(", "Subtarget", ".", "isPPC64", "(", ")", "||", "!", "Subtarget", ".", "isSVR4ABI", "(", ")", "||", "FrameSize", "==", "0", ")", "&&", "FrameSize", "<=", "224", "&&", "!", "MFI", "->", "hasVarSizedObjects", "(", ")", "&&", "!", "MFI", "->", "adjustsStack", "(", ")", "&&", "!", "MustSaveLR", "(", "MF", ",", "LR", ")", "&&", "!", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "if", "(", "UpdateMF", ")", "MFI", "->", "setStackSize", "(", "0", ")", ";", "return", "0", ";", "}", "unsigned", "maxCallFrameSize", "=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "unsigned", "minCallFrameSize", "=", "getLinkageSize", "(", "Subtarget", ".", "isPPC64", "(", ")", ",", "Subtarget", ".", "isDarwinABI", "(", ")", ",", "Subtarget", ".", "isELFv2ABI", "(", ")", ")", ";", "maxCallFrameSize", "=", "std", "::", "max", "(", "maxCallFrameSize", ",", "minCallFrameSize", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "maxCallFrameSize", "=", "(", "maxCallFrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "if", "(", "UpdateMF", ")", "MFI", "->", "setMaxCallFrameSize", "(", "maxCallFrameSize", ")", ";", "FrameSize", "+=", "maxCallFrameSize", ";", "FrameSize", "=", "(", "FrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "if", "(", "UpdateMF", ")", "MFI", "->", "setStackSize", "(", "FrameSize", ")", ";", "return", "FrameSize", ";", "}", "</s>" ]

[ "Determine", "the", "frame", "layout", "but", "do", "not", "update", "the", "machine", "function", "." ]

[ "PowerPC", "PPC", "1", "PPC", "PPC", "PPC", "0", "224", "0", "0", "PPC" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "isInlineConstant", "(", "const", "MCInst", "&", "Inst", ",", "unsigned", "OpIdx", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MII", ".", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "!", "AMDGPU", "::", "isSISrcOperand", "(", "Desc", ",", "OpIdx", ")", ")", "{", "return", "false", ";", "}", "const", "MCOperand", "&", "MO", "=", "Inst", ".", "getOperand", "(", "OpIdx", ")", ";", "int64_t", "Val", "=", "MO", ".", "getImm", "(", ")", ";", "auto", "OpSize", "=", "AMDGPU", "::", "getOperandSize", "(", "Desc", ",", "OpIdx", ")", ";", "switch", "(", "OpSize", ")", "{", "case", "8", ":", "return", "AMDGPU", "::", "isInlinableLiteral64", "(", "Val", ",", "hasInv2PiInlineImm", "(", ")", ")", ";", "case", "4", ":", "return", "AMDGPU", "::", "isInlinableLiteral32", "(", "Val", ",", "hasInv2PiInlineImm", "(", ")", ")", ";", "case", "2", ":", "{", "const", "unsigned", "OperandType", "=", "Desc", ".", "OpInfo", "[", "OpIdx", "]", ".", "OperandType", ";", "if", "(", "OperandType", "==", "AMDGPU", "::", "OPERAND_REG_INLINE_C_V2INT16", "||", "OperandType", "==", "AMDGPU", "::", "OPERAND_REG_INLINE_C_V2FP16", ")", "{", "return", "AMDGPU", "::", "isInlinableLiteralV216", "(", "Val", ",", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "else", "{", "return", "AMDGPU", "::", "isInlinableLiteral16", "(", "Val", ",", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "}", "default", ":", "llvm_unreachable", "(", "\"invalid operand size\"", ")", ";", "}", "}", "</s>" ]

[ "returns", "true", "if", "the", "operand", "OpIdx", "in", "MI", "is", "a", "valid", "inline", "immediate", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::isSISrcOperand", "AMDGPU::getOperandSize", "8", "AMDGPU::isInlinableLiteral64", "4", "AMDGPU::isInlinableLiteral32", "2", "AMDGPU::OPERAND_REG_INLINE_C_V2INT16", "AMDGPU::OPERAND_REG_INLINE_C_V2FP16", "AMDGPU::isInlinableLiteralV216", "AMDGPU::isInlinableLiteral16", "\"invalid operand size\"" ]

[]

[ "<s>", "static", "bool", "alpha_vms_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "switch", "(", "alpha_procedure_type", ")", "{", "case", "PT_NULL", ":", "return", "to", "==", "STACK_POINTER_REGNUM", ";", "case", "PT_REGISTER", ":", "case", "PT_STACK", ":", "return", "(", "to", "!=", "STACK_POINTER_REGNUM", "||", "vms_unwind_regno", "!=", "HARD_FRAME_POINTER_REGNUM", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_CAN_ELIMINATE", "." ]

[ "alpha" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "CodeModel", "::", "Model", "M", "=", "getTargetMachine", "(", ")", ".", "getCodeModel", "(", ")", ";", "Reloc", "::", "Model", "R", "=", "getTargetMachine", "(", ")", ".", "getRelocationModel", "(", ")", ";", "if", "(", "!", "X86", "::", "isOffsetSuitableForCodeModel", "(", "AM", ".", "BaseOffs", ",", "M", ",", "AM", ".", "BaseGV", "!=", "nullptr", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "BaseGV", ")", "{", "unsigned", "GVFlags", "=", "Subtarget", ".", "ClassifyGlobalReference", "(", "AM", ".", "BaseGV", ",", "getTargetMachine", "(", ")", ")", ";", "if", "(", "isGlobalStubReference", "(", "GVFlags", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "HasBaseReg", "&&", "isGlobalRelativeToPICBase", "(", "GVFlags", ")", ")", "return", "false", ";", "if", "(", "(", "M", "!=", "CodeModel", "::", "Small", "||", "R", "!=", "Reloc", "::", "Static", ")", "&&", "Subtarget", ".", "is64Bit", "(", ")", "&&", "(", "AM", ".", "BaseOffs", "||", "AM", ".", "Scale", ">", "1", ")", ")", "return", "false", ";", "}", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "case", "1", ":", "case", "2", ":", "case", "4", ":", "case", "8", ":", "break", ";", "case", "3", ":", "case", "5", ":", "case", "9", ":", "if", "(", "AM", ".", "HasBaseReg", ")", "return", "false", ";", "break", ";", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "X86", "X86", "X86::isOffsetSuitableForCodeModel", "1", "0", "1", "2", "4", "8", "3", "5", "9" ]

[]

[ "<s>", "HexagonGOTEntry", "*", "HexagonGOT", "::", "create", "(", ")", "{", "return", "new", "HexagonGOTEntry", "(", "0", ",", "m_SectionData", ")", ";", "}", "</s>" ]

[ "This", "creates", "an", "identified", "struct", "." ]

[ "Hexagon", "Hexagon", "HexagonGOT::create", "Hexagon", "0" ]

[]

[ "<s>", "unsigned", "AArch64TargetLowering", "::", "getByValTypeAlignment", "(", "Type", "*", "Ty", ")", "const", "{", "return", "4", ";", "}", "</s>" ]

[ "Return", "the", "desired", "alignment", "for", "ByVal", "aggregate", "function", "arguments", "in", "the", "caller", "parameter", "area", "." ]

[ "AArch64", "AArch64", "4" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "AArch64FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "AArch64InstrInfo", "*", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "IsDestroy", "=", "Opc", "==", "TII", "->", "getCallFrameDestroyOpcode", "(", ")", ";", "uint64_t", "CalleePopAmount", "=", "IsDestroy", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "int64_t", "Amount", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "Amount", "=", "alignTo", "(", "Amount", ",", "getStackAlign", "(", ")", ")", ";", "if", "(", "!", "IsDestroy", ")", "Amount", "=", "-", "Amount", ";", "if", "(", "CalleePopAmount", "==", "0", ")", "{", "assert", "(", "Amount", ">", "-", "0xffffff", "&&", "Amount", "<", "0xffffff", "&&", "\"call frame too large\"", ")", ";", "emitFrameOffset", "(", "MBB", ",", "I", ",", "DL", ",", "AArch64", "::", "SP", ",", "AArch64", "::", "SP", ",", "StackOffset", "::", "getFixed", "(", "Amount", ")", ",", "TII", ")", ";", "}", "}", "else", "if", "(", "CalleePopAmount", "!=", "0", ")", "{", "assert", "(", "CalleePopAmount", "<", "0xffffff", "&&", "\"call frame too large\"", ")", ";", "emitFrameOffset", "(", "MBB", ",", "I", ",", "DL", ",", "AArch64", "::", "SP", ",", "AArch64", "::", "SP", ",", "StackOffset", "::", "getFixed", "(", "-", "(", "int64_t", ")", "CalleePopAmount", ")", ",", "TII", ")", ";", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "1", "0", "0", "0", "0xffffff", "0xffffff", "\"call frame too large\"", "AArch64::SP", "AArch64::SP", "0", "0xffffff", "\"call frame too large\"", "AArch64::SP", "AArch64::SP" ]

[]

[ "<s>", "const", "WebAssemblySubtarget", "*", "WebAssemblyTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "make_unique", "<", "WebAssemblySubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "\"target-cpu\"", "\"target-features\"", "WebAssembly" ]

[]

[ "<s>", "bool", "MipsRegisterInfo", "::", "trackLivenessAfterRegAlloc", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "analyzeBranchPredicate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBranchPredicate", "&", "MBP", ",", "bool", "AllowModify", ")", "const", "{", "using", "namespace", "std", "::", "placeholders", ";", "SmallVector", "<", "MachineOperand", ",", "4", ">", "Cond", ";", "SmallVector", "<", "MachineInstr", "*", ",", "4", ">", "CondBranches", ";", "if", "(", "AnalyzeBranchImpl", "(", "MBB", ",", "MBP", ".", "TrueDest", ",", "MBP", ".", "FalseDest", ",", "Cond", ",", "CondBranches", ",", "AllowModify", ")", ")", "return", "true", ";", "if", "(", "Cond", ".", "size", "(", ")", "!=", "1", ")", "return", "true", ";", "assert", "(", "MBP", ".", "TrueDest", "&&", "\"expected!\"", ")", ";", "if", "(", "!", "MBP", ".", "FalseDest", ")", "MBP", ".", "FalseDest", "=", "MBB", ".", "getNextNode", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "MachineInstr", "*", "ConditionDef", "=", "nullptr", ";", "bool", "SingleUseCondition", "=", "true", ";", "for", "(", "auto", "I", "=", "std", "::", "next", "(", "MBB", ".", "rbegin", "(", ")", ")", ",", "E", "=", "MBB", ".", "rend", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "modifiesRegister", "(", "X86", "::", "EFLAGS", ",", "TRI", ")", ")", "{", "ConditionDef", "=", "&", "*", "I", ";", "break", ";", "}", "if", "(", "I", "->", "readsRegister", "(", "X86", "::", "EFLAGS", ",", "TRI", ")", ")", "SingleUseCondition", "=", "false", ";", "}", "if", "(", "!", "ConditionDef", ")", "return", "true", ";", "if", "(", "SingleUseCondition", ")", "{", "for", "(", "auto", "*", "Succ", ":", "MBB", ".", "successors", "(", ")", ")", "if", "(", "Succ", "->", "isLiveIn", "(", "X86", "::", "EFLAGS", ")", ")", "SingleUseCondition", "=", "false", ";", "}", "MBP", ".", "ConditionDef", "=", "ConditionDef", ";", "MBP", ".", "SingleUseCondition", "=", "SingleUseCondition", ";", "const", "unsigned", "TestOpcode", "=", "Subtarget", ".", "is64Bit", "(", ")", "?", "X86", "::", "TEST64rr", ":", "X86", "::", "TEST32rr", ";", "if", "(", "ConditionDef", "->", "getOpcode", "(", ")", "==", "TestOpcode", "&&", "ConditionDef", "->", "getNumOperands", "(", ")", "==", "3", "&&", "ConditionDef", "->", "getOperand", "(", "0", ")", ".", "isIdenticalTo", "(", "ConditionDef", "->", "getOperand", "(", "1", ")", ")", "&&", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", "==", "X86", "::", "COND_NE", "||", "Cond", "[", "0", "]", ".", "getImm", "(", ")", "==", "X86", "::", "COND_E", ")", ")", "{", "MBP", ".", "LHS", "=", "ConditionDef", "->", "getOperand", "(", "0", ")", ";", "MBP", ".", "RHS", "=", "MachineOperand", "::", "CreateImm", "(", "0", ")", ";", "MBP", ".", "Predicate", "=", "Cond", "[", "0", "]", ".", "getImm", "(", ")", "==", "X86", "::", "COND_NE", "?", "MachineBranchPredicate", "::", "PRED_NE", ":", "MachineBranchPredicate", "::", "PRED_EQ", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", "and", "parse", "it", "into", "the", "MachineBranchPredicate", "structure", "if", "possible", "." ]

[ "X86", "X86", "4", "4", "1", "\"expected!\"", "X86::EFLAGS", "X86::EFLAGS", "X86::EFLAGS", "X86::TEST64rr", "X86::TEST32rr", "3", "0", "1", "0", "X86::COND_NE", "0", "X86::COND_E", "0", "0", "0", "X86::COND_NE" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "shouldExtendTypeInLibCall", "(", "EVT", "Type", ")", "const", "{", "RISCVABI", "::", "ABI", "ABI", "=", "Subtarget", ".", "getTargetABI", "(", ")", ";", "if", "(", "ABI", "==", "RISCVABI", "::", "ABI_LP64", "&&", "(", "Type", "==", "MVT", "::", "f32", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "arguments", "should", "be", "extended", "in", "lib", "calls", "." ]

[ "RI5CY", "RISCV", "RISCVABI::ABI", "RISCVABI::ABI_LP64", "MVT::f32" ]

[]

[ "<s>", "void", "assignValueToAddress", "(", "Register", "ValVReg", ",", "Register", "Addr", ",", "uint64_t", "Size", ",", "MachinePointerInfo", "&", "MPO", ",", "CCValAssign", "&", "VA", ")", "override", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "unsigned", "Align", "=", "inferAlignmentFromPtrInfo", "(", "MF", ",", "MPO", ")", ";", "auto", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MPO", ",", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOInvariant", ",", "Size", ",", "Align", ")", ";", "MIRBuilder", ".", "buildLoad", "(", "ValVReg", ",", "Addr", ",", "*", "MMO", ")", ";", "}", "</s>" ]

[ "An", "overload", "which", "takes", "an", "ArgInfo", "if", "additional", "information", "about", "the", "arg", "is", "needed", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "TargetPassConfig", "*", "Cpu0TargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "Cpu0PassConfig", "(", "*", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

[ "Cpu0", "Cpu0", "Cpu0" ]

[]

[ "<s>", "void", "AMDGPUAsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", "{", "if", "(", "IsaInfo", "::", "hasCodeObjectV3", "(", "getGlobalSTI", "(", ")", ")", "&&", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", ")", "{", "AsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", ";", "return", ";", "}", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "const", "GCNSubtarget", "&", "STM", "=", "MF", "->", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "if", "(", "MFI", "->", "isEntryFunction", "(", ")", "&&", "STM", ".", "isAmdHsaOrMesa", "(", "MF", "->", "getFunction", "(", ")", ")", ")", "{", "SmallString", "<", "128", ">", "SymbolName", ";", "getNameWithPrefix", "(", "SymbolName", ",", "&", "MF", "->", "getFunction", "(", ")", ")", ",", "getTargetStreamer", "(", ")", "->", "EmitAMDGPUSymbolType", "(", "SymbolName", ",", "ELF", "::", "STT_AMDGPU_HSA_KERNEL", ")", ";", "}", "if", "(", "DumpCodeInstEmitter", ")", "{", "DisasmLines", ".", "push_back", "(", "MF", "->", "getName", "(", ")", ".", "str", "(", ")", "+", "\":\"", ")", ";", "DisasmLineMaxLen", "=", "std", "::", "max", "(", "DisasmLineMaxLen", ",", "DisasmLines", ".", "back", "(", ")", ".", "size", "(", ")", ")", ";", "HexLines", ".", "push_back", "(", "\"\"", ")", ";", "}", "AsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", ";", "}", "</s>" ]

[ "EmitFunctionEntryLabel", "-", "Emit", "the", "label", "that", "is", "the", "entrypoint", "for", "the", "function", "." ]

[ "AMDGPU", "AMDGPU", "SI", "SI", "128", "AMDGPU", "AMDGPU", "\":\"", "\"\"" ]

[]

[ "<s>", "bool", "MipsLongBranch", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "const", "MipsInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "MipsInstrInfo", "*", ">", "(", "TM", ".", "getInstrInfo", "(", ")", ")", ";", "const", "MipsSubtarget", "&", "STI", "=", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "if", "(", "STI", ".", "inMips16Mode", "(", ")", "||", "!", "STI", ".", "enableLongBranchPass", "(", ")", ")", "return", "false", ";", "if", "(", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "&&", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "isABI_O32", "(", ")", "&&", "F", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", "->", "globalBaseRegSet", "(", ")", ")", "emitGPDisp", "(", "F", ",", "TII", ")", ";", "if", "(", "SkipLongBranch", ")", "return", "true", ";", "MF", "=", "&", "F", ";", "initMBBInfo", "(", ")", ";", "SmallVectorImpl", "<", "MBBInfo", ">", "::", "iterator", "I", ",", "E", "=", "MBBInfos", ".", "end", "(", ")", ";", "bool", "EverMadeChange", "=", "false", ",", "MadeChange", "=", "true", ";", "while", "(", "MadeChange", ")", "{", "MadeChange", "=", "false", ";", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "!", "I", "->", "Br", "||", "I", "->", "HasLongBranch", ")", "continue", ";", "int", "ShVal", "=", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "inMicroMipsMode", "(", ")", "?", "2", ":", "4", ";", "int64_t", "Offset", "=", "computeOffset", "(", "I", "->", "Br", ")", "/", "ShVal", ";", "if", "(", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "isTargetNaCl", "(", ")", ")", "{", "Offset", "*=", "2", ";", "}", "if", "(", "!", "ForceLongBranch", "&&", "isInt", "<", "16", ">", "(", "Offset", ")", ")", "continue", ";", "I", "->", "HasLongBranch", "=", "true", ";", "I", "->", "Size", "+=", "LongBranchSeqSize", "*", "4", ";", "++", "LongBranches", ";", "EverMadeChange", "=", "MadeChange", "=", "true", ";", "}", "}", "if", "(", "!", "EverMadeChange", ")", "return", "true", ";", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "{", "uint64_t", "Address", "=", "0", ";", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "Address", "+=", "I", "->", "Size", ",", "++", "I", ")", "I", "->", "Address", "=", "Address", ";", "}", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "I", "->", "HasLongBranch", ")", "expandToLongBranch", "(", "*", "I", ")", ";", "MF", "->", "RenumberBlocks", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "2", "4", "Mips", "2", "16", "4", "0" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "canUseLEAForSPInEpilogue", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "!", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", "->", "usesWindowsCFI", "(", ")", "||", "hasFP", "(", "MF", ")", ";", "}", "</s>" ]

[ "Check", "that", "LEA", "can", "be", "used", "on", "SP", "in", "an", "epilogue", "sequence", "for", "MF", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "AArch64DeadRegisterDefinitions", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64DeadRegisterDefinitions *****\\n\"", ")", ";", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "processMachineBasicBlock", "(", "MBB", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"***** AArch64DeadRegisterDefinitions *****\\n\"" ]

[]

[ "<s>", "void", "NyuziInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "Nyuzi", "::", "ORSSI", "&&", "MI", "->", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "Nyuzi", "::", "S0", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "Nyuzi", "::", "S0", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "O", "<<", "\"\\tnop\"", ";", "return", ";", "}", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "Nyuzi", "Nyuzi", "Nyuzi::ORSSI", "0", "0", "Nyuzi::S0", "1", "1", "Nyuzi::S0", "2", "2", "0", "\"\\tnop\"" ]

[]

[ "<s>", "const", "char", "*", "HexagonRelocator", "::", "getName", "(", "Relocation", "::", "Type", "pType", ")", "const", "{", "return", "ApplyFunctions", "[", "pType", "]", ".", "name", ";", "}", "</s>" ]

[ "Return", "a", "string", "with", "the", "name", "of", "the", "plan", "and", "the", "applicable", "VFs", "and", "UFs", "." ]

[ "Hexagon", "Hexagon" ]

[]