Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "PPCHazardRecognizer970", "::", "EmitInstruction", "(", "SUnit", "*", "SU", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "MI", "->", "isDebugInstr", "(", ")", ")", "return", ";", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "bool", "isFirst", ",", "isSingle", ",", "isCracked", ",", "isLoad", ",", "isStore", ";", "PPCII", "::", "PPC970_Unit", "InstrType", "=", "GetInstrType", "(", "Opcode", ",", "isFirst", ",", "isSingle", ",", "isCracked", ",", "isLoad", ",", "isStore", ")", ";", "if", "(", "InstrType", "==", "PPCII", "::", "PPC970_Pseudo", ")", "return", ";", "if", "(", "Opcode", "==", "PPC", "::", "MTCTR", "||", "Opcode", "==", "PPC", "::", "MTCTR8", ")", "HasCTRSet", "=", "true", ";", "if", "(", "isStore", "&&", "NumStores", "<", "4", "&&", "!", "MI", "->", "memoperands_empty", "(", ")", ")", "{", "MachineMemOperand", "*", "MO", "=", "*", "MI", "->", "memoperands_begin", "(", ")", ";", "StoreSize", "[", "NumStores", "]", "=", "MO", "->", "getSize", "(", ")", ";", "StoreOffset", "[", "NumStores", "]", "=", "MO", "->", "getOffset", "(", ")", ";", "StoreValue", "[", "NumStores", "]", "=", "MO", "->", "getValue", "(", ")", ";", "++", "NumStores", ";", "}", "if", "(", "InstrType", "==", "PPCII", "::", "PPC970_BRU", "||", "isSingle", ")", "NumIssued", "=", "4", ";", "++", "NumIssued", ";", "if", "(", "isCracked", ")", "++", "NumIssued", ";", "if", "(", "NumIssued", "==", "5", ")", "EndDispatchGroup", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPCII::PPC970_Unit", "PPCII::PPC970_Pseudo", "PPC::MTCTR", "PPC::MTCTR8", "4", "PPCII::PPC970_BRU", "4", "5" ]

[]

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

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

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

[]

[ "<s>", "unsigned", "PPCMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "assert", "(", "(", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "MTCRF", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "MFOCRF", ")", "||", "MO", ".", "getReg", "(", ")", "<", "PPC", "::", "CR0", "||", "MO", ".", "getReg", "(", ")", ">", "PPC", "::", "CR7", ")", ";", "return", "getPPCRegisterNumbering", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "assert", "(", "MO", ".", "isImm", "(", ")", "&&", "\"Relocation required in an instruction that we cannot encode!\"", ")", ";", "return", "MO", ".", "getImm", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::MTCRF", "PPC::MFOCRF", "PPC::CR0", "PPC::CR7", "PPC", "\"Relocation required in an instruction that we cannot encode!\"" ]

[]

[ "<s>", "static", "bool", "aarch64_register_saved_on_entry", "(", "int", "regno", ")", "{", "return", "known_ge", "(", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno", "]", ",", "0", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "register", "REGNO", "is", "saved", "on", "entry", "to", "the", "current", "function", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "int", "mips_class_max_nregs", "(", "enum", "reg_class", "class", "ATTRIBUTE_UNUSED", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "class", "==", "ST_REGS", ")", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "3", ")", "/", "4", ";", "else", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Implement", "CLASS_MAX_NREGS", ".", "Usually", "all", "registers", "are", "word-sized", ".", "The", "only", "supported", "exception", "is", "-mgp64", "-msingle-float", ",", "which", "has", "64-bit", "words", "but", "32-bit", "float", "registers", ".", "A", "word-based", "calculation", "is", "correct", "even", "in", "that", "case", ",", "since", "-msingle-float", "disallows", "multi-FPR", "values", ".", "The", "FP", "status", "registers", "are", "an", "exception", "to", "this", "rule", ".", "They", "are", "always", "4", "bytes", "wide", "as", "they", "only", "hold", "condition", "code", "modes", ",", "and", "CCmode", "is", "always", "considered", "to", "be", "4", "bytes", "wide", "." ]

[ "mips", "3", "4", "1" ]

[]

[ "<s>", "unsigned", "SparcRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "int", "*", "Value", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", "+", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "Offset", ">=", "-", "4096", "&&", "Offset", "<=", "4095", ")", "{", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "SP", "::", "I6", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "else", "{", "unsigned", "OffHi", "=", "(", "unsigned", ")", "Offset", ">>", "10U", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "SETHIi", ")", ",", "SP", "::", "G1", ")", ".", "addImm", "(", "OffHi", ")", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "ADDrr", ")", ",", "SP", "::", "G1", ")", ".", "addReg", "(", "SP", "::", "G1", ")", ".", "addReg", "(", "SP", "::", "I6", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "SP", "::", "G1", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", "&", "(", "(", "1", "<<", "10", ")", "-", "1", ")", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SP", "SP", "0", "\"Unexpected\"", "0", "\"Instr doesn't have FrameIndex operand!\"", "1", "4096", "4095", "SP::I6", "1", "10U", "SP::SETHIi", "SP::G1", "SP::ADDrr", "SP::G1", "SP::G1", "SP::I6", "SP::G1", "1", "1", "10", "1", "0" ]

[]

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

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

[ "SPIRV", "\"SPIRV Assembly Printer\"" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "{", "assert", "(", "Kind", "==", "Register", "&&", "\"Invalid access!\"", ")", ";", "return", "Reg", ".", "RegNum", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "Hexagon", "\"Invalid access!\"" ]

[]

[ "<s>", "PPC", "::", "Predicate", "PPC", "::", "getSwappedPredicate", "(", "PPC", "::", "Predicate", "Opcode", ")", "{", "switch", "(", "Opcode", ")", "{", "case", "PPC", "::", "PRED_EQ", ":", "return", "PPC", "::", "PRED_EQ", ";", "case", "PPC", "::", "PRED_NE", ":", "return", "PPC", "::", "PRED_NE", ";", "case", "PPC", "::", "PRED_LT", ":", "return", "PPC", "::", "PRED_GT", ";", "case", "PPC", "::", "PRED_GE", ":", "return", "PPC", "::", "PRED_LE", ";", "case", "PPC", "::", "PRED_GT", ":", "return", "PPC", "::", "PRED_LT", ";", "case", "PPC", "::", "PRED_LE", ":", "return", "PPC", "::", "PRED_GE", ";", "case", "PPC", "::", "PRED_NU", ":", "return", "PPC", "::", "PRED_NU", ";", "case", "PPC", "::", "PRED_UN", ":", "return", "PPC", "::", "PRED_UN", ";", "}", "llvm_unreachable", "(", "\"Unknown PPC branch opcode!\"", ")", ";", "}", "</s>" ]

[ "This", "is", "a", "static", "version", "that", "you", "can", "use", "without", "an", "instruction", "available", "." ]

[ "PowerPC", "PPC::Predicate", "PPC::getSwappedPredicate", "PPC::Predicate", "PPC::PRED_EQ", "PPC::PRED_EQ", "PPC::PRED_NE", "PPC::PRED_NE", "PPC::PRED_LT", "PPC::PRED_GT", "PPC::PRED_GE", "PPC::PRED_LE", "PPC::PRED_GT", "PPC::PRED_LT", "PPC::PRED_LE", "PPC::PRED_GE", "PPC::PRED_NU", "PPC::PRED_NU", "PPC::PRED_UN", "PPC::PRED_UN", "\"Unknown PPC branch opcode!\"" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "bool", "Changed", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ";", "I", "!=", "MF", ".", "end", "(", ")", ";", ")", "{", "MachineBasicBlock", "&", "B", "=", "*", "I", "++", ";", "if", "(", "processBlock", "(", "B", ")", ")", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "PowerPC" ]

[]

[ "<s>", "virtual", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "PatmosSinglePathInfo", "&", "PSPI", "=", "getAnalysis", "<", "PatmosSinglePathInfo", ">", "(", ")", ";", "bool", "changed", "=", "false", ";", "if", "(", "PSPI", ".", "isConverting", "(", "MF", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"[Single-Path] Preparing \"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "doPrepareFunction", "(", "MF", ")", ";", "changed", "|=", "true", ";", "}", "return", "changed", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "Patmos", "\"[Single-Path] Preparing \"", "\"\\n\"" ]

[]

[ "<s>", "bool", "mips_split_move_insn_p", "(", "rtx", "dest", ",", "rtx", "src", ",", "rtx", "insn", ")", "{", "return", "mips_split_move_p", "(", "dest", ",", "src", ",", "mips_insn_split_type", "(", "insn", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "move", "from", "SRC", "to", "DEST", "in", "INSN", "should", "be", "split", "." ]

[ "mips" ]

[]

[ "<s>", "void", "R600SchedStrategy", "::", "releaseBottomNode", "(", "SUnit", "*", "SU", ")", "{", "}", "</s>" ]

[ "Currently", "only", "scheduling", "top-down", ",", "so", "this", "method", "is", "empty", "." ]

[ "R600" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "getRecipEstimate", "(", "SDValue", "Operand", ",", "SelectionDAG", "&", "DAG", ",", "int", "Enabled", ",", "int", "&", "RefinementSteps", ")", "const", "{", "EVT", "VT", "=", "Operand", ".", "getValueType", "(", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "f32", "&&", "Subtarget", ".", "hasFRES", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "f64", "&&", "Subtarget", ".", "hasFRE", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v4f32", "&&", "Subtarget", ".", "hasAltivec", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v2f64", "&&", "Subtarget", ".", "hasVSX", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v4f32", "&&", "Subtarget", ".", "hasQPX", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v4f64", "&&", "Subtarget", ".", "hasQPX", "(", ")", ")", ")", "{", "if", "(", "RefinementSteps", "==", "ReciprocalEstimate", "::", "Unspecified", ")", "RefinementSteps", "=", "getEstimateRefinementSteps", "(", "VT", ",", "Subtarget", ")", ";", "return", "DAG", ".", "getNode", "(", "PPCISD", "::", "FRE", ",", "SDLoc", "(", "Operand", ")", ",", "VT", ",", "Operand", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Return", "a", "reciprocal", "estimate", "value", "for", "the", "input", "operand", "." ]

[ "PowerPC", "PPC", "MVT::f32", "MVT::f64", "MVT::v4f32", "MVT::v2f64", "MVT::v4f32", "MVT::v4f64", "PPCISD::FRE" ]

[]

[ "<s>", "bool", "isProfitableToUnpredicate", "(", "MachineBasicBlock", "&", "TMBB", ",", "MachineBasicBlock", "&", "FMBB", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "profitable", "to", "unpredicate", "one", "side", "of", "a", "'diamond", "'", ",", "i.e", "." ]

[ "PowerPC" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "void", "rs6000_function_specific_restore", "(", "struct", "gcc_options", "*", "opts", ",", "struct", "gcc_options", "*", ",", "struct", "cl_target_option", "*", "ptr", ")", "{", "opts", "->", "x_rs6000_isa_flags", "=", "ptr", "->", "x_rs6000_isa_flags", ";", "opts", "->", "x_rs6000_isa_flags_explicit", "=", "ptr", "->", "x_rs6000_isa_flags_explicit", ";", "(", "void", ")", "rs6000_option_override_internal", "(", "false", ")", ";", "}", "</s>" ]

[ "Restore", "the", "current", "options" ]

[ "rs6000" ]

[]

[ "<s>", "bool", "enableMachineScheduler", "(", ")", "const", "override", "{", "return", "getGeneration", "(", ")", "<=", "NORTHERN_ISLANDS", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "static", "void", "process_args", "(", "int", "argc", ",", "char", "*", "*", "argv", ")", "{", "int", "i", ";", "for", "(", "i", "=", "1", ";", "i", "<", "argc", ";", "i", "++", ")", "{", "if", "(", "strncmp", "(", "argv", "[", "i", "]", ",", "\"-L\"", ",", "2", ")", "==", "0", ")", "{", "search_dirs", "=", "XRESIZEVEC", "(", "const", "char", "*", ",", "search_dirs", ",", "search_dirs_len", "+", "1", ")", ";", "search_dirs", "[", "search_dirs_len", "++", "]", "=", "&", "argv", "[", "i", "]", "[", "2", "]", ";", "}", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-v\"", ")", "==", "0", ")", "verbose", "++", ";", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"--version\"", ")", "==", "0", ")", "{", "fprintf", "(", "stdout", ",", "\"VMS Linker\\n\"", ")", ";", "exit", "(", "EXIT_SUCCESS", ")", ";", "}", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"--help\"", ")", "==", "0", ")", "{", "fprintf", "(", "stdout", ",", "\"VMS Linker\\n\"", ")", ";", "exit", "(", "EXIT_SUCCESS", ")", ";", "}", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-g0\"", ")", "==", "0", ")", "addarg", "(", "\"/notraceback\"", ")", ";", "else", "if", "(", "strncmp", "(", "argv", "[", "i", "]", ",", "\"-g\"", ",", "2", ")", "==", "0", ")", "{", "addarg", "(", "\"/debug\"", ")", ";", "debug", "=", "1", ";", "}", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-static\"", ")", "==", "0", ")", "staticp", "=", "1", ";", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-map\"", ")", "==", "0", ")", "{", "char", "*", "buff", ",", "*", "ptr", ";", "buff", "=", "(", "char", "*", ")", "xstrdup", "(", "exefullfilename", ")", ";", "ptr", "=", "strrchr", "(", "buff", ",", "'.'", ")", ";", "if", "(", "ptr", ")", "*", "ptr", "=", "0", ";", "strcat", "(", "buff", ",", "\".map\"", ")", ";", "addarg", "(", "\"/map=\"", ")", ";", "addarg", "(", "buff", ")", ";", "addarg", "(", "\".map\"", ")", ";", "addarg", "(", "\"/full\"", ")", ";", "free", "(", "buff", ")", ";", "}", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-save-temps\"", ")", "==", "0", ")", "save_temps", "=", "1", ";", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"--noinhibit-exec\"", ")", "==", "0", ")", "inhibit_exec", "=", "0", ";", "}", "}", "</s>" ]

[ "Preprocess", "the", "number", "of", "args", "ARGC", "in", "ARGV", ".", "Look", "for", "special", "flags", ",", "etc", ".", "that", "must", "be", "handled", "for", "the", "VMS", "linker", "." ]

[ "vms", "1", "\"-L\"", "2", "0", "1", "2", "\"-v\"", "0", "\"--version\"", "0", "\"VMS Linker\\n\"", "\"--help\"", "0", "\"VMS Linker\\n\"", "\"-g0\"", "0", "\"/notraceback\"", "\"-g\"", "2", "0", "\"/debug\"", "1", "\"-static\"", "0", "1", "\"-map\"", "0", "0", "\".map\"", "\"/map=\"", "\".map\"", "\"/full\"", "\"-save-temps\"", "0", "1", "\"--noinhibit-exec\"", "0", "0" ]

[]

[ "<s>", "void", "FISCFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "FISC", "::", "ADJCALLSTACKUP", "||", "I", "->", "getOpcode", "(", ")", "==", "FISC", "::", "ADJCALLSTACKDOWN", ")", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "FISC", "FISC", "FISC::ADJCALLSTACKUP", "FISC::ADJCALLSTACKDOWN" ]

[]

[ "<s>", "static", "ArgDescriptor", "createArg", "(", "const", "ArgDescriptor", "&", "Arg", ",", "unsigned", "Mask", ")", "{", "return", "ArgDescriptor", "(", "Arg", ".", "Reg", ",", "Mask", ",", "Arg", ".", "IsStack", ",", "Arg", ".", "IsSet", ")", ";", "}", "</s>" ]

[ "Convenience", "wrapper", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "ARM64AsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "assert", "(", "MO", ".", "isReg", "(", ")", "&&", "\"unexpected inline asm memory operand\"", ")", ";", "O", "<<", "\"[\"", "<<", "ARM64InstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", "<<", "\"]\"", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "0", "\"unexpected inline asm memory operand\"", "\"[\"", "ARM64", "\"]\"" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "getRecipEstimate", "(", "SDValue", "Operand", ",", "DAGCombinerInfo", "&", "DCI", ",", "unsigned", "&", "RefinementSteps", ")", "const", "{", "EVT", "VT", "=", "Operand", ".", "getValueType", "(", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "f32", "&&", "Subtarget", ".", "hasFRES", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "f64", "&&", "Subtarget", ".", "hasFRE", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v4f32", "&&", "Subtarget", ".", "hasAltivec", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v2f64", "&&", "Subtarget", ".", "hasVSX", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v4f32", "&&", "Subtarget", ".", "hasQPX", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v4f64", "&&", "Subtarget", ".", "hasQPX", "(", ")", ")", ")", "{", "TargetRecip", "Recips", "=", "DCI", ".", "DAG", ".", "getTarget", "(", ")", ".", "Options", ".", "Reciprocals", ";", "std", "::", "string", "RecipOp", "=", "getRecipOp", "(", "\"div\"", ",", "VT", ")", ";", "if", "(", "!", "Recips", ".", "isEnabled", "(", "RecipOp", ")", ")", "return", "SDValue", "(", ")", ";", "RefinementSteps", "=", "Recips", ".", "getRefinementSteps", "(", "RecipOp", ")", ";", "return", "DCI", ".", "DAG", ".", "getNode", "(", "PPCISD", "::", "FRE", ",", "SDLoc", "(", "Operand", ")", ",", "VT", ",", "Operand", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Return", "a", "reciprocal", "estimate", "value", "for", "the", "input", "operand", "." ]

[ "PowerPC", "PPC", "MVT::f32", "MVT::f64", "MVT::v4f32", "MVT::v2f64", "MVT::v4f32", "MVT::v4f64", "\"div\"", "PPCISD::FRE" ]

[]

[ "<s>", "void", "AMDGPUCallLowering", "::", "splitToValueTypes", "(", "MachineIRBuilder", "&", "B", ",", "const", "ArgInfo", "&", "OrigArg", ",", "SmallVectorImpl", "<", "ArgInfo", ">", "&", "SplitArgs", ",", "const", "DataLayout", "&", "DL", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsOutgoing", ",", "SplitArgTy", "PerformArgSplit", ")", "const", "{", "const", "SITargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "SITargetLowering", ">", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "OrigArg", ".", "Ty", "->", "getContext", "(", ")", ";", "if", "(", "OrigArg", ".", "Ty", "->", "isVoidTy", "(", ")", ")", "return", ";", "SmallVector", "<", "EVT", ",", "4", ">", "SplitVTs", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "OrigArg", ".", "Ty", ",", "SplitVTs", ")", ";", "assert", "(", "OrigArg", ".", "Regs", ".", "size", "(", ")", "==", "SplitVTs", ".", "size", "(", ")", ")", ";", "int", "SplitIdx", "=", "0", ";", "for", "(", "EVT", "VT", ":", "SplitVTs", ")", "{", "Register", "Reg", "=", "OrigArg", ".", "Regs", "[", "SplitIdx", "]", ";", "Type", "*", "Ty", "=", "VT", ".", "getTypeForEVT", "(", "Ctx", ")", ";", "LLT", "LLTy", "=", "getLLTForType", "(", "*", "Ty", ",", "DL", ")", ";", "if", "(", "IsOutgoing", "&&", "VT", ".", "isScalarInteger", "(", ")", ")", "{", "unsigned", "ExtendOp", "=", "TargetOpcode", "::", "G_ANYEXT", ";", "if", "(", "OrigArg", ".", "Flags", "[", "0", "]", ".", "isSExt", "(", ")", ")", "{", "assert", "(", "OrigArg", ".", "Regs", ".", "size", "(", ")", "==", "1", "&&", "\"expect only simple return values\"", ")", ";", "ExtendOp", "=", "TargetOpcode", "::", "G_SEXT", ";", "}", "else", "if", "(", "OrigArg", ".", "Flags", "[", "0", "]", ".", "isZExt", "(", ")", ")", "{", "assert", "(", "OrigArg", ".", "Regs", ".", "size", "(", ")", "==", "1", "&&", "\"expect only simple return values\"", ")", ";", "ExtendOp", "=", "TargetOpcode", "::", "G_ZEXT", ";", "}", "EVT", "ExtVT", "=", "TLI", ".", "getTypeForExtReturn", "(", "Ctx", ",", "VT", ",", "extOpcodeToISDExtOpcode", "(", "ExtendOp", ")", ")", ";", "if", "(", "ExtVT", ".", "getSizeInBits", "(", ")", "!=", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "VT", "=", "ExtVT", ";", "Ty", "=", "ExtVT", ".", "getTypeForEVT", "(", "Ctx", ")", ";", "LLTy", "=", "getLLTForType", "(", "*", "Ty", ",", "DL", ")", ";", "Reg", "=", "B", ".", "buildInstr", "(", "ExtendOp", ",", "{", "LLTy", "}", ",", "{", "Reg", "}", ")", ".", "getReg", "(", "0", ")", ";", "}", "}", "unsigned", "NumParts", "=", "TLI", ".", "getNumRegistersForCallingConv", "(", "Ctx", ",", "CallConv", ",", "VT", ")", ";", "MVT", "RegVT", "=", "TLI", ".", "getRegisterTypeForCallingConv", "(", "Ctx", ",", "CallConv", ",", "VT", ")", ";", "if", "(", "NumParts", "==", "1", ")", "{", "SplitArgs", ".", "emplace_back", "(", "Reg", ",", "Ty", ",", "OrigArg", ".", "Flags", ",", "OrigArg", ".", "IsFixed", ")", ";", "++", "SplitIdx", ";", "continue", ";", "}", "SmallVector", "<", "Register", ",", "8", ">", "SplitRegs", ";", "Type", "*", "PartTy", "=", "EVT", "(", "RegVT", ")", ".", "getTypeForEVT", "(", "Ctx", ")", ";", "LLT", "PartLLT", "=", "getLLTForType", "(", "*", "PartTy", ",", "DL", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "*", "B", ".", "getMRI", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "NumParts", ";", "++", "i", ")", "{", "Register", "PartReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "PartLLT", ")", ";", "SplitRegs", ".", "push_back", "(", "PartReg", ")", ";", "SplitArgs", ".", "emplace_back", "(", "ArrayRef", "<", "Register", ">", "(", "PartReg", ")", ",", "PartTy", ",", "OrigArg", ".", "Flags", ")", ";", "}", "PerformArgSplit", "(", "SplitRegs", ",", "Reg", ",", "LLTy", ",", "PartLLT", ",", "SplitIdx", ")", ";", "++", "SplitIdx", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "SI", "SI", "4", "0", "0", "1", "\"expect only simple return values\"", "0", "1", "\"expect only simple return values\"", "0", "1", "8", "0" ]

[]

[ "<s>", "static", "void", "nvptx_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "first", ")", "{", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "if", "(", "first", "&&", "MEM_P", "(", "rtl", ")", ")", "{", "nvptx_data_area", "area", "=", "DATA_AREA_GENERIC", ";", "if", "(", "TREE_CONSTANT", "(", "decl", ")", ")", "area", "=", "DATA_AREA_CONST", ";", "else", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", ")", "area", "=", "TREE_READONLY", "(", "decl", ")", "?", "DATA_AREA_CONST", ":", "DATA_AREA_GLOBAL", ";", "SET_SYMBOL_DATA_AREA", "(", "XEXP", "(", "rtl", ",", "0", ")", ",", "area", ")", ";", "}", "}", "</s>" ]

[ "Encode", "the", "PTX", "data", "area", "that", "DECL", "(", "which", "might", "not", "actually", "be", "a", "_DECL", ")", "should", "reside", "in", "." ]

[ "nvptx", "0" ]

[]

[ "<s>", "static", "const", "char", "*", "ia64_mangle_type", "(", "const_tree", "type", ")", "{", "type", "=", "TYPE_MAIN_VARIANT", "(", "type", ")", ";", "if", "(", "TREE_CODE", "(", "type", ")", "!=", "VOID_TYPE", "&&", "TREE_CODE", "(", "type", ")", "!=", "BOOLEAN_TYPE", "&&", "TREE_CODE", "(", "type", ")", "!=", "INTEGER_TYPE", "&&", "TREE_CODE", "(", "type", ")", "!=", "REAL_TYPE", ")", "return", "NULL", ";", "if", "(", "type", "==", "float128_type_node", "||", "type", "==", "float64x_type_node", ")", "return", "NULL", ";", "if", "(", "!", "TARGET_HPUX", "&&", "TYPE_MODE", "(", "type", ")", "==", "TFmode", ")", "return", "\"g\"", ";", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "XFmode", ")", "return", "TARGET_HPUX", "?", "\"u9__float80\"", ":", "\"e\"", ";", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "RFmode", ")", "return", "\"u7__fpreg\"", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Return", "the", "mangling", "of", "TYPE", "if", "it", "is", "an", "extended", "fundamental", "type", "." ]

[ "ia64", "\"g\"", "\"u9__float80\"", "\"e\"", "\"u7__fpreg\"" ]

[]

[ "<s>", "ARMSubtarget", "::", "ARMSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ",", "bool", "IsLittle", ")", ":", "ARMGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ARMProcFamily", "(", "Others", ")", ",", "ARMProcClass", "(", "None", ")", ",", "stackAlignment", "(", "4", ")", ",", "CPUString", "(", "CPU", ")", ",", "IsLittle", "(", "IsLittle", ")", ",", "TargetTriple", "(", "TT", ")", ",", "Options", "(", "TM", ".", "Options", ")", ",", "TargetABI", "(", "ARM_ABI_UNKNOWN", ")", ",", "DL", "(", "computeDataLayout", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ")", ",", "TSInfo", "(", "DL", ")", ",", "InstrInfo", "(", "isThumb1Only", "(", ")", "?", "(", "ARMBaseInstrInfo", "*", ")", "new", "Thumb1InstrInfo", "(", "*", "this", ")", ":", "!", "isThumb", "(", ")", "?", "(", "ARMBaseInstrInfo", "*", ")", "new", "ARMInstrInfo", "(", "*", "this", ")", ":", "(", "ARMBaseInstrInfo", "*", ")", "new", "Thumb2InstrInfo", "(", "*", "this", ")", ")", ",", "TLInfo", "(", "TM", ")", ",", "FrameLowering", "(", "!", "isThumb1Only", "(", ")", "?", "new", "ARMFrameLowering", "(", "*", "this", ")", ":", "(", "ARMFrameLowering", "*", ")", "new", "Thumb1FrameLowering", "(", "*", "this", ")", ")", "{", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "X86InstrInfo", "::", "hasLiveCondCodeDef", "(", "MachineInstr", "&", "MI", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isDef", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "X86", "::", "EFLAGS", "&&", "!", "MO", ".", "isDead", "(", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "True", "if", "MI", "has", "a", "condition", "code", "def", ",", "e.g", "." ]

[ "X86", "X86", "0", "X86::EFLAGS" ]

[]

[ "<s>", "void", "ix86_emit_i387_log1p", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx_code_label", "*", "label1", "=", "gen_label_rtx", "(", ")", ";", "rtx_code_label", "*", "label2", "=", "gen_label_rtx", "(", ")", ";", "rtx", "tmp", "=", "gen_reg_rtx", "(", "XFmode", ")", ";", "rtx", "tmp2", "=", "gen_reg_rtx", "(", "XFmode", ")", ";", "rtx", "test", ";", "emit_insn", "(", "gen_absxf2", "(", "tmp", ",", "op1", ")", ")", ";", "test", "=", "gen_rtx_GE", "(", "VOIDmode", ",", "tmp", ",", "const_double_from_real_value", "(", "REAL_VALUE_ATOF", "(", "\"0.29289321881345247561810596348408353\"", ",", "XFmode", ")", ",", "XFmode", ")", ")", ";", "emit_jump_insn", "(", "gen_cbranchxf4", "(", "test", ",", "XEXP", "(", "test", ",", "0", ")", ",", "XEXP", "(", "test", ",", "1", ")", ",", "label1", ")", ")", ";", "emit_move_insn", "(", "tmp2", ",", "standard_80387_constant_rtx", "(", "4", ")", ")", ";", "emit_insn", "(", "gen_fyl2xp1xf3_i387", "(", "op0", ",", "op1", ",", "tmp2", ")", ")", ";", "emit_jump", "(", "label2", ")", ";", "emit_label", "(", "label1", ")", ";", "emit_move_insn", "(", "tmp", ",", "CONST1_RTX", "(", "XFmode", ")", ")", ";", "emit_insn", "(", "gen_addxf3", "(", "tmp", ",", "op1", ",", "tmp", ")", ")", ";", "emit_move_insn", "(", "tmp2", ",", "standard_80387_constant_rtx", "(", "4", ")", ")", ";", "emit_insn", "(", "gen_fyl2xxf3_i387", "(", "op0", ",", "tmp", ",", "tmp2", ")", ")", ";", "emit_label", "(", "label2", ")", ";", "}", "</s>" ]

[ "Output", "code", "to", "perform", "a", "log1p", "XFmode", "calculation", "." ]

[ "i386", "\"0.29289321881345247561810596348408353\"", "0", "1", "4", "4" ]

[]

[ "<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", ",", "target_flag_set_p", "(", "MASK_OPT_HTM", ")", ",", "old_opts", ",", "opts", ",", "\"__HTM__\"", ",", "\"__HTM__\"", ")", ";", "s390_def_or_undef_macro", "(", "pfile", ",", "target_flag_set_p", "(", "MASK_OPT_VX", ")", ",", "old_opts", ",", "opts", ",", "\"__VX__\"", ",", "\"__VX__\"", ")", ";", "s390_def_or_undef_macro", "(", "pfile", ",", "target_flag_set_p", "(", "MASK_ZVECTOR", ")", ",", "old_opts", ",", "opts", ",", "\"__VEC__=10304\"", ",", "\"__VEC__\"", ")", ";", "s390_def_or_undef_macro", "(", "pfile", ",", "target_flag_set_p", "(", "MASK_ZVECTOR", ")", ",", "old_opts", ",", "opts", ",", "\"__vector=__attribute__((vector_size(16)))\"", ",", "\"__vector__\"", ")", ";", "s390_def_or_undef_macro", "(", "pfile", ",", "target_flag_set_p", "(", "MASK_ZVECTOR", ")", ",", "old_opts", ",", "opts", ",", "\"__bool=__attribute__((s390_vector_bool)) unsigned\"", ",", "\"__bool\"", ")", ";", "{", "char", "macro_def", "[", "64", "]", ";", "gcc_assert", "(", "s390_arch", "!=", "PROCESSOR_NATIVE", ")", ";", "sprintf", "(", "macro_def", ",", "\"__ARCH__=%d\"", ",", "processor_table", "[", "s390_arch", "]", ".", "arch_level", ")", ";", "cpp_undef", "(", "pfile", ",", "\"__ARCH__\"", ")", ";", "cpp_define", "(", "pfile", ",", "macro_def", ")", ";", "}", "s390_def_or_undef_macro", "(", "pfile", ",", "[", "]", "(", "const", "struct", "cl_target_option", "*", "opts", ")", "{", "return", "TARGET_VXE_P", "(", "opts", ")", ";", "}", ",", "old_opts", ",", "opts", ",", "\"__LONG_DOUBLE_VX__\"", ",", "\"__LONG_DOUBLE_VX__\"", ")", ";", "if", "(", "!", "flag_iso", ")", "{", "s390_def_or_undef_macro", "(", "pfile", ",", "target_flag_set_p", "(", "MASK_ZVECTOR", ")", ",", "old_opts", ",", "opts", ",", "\"__VECTOR_KEYWORD_SUPPORTED__\"", ",", "\"__VECTOR_KEYWORD_SUPPORTED__\"", ")", ";", "s390_def_or_undef_macro", "(", "pfile", ",", "target_flag_set_p", "(", "MASK_ZVECTOR", ")", ",", "old_opts", ",", "opts", ",", "\"vector=vector\"", ",", "\"vector\"", ")", ";", "s390_def_or_undef_macro", "(", "pfile", ",", "target_flag_set_p", "(", "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__=10304\"", "\"__VEC__\"", "\"__vector=__attribute__((vector_size(16)))\"", "\"__vector__\"", "\"__bool=__attribute__((s390_vector_bool)) unsigned\"", "\"__bool\"", "64", "\"__ARCH__=%d\"", "\"__ARCH__\"", "\"__LONG_DOUBLE_VX__\"", "\"__LONG_DOUBLE_VX__\"", "\"__VECTOR_KEYWORD_SUPPORTED__\"", "\"__VECTOR_KEYWORD_SUPPORTED__\"", "\"vector=vector\"", "\"vector\"", "\"bool=bool\"", "\"bool\"", "\"__vector\"", "\"vector\"", "\"__bool\"", "\"bool\"", "\"_Bool\"" ]

[]

[ "<s>", "bool", "nds32_ls_333_p", "(", "rtx", "rt", ",", "rtx", "ra", ",", "rtx", "imm", ",", "machine_mode", "mode", ")", "{", "if", "(", "REGNO_REG_CLASS", "(", "REGNO", "(", "rt", ")", ")", "==", "LOW_REGS", "&&", "REGNO_REG_CLASS", "(", "REGNO", "(", "ra", ")", ")", "==", "LOW_REGS", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "4", ")", "return", "satisfies_constraint_Iu05", "(", "imm", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "2", ")", "return", "satisfies_constraint_Iu04", "(", "imm", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "1", ")", "return", "satisfies_constraint_Iu03", "(", "imm", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Function", "to", "test", "333-form", "for", "load/store", "instructions", ".", "This", "is", "auxiliary", "extern", "function", "for", "auxiliary", "macro", "in", "nds32.h", ".", "Because", "it", "is", "a", "little", "complicated", ",", "we", "use", "function", "instead", "of", "macro", "." ]

[ "nds32", "4", "2", "1" ]

[]

[ "<s>", "static", "void", "mips_print_int_branch_condition", "(", "FILE", "*", "file", ",", "enum", "rtx_code", "code", ",", "int", "letter", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "NE", ":", "case", "GT", ":", "case", "GE", ":", "case", "LT", ":", "case", "LE", ":", "case", "GTU", ":", "case", "GEU", ":", "case", "LTU", ":", "case", "LEU", ":", "fputs", "(", "GET_RTX_NAME", "(", "code", ")", ",", "file", ")", ";", "break", ";", "default", ":", "output_operand_lossage", "(", "\"'%%%c' is not a valid operand prefix\"", ",", "letter", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "PRINT_OPERAND", "prefix", "LETTER", "refers", "to", "the", "integer", "branch", "instruction", "associated", "with", "condition", "CODE", ".", "Print", "the", "condition", "part", "of", "the", "opcode", "to", "FILE", "." ]

[ "mips", "\"'%%%c' is not a valid operand prefix\"" ]

[]

[ "<s>", "bool", "LEGTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "RVLocs", ",", "Context", ")", ";", "if", "(", "!", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "RetCC_LEG", ")", ")", "{", "return", "false", ";", "}", "if", "(", "CCInfo", ".", "getNextStackOffset", "(", ")", "!=", "0", "&&", "isVarArg", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]

[ "LEG", "LEG", "ISD::OutputArg", "16", "LEG", "0" ]

[]

[ "<s>", "unsigned", "PPCInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "PPC", "::", "INLINEASM", ")", "{", "const", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "char", "*", "AsmStr", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ";", "return", "getInlineAsmLength", "(", "AsmStr", ",", "*", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "else", "if", "(", "Opcode", "==", "TargetOpcode", "::", "STACKMAP", ")", "{", "StackMapOpers", "Opers", "(", "&", "MI", ")", ";", "return", "Opers", ".", "getNumPatchBytes", "(", ")", ";", "}", "else", "if", "(", "Opcode", "==", "TargetOpcode", "::", "PATCHPOINT", ")", "{", "PatchPointOpers", "Opers", "(", "&", "MI", ")", ";", "return", "Opers", ".", "getNumPatchBytes", "(", ")", ";", "}", "else", "{", "return", "get", "(", "Opcode", ")", ".", "getSize", "(", ")", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::INLINEASM", "0" ]

[]

[ "<s>", "static", "int", "const_vector_immediate_p", "(", "rtx", "x", ")", "{", "int", "i", ";", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "GET_MODE_NUNITS", "(", "GET_MODE", "(", "x", ")", ")", ";", "i", "++", ")", "if", "(", "GET_CODE", "(", "CONST_VECTOR_ELT", "(", "x", ",", "i", ")", ")", "!=", "CONST_INT", "&&", "GET_CODE", "(", "CONST_VECTOR_ELT", "(", "x", ",", "i", ")", ")", "!=", "CONST_DOUBLE", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "TRUE", "when", "X", ",", "a", "CONST_VECTOR", ",", "only", "contains", "CONST_INTs", "or", "CONST_DOUBLEs", "." ]

[ "spu", "0", "0", "1" ]

[]

[ "<s>", "const", "char", "*", "SystemZTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "OPCODE", "(", "RET_FLAG", ")", ";", "OPCODE", "(", "CALL", ")", ";", "OPCODE", "(", "SIBCALL", ")", ";", "OPCODE", "(", "PCREL_WRAPPER", ")", ";", "OPCODE", "(", "PCREL_OFFSET", ")", ";", "OPCODE", "(", "ICMP", ")", ";", "OPCODE", "(", "FCMP", ")", ";", "OPCODE", "(", "TM", ")", ";", "OPCODE", "(", "BR_CCMASK", ")", ";", "OPCODE", "(", "SELECT_CCMASK", ")", ";", "OPCODE", "(", "ADJDYNALLOC", ")", ";", "OPCODE", "(", "EXTRACT_ACCESS", ")", ";", "OPCODE", "(", "UMUL_LOHI64", ")", ";", "OPCODE", "(", "SDIVREM64", ")", ";", "OPCODE", "(", "UDIVREM32", ")", ";", "OPCODE", "(", "UDIVREM64", ")", ";", "OPCODE", "(", "MVC", ")", ";", "OPCODE", "(", "MVC_LOOP", ")", ";", "OPCODE", "(", "NC", ")", ";", "OPCODE", "(", "NC_LOOP", ")", ";", "OPCODE", "(", "OC", ")", ";", "OPCODE", "(", "OC_LOOP", ")", ";", "OPCODE", "(", "XC", ")", ";", "OPCODE", "(", "XC_LOOP", ")", ";", "OPCODE", "(", "CLC", ")", ";", "OPCODE", "(", "CLC_LOOP", ")", ";", "OPCODE", "(", "STRCMP", ")", ";", "OPCODE", "(", "STPCPY", ")", ";", "OPCODE", "(", "SEARCH_STRING", ")", ";", "OPCODE", "(", "IPM", ")", ";", "OPCODE", "(", "ATOMIC_SWAPW", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_ADD", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_SUB", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_AND", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_OR", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_XOR", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_NAND", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_MIN", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_MAX", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_UMIN", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_UMAX", ")", ";", "OPCODE", "(", "ATOMIC_CMP_SWAPW", ")", ";", "OPCODE", "(", "PREFETCH", ")", ";", "}", "return", "NULL", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "static", "void", "nvptx_wpropagate", "(", "bool", "pre_p", ",", "basic_block", "block", ",", "rtx_insn", "*", "insn", ")", "{", "wcast_data_t", "data", ";", "data", ".", "base", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "data", ".", "offset", "=", "0", ";", "data", ".", "ptr", "=", "NULL_RTX", ";", "nvptx_propagate", "(", "block", ",", "insn", ",", "pre_p", "?", "PM_read", ":", "PM_write", ",", "wprop_gen", ",", "&", "data", ")", ";", "if", "(", "data", ".", "offset", ")", "{", "rtx", "init", "=", "gen_rtx_SET", "(", "data", ".", "base", ",", "worker_bcast_sym", ")", ";", "emit_insn_after", "(", "init", ",", "insn", ")", ";", "if", "(", "worker_bcast_size", "<", "data", ".", "offset", ")", "worker_bcast_size", "=", "data", ".", "offset", ";", "}", "}", "</s>" ]

[ "Spill", "or", "fill", "live", "state", "that", "is", "live", "at", "start", "of", "BLOCK", ".", "PRE_P", "indicates", "if", "this", "is", "just", "before", "partitioned", "mode", "(", "do", "spill", ")", ",", "or", "just", "after", "it", "starts", "(", "do", "fill", ")", ".", "Sequence", "is", "inserted", "just", "after", "INSN", ".", "IS_CALL", "and", "return", "as", "for", "nvptx_propagate", "." ]

[ "nvptx", "0" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "HexagonTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "assert", "(", "0", "&&", "\"getRegForInlineAsmConstraint Unhandled data type\"", ")", ";", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i8", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "Hexagon", "::", "IntRegsRegisterClass", ")", ";", "case", "MVT", "::", "i64", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "Hexagon", "::", "DoubleRegsRegisterClass", ")", ";", "}", "default", ":", "assert", "(", "0", "&&", "\"Unknown asm register class\"", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "1", "0", "0", "\"getRegForInlineAsmConstraint Unhandled data type\"", "MVT::i32", "MVT::i16", "MVT::i8", "0U", "Hexagon::IntRegsRegisterClass", "MVT::i64", "0U", "Hexagon::DoubleRegsRegisterClass", "0", "\"Unknown asm register class\"" ]

[]

[ "<s>", "static", "void", "vr4130_align_insns", "(", "void", ")", "{", "struct", "mips_sim", "state", ";", "rtx_insn", "*", "insn", ",", "*", "subinsn", ",", "*", "last", ",", "*", "last2", ",", "*", "next", ";", "bool", "aligned_p", ";", "dfa_start", "(", ")", ";", "last", "=", "0", ";", "last2", "=", "0", ";", "aligned_p", "=", "true", ";", "mips_sim_init", "(", "&", "state", ",", "alloca", "(", "state_size", "(", ")", ")", ")", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", "!=", "0", ";", "insn", "=", "next", ")", "{", "unsigned", "int", "length", ";", "next", "=", "NEXT_INSN", "(", "insn", ")", ";", "vr4130_avoid_branch_rt_conflict", "(", "insn", ")", ";", "length", "=", "get_attr_length", "(", "insn", ")", ";", "if", "(", "length", ">", "0", "&&", "USEFUL_INSN_P", "(", "insn", ")", ")", "FOR_EACH_SUBINSN", "(", "subinsn", ",", "insn", ")", "{", "mips_sim_wait_insn", "(", "&", "state", ",", "subinsn", ")", ";", "if", "(", "state", ".", "insns_left", "!=", "state", ".", "issue_rate", "&&", "!", "CALL_P", "(", "subinsn", ")", ")", "{", "if", "(", "subinsn", "==", "SEQ_BEGIN", "(", "insn", ")", "&&", "aligned_p", ")", "{", "gcc_assert", "(", "last2", ")", ";", "emit_insn_after", "(", "gen_nop", "(", ")", ",", "last2", ")", ";", "aligned_p", "=", "false", ";", "}", "else", "if", "(", "subinsn", "!=", "SEQ_BEGIN", "(", "insn", ")", "&&", "!", "aligned_p", ")", "{", "gcc_assert", "(", "last", ")", ";", "emit_insn_after", "(", "gen_nop", "(", ")", ",", "last", ")", ";", "aligned_p", "=", "true", ";", "}", "}", "mips_sim_issue_insn", "(", "&", "state", ",", "subinsn", ")", ";", "}", "mips_sim_finish_insn", "(", "&", "state", ",", "insn", ")", ";", "length", "=", "get_attr_length", "(", "insn", ")", ";", "if", "(", "length", ">", "0", ")", "{", "if", "(", "NONJUMP_INSN_P", "(", "SEQ_BEGIN", "(", "insn", ")", ")", "&&", "(", "recog_memoized", "(", "insn", ")", "<", "0", "||", "length", ">=", "8", ")", ")", "{", "next", "=", "emit_insn_after", "(", "gen_align", "(", "GEN_INT", "(", "3", ")", ")", ",", "insn", ")", ";", "next", "=", "NEXT_INSN", "(", "next", ")", ";", "mips_sim_next_cycle", "(", "&", "state", ")", ";", "aligned_p", "=", "true", ";", "}", "else", "if", "(", "length", "&", "4", ")", "aligned_p", "=", "!", "aligned_p", ";", "last2", "=", "last", ";", "last", "=", "insn", ";", "}", "if", "(", "LABEL_P", "(", "insn", ")", "&&", "label_to_alignment", "(", "insn", ")", ">=", "3", ")", "aligned_p", "=", "true", ";", "}", "dfa_finish", "(", ")", ";", "}", "</s>" ]

[ "Implement", "-mvr4130-align", ".", "Go", "through", "each", "basic", "block", "and", "simulate", "the", "processor", "pipeline", ".", "If", "we", "find", "that", "a", "pair", "of", "instructions", "could", "execute", "in", "parallel", ",", "and", "the", "first", "of", "those", "instruction", "is", "not", "8-byte", "aligned", ",", "insert", "a", "nop", "to", "make", "it", "aligned", "." ]

[ "mips", "0", "0", "0", "0", "0", "0", "8", "3", "4", "3" ]

[]

[ "<s>", "bool", "ARMAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", ";", "bool", "PendConditionalInstruction", "=", "false", ";", "SmallVector", "<", "NearMissInfo", ",", "4", ">", "NearMisses", ";", "MatchResult", "=", "MatchInstruction", "(", "Operands", ",", "Inst", ",", "NearMisses", ",", "MatchingInlineAsm", ",", "PendConditionalInstruction", ",", "Out", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Parsed as: \"", ";", "Inst", ".", "dump_pretty", "(", "dbgs", "(", ")", ",", "MII", ".", "getName", "(", "Inst", ".", "getOpcode", "(", ")", ")", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "validateInstruction", "(", "Inst", ",", "Operands", ")", ")", "{", "forwardITPosition", "(", ")", ";", "forwardVPTPosition", "(", ")", ";", "return", "true", ";", "}", "{", "bool", "wasInITBlock", "=", "inITBlock", "(", ")", ";", "while", "(", "processInstruction", "(", "Inst", ",", "Operands", ",", "Out", ")", ")", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Changed to: \"", ";", "Inst", ".", "dump_pretty", "(", "dbgs", "(", ")", ",", "MII", ".", "getName", "(", "Inst", ".", "getOpcode", "(", ")", ")", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "wasInITBlock", "&&", "hasV8Ops", "(", ")", "&&", "isThumb", "(", ")", "&&", "!", "isV8EligibleForIT", "(", "&", "Inst", ")", ")", "{", "Warning", "(", "IDLoc", ",", "\"deprecated instruction in IT block\"", ")", ";", "}", "}", "forwardITPosition", "(", ")", ";", "forwardVPTPosition", "(", ")", ";", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "ARM", "::", "ITasm", ")", "return", "false", ";", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "if", "(", "PendConditionalInstruction", ")", "{", "PendingConditionalInsts", ".", "push_back", "(", "Inst", ")", ";", "if", "(", "isITBlockFull", "(", ")", "||", "isITBlockTerminator", "(", "Inst", ")", ")", "flushPendingInstructions", "(", "Out", ")", ";", "}", "else", "{", "Out", ".", "emitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "}", "return", "false", ";", "case", "Match_NearMisses", ":", "ReportNearMisses", "(", "NearMisses", ",", "IDLoc", ",", "Operands", ")", ";", "return", "true", ";", "case", "Match_MnemonicFail", ":", "{", "FeatureBitset", "FBS", "=", "ComputeAvailableFeatures", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", ")", ";", "std", "::", "string", "Suggestion", "=", "ARMMnemonicSpellCheck", "(", "(", "(", "ARMOperand", "&", ")", "*", "Operands", "[", "0", "]", ")", ".", "getToken", "(", ")", ",", "FBS", ")", ";", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", "+", "Suggestion", ",", "(", "(", "ARMOperand", "&", ")", "*", "Operands", "[", "0", "]", ")", ".", "getLocRange", "(", ")", ")", ";", "}", "}", "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", "." ]

[ "ARM", "ARM", "4", "\"Parsed as: \"", "\"\\n\"", "\"Changed to: \"", "\"\\n\"", "\"deprecated instruction in IT block\"", "ARM::ITasm", "ARM", "ARM", "0", "\"invalid instruction\"", "ARM", "0", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "bool", "bx_p", "(", "rtx", "op", ",", "bool", "strict", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "false", ";", "return", "inside_bx_p", "(", "XEXP", "(", "op", ",", "0", ")", ",", "strict", ")", ";", "}", "</s>" ]

[ "ptr", "sized", "reg", "+", "sign", "extended", "int", "reg" ]

[ "z8k", "0" ]

[]

[ "<s>", "MCSymbol", "*", "DCPU16MCInstLower", "::", "GetBlockAddressSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "switch", "(", "MO", ".", "getTargetFlags", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown target flag on GV operand\"", ")", ";", "case", "0", ":", "break", ";", "}", "return", "Printer", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "used", "to", "satisfy", "BlockAddress", "uses", "of", "the", "specified", "basic", "block", "." ]

[ "Dcpu16", "DCPU16", "\"Unknown target flag on GV operand\"", "0" ]

[]

[ "<s>", "int", "frv_class_max_nregs", "(", "enum", "reg_class", "rclass", ",", "machine_mode", "mode", ")", "{", "if", "(", "rclass", "==", "ACCG_REGS", ")", "return", "GET_MODE_SIZE", "(", "mode", ")", ";", "else", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "A", "C", "expression", "for", "the", "maximum", "number", "of", "consecutive", "registers", "of", "class", "RCLASS", "needed", "to", "hold", "a", "value", "of", "mode", "MODE", ".", "This", "is", "closely", "related", "to", "the", "macro", "`", "HARD_REGNO_NREGS", "'", ".", "In", "fact", ",", "the", "value", "of", "the", "macro", "`", "CLASS_MAX_NREGS", "(", "RCLASS", ",", "MODE", ")", "'", "should", "be", "the", "maximum", "value", "of", "`", "HARD_REGNO_NREGS", "(", "REGNO", ",", "MODE", ")", "'", "for", "all", "REGNO", "values", "in", "the", "class", "RCLASS", ".", "This", "macro", "helps", "control", "the", "handling", "of", "multiple-word", "values", "in", "the", "reload", "pass", ".", "This", "declaration", "is", "required", "." ]

[ "frv", "1" ]

[]

[ "<s>", "tree", "ix86_get_function_versions_dispatcher", "(", "void", "*", "decl", ")", "{", "tree", "fn", "=", "(", "tree", ")", "decl", ";", "struct", "cgraph_node", "*", "node", "=", "NULL", ";", "struct", "cgraph_node", "*", "default_node", "=", "NULL", ";", "struct", "cgraph_function_version_info", "*", "node_v", "=", "NULL", ";", "struct", "cgraph_function_version_info", "*", "first_v", "=", "NULL", ";", "tree", "dispatch_decl", "=", "NULL", ";", "struct", "cgraph_function_version_info", "*", "default_version_info", "=", "NULL", ";", "gcc_assert", "(", "fn", "!=", "NULL", "&&", "DECL_FUNCTION_VERSIONED", "(", "fn", ")", ")", ";", "node", "=", "cgraph_node", "::", "get", "(", "fn", ")", ";", "gcc_assert", "(", "node", "!=", "NULL", ")", ";", "node_v", "=", "node", "->", "function_version", "(", ")", ";", "gcc_assert", "(", "node_v", "!=", "NULL", ")", ";", "if", "(", "node_v", "->", "dispatcher_resolver", "!=", "NULL", ")", "return", "node_v", "->", "dispatcher_resolver", ";", "first_v", "=", "node_v", ";", "while", "(", "first_v", "->", "prev", "!=", "NULL", ")", "first_v", "=", "first_v", "->", "prev", ";", "default_version_info", "=", "first_v", ";", "while", "(", "default_version_info", "!=", "NULL", ")", "{", "if", "(", "is_function_default_version", "(", "default_version_info", "->", "this_node", "->", "decl", ")", ")", "break", ";", "default_version_info", "=", "default_version_info", "->", "next", ";", "}", "if", "(", "default_version_info", "==", "NULL", ")", "return", "NULL", ";", "if", "(", "first_v", "!=", "default_version_info", ")", "{", "default_version_info", "->", "prev", "->", "next", "=", "default_version_info", "->", "next", ";", "if", "(", "default_version_info", "->", "next", ")", "default_version_info", "->", "next", "->", "prev", "=", "default_version_info", "->", "prev", ";", "first_v", "->", "prev", "=", "default_version_info", ";", "default_version_info", "->", "next", "=", "first_v", ";", "default_version_info", "->", "prev", "=", "NULL", ";", "}", "default_node", "=", "default_version_info", "->", "this_node", ";", "if", "(", "targetm", ".", "has_ifunc_p", "(", ")", ")", "{", "struct", "cgraph_function_version_info", "*", "it_v", "=", "NULL", ";", "struct", "cgraph_node", "*", "dispatcher_node", "=", "NULL", ";", "struct", "cgraph_function_version_info", "*", "dispatcher_version_info", "=", "NULL", ";", "dispatch_decl", "=", "make_dispatcher_decl", "(", "default_node", "->", "decl", ")", ";", "TREE_NOTHROW", "(", "dispatch_decl", ")", "=", "TREE_NOTHROW", "(", "fn", ")", ";", "dispatcher_node", "=", "cgraph_node", "::", "get_create", "(", "dispatch_decl", ")", ";", "gcc_assert", "(", "dispatcher_node", "!=", "NULL", ")", ";", "dispatcher_node", "->", "dispatcher_function", "=", "1", ";", "dispatcher_version_info", "=", "dispatcher_node", "->", "insert_new_function_version", "(", ")", ";", "dispatcher_version_info", "->", "next", "=", "default_version_info", ";", "dispatcher_node", "->", "definition", "=", "1", ";", "it_v", "=", "default_version_info", ";", "while", "(", "it_v", "!=", "NULL", ")", "{", "it_v", "->", "dispatcher_resolver", "=", "dispatch_decl", ";", "it_v", "=", "it_v", "->", "next", ";", "}", "}", "else", "{", "error_at", "(", "DECL_SOURCE_LOCATION", "(", "default_node", "->", "decl", ")", ",", "\"multiversioning needs %<ifunc%> which is not supported \"", "\"on this target\"", ")", ";", "}", "return", "dispatch_decl", ";", "}", "</s>" ]

[ "Make", "a", "dispatcher", "declaration", "for", "the", "multi-versioned", "function", "DECL", ".", "Calls", "to", "DECL", "function", "will", "be", "replaced", "with", "calls", "to", "the", "dispatcher", "by", "the", "front-end", ".", "Returns", "the", "decl", "of", "the", "dispatcher", "function", "." ]

[ "i386", "1", "1", "\"multiversioning needs %<ifunc%> which is not supported \"", "\"on this target\"" ]

[]

[ "<s>", "static", "void", "rs6000_set_up_by_prologue", "(", "struct", "hard_reg_set_container", "*", "set", ")", "{", "if", "(", "!", "TARGET_SINGLE_PIC_BASE", "&&", "TARGET_TOC", "&&", "TARGET_MINIMAL_TOC", "&&", "!", "constant_pool_empty_p", "(", ")", ")", "add_to_hard_reg_set", "(", "&", "set", "->", "set", ",", "Pmode", ",", "RS6000_PIC_OFFSET_TABLE_REGNUM", ")", ";", "if", "(", "cfun", "->", "machine", "->", "split_stack_argp_used", ")", "add_to_hard_reg_set", "(", "&", "set", "->", "set", ",", "Pmode", ",", "12", ")", ";", "}", "</s>" ]

[ "Add", "r30", "to", "hard", "reg", "set", "if", "the", "prologue", "sets", "it", "up", "and", "it", "is", "not", "pic_offset_table_rtx", "." ]

[ "powerpcspe", "12" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "AArch64TargetLowering", "::", "shouldExpandAtomicCmpXchgInIR", "(", "AtomicCmpXchgInst", "*", "AI", ")", "const", "{", "if", "(", "Subtarget", "->", "hasLSE", "(", ")", "||", "Subtarget", "->", "outlineAtomics", "(", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "return", "AtomicExpansionKind", "::", "None", ";", "unsigned", "Size", "=", "AI", "->", "getCompareOperand", "(", ")", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "Size", ">", "64", ")", "return", "AtomicExpansionKind", "::", "None", ";", "return", "AtomicExpansionKind", "::", "LLSC", ";", "}", "</s>" ]

[ "Returns", "how", "the", "given", "atomic", "cmpxchg", "should", "be", "expanded", "by", "the", "IR-level", "AtomicExpand", "pass", "." ]

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

[]

[ "<s>", "rtx", "alpha_tablejump_best_label", "(", "rtx", "insn", ")", "{", "rtx", "jump_table", "=", "alpha_tablejump_addr_vec", "(", "insn", ")", ";", "rtx", "best_label", "=", "NULL_RTX", ";", "if", "(", "jump_table", ")", "{", "int", "n_labels", "=", "XVECLEN", "(", "jump_table", ",", "1", ")", ";", "int", "best_count", "=", "-", "1", ";", "int", "i", ",", "j", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_labels", ";", "i", "++", ")", "{", "int", "count", "=", "1", ";", "for", "(", "j", "=", "i", "+", "1", ";", "j", "<", "n_labels", ";", "j", "++", ")", "if", "(", "XEXP", "(", "XVECEXP", "(", "jump_table", ",", "1", ",", "i", ")", ",", "0", ")", "==", "XEXP", "(", "XVECEXP", "(", "jump_table", ",", "1", ",", "j", ")", ",", "0", ")", ")", "count", "++", ";", "if", "(", "count", ">", "best_count", ")", "best_count", "=", "count", ",", "best_label", "=", "XVECEXP", "(", "jump_table", ",", "1", ",", "i", ")", ";", "}", "}", "return", "best_label", "?", "best_label", ":", "const0_rtx", ";", "}", "</s>" ]

[ "Return", "the", "label", "of", "the", "predicted", "edge", ",", "or", "CONST0_RTX", "if", "we", "do", "n't", "know", "." ]

[ "alpha", "1", "1", "0", "1", "1", "1", "0", "1", "0", "1" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "Result", "=", "Match_Success", ";", "for", "(", "auto", "Variant", ":", "getMatchedVariants", "(", ")", ")", "{", "uint64_t", "EI", ";", "auto", "R", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "EI", ",", "MatchingInlineAsm", ",", "Variant", ")", ";", "if", "(", "(", "R", "==", "Match_Success", ")", "||", "(", "R", "==", "Match_PreferE32", ")", "||", "(", "R", "==", "Match_MissingFeature", "&&", "Result", "!=", "Match_PreferE32", ")", "||", "(", "R", "==", "Match_InvalidOperand", "&&", "Result", "!=", "Match_MissingFeature", "&&", "Result", "!=", "Match_PreferE32", ")", "||", "(", "R", "==", "Match_MnemonicFail", "&&", "Result", "!=", "Match_InvalidOperand", "&&", "Result", "!=", "Match_MissingFeature", "&&", "Result", "!=", "Match_PreferE32", ")", ")", "{", "Result", "=", "R", ";", "ErrorInfo", "=", "EI", ";", "}", "if", "(", "R", "==", "Match_Success", ")", "break", ";", "}", "switch", "(", "Result", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "if", "(", "!", "validateInstruction", "(", "Inst", ",", "IDLoc", ",", "Operands", ")", ")", "{", "return", "true", ";", "}", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction not supported on this GPU\"", ")", ";", "case", "Match_MnemonicFail", ":", "{", "FeatureBitset", "FBS", "=", "ComputeAvailableFeatures", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", ")", ";", "std", "::", "string", "Suggestion", "=", "AMDGPUMnemonicSpellCheck", "(", "(", "(", "AMDGPUOperand", "&", ")", "*", "Operands", "[", "0", "]", ")", ".", "getToken", "(", ")", ",", "FBS", ")", ";", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", "+", "Suggestion", ",", "(", "(", "AMDGPUOperand", "&", ")", "*", "Operands", "[", "0", "]", ")", ".", "getLocRange", "(", ")", ")", ";", "}", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "{", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "}", "ErrorLoc", "=", "(", "(", "AMDGPUOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_PreferE32", ":", "return", "Error", "(", "IDLoc", ",", "\"internal error: instruction without _e64 suffix \"", "\"should be encoded as e32\"", ")", ";", "}", "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", "." ]

[ "AMDGPU", "AMDGPU", "\"instruction not supported on this GPU\"", "AMDGPU", "AMDGPU", "0", "\"invalid instruction\"", "AMDGPU", "0", "0ULL", "\"too few operands for instruction\"", "AMDGPU", "\"invalid operand for instruction\"", "\"internal error: instruction without _e64 suffix \"", "\"should be encoded as e32\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "static", "unsigned", "size", "(", "const", "GraphType", "&", "G", ")", "{", "return", "G", ".", "Blocks", ".", "size", "(", ")", ";", "}", "</s>" ]

[ "The", "number", "of", "name/type", "pairs", "is", "returned", "." ]

[ "Patmos" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"SI Type Rewriter\"", ";", "}", "</s>" ]

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

[ "R600", "\"SI Type Rewriter\"" ]

[]

[ "<s>", "bool", "has", "(", "unsigned", "R", ")", "const", "{", "if", "(", "!", "Register", "::", "isVirtualRegister", "(", "R", ")", ")", "return", "true", ";", "MapType", "::", "const_iterator", "F", "=", "Map", ".", "find", "(", "R", ")", ";", "return", "F", "!=", "Map", ".", "end", "(", ")", ";", "}", "</s>" ]

[ "Tests", "whether", "a", "library", "function", "is", "available", "." ]

[ "Hexagon" ]

[]

[ "<s>", "unsigned", "AMDGPUTargetLowering", "::", "computeNumSignBitsForTargetInstr", "(", "GISelKnownBits", "&", "Analysis", ",", "Register", "R", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "MachineRegisterInfo", "&", "MRI", ",", "unsigned", "Depth", ")", "const", "{", "const", "MachineInstr", "*", "MI", "=", "MRI", ".", "getVRegDef", "(", "R", ")", ";", "if", "(", "!", "MI", ")", "return", "1", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "G_AMDGPU_BUFFER_LOAD_SBYTE", ":", "return", "25", ";", "case", "AMDGPU", "::", "G_AMDGPU_BUFFER_LOAD_SSHORT", ":", "return", "17", ";", "case", "AMDGPU", "::", "G_AMDGPU_BUFFER_LOAD_UBYTE", ":", "return", "24", ";", "case", "AMDGPU", "::", "G_AMDGPU_BUFFER_LOAD_USHORT", ":", "return", "16", ";", "default", ":", "return", "1", ";", "}", "}", "</s>" ]

[ "This", "method", "can", "be", "implemented", "by", "targets", "that", "want", "to", "expose", "additional", "information", "about", "sign", "bits", "to", "GlobalISel", "combiners", "." ]

[ "AMDGPU", "AMDGPU", "1", "AMDGPU::G_AMDGPU_BUFFER_LOAD_SBYTE", "25", "AMDGPU::G_AMDGPU_BUFFER_LOAD_SSHORT", "17", "AMDGPU::G_AMDGPU_BUFFER_LOAD_UBYTE", "24", "AMDGPU::G_AMDGPU_BUFFER_LOAD_USHORT", "16", "1" ]

[]

[ "<s>", "bool", "lm32_move_ok", "(", "machine_mode", "mode", ",", "rtx", "operands", "[", "2", "]", ")", "{", "if", "(", "memory_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", ")", "return", "register_or_zero_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Check", "a", "move", "is", "not", "memory", "to", "memory", "." ]

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

[]

[ "<s>", "unsigned", "getBitMask", "(", "unsigned", "Shift", ",", "unsigned", "Width", ")", "{", "return", "(", "(", "1", "<<", "Width", ")", "-", "1", ")", "<<", "Shift", ";", "}", "</s>" ]

[ "Return", "a", "bitmask", "with", "ones", "set", "for", "all", "of", "the", "bits", "that", "can", "be", "set", "by", "an", "unsigned", "version", "of", "this", "type", "." ]

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

[]

[ "<s>", "void", "avr_register_target_pragmas", "(", "void", ")", "{", "int", "i", ";", "gcc_assert", "(", "ADDR_SPACE_GENERIC", "==", "ADDR_SPACE_RAM", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ADDR_SPACE_COUNT", ";", "i", "++", ")", "{", "gcc_assert", "(", "i", "==", "avr_addrspace", "[", "i", "]", ".", "id", ")", ";", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "i", ")", ")", "c_register_addr_space", "(", "avr_addrspace", "[", "i", "]", ".", "name", ",", "avr_addrspace", "[", "i", "]", ".", "id", ")", ";", "}", "targetm", ".", "resolve_overloaded_builtin", "=", "avr_resolve_overloaded_builtin", ";", "}", "</s>" ]

[ "Implement", "`", "REGISTER_TARGET_PRAGMAS", "'", "." ]

[ "avr", "0" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "PPCHazardRecognizer970", "::", "getHazardType", "(", "SUnit", "*", "SU", ",", "int", "Stalls", ")", "{", "assert", "(", "Stalls", "==", "0", "&&", "\"PPC hazards don't support scoreboard lookahead\"", ")", ";", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "return", "NoHazard", ";", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "LastWasBL8_ELF", "&&", "Opcode", "!=", "PPC", "::", "NOP", ")", "return", "Hazard", ";", "bool", "isFirst", ",", "isSingle", ",", "isCracked", ",", "isLoad", ",", "isStore", ";", "PPCII", "::", "PPC970_Unit", "InstrType", "=", "GetInstrType", "(", "Opcode", ",", "isFirst", ",", "isSingle", ",", "isCracked", ",", "isLoad", ",", "isStore", ")", ";", "if", "(", "InstrType", "==", "PPCII", "::", "PPC970_Pseudo", ")", "return", "NoHazard", ";", "if", "(", "NumIssued", "!=", "0", "&&", "(", "isFirst", "||", "isSingle", ")", ")", "return", "Hazard", ";", "if", "(", "isCracked", "&&", "NumIssued", ">", "2", ")", "return", "Hazard", ";", "switch", "(", "InstrType", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown instruction type!\"", ")", ";", "case", "PPCII", "::", "PPC970_FXU", ":", "case", "PPCII", "::", "PPC970_LSU", ":", "case", "PPCII", "::", "PPC970_FPU", ":", "case", "PPCII", "::", "PPC970_VALU", ":", "case", "PPCII", "::", "PPC970_VPERM", ":", "if", "(", "NumIssued", "==", "4", ")", "return", "Hazard", ";", "break", ";", "case", "PPCII", "::", "PPC970_CRU", ":", "if", "(", "NumIssued", ">=", "2", ")", "return", "Hazard", ";", "break", ";", "case", "PPCII", "::", "PPC970_BRU", ":", "break", ";", "}", "if", "(", "HasCTRSet", "&&", "(", "Opcode", "==", "PPC", "::", "BCTRL_Darwin", "||", "Opcode", "==", "PPC", "::", "BCTRL_SVR4", ")", ")", "return", "NoopHazard", ";", "if", "(", "isLoad", "&&", "NumStores", "&&", "!", "MI", "->", "memoperands_empty", "(", ")", ")", "{", "MachineMemOperand", "*", "MO", "=", "*", "MI", "->", "memoperands_begin", "(", ")", ";", "if", "(", "isLoadOfStoredAddress", "(", "MO", "->", "getSize", "(", ")", ",", "MO", "->", "getOffset", "(", ")", ",", "MO", "->", "getValue", "(", ")", ")", ")", "return", "NoopHazard", ";", "}", "return", "NoHazard", ";", "}", "</s>" ]

[ "getHazardType", "-", "Return", "the", "hazard", "type", "of", "emitting", "this", "node", "." ]

[ "PowerPC", "PPC", "0", "\"PPC hazards don't support scoreboard lookahead\"", "PPC::NOP", "PPCII::PPC970_Unit", "PPCII::PPC970_Pseudo", "0", "2", "\"Unknown instruction type!\"", "PPCII::PPC970_FXU", "PPCII::PPC970_LSU", "PPCII::PPC970_FPU", "PPCII::PPC970_VALU", "PPCII::PPC970_VPERM", "4", "PPCII::PPC970_CRU", "2", "PPCII::PPC970_BRU", "PPC::BCTRL_Darwin", "PPC::BCTRL_SVR4" ]

[]

[ "<s>", "static", "int", "ix86_issue_rate", "(", "void", ")", "{", "switch", "(", "ix86_tune", ")", "{", "case", "PROCESSOR_PENTIUM", ":", "case", "PROCESSOR_LAKEMONT", ":", "case", "PROCESSOR_BONNELL", ":", "case", "PROCESSOR_SILVERMONT", ":", "case", "PROCESSOR_KNL", ":", "case", "PROCESSOR_INTEL", ":", "case", "PROCESSOR_K6", ":", "case", "PROCESSOR_BTVER2", ":", "case", "PROCESSOR_PENTIUM4", ":", "case", "PROCESSOR_NOCONA", ":", "return", "2", ";", "case", "PROCESSOR_PENTIUMPRO", ":", "case", "PROCESSOR_ATHLON", ":", "case", "PROCESSOR_K8", ":", "case", "PROCESSOR_AMDFAM10", ":", "case", "PROCESSOR_GENERIC", ":", "case", "PROCESSOR_BTVER1", ":", "return", "3", ";", "case", "PROCESSOR_BDVER1", ":", "case", "PROCESSOR_BDVER2", ":", "case", "PROCESSOR_BDVER3", ":", "case", "PROCESSOR_BDVER4", ":", "case", "PROCESSOR_ZNVER1", ":", "case", "PROCESSOR_CORE2", ":", "case", "PROCESSOR_NEHALEM", ":", "case", "PROCESSOR_SANDYBRIDGE", ":", "case", "PROCESSOR_HASWELL", ":", "return", "4", ";", "default", ":", "return", "1", ";", "}", "}", "</s>" ]

[ "Return", "the", "maximum", "number", "of", "instructions", "a", "cpu", "can", "issue", "." ]

[ "i386", "2", "3", "4", "1" ]

[]

[ "<s>", "DecodeStatus", "SparcDisassembler", "::", "getInstruction", "(", "MCInst", "&", "Instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "VStream", ",", "raw_ostream", "&", "CStream", ")", "const", "{", "uint32_t", "Insn", ";", "DecodeStatus", "Result", "=", "readInstruction32", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableSparc32", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "4", ";", "return", "Result", ";", "}", "return", "MCDisassembler", "::", "Fail", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "Sparc", "4" ]

[]

[ "<s>", "virtual", "void", "EmitInstruction", "(", "const", "MCInst", "&", "Inst", ")", "{", "const", "MCInstrDesc", "&", "MID", "=", "MII", ".", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ";", "count", "++", ";", "size", "+=", "MID", ".", "getSize", "(", ")", ";", "call", "|=", "MID", ".", "isCall", "(", ")", ";", "}", "</s>" ]

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

[ "Patmos" ]

[]

[ "<s>", "int", "registers_ok_for_ldd_peep", "(", "rtx", "reg1", ",", "rtx", "reg2", ")", "{", "if", "(", "GET_CODE", "(", "reg1", ")", "!=", "REG", "||", "GET_CODE", "(", "reg2", ")", "!=", "REG", ")", "return", "0", ";", "if", "(", "REGNO", "(", "reg1", ")", "%", "2", "!=", "0", ")", "return", "0", ";", "if", "(", "TARGET_V9", "&&", "REGNO", "(", "reg1", ")", "<", "32", ")", "return", "0", ";", "return", "(", "REGNO", "(", "reg1", ")", "==", "REGNO", "(", "reg2", ")", "-", "1", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "REGNO", "(", "reg1", ")", "is", "even", "and", "REGNO", "(", "reg1", ")", "==", "REGNO", "(", "reg2", ")", "-", "1", ".", "This", "makes", "them", "candidates", "for", "using", "ldd", "and", "std", "insns", ".", "Note", "reg1", "and", "reg2", "*", "must", "*", "be", "hard", "registers", "." ]

[ "sparc", "0", "2", "0", "0", "32", "0", "1" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "SimplifyDemandedBitsForTargetNode", "(", "SDValue", "Op", ",", "const", "APInt", "&", "OriginalDemandedBits", ",", "const", "APInt", "&", "OriginalDemandedElts", ",", "KnownBits", "&", "Known", ",", "TargetLoweringOpt", "&", "TLO", ",", "unsigned", "Depth", ")", "const", "{", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "ARMISD", "::", "ASRL", ":", "case", "ARMISD", "::", "LSRL", ":", "{", "if", "(", "Op", ".", "getResNo", "(", ")", "==", "0", "&&", "!", "Op", "->", "hasAnyUseOfValue", "(", "1", ")", "&&", "isa", "<", "ConstantSDNode", ">", "(", "Op", "->", "getOperand", "(", "2", ")", ")", ")", "{", "unsigned", "ShAmt", "=", "Op", "->", "getConstantOperandVal", "(", "2", ")", ";", "if", "(", "ShAmt", "<", "32", "&&", "OriginalDemandedBits", ".", "isSubsetOf", "(", "APInt", "::", "getAllOnesValue", "(", "32", ")", "<<", "(", "32", "-", "ShAmt", ")", ")", ")", "return", "TLO", ".", "CombineTo", "(", "Op", ",", "TLO", ".", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "SDLoc", "(", "Op", ")", ",", "MVT", "::", "i32", ",", "Op", ".", "getOperand", "(", "1", ")", ",", "TLO", ".", "DAG", ".", "getConstant", "(", "32", "-", "ShAmt", ",", "SDLoc", "(", "Op", ")", ",", "MVT", "::", "i32", ")", ")", ")", ";", "}", "break", ";", "}", "}", "return", "TargetLowering", "::", "SimplifyDemandedBitsForTargetNode", "(", "Op", ",", "OriginalDemandedBits", ",", "OriginalDemandedElts", ",", "Known", ",", "TLO", ",", "Depth", ")", ";", "}", "</s>" ]

[ "Attempt", "to", "simplify", "any", "target", "nodes", "based", "on", "the", "demanded", "bits/elts", ",", "returning", "true", "on", "success", "." ]

[ "ARM", "ARM", "ARMISD::ASRL", "ARMISD::LSRL", "0", "1", "2", "2", "32", "32", "32", "ISD::SHL", "MVT::i32", "1", "32", "MVT::i32" ]

[]

[ "<s>", "const", "TargetRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "XCore" ]

[]

[ "<s>", "StackOffset", "RISCVFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "auto", "*", "RVFI", "=", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "const", "auto", "&", "CSI", "=", "getNonLibcallCSI", "(", "MFI", ".", "getCalleeSavedInfo", "(", ")", ")", ";", "int", "MinCSFI", "=", "0", ";", "int", "MaxCSFI", "=", "-", "1", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", "-", "getOffsetOfLocalArea", "(", ")", "+", "MFI", ".", "getOffsetAdjustment", "(", ")", ";", "uint64_t", "FirstSPAdjustAmount", "=", "getFirstSPAdjustAmount", "(", "MF", ")", ";", "if", "(", "CSI", ".", "size", "(", ")", ")", "{", "MinCSFI", "=", "CSI", "[", "0", "]", ".", "getFrameIdx", "(", ")", ";", "MaxCSFI", "=", "CSI", "[", "CSI", ".", "size", "(", ")", "-", "1", "]", ".", "getFrameIdx", "(", ")", ";", "}", "if", "(", "FI", ">=", "MinCSFI", "&&", "FI", "<=", "MaxCSFI", ")", "{", "FrameReg", "=", "RISCV", "::", "X2", ";", "if", "(", "FirstSPAdjustAmount", ")", "Offset", "+=", "FirstSPAdjustAmount", ";", "else", "Offset", "+=", "MFI", ".", "getStackSize", "(", ")", ";", "}", "else", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", "&&", "!", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", ")", "{", "if", "(", "hasBP", "(", "MF", ")", ")", "FrameReg", "=", "RISCVABI", "::", "getBPReg", "(", ")", ";", "else", "FrameReg", "=", "RISCV", "::", "X2", ";", "Offset", "+=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "FI", "<", "0", ")", "Offset", "+=", "RVFI", "->", "getLibCallStackSize", "(", ")", ";", "}", "else", "{", "FrameReg", "=", "RI", "->", "getFrameRegister", "(", "MF", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "Offset", "+=", "RVFI", "->", "getVarArgsSaveSize", "(", ")", ";", "if", "(", "FI", ">=", "0", ")", "Offset", "-=", "RVFI", "->", "getLibCallStackSize", "(", ")", ";", "}", "else", "{", "Offset", "+=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "FI", "<", "0", ")", "Offset", "+=", "RVFI", "->", "getLibCallStackSize", "(", ")", ";", "}", "}", "return", "StackOffset", "::", "getFixed", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "0", "1", "0", "1", "RISCV::X2", "RISCVABI::getBPReg", "RISCV::X2", "0", "0", "0" ]

[]

[ "<s>", "char", "*", "aarch64_output_sve_addvl_addpl", "(", "rtx", "dest", ",", "rtx", "base", ",", "rtx", "offset", ")", "{", "static", "char", "buffer", "[", "sizeof", "(", "\"addpl\\t%x0, %x1, #-\"", ")", "+", "3", "*", "sizeof", "(", "int", ")", "]", ";", "poly_int64", "offset_value", "=", "rtx_to_poly_int64", "(", "offset", ")", ";", "gcc_assert", "(", "aarch64_sve_addvl_addpl_immediate_p", "(", "offset_value", ")", ")", ";", "if", "(", "rtx_equal_p", "(", "dest", ",", "base", ")", "&&", "GP_REGNUM_P", "(", "REGNO", "(", "dest", ")", ")", ")", "{", "if", "(", "aarch64_sve_cnt_immediate_p", "(", "offset_value", ")", ")", "return", "aarch64_output_sve_cnt_immediate", "(", "\"inc\"", ",", "\"%x0\"", ",", "offset_value", ".", "coeffs", "[", "1", "]", ",", "0", ")", ";", "if", "(", "aarch64_sve_cnt_immediate_p", "(", "-", "offset_value", ")", ")", "return", "aarch64_output_sve_cnt_immediate", "(", "\"dec\"", ",", "\"%x0\"", ",", "-", "offset_value", ".", "coeffs", "[", "1", "]", ",", "0", ")", ";", "}", "int", "factor", "=", "offset_value", ".", "coeffs", "[", "1", "]", ";", "if", "(", "(", "factor", "&", "15", ")", "==", "0", ")", "snprintf", "(", "buffer", ",", "sizeof", "(", "buffer", ")", ",", "\"addvl\\t%%x0, %%x1, #%d\"", ",", "factor", "/", "16", ")", ";", "else", "snprintf", "(", "buffer", ",", "sizeof", "(", "buffer", ")", ",", "\"addpl\\t%%x0, %%x1, #%d\"", ",", "factor", "/", "2", ")", ";", "return", "buffer", ";", "}", "</s>" ]

[ "Return", "the", "asm", "string", "for", "adding", "ADDVL", "or", "ADDPL", "immediate", "X", "to", "operand", "1", "and", "storing", "the", "result", "in", "operand", "0", "." ]

[ "aarch64", "\"addpl\\t%x0, %x1, #-\"", "3", "\"inc\"", "\"%x0\"", "1", "0", "\"dec\"", "\"%x0\"", "1", "0", "1", "15", "0", "\"addvl\\t%%x0, %%x1, #%d\"", "16", "\"addpl\\t%%x0, %%x1, #%d\"", "2" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "XCoreInstrInfo", "::", "loadImmediate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "Reg", ",", "uint64_t", "Value", ")", "const", "{", "DebugLoc", "dl", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "isMask_32", "(", "Value", ")", ")", "{", "int", "N", "=", "Log2_32", "(", "Value", ")", "+", "1", ";", "return", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "XCore", "::", "MKMSK_rus", ")", ",", "Reg", ")", ".", "addImm", "(", "N", ")", ";", "}", "if", "(", "isImmU16", "(", "Value", ")", ")", "{", "int", "Opcode", "=", "isImmU6", "(", "Value", ")", "?", "XCore", "::", "LDC_ru6", ":", "XCore", "::", "LDC_lru6", ";", "return", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "Opcode", ")", ",", "Reg", ")", ".", "addImm", "(", "Value", ")", ";", "}", "MachineConstantPool", "*", "ConstantPool", "=", "MBB", ".", "getParent", "(", ")", "->", "getConstantPool", "(", ")", ";", "const", "Constant", "*", "C", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ")", ",", "Value", ")", ";", "unsigned", "Idx", "=", "ConstantPool", "->", "getConstantPoolIndex", "(", "C", ",", "4", ")", ";", "return", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "XCore", "::", "LDWCP_lru6", ")", ",", "Reg", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ";", "}", "</s>" ]

[ "Emit", "a", "series", "of", "instructions", "to", "load", "an", "immediate", "." ]

[ "XCore", "XCore", "1", "XCore::MKMSK_rus", "XCore::LDC_ru6", "XCore::LDC_lru6", "4", "XCore::LDWCP_lru6" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "hasVFP3", "(", ")", ")", "return", "false", ";", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "ARM", "::", "getVFPf32Imm", "(", "Imm", ")", "!=", "-", "1", ";", "if", "(", "VT", "==", "MVT", "::", "f64", ")", "return", "ARM", "::", "getVFPf64Imm", "(", "Imm", ")", "!=", "-", "1", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "can", "instruction", "select", "the", "specified", "FP", "immediate", "natively", "." ]

[ "ARM", "ARM", "MVT::f32", "ARM::getVFPf32Imm", "1", "MVT::f64", "ARM::getVFPf64Imm", "1" ]

[]

[ "<s>", "static", "void", "ia64_globalize_decl_name", "(", "FILE", "*", "stream", ",", "tree", "decl", ")", "{", "const", "char", "*", "name", "=", "XSTR", "(", "XEXP", "(", "DECL_RTL", "(", "decl", ")", ",", "0", ")", ",", "0", ")", ";", "tree", "version_attr", "=", "lookup_attribute", "(", "\"version_id\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ";", "if", "(", "version_attr", ")", "{", "tree", "v", "=", "TREE_VALUE", "(", "TREE_VALUE", "(", "version_attr", ")", ")", ";", "const", "char", "*", "p", "=", "TREE_STRING_POINTER", "(", "v", ")", ";", "fprintf", "(", "stream", ",", "\"\\t.alias %s#, \\\"%s{%s}\\\"\\n\"", ",", "name", ",", "name", ",", "p", ")", ";", "}", "targetm", ".", "asm_out", ".", "globalize_label", "(", "stream", ",", "name", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "ASM_OUTPUT_TYPE_DIRECTIVE", "(", "stream", ",", "name", ",", "\"function\"", ")", ";", "}", "</s>" ]

[ "Globalize", "a", "declaration", "." ]

[ "ia64", "0", "0", "\"version_id\"", "\"\\t.alias %s#, \\\"%s{%s}\\\"\\n\"", "\"function\"" ]

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "emitDebugValue", "(", "const", "MCExpr", "*", "Value", ",", "unsigned", "Size", ")", "const", "{", "if", "(", "auto", "*", "MipsExpr", "=", "dyn_cast", "<", "MipsMCExpr", ">", "(", "Value", ")", ")", "{", "if", "(", "MipsExpr", "&&", "MipsExpr", "->", "getKind", "(", ")", "==", "MipsMCExpr", "::", "MEK_DTPREL", ")", "{", "switch", "(", "Size", ")", "{", "case", "4", ":", "OutStreamer", "->", "emitDTPRel32Value", "(", "MipsExpr", "->", "getSubExpr", "(", ")", ")", ";", "break", ";", "case", "8", ":", "OutStreamer", "->", "emitDTPRel64Value", "(", "MipsExpr", "->", "getSubExpr", "(", ")", ")", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Unexpected size of expression value.\"", ")", ";", "}", "return", ";", "}", "}", "AsmPrinter", "::", "emitDebugValue", "(", "Value", ",", "Size", ")", ";", "}", "</s>" ]

[ "Emit", "the", "directive", "and", "value", "for", "debug", "thread", "local", "expression", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "4", "Mips", "8", "Mips", "\"Unexpected size of expression value.\"" ]

[]

[ "<s>", "unsigned", "getReturnOpcode", "(", ")", "const", "{", "if", "(", "isThumb", "(", ")", ")", "return", "ARM", "::", "tBX_RET", ";", "if", "(", "hasV4TOps", "(", ")", ")", "return", "ARM", "::", "BX_RET", ";", "return", "ARM", "::", "MOVPCLR", ";", "}", "</s>" ]

[ "Returns", "the", "correct", "return", "opcode", "for", "the", "current", "feature", "set", "." ]

[ "ARM", "ARM::tBX_RET", "ARM::BX_RET", "ARM::MOVPCLR" ]

[]

[ "<s>", "void", "WDC65816TargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "return", "LowerOperationWrapper", "(", "N", ",", "Results", ",", "DAG", ")", ";", "}", "</s>" ]

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

[ "WDC65816", "WDC" ]

[]

[ "<s>", "const", "char", "*", "CSKYTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown CSKYISD node\"", ")", ";", "case", "CSKYISD", "::", "NIE", ":", "return", "\"CSKYISD::NIE\"", ";", "case", "CSKYISD", "::", "NIR", ":", "return", "\"CSKYISD::NIR\"", ";", "case", "CSKYISD", "::", "RET", ":", "return", "\"CSKYISD::RET\"", ";", "case", "CSKYISD", "::", "CALL", ":", "return", "\"CSKYISD::CALL\"", ";", "case", "CSKYISD", "::", "CALLReg", ":", "return", "\"CSKYISD::CALLReg\"", ";", "case", "CSKYISD", "::", "TAIL", ":", "return", "\"CSKYISD::TAIL\"", ";", "case", "CSKYISD", "::", "TAILReg", ":", "return", "\"CSKYISD::TAILReg\"", ";", "case", "CSKYISD", "::", "LOAD_ADDR", ":", "return", "\"CSKYISD::LOAD_ADDR\"", ";", "case", "CSKYISD", "::", "BITCAST_TO_LOHI", ":", "return", "\"CSKYISD::BITCAST_TO_LOHI\"", ";", "case", "CSKYISD", "::", "BITCAST_FROM_LOHI", ":", "return", "\"CSKYISD::BITCAST_FROM_LOHI\"", ";", "}", "}", "</s>" ]

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

[ "CSKY", "CSKY", "\"unknown CSKYISD node\"", "CSKYISD::NIE", "\"CSKYISD::NIE\"", "CSKYISD::NIR", "\"CSKYISD::NIR\"", "CSKYISD::RET", "\"CSKYISD::RET\"", "CSKYISD::CALL", "\"CSKYISD::CALL\"", "CSKYISD::CALLReg", "\"CSKYISD::CALLReg\"", "CSKYISD::TAIL", "\"CSKYISD::TAIL\"", "CSKYISD::TAILReg", "\"CSKYISD::TAILReg\"", "CSKYISD::LOAD_ADDR", "\"CSKYISD::LOAD_ADDR\"", "CSKYISD::BITCAST_TO_LOHI", "\"CSKYISD::BITCAST_TO_LOHI\"", "CSKYISD::BITCAST_FROM_LOHI", "\"CSKYISD::BITCAST_FROM_LOHI\"" ]

[]

[ "<s>", "void", "WebAssemblyAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"EmitInstruction: \"", "<<", "*", "MI", "<<", "'\\n'", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "ARGUMENT_i32", ":", "case", "WebAssembly", "::", "ARGUMENT_i32_S", ":", "case", "WebAssembly", "::", "ARGUMENT_i64", ":", "case", "WebAssembly", "::", "ARGUMENT_i64_S", ":", "case", "WebAssembly", "::", "ARGUMENT_f32", ":", "case", "WebAssembly", "::", "ARGUMENT_f32_S", ":", "case", "WebAssembly", "::", "ARGUMENT_f64", ":", "case", "WebAssembly", "::", "ARGUMENT_f64_S", ":", "case", "WebAssembly", "::", "ARGUMENT_v16i8", ":", "case", "WebAssembly", "::", "ARGUMENT_v16i8_S", ":", "case", "WebAssembly", "::", "ARGUMENT_v8i16", ":", "case", "WebAssembly", "::", "ARGUMENT_v8i16_S", ":", "case", "WebAssembly", "::", "ARGUMENT_v4i32", ":", "case", "WebAssembly", "::", "ARGUMENT_v4i32_S", ":", "case", "WebAssembly", "::", "ARGUMENT_v2i64", ":", "case", "WebAssembly", "::", "ARGUMENT_v2i64_S", ":", "case", "WebAssembly", "::", "ARGUMENT_v4f32", ":", "case", "WebAssembly", "::", "ARGUMENT_v4f32_S", ":", "case", "WebAssembly", "::", "ARGUMENT_v2f64", ":", "case", "WebAssembly", "::", "ARGUMENT_v2f64_S", ":", "break", ";", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_I32", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_I32_S", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_I64", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_I64_S", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_F32", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_F32_S", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_F64", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_F64_S", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v16i8", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v16i8_S", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v8i16", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v8i16_S", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v4i32", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v4i32_S", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v2i64", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v2i64_S", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v4f32", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v4f32_S", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v2f64", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v2f64_S", ":", "{", "if", "(", "isVerbose", "(", ")", ")", "{", "OutStreamer", "->", "AddComment", "(", "\"fallthrough-return-value\"", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "break", ";", "}", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_VOID", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_VOID_S", ":", "if", "(", "isVerbose", "(", ")", ")", "{", "OutStreamer", "->", "AddComment", "(", "\"fallthrough-return-void\"", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "break", ";", "case", "WebAssembly", "::", "EXTRACT_EXCEPTION_I32", ":", "case", "WebAssembly", "::", "EXTRACT_EXCEPTION_I32_S", ":", "if", "(", "!", "WasmKeepRegisters", ")", "break", ";", "LLVM_FALLTHROUGH", ";", "default", ":", "{", "WebAssemblyMCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"EmitInstruction: \"", "WebAssembly::ARGUMENT_i32", "WebAssembly::ARGUMENT_i32_S", "WebAssembly::ARGUMENT_i64", "WebAssembly::ARGUMENT_i64_S", "WebAssembly::ARGUMENT_f32", "WebAssembly::ARGUMENT_f32_S", "WebAssembly::ARGUMENT_f64", "WebAssembly::ARGUMENT_f64_S", "WebAssembly::ARGUMENT_v16i8", "WebAssembly::ARGUMENT_v16i8_S", "WebAssembly::ARGUMENT_v8i16", "WebAssembly::ARGUMENT_v8i16_S", "WebAssembly::ARGUMENT_v4i32", "WebAssembly::ARGUMENT_v4i32_S", "WebAssembly::ARGUMENT_v2i64", "WebAssembly::ARGUMENT_v2i64_S", "WebAssembly::ARGUMENT_v4f32", "WebAssembly::ARGUMENT_v4f32_S", "WebAssembly::ARGUMENT_v2f64", "WebAssembly::ARGUMENT_v2f64_S", "WebAssembly::FALLTHROUGH_RETURN_I32", "WebAssembly::FALLTHROUGH_RETURN_I32_S", "WebAssembly::FALLTHROUGH_RETURN_I64", "WebAssembly::FALLTHROUGH_RETURN_I64_S", "WebAssembly::FALLTHROUGH_RETURN_F32", "WebAssembly::FALLTHROUGH_RETURN_F32_S", "WebAssembly::FALLTHROUGH_RETURN_F64", "WebAssembly::FALLTHROUGH_RETURN_F64_S", "WebAssembly::FALLTHROUGH_RETURN_v16i8", "WebAssembly::FALLTHROUGH_RETURN_v16i8_S", "WebAssembly::FALLTHROUGH_RETURN_v8i16", "WebAssembly::FALLTHROUGH_RETURN_v8i16_S", "WebAssembly::FALLTHROUGH_RETURN_v4i32", "WebAssembly::FALLTHROUGH_RETURN_v4i32_S", "WebAssembly::FALLTHROUGH_RETURN_v2i64", "WebAssembly::FALLTHROUGH_RETURN_v2i64_S", "WebAssembly::FALLTHROUGH_RETURN_v4f32", "WebAssembly::FALLTHROUGH_RETURN_v4f32_S", "WebAssembly::FALLTHROUGH_RETURN_v2f64", "WebAssembly::FALLTHROUGH_RETURN_v2f64_S", "\"fallthrough-return-value\"", "WebAssembly::FALLTHROUGH_RETURN_VOID", "WebAssembly::FALLTHROUGH_RETURN_VOID_S", "\"fallthrough-return-void\"", "WebAssembly::EXTRACT_EXCEPTION_I32", "WebAssembly::EXTRACT_EXCEPTION_I32_S", "WebAssembly" ]

[]

[ "<s>", "bool", "hasFusion", "(", ")", "const", "{", "return", "HasFusion", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "CPU", "supports", "any", "kind", "of", "instruction", "fusion", "." ]

[ "PowerPC" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isValidOffset", "(", "const", "int", "Opcode", ",", "const", "int", "Offset", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "Hexagon", "::", "LDriw", ":", "case", "Hexagon", "::", "LDriw_indexed", ":", "case", "Hexagon", "::", "LDriw_f", ":", "case", "Hexagon", "::", "STriw_indexed", ":", "case", "Hexagon", "::", "STriw", ":", "case", "Hexagon", "::", "STriw_f", ":", "assert", "(", "(", "Offset", "%", "4", "==", "0", ")", "&&", "\"Offset has incorrect alignment\"", ")", ";", "return", "(", "Offset", ">=", "Hexagon_MEMW_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMW_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "LDrid", ":", "case", "Hexagon", "::", "LDrid_indexed", ":", "case", "Hexagon", "::", "LDrid_f", ":", "case", "Hexagon", "::", "STrid", ":", "case", "Hexagon", "::", "STrid_indexed", ":", "case", "Hexagon", "::", "STrid_f", ":", "assert", "(", "(", "Offset", "%", "8", "==", "0", ")", "&&", "\"Offset has incorrect alignment\"", ")", ";", "return", "(", "Offset", ">=", "Hexagon_MEMD_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMD_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "LDrih", ":", "case", "Hexagon", "::", "LDriuh", ":", "case", "Hexagon", "::", "STrih", ":", "assert", "(", "(", "Offset", "%", "2", "==", "0", ")", "&&", "\"Offset has incorrect alignment\"", ")", ";", "return", "(", "Offset", ">=", "Hexagon_MEMH_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMH_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "LDrib", ":", "case", "Hexagon", "::", "STrib", ":", "case", "Hexagon", "::", "LDriub", ":", "return", "(", "Offset", ">=", "Hexagon_MEMB_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMB_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "ADD_ri", ":", "case", "Hexagon", "::", "TFR_FI", ":", "return", "(", "Offset", ">=", "Hexagon_ADDI_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_ADDI_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "MEMw_ADDi_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_SUBi_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_ADDr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_SUBr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_ANDr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_ORr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_ADDi_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_SUBi_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_ADDr_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_SUBr_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_ANDr_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_ORr_MEM_V4", ":", "assert", "(", "(", "Offset", "%", "4", ")", "==", "0", "&&", "\"MEMOPw offset is not aligned correctly.\"", ")", ";", "return", "(", "0", "<=", "Offset", "&&", "Offset", "<=", "255", ")", ";", "case", "Hexagon", "::", "MEMh_ADDi_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_SUBi_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_ADDr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_SUBr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_ANDr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_ORr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_ADDi_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_SUBi_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_ADDr_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_SUBr_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_ANDr_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_ORr_MEM_V4", ":", "assert", "(", "(", "Offset", "%", "2", ")", "==", "0", "&&", "\"MEMOPh offset is not aligned correctly.\"", ")", ";", "return", "(", "0", "<=", "Offset", "&&", "Offset", "<=", "127", ")", ";", "case", "Hexagon", "::", "MEMb_ADDi_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_SUBi_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_ADDr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_SUBr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_ANDr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_ORr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_ADDi_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_SUBi_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_ADDr_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_SUBr_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_ANDr_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_ORr_MEM_V4", ":", "return", "(", "0", "<=", "Offset", "&&", "Offset", "<=", "63", ")", ";", "case", "Hexagon", "::", "STriw_pred", ":", "case", "Hexagon", "::", "LDriw_pred", ":", "return", "true", ";", "case", "Hexagon", "::", "LOOP0_i", ":", "return", "isUInt", "<", "10", ">", "(", "Offset", ")", ";", "case", "Hexagon", "::", "INLINEASM", ":", "return", "true", ";", "}", "llvm_unreachable", "(", "\"No offset range is defined for this opcode. \"", "\"Please define it in the above switch statement!\"", ")", ";", "}", "</s>" ]

[ "Test", "the", "validity", "of", "offset", "." ]

[ "Hexagon", "Hexagon", "Hexagon::LDriw", "Hexagon::LDriw_indexed", "Hexagon::LDriw_f", "Hexagon::STriw_indexed", "Hexagon::STriw", "Hexagon::STriw_f", "4", "0", "\"Offset has incorrect alignment\"", "Hexagon", "Hexagon", "Hexagon::LDrid", "Hexagon::LDrid_indexed", "Hexagon::LDrid_f", "Hexagon::STrid", "Hexagon::STrid_indexed", "Hexagon::STrid_f", "8", "0", "\"Offset has incorrect alignment\"", "Hexagon", "Hexagon", "Hexagon::LDrih", "Hexagon::LDriuh", "Hexagon::STrih", "2", "0", "\"Offset has incorrect alignment\"", "Hexagon", "Hexagon", "Hexagon::LDrib", "Hexagon::STrib", "Hexagon::LDriub", "Hexagon", "Hexagon", "Hexagon::ADD_ri", "Hexagon::TFR_FI", "Hexagon", "Hexagon", "Hexagon::MEMw_ADDi_indexed_MEM_V4", "Hexagon::MEMw_SUBi_indexed_MEM_V4", "Hexagon::MEMw_ADDr_indexed_MEM_V4", "Hexagon::MEMw_SUBr_indexed_MEM_V4", "Hexagon::MEMw_ANDr_indexed_MEM_V4", "Hexagon::MEMw_ORr_indexed_MEM_V4", "Hexagon::MEMw_ADDi_MEM_V4", "Hexagon::MEMw_SUBi_MEM_V4", "Hexagon::MEMw_ADDr_MEM_V4", "Hexagon::MEMw_SUBr_MEM_V4", "Hexagon::MEMw_ANDr_MEM_V4", "Hexagon::MEMw_ORr_MEM_V4", "4", "0", "\"MEMOPw offset is not aligned correctly.\"", "0", "255", "Hexagon::MEMh_ADDi_indexed_MEM_V4", "Hexagon::MEMh_SUBi_indexed_MEM_V4", "Hexagon::MEMh_ADDr_indexed_MEM_V4", "Hexagon::MEMh_SUBr_indexed_MEM_V4", "Hexagon::MEMh_ANDr_indexed_MEM_V4", "Hexagon::MEMh_ORr_indexed_MEM_V4", "Hexagon::MEMh_ADDi_MEM_V4", "Hexagon::MEMh_SUBi_MEM_V4", "Hexagon::MEMh_ADDr_MEM_V4", "Hexagon::MEMh_SUBr_MEM_V4", "Hexagon::MEMh_ANDr_MEM_V4", "Hexagon::MEMh_ORr_MEM_V4", "2", "0", "\"MEMOPh offset is not aligned correctly.\"", "0", "127", "Hexagon::MEMb_ADDi_indexed_MEM_V4", "Hexagon::MEMb_SUBi_indexed_MEM_V4", "Hexagon::MEMb_ADDr_indexed_MEM_V4", "Hexagon::MEMb_SUBr_indexed_MEM_V4", "Hexagon::MEMb_ANDr_indexed_MEM_V4", "Hexagon::MEMb_ORr_indexed_MEM_V4", "Hexagon::MEMb_ADDi_MEM_V4", "Hexagon::MEMb_SUBi_MEM_V4", "Hexagon::MEMb_ADDr_MEM_V4", "Hexagon::MEMb_SUBr_MEM_V4", "Hexagon::MEMb_ANDr_MEM_V4", "Hexagon::MEMb_ORr_MEM_V4", "0", "63", "Hexagon::STriw_pred", "Hexagon::LDriw_pred", "Hexagon::LOOP0_i", "10", "Hexagon::INLINEASM", "\"No offset range is defined for this opcode. \"", "\"Please define it in the above switch statement!\"" ]

[]

[ "<s>", "SDValue", "Z80TargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"LowerOperation: \"", ";", "Op", "->", "dump", "(", "&", "DAG", ")", ")", ";", "assert", "(", "Op", ".", "getResNo", "(", ")", "==", "0", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to lower this operation.\"", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "AND", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "XOR", ":", "return", "LowerBitwise", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "ROTL", ":", "case", "ISD", "::", "ROTR", ":", "return", "LowerShift", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ANY_EXTEND", ":", "return", "LowerAnyExtend", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "LowerZeroExtend", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "LowerSignExtend", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "LowerMul", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "cast", "<", "GlobalAddressSDNode", ">", "(", "Op", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "ExternalSymbol", ":", "return", "LowerExternalSymbol", "(", "cast", "<", "ExternalSymbolSDNode", ">", "(", "Op", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "cast", "<", "BlockAddressSDNode", ">", "(", "Op", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLoad", "(", "cast", "<", "LoadSDNode", ">", "(", "Op", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerStore", "(", "cast", "<", "StoreSDNode", ">", "(", "Op", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVAStart", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "Z80", "Z80", "\"LowerOperation: \"", "0", "\"Don't know how to lower this operation.\"", "ISD::BR_CC", "ISD::SELECT_CC", "ISD::AND", "ISD::OR", "ISD::XOR", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::ROTL", "ISD::ROTR", "ISD::ANY_EXTEND", "ISD::ZERO_EXTEND", "ISD::SIGN_EXTEND", "ISD::MUL", "ISD::GlobalAddress", "ISD::ExternalSymbol", "ISD::BlockAddress", "ISD::LOAD", "ISD::STORE", "ISD::VASTART" ]

[]

[ "<s>", "bool", "PPCLinuxAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "const", "DataLayout", "&", "DL", "=", "getDataLayout", "(", ")", ";", "bool", "isPPC64", "=", "DL", ".", "getPointerSizeInBits", "(", ")", "==", "64", ";", "PPCTargetStreamer", "&", "TS", "=", "static_cast", "<", "PPCTargetStreamer", "&", ">", "(", "*", "OutStreamer", "->", "getTargetStreamer", "(", ")", ")", ";", "if", "(", "!", "TOC", ".", "empty", "(", ")", ")", "{", "MCSectionELF", "*", "Section", ";", "if", "(", "isPPC64", ")", "Section", "=", "OutStreamer", "->", "getContext", "(", ")", ".", "getELFSection", "(", "\".toc\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "else", "Section", "=", "OutStreamer", "->", "getContext", "(", ")", ".", "getELFSection", "(", "\".got2\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "Section", ")", ";", "for", "(", "const", "auto", "&", "TOCMapPair", ":", "TOC", ")", "{", "const", "MCSymbol", "*", "const", "TOCEntryTarget", "=", "TOCMapPair", ".", "first", ";", "MCSymbol", "*", "const", "TOCEntryLabel", "=", "TOCMapPair", ".", "second", ";", "OutStreamer", "->", "emitLabel", "(", "TOCEntryLabel", ")", ";", "if", "(", "isPPC64", ")", "{", "TS", ".", "emitTCEntry", "(", "*", "TOCEntryTarget", ")", ";", "}", "else", "{", "OutStreamer", "->", "emitValueToAlignment", "(", "4", ")", ";", "OutStreamer", "->", "emitSymbolValue", "(", "TOCEntryTarget", ",", "4", ")", ";", "}", "}", "}", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "64", "PPC", "PPC", "PPC", "\".toc\"", "\".got2\"", "PPC", "4", "4" ]

[]

[ "<s>", "static", "rtx", "rs6000_darwin64_record_arg", "(", "CUMULATIVE_ARGS", "*", "orig_cum", ",", "tree", "type", ",", "int", "named", ",", "bool", "retval", ")", "{", "rtx", "rvec", "[", "FIRST_PSEUDO_REGISTER", "]", ";", "int", "k", "=", "1", ",", "kbase", "=", "1", ";", "HOST_WIDE_INT", "typesize", "=", "int_size_in_bytes", "(", "type", ")", ";", "CUMULATIVE_ARGS", "copy_cum", "=", "*", "orig_cum", ";", "CUMULATIVE_ARGS", "*", "cum", "=", "&", "copy_cum", ";", "if", "(", "!", "retval", "&&", "TYPE_ALIGN", "(", "type", ")", ">=", "2", "*", "BITS_PER_WORD", "&&", "(", "cum", "->", "words", "%", "2", ")", "!=", "0", ")", "cum", "->", "words", "++", ";", "cum", "->", "intoffset", "=", "0", ";", "cum", "->", "use_stack", "=", "0", ";", "cum", "->", "named", "=", "named", ";", "rs6000_darwin64_record_arg_recurse", "(", "cum", ",", "type", ",", "0", ",", "rvec", ",", "&", "k", ")", ";", "rs6000_darwin64_record_arg_flush", "(", "cum", ",", "typesize", "*", "BITS_PER_UNIT", ",", "rvec", ",", "&", "k", ")", ";", "if", "(", "cum", "->", "use_stack", ")", "{", "if", "(", "retval", ")", "return", "NULL_RTX", ";", "kbase", "=", "0", ";", "rvec", "[", "0", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "NULL_RTX", ",", "const0_rtx", ")", ";", "}", "if", "(", "k", ">", "1", "||", "cum", "->", "use_stack", ")", "return", "gen_rtx_PARALLEL", "(", "BLKmode", ",", "gen_rtvec_v", "(", "k", "-", "kbase", ",", "&", "rvec", "[", "kbase", "]", ")", ")", ";", "else", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "For", "the", "darwin64", "ABI", ",", "we", "want", "to", "construct", "a", "PARALLEL", "consisting", "of", "the", "register", "(", "s", ")", "to", "be", "used", "for", "each", "field", "and", "subfield", "of", "a", "struct", "being", "passed", "by", "value", ",", "along", "with", "the", "offset", "of", "where", "the", "register", "'s", "value", "may", "be", "found", "in", "the", "block", ".", "FP", "fields", "go", "in", "FP", "register", ",", "vector", "fields", "go", "in", "vector", "registers", ",", "and", "everything", "else", "goes", "in", "int", "registers", ",", "packed", "as", "in", "memory", ".", "This", "code", "is", "also", "used", "for", "function", "return", "values", ".", "RETVAL", "indicates", "whether", "this", "is", "the", "case", ".", "Much", "of", "this", "is", "taken", "from", "the", "SPARC", "V9", "port", ",", "which", "has", "a", "similar", "calling", "convention", "." ]

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

[]

[ "<s>", "static", "inline", "enum", "insn_code", "rs6000_htm_spr_icode", "(", "bool", "nonvoid", ")", "{", "if", "(", "nonvoid", ")", "return", "(", "TARGET_POWERPC64", ")", "?", "CODE_FOR_htm_mfspr_di", ":", "CODE_FOR_htm_mfspr_si", ";", "else", "return", "(", "TARGET_POWERPC64", ")", "?", "CODE_FOR_htm_mtspr_di", ":", "CODE_FOR_htm_mtspr_si", ";", "}", "</s>" ]

[ "Return", "the", "correct", "ICODE", "value", "depending", "on", "whether", "we", "are", "setting", "or", "reading", "the", "HTM", "SPRs", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "static", "void", "sparc_file_end", "(", "void", ")", "{", "if", "(", "got_helper_needed", ")", "{", "const", "char", "*", "name", "=", "XSTR", "(", "got_helper_rtx", ",", "0", ")", ";", "bool", "do_cfi", ";", "if", "(", "USE_HIDDEN_LINKONCE", ")", "{", "tree", "decl", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FUNCTION_DECL", ",", "get_identifier", "(", "name", ")", ",", "build_function_type_list", "(", "void_type_node", ",", "NULL_TREE", ")", ")", ";", "DECL_RESULT", "(", "decl", ")", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "RESULT_DECL", ",", "NULL_TREE", ",", "void_type_node", ")", ";", "TREE_PUBLIC", "(", "decl", ")", "=", "1", ";", "TREE_STATIC", "(", "decl", ")", "=", "1", ";", "make_decl_one_only", "(", "decl", ",", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ";", "DECL_VISIBILITY", "(", "decl", ")", "=", "VISIBILITY_HIDDEN", ";", "DECL_VISIBILITY_SPECIFIED", "(", "decl", ")", "=", "1", ";", "resolve_unique_section", "(", "decl", ",", "0", ",", "flag_function_sections", ")", ";", "allocate_struct_function", "(", "decl", ",", "true", ")", ";", "cfun", "->", "is_thunk", "=", "1", ";", "current_function_decl", "=", "decl", ";", "init_varasm_status", "(", ")", ";", "assemble_start_function", "(", "decl", ",", "name", ")", ";", "}", "else", "{", "const", "int", "align", "=", "floor_log2", "(", "FUNCTION_BOUNDARY", "/", "BITS_PER_UNIT", ")", ";", "switch_to_section", "(", "text_section", ")", ";", "if", "(", "align", ">", "0", ")", "ASM_OUTPUT_ALIGN", "(", "asm_out_file", ",", "align", ")", ";", "ASM_OUTPUT_LABEL", "(", "asm_out_file", ",", "name", ")", ";", "}", "do_cfi", "=", "dwarf2out_do_cfi_asm", "(", ")", ";", "if", "(", "do_cfi", ")", "output_asm_insn", "(", "\".cfi_startproc\"", ",", "NULL", ")", ";", "if", "(", "flag_delayed_branch", ")", "{", "output_asm_insn", "(", "\"jmp\\t%%o7+8\"", ",", "NULL", ")", ";", "output_asm_insn", "(", "\" add\\t%%o7, %0, %0\"", ",", "&", "got_register_rtx", ")", ";", "}", "else", "{", "output_asm_insn", "(", "\"add\\t%%o7, %0, %0\"", ",", "&", "got_register_rtx", ")", ";", "output_asm_insn", "(", "\"jmp\\t%%o7+8\"", ",", "NULL", ")", ";", "output_asm_insn", "(", "\" nop\"", ",", "NULL", ")", ";", "}", "if", "(", "do_cfi", ")", "output_asm_insn", "(", "\".cfi_endproc\"", ",", "NULL", ")", ";", "}", "if", "(", "NEED_INDICATE_EXEC_STACK", ")", "file_end_indicate_exec_stack", "(", ")", ";", "solaris_file_end", "(", ")", ";", "}", "</s>" ]

[ "Do", "whatever", "processing", "is", "required", "at", "the", "end", "of", "a", "file", "." ]

[ "sparc", "0", "1", "1", "1", "0", "1", "0", "\".cfi_startproc\"", "\"jmp\\t%%o7+8\"", "\" add\\t%%o7, %0, %0\"", "\"add\\t%%o7, %0, %0\"", "\"jmp\\t%%o7+8\"", "\" nop\"", "\".cfi_endproc\"" ]

[]

[ "<s>", "bool", "HexagonPassConfig", "::", "addPreSched2", "(", ")", "{", "const", "HexagonTargetMachine", "&", "TM", "=", "getHexagonTargetMachine", "(", ")", ";", "addPass", "(", "createHexagonCopyToCombine", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "&", "IfConverterID", ")", ";", "addPass", "(", "createHexagonSplitConst32AndConst64", "(", "TM", ")", ")", ";", "printAndVerify", "(", "\"After hexagon split const32/64 pass\"", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"After hexagon split const32/64 pass\"" ]

[]

[ "<s>", "int", "arm_apply_result_size", "(", "void", ")", "{", "int", "size", "=", "16", ";", "if", "(", "TARGET_ARM", ")", "{", "if", "(", "TARGET_HARD_FLOAT_ABI", ")", "{", "if", "(", "TARGET_FPA", ")", "size", "+=", "12", ";", "if", "(", "TARGET_MAVERICK", ")", "size", "+=", "8", ";", "}", "if", "(", "TARGET_IWMMXT_ABI", ")", "size", "+=", "8", ";", "}", "return", "size", ";", "}", "</s>" ]

[ "Determine", "the", "amount", "of", "memory", "needed", "to", "store", "the", "possible", "return", "registers", "of", "an", "untyped", "call", "." ]

[ "arm", "16", "12", "8", "8" ]

[]

[ "<s>", "void", "SPIRVMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "auto", "Features", "=", "computeAvailableFeatures", "(", "STI", ".", "getFeatureBits", "(", ")", ")", ";", "verifyInstructionPredicates", "(", "MI", ",", "Features", ")", ";", "EndianWriter", "OSE", "(", "OS", ",", "support", "::", "little", ")", ";", "const", "uint64_t", "OpCode", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "const", "uint32_t", "NumWords", "=", "MI", ".", "getNumOperands", "(", ")", "+", "1", ";", "const", "uint32_t", "FirstWord", "=", "(", "NumWords", "<<", "16", ")", "|", "OpCode", ";", "OSE", ".", "write", "<", "uint32_t", ">", "(", "FirstWord", ")", ";", "if", "(", "hasType", "(", "MI", ",", "MCII", ",", "MRI", ")", ")", "emitTypedInstrOperands", "(", "MI", ",", "OSE", ")", ";", "else", "emitUntypedInstrOperands", "(", "MI", ",", "OSE", ")", ";", "}", "</s>" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "SPIRV", "SPIRV", "support::little", "1", "16" ]

[]

[ "<s>", "TargetTransformInfo", "SPIRVTargetMachine", "::", "getTargetTransformInfo", "(", "const", "Function", "&", "F", ")", "const", "{", "return", "TargetTransformInfo", "(", "SPIRVTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetTransformInfo", "implementation", "for", "the", "target", "." ]

[ "SPIRV", "SPIRV", "SPIRV" ]

[]

[ "<s>", "bool", "ARMLoadStoreOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "MF", "=", "&", "Fn", ";", "STI", "=", "&", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ")", ";", "TL", "=", "STI", "->", "getTargetLowering", "(", ")", ";", "AFI", "=", "Fn", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "RegClassInfoValid", "=", "false", ";", "isThumb2", "=", "AFI", "->", "isThumb2Function", "(", ")", ";", "isThumb1", "=", "AFI", "->", "isThumbFunction", "(", ")", "&&", "!", "isThumb2", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "Fn", ".", "begin", "(", ")", ",", "E", "=", "Fn", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MFI", ";", "Modified", "|=", "LoadStoreMultipleOpti", "(", "MBB", ")", ";", "if", "(", "STI", "->", "hasV5TOps", "(", ")", ")", "Modified", "|=", "MergeReturnIntoLDM", "(", "MBB", ")", ";", "if", "(", "isThumb1", ")", "Modified", "|=", "CombineMovBx", "(", "MBB", ")", ";", "}", "Allocator", ".", "DestroyAll", "(", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "rtx", "aarch64_expand_builtin_tme", "(", "int", "fcode", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "switch", "(", "fcode", ")", "{", "case", "AARCH64_TME_BUILTIN_TSTART", ":", "target", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "emit_insn", "(", "GEN_FCN", "(", "CODE_FOR_tstart", ")", "(", "target", ")", ")", ";", "break", ";", "case", "AARCH64_TME_BUILTIN_TTEST", ":", "target", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "emit_insn", "(", "GEN_FCN", "(", "CODE_FOR_ttest", ")", "(", "target", ")", ")", ";", "break", ";", "case", "AARCH64_TME_BUILTIN_TCOMMIT", ":", "emit_insn", "(", "GEN_FCN", "(", "CODE_FOR_tcommit", ")", "(", ")", ")", ";", "break", ";", "case", "AARCH64_TME_BUILTIN_TCANCEL", ":", "{", "tree", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "rtx", "op0", "=", "expand_normal", "(", "arg0", ")", ";", "if", "(", "CONST_INT_P", "(", "op0", ")", "&&", "UINTVAL", "(", "op0", ")", "<=", "65536", ")", "emit_insn", "(", "GEN_FCN", "(", "CODE_FOR_tcancel", ")", "(", "op0", ")", ")", ";", "else", "{", "error_at", "(", "EXPR_LOCATION", "(", "exp", ")", ",", "\"argument must be a 16-bit constant immediate\"", ")", ";", "return", "const0_rtx", ";", "}", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "target", ";", "}", "</s>" ]

[ "Function", "to", "expand", "an", "expression", "EXP", "which", "calls", "one", "of", "the", "Transactional", "Memory", "Extension", "(", "TME", ")", "builtins", "FCODE", "with", "the", "result", "going", "to", "TARGET", "." ]

[ "aarch64", "0", "65536", "\"argument must be a 16-bit constant immediate\"" ]

[]

[ "<s>", "enum", "arc_function_type", "arc_compute_function_type", "(", "struct", "function", "*", "fun", ")", "{", "tree", "decl", "=", "fun", "->", "decl", ";", "tree", "a", ";", "enum", "arc_function_type", "fn_type", "=", "fun", "->", "machine", "->", "fn_type", ";", "if", "(", "fn_type", "!=", "ARC_FUNCTION_UNKNOWN", ")", "return", "fn_type", ";", "fn_type", "=", "ARC_FUNCTION_NORMAL", ";", "for", "(", "a", "=", "DECL_ATTRIBUTES", "(", "decl", ")", ";", "a", ";", "a", "=", "TREE_CHAIN", "(", "a", ")", ")", "{", "tree", "name", "=", "TREE_PURPOSE", "(", "a", ")", ",", "args", "=", "TREE_VALUE", "(", "a", ")", ";", "if", "(", "name", "==", "get_identifier", "(", "\"interrupt\"", ")", "&&", "list_length", "(", "args", ")", "==", "1", "&&", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "==", "STRING_CST", ")", "{", "tree", "value", "=", "TREE_VALUE", "(", "args", ")", ";", "if", "(", "!", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink1\"", ")", "||", "!", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink\"", ")", ")", "fn_type", "=", "ARC_FUNCTION_ILINK1", ";", "else", "if", "(", "!", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink2\"", ")", ")", "fn_type", "=", "ARC_FUNCTION_ILINK2", ";", "else", "gcc_unreachable", "(", ")", ";", "break", ";", "}", "}", "return", "fun", "->", "machine", "->", "fn_type", "=", "fn_type", ";", "}", "</s>" ]

[ "Type", "of", "function", "DECL", ".", "The", "result", "is", "cached", ".", "To", "reset", "the", "cache", "at", "the", "end", "of", "a", "function", ",", "call", "with", "DECL", "=", "NULL_TREE", "." ]

[ "arc", "\"interrupt\"", "1", "\"ilink1\"", "\"ilink\"", "\"ilink2\"" ]

[]

[ "<s>", "SDValue", "SITargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "SDLoc", "DL", "(", "N", ")", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "SELECT_CC", ":", "{", "N", "->", "dump", "(", ")", ";", "ConstantSDNode", "*", "True", ",", "*", "False", ";", "if", "(", "(", "True", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "2", ")", ")", ")", "&&", "(", "False", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "3", ")", ")", ")", "&&", "True", "->", "isAllOnesValue", "(", ")", "&&", "False", "->", "isNullValue", "(", ")", "&&", "VT", "==", "MVT", "::", "i1", ")", "{", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SETCC", ",", "DL", ",", "VT", ",", "N", "->", "getOperand", "(", "0", ")", ",", "N", "->", "getOperand", "(", "1", ")", ",", "N", "->", "getOperand", "(", "4", ")", ")", ";", "}", "break", ";", "}", "case", "ISD", "::", "SETCC", ":", "{", "SDValue", "Arg0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Arg1", "=", "N", "->", "getOperand", "(", "1", ")", ";", "SDValue", "CC", "=", "N", "->", "getOperand", "(", "2", ")", ";", "ConstantSDNode", "*", "C", "=", "NULL", ";", "ISD", "::", "CondCode", "CCOp", "=", "dyn_cast", "<", "CondCodeSDNode", ">", "(", "CC", ")", "->", "get", "(", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i1", "&&", "Arg0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SIGN_EXTEND", "&&", "Arg0", ".", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "i1", "&&", "(", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Arg1", ")", ")", "&&", "C", "->", "isNullValue", "(", ")", "&&", "CCOp", "==", "ISD", "::", "SETNE", ")", "{", "return", "SimplifySetCC", "(", "VT", ",", "Arg0", ".", "getOperand", "(", "0", ")", ",", "DAG", ".", "getConstant", "(", "0", ",", "MVT", "::", "i1", ")", ",", "CCOp", ",", "true", ",", "DCI", ",", "DL", ")", ";", "}", "break", ";", "}", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "R600", "SI", "0", "ISD::SELECT_CC", "2", "3", "MVT::i1", "ISD::SETCC", "0", "1", "4", "ISD::SETCC", "0", "1", "2", "ISD::CondCode", "MVT::i1", "ISD::SIGN_EXTEND", "0", "MVT::i1", "ISD::SETNE", "0", "0", "MVT::i1" ]

[]

[ "<s>", "static", "const", "struct", "riscv_cpu_info", "*", "riscv_parse_cpu", "(", "const", "char", "*", "cpu_string", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "riscv_cpu_info_table", ")", ";", "i", "++", ")", "if", "(", "strcmp", "(", "riscv_cpu_info_table", "[", "i", "]", ".", "name", ",", "cpu_string", ")", "==", "0", ")", "return", "riscv_cpu_info_table", "+", "i", ";", "error", "(", "\"unknown cpu %qs for -mtune\"", ",", "cpu_string", ")", ";", "return", "riscv_cpu_info_table", ";", "}", "</s>" ]

[ "Return", "the", "riscv_cpu_info", "entry", "for", "the", "given", "name", "string", "." ]

[ "riscv", "0", "0", "\"unknown cpu %qs for -mtune\"" ]

[]

[ "<s>", "SDValue", "WebAssemblyTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "assert", "(", "Outs", ".", "size", "(", ")", "<=", "1", "&&", "\"WebAssembly can only return up to one value\"", ")", ";", "if", "(", "!", "CallingConvSupported", "(", "CallConv", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support non-C calling conventions\"", ")", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "RetOps", ".", "append", "(", "OutVals", ".", "begin", "(", ")", ",", "OutVals", ".", "end", "(", ")", ")", ";", "Chain", "=", "DAG", ".", "getNode", "(", "WebAssemblyISD", "::", "RETURN", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "for", "(", "const", "ISD", "::", "OutputArg", "&", "Out", ":", "Outs", ")", "{", "assert", "(", "!", "Out", ".", "Flags", ".", "isByVal", "(", ")", "&&", "\"byval is not valid for return values\"", ")", ";", "assert", "(", "!", "Out", ".", "Flags", ".", "isNest", "(", ")", "&&", "\"nest is not valid for return values\"", ")", ";", "assert", "(", "Out", ".", "IsFixed", "&&", "\"non-fixed return value is not valid\"", ")", ";", "if", "(", "Out", ".", "Flags", ".", "isInAlloca", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented inalloca results\"", ")", ";", "if", "(", "Out", ".", "Flags", ".", "isInConsecutiveRegs", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented cons regs results\"", ")", ";", "if", "(", "Out", ".", "Flags", ".", "isInConsecutiveRegsLast", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented cons regs last results\"", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "ISD::OutputArg", "1", "\"WebAssembly can only return up to one value\"", "\"WebAssembly doesn't support non-C calling conventions\"", "4", "1", "WebAssemblyISD::RETURN", "MVT::Other", "ISD::OutputArg", "\"byval is not valid for return values\"", "\"nest is not valid for return values\"", "\"non-fixed return value is not valid\"", "\"WebAssembly hasn't implemented inalloca results\"", "\"WebAssembly hasn't implemented cons regs results\"", "\"WebAssembly hasn't implemented cons regs last results\"" ]

[]

[ "<s>", "unsigned", "ARMCodeEmitter", "::", "getMachineOpValue", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "&", "MO", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "getARMRegisterNumbering", "(", "MO", ".", "getReg", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isFPImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getFPImm", "(", ")", "->", "getValueAPF", "(", ")", ".", "bitcastToAPInt", "(", ")", ".", "getHiBits", "(", "32", ")", ".", "getLimitedValue", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "emitGlobalAddress", "(", "MO", ".", "getGlobal", "(", ")", ",", "ARM", "::", "reloc_arm_branch", ",", "true", ",", "false", ")", ";", "else", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "emitExternalSymbolAddress", "(", "MO", ".", "getSymbolName", "(", ")", ",", "ARM", "::", "reloc_arm_branch", ")", ";", "else", "if", "(", "MO", ".", "isCPI", "(", ")", ")", "{", "const", "MCInstrDesc", "&", "MCID", "=", "MI", ".", "getDesc", "(", ")", ";", "unsigned", "Reloc", "=", "(", "(", "MCID", ".", "TSFlags", "&", "ARMII", "::", "FormMask", ")", "==", "ARMII", "::", "VFPLdStFrm", ")", "?", "ARM", "::", "reloc_arm_vfp_cp_entry", ":", "ARM", "::", "reloc_arm_cp_entry", ";", "emitConstPoolAddress", "(", "MO", ".", "getIndex", "(", ")", ",", "Reloc", ")", ";", "}", "else", "if", "(", "MO", ".", "isJTI", "(", ")", ")", "emitJumpTableAddress", "(", "MO", ".", "getIndex", "(", ")", ",", "ARM", "::", "reloc_arm_relative", ")", ";", "else", "if", "(", "MO", ".", "isMBB", "(", ")", ")", "emitMachineBasicBlock", "(", "MO", ".", "getMBB", "(", ")", ",", "ARM", "::", "reloc_arm_branch", ")", ";", "else", "llvm_unreachable", "(", "\"Unable to encode MachineOperand!\"", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "32", "ARM::reloc_arm_branch", "ARM::reloc_arm_branch", "ARMII::FormMask", "ARMII::VFPLdStFrm", "ARM::reloc_arm_vfp_cp_entry", "ARM::reloc_arm_cp_entry", "ARM::reloc_arm_relative", "ARM::reloc_arm_branch", "\"Unable to encode MachineOperand!\"", "0" ]

[]

[ "<s>", "bool", "X86AsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "AsmVariant", ",", "ExtraCode", ",", "O", ")", ";", "case", "'a'", ":", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "O", "<<", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "}", "if", "(", "MO", ".", "isGlobal", "(", ")", "||", "MO", ".", "isCPI", "(", ")", "||", "MO", ".", "isJTI", "(", ")", "||", "MO", ".", "isSymbol", "(", ")", ")", "{", "printSymbolOperand", "(", "MO", ",", "O", ")", ";", "if", "(", "Subtarget", "->", "isPICStyleRIPRel", "(", ")", ")", "O", "<<", "\"(%rip)\"", ";", "return", "false", ";", "}", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "O", "<<", "'('", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "O", "<<", "')'", ";", "return", "false", ";", "}", "return", "true", ";", "case", "'c'", ":", "if", "(", "MO", ".", "isImm", "(", ")", ")", "O", "<<", "MO", ".", "getImm", "(", ")", ";", "else", "if", "(", "MO", ".", "isGlobal", "(", ")", "||", "MO", ".", "isCPI", "(", ")", "||", "MO", ".", "isJTI", "(", ")", "||", "MO", ".", "isSymbol", "(", ")", ")", "printSymbolOperand", "(", "MO", ",", "O", ")", ";", "else", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "case", "'A'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "O", "<<", "'*'", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "return", "true", ";", "case", "'b'", ":", "case", "'h'", ":", "case", "'w'", ":", "case", "'k'", ":", "case", "'q'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "printAsmMRegister", "(", "MO", ",", "ExtraCode", "[", "0", "]", ",", "O", ")", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "case", "'P'", ":", "printPCRelImm", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "case", "'n'", ":", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "O", "<<", "-", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "}", "O", "<<", "'-'", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ",", "0", ",", "AsmVariant", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "X86", "X86", "0", "1", "0", "0", "\"(%rip)\"", "0", "0" ]

[]

[ "<s>", "void", "emitGlobalVariable", "(", "const", "GlobalVariable", "*", "GV", ")", "override", "{", "}", "</s>" ]

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

[ "SPIRV" ]

[]

[ "<s>", "const", "SICFrameLowering", "*", "SICFrameLowering", "::", "create", "(", "const", "SICSubtarget", "&", "ST", ")", "{", "return", "new", "SICFrameLowering", "(", "ST", ",", "ST", ".", "stackAlignment", "(", ")", ")", ";", "}", "</s>" ]

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

[ "SIC", "SIC", "SIC", "SIC", "SIC" ]

[]

[ "<s>", "static", "unsigned", "int", "aarch64_dwarf_poly_indeterminate_value", "(", "unsigned", "int", "i", ",", "unsigned", "int", "*", "factor", ",", "int", "*", "offset", ")", "{", "gcc_assert", "(", "i", "==", "1", ")", ";", "*", "factor", "=", "2", ";", "*", "offset", "=", "1", ";", "return", "AARCH64_DWARF_VG", ";", "}", "</s>" ]

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

[ "aarch64", "1", "2", "1" ]

[]

[ "<s>", "static", "void", "loongarch_emit_float_compare", "(", "enum", "rtx_code", "*", "code", ",", "rtx", "*", "op0", ",", "rtx", "*", "op1", ")", "{", "rtx", "cmp_op0", "=", "*", "op0", ";", "rtx", "cmp_op1", "=", "*", "op1", ";", "enum", "rtx_code", "cmp_code", "=", "*", "code", ";", "*", "code", "=", "NE", ";", "*", "op0", "=", "loongarch_allocate_fcc", "(", "FCCmode", ")", ";", "*", "op1", "=", "const0_rtx", ";", "loongarch_emit_binary", "(", "cmp_code", ",", "*", "op0", ",", "cmp_op0", ",", "cmp_op1", ")", ";", "}", "</s>" ]

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

[ "loongarch" ]

[]

[ "<s>", "static", "void", "arm_setup_incoming_varargs", "(", "cumulative_args_t", "pcum_v", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_size", ",", "int", "second_time", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "pcum", "=", "get_cumulative_args", "(", "pcum_v", ")", ";", "int", "nregs", ";", "cfun", "->", "machine", "->", "uses_anonymous_args", "=", "1", ";", "if", "(", "pcum", "->", "pcs_variant", "<=", "ARM_PCS_AAPCS_LOCAL", ")", "{", "nregs", "=", "pcum", "->", "aapcs_ncrn", ";", "if", "(", "!", "TYPE_NO_NAMED_ARGS_STDARG_P", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", "&&", "(", "nregs", "&", "1", ")", ")", "{", "int", "res", "=", "arm_needs_doubleword_align", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ";", "if", "(", "res", "<", "0", "&&", "warn_psabi", ")", "inform", "(", "input_location", ",", "\"parameter passing for argument of \"", "\"type %qT changed in GCC 7.1\"", ",", "arg", ".", "type", ")", ";", "else", "if", "(", "res", ">", "0", ")", "{", "nregs", "++", ";", "if", "(", "res", ">", "1", "&&", "warn_psabi", ")", "inform", "(", "input_location", ",", "\"parameter passing for argument of type \"", "\"%qT changed in GCC 9.1\"", ",", "arg", ".", "type", ")", ";", "}", "}", "}", "else", "nregs", "=", "pcum", "->", "nregs", ";", "if", "(", "nregs", "<", "NUM_ARG_REGS", ")", "*", "pretend_size", "=", "(", "NUM_ARG_REGS", "-", "nregs", ")", "*", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_SETUP_INCOMING_VARARGS", ".", "On", "the", "ARM", ",", "PRETEND_SIZE", "is", "set", "in", "order", "to", "have", "the", "prologue", "push", "the", "last", "named", "arg", "and", "all", "anonymous", "args", "onto", "the", "stack", ".", "XXX", "I", "know", "the", "prologue", "should", "n't", "be", "pushing", "registers", ",", "but", "it", "is", "faster", "that", "way", "." ]

[ "arm", "1", "1", "0", "\"parameter passing for argument of \"", "\"type %qT changed in GCC 7.1\"", "0", "1", "\"parameter passing for argument of type \"", "\"%qT changed in GCC 9.1\"" ]

[]

[ "<s>", "const", "RegisterBank", "&", "X86RegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ")", "const", "{", "if", "(", "X86", "::", "GR8RegClass", ".", "hasSubClassEq", "(", "&", "RC", ")", "||", "X86", "::", "GR16RegClass", ".", "hasSubClassEq", "(", "&", "RC", ")", "||", "X86", "::", "GR32RegClass", ".", "hasSubClassEq", "(", "&", "RC", ")", "||", "X86", "::", "GR64RegClass", ".", "hasSubClassEq", "(", "&", "RC", ")", ")", "return", "getRegBank", "(", "X86", "::", "GPRRegBankID", ")", ";", "llvm_unreachable", "(", "\"Unsupported register kind yet.\"", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::GR8RegClass", "X86::GR16RegClass", "X86::GR32RegClass", "X86::GR64RegClass", "X86::GPRRegBankID", "\"Unsupported register kind yet.\"" ]

[]

[ "<s>", "static", "rtx", "rs6000_function_value", "(", "const_tree", "valtype", ",", "const_tree", "fn_decl_or_type", "ATTRIBUTE_UNUSED", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "machine_mode", "mode", ";", "unsigned", "int", "regno", ";", "machine_mode", "elt_mode", ";", "int", "n_elts", ";", "if", "(", "TARGET_MACHO", "&&", "rs6000_darwin64_struct_check_p", "(", "TYPE_MODE", "(", "valtype", ")", ",", "valtype", ")", ")", "{", "CUMULATIVE_ARGS", "valcum", ";", "rtx", "valret", ";", "valcum", ".", "words", "=", "0", ";", "valcum", ".", "fregno", "=", "FP_ARG_MIN_REG", ";", "valcum", ".", "vregno", "=", "ALTIVEC_ARG_MIN_REG", ";", "valret", "=", "rs6000_darwin64_record_arg", "(", "&", "valcum", ",", "valtype", ",", "true", ",", "true", ")", ";", "if", "(", "valret", ")", "return", "valret", ";", "}", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "if", "(", "rs6000_discover_homogeneous_aggregate", "(", "mode", ",", "valtype", ",", "&", "elt_mode", ",", "&", "n_elts", ")", ")", "{", "int", "first_reg", ",", "n_regs", ";", "if", "(", "SCALAR_FLOAT_MODE_NOT_VECTOR_P", "(", "elt_mode", ")", ")", "{", "first_reg", "=", "(", "elt_mode", "==", "TDmode", ")", "?", "FP_ARG_RETURN", "+", "1", ":", "FP_ARG_RETURN", ";", "n_regs", "=", "(", "GET_MODE_SIZE", "(", "elt_mode", ")", "+", "7", ")", ">>", "3", ";", "}", "else", "{", "first_reg", "=", "ALTIVEC_ARG_RETURN", ";", "n_regs", "=", "1", ";", "}", "return", "rs6000_parallel_return", "(", "mode", ",", "n_elts", ",", "elt_mode", ",", "first_reg", ",", "n_regs", ")", ";", "}", "if", "(", "TARGET_32BIT", "&&", "TARGET_POWERPC64", ")", "switch", "(", "mode", ")", "{", "default", ":", "break", ";", "case", "DImode", ":", "case", "SCmode", ":", "case", "DCmode", ":", "case", "TCmode", ":", "int", "count", "=", "GET_MODE_SIZE", "(", "mode", ")", "/", "4", ";", "return", "rs6000_parallel_return", "(", "mode", ",", "count", ",", "SImode", ",", "GP_ARG_RETURN", ",", "1", ")", ";", "}", "if", "(", "(", "INTEGRAL_TYPE_P", "(", "valtype", ")", "&&", "GET_MODE_BITSIZE", "(", "mode", ")", "<", "(", "TARGET_32BIT", "?", "32", ":", "64", ")", ")", "||", "POINTER_TYPE_P", "(", "valtype", ")", ")", "mode", "=", "TARGET_32BIT", "?", "SImode", ":", "DImode", ";", "if", "(", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", "&&", "TARGET_HARD_FLOAT", "&&", "TARGET_FPRS", ")", "regno", "=", "(", "mode", "==", "TDmode", ")", "?", "FP_ARG_RETURN", "+", "1", ":", "FP_ARG_RETURN", ";", "else", "if", "(", "SCALAR_FLOAT_TYPE_P", "(", "valtype", ")", "&&", "TARGET_HARD_FLOAT", "&&", "TARGET_FPRS", "&&", "!", "FLOAT128_VECTOR_P", "(", "mode", ")", "&&", "(", "(", "TARGET_SINGLE_FLOAT", "&&", "(", "mode", "==", "SFmode", ")", ")", "||", "TARGET_DOUBLE_FLOAT", ")", ")", "regno", "=", "FP_ARG_RETURN", ";", "else", "if", "(", "TREE_CODE", "(", "valtype", ")", "==", "COMPLEX_TYPE", "&&", "targetm", ".", "calls", ".", "split_complex_arg", ")", "return", "rs6000_complex_function_value", "(", "mode", ")", ";", "else", "if", "(", "(", "TREE_CODE", "(", "valtype", ")", "==", "VECTOR_TYPE", "||", "FLOAT128_VECTOR_P", "(", "mode", ")", ")", "&&", "TARGET_ALTIVEC", "&&", "TARGET_ALTIVEC_ABI", "&&", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "mode", ")", ")", "regno", "=", "ALTIVEC_ARG_RETURN", ";", "else", "if", "(", "TARGET_E500_DOUBLE", "&&", "TARGET_HARD_FLOAT", "&&", "(", "mode", "==", "DFmode", "||", "mode", "==", "DCmode", "||", "FLOAT128_IBM_P", "(", "mode", ")", "||", "mode", "==", "TCmode", ")", ")", "return", "spe_build_register_parallel", "(", "mode", ",", "GP_ARG_RETURN", ")", ";", "else", "regno", "=", "GP_ARG_RETURN", ";", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}", "</s>" ]

[ "Define", "how", "to", "find", "the", "value", "returned", "by", "a", "function", ".", "VALTYPE", "is", "the", "data", "type", "of", "the", "value", "(", "as", "a", "tree", ")", ".", "If", "the", "precise", "function", "being", "called", "is", "known", ",", "FUNC", "is", "its", "FUNCTION_DECL", ";", "otherwise", ",", "FUNC", "is", "0", ".", "On", "the", "SPE", ",", "both", "FPs", "and", "vectors", "are", "returned", "in", "r3", ".", "On", "RS/6000", "an", "integer", "value", "is", "in", "r3", "and", "a", "floating-point", "value", "is", "in", "fp1", ",", "unless", "-msoft-float", "." ]

[ "rs6000", "0", "1", "7", "3", "1", "4", "1", "32", "64", "1" ]

[]

[ "<s>", "const", "uint32_t", "*", "AArch64RegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_AArch64_NoRegs_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "AnyReg", ")", "return", "CSR_AArch64_AllRegs_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "CXX_FAST_TLS", ")", "return", "CSR_AArch64_CXX_TLS_Darwin_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "AArch64_SVE_VectorCall", ")", "return", "CSR_AArch64_SVE_AAPCS_RegMask", ";", "if", "(", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_AArch64_AAPCS_SwiftError_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "PreserveMost", ")", "return", "CSR_AArch64_RT_MostRegs_RegMask", ";", "else", "return", "CSR_AArch64_AAPCS_RegMask", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "nvptx_function_end", "(", "FILE", "*", "file", ")", "{", "fprintf", "(", "file", ",", "\"\\t}\\n\"", ")", ";", "}", "</s>" ]

[ "Terminate", "a", "function", "by", "writing", "a", "closing", "brace", "to", "FILE", "." ]

[ "nvptx", "\"\\t}\\n\"" ]

[]