Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "MSP430AsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "return", "true", ";", "}", "printSrcMemOperand", "(", "MI", ",", "OpNo", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

[ "MSP430", "MSP430", "0" ]

[]

[ "<s>", "static", "void", "irq_range", "(", "const", "char", "*", "cstr", ")", "{", "int", "i", ",", "first", ",", "last", ",", "blink", ",", "lpcount", ",", "xreg", ";", "char", "*", "str", ",", "*", "dash", ",", "*", "comma", ";", "i", "=", "strlen", "(", "cstr", ")", ";", "str", "=", "(", "char", "*", ")", "alloca", "(", "i", "+", "1", ")", ";", "memcpy", "(", "str", ",", "cstr", ",", "i", "+", "1", ")", ";", "blink", "=", "-", "1", ";", "lpcount", "=", "-", "1", ";", "dash", "=", "strchr", "(", "str", ",", "'-'", ")", ";", "if", "(", "!", "dash", ")", "{", "warning", "(", "0", ",", "\"value of -mirq-ctrl-saved must have form R0-REGx\"", ")", ";", "return", ";", "}", "*", "dash", "=", "'\\0'", ";", "comma", "=", "strchr", "(", "dash", "+", "1", ",", "','", ")", ";", "if", "(", "comma", ")", "*", "comma", "=", "'\\0'", ";", "first", "=", "decode_reg_name", "(", "str", ")", ";", "if", "(", "first", "!=", "0", ")", "{", "warning", "(", "0", ",", "\"first register must be R0\"", ")", ";", "return", ";", "}", "if", "(", "!", "strcmp", "(", "dash", "+", "1", ",", "\"ilink\"", ")", ")", "last", "=", "29", ";", "else", "last", "=", "decode_reg_name", "(", "dash", "+", "1", ")", ";", "if", "(", "last", "<", "0", ")", "{", "warning", "(", "0", ",", "\"unknown register name: %s\"", ",", "dash", "+", "1", ")", ";", "return", ";", "}", "if", "(", "!", "(", "last", "&", "0x01", ")", ")", "{", "warning", "(", "0", ",", "\"last register name %s must be an odd register\"", ",", "dash", "+", "1", ")", ";", "return", ";", "}", "*", "dash", "=", "'-'", ";", "if", "(", "first", ">", "last", ")", "{", "warning", "(", "0", ",", "\"%s-%s is an empty range\"", ",", "str", ",", "dash", "+", "1", ")", ";", "return", ";", "}", "while", "(", "comma", ")", "{", "*", "comma", "=", "','", ";", "str", "=", "comma", "+", "1", ";", "comma", "=", "strchr", "(", "str", ",", "','", ")", ";", "if", "(", "comma", ")", "*", "comma", "=", "'\\0'", ";", "xreg", "=", "decode_reg_name", "(", "str", ")", ";", "switch", "(", "xreg", ")", "{", "case", "31", ":", "blink", "=", "31", ";", "break", ";", "case", "60", ":", "lpcount", "=", "60", ";", "break", ";", "default", ":", "warning", "(", "0", ",", "\"unknown register name: %s\"", ",", "str", ")", ";", "return", ";", "}", "}", "irq_ctrl_saved", ".", "irq_save_last_reg", "=", "last", ";", "irq_ctrl_saved", ".", "irq_save_blink", "=", "(", "blink", "==", "31", ")", "||", "(", "last", "==", "31", ")", ";", "irq_ctrl_saved", ".", "irq_save_lpcount", "=", "(", "lpcount", "==", "60", ")", ";", "}", "</s>" ]

[ "Parse", "-mirq-ctrl-saved=RegisterRange", ",", "blink", ",", "lp_copunt", ".", "The", "register", "range", "is", "specified", "as", "two", "registers", "separated", "by", "a", "dash", ".", "It", "always", "starts", "with", "r0", ",", "and", "its", "upper", "limit", "is", "fp", "register", ".", "blink", "and", "lp_count", "registers", "are", "optional", "." ]

[ "arc", "1", "1", "1", "1", "0", "\"value of -mirq-ctrl-saved must have form R0-REGx\"", "1", "0", "0", "\"first register must be R0\"", "1", "\"ilink\"", "29", "1", "0", "0", "\"unknown register name: %s\"", "1", "0x01", "0", "\"last register name %s must be an odd register\"", "1", "0", "\"%s-%s is an empty range\"", "1", "1", "31", "31", "60", "60", "0", "\"unknown register name: %s\"", "31", "31", "60" ]

[]

[ "<s>", "unsigned", "HSAILTargetLowering", "::", "ComputeNumSignBitsForTargetNode", "(", "SDValue", "Op", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "return", "1", ";", "}", "</s>" ]

[ "Determine", "the", "number", "of", "bits", "in", "the", "operation", "that", "are", "sign", "bits", "." ]

[ "HSAIL", "HSAIL", "1" ]

[]

[ "<s>", "int", "rl78_force_nonfar_3", "(", "rtx", "*", "operands", ",", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ")", "{", "int", "did", "=", "0", ";", "rtx", "temp_reg", "=", "NULL", ";", "if", "(", "rl78_far_p", "(", "operands", "[", "1", "]", ")", ")", "{", "rtx", "temp_reg", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "operands", "[", "1", "]", ")", ")", ";", "emit_move_insn", "(", "temp_reg", ",", "operands", "[", "1", "]", ")", ";", "operands", "[", "1", "]", "=", "temp_reg", ";", "did", "=", "1", ";", "}", "if", "(", "rl78_far_p", "(", "operands", "[", "0", "]", ")", ")", "{", "temp_reg", "=", "operands", "[", "0", "]", ";", "operands", "[", "0", "]", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ")", ";", "did", "=", "1", ";", "}", "if", "(", "!", "did", ")", "return", "0", ";", "emit_insn", "(", "gen", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ")", ";", "if", "(", "temp_reg", ")", "emit_move_insn", "(", "temp_reg", ",", "operands", "[", "0", "]", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Likewise", ",", "but", "for", "three-operand", "expanders", "." ]

[ "rl78", "0", "1", "1", "1", "1", "1", "0", "0", "0", "0", "1", "0", "0", "1", "2", "0", "1" ]

[]

[ "<s>", "void", "J2DAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "SDLoc", "DL", "(", "Node", ")", ";", "switch", "(", "Node", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "FrameIndex", ":", "assert", "(", "Node", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i32", ")", ";", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "const", "auto", "Opc", "=", "J2", "::", "MOV32rr", ";", "CurDAG", "->", "SelectNodeTo", "(", "Node", ",", "Opc", ",", "MVT", "::", "i32", ",", "TFI", ")", ";", "return", ";", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "J2", "J2", "\"Selecting: \"", "\"\\n\"", "ISD::FrameIndex", "0", "MVT::i32", "MVT::i32", "J2::MOV32rr", "MVT::i32" ]

[]

[ "<s>", "const", "RegisterBank", "&", "AArch64RegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ",", "LLT", ")", "const", "{", "switch", "(", "RC", ".", "getID", "(", ")", ")", "{", "case", "AArch64", "::", "FPR8RegClassID", ":", "case", "AArch64", "::", "FPR16RegClassID", ":", "case", "AArch64", "::", "FPR16_loRegClassID", ":", "case", "AArch64", "::", "FPR32_with_hsub_in_FPR16_loRegClassID", ":", "case", "AArch64", "::", "FPR32RegClassID", ":", "case", "AArch64", "::", "FPR64RegClassID", ":", "case", "AArch64", "::", "FPR64_loRegClassID", ":", "case", "AArch64", "::", "FPR128RegClassID", ":", "case", "AArch64", "::", "FPR128_loRegClassID", ":", "case", "AArch64", "::", "DDRegClassID", ":", "case", "AArch64", "::", "DDDRegClassID", ":", "case", "AArch64", "::", "DDDDRegClassID", ":", "case", "AArch64", "::", "QQRegClassID", ":", "case", "AArch64", "::", "QQQRegClassID", ":", "case", "AArch64", "::", "QQQQRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "FPRRegBankID", ")", ";", "case", "AArch64", "::", "GPR32commonRegClassID", ":", "case", "AArch64", "::", "GPR32RegClassID", ":", "case", "AArch64", "::", "GPR32spRegClassID", ":", "case", "AArch64", "::", "GPR32sponlyRegClassID", ":", "case", "AArch64", "::", "GPR32argRegClassID", ":", "case", "AArch64", "::", "GPR32allRegClassID", ":", "case", "AArch64", "::", "GPR64commonRegClassID", ":", "case", "AArch64", "::", "GPR64RegClassID", ":", "case", "AArch64", "::", "GPR64spRegClassID", ":", "case", "AArch64", "::", "GPR64sponlyRegClassID", ":", "case", "AArch64", "::", "GPR64argRegClassID", ":", "case", "AArch64", "::", "GPR64allRegClassID", ":", "case", "AArch64", "::", "GPR64noipRegClassID", ":", "case", "AArch64", "::", "GPR64common_and_GPR64noipRegClassID", ":", "case", "AArch64", "::", "GPR64noip_and_tcGPR64RegClassID", ":", "case", "AArch64", "::", "tcGPR64RegClassID", ":", "case", "AArch64", "::", "rtcGPR64RegClassID", ":", "case", "AArch64", "::", "WSeqPairsClassRegClassID", ":", "case", "AArch64", "::", "XSeqPairsClassRegClassID", ":", "case", "AArch64", "::", "MatrixIndexGPR32_12_15RegClassID", ":", "case", "AArch64", "::", "GPR64_with_sub_32_in_MatrixIndexGPR32_12_15RegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "GPRRegBankID", ")", ";", "case", "AArch64", "::", "CCRRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "CCRegBankID", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Register class not supported\"", ")", ";", "}", "}", "</s>" ]

[ "Get", "a", "register", "bank", "that", "covers", "RC", "." ]

[ "AArch64", "AArch64", "AArch64::FPR8RegClassID", "AArch64::FPR16RegClassID", "AArch64::FPR16_loRegClassID", "AArch64::FPR32_with_hsub_in_FPR16_loRegClassID", "AArch64::FPR32RegClassID", "AArch64::FPR64RegClassID", "AArch64::FPR64_loRegClassID", "AArch64::FPR128RegClassID", "AArch64::FPR128_loRegClassID", "AArch64::DDRegClassID", "AArch64::DDDRegClassID", "AArch64::DDDDRegClassID", "AArch64::QQRegClassID", "AArch64::QQQRegClassID", "AArch64::QQQQRegClassID", "AArch64::FPRRegBankID", "AArch64::GPR32commonRegClassID", "AArch64::GPR32RegClassID", "AArch64::GPR32spRegClassID", "AArch64::GPR32sponlyRegClassID", "AArch64::GPR32argRegClassID", "AArch64::GPR32allRegClassID", "AArch64::GPR64commonRegClassID", "AArch64::GPR64RegClassID", "AArch64::GPR64spRegClassID", "AArch64::GPR64sponlyRegClassID", "AArch64::GPR64argRegClassID", "AArch64::GPR64allRegClassID", "AArch64::GPR64noipRegClassID", "AArch64::GPR64common_and_GPR64noipRegClassID", "AArch64::GPR64noip_and_tcGPR64RegClassID", "AArch64::tcGPR64RegClassID", "AArch64::rtcGPR64RegClassID", "AArch64::WSeqPairsClassRegClassID", "AArch64::XSeqPairsClassRegClassID", "AArch64::MatrixIndexGPR32_12_15RegClassID", "AArch64::GPR64_with_sub_32_in_MatrixIndexGPR32_12_15RegClassID", "AArch64::GPRRegBankID", "AArch64::CCRRegClassID", "AArch64::CCRegBankID", "\"Register class not supported\"" ]

[]

[ "<s>", "uint64_t", "AArch64GOT", "::", "emit", "(", "MemoryRegion", "&", "pRegion", ")", "{", "uint64_t", "*", "buffer", "=", "reinterpret_cast", "<", "uint64_t", "*", ">", "(", "pRegion", ".", "begin", "(", ")", ")", ";", "AArch64GOTEntry", "*", "got", "=", "NULL", ";", "uint64_t", "result", "=", "0x0", ";", "for", "(", "iterator", "it", "=", "begin", "(", ")", ",", "ie", "=", "end", "(", ")", ";", "it", "!=", "ie", ";", "++", "it", ",", "++", "buffer", ")", "{", "got", "=", "&", "(", "llvm", "::", "cast", "<", "AArch64GOTEntry", ">", "(", "(", "*", "it", ")", ")", ")", ";", "*", "buffer", "=", "static_cast", "<", "uint64_t", ">", "(", "got", "->", "getValue", "(", ")", ")", ";", "result", "+=", "AArch64GOTEntry", "::", "EntrySize", ";", "}", "return", "result", ";", "}", "</s>" ]

[ "Output", "the", "remark", "via", "the", "diagnostic", "handler", "and", "to", "the", "optimization", "record", "file", "." ]

[ "AArch64", "AArch64", "AArch64", "0x0", "AArch64", "AArch64GOTEntry::EntrySize" ]

[]

[ "<s>", "void", "SIScheduleBlock", "::", "releaseSucc", "(", "SUnit", "*", "SU", ",", "SDep", "*", "SuccEdge", ")", "{", "SUnit", "*", "SuccSU", "=", "SuccEdge", "->", "getSUnit", "(", ")", ";", "if", "(", "SuccEdge", "->", "isWeak", "(", ")", ")", "{", "--", "SuccSU", "->", "WeakPredsLeft", ";", "return", ";", "}", "if", "(", "SuccSU", "->", "NumPredsLeft", "==", "0", ")", "{", "dbgs", "(", ")", "<<", "\"*** Scheduling failed! ***\\n\"", ";", "SuccSU", "->", "dump", "(", "DAG", ")", ";", "dbgs", "(", ")", "<<", "\" has been released too many times!\\n\"", ";", "llvm_unreachable", "(", "nullptr", ")", ";", "}", "--", "SuccSU", "->", "NumPredsLeft", ";", "}", "</s>" ]

[ "ReleaseSucc", "-", "Decrement", "the", "NumPredsLeft", "count", "of", "a", "successor", "." ]

[ "AMDGPU", "SI", "0", "\"*** Scheduling failed! ***\\n\"", "\" has been released too many times!\\n\"" ]

[]

[ "<s>", "const", "char", "*", "MSP430TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "MSP430ISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "MSP430ISD", "::", "FIRST_NUMBER", ":", "break", ";", "case", "MSP430ISD", "::", "RET_FLAG", ":", "return", "\"MSP430ISD::RET_FLAG\"", ";", "case", "MSP430ISD", "::", "RETI_FLAG", ":", "return", "\"MSP430ISD::RETI_FLAG\"", ";", "case", "MSP430ISD", "::", "RRA", ":", "return", "\"MSP430ISD::RRA\"", ";", "case", "MSP430ISD", "::", "RLA", ":", "return", "\"MSP430ISD::RLA\"", ";", "case", "MSP430ISD", "::", "RRC", ":", "return", "\"MSP430ISD::RRC\"", ";", "case", "MSP430ISD", "::", "CALL", ":", "return", "\"MSP430ISD::CALL\"", ";", "case", "MSP430ISD", "::", "Wrapper", ":", "return", "\"MSP430ISD::Wrapper\"", ";", "case", "MSP430ISD", "::", "BR_CC", ":", "return", "\"MSP430ISD::BR_CC\"", ";", "case", "MSP430ISD", "::", "CMP", ":", "return", "\"MSP430ISD::CMP\"", ";", "case", "MSP430ISD", "::", "SETCC", ":", "return", "\"MSP430ISD::SETCC\"", ";", "case", "MSP430ISD", "::", "SELECT_CC", ":", "return", "\"MSP430ISD::SELECT_CC\"", ";", "case", "MSP430ISD", "::", "SHL", ":", "return", "\"MSP430ISD::SHL\"", ";", "case", "MSP430ISD", "::", "SRA", ":", "return", "\"MSP430ISD::SRA\"", ";", "case", "MSP430ISD", "::", "SRL", ":", "return", "\"MSP430ISD::SRL\"", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "MSP430", "MSP430", "MSP430ISD::NodeType", "MSP430ISD::FIRST_NUMBER", "MSP430ISD::RET_FLAG", "\"MSP430ISD::RET_FLAG\"", "MSP430ISD::RETI_FLAG", "\"MSP430ISD::RETI_FLAG\"", "MSP430ISD::RRA", "\"MSP430ISD::RRA\"", "MSP430ISD::RLA", "\"MSP430ISD::RLA\"", "MSP430ISD::RRC", "\"MSP430ISD::RRC\"", "MSP430ISD::CALL", "\"MSP430ISD::CALL\"", "MSP430ISD::Wrapper", "\"MSP430ISD::Wrapper\"", "MSP430ISD::BR_CC", "\"MSP430ISD::BR_CC\"", "MSP430ISD::CMP", "\"MSP430ISD::CMP\"", "MSP430ISD::SETCC", "\"MSP430ISD::SETCC\"", "MSP430ISD::SELECT_CC", "\"MSP430ISD::SELECT_CC\"", "MSP430ISD::SHL", "\"MSP430ISD::SHL\"", "MSP430ISD::SRA", "\"MSP430ISD::SRA\"", "MSP430ISD::SRL", "\"MSP430ISD::SRL\"" ]

[]

[ "<s>", "unsigned", "char", "AArch64Subtarget", "::", "ClassifyGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", "&&", "isTargetMachO", "(", ")", ")", "return", "AArch64II", "::", "MO_GOT", ";", "unsigned", "Flags", "=", "GV", "->", "hasDLLImportStorageClass", "(", ")", "?", "AArch64II", "::", "MO_DLLIMPORT", ":", "AArch64II", "::", "MO_NO_FLAG", ";", "if", "(", "!", "TM", ".", "shouldAssumeDSOLocal", "(", "*", "GV", "->", "getParent", "(", ")", ",", "GV", ")", ")", "return", "AArch64II", "::", "MO_GOT", "|", "Flags", ";", "if", "(", "useSmallAddressing", "(", ")", "&&", "GV", "->", "hasExternalWeakLinkage", "(", ")", ")", "return", "AArch64II", "::", "MO_GOT", "|", "Flags", ";", "return", "Flags", ";", "}", "</s>" ]

[ "ClassifyGlobalReference", "-", "Find", "the", "target", "operand", "flags", "that", "describe", "how", "a", "global", "value", "should", "be", "referenced", "for", "the", "current", "subtarget", "." ]

[ "AArch64", "AArch64", "AArch64II::MO_GOT", "AArch64II::MO_DLLIMPORT", "AArch64II::MO_NO_FLAG", "AArch64II::MO_GOT", "AArch64II::MO_GOT" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ",", "const", "SDNode", "*", "CallNode", ",", "const", "Type", "*", "RetTy", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "MipsCC", "MipsCCInfo", "(", "CallConv", ",", "Subtarget", ".", "isABI_O32", "(", ")", ",", "Subtarget", ".", "isFP64bit", "(", ")", ",", "CCInfo", ")", ";", "MipsCCInfo", ".", "analyzeCallResult", "(", "Ins", ",", "Subtarget", ".", "abiUsesSoftFloat", "(", ")", ",", "CallNode", ",", "RetTy", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ",", "InFlag", ")", ";", "Chain", "=", "Val", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Val", ".", "getValue", "(", "2", ")", ";", "if", "(", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", "!=", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "InVals", ".", "push_back", "(", "Val", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "Mips", "Mips", "ISD::InputArg", "16", "Mips", "Mips", "Mips", "0", "1", "2", "ISD::BITCAST" ]

[]

[ "<s>", "void", "Reset", "(", ")", "{", "Ops", ".", "clear", "(", ")", ";", "OpBegins", ".", "clear", "(", ")", ";", "OpBegins", ".", "push_back", "(", "0", ")", ";", "HasPersonality", "=", "false", ";", "}", "</s>" ]

[ "Reset", "the", "unwind", "opcode", "assembler", "." ]

[ "ARM", "0" ]

[]

[ "<s>", "bool", "ARMAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "MCP", "=", "MF", ".", "getConstantPool", "(", ")", ";", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "const", "TargetMachine", "&", "TM", "=", "MF", ".", "getTarget", "(", ")", ";", "for", "(", "auto", "*", "GV", ":", "AFI", "->", "getGlobalsPromotedToConstantPool", "(", ")", ")", "PromotedGlobals", ".", "insert", "(", "GV", ")", ";", "unsigned", "OptimizationGoal", ";", "if", "(", "F", ".", "hasOptNone", "(", ")", ")", "OptimizationGoal", "=", "6", ";", "else", "if", "(", "F", ".", "hasMinSize", "(", ")", ")", "OptimizationGoal", "=", "4", ";", "else", "if", "(", "F", ".", "hasOptSize", "(", ")", ")", "OptimizationGoal", "=", "3", ";", "else", "if", "(", "TM", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", ")", "OptimizationGoal", "=", "2", ";", "else", "if", "(", "TM", ".", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "OptimizationGoal", "=", "1", ";", "else", "OptimizationGoal", "=", "5", ";", "if", "(", "OptimizationGoals", "==", "-", "1", ")", "OptimizationGoals", "=", "OptimizationGoal", ";", "else", "if", "(", "OptimizationGoals", "!=", "(", "int", ")", "OptimizationGoal", ")", "OptimizationGoals", "=", "0", ";", "if", "(", "Subtarget", "->", "isTargetCOFF", "(", ")", ")", "{", "bool", "Internal", "=", "F", ".", "hasInternalLinkage", "(", ")", ";", "COFF", "::", "SymbolStorageClass", "Scl", "=", "Internal", "?", "COFF", "::", "IMAGE_SYM_CLASS_STATIC", ":", "COFF", "::", "IMAGE_SYM_CLASS_EXTERNAL", ";", "int", "Type", "=", "COFF", "::", "IMAGE_SYM_DTYPE_FUNCTION", "<<", "COFF", "::", "SCT_COMPLEX_TYPE_SHIFT", ";", "OutStreamer", "->", "BeginCOFFSymbolDef", "(", "CurrentFnSym", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolStorageClass", "(", "Scl", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolType", "(", "Type", ")", ";", "OutStreamer", "->", "EndCOFFSymbolDef", "(", ")", ";", "}", "EmitFunctionBody", "(", ")", ";", "emitXRayTable", "(", ")", ";", "if", "(", "!", "ThumbIndirectPads", ".", "empty", "(", ")", ")", "{", "OutStreamer", "->", "EmitAssemblerFlag", "(", "MCAF_Code16", ")", ";", "EmitAlignment", "(", "1", ")", ";", "for", "(", "std", "::", "pair", "<", "unsigned", ",", "MCSymbol", "*", ">", "&", "TIP", ":", "ThumbIndirectPads", ")", "{", "OutStreamer", "->", "EmitLabel", "(", "TIP", ".", "second", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "MCInstBuilder", "(", "ARM", "::", "tBX", ")", ".", "addReg", "(", "TIP", ".", "first", ")", ".", "addImm", "(", "ARMCC", "::", "AL", ")", ".", "addReg", "(", "0", ")", ")", ";", "}", "ThumbIndirectPads", ".", "clear", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "6", "4", "3", "2", "1", "5", "1", "0", "1", "ARM::tBX", "ARMCC::AL", "0" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "canUseRedZone", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "!", "EnableRedZone", ")", "return", "false", ";", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoRedZone", ")", ")", "return", "false", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "AArch64FunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "unsigned", "NumBytes", "=", "AFI", "->", "getLocalStackSize", "(", ")", ";", "return", "!", "(", "MFI", ".", "hasCalls", "(", ")", "||", "hasFP", "(", "MF", ")", "||", "NumBytes", ">", "128", ")", ";", "}", "</s>" ]

[ "Can", "this", "function", "use", "the", "red", "zone", "for", "local", "allocations", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "128" ]

[]

[ "<s>", "void", "WebAssemblyTargetAsmStreamer", "::", "emitFunctionType", "(", "const", "MCSymbolWasm", "*", "Sym", ")", "{", "assert", "(", "Sym", "->", "isFunction", "(", ")", ")", ";", "OS", "<<", "\"\\t.functype\\t\"", "<<", "Sym", "->", "getName", "(", ")", "<<", "\" \"", ";", "emitSignature", "(", "Sym", "->", "getSignature", "(", ")", ")", ";", "OS", "<<", "\"\\n\"", ";", "}", "</s>" ]

[ ".functype" ]

[ "WebAssembly", "WebAssembly", "\"\\t.functype\\t\"", "\" \"", "\"\\n\"" ]

[]

[ "<s>", "static", "void", "output_file_start", "(", "void", ")", "{", "FILE", "*", "file", "=", "asm_out_file", ";", "int", "i", ";", "fprintf", "(", "file", ",", "\".file \\\"%s\\\";\\n\"", ",", "input_filename", ")", ";", "for", "(", "i", "=", "0", ";", "arg_regs", "[", "i", "]", ">=", "0", ";", "i", "++", ")", ";", "max_arg_registers", "=", "i", ";", "}", "</s>" ]

[ "Output", "to", "FILE", "the", "start", "of", "the", "assembler", "file", "." ]

[ "bfin", "\".file \\\"%s\\\";\\n\"", "0", "0" ]

[]

[ "<s>", "static", "void", "tryAddingPcLoadReferenceComment", "(", "uint64_t", "Address", ",", "uint64_t", "Value", ",", "const", "void", "*", "Decoder", ")", "{", "const", "MCDisassembler", "*", "Dis", "=", "static_cast", "<", "const", "MCDisassembler", "*", ">", "(", "Decoder", ")", ";", "LLVMSymbolLookupCallback", "SymbolLookUp", "=", "Dis", "->", "getLLVMSymbolLookupCallback", "(", ")", ";", "if", "(", "SymbolLookUp", ")", "{", "void", "*", "DisInfo", "=", "Dis", "->", "getDisInfoBlock", "(", ")", ";", "uint64_t", "ReferenceType", "=", "LLVMDisassembler_ReferenceType_In_PCrel_Load", ";", "const", "char", "*", "ReferenceName", ";", "(", "void", ")", "SymbolLookUp", "(", "DisInfo", ",", "Value", ",", "&", "ReferenceType", ",", "Address", ",", "&", "ReferenceName", ")", ";", "if", "(", "ReferenceType", "==", "LLVMDisassembler_ReferenceType_Out_LitPool_CstrAddr", ")", "(", "*", "Dis", "->", "CommentStream", ")", "<<", "\"literal pool for: \"", "<<", "ReferenceName", ";", "}", "}", "</s>" ]

[ "Try", "to", "add", "a", "comment", "on", "the", "PC-relative", "load", "." ]

[ "X86", "\"literal pool for: \"" ]

[]

[ "<s>", "static", "void", "h8300_option_override", "(", "void", ")", "{", "static", "const", "char", "*", "const", "h8_push_ops", "[", "2", "]", "=", "{", "\"push\"", ",", "\"push.l\"", "}", ";", "static", "const", "char", "*", "const", "h8_pop_ops", "[", "2", "]", "=", "{", "\"pop\"", ",", "\"pop.l\"", "}", ";", "static", "const", "char", "*", "const", "h8_mov_ops", "[", "2", "]", "=", "{", "\"mov.w\"", ",", "\"mov.l\"", "}", ";", "cpu_type", "=", "(", "int", ")", "CPU_H8300H", ";", "h8_reg_names", "=", "names_extended", ";", "h8_push_op", "=", "h8_push_ops", "[", "cpu_type", "]", ";", "h8_pop_op", "=", "h8_pop_ops", "[", "cpu_type", "]", ";", "h8_mov_op", "=", "h8_mov_ops", "[", "cpu_type", "]", ";", "if", "(", "TARGET_H8300S", ")", "target_flags", "&=", "~", "MASK_H8300H", ";", "if", "(", "!", "TARGET_H8300S", "&&", "TARGET_MAC", ")", "{", "error", "(", "\"%<-ms2600%> is used without %<-ms%>\"", ")", ";", "target_flags", "|=", "MASK_H8300S_1", ";", "}", "if", "(", "!", "TARGET_H8300S", "&&", "TARGET_EXR", ")", "{", "error", "(", "\"%<-mexr%> is used without %<-ms%>\"", ")", ";", "target_flags", "|=", "MASK_H8300S_1", ";", "}", "if", "(", "(", "!", "TARGET_H8300S", "&&", "TARGET_EXR", ")", "&&", "(", "!", "TARGET_H8300SX", "&&", "TARGET_EXR", ")", ")", "{", "error", "(", "\"%<-mexr%> is used without %<-ms%> or %<-msx%>\"", ")", ";", "target_flags", "|=", "MASK_H8300S_1", ";", "}", "if", "(", "(", "!", "TARGET_H8300S", "&&", "TARGET_NEXR", ")", "&&", "(", "!", "TARGET_H8300SX", "&&", "TARGET_NEXR", ")", ")", "{", "warning", "(", "OPT_mno_exr", ",", "\"%<-mno-exr%> is valid only with %<-ms%> or \"", "\"%<-msx%> - option ignored\"", ")", ";", "}", "if", "(", "(", "TARGET_NORMAL_MODE", ")", ")", "{", "error", "(", "\"%<-mn%> is not supported for linux targets\"", ")", ";", "target_flags", "^=", "MASK_NORMAL_MODE", ";", "}", "if", "(", "optimize_size", ")", "{", "shift_alg_hi", "[", "H8_300H", "]", "[", "SHIFT_ASHIFT", "]", "[", "5", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300H", "]", "[", "SHIFT_ASHIFT", "]", "[", "6", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300H", "]", "[", "SHIFT_LSHIFTRT", "]", "[", "5", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300H", "]", "[", "SHIFT_LSHIFTRT", "]", "[", "6", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300H", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "5", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300H", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "6", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300H", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "13", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300H", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "14", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_S", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "14", "]", "=", "SHIFT_LOOP", ";", "}", "if", "(", "!", "TARGET_H8300SX", ")", "{", "h8300_move_ratio", "=", "3", ";", "}", "else", "if", "(", "flag_omit_frame_pointer", ")", "{", "h8300_move_ratio", "=", "4", ";", "}", "else", "if", "(", "optimize_size", ")", "{", "h8300_move_ratio", "=", "4", ";", "}", "else", "{", "h8300_move_ratio", "=", "6", ";", "}", "if", "(", "flag_strict_volatile_bitfields", "<", "0", "&&", "abi_version_at_least", "(", "2", ")", ")", "flag_strict_volatile_bitfields", "=", "1", ";", "}", "</s>" ]

[ "Initialize", "various", "cpu", "specific", "globals", "at", "start", "up", "." ]

[ "h8300", "2", "\"push\"", "\"push.l\"", "2", "\"pop\"", "\"pop.l\"", "2", "\"mov.w\"", "\"mov.l\"", "\"%<-ms2600%> is used without %<-ms%>\"", "\"%<-mexr%> is used without %<-ms%>\"", "\"%<-mexr%> is used without %<-ms%> or %<-msx%>\"", "\"%<-mno-exr%> is valid only with %<-ms%> or \"", "\"%<-msx%> - option ignored\"", "\"%<-mn%> is not supported for linux targets\"", "5", "6", "5", "6", "5", "6", "13", "14", "14", "3", "4", "4", "6", "0", "2", "1" ]

[]

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

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

[ "ARM", "ARM", "ARM" ]

[]

[ "<s>", "bool", "m32c_mov_ok", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "op0", "=", "operands", "[", "0", "]", ";", "rtx", "op1", "=", "operands", "[", "1", "]", ";", "if", "(", "TARGET_A24", ")", "return", "true", ";", "fprintf", "(", "stderr", ",", "\"m32c_mov_ok %s\\n\"", ",", "mode_name", "[", "mode", "]", ")", ";", "debug_rtx", "(", "op0", ")", ";", "debug_rtx", "(", "op1", ")", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "SUBREG", ")", "op0", "=", "XEXP", "(", "op0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "SUBREG", ")", "op1", "=", "XEXP", "(", "op1", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "MEM", "&&", "GET_CODE", "(", "op1", ")", "==", "MEM", "&&", "!", "reload_completed", ")", "{", "fprintf", "(", "stderr", ",", "\" - no, mem to mem\\n\"", ")", ";", "return", "false", ";", "}", "fprintf", "(", "stderr", ",", "\" - ok\\n\"", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "TRUE", "if", "we", "support", "a", "move", "between", "the", "first", "two", "operands", ".", "At", "the", "moment", ",", "we", "just", "want", "to", "discourage", "mem", "to", "mem", "moves", "until", "after", "reload", ",", "because", "reload", "has", "a", "hard", "time", "with", "our", "limited", "number", "of", "address", "registers", ",", "and", "we", "can", "get", "into", "a", "situation", "where", "we", "need", "three", "of", "them", "when", "we", "only", "have", "two", "." ]

[ "m32c", "0", "1", "\"m32c_mov_ok %s\\n\"", "0", "0", "\" - no, mem to mem\\n\"", "\" - ok\\n\"" ]

[]

[ "<s>", "bool", "LanaiInstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "MachineInstr", "*", "MIa", ",", "MachineInstr", "*", "MIb", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "assert", "(", "MIa", "&&", "MIa", "->", "mayLoadOrStore", "(", ")", "&&", "\"MIa must be a load or store.\"", ")", ";", "assert", "(", "MIb", "&&", "MIb", "->", "mayLoadOrStore", "(", ")", "&&", "\"MIb must be a load or store.\"", ")", ";", "if", "(", "MIa", "->", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", "->", "hasUnmodeledSideEffects", "(", ")", "||", "MIa", "->", "hasOrderedMemoryRef", "(", ")", "||", "MIb", "->", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "unsigned", "BaseRegA", "=", "0", ",", "BaseRegB", "=", "0", ";", "int64_t", "OffsetA", "=", "0", ",", "OffsetB", "=", "0", ";", "unsigned", "int", "WidthA", "=", "0", ",", "WidthB", "=", "0", ";", "if", "(", "getMemOpBaseRegImmOfsWidth", "(", "MIa", ",", "BaseRegA", ",", "OffsetA", ",", "WidthA", ",", "TRI", ")", "&&", "getMemOpBaseRegImmOfsWidth", "(", "MIb", ",", "BaseRegB", ",", "OffsetB", ",", "WidthB", ",", "TRI", ")", ")", "{", "if", "(", "BaseRegA", "==", "BaseRegB", ")", "{", "int", "LowOffset", "=", "std", "::", "min", "(", "OffsetA", ",", "OffsetB", ")", ";", "int", "HighOffset", "=", "std", "::", "max", "(", "OffsetA", ",", "OffsetB", ")", ";", "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", "." ]

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

[]

[ "<s>", "void", "insert", "(", "MachineInstr", "*", "MI", ")", "{", "Insts", ".", "push_back", "(", "MI", ")", ";", "assert", "(", "Insts", ".", "size", "(", ")", "<=", "5", "&&", "\"Too many instructions in VPT block!\"", ")", ";", "}", "</s>" ]

[ "insert", "-", "Append", "entry", "to", "the", "vector", "if", "it", "does", "n't", "already", "exist", "." ]

[ "ARM", "5", "\"Too many instructions in VPT block!\"" ]

[]

[ "<s>", "const", "RegisterBank", "&", "ARMRegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ",", "LLT", ")", "const", "{", "using", "namespace", "ARM", ";", "switch", "(", "RC", ".", "getID", "(", ")", ")", "{", "case", "GPRRegClassID", ":", "case", "GPRwithAPSRRegClassID", ":", "case", "GPRnoipRegClassID", ":", "case", "GPRnopcRegClassID", ":", "case", "GPRnoip_and_GPRnopcRegClassID", ":", "case", "rGPRRegClassID", ":", "case", "GPRspRegClassID", ":", "case", "GPRnoip_and_tcGPRRegClassID", ":", "case", "tcGPRRegClassID", ":", "case", "tGPRRegClassID", ":", "case", "tGPREvenRegClassID", ":", "case", "tGPROddRegClassID", ":", "case", "tGPR_and_tGPREvenRegClassID", ":", "case", "tGPR_and_tGPROddRegClassID", ":", "case", "tGPREven_and_tcGPRRegClassID", ":", "case", "tGPREven_and_GPRnoip_and_tcGPRRegClassID", ":", "case", "tGPROdd_and_tcGPRRegClassID", ":", "return", "getRegBank", "(", "ARM", "::", "GPRRegBankID", ")", ";", "case", "HPRRegClassID", ":", "case", "SPR_8RegClassID", ":", "case", "SPRRegClassID", ":", "case", "DPR_8RegClassID", ":", "case", "DPRRegClassID", ":", "case", "QPRRegClassID", ":", "return", "getRegBank", "(", "ARM", "::", "FPRRegBankID", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Unsupported register kind\"", ")", ";", "}", "llvm_unreachable", "(", "\"Switch should handle all register classes\"", ")", ";", "}", "</s>" ]

[ "Get", "a", "register", "bank", "that", "covers", "RC", "." ]

[ "ARM", "ARM", "ARM", "ARM::GPRRegBankID", "ARM::FPRRegBankID", "\"Unsupported register kind\"", "\"Switch should handle all register classes\"" ]

[]

[ "<s>", "static", "void", "csky_print_operand_address", "(", "FILE", "*", "stream", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "struct", "csky_address", "addr", ";", "decompose_csky_address", "(", "x", ",", "&", "addr", ")", ";", "if", "(", "addr", ".", "label", "&&", "addr", ".", "disp", "&&", "GET_CODE", "(", "addr", ".", "disp", ")", "==", "CONST_INT", ")", "{", "fprintf", "(", "stream", ",", "\"[\"", ")", ";", "csky_output_constpool_label", "(", "stream", ",", "addr", ".", "label", ")", ";", "fprintf", "(", "stream", ",", "\"+%d]\"", ",", "(", "int", ")", "INTVAL", "(", "addr", ".", "disp", ")", ")", ";", "}", "else", "if", "(", "addr", ".", "label", ")", "{", "fprintf", "(", "stream", ",", "\"[\"", ")", ";", "csky_output_constpool_label", "(", "stream", ",", "addr", ".", "label", ")", ";", "fprintf", "(", "stream", ",", "\"]\"", ")", ";", "}", "else", "if", "(", "addr", ".", "symbol", "&&", "addr", ".", "disp", "&&", "GET_CODE", "(", "addr", ".", "disp", ")", "==", "CONST_INT", ")", "{", "fprintf", "(", "stream", ",", "\"[\"", ")", ";", "output_addr_const", "(", "stream", ",", "addr", ".", "symbol", ")", ";", "fprintf", "(", "stream", ",", "\"+%d]\"", ",", "(", "int", ")", "INTVAL", "(", "addr", ".", "disp", ")", ")", ";", "}", "else", "if", "(", "addr", ".", "symbol", ")", "{", "fprintf", "(", "stream", ",", "\"[\"", ")", ";", "output_addr_const", "(", "stream", ",", "addr", ".", "symbol", ")", ";", "fprintf", "(", "stream", ",", "\"]\"", ")", ";", "}", "else", "if", "(", "addr", ".", "disp", "&&", "GET_CODE", "(", "addr", ".", "disp", ")", "==", "CONST_INT", ")", "fprintf", "(", "stream", ",", "\"(%s, %d)\"", ",", "reg_names", "[", "REGNO", "(", "addr", ".", "base", ")", "]", ",", "(", "int", ")", "INTVAL", "(", "addr", ".", "disp", ")", ")", ";", "else", "if", "(", "addr", ".", "disp", "&&", "GET_CODE", "(", "addr", ".", "disp", ")", "==", "UNSPEC", ")", "{", "if", "(", "REGNO", "(", "addr", ".", "base", ")", "!=", "CSKY_GB_REGNUM", ")", "fprintf", "(", "stream", ",", "\"(%s, \"", ",", "reg_names", "[", "REGNO", "(", "addr", ".", "base", ")", "]", ")", ";", "else", "fprintf", "(", "stream", ",", "\"[\"", ")", ";", "csky_output_pic_addr_const", "(", "stream", ",", "addr", ".", "disp", ",", "0", ")", ";", "fprintf", "(", "stream", ",", "\"%s\"", ",", "(", "REGNO", "(", "addr", ".", "base", ")", "!=", "CSKY_GB_REGNUM", ")", "?", "\")\"", ":", "\"]\"", ")", ";", "}", "else", "if", "(", "addr", ".", "index", ")", "fprintf", "(", "stream", ",", "\"(%s, %s << %d)\"", ",", "reg_names", "[", "REGNO", "(", "addr", ".", "base", ")", "]", ",", "reg_names", "[", "REGNO", "(", "addr", ".", "index", ")", "]", ",", "exact_log2", "(", "(", "int", ")", "(", "addr", ".", "scale", ")", ")", ")", ";", "else", "fprintf", "(", "stream", ",", "\"(%s, 0)\"", ",", "reg_names", "[", "REGNO", "(", "addr", ".", "base", ")", "]", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_PRINT_OPERAND_ADDRESS", "." ]

[ "csky", "\"[\"", "\"+%d]\"", "\"[\"", "\"]\"", "\"[\"", "\"+%d]\"", "\"[\"", "\"]\"", "\"(%s, %d)\"", "\"(%s, \"", "\"[\"", "0", "\"%s\"", "\")\"", "\"]\"", "\"(%s, %s << %d)\"", "\"(%s, 0)\"" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "SmallVector", "<", "RegPairInfo", ",", "8", ">", "RegPairs", ";", "computeCalleeSaveRegisterPairs", "(", "MF", ",", "CSI", ",", "TRI", ",", "RegPairs", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "for", "(", "auto", "RPII", "=", "RegPairs", ".", "rbegin", "(", ")", ",", "RPIE", "=", "RegPairs", ".", "rend", "(", ")", ";", "RPII", "!=", "RPIE", ";", "++", "RPII", ")", "{", "RegPairInfo", "RPI", "=", "*", "RPII", ";", "unsigned", "Reg1", "=", "RPI", ".", "Reg1", ";", "unsigned", "Reg2", "=", "RPI", ".", "Reg2", ";", "unsigned", "StrOpc", ";", "if", "(", "RPI", ".", "IsGPR", ")", "StrOpc", "=", "RPI", ".", "isPaired", "(", ")", "?", "AArch64", "::", "STPXi", ":", "AArch64", "::", "STRXui", ";", "else", "StrOpc", "=", "RPI", ".", "isPaired", "(", ")", "?", "AArch64", "::", "STPDi", ":", "AArch64", "::", "STRDui", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"CSR spill: (\"", "<<", "TRI", "->", "getName", "(", "Reg1", ")", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "dbgs", "(", ")", "<<", "\", \"", "<<", "TRI", "->", "getName", "(", "Reg2", ")", ";", "dbgs", "(", ")", "<<", "\") -> fi#(\"", "<<", "RPI", ".", "FrameIdx", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "dbgs", "(", ")", "<<", "\", \"", "<<", "RPI", ".", "FrameIdx", "+", "1", ";", "dbgs", "(", ")", "<<", "\")\\n\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "StrOpc", ")", ")", ";", "if", "(", "!", "MRI", ".", "isReserved", "(", "Reg1", ")", ")", "MBB", ".", "addLiveIn", "(", "Reg1", ")", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "{", "if", "(", "!", "MRI", ".", "isReserved", "(", "Reg2", ")", ")", "MBB", ".", "addLiveIn", "(", "Reg2", ")", ";", "MIB", ".", "addReg", "(", "Reg2", ",", "getPrologueDeath", "(", "MF", ",", "Reg2", ")", ")", ";", "MIB", ".", "addMemOperand", "(", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "RPI", ".", "FrameIdx", "+", "1", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "8", ",", "8", ")", ")", ";", "}", "MIB", ".", "addReg", "(", "Reg1", ",", "getPrologueDeath", "(", "MF", ",", "Reg1", ")", ")", ".", "addReg", "(", "AArch64", "::", "SP", ")", ".", "addImm", "(", "RPI", ".", "Offset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "MIB", ".", "addMemOperand", "(", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "RPI", ".", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "8", ",", "8", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "spillCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "spill", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "store", "instructions", "via", "storeRegToStackSlot", "(", ")", "." ]

[ "AArch64", "AArch64", "8", "AArch64::STPXi", "AArch64::STRXui", "AArch64::STPDi", "AArch64::STRDui", "\"CSR spill: (\"", "\", \"", "\") -> fi#(\"", "\", \"", "1", "\")\\n\"", "1", "8", "8", "AArch64::SP", "8", "8" ]

[]

[ "<s>", "static", "const", "char", "*", "sparc_mangle_fundamental_type", "(", "tree", "type", ")", "{", "if", "(", "!", "TARGET_64BIT", "&&", "TYPE_MAIN_VARIANT", "(", "type", ")", "==", "long_double_type_node", "&&", "TARGET_LONG_DOUBLE_128", ")", "return", "\"g\"", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Implement", "TARGET_MANGLE_FUNDAMENTAL_TYPE", "." ]

[ "sparc", "\"g\"" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isVectorLoadExtDesirable", "(", "SDValue", "ExtVal", ")", "const", "{", "EVT", "VT", "=", "ExtVal", ".", "getValueType", "(", ")", ";", "if", "(", "!", "isTypeLegal", "(", "VT", ")", ")", "return", "false", ";", "if", "(", "ExtVal", "->", "use_empty", "(", ")", "||", "!", "ExtVal", "->", "use_begin", "(", ")", "->", "isOnlyUserOf", "(", "ExtVal", ".", "getNode", "(", ")", ")", ")", "return", "true", ";", "SDNode", "*", "U", "=", "*", "ExtVal", "->", "use_begin", "(", ")", ";", "if", "(", "(", "U", "->", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", "||", "U", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SUB", "||", "U", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SHL", "||", "U", "->", "getOpcode", "(", ")", "==", "ARMISD", "::", "VSHLIMM", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "folding", "a", "vector", "load", "into", "ExtVal", "(", "a", "sign", ",", "zero", ",", "or", "any", "extend", "node", ")", "is", "profitable", "." ]

[ "ARM", "ARM", "ISD::ADD", "ISD::SUB", "ISD::SHL", "ARMISD::VSHLIMM" ]

[]

[ "<s>", "int", "m32c_legitimize_reload_address", "(", "rtx", "*", "x", ",", "enum", "machine_mode", "mode", ",", "int", "opnum", ",", "int", "type", ",", "int", "ind_levels", "ATTRIBUTE_UNUSED", ")", "{", "fprintf", "(", "stderr", ",", "\"\\nm32c_legitimize_reload_address for mode %s\\n\"", ",", "mode_name", "[", "mode", "]", ")", ";", "debug_rtx", "(", "*", "x", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Implements", "LEGITIMIZE_RELOAD_ADDRESS", ".", "See", "comment", "above", "." ]

[ "m32c", "\"\\nm32c_legitimize_reload_address for mode %s\\n\"", "0" ]

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addPreISel", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableGlobalMerge", ")", "PM", "->", "add", "(", "createGlobalMergePass", "(", "TM", "->", "getTargetLowering", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "isLegalMaskedStore", "(", "Type", "*", "DataType", ",", "MaybeAlign", "Alignment", ")", "{", "return", "isVectorLaneType", "(", "*", "getLaneType", "(", "DataType", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "masked", "store", "." ]

[ "VE" ]

[]

[ "<s>", "void", "KudeyarAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "PrintDebugValueComment", "(", "MI", ",", "OS", ")", ";", "return", ";", "}", "MCInst", "TmpInst0", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst0", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst0", ")", ";", "}", "</s>" ]

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

[ "Kudeyar", "Kudeyar", "128" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "MachineLoopInfo", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "TPC" ]

[]

[ "<s>", "void", "AArch64MacroFusion", "::", "apply", "(", "ScheduleDAGInstrs", "*", "DAGInstrs", ")", "{", "ScheduleDAGMI", "*", "DAG", "=", "static_cast", "<", "ScheduleDAGMI", "*", ">", "(", "DAGInstrs", ")", ";", "for", "(", "SUnit", "&", "ASU", ":", "DAG", "->", "SUnits", ")", "scheduleAdjacentImpl", "(", "DAG", ",", "&", "ASU", ",", "ASU", ".", "Succs", ",", "false", ")", ";", "scheduleAdjacentImpl", "(", "DAG", ",", "&", "DAG", "->", "ExitSU", ",", "DAG", "->", "ExitSU", ".", "Preds", ",", "true", ")", ";", "}", "</s>" ]

[ "Apply", "the", "profile", "inference", "algorithm", "for", "a", "given", "function", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "FunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "AU", ".", "addRequired", "<", "AssumptionCacheTracker", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "ScalarEvolutionWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "AAResultsWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "TargetPassConfig", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "ScalarEvolutionWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "GlobalsAAWrapperPass", ">", "(", ")", ";", "AU", ".", "setPreservesCFG", "(", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "ARM" ]

[]

[ "<s>", "static", "int", "loongarch_move_from_gpr_cost", "(", "reg_class_t", "to", ")", "{", "switch", "(", "to", ")", "{", "case", "GENERAL_REGS", ":", "return", "2", ";", "case", "FP_REGS", ":", "return", "4", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "Return", "the", "cost", "of", "moving", "a", "value", "from", "a", "GPR", "to", "a", "register", "of", "class", "TO", ".", "Return", "0", "for", "classes", "that", "are", "unions", "of", "other", "classes", "handled", "by", "this", "function", "." ]

[ "loongarch", "2", "4", "0" ]

[]

[ "<s>", "bool", "SITypeRewriter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "Mod", "=", "&", "M", ";", "v16i8", "=", "VectorType", "::", "get", "(", "Type", "::", "getInt8Ty", "(", "M", ".", "getContext", "(", ")", ")", ",", "16", ")", ";", "v4i32", "=", "VectorType", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "M", ".", "getContext", "(", ")", ")", ",", "4", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "R600", "SI", "16", "4" ]

[]

[ "<s>", "void", "h8300_expand_prologue", "(", "void", ")", "{", "int", "regno", ";", "int", "saved_regs", ";", "int", "n_regs", ";", "if", "(", "h8300_os_task_function_p", "(", "current_function_decl", ")", ")", "return", ";", "if", "(", "h8300_monitor_function_p", "(", "current_function_decl", ")", ")", "emit_insn", "(", "gen_monitor_prologue", "(", ")", ")", ";", "if", "(", "frame_pointer_needed", ")", "{", "push", "(", "HARD_FRAME_POINTER_REGNUM", ")", ";", "emit_move_insn", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "}", "saved_regs", "=", "compute_saved_regs", "(", ")", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "+=", "n_regs", ")", "{", "n_regs", "=", "1", ";", "if", "(", "saved_regs", "&", "(", "1", "<<", "regno", ")", ")", "{", "if", "(", "TARGET_H8300S", ")", "{", "if", "(", "(", "!", "TARGET_H8300SX", "||", "(", "regno", "&", "3", ")", "==", "0", ")", "&&", "(", "(", "saved_regs", ">>", "regno", ")", "&", "0x0f", ")", "==", "0x0f", ")", "n_regs", "=", "4", ";", "else", "if", "(", "(", "!", "TARGET_H8300SX", "||", "(", "regno", "&", "3", ")", "==", "0", ")", "&&", "(", "(", "saved_regs", ">>", "regno", ")", "&", "0x07", ")", "==", "0x07", ")", "n_regs", "=", "3", ";", "else", "if", "(", "(", "!", "TARGET_H8300SX", "||", "(", "regno", "&", "1", ")", "==", "0", ")", "&&", "(", "(", "saved_regs", ">>", "regno", ")", "&", "0x03", ")", "==", "0x03", ")", "n_regs", "=", "2", ";", "}", "h8300_push_pop", "(", "regno", ",", "n_regs", ",", "0", ",", "0", ")", ";", "}", "}", "h8300_emit_stack_adjustment", "(", "-", "1", ",", "round_frame_size", "(", "get_frame_size", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "Generate", "RTL", "code", "for", "the", "function", "prologue", "." ]

[ "h8300", "0", "1", "1", "3", "0", "0x0f", "0x0f", "4", "3", "0", "0x07", "0x07", "3", "1", "0", "0x03", "0x03", "2", "0", "0", "1" ]

[]

[ "<s>", "static", "void", "pa_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "chain_value", ")", "{", "rtx", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "rtx", "start_addr", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "rtx", "end_addr", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "rtx", "line_length", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "rtx", "r_tramp", ",", "tmp", ";", "emit_block_move", "(", "m_tramp", ",", "assemble_trampoline_template", "(", ")", ",", "GEN_INT", "(", "TRAMPOLINE_SIZE", ")", ",", "BLOCK_OP_NORMAL", ")", ";", "r_tramp", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "m_tramp", ",", "0", ")", ")", ";", "if", "(", "!", "TARGET_64BIT", ")", "{", "tmp", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "36", ")", ";", "emit_move_insn", "(", "tmp", ",", "fnaddr", ")", ";", "tmp", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "40", ")", ";", "emit_move_insn", "(", "tmp", ",", "chain_value", ")", ";", "tmp", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "44", ")", ";", "emit_move_insn", "(", "tmp", ",", "r_tramp", ")", ";", "tmp", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "48", ")", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_REG", "(", "Pmode", ",", "19", ")", ")", ";", "emit_insn", "(", "gen_andsi3", "(", "start_addr", ",", "r_tramp", ",", "GEN_INT", "(", "-", "MIN_CACHELINE_SIZE", ")", ")", ")", ";", "tmp", "=", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "r_tramp", ",", "TRAMPOLINE_CODE_SIZE", "-", "1", ")", ")", ";", "emit_insn", "(", "gen_andsi3", "(", "end_addr", ",", "tmp", ",", "GEN_INT", "(", "-", "MIN_CACHELINE_SIZE", ")", ")", ")", ";", "emit_move_insn", "(", "line_length", ",", "GEN_INT", "(", "MIN_CACHELINE_SIZE", ")", ")", ";", "emit_insn", "(", "gen_dcacheflushsi", "(", "start_addr", ",", "end_addr", ",", "line_length", ")", ")", ";", "emit_insn", "(", "gen_icacheflushsi", "(", "start_addr", ",", "end_addr", ",", "line_length", ",", "gen_reg_rtx", "(", "Pmode", ")", ",", "gen_reg_rtx", "(", "Pmode", ")", ")", ")", ";", "}", "else", "{", "tmp", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "56", ")", ";", "emit_move_insn", "(", "tmp", ",", "fnaddr", ")", ";", "tmp", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "64", ")", ";", "emit_move_insn", "(", "tmp", ",", "chain_value", ")", ";", "tmp", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "16", ")", ";", "emit_move_insn", "(", "tmp", ",", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "r_tramp", ",", "32", ")", ")", ")", ";", "tmp", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "24", ")", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_REG", "(", "Pmode", ",", "27", ")", ")", ";", "tmp", "=", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "r_tramp", ",", "32", ")", ")", ";", "emit_insn", "(", "gen_anddi3", "(", "start_addr", ",", "tmp", ",", "GEN_INT", "(", "-", "MIN_CACHELINE_SIZE", ")", ")", ")", ";", "tmp", "=", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "tmp", ",", "TRAMPOLINE_CODE_SIZE", "-", "1", ")", ")", ";", "emit_insn", "(", "gen_anddi3", "(", "end_addr", ",", "tmp", ",", "GEN_INT", "(", "-", "MIN_CACHELINE_SIZE", ")", ")", ")", ";", "emit_move_insn", "(", "line_length", ",", "GEN_INT", "(", "MIN_CACHELINE_SIZE", ")", ")", ";", "emit_insn", "(", "gen_dcacheflushdi", "(", "start_addr", ",", "end_addr", ",", "line_length", ")", ")", ";", "emit_insn", "(", "gen_icacheflushdi", "(", "start_addr", ",", "end_addr", ",", "line_length", ",", "gen_reg_rtx", "(", "Pmode", ")", ",", "gen_reg_rtx", "(", "Pmode", ")", ")", ")", ";", "}", "emit_library_call", "(", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__enable_execute_stack\"", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "XEXP", "(", "m_tramp", ",", "0", ")", ",", "Pmode", ")", ";", "}", "</s>" ]

[ "Emit", "RTL", "insns", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", ".", "FNADDR", "is", "an", "RTX", "for", "the", "address", "of", "the", "function", "'s", "pure", "code", ".", "CXT", "is", "an", "RTX", "for", "the", "static", "chain", "value", "for", "the", "function", ".", "Move", "the", "function", "address", "to", "the", "trampoline", "template", "at", "offset", "36", ".", "Move", "the", "static", "chain", "value", "to", "trampoline", "template", "at", "offset", "40", ".", "Move", "the", "trampoline", "address", "to", "trampoline", "template", "at", "offset", "44", ".", "Move", "r19", "to", "trampoline", "template", "at", "offset", "48", ".", "The", "latter", "two", "words", "create", "a", "plabel", "for", "the", "indirect", "call", "to", "the", "trampoline", ".", "A", "similar", "sequence", "is", "used", "for", "the", "64-bit", "port", "but", "the", "plabel", "is", "at", "the", "beginning", "of", "the", "trampoline", ".", "Finally", ",", "the", "cache", "entries", "for", "the", "trampoline", "code", "are", "flushed", ".", "This", "is", "necessary", "to", "ensure", "that", "the", "trampoline", "instruction", "sequence", "is", "written", "to", "memory", "prior", "to", "any", "attempts", "at", "prefetching", "the", "code", "sequence", "." ]

[ "pa", "0", "0", "36", "40", "44", "48", "19", "1", "56", "64", "16", "32", "24", "27", "32", "1", "\"__enable_execute_stack\"", "0" ]

[]

[ "<s>", "static", "bool", "match_pcrel_step1", "(", "rtx", "insn", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "src", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "!=", "SET", ")", "return", "false", ";", "src", "=", "SET_SRC", "(", "pattern", ")", ";", "return", "(", "GET_CODE", "(", "src", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "==", "UNSPEC", "&&", "XINT", "(", "XEXP", "(", "src", ",", "0", ")", ",", "1", ")", "==", "UNSPEC_HW1_LAST_PCREL", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "INSN", "is", "the", "first", "instruction", "of", "a", "pc-relative", "address", "compuatation", "." ]

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

[]

[ "<s>", "static", "bool", "has_dispatch", "(", "rtx_insn", "*", "insn", ",", "int", "action", ")", "{", "if", "(", "(", "TARGET_BDVER1", "||", "TARGET_BDVER2", "||", "TARGET_BDVER3", "||", "TARGET_BDVER4", ")", "&&", "flag_dispatch_scheduler", ")", "switch", "(", "action", ")", "{", "default", ":", "return", "false", ";", "case", "IS_DISPATCH_ON", ":", "return", "true", ";", "break", ";", "case", "IS_CMP", ":", "return", "is_cmp", "(", "insn", ")", ";", "case", "DISPATCH_VIOLATION", ":", "return", "dispatch_violation", "(", ")", ";", "case", "FITS_DISPATCH_WINDOW", ":", "return", "fits_dispatch_window", "(", "insn", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "Dispatch", "Scheduling", "is", "supported", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "MipsBranchExpansion", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetMachine", "&", "TM", "=", "MF", ".", "getTarget", "(", ")", ";", "IsPIC", "=", "TM", ".", "isPositionIndependent", "(", ")", ";", "ABI", "=", "static_cast", "<", "const", "MipsTargetMachine", "&", ">", "(", "TM", ")", ".", "getABI", "(", ")", ";", "STI", "=", "&", "static_cast", "<", "const", "MipsSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "TII", "=", "static_cast", "<", "const", "MipsInstrInfo", "*", ">", "(", "STI", "->", "getInstrInfo", "(", ")", ")", ";", "if", "(", "IsPIC", "&&", "ABI", ".", "IsO32", "(", ")", "&&", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", "->", "globalBaseRegSet", "(", ")", ")", "emitGPDisp", "(", "MF", ",", "TII", ")", ";", "MFp", "=", "&", "MF", ";", "ForceLongBranchFirstPass", "=", "ForceLongBranch", ";", "bool", "longBranchChanged", "=", "handlePossibleLongBranch", "(", ")", ";", "bool", "forbiddenSlotChanged", "=", "handleForbiddenSlot", "(", ")", ";", "bool", "fpuDelaySlotChanged", "=", "handleFPUDelaySlot", "(", ")", ";", "bool", "Changed", "=", "longBranchChanged", "||", "forbiddenSlotChanged", "||", "fpuDelaySlotChanged", ";", "while", "(", "forbiddenSlotChanged", ")", "{", "longBranchChanged", "=", "handlePossibleLongBranch", "(", ")", ";", "fpuDelaySlotChanged", "=", "handleFPUDelaySlot", "(", ")", ";", "if", "(", "!", "longBranchChanged", "&&", "!", "fpuDelaySlotChanged", ")", "break", ";", "forbiddenSlotChanged", "=", "handleForbiddenSlot", "(", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "aarch64_macro_fusion_p", "(", "void", ")", "{", "return", "aarch64_tune_params", ".", "fusible_ops", "!=", "AARCH64_FUSE_NOTHING", ";", "}", "</s>" ]

[ "Implement", "TARGET_SCHED_MACRO_FUSION_P", ".", "Return", "true", "if", "target", "supports", "instruction", "fusion", "of", "some", "sort", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "void", "s390_cpu_cpp_builtins_internal", "(", "cpp_reader", "*", "pfile", ",", "struct", "cl_target_option", "*", "opts", ",", "const", "struct", "cl_target_option", "*", "old_opts", ")", "{", "s390_def_or_undef_macro", "(", "pfile", ",", "MASK_OPT_HTM", ",", "old_opts", ",", "opts", ",", "\"__HTM__\"", ",", "\"__HTM__\"", ")", ";", "s390_def_or_undef_macro", "(", "pfile", ",", "MASK_OPT_VX", ",", "old_opts", ",", "opts", ",", "\"__VX__\"", ",", "\"__VX__\"", ")", ";", "s390_def_or_undef_macro", "(", "pfile", ",", "MASK_ZVECTOR", ",", "old_opts", ",", "opts", ",", "\"__VEC__=10302\"", ",", "\"__VEC__\"", ")", ";", "s390_def_or_undef_macro", "(", "pfile", ",", "MASK_ZVECTOR", ",", "old_opts", ",", "opts", ",", "\"__vector=__attribute__((vector_size(16)))\"", ",", "\"__vector__\"", ")", ";", "s390_def_or_undef_macro", "(", "pfile", ",", "MASK_ZVECTOR", ",", "old_opts", ",", "opts", ",", "\"__bool=__attribute__((s390_vector_bool)) unsigned\"", ",", "\"__bool\"", ")", ";", "{", "char", "macro_def", "[", "64", "]", ";", "int", "arch_level", ";", "gcc_assert", "(", "s390_arch", "!=", "PROCESSOR_NATIVE", ")", ";", "arch_level", "=", "(", "int", ")", "s390_arch", "+", "3", ";", "if", "(", "s390_arch", ">=", "PROCESSOR_2094_Z9_EC", ")", "arch_level", "--", ";", "char", "dummy", "[", "(", "PROCESSOR_max", ">", "12", ")", "?", "-", "1", ":", "1", "]", "__attribute__", "(", "(", "unused", ")", ")", ";", "sprintf", "(", "macro_def", ",", "\"__ARCH__=%d\"", ",", "arch_level", ")", ";", "cpp_undef", "(", "pfile", ",", "\"__ARCH__\"", ")", ";", "cpp_define", "(", "pfile", ",", "macro_def", ")", ";", "}", "if", "(", "!", "flag_iso", ")", "{", "s390_def_or_undef_macro", "(", "pfile", ",", "MASK_ZVECTOR", ",", "old_opts", ",", "opts", ",", "\"__VECTOR_KEYWORD_SUPPORTED__\"", ",", "\"__VECTOR_KEYWORD_SUPPORTED__\"", ")", ";", "s390_def_or_undef_macro", "(", "pfile", ",", "MASK_ZVECTOR", ",", "old_opts", ",", "opts", ",", "\"vector=vector\"", ",", "\"vector\"", ")", ";", "s390_def_or_undef_macro", "(", "pfile", ",", "MASK_ZVECTOR", ",", "old_opts", ",", "opts", ",", "\"bool=bool\"", ",", "\"bool\"", ")", ";", "if", "(", "TARGET_ZVECTOR_P", "(", "opts", "->", "x_target_flags", ")", "&&", "__vector_keyword", "==", "NULL", ")", "{", "__vector_keyword", "=", "get_identifier", "(", "\"__vector\"", ")", ";", "C_CPP_HASHNODE", "(", "__vector_keyword", ")", "->", "flags", "|=", "NODE_CONDITIONAL", ";", "vector_keyword", "=", "get_identifier", "(", "\"vector\"", ")", ";", "C_CPP_HASHNODE", "(", "vector_keyword", ")", "->", "flags", "|=", "NODE_CONDITIONAL", ";", "__bool_keyword", "=", "get_identifier", "(", "\"__bool\"", ")", ";", "C_CPP_HASHNODE", "(", "__bool_keyword", ")", "->", "flags", "|=", "NODE_CONDITIONAL", ";", "bool_keyword", "=", "get_identifier", "(", "\"bool\"", ")", ";", "C_CPP_HASHNODE", "(", "bool_keyword", ")", "->", "flags", "|=", "NODE_CONDITIONAL", ";", "_Bool_keyword", "=", "get_identifier", "(", "\"_Bool\"", ")", ";", "C_CPP_HASHNODE", "(", "_Bool_keyword", ")", "->", "flags", "|=", "NODE_CONDITIONAL", ";", "cpp_get_callbacks", "(", "pfile", ")", "->", "macro_to_expand", "=", "s390_macro_to_expand", ";", "}", "}", "}", "</s>" ]

[ "Internal", "function", "to", "either", "define", "or", "undef", "the", "appropriate", "system", "macros", "." ]

[ "s390", "\"__HTM__\"", "\"__HTM__\"", "\"__VX__\"", "\"__VX__\"", "\"__VEC__=10302\"", "\"__VEC__\"", "\"__vector=__attribute__((vector_size(16)))\"", "\"__vector__\"", "\"__bool=__attribute__((s390_vector_bool)) unsigned\"", "\"__bool\"", "64", "3", "12", "1", "1", "\"__ARCH__=%d\"", "\"__ARCH__\"", "\"__VECTOR_KEYWORD_SUPPORTED__\"", "\"__VECTOR_KEYWORD_SUPPORTED__\"", "\"vector=vector\"", "\"vector\"", "\"bool=bool\"", "\"bool\"", "\"__vector\"", "\"vector\"", "\"__bool\"", "\"bool\"", "\"_Bool\"" ]

[]

[ "<s>", "void", "rbt_dump", "(", "struct", "rbt_strings", "*", "t", ",", "struct", "rbt_string_node", "*", "subtree", ")", "{", "if", "(", "subtree", "!=", "t", "->", "rbt_nil", ")", "{", "rbt_dump", "(", "t", ",", "subtree", "->", "left", ")", ";", "fprintf", "(", "stderr", ",", "\"%s\\n\"", ",", "subtree", "->", "str", ")", ";", "rbt_dump", "(", "t", ",", "subtree", "->", "right", ")", ";", "}", "}", "</s>" ]

[ "Inorder", "dump", "of", "the", "binary", "search", "tree", "." ]

[ "rs6000", "\"%s\\n\"" ]

[]

[ "<s>", "bool", "PPCFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "return", "false", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "PPCInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "PPCInstrInfo", "*", ">", "(", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "bool", "CR2Spilled", "=", "false", ";", "bool", "CR3Spilled", "=", "false", ";", "bool", "CR4Spilled", "=", "false", ";", "unsigned", "CSIIndex", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MI", ",", "BeforeI", "=", "I", ";", "bool", "AtStart", "=", "I", "==", "MBB", ".", "begin", "(", ")", ";", "if", "(", "!", "AtStart", ")", "--", "BeforeI", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "==", "PPC", "::", "CR2", ")", "{", "CR2Spilled", "=", "true", ";", "CSIIndex", "=", "i", ";", "continue", ";", "}", "else", "if", "(", "Reg", "==", "PPC", "::", "CR3", ")", "{", "CR3Spilled", "=", "true", ";", "continue", ";", "}", "else", "if", "(", "Reg", "==", "PPC", "::", "CR4", ")", "{", "CR4Spilled", "=", "true", ";", "continue", ";", "}", "else", "{", "if", "(", "(", "CR2Spilled", "||", "CR3Spilled", "||", "CR4Spilled", ")", "&&", "!", "(", "PPC", "::", "CR2", "<=", "Reg", "&&", "Reg", "<=", "PPC", "::", "CR4", ")", ")", "{", "restoreCRs", "(", "Subtarget", ".", "isPPC64", "(", ")", ",", "CR2Spilled", ",", "CR3Spilled", ",", "CR4Spilled", ",", "MBB", ",", "I", ",", "CSI", ",", "CSIIndex", ")", ";", "CR2Spilled", "=", "CR3Spilled", "=", "CR4Spilled", "=", "false", ";", "}", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "I", ",", "Reg", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "assert", "(", "I", "!=", "MBB", ".", "begin", "(", ")", "&&", "\"loadRegFromStackSlot didn't insert any code!\"", ")", ";", "}", "if", "(", "AtStart", ")", "I", "=", "MBB", ".", "begin", "(", ")", ";", "else", "{", "I", "=", "BeforeI", ";", "++", "I", ";", "}", "}", "if", "(", "CR2Spilled", "||", "CR3Spilled", "||", "CR4Spilled", ")", "restoreCRs", "(", "Subtarget", ".", "isPPC64", "(", ")", ",", "CR2Spilled", ",", "CR3Spilled", ",", "CR4Spilled", ",", "MBB", ",", "I", ",", "CSI", ",", "CSIIndex", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "restoreCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "restore", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "load", "instructions", "via", "loadRegToStackSlot", "(", ")", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "0", "0", "PPC::CR2", "PPC::CR3", "PPC::CR4", "PPC::CR2", "PPC::CR4", "PPC", "\"loadRegFromStackSlot didn't insert any code!\"", "PPC" ]

[]

[ "<s>", "int", "arm_const_double_rtx", "(", "rtx", "x", ")", "{", "const", "REAL_VALUE_TYPE", "*", "r", ";", "if", "(", "!", "fp_consts_inited", ")", "init_fp_table", "(", ")", ";", "r", "=", "CONST_DOUBLE_REAL_VALUE", "(", "x", ")", ";", "if", "(", "REAL_VALUE_MINUS_ZERO", "(", "*", "r", ")", ")", "return", "0", ";", "if", "(", "real_equal", "(", "r", ",", "&", "value_fp0", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "rtx", "X", "is", "a", "valid", "immediate", "FP", "constant", "." ]

[ "arm", "0", "1", "0" ]

[]

[ "<s>", "bool", "MOVToLEAPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "TargetInstrInfo", "*", "TII", "=", "Fn", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "Seed", "!=", "0", ")", "RNG", ".", "reset", "(", "Fn", ".", "getFunction", "(", ")", "->", "getParent", "(", ")", "->", "createRNG", "(", "Seed", ",", "this", ",", "Fn", ".", "getFunction", "(", ")", "->", "getName", "(", ")", ")", ")", ";", "else", "if", "(", "!", "RNG", ")", "RNG", ".", "reset", "(", "Fn", ".", "getFunction", "(", ")", "->", "getParent", "(", ")", "->", "createRNG", "(", "this", ")", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "Fn", ".", "begin", "(", ")", ",", "E", "=", "Fn", ".", "end", "(", ")", ";", "BB", "!=", "E", ";", "++", "BB", ")", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "BB", "->", "begin", "(", ")", ";", "I", "!=", "BB", "->", "end", "(", ")", ";", ")", "{", "++", "PreMOVtoLEAInstructionCount", ";", "if", "(", "I", "->", "getNumOperands", "(", ")", "!=", "2", "||", "!", "I", "->", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", "||", "!", "I", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", ")", "{", "++", "I", ";", "continue", ";", "}", "unsigned", "leaOpc", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "X86", "::", "MOV32rr", ")", "{", "leaOpc", "=", "X86", "::", "LEA32r", ";", "}", "else", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "X86", "::", "MOV64rr", ")", "{", "leaOpc", "=", "X86", "::", "LEA64r", ";", "}", "else", "{", "++", "I", ";", "continue", ";", "}", "unsigned", "int", "Roll", "=", "RNG", "->", "Random", "(", "100", ")", ";", "++", "MOVCandidates", ";", "if", "(", "Roll", ">=", "multicompiler", "::", "MOVToLEAPercentage", ")", "{", "++", "I", ";", "continue", ";", "}", "++", "ReplacedMOV", ";", "MachineBasicBlock", "::", "iterator", "J", "=", "I", ";", "++", "I", ";", "addRegOffset", "(", "BuildMI", "(", "*", "BB", ",", "J", ",", "J", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "leaOpc", ")", ",", "J", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ",", "J", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ",", "false", ",", "0", ")", ";", "J", "->", "eraseFromParent", "(", ")", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "0", "2", "0", "1", "X86::MOV32rr", "X86::LEA32r", "X86::MOV64rr", "X86::LEA64r", "100", "0", "1", "0" ]

[]

[ "<s>", "static", "void", "avr_reorg", "(", "void", ")", "{", "rtx_insn", "*", "insn", "=", "get_insns", "(", ")", ";", "for", "(", "insn", "=", "next_real_insn", "(", "insn", ")", ";", "insn", ";", "insn", "=", "next_real_insn", "(", "insn", ")", ")", "{", "rtx", "pattern", "=", "avr_compare_pattern", "(", "insn", ")", ";", "if", "(", "!", "pattern", ")", "continue", ";", "if", "(", "optimize", "&&", "avr_reorg_remove_redundant_compare", "(", "insn", ")", ")", "{", "continue", ";", "}", "if", "(", "compare_diff_p", "(", "insn", ")", ")", "{", "rtx", "next", "=", "next_real_insn", "(", "insn", ")", ";", "rtx", "pat", "=", "PATTERN", "(", "next", ")", ";", "pattern", "=", "SET_SRC", "(", "pattern", ")", ";", "if", "(", "true_regnum", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ">=", "0", "&&", "true_regnum", "(", "XEXP", "(", "pattern", ",", "1", ")", ")", ">=", "0", ")", "{", "rtx", "x", "=", "XEXP", "(", "pattern", ",", "0", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "rtx", "t", "=", "XEXP", "(", "src", ",", "0", ")", ";", "PUT_CODE", "(", "t", ",", "swap_condition", "(", "GET_CODE", "(", "t", ")", ")", ")", ";", "XEXP", "(", "pattern", ",", "0", ")", "=", "XEXP", "(", "pattern", ",", "1", ")", ";", "XEXP", "(", "pattern", ",", "1", ")", "=", "x", ";", "INSN_CODE", "(", "next", ")", "=", "-", "1", ";", "}", "else", "if", "(", "true_regnum", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ">=", "0", "&&", "XEXP", "(", "pattern", ",", "1", ")", "==", "const0_rtx", ")", "{", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "rtx", "t", "=", "XEXP", "(", "src", ",", "0", ")", ";", "PUT_CODE", "(", "t", ",", "swap_condition", "(", "GET_CODE", "(", "t", ")", ")", ")", ";", "XEXP", "(", "pattern", ",", "1", ")", "=", "XEXP", "(", "pattern", ",", "0", ")", ";", "XEXP", "(", "pattern", ",", "0", ")", "=", "const0_rtx", ";", "INSN_CODE", "(", "next", ")", "=", "-", "1", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "}", "else", "if", "(", "true_regnum", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ">=", "0", "&&", "CONST_INT_P", "(", "XEXP", "(", "pattern", ",", "1", ")", ")", ")", "{", "rtx", "x", "=", "XEXP", "(", "pattern", ",", "1", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "rtx", "t", "=", "XEXP", "(", "src", ",", "0", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ";", "if", "(", "avr_simplify_comparison_p", "(", "mode", ",", "GET_CODE", "(", "t", ")", ",", "x", ")", ")", "{", "XEXP", "(", "pattern", ",", "1", ")", "=", "gen_int_mode", "(", "INTVAL", "(", "x", ")", "+", "1", ",", "mode", ")", ";", "PUT_CODE", "(", "t", ",", "avr_normalize_condition", "(", "GET_CODE", "(", "t", ")", ")", ")", ";", "INSN_CODE", "(", "next", ")", "=", "-", "1", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "}", "}", "}", "}", "}", "</s>" ]

[ "This", "function", "optimizes", "conditional", "jumps", "." ]

[ "avr", "0", "0", "1", "0", "0", "0", "0", "1", "1", "1", "0", "0", "1", "0", "1", "0", "0", "1", "1", "0", "0", "1", "1", "0", "0", "1", "1", "1", "1" ]

[]

[ "<s>", "bool", "AMDGPUCFGStructurizer", "::", "prepare", "(", ")", "{", "bool", "Changed", "=", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"AMDGPUCFGStructurizer::prepare\\n\"", ";", ")", ";", "orderBlocks", "(", "FuncRep", ")", ";", "SmallVector", "<", "MachineBasicBlock", "*", ",", "DEFAULT_VEC_SLOTS", ">", "RetBlks", ";", "for", "(", "MachineLoopInfo", "::", "iterator", "It", "=", "MLI", "->", "begin", "(", ")", ",", "E", "=", "MLI", "->", "end", "(", ")", ";", "It", "!=", "E", ";", "++", "It", ")", "{", "MachineLoop", "*", "LoopRep", "=", "(", "*", "It", ")", ";", "MBBVector", "ExitingMBBs", ";", "LoopRep", "->", "getExitingBlocks", "(", "ExitingMBBs", ")", ";", "if", "(", "ExitingMBBs", ".", "size", "(", ")", "==", "0", ")", "{", "MachineBasicBlock", "*", "DummyExitBlk", "=", "normalizeInfiniteLoopExit", "(", "LoopRep", ")", ";", "if", "(", "DummyExitBlk", ")", "RetBlks", ".", "push_back", "(", "DummyExitBlk", ")", ";", "}", "}", "for", "(", "MachineBasicBlock", "*", "MBB", ":", "OrderedBlks", ")", "{", "removeUnconditionalBranch", "(", "MBB", ")", ";", "removeRedundantConditionalBranch", "(", "MBB", ")", ";", "if", "(", "isReturnBlock", "(", "MBB", ")", ")", "{", "RetBlks", ".", "push_back", "(", "MBB", ")", ";", "}", "assert", "(", "MBB", "->", "succ_size", "(", ")", "<=", "2", ")", ";", "}", "if", "(", "RetBlks", ".", "size", "(", ")", ">=", "2", ")", "{", "addDummyExitBlock", "(", "RetBlks", ")", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "prepare", "-", "Reset", "state", "and", "prepare", "for", "a", "new", "spill", "placement", "computation", "." ]

[ "AMDGPU", "AMDGPU", "\"AMDGPUCFGStructurizer::prepare\\n\"", "0", "2", "2" ]

[]

[ "<s>", "int", "PIC16RegisterInfo", "::", "getDwarfRegNum", "(", "unsigned", "RegNum", ",", "bool", "isEH", ")", "const", "{", "assert", "(", "0", "&&", "\"Not keeping track of debug information yet!!\"", ")", ";", "return", "-", "1", ";", "}", "</s>" ]

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

[ "PIC16", "PIC16", "0", "\"Not keeping track of debug information yet!!\"", "1" ]

[]

[ "<s>", "void", "PTXPassConfig", "::", "addMachineLateOptimization", "(", ")", "{", "if", "(", "addPass", "(", "BranchFolderPassID", ")", "!=", "&", "NoPassID", ")", "printAndVerify", "(", "\"After BranchFolding\"", ")", ";", "if", "(", "addPass", "(", "TailDuplicateID", ")", "!=", "&", "NoPassID", ")", "printAndVerify", "(", "\"After TailDuplicate\"", ")", ";", "}", "</s>" ]

[ "Add", "passes", "that", "optimize", "machine", "instructions", "after", "register", "allocation", "." ]

[ "PTX", "PTX", "\"After BranchFolding\"", "\"After TailDuplicate\"" ]

[]

[ "<s>", "bool", "doFinalization", "(", "Module", "&", "M", ")", "override", "{", "Result", ".", "reset", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

[ "TPC" ]

[]

[ "<s>", "bool", "WinEHStatePass", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "F", ".", "hasPersonalityFn", "(", ")", ")", "return", "false", ";", "PersonalityFn", "=", "dyn_cast", "<", "Function", ">", "(", "F", ".", "getPersonalityFn", "(", ")", "->", "stripPointerCasts", "(", ")", ")", ";", "if", "(", "!", "PersonalityFn", ")", "return", "false", ";", "Personality", "=", "classifyEHPersonality", "(", "PersonalityFn", ")", ";", "if", "(", "!", "isFuncletEHPersonality", "(", "Personality", ")", ")", "return", "false", ";", "bool", "HasPads", "=", "false", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "if", "(", "BB", ".", "isEHPad", "(", ")", ")", "{", "HasPads", "=", "true", ";", "break", ";", "}", "}", "if", "(", "!", "HasPads", ")", "return", "false", ";", "Type", "*", "Int8PtrType", "=", "Type", "::", "getInt8PtrTy", "(", "TheModule", "->", "getContext", "(", ")", ")", ";", "SetJmp3", "=", "TheModule", "->", "getOrInsertFunction", "(", "\"_setjmp3\"", ",", "FunctionType", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "TheModule", "->", "getContext", "(", ")", ")", ",", "{", "Int8PtrType", ",", "Type", "::", "getInt32Ty", "(", "TheModule", "->", "getContext", "(", ")", ")", "}", ",", "true", ")", ")", ";", "F", ".", "addFnAttr", "(", "\"no-frame-pointer-elim\"", ",", "\"true\"", ")", ";", "emitExceptionRegistrationRecord", "(", "&", "F", ")", ";", "WinEHFuncInfo", "FuncInfo", ";", "addStateStores", "(", "F", ",", "FuncInfo", ")", ";", "PersonalityFn", "=", "nullptr", ";", "Personality", "=", "EHPersonality", "::", "Unknown", ";", "UseStackGuard", "=", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "X86", "\"_setjmp3\"", "\"no-frame-pointer-elim\"", "\"true\"" ]

[]

[ "<s>", "static", "bool", "aarch64_simd_call_p", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "symbol", ";", "rtx", "call", ";", "tree", "fndecl", ";", "gcc_assert", "(", "CALL_P", "(", "insn", ")", ")", ";", "call", "=", "get_call_rtx_from", "(", "insn", ")", ";", "symbol", "=", "XEXP", "(", "XEXP", "(", "call", ",", "0", ")", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "symbol", ")", "!=", "SYMBOL_REF", ")", "return", "false", ";", "fndecl", "=", "SYMBOL_REF_DECL", "(", "symbol", ")", ";", "if", "(", "!", "fndecl", ")", "return", "false", ";", "return", "aarch64_simd_decl_p", "(", "fndecl", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "is", "a", "call", "to", "a", "SIMD", "function", ",", "false", "if", "it", "is", "not", "a", "SIMD", "function", "or", "if", "we", "do", "not", "know", "anything", "about", "the", "function", "." ]

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

[]

[ "<s>", "unsigned", "MipsCodeEmitter", "::", "getMachineOpValue", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "&", "MO", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "MipsRegisterInfo", "::", "getRegisterNumbering", "(", "MO", ".", "getReg", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "Mips", "::", "ULW", "||", "MI", ".", "getOpcode", "(", ")", "==", "Mips", "::", "USW", "||", "MI", ".", "getOpcode", "(", ")", "==", "Mips", "::", "ULH", "||", "MI", ".", "getOpcode", "(", ")", "==", "Mips", "::", "ULHu", ")", "emitGlobalAddressUnaligned", "(", "MO", ".", "getGlobal", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ",", "4", ")", ";", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "Mips", "::", "USH", ")", "emitGlobalAddressUnaligned", "(", "MO", ".", "getGlobal", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ",", "8", ")", ";", "else", "emitGlobalAddress", "(", "MO", ".", "getGlobal", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ",", "true", ")", ";", "}", "else", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "emitExternalSymbolAddress", "(", "MO", ".", "getSymbolName", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ")", ";", "else", "if", "(", "MO", ".", "isCPI", "(", ")", ")", "emitConstPoolAddress", "(", "MO", ".", "getIndex", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ")", ";", "else", "if", "(", "MO", ".", "isJTI", "(", ")", ")", "emitJumpTableAddress", "(", "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", "." ]

[ "Mips", "Mips", "Mips", "Mips::ULW", "Mips::USW", "Mips::ULH", "Mips::ULHu", "4", "Mips::USH", "8", "\"Unable to encode MachineOperand!\"", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Workaround A53 erratum 835769 pass\"", ";", "}", "</s>" ]

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

[ "AArch64", "\"Workaround A53 erratum 835769 pass\"" ]

[]

[ "<s>", "int", "X86FrameLowering", "::", "getFrameIndexReferencePreferSP", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ",", "bool", "IgnoreSPUpdates", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", "&&", "TRI", "->", "needsStackRealignment", "(", "MF", ")", "&&", "!", "STI", ".", "isTargetWin64", "(", ")", ")", "return", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "!", "IgnoreSPUpdates", "&&", "!", "TFI", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "return", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ")", ";", "assert", "(", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getTCReturnAddrDelta", "(", ")", ">=", "0", "&&", "\"we don't handle this case!\"", ")", ";", "FrameReg", "=", "TRI", "->", "getStackRegister", "(", ")", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", "-", "getOffsetOfLocalArea", "(", ")", ";", "return", "Offset", "+", "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", "rtx", "v850_function_arg", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "rtx", "result", "=", "NULL_RTX", ";", "int", "size", ",", "align", ";", "if", "(", "!", "arg", ".", "named", ")", "return", "NULL_RTX", ";", "size", "=", "arg", ".", "promoted_size_in_bytes", "(", ")", ";", "size", "=", "(", "size", "+", "UNITS_PER_WORD", "-", "1", ")", "&", "~", "(", "UNITS_PER_WORD", "-", "1", ")", ";", "if", "(", "size", "<", "1", ")", "{", "cum", "->", "nbytes", "=", "4", "*", "UNITS_PER_WORD", ";", "return", "NULL_RTX", ";", "}", "if", "(", "!", "TARGET_GCC_ABI", ")", "align", "=", "UNITS_PER_WORD", ";", "else", "if", "(", "size", "<=", "UNITS_PER_WORD", "&&", "arg", ".", "type", ")", "align", "=", "TYPE_ALIGN", "(", "arg", ".", "type", ")", "/", "BITS_PER_UNIT", ";", "else", "align", "=", "size", ";", "cum", "->", "nbytes", "=", "(", "cum", "->", "nbytes", "+", "align", "-", "1", ")", "&", "~", "(", "align", "-", "1", ")", ";", "if", "(", "cum", "->", "nbytes", ">", "4", "*", "UNITS_PER_WORD", ")", "return", "NULL_RTX", ";", "if", "(", "arg", ".", "type", "==", "NULL_TREE", "&&", "cum", "->", "nbytes", "+", "size", ">", "4", "*", "UNITS_PER_WORD", ")", "return", "NULL_RTX", ";", "switch", "(", "cum", "->", "nbytes", "/", "UNITS_PER_WORD", ")", "{", "case", "0", ":", "result", "=", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "6", ")", ";", "break", ";", "case", "1", ":", "result", "=", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "7", ")", ";", "break", ";", "case", "2", ":", "result", "=", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "8", ")", ";", "break", ";", "case", "3", ":", "result", "=", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "9", ")", ";", "break", ";", "default", ":", "result", "=", "NULL_RTX", ";", "}", "return", "result", ";", "}", "</s>" ]

[ "Return", "an", "RTX", "to", "represent", "where", "an", "argument", "with", "mode", "MODE", "and", "type", "TYPE", "will", "be", "passed", "to", "a", "function", ".", "If", "the", "result", "is", "NULL_RTX", ",", "the", "argument", "will", "be", "pushed", "." ]

[ "v850", "1", "1", "1", "4", "1", "1", "4", "4", "0", "6", "1", "7", "2", "8", "3", "9" ]

[]

[ "<s>", "bool", "Z80ExpandPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ".", "addKillFlags", "(", "&", "getAnalysis", "<", "VirtRegMap", ">", "(", ")", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "Z80", "Z80" ]

[]

[ "<s>", "bool", "AArch64PostLegalizerCombiner", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "MF", ".", "getProperties", "(", ")", ".", "hasProperty", "(", "MachineFunctionProperties", "::", "Property", "::", "FailedISel", ")", ")", "return", "false", ";", "assert", "(", "MF", ".", "getProperties", "(", ")", ".", "hasProperty", "(", "MachineFunctionProperties", "::", "Property", "::", "Legalized", ")", "&&", "\"Expected a legalized function?\"", ")", ";", "auto", "*", "TPC", "=", "&", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "EnableOpt", "=", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "!", "skipFunction", "(", "F", ")", ";", "GISelKnownBits", "*", "KB", "=", "&", "getAnalysis", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ".", "get", "(", "MF", ")", ";", "MachineDominatorTree", "*", "MDT", "=", "IsOptNone", "?", "nullptr", ":", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "AArch64PostLegalizerCombinerInfo", "PCInfo", "(", "EnableOpt", ",", "F", ".", "hasOptSize", "(", ")", ",", "F", ".", "hasMinSize", "(", ")", ",", "KB", ",", "MDT", ")", ";", "Combiner", "C", "(", "PCInfo", ",", "TPC", ")", ";", "return", "C", ".", "combineMachineInstrs", "(", "MF", ",", "nullptr", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Expected a legalized function?\"", "AArch64" ]

[]

[ "<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", "." ]

[ "X86" ]

[]

[ "<s>", "void", "ARMCallLowering", "::", "splitToValueTypes", "(", "const", "ArgInfo", "&", "OrigArg", ",", "SmallVectorImpl", "<", "ArgInfo", ">", "&", "SplitArgs", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "ARMTargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "ARMTargetLowering", ">", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "OrigArg", ".", "Ty", "->", "getContext", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "SmallVector", "<", "EVT", ",", "4", ">", "SplitVTs", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "OrigArg", ".", "Ty", ",", "SplitVTs", ",", "nullptr", ",", "nullptr", ",", "0", ")", ";", "assert", "(", "OrigArg", ".", "Regs", ".", "size", "(", ")", "==", "SplitVTs", ".", "size", "(", ")", "&&", "\"Regs / types mismatch\"", ")", ";", "if", "(", "SplitVTs", ".", "size", "(", ")", "==", "1", ")", "{", "auto", "Flags", "=", "OrigArg", ".", "Flags", "[", "0", "]", ";", "unsigned", "OriginalAlignment", "=", "DL", ".", "getABITypeAlignment", "(", "OrigArg", ".", "Ty", ")", ";", "Flags", ".", "setOrigAlign", "(", "OriginalAlignment", ")", ";", "SplitArgs", ".", "emplace_back", "(", "OrigArg", ".", "Regs", "[", "0", "]", ",", "SplitVTs", "[", "0", "]", ".", "getTypeForEVT", "(", "Ctx", ")", ",", "Flags", ",", "OrigArg", ".", "IsFixed", ")", ";", "return", ";", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "SplitVTs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "EVT", "SplitVT", "=", "SplitVTs", "[", "i", "]", ";", "Type", "*", "SplitTy", "=", "SplitVT", ".", "getTypeForEVT", "(", "Ctx", ")", ";", "auto", "Flags", "=", "OrigArg", ".", "Flags", "[", "0", "]", ";", "unsigned", "OriginalAlignment", "=", "DL", ".", "getABITypeAlignment", "(", "SplitTy", ")", ";", "Flags", ".", "setOrigAlign", "(", "OriginalAlignment", ")", ";", "bool", "NeedsConsecutiveRegisters", "=", "TLI", ".", "functionArgumentNeedsConsecutiveRegisters", "(", "SplitTy", ",", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ";", "if", "(", "NeedsConsecutiveRegisters", ")", "{", "Flags", ".", "setInConsecutiveRegs", "(", ")", ";", "if", "(", "i", "==", "e", "-", "1", ")", "Flags", ".", "setInConsecutiveRegsLast", "(", ")", ";", "}", "Register", "PartReg", "=", "OrigArg", ".", "Regs", "[", "i", "]", ";", "SplitArgs", ".", "emplace_back", "(", "PartReg", ",", "SplitTy", ",", "Flags", ",", "OrigArg", ".", "IsFixed", ")", ";", "}", "}", "</s>" ]

[ "Break", "OrigArgInfo", "into", "one", "or", "more", "pieces", "the", "calling", "convention", "can", "process", ",", "returned", "in", "SplitArgs", "." ]

[ "ARM", "ARM", "ARM", "ARM", "4", "0", "\"Regs / types mismatch\"", "1", "0", "0", "0", "0", "0", "1" ]

[]

[ "<s>", "AArch64TargetMachine", "::", "AArch64TargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ",", "bool", "LittleEndian", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ",", "Options", ".", "MCOptions", ",", "LittleEndian", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "TT", ",", "RM", ")", ",", "getEffectiveAArch64CodeModel", "(", "TT", ",", "CM", ",", "JIT", ")", ",", "OL", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", ",", "isLittle", "(", "LittleEndian", ")", "{", "initAsmInfo", "(", ")", ";", "if", "(", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "this", "->", "Options", ".", "NoTrapAfterNoreturn", "=", "true", ";", "}", "if", "(", "getMCAsmInfo", "(", ")", "->", "usesWindowsCFI", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "}", "if", "(", "getOptLevel", "(", ")", "<=", "EnableGlobalISelAtO", ")", "{", "setGlobalISel", "(", "true", ")", ";", "setGlobalISelAbort", "(", "GlobalISelAbortMode", "::", "Disable", ")", ";", "}", "setMachineOutliner", "(", "true", ")", ";", "setSupportsDefaultOutlining", "(", "true", ")", ";", "}", "</s>" ]

[ "Create", "an", "AArch64", "architecture", "model", "." ]

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

[]

[ "<s>", "rtx", "function_value", "(", "const_tree", "valtype", ",", "const_tree", "func", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "unsigned", "int", "regnum", ",", "dummy", "ATTRIBUTE_UNUSED", ";", "enum", "mode_class", "mclass", ";", "gcc_assert", "(", "!", "valtype", "||", "!", "alpha_return_in_memory", "(", "valtype", ",", "func", ")", ")", ";", "if", "(", "valtype", ")", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "mclass", "=", "GET_MODE_CLASS", "(", "mode", ")", ";", "switch", "(", "mclass", ")", "{", "case", "MODE_INT", ":", "if", "(", "!", "(", "TARGET_ABI_OPEN_VMS", "&&", "valtype", "&&", "AGGREGATE_TYPE_P", "(", "valtype", ")", ")", ")", "PROMOTE_MODE", "(", "mode", ",", "dummy", ",", "valtype", ")", ";", "case", "MODE_COMPLEX_INT", ":", "case", "MODE_VECTOR_INT", ":", "regnum", "=", "0", ";", "break", ";", "case", "MODE_FLOAT", ":", "regnum", "=", "32", ";", "break", ";", "case", "MODE_COMPLEX_FLOAT", ":", "{", "machine_mode", "cmode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "return", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "cmode", ",", "32", ")", ",", "const0_rtx", ")", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "cmode", ",", "33", ")", ",", "GEN_INT", "(", "GET_MODE_SIZE", "(", "cmode", ")", ")", ")", ")", ")", ";", "}", "case", "MODE_RANDOM", ":", "gcc_assert", "(", "TARGET_ABI_OPEN_VMS", "&&", "mode", "==", "BLKmode", ")", ";", "regnum", "=", "0", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "gen_rtx_REG", "(", "mode", ",", "regnum", ")", ";", "}", "</s>" ]

[ "Handle", "FUNCTION_VALUE", ",", "FUNCTION_OUTGOING_VALUE", ",", "and", "LIBCALL_VALUE", "macros", ".", "For", "v9", ",", "function", "return", "values", "are", "subject", "to", "the", "same", "rules", "as", "arguments", ",", "except", "that", "up", "to", "32", "bytes", "may", "be", "returned", "in", "registers", "." ]

[ "alpha", "0", "32", "2", "32", "33", "0" ]

[]

[ "<s>", "bool", "AAPFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

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

[ "AAP", "AAP" ]

[]

[ "<s>", "int", "ccr_bit", "(", "rtx", "op", ",", "int", "scc_p", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "op", ")", ";", "enum", "machine_mode", "cc_mode", ";", "int", "cc_regnum", ";", "int", "base_bit", ";", "rtx", "reg", ";", "if", "(", "!", "COMPARISON_P", "(", "op", ")", ")", "return", "-", "1", ";", "reg", "=", "XEXP", "(", "op", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "reg", ")", "==", "REG", "&&", "CR_REGNO_P", "(", "REGNO", "(", "reg", ")", ")", ")", ";", "cc_mode", "=", "GET_MODE", "(", "reg", ")", ";", "cc_regnum", "=", "REGNO", "(", "reg", ")", ";", "base_bit", "=", "4", "*", "(", "cc_regnum", "-", "CR0_REGNO", ")", ";", "validate_condition_mode", "(", "code", ",", "cc_mode", ")", ";", "gcc_assert", "(", "!", "scc_p", "||", "code", "==", "EQ", "||", "code", "==", "GT", "||", "code", "==", "LT", "||", "code", "==", "UNORDERED", "||", "code", "==", "GTU", "||", "code", "==", "LTU", ")", ";", "switch", "(", "code", ")", "{", "case", "NE", ":", "return", "scc_p", "?", "base_bit", "+", "3", ":", "base_bit", "+", "2", ";", "case", "EQ", ":", "return", "base_bit", "+", "2", ";", "case", "GT", ":", "case", "GTU", ":", "case", "UNLE", ":", "return", "base_bit", "+", "1", ";", "case", "LT", ":", "case", "LTU", ":", "case", "UNGE", ":", "return", "base_bit", ";", "case", "ORDERED", ":", "case", "UNORDERED", ":", "return", "base_bit", "+", "3", ";", "case", "GE", ":", "case", "GEU", ":", "return", "scc_p", "?", "base_bit", "+", "3", ":", "base_bit", ";", "case", "LE", ":", "case", "LEU", ":", "return", "scc_p", "?", "base_bit", "+", "3", ":", "base_bit", "+", "1", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Given", "a", "comparison", "operation", ",", "return", "the", "bit", "number", "in", "CCR", "to", "test", ".", "We", "know", "this", "is", "a", "valid", "comparison", ".", "SCC_P", "is", "1", "if", "this", "is", "for", "an", "scc", ".", "That", "means", "that", "%", "D", "will", "have", "been", "used", "instead", "of", "%", "C", ",", "so", "the", "bits", "will", "be", "in", "different", "places", ".", "Return", "-1", "if", "OP", "is", "n't", "a", "valid", "comparison", "for", "some", "reason", "." ]

[ "rs6000", "1", "0", "4", "3", "2", "2", "1", "3", "3", "3", "1" ]

[]

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

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "M680x0" ]

[]

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

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

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

[]

[ "<s>", "int", "cirrus_memory_offset", "(", "rtx", "op", ")", "{", "if", "(", "!", "(", "reload_in_progress", "||", "reload_completed", ")", "&&", "(", "reg_mentioned_p", "(", "frame_pointer_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "arg_pointer_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "virtual_incoming_args_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "virtual_outgoing_args_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "virtual_stack_dynamic_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "virtual_stack_vars_rtx", ",", "op", ")", ")", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "MEM", ")", "{", "rtx", "ind", ";", "ind", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "ind", ")", "==", "REG", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "ind", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "ind", ",", "0", ")", ")", "==", "REG", "&&", "REG_MODE_OK_FOR_BASE_P", "(", "XEXP", "(", "ind", ",", "0", ")", ",", "VOIDmode", ")", "&&", "GET_CODE", "(", "XEXP", "(", "ind", ",", "1", ")", ")", "==", "CONST_INT", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "OP", "is", "a", "valid", "Cirrus", "memory", "address", "pattern", "." ]

[ "arm", "0", "0", "1", "0", "0", "1", "1", "0" ]

[]

[ "<s>", "void", "XCoreAsmPrinter", "::", "emitGlobalVariable", "(", "const", "GlobalVariable", "*", "GV", ")", "{", "if", "(", "!", "GV", "->", "hasInitializer", "(", ")", "||", "emitSpecialLLVMGlobal", "(", "GV", ")", ")", "return", ";", "const", "DataLayout", "&", "DL", "=", "getDataLayout", "(", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "SectionForGlobal", "(", "GV", ",", "TM", ")", ")", ";", "MCSymbol", "*", "GVSym", "=", "getSymbol", "(", "GV", ")", ";", "const", "Constant", "*", "C", "=", "GV", "->", "getInitializer", "(", ")", ";", "const", "Align", "Alignment", "(", "DL", ".", "getPrefTypeAlignment", "(", "C", "->", "getType", "(", ")", ")", ")", ";", "getTargetStreamer", "(", ")", ".", "emitCCTopData", "(", "GVSym", "->", "getName", "(", ")", ")", ";", "switch", "(", "GV", "->", "getLinkage", "(", ")", ")", "{", "case", "GlobalValue", "::", "AppendingLinkage", ":", "report_fatal_error", "(", "\"AppendingLinkage is not supported by this target!\"", ")", ";", "case", "GlobalValue", "::", "LinkOnceAnyLinkage", ":", "case", "GlobalValue", "::", "LinkOnceODRLinkage", ":", "case", "GlobalValue", "::", "WeakAnyLinkage", ":", "case", "GlobalValue", "::", "WeakODRLinkage", ":", "case", "GlobalValue", "::", "ExternalLinkage", ":", "case", "GlobalValue", "::", "CommonLinkage", ":", "emitArrayBound", "(", "GVSym", ",", "GV", ")", ";", "OutStreamer", "->", "emitSymbolAttribute", "(", "GVSym", ",", "MCSA_Global", ")", ";", "if", "(", "GV", "->", "hasWeakLinkage", "(", ")", "||", "GV", "->", "hasLinkOnceLinkage", "(", ")", "||", "GV", "->", "hasCommonLinkage", "(", ")", ")", "OutStreamer", "->", "emitSymbolAttribute", "(", "GVSym", ",", "MCSA_Weak", ")", ";", "LLVM_FALLTHROUGH", ";", "case", "GlobalValue", "::", "InternalLinkage", ":", "case", "GlobalValue", "::", "PrivateLinkage", ":", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Unknown linkage type!\"", ")", ";", "}", "emitAlignment", "(", "std", "::", "max", "(", "Alignment", ",", "Align", "(", "4", ")", ")", ",", "GV", ")", ";", "if", "(", "GV", "->", "isThreadLocal", "(", ")", ")", "{", "report_fatal_error", "(", "\"TLS is not supported by this target!\"", ")", ";", "}", "unsigned", "Size", "=", "DL", ".", "getTypeAllocSize", "(", "C", "->", "getType", "(", ")", ")", ";", "if", "(", "MAI", "->", "hasDotTypeDotSizeDirective", "(", ")", ")", "{", "OutStreamer", "->", "emitSymbolAttribute", "(", "GVSym", ",", "MCSA_ELF_TypeObject", ")", ";", "OutStreamer", "->", "emitELFSize", "(", "GVSym", ",", "MCConstantExpr", "::", "create", "(", "Size", ",", "OutContext", ")", ")", ";", "}", "OutStreamer", "->", "emitLabel", "(", "GVSym", ")", ";", "emitGlobalConstant", "(", "DL", ",", "C", ",", "0", ")", ";", "if", "(", "Size", "<", "4", ")", "OutStreamer", "->", "emitZeros", "(", "4", "-", "Size", ")", ";", "getTargetStreamer", "(", ")", ".", "emitCCBottomData", "(", "GVSym", "->", "getName", "(", ")", ")", ";", "}", "</s>" ]

[ "Emit", "the", "specified", "global", "variable", "to", "the", ".s", "file", "." ]

[ "XCore", "XCore", "\"AppendingLinkage is not supported by this target!\"", "\"Unknown linkage type!\"", "4", "\"TLS is not supported by this target!\"", "0", "4", "4" ]

[]

[ "<s>", "MachineBasicBlock", "*", "MSP430TargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "MSP430", "::", "Shl8", "||", "Opc", "==", "MSP430", "::", "Shl16", "||", "Opc", "==", "MSP430", "::", "Sra8", "||", "Opc", "==", "MSP430", "::", "Sra16", "||", "Opc", "==", "MSP430", "::", "Srl8", "||", "Opc", "==", "MSP430", "::", "Srl16", ")", "return", "EmitShiftInstr", "(", "MI", ",", "BB", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "(", "Opc", "==", "MSP430", "::", "Select16", "||", "Opc", "==", "MSP430", "::", "Select8", ")", "&&", "\"Unexpected instr type to insert\"", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "I", "=", "BB", ";", "++", "I", ";", "MachineBasicBlock", "*", "thisMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "copy0MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "copy1MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "F", "->", "insert", "(", "I", ",", "copy0MBB", ")", ";", "F", "->", "insert", "(", "I", ",", "copy1MBB", ")", ";", "copy1MBB", "->", "splice", "(", "copy1MBB", "->", "begin", "(", ")", ",", "BB", ",", "llvm", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "BB", "->", "end", "(", ")", ")", ";", "copy1MBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "BB", ")", ";", "BB", "->", "addSuccessor", "(", "copy0MBB", ")", ";", "BB", "->", "addSuccessor", "(", "copy1MBB", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", ".", "get", "(", "MSP430", "::", "JCC", ")", ")", ".", "addMBB", "(", "copy1MBB", ")", ".", "addImm", "(", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ")", ";", "BB", "=", "copy0MBB", ";", "BB", "->", "addSuccessor", "(", "copy1MBB", ")", ";", "BB", "=", "copy1MBB", ";", "BuildMI", "(", "*", "BB", ",", "BB", "->", "begin", "(", ")", ",", "dl", ",", "TII", ".", "get", "(", "MSP430", "::", "PHI", ")", ",", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "copy0MBB", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "thisMBB", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "BB", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430::Shl8", "MSP430::Shl16", "MSP430::Sra8", "MSP430::Sra16", "MSP430::Srl8", "MSP430::Srl16", "MSP430::Select16", "MSP430::Select8", "\"Unexpected instr type to insert\"", "MSP430::JCC", "3", "MSP430::PHI", "0", "2", "1" ]

[]

[ "<s>", "static", "void", "riscv_conditional_register_usage", "(", "void", ")", "{", "if", "(", "!", "TARGET_HARD_FLOAT", ")", "{", "for", "(", "int", "regno", "=", "FP_REG_FIRST", ";", "regno", "<=", "FP_REG_LAST", ";", "regno", "++", ")", "fixed_regs", "[", "regno", "]", "=", "call_used_regs", "[", "regno", "]", "=", "1", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_CONDITIONAL_REGISTER_USAGE", "." ]

[ "riscv", "1" ]

[]

[ "<s>", "bool", "MipsPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createMipsModuleISelDagPass", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createMips16ISelDag", "(", "getMipsTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "addPass", "(", "createMipsSEISelDag", "(", "getMipsTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "M68kRegisterInfo", "::", "getMatchingMegaReg", "(", "unsigned", "Reg", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "for", "(", "MCSuperRegIterator", "Super", "(", "Reg", ",", "this", ")", ";", "Super", ".", "isValid", "(", ")", ";", "++", "Super", ")", "if", "(", "RC", "->", "contains", "(", "*", "Super", ")", ")", "return", "*", "Super", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "a", "mega-register", "of", "the", "specified", "register", "Reg", "so", "its", "sub-register", "of", "index", "SubIdx", "is", "Reg", ",", "its", "super", "(", "or", "mega", ")", "Reg", "." ]

[ "M68k", "M68k", "0" ]

[]

[ "<s>", "static", "bool", "frv_function_ok_for_sibcall", "(", "tree", "decl", "ATTRIBUTE_UNUSED", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "Any", "function", "call", "that", "satisfies", "the", "machine-independent", "requirements", "is", "eligible", "on", "FR-V", "." ]

[ "frv" ]

[]

[ "<s>", "static", "enum", "reg_class", "rs6000_secondary_reload_class", "(", "enum", "reg_class", "rclass", ",", "machine_mode", "mode", ",", "rtx", "in", ")", "{", "int", "regno", ";", "if", "(", "TARGET_ELF", "||", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "&&", "MACHOPIC_INDIRECT", ")", ")", "{", "if", "(", "rclass", "!=", "BASE_REGS", "&&", "(", "GET_CODE", "(", "in", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "in", ")", "==", "HIGH", "||", "GET_CODE", "(", "in", ")", "==", "LABEL_REF", "||", "GET_CODE", "(", "in", ")", "==", "CONST", ")", ")", "return", "BASE_REGS", ";", "}", "if", "(", "GET_CODE", "(", "in", ")", "==", "REG", ")", "{", "regno", "=", "REGNO", "(", "in", ")", ";", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "{", "regno", "=", "true_regnum", "(", "in", ")", ";", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "regno", "=", "-", "1", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "in", ")", "==", "SUBREG", ")", "{", "regno", "=", "true_regnum", "(", "in", ")", ";", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "regno", "=", "-", "1", ";", "}", "else", "regno", "=", "-", "1", ";", "if", "(", "TARGET_VSX", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<", "16", "&&", "(", "(", "(", "rclass", "==", "GENERAL_REGS", "||", "rclass", "==", "BASE_REGS", ")", "&&", "(", "regno", ">=", "0", "&&", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", ")", "||", "(", "(", "rclass", "==", "VSX_REGS", "||", "rclass", "==", "ALTIVEC_REGS", ")", "&&", "(", "regno", ">=", "0", "&&", "INT_REGNO_P", "(", "regno", ")", ")", ")", ")", ")", "return", "FLOAT_REGS", ";", "if", "(", "rclass", "==", "GENERAL_REGS", "||", "rclass", "==", "BASE_REGS", "||", "(", "regno", ">=", "0", "&&", "INT_REGNO_P", "(", "regno", ")", ")", ")", "return", "NO_REGS", ";", "if", "(", "rclass", "==", "VSX_REGS", "&&", "(", "regno", "==", "-", "1", "||", "VSX_REGNO_P", "(", "regno", ")", ")", ")", "return", "NO_REGS", ";", "if", "(", "(", "regno", "==", "-", "1", "||", "FP_REGNO_P", "(", "regno", ")", ")", "&&", "(", "rclass", "==", "FLOAT_REGS", "||", "rclass", "==", "NON_SPECIAL_REGS", ")", ")", "return", "(", "mode", "!=", "SDmode", "||", "lra_in_progress", ")", "?", "NO_REGS", ":", "GENERAL_REGS", ";", "if", "(", "(", "regno", "==", "-", "1", "||", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "&&", "rclass", "==", "ALTIVEC_REGS", ")", "return", "NO_REGS", ";", "if", "(", "(", "rclass", "==", "CR_REGS", "||", "rclass", "==", "CR0_REGS", ")", "&&", "regno", ">=", "0", "&&", "CR_REGNO_P", "(", "regno", ")", ")", "return", "NO_REGS", ";", "return", "GENERAL_REGS", ";", "}", "</s>" ]

[ "Return", "the", "register", "class", "of", "a", "scratch", "register", "needed", "to", "copy", "IN", "into", "or", "out", "of", "a", "register", "in", "RCLASS", "in", "MODE", ".", "If", "it", "can", "be", "done", "directly", ",", "NO_REGS", "is", "returned", "." ]

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

[]

[ "<s>", "void", "CSKYAsmPrinter", "::", "emitStartOfAsmFile", "(", "Module", "&", "M", ")", "{", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "isOSBinFormatELF", "(", ")", ")", "emitAttributes", "(", ")", ";", "}", "</s>" ]

[ "This", "virtual", "method", "can", "be", "overridden", "by", "targets", "that", "want", "to", "emit", "something", "at", "the", "start", "of", "their", "file", "." ]

[ "CSKY", "CSKY" ]

[]

[ "<s>", "int", "PPCTTIImpl", "::", "getIntImmCost", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "{", "if", "(", "DisablePPCConstHoist", ")", "return", "BaseT", "::", "getIntImmCost", "(", "Opcode", ",", "Idx", ",", "Imm", ",", "Ty", ")", ";", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "~", "0U", ";", "unsigned", "ImmIdx", "=", "~", "0U", ";", "bool", "ShiftedFree", "=", "false", ",", "RunFree", "=", "false", ",", "UnsignedFree", "=", "false", ",", "ZeroFree", "=", "false", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "GetElementPtr", ":", "if", "(", "Idx", "==", "0", ")", "return", "2", "*", "TTI", "::", "TCC_Basic", ";", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "And", ":", "RunFree", "=", "true", ";", "LLVM_FALLTHROUGH", ";", "case", "Instruction", "::", "Add", ":", "case", "Instruction", "::", "Or", ":", "case", "Instruction", "::", "Xor", ":", "ShiftedFree", "=", "true", ";", "LLVM_FALLTHROUGH", ";", "case", "Instruction", "::", "Sub", ":", "case", "Instruction", "::", "Mul", ":", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "ImmIdx", "=", "1", ";", "break", ";", "case", "Instruction", "::", "ICmp", ":", "UnsignedFree", "=", "true", ";", "ImmIdx", "=", "1", ";", "LLVM_FALLTHROUGH", ";", "case", "Instruction", "::", "Select", ":", "ZeroFree", "=", "true", ";", "break", ";", "case", "Instruction", "::", "PHI", ":", "case", "Instruction", "::", "Call", ":", "case", "Instruction", "::", "Ret", ":", "case", "Instruction", "::", "Load", ":", "case", "Instruction", "::", "Store", ":", "break", ";", "}", "if", "(", "ZeroFree", "&&", "Imm", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "Idx", "==", "ImmIdx", "&&", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", ")", "{", "if", "(", "isInt", "<", "16", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "RunFree", ")", "{", "if", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "32", "&&", "(", "isShiftedMask_32", "(", "Imm", ".", "getZExtValue", "(", ")", ")", "||", "isShiftedMask_32", "(", "~", "Imm", ".", "getZExtValue", "(", ")", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "ST", "->", "isPPC64", "(", ")", "&&", "(", "isShiftedMask_64", "(", "Imm", ".", "getZExtValue", "(", ")", ")", "||", "isShiftedMask_64", "(", "~", "Imm", ".", "getZExtValue", "(", ")", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "}", "if", "(", "UnsignedFree", "&&", "isUInt", "<", "16", ">", "(", "Imm", ".", "getZExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "ShiftedFree", "&&", "(", "Imm", ".", "getZExtValue", "(", ")", "&", "0xFFFF", ")", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "}", "return", "PPCTTIImpl", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "materializing", "a", "64-bit", "value", "." ]

[ "PowerPC", "PPC", "PPC", "0", "0U", "0U", "0", "2", "1", "1", "0", "64", "16", "32", "PPC", "16", "0xFFFF", "0", "PPC" ]

[]

[ "<s>", "bool", "PTXTargetMachine", "::", "addPostRegAlloc", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "register", "allocation", "pass", "pipeline", "but", "before", "prolog-epilog", "insertion", "." ]

[ "PTX", "PTX" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"AArch64 Stack Tagging\"", ";", "}", "</s>" ]

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

[ "AArch64", "\"AArch64 Stack Tagging\"" ]

[]

[ "<s>", "bool", "PPCSubtarget", "::", "enableMachineScheduler", "(", ")", "const", "{", "return", "needsAggressiveScheduling", "(", "DarwinDirective", ")", ";", "}", "</s>" ]

[ "Enable", "the", "MachineScheduler", "pass", "for", "all", "X86", "subtargets", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "static", "bool", "sh1_builtin_p", "(", "void", ")", "{", "return", "TARGET_SH1", ";", "}", "</s>" ]

[ "This", "function", "can", "be", "used", "if", "there", "are", "any", "built-ins", "that", "are", "not", "for", "SHmedia", ".", "It", "'s", "commented", "out", "to", "avoid", "the", "defined-but-unused", "warning", "." ]

[ "sh" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "ARMTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'l'", ":", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "tGPRRegisterClass", ")", ";", "else", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "GPRRegisterClass", ")", ";", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "GPRRegisterClass", ")", ";", "case", "'w'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "SPRRegisterClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "DPRRegisterClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "QPRRegisterClass", ")", ";", "break", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "ARM", "ARM", "1", "0", "0U", "ARM::tGPRRegisterClass", "0U", "ARM::GPRRegisterClass", "0U", "ARM::GPRRegisterClass", "MVT::f32", "0U", "ARM::SPRRegisterClass", "64", "0U", "ARM::DPRRegisterClass", "128", "0U", "ARM::QPRRegisterClass" ]

[]

[ "<s>", "void", "RISCVTargetLowering", "::", "AdjustInstrPostInstrSelection", "(", "MachineInstr", "&", "MI", ",", "SDNode", "*", "Node", ")", "const", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "auto", "Idx", "=", "RISCV", "::", "getNamedOperandIdx", "(", "Opc", ",", "RISCV", "::", "OpName", "::", "frm", ")", ";", "if", "(", "Idx", "<", "0", ")", "return", ";", "if", "(", "MI", ".", "getOperand", "(", "Idx", ")", ".", "getImm", "(", ")", "!=", "RISCVFPRndMode", "::", "DYN", ")", "return", ";", "if", "(", "MI", ".", "readsRegister", "(", "RISCV", "::", "FRM", ")", ")", "return", ";", "MI", ".", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "RISCV", "::", "FRM", ",", "false", ",", "true", ")", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::getNamedOperandIdx", "RISCV::OpName", "0", "RISCVFPRndMode::DYN", "RISCV::FRM", "RISCV::FRM" ]

[]

[ "<s>", "void", "MipsTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "TM", ".", "Options", ".", "UseInitArray", ")", ";", "SmallDataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "SmallBSSSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sbss\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getBSS", "(", ")", ")", ";", "const", "MipsSubtarget", "&", "Subtarget", "=", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "if", "(", "Subtarget", ".", "isTargetNaCl", "(", ")", ")", "{", "StaticCtorSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".init_array\"", ",", "ELF", "::", "SHT_INIT_ARRAY", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "StaticDtorSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".fini_array\"", ",", "ELF", "::", "SHT_FINI_ARRAY", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "\".sdata\"", "\".sbss\"", "Mips", "Mips", "\".init_array\"", "\".fini_array\"" ]

[]

[ "<s>", "bool", "mep_store_data_bypass_p", "(", "rtx_insn", "*", "prev", ",", "rtx_insn", "*", "insn", ")", "{", "return", "INSN_P", "(", "insn", ")", "?", "mep_store_data_bypass_1", "(", "prev", ",", "PATTERN", "(", "insn", ")", ")", ":", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "INSN", "is", "a", "store", "instruction", "and", "if", "the", "store", "address", "has", "no", "true", "dependence", "on", "PREV", "." ]

[ "mep" ]

[]

[ "<s>", "unsigned", "HexagonRegisterInfo", "::", "getFrameRegister", "(", ")", "const", "{", "return", "Hexagon", "::", "R30", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "Hexagon", "Hexagon", "Hexagon::R30" ]

[]

[ "<s>", "static", "void", "rs6000_darwin64_record_arg_flush", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "HOST_WIDE_INT", "bitpos", ",", "rtx", "rvec", "[", "]", ",", "int", "*", "k", ")", "{", "enum", "machine_mode", "mode", ";", "unsigned", "int", "regno", ";", "unsigned", "int", "startbit", ",", "endbit", ";", "int", "this_regno", ",", "intregs", ",", "intoffset", ";", "rtx", "reg", ";", "if", "(", "cum", "->", "intoffset", "==", "-", "1", ")", "return", ";", "intoffset", "=", "cum", "->", "intoffset", ";", "cum", "->", "intoffset", "=", "-", "1", ";", "if", "(", "intoffset", "%", "BITS_PER_WORD", "!=", "0", ")", "{", "mode", "=", "mode_for_size", "(", "BITS_PER_WORD", "-", "intoffset", "%", "BITS_PER_WORD", ",", "MODE_INT", ",", "0", ")", ";", "if", "(", "mode", "==", "BLKmode", ")", "{", "intoffset", "=", "intoffset", "&", "-", "BITS_PER_WORD", ";", "mode", "=", "word_mode", ";", "}", "}", "else", "mode", "=", "word_mode", ";", "startbit", "=", "intoffset", "&", "-", "BITS_PER_WORD", ";", "endbit", "=", "(", "bitpos", "+", "BITS_PER_WORD", "-", "1", ")", "&", "-", "BITS_PER_WORD", ";", "intregs", "=", "(", "endbit", "-", "startbit", ")", "/", "BITS_PER_WORD", ";", "this_regno", "=", "cum", "->", "words", "+", "intoffset", "/", "BITS_PER_WORD", ";", "if", "(", "intregs", ">", "0", "&&", "intregs", ">", "GP_ARG_NUM_REG", "-", "this_regno", ")", "cum", "->", "use_stack", "=", "1", ";", "intregs", "=", "MIN", "(", "intregs", ",", "GP_ARG_NUM_REG", "-", "this_regno", ")", ";", "if", "(", "intregs", "<=", "0", ")", "return", ";", "intoffset", "/=", "BITS_PER_UNIT", ";", "do", "{", "regno", "=", "GP_ARG_MIN_REG", "+", "this_regno", ";", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "rvec", "[", "(", "*", "k", ")", "++", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg", ",", "GEN_INT", "(", "intoffset", ")", ")", ";", "this_regno", "+=", "1", ";", "intoffset", "=", "(", "intoffset", "|", "(", "UNITS_PER_WORD", "-", "1", ")", ")", "+", "1", ";", "mode", "=", "word_mode", ";", "intregs", "-=", "1", ";", "}", "while", "(", "intregs", ">", "0", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "rs6000_darwin64_record_arg", ".", "Assign", "the", "bits", "of", "the", "structure", "between", "cum-", ">", "intoffset", "and", "bitpos", "to", "integer", "registers", "." ]

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

[]

[ "<s>", "bool", "HexagonSplitDoubleRegs", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Splitting double registers in function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "auto", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "UUSetMap", "P2Rs", ";", "LoopRegMap", "IRM", ";", "collectIndRegs", "(", "IRM", ")", ";", "partitionRegisters", "(", "P2Rs", ")", ";", "DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"Register partitioning: (partition #0 is fixed)\\n\"", ";", "for", "(", "UUSetMap", "::", "iterator", "I", "=", "P2Rs", ".", "begin", "(", ")", ",", "E", "=", "P2Rs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "dbgs", "(", ")", "<<", "'#'", "<<", "I", "->", "first", "<<", "\" -> \"", ";", "dump_partition", "(", "dbgs", "(", ")", ",", "I", "->", "second", ",", "*", "TRI", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ";", "}", "}", ")", ";", "bool", "Changed", "=", "false", ";", "int", "Limit", "=", "MaxHSDR", ";", "for", "(", "UUSetMap", "::", "iterator", "I", "=", "P2Rs", ".", "begin", "(", ")", ",", "E", "=", "P2Rs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "first", "==", "0", ")", "continue", ";", "if", "(", "Limit", ">=", "0", "&&", "Counter", ">=", "Limit", ")", "break", ";", "USet", "&", "Part", "=", "I", "->", "second", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Calculating profit for partition #\"", "<<", "I", "->", "first", "<<", "'\\n'", ")", ";", "if", "(", "!", "isProfitable", "(", "Part", ",", "IRM", ")", ")", "continue", ";", "Counter", "++", ";", "Changed", "|=", "splitPartition", "(", "Part", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "\"Splitting double registers in function: \"", "Hexagon", "\"Register partitioning: (partition #0 is fixed)\\n\"", "\" -> \"", "0", "0", "\"Calculating profit for partition #\"" ]

[]

[ "<s>", "void", "KudeyarInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "markup", "(", "\"<reg:\"", ")", "<<", "getRegisterName", "(", "RegNo", ")", "<<", "markup", "(", "\">\"", ")", ";", "}", "</s>" ]

[ "Print", "the", "assembler", "register", "name", "." ]

[ "Kudeyar", "Kudeyar", "\"<reg:\"", "\">\"" ]

[]

[ "<s>", "static", "void", "expand_epilogue_reg_restore", "(", "rtx", "spreg", ",", "bool", "saveall", ",", "bool", "is_inthandler", ")", "{", "int", "ndregs", "=", "saveall", "?", "8", ":", "n_dregs_to_save", "(", "is_inthandler", ")", ";", "int", "npregs", "=", "saveall", "?", "6", ":", "n_pregs_to_save", "(", "is_inthandler", ")", ";", "int", "total", "=", "ndregs", "+", "npregs", ";", "int", "i", ",", "regno", ";", "rtx", "pat", ",", "insn", ";", "if", "(", "total", "==", "0", ")", "return", ";", "pat", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "total", "+", "1", ")", ")", ";", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "spreg", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "spreg", ",", "GEN_INT", "(", "total", "*", "4", ")", ")", ")", ";", "if", "(", "npregs", ">", "0", ")", "regno", "=", "REG_P5", "+", "1", ";", "else", "regno", "=", "REG_R7", "+", "1", ";", "for", "(", "i", "=", "0", ";", "i", "<", "total", ";", "i", "++", ")", "{", "rtx", "addr", "=", "(", "i", ">", "0", "?", "gen_rtx_PLUS", "(", "Pmode", ",", "spreg", ",", "GEN_INT", "(", "i", "*", "4", ")", ")", ":", "spreg", ")", ";", "rtx", "memref", "=", "gen_rtx_MEM", "(", "word_mode", ",", "addr", ")", ";", "regno", "--", ";", "XVECEXP", "(", "pat", ",", "0", ",", "i", "+", "1", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "word_mode", ",", "regno", ")", ",", "memref", ")", ";", "if", "(", "npregs", ">", "0", ")", "{", "if", "(", "--", "npregs", "==", "0", ")", "regno", "=", "REG_R7", "+", "1", ";", "}", "}", "insn", "=", "emit_insn", "(", "pat", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "</s>" ]

[ "Emit", "code", "to", "restore", "registers", "in", "the", "epilogue", ".", "SAVEALL", "is", "nonzero", "if", "we", "must", "save", "all", "registers", ";", "this", "is", "used", "for", "interrupt", "handlers", ".", "SPREG", "contains", "(", "reg", ":", "SI", "REG_SP", ")", ".", "IS_INTHANDLER", "is", "true", "if", "we", "'re", "doing", "this", "for", "an", "interrupt", "(", "or", "exception", ")", "handler", "." ]

[ "bfin", "8", "6", "0", "1", "0", "0", "4", "0", "1", "1", "0", "0", "4", "0", "1", "0", "0", "1", "1" ]

[]

[ "<s>", "static", "unsigned", "getFramePointerSaveOffset", "(", "bool", "isPPC64", ",", "bool", "isDarwinABI", ")", "{", "if", "(", "isDarwinABI", ")", "return", "isPPC64", "?", "40", ":", "20", ";", "return", "-", "4U", ";", "}", "</s>" ]

[ "getFramePointerSaveOffset", "-", "Return", "the", "previous", "frame", "offset", "to", "save", "the", "frame", "pointer", "." ]

[ "PowerPC", "PPC", "PPC", "40", "20", "4U" ]

[]

[ "<s>", "bool", "OptimizePICCall", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "if", "(", "static_cast", "<", "const", "MipsSubtarget", "&", ">", "(", "F", ".", "getSubtarget", "(", ")", ")", ".", "inMips16Mode", "(", ")", ")", "return", "false", ";", "MachineDominatorTree", "*", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "bool", "Changed", "=", "false", ";", "SmallVector", "<", "MBBInfo", ",", "8", ">", "WorkList", "(", "1", ",", "MBBInfo", "(", "MDT", "->", "getRootNode", "(", ")", ")", ")", ";", "while", "(", "!", "WorkList", ".", "empty", "(", ")", ")", "{", "MBBInfo", "&", "MBBI", "=", "WorkList", ".", "back", "(", ")", ";", "if", "(", "MBBI", ".", "isVisited", "(", ")", ")", "{", "MBBI", ".", "postVisit", "(", ")", ";", "WorkList", ".", "pop_back", "(", ")", ";", "continue", ";", "}", "MBBI", ".", "preVisit", "(", "ScopedHT", ")", ";", "Changed", "|=", "visitNode", "(", "MBBI", ")", ";", "const", "MachineDomTreeNode", "*", "Node", "=", "MBBI", ".", "getNode", "(", ")", ";", "const", "std", "::", "vector", "<", "MachineDomTreeNode", "*", ">", "&", "Children", "=", "Node", "->", "getChildren", "(", ")", ";", "WorkList", ".", "append", "(", "Children", ".", "begin", "(", ")", ",", "Children", ".", "end", "(", ")", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "8", "1" ]

[]

[ "<s>", "static", "void", "spu_setup_incoming_varargs", "(", "cumulative_args_t", "cum", ",", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", ")", "{", "if", "(", "!", "no_rtl", ")", "{", "rtx", "tmp", ";", "int", "regno", ";", "int", "offset", ";", "int", "ncum", "=", "*", "get_cumulative_args", "(", "cum", ")", ";", "spu_function_arg_advance", "(", "pack_cumulative_args", "(", "&", "ncum", ")", ",", "mode", ",", "type", ",", "true", ")", ";", "offset", "=", "-", "STACK_POINTER_OFFSET", ";", "for", "(", "regno", "=", "ncum", ";", "regno", "<", "MAX_REGISTER_ARGS", ";", "regno", "++", ")", "{", "tmp", "=", "gen_frame_mem", "(", "V4SImode", ",", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "offset", ")", ")", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_REG", "(", "V4SImode", ",", "FIRST_ARG_REGNUM", "+", "regno", ")", ")", ";", "offset", "+=", "16", ";", "}", "*", "pretend_size", "=", "offset", "+", "STACK_POINTER_OFFSET", ";", "}", "}", "</s>" ]

[ "Save", "parameter", "registers", "starting", "with", "the", "register", "that", "corresponds", "to", "the", "first", "unnamed", "parameters", ".", "If", "the", "first", "unnamed", "parameter", "is", "in", "the", "stack", "then", "save", "no", "registers", ".", "Set", "pretend_args_size", "to", "the", "amount", "of", "space", "needed", "to", "save", "the", "registers", "." ]

[ "spu", "16" ]

[]

[ "<s>", "static", "void", "write_autogenerated_header", "(", "FILE", "*", "file", ")", "{", "fprintf", "(", "file", ",", "\"/* Automatically generated by the program '%s'\\n\"", ",", "pgm_path", ")", ";", "fprintf", "(", "file", ",", "\" from the files '%s' and '%s'. */\\n\\n\"", ",", "bif_path", ",", "ovld_path", ")", ";", "}", "</s>" ]

[ "Write", "a", "comment", "at", "the", "top", "of", "FILE", "about", "how", "the", "code", "was", "generated", "." ]

[ "rs6000", "\"/* Automatically generated by the program '%s'\\n\"", "\" from the files '%s' and '%s'. */\\n\\n\"" ]

[]

[ "<s>", "void", "MipsTargetLowering", "::", "getOpndList", "(", "SmallVectorImpl", "<", "SDValue", ">", "&", "Ops", ",", "std", "::", "deque", "<", "std", "::", "pair", "<", "unsigned", ",", "SDValue", ">", ">", "&", "RegsToPass", ",", "bool", "IsPICCall", ",", "bool", "GlobalOrExternal", ",", "bool", "InternalLinkage", ",", "CallLoweringInfo", "&", "CLI", ",", "SDValue", "Callee", ",", "SDValue", "Chain", ")", "const", "{", "if", "(", "IsPICCall", "&&", "!", "InternalLinkage", ")", "{", "unsigned", "GPReg", "=", "IsN64", "?", "Mips", "::", "GP_64", ":", "Mips", "::", "GP", ";", "EVT", "Ty", "=", "IsN64", "?", "MVT", "::", "i64", ":", "MVT", "::", "i32", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "GPReg", ",", "getGlobalReg", "(", "CLI", ".", "DAG", ",", "Ty", ")", ")", ")", ";", "}", "SDValue", "InFlag", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "Chain", "=", "CLI", ".", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "CLI", ".", "DL", ",", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ",", "InFlag", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "Ops", ".", "push_back", "(", "CLI", ".", "DAG", ".", "getRegister", "(", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ".", "getValueType", "(", ")", ")", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "getTargetMachine", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "uint32_t", "*", "Mask", "=", "TRI", "->", "getCallPreservedMask", "(", "CLI", ".", "CallConv", ")", ";", "assert", "(", "Mask", "&&", "\"Missing call preserved mask for calling convention\"", ")", ";", "Ops", ".", "push_back", "(", "CLI", ".", "DAG", ".", "getRegisterMask", "(", "Mask", ")", ")", ";", "if", "(", "InFlag", ".", "getNode", "(", ")", ")", "Ops", ".", "push_back", "(", "InFlag", ")", ";", "}", "</s>" ]

[ "This", "function", "fills", "Ops", ",", "which", "is", "the", "list", "of", "operands", "that", "will", "later", "be", "used", "when", "a", "function", "call", "node", "is", "created", "." ]

[ "Mips", "Mips", "Mips::GP_64", "Mips::GP", "MVT::i64", "MVT::i32", "0", "1", "0", "\"Missing call preserved mask for calling convention\"" ]

[]

[ "<s>", "static", "unsigned", "int", "xtensa_multibss_section_type_flags", "(", "tree", "decl", ",", "const", "char", "*", "name", ",", "int", "reloc", ")", "{", "unsigned", "int", "flags", "=", "default_section_type_flags", "(", "decl", ",", "name", ",", "reloc", ")", ";", "const", "char", "*", "suffix", ";", "suffix", "=", "strrchr", "(", "name", ",", "'.'", ")", ";", "if", "(", "suffix", "&&", "strcmp", "(", "suffix", ",", "\".bss\"", ")", "==", "0", ")", "{", "if", "(", "!", "decl", "||", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "DECL_INITIAL", "(", "decl", ")", "==", "NULL_TREE", ")", ")", "flags", "|=", "SECTION_BSS", ";", "else", "warning", "(", "0", ",", "\"only uninitialized variables can be placed in a \"", "\"%<.bss%> section\"", ")", ";", "}", "return", "flags", ";", "}", "</s>" ]

[ "Some", "Xtensa", "targets", "support", "multiple", "bss", "sections", ".", "If", "the", "section", "name", "ends", "with", "``", ".bss", "''", ",", "add", "SECTION_BSS", "to", "the", "flags", "." ]

[ "xtensa", "\".bss\"", "0", "0", "\"only uninitialized variables can be placed in a \"", "\"%<.bss%> section\"" ]

[]

[ "<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", "::", "X86_RegCall", ":", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "{", "return", "(", "HasSSE", "?", "CSR_Win64_RegCall_RegMask", ":", "CSR_Win64_RegCall_NoSSE_RegMask", ")", ";", "}", "else", "{", "return", "(", "HasSSE", "?", "CSR_SysV64_RegCall_RegMask", ":", "CSR_SysV64_RegCall_NoSSE_RegMask", ")", ";", "}", "}", "else", "{", "return", "(", "HasSSE", "?", "CSR_32_RegCall_RegMask", ":", "CSR_32_RegCall_NoSSE_RegMask", ")", ";", "}", "case", "CallingConv", "::", "Cold", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_MostRegs_RegMask", ";", "break", ";", "case", "CallingConv", "::", "Win64", ":", "return", "CSR_Win64_RegMask", ";", "case", "CallingConv", "::", "X86_64_SysV", ":", "return", "CSR_64_RegMask", ";", "case", "CallingConv", "::", "X86_INTR", ":", "if", "(", "Is64Bit", ")", "{", "if", "(", "HasAVX512", ")", "return", "CSR_64_AllRegs_AVX512_RegMask", ";", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_RegMask", ";", "if", "(", "HasSSE", ")", "return", "CSR_64_AllRegs_RegMask", ";", "return", "CSR_64_AllRegs_NoSSE_RegMask", ";", "}", "else", "{", "if", "(", "HasAVX512", ")", "return", "CSR_32_AllRegs_AVX512_RegMask", ";", "if", "(", "HasAVX", ")", "return", "CSR_32_AllRegs_AVX_RegMask", ";", "if", "(", "HasSSE", ")", "return", "CSR_32_AllRegs_SSE_RegMask", ";", "return", "CSR_32_AllRegs_RegMask", ";", "}", "default", ":", "break", ";", "}", "if", "(", "Is64Bit", ")", "{", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "IsSwiftCC", "=", "Subtarget", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "F", "->", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ";", "if", "(", "IsSwiftCC", ")", "return", "IsWin64", "?", "CSR_Win64_SwiftError_RegMask", ":", "CSR_64_SwiftError_RegMask", ";", "return", "IsWin64", "?", "CSR_Win64_RegMask", ":", "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>", "bool", "SparcAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "SmallVector", "<", "MCInst", ",", "8", ">", "Instructions", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "{", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Instructions", ".", "push_back", "(", "Inst", ")", ";", "break", ";", "case", "SP", "::", "SET", ":", "if", "(", "expandSET", "(", "Inst", ",", "IDLoc", ",", "Instructions", ")", ")", "return", "true", ";", "break", ";", "}", "for", "(", "const", "MCInst", "&", "I", ":", "Instructions", ")", "{", "Out", ".", "EmitInstruction", "(", "I", ",", "getSTI", "(", ")", ")", ";", "}", "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction requires a CPU feature not currently enabled\"", ")", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "SparcOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction mnemonic\"", ")", ";", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "Sparc", "Sparc", "8", "SP::SET", "\"instruction requires a CPU feature not currently enabled\"", "0ULL", "\"too few operands for instruction\"", "Sparc", "\"invalid operand for instruction\"", "\"invalid instruction mnemonic\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "static", "bool", "rs6000_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_PAIRED_FLOAT", "&&", "PAIRED_VECTOR_MODE", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "TARGET_SPE", "&&", "SPE_VECTOR_MODE", "(", "mode", ")", ")", "return", "true", ";", "else", "if", "(", "VECTOR_MEM_ALTIVEC_OR_VSX_P", "(", "mode", ")", "&&", "!", "FLOAT128_IEEE_P", "(", "mode", ")", ")", "return", "true", ";", "else", "return", "false", ";", "}", "</s>" ]

[ "Target", "hook", "for", "vector_mode_supported_p", "." ]

[ "powerpcspe" ]

[]