Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "SparcSubtarget", "&", "SparcSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "UseSoftMulDiv", "=", "false", ";", "IsV9", "=", "false", ";", "IsLeon", "=", "false", ";", "V8DeprecatedInsts", "=", "false", ";", "IsVIS", "=", "false", ";", "IsVIS2", "=", "false", ";", "IsVIS3", "=", "false", ";", "HasHardQuad", "=", "false", ";", "UsePopc", "=", "false", ";", "UseSoftFloat", "=", "false", ";", "HasNoFSMULD", "=", "false", ";", "HasNoFMULS", "=", "false", ";", "HasLeonCasa", "=", "false", ";", "HasUmacSmac", "=", "false", ";", "InsertNOPLoad", "=", "false", ";", "FixAllFDIVSQRT", "=", "false", ";", "DetectRoundChange", "=", "false", ";", "HasLeonCycleCounter", "=", "false", ";", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "(", "Is64Bit", ")", "?", "\"v9\"", ":", "\"v8\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "if", "(", "!", "IsV9", ")", "UsePopc", "=", "false", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

[ "Sparc", "Sparc", "Sparc", "\"v9\"", "\"v8\"" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isLegalVSrcOperand", "(", "const", "MachineRegisterInfo", "&", "MRI", ",", "const", "MCOperandInfo", "&", "OpInfo", ",", "const", "MachineOperand", "&", "MO", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "isLegalRegOperand", "(", "MRI", ",", "OpInfo", ",", "MO", ")", ";", "assert", "(", "MO", ".", "isImm", "(", ")", "||", "MO", ".", "isTargetIndex", "(", ")", "||", "MO", ".", "isFI", "(", ")", "||", "MO", ".", "isGlobal", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Check", "if", "MO", "would", "be", "a", "valid", "operand", "for", "the", "given", "operand", "definition", "OpInfo", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"OR1K DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "OR1K", "\"OR1K DAG->DAG Pattern Instruction Selection\"" ]

[]

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

[ "isReg", "-", "Is", "this", "a", "register", "operand", "?" ]

[ "FISC" ]

[]

[ "<s>", "bool", "TLCS900DAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Op0", ",", "Op1", ";", "switch", "(", "ConstraintCode", ")", "{", "default", ":", "return", "true", ";", "case", "'m'", ":", "if", "(", "!", "SelectAddr", "(", "Op", ",", "Op0", ",", "Op1", ")", ")", "return", "true", ";", "break", ";", "}", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "Op1", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "TLCS900", "TLCS900" ]

[]

[ "<s>", "rtx", "arm_simd_vect_par_cnst_half", "(", "machine_mode", "mode", ",", "bool", "high", ")", "{", "int", "nunits", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "rtvec", "v", "=", "rtvec_alloc", "(", "nunits", "/", "2", ")", ";", "int", "high_base", "=", "nunits", "/", "2", ";", "int", "low_base", "=", "0", ";", "int", "base", ";", "rtx", "t1", ";", "int", "i", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "base", "=", "high", "?", "low_base", ":", "high_base", ";", "else", "base", "=", "high", "?", "high_base", ":", "low_base", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nunits", "/", "2", ";", "i", "++", ")", "RTVEC_ELT", "(", "v", ",", "i", ")", "=", "GEN_INT", "(", "base", "+", "i", ")", ";", "t1", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "v", ")", ";", "return", "t1", ";", "}", "</s>" ]

[ "Construct", "and", "return", "a", "PARALLEL", "RTX", "vector", "with", "elements", "numbering", "the", "lanes", "of", "either", "the", "high", "(", "HIGH", "==", "TRUE", ")", "or", "low", "(", "HIGH", "==", "FALSE", ")", "half", "of", "the", "vector", "-", "from", "the", "perspective", "of", "the", "architecture", ".", "This", "does", "not", "line", "up", "with", "GCC", "'s", "perspective", "on", "lane", "numbers", ",", "so", "we", "end", "up", "with", "different", "masks", "depending", "on", "our", "target", "endian-ness", ".", "The", "diagram", "below", "may", "help", ".", "We", "must", "draw", "the", "distinction", "when", "building", "masks", "which", "select", "one", "half", "of", "the", "vector", ".", "An", "instruction", "selecting", "architectural", "low-lanes", "for", "a", "big-endian", "target", ",", "must", "be", "described", "using", "a", "mask", "selecting", "GCC", "high-lanes", ".", "Big-Endian", "Little-EndianGCC", "0", "1", "2", "3", "3", "2", "1", "0", "|", "x", "|", "x", "|", "x", "|", "x", "|", "|", "x", "|", "x", "|", "x", "|", "x", "|Architecture", "3", "2", "1", "0", "3", "2", "1", "0Low", "Mask", ":", "{", "2", ",", "3", "}", "{", "0", ",", "1", "}", "High", "Mask", ":", "{", "0", ",", "1", "}", "{", "2", ",", "3", "}" ]

[ "arm", "2", "2", "0", "0", "2" ]

[]

[ "<s>", "AArch64TargetMachine", "::", "AArch64TargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "LittleEndian", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "*", "this", ",", "LittleEndian", ")", ",", "isLittle", "(", "LittleEndian", ")", ",", "usingPBQP", "(", "false", ")", "{", "initAsmInfo", "(", ")", ";", "if", "(", "EnablePBQP", "&&", "Subtarget", ".", "isCortexA57", "(", ")", "&&", "OL", "!=", "CodeGenOpt", "::", "None", ")", "{", "usingPBQP", "=", "true", ";", "RegisterRegAlloc", "::", "setDefault", "(", "createDefaultPBQPRegisterAllocator", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "alpha_split_conditional_move", "(", "enum", "rtx_code", "code", ",", "rtx", "dest", ",", "rtx", "cond", ",", "rtx", "t_rtx", ",", "rtx", "f_rtx", ")", "{", "HOST_WIDE_INT", "t", ",", "f", ",", "diff", ";", "machine_mode", "mode", ";", "rtx", "target", ",", "subtarget", ",", "tmp", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "t", "=", "INTVAL", "(", "t_rtx", ")", ";", "f", "=", "INTVAL", "(", "f_rtx", ")", ";", "diff", "=", "t", "-", "f", ";", "if", "(", "(", "(", "code", "==", "NE", "||", "code", "==", "EQ", ")", "&&", "diff", "<", "0", ")", "||", "(", "code", "==", "GE", "||", "code", "==", "GT", ")", ")", "{", "code", "=", "reverse_condition", "(", "code", ")", ";", "std", "::", "swap", "(", "t", ",", "f", ")", ";", "diff", "=", "-", "diff", ";", "}", "subtarget", "=", "target", "=", "dest", ";", "if", "(", "mode", "!=", "DImode", ")", "{", "target", "=", "gen_lowpart", "(", "DImode", ",", "dest", ")", ";", "if", "(", "can_create_pseudo_p", "(", ")", ")", "subtarget", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "else", "subtarget", "=", "target", ";", "}", "if", "(", "f", "==", "0", "&&", "exact_log2", "(", "diff", ")", ">", "0", "&&", "(", "diff", "<=", "8", "||", "alpha_tune", "==", "PROCESSOR_EV6", ")", ")", "{", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "copy_rtx", "(", "subtarget", ")", ",", "tmp", ")", ")", ";", "tmp", "=", "gen_rtx_ASHIFT", "(", "DImode", ",", "copy_rtx", "(", "subtarget", ")", ",", "GEN_INT", "(", "exact_log2", "(", "t", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "tmp", ")", ")", ";", "}", "else", "if", "(", "f", "==", "0", "&&", "t", "==", "-", "1", ")", "{", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "copy_rtx", "(", "subtarget", ")", ",", "tmp", ")", ")", ";", "emit_insn", "(", "gen_negdi2", "(", "target", ",", "copy_rtx", "(", "subtarget", ")", ")", ")", ";", "}", "else", "if", "(", "diff", "==", "1", "||", "diff", "==", "4", "||", "diff", "==", "8", ")", "{", "rtx", "add_op", ";", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "copy_rtx", "(", "subtarget", ")", ",", "tmp", ")", ")", ";", "if", "(", "diff", "==", "1", ")", "emit_insn", "(", "gen_adddi3", "(", "target", ",", "copy_rtx", "(", "subtarget", ")", ",", "GEN_INT", "(", "f", ")", ")", ")", ";", "else", "{", "add_op", "=", "GEN_INT", "(", "f", ")", ";", "if", "(", "sext_add_operand", "(", "add_op", ",", "mode", ")", ")", "{", "tmp", "=", "gen_rtx_ASHIFT", "(", "DImode", ",", "copy_rtx", "(", "subtarget", ")", ",", "GEN_INT", "(", "exact_log2", "(", "diff", ")", ")", ")", ";", "tmp", "=", "gen_rtx_PLUS", "(", "DImode", ",", "tmp", ",", "add_op", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "tmp", ")", ")", ";", "}", "else", "return", "0", ";", "}", "}", "else", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Simplify", "a", "conditional", "move", "of", "two", "constants", "into", "a", "setcc", "with", "arithmetic", ".", "This", "is", "done", "with", "a", "splitter", "since", "combine", "would", "just", "undo", "the", "work", "if", "done", "during", "code", "generation", ".", "It", "also", "catches", "cases", "we", "would", "n't", "have", "before", "cse", "." ]

[ "alpha", "0", "0", "0", "8", "0", "1", "1", "4", "8", "1", "0", "0", "1" ]

[]

[ "<s>", "unsigned", "ARMAsmParser", "::", "checkTargetMatchPredicate", "(", "MCInst", "&", "Inst", ")", "{", "unsigned", "Opc", "=", "Inst", ".", "getOpcode", "(", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "MII", ".", "get", "(", "Opc", ")", ";", "if", "(", "MCID", ".", "TSFlags", "&", "ARMII", "::", "ThumbArithFlagSetting", ")", "{", "assert", "(", "MCID", ".", "hasOptionalDef", "(", ")", "&&", "\"optionally flag setting instruction missing optional def operand\"", ")", ";", "assert", "(", "MCID", ".", "NumOperands", "==", "Inst", ".", "getNumOperands", "(", ")", "&&", "\"operand count mismatch!\"", ")", ";", "unsigned", "OpNo", ";", "for", "(", "OpNo", "=", "0", ";", "!", "MCID", ".", "OpInfo", "[", "OpNo", "]", ".", "isOptionalDef", "(", ")", "&&", "OpNo", "<", "MCID", ".", "NumOperands", ";", "++", "OpNo", ")", ";", "if", "(", "isThumbOne", "(", ")", "&&", "Inst", ".", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", "!=", "ARM", "::", "CPSR", ")", "return", "Match_MnemonicFail", ";", "if", "(", "isThumbTwo", "(", ")", "&&", "Inst", ".", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", "!=", "ARM", "::", "CPSR", "&&", "!", "inITBlock", "(", ")", ")", "return", "Match_RequiresITBlock", ";", "if", "(", "isThumbTwo", "(", ")", "&&", "Inst", ".", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "CPSR", "&&", "inITBlock", "(", ")", ")", "return", "Match_RequiresNotITBlock", ";", "}", "else", "if", "(", "Opc", "==", "ARM", "::", "tADDhirr", "&&", "isThumbOne", "(", ")", "&&", "!", "hasV6MOps", "(", ")", "&&", "isARMLowRegister", "(", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", "&&", "isARMLowRegister", "(", "Inst", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ")", "return", "Match_RequiresThumb2", ";", "else", "if", "(", "Opc", "==", "ARM", "::", "tMOVr", "&&", "isThumbOne", "(", ")", "&&", "!", "hasV6Ops", "(", ")", "&&", "isARMLowRegister", "(", "Inst", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", "&&", "isARMLowRegister", "(", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ")", "return", "Match_RequiresV6", ";", "return", "Match_Success", ";", "}", "</s>" ]

[ "checkTargetMatchPredicate", "-", "Validate", "the", "instruction", "match", "against", "any", "complex", "target", "predicates", "not", "expressible", "via", "match", "classes", "." ]

[ "ARM", "ARM", "ARMII::ThumbArithFlagSetting", "\"optionally flag setting instruction missing optional def operand\"", "\"operand count mismatch!\"", "0", "ARM::CPSR", "ARM::CPSR", "ARM::CPSR", "ARM::tADDhirr", "ARM", "1", "ARM", "2", "ARM::tMOVr", "ARM", "0", "ARM", "1" ]

[]

[ "<s>", "void", "MipsTargetLowering", "::", "AdjustInstrPostInstrSelection", "(", "MachineInstr", "&", "MI", ",", "SDNode", "*", "Node", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", ";", "case", "Mips", "::", "JALR", ":", "case", "Mips", "::", "JALRPseudo", ":", "case", "Mips", "::", "JALR64", ":", "case", "Mips", "::", "JALR64Pseudo", ":", "case", "Mips", "::", "JALR16_MM", ":", "case", "Mips", "::", "JALRC16_MMR6", ":", "case", "Mips", "::", "TAILCALLREG", ":", "case", "Mips", "::", "TAILCALLREG64", ":", "case", "Mips", "::", "TAILCALLR6REG", ":", "case", "Mips", "::", "TAILCALL64R6REG", ":", "case", "Mips", "::", "TAILCALLREG_MM", ":", "case", "Mips", "::", "TAILCALLREG_MMR6", ":", "{", "if", "(", "!", "EmitJalrReloc", "||", "Subtarget", ".", "inMips16Mode", "(", ")", "||", "!", "isPositionIndependent", "(", ")", "||", "Node", "->", "getNumOperands", "(", ")", "<", "1", "||", "Node", "->", "getOperand", "(", "0", ")", ".", "getNumOperands", "(", ")", "<", "2", ")", "{", "return", ";", "}", "const", "SDValue", "TargetAddr", "=", "Node", "->", "getOperand", "(", "0", ")", ".", "getOperand", "(", "1", ")", ";", "StringRef", "Sym", ";", "if", "(", "const", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast_or_null", "<", "const", "GlobalAddressSDNode", ">", "(", "TargetAddr", ")", ")", "{", "Sym", "=", "G", "->", "getGlobal", "(", ")", "->", "getName", "(", ")", ";", "}", "else", "if", "(", "const", "ExternalSymbolSDNode", "*", "ES", "=", "dyn_cast_or_null", "<", "const", "ExternalSymbolSDNode", ">", "(", "TargetAddr", ")", ")", "{", "Sym", "=", "ES", "->", "getSymbol", "(", ")", ";", "}", "if", "(", "Sym", ".", "empty", "(", ")", ")", "return", ";", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MCSymbol", "*", "S", "=", "MF", "->", "getContext", "(", ")", ".", "getOrCreateSymbol", "(", "Sym", ")", ";", "MI", ".", "addOperand", "(", "MachineOperand", "::", "CreateMCSymbol", "(", "S", ",", "MipsII", "::", "MO_JALR", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::JALR", "Mips::JALRPseudo", "Mips::JALR64", "Mips::JALR64Pseudo", "Mips::JALR16_MM", "Mips::JALRC16_MMR6", "Mips::TAILCALLREG", "Mips::TAILCALLREG64", "Mips::TAILCALLR6REG", "Mips::TAILCALL64R6REG", "Mips::TAILCALLREG_MM", "Mips::TAILCALLREG_MMR6", "Mips", "1", "0", "2", "0", "1", "MipsII::MO_JALR" ]

[]

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

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

[ "TOY", "TOY" ]

[]

[ "<s>", "static", "void", "cris_init_libfuncs", "(", "void", ")", "{", "set_optab_libfunc", "(", "smul_optab", ",", "SImode", ",", "\"__Mul\"", ")", ";", "set_optab_libfunc", "(", "sdiv_optab", ",", "SImode", ",", "\"__Div\"", ")", ";", "set_optab_libfunc", "(", "udiv_optab", ",", "SImode", ",", "\"__Udiv\"", ")", ";", "set_optab_libfunc", "(", "smod_optab", ",", "SImode", ",", "\"__Mod\"", ")", ";", "set_optab_libfunc", "(", "umod_optab", ",", "SImode", ",", "\"__Umod\"", ")", ";", "if", "(", "TARGET_ATOMICS_MAY_CALL_LIBFUNCS", ")", "{", "set_optab_libfunc", "(", "sync_compare_and_swap_optab", ",", "SImode", ",", "\"__cris_atcmpxchgr32\"", ")", ";", "set_optab_libfunc", "(", "sync_compare_and_swap_optab", ",", "HImode", ",", "\"__cris_atcmpxchgr16\"", ")", ";", "}", "}", "</s>" ]

[ "Rename", "the", "function", "calls", "for", "integer", "multiply", "and", "divide", "." ]

[ "cris", "\"__Mul\"", "\"__Div\"", "\"__Udiv\"", "\"__Mod\"", "\"__Umod\"", "\"__cris_atcmpxchgr32\"", "\"__cris_atcmpxchgr16\"" ]

[]

[ "<s>", "bool", "HexagonTargetMachine", "::", "addPreRegAlloc", "(", "PassManagerBase", "&", "PM", ")", "{", "if", "(", "!", "DisableHardwareLoops", ")", "{", "PM", ".", "add", "(", "createHexagonHardwareLoops", "(", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

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

[]

[ "<s>", "bool", "MipsSEInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "bool", "isMicroMips", "=", "Subtarget", ".", "inMicroMipsMode", "(", ")", ";", "unsigned", "Opc", ";", "switch", "(", "MI", "->", "getDesc", "(", ")", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Mips", "::", "RetRA", ":", "expandRetRA", "(", "MBB", ",", "MI", ")", ";", "break", ";", "case", "Mips", "::", "ERet", ":", "expandERet", "(", "MBB", ",", "MI", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMFHI", ":", "Opc", "=", "isMicroMips", "?", "Mips", "::", "MFHI16_MM", ":", "Mips", "::", "MFHI", ";", "expandPseudoMFHiLo", "(", "MBB", ",", "MI", ",", "Opc", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMFLO", ":", "Opc", "=", "isMicroMips", "?", "Mips", "::", "MFLO16_MM", ":", "Mips", "::", "MFLO", ";", "expandPseudoMFHiLo", "(", "MBB", ",", "MI", ",", "Opc", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMFHI64", ":", "expandPseudoMFHiLo", "(", "MBB", ",", "MI", ",", "Mips", "::", "MFHI64", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMFLO64", ":", "expandPseudoMFHiLo", "(", "MBB", ",", "MI", ",", "Mips", "::", "MFLO64", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMTLOHI", ":", "expandPseudoMTLoHi", "(", "MBB", ",", "MI", ",", "Mips", "::", "MTLO", ",", "Mips", "::", "MTHI", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMTLOHI64", ":", "expandPseudoMTLoHi", "(", "MBB", ",", "MI", ",", "Mips", "::", "MTLO64", ",", "Mips", "::", "MTHI64", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMTLOHI_DSP", ":", "expandPseudoMTLoHi", "(", "MBB", ",", "MI", ",", "Mips", "::", "MTLO_DSP", ",", "Mips", "::", "MTHI_DSP", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_S_W", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_S_W", ",", "Mips", "::", "MTC1", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_D32_W", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_D32_W", ",", "Mips", "::", "MTC1", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_S_L", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_S_L", ",", "Mips", "::", "DMTC1", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_D64_W", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_D64_W", ",", "Mips", "::", "MTC1", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_D64_L", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_D64_L", ",", "Mips", "::", "DMTC1", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "BuildPairF64", ":", "expandBuildPairF64", "(", "MBB", ",", "MI", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "BuildPairF64_64", ":", "expandBuildPairF64", "(", "MBB", ",", "MI", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "ExtractElementF64", ":", "expandExtractElementF64", "(", "MBB", ",", "MI", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "ExtractElementF64_64", ":", "expandExtractElementF64", "(", "MBB", ",", "MI", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "MIPSeh_return32", ":", "case", "Mips", "::", "MIPSeh_return64", ":", "expandEhReturn", "(", "MBB", ",", "MI", ")", ";", "break", ";", "}", "MBB", ".", "erase", "(", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips::RetRA", "Mips::ERet", "Mips::PseudoMFHI", "Mips", "Mips::MFHI16_MM", "Mips::MFHI", "Mips::PseudoMFLO", "Mips", "Mips::MFLO16_MM", "Mips::MFLO", "Mips::PseudoMFHI64", "Mips::MFHI64", "Mips::PseudoMFLO64", "Mips::MFLO64", "Mips::PseudoMTLOHI", "Mips::MTLO", "Mips::MTHI", "Mips::PseudoMTLOHI64", "Mips::MTLO64", "Mips::MTHI64", "Mips::PseudoMTLOHI_DSP", "Mips::MTLO_DSP", "Mips::MTHI_DSP", "Mips::PseudoCVT_S_W", "Mips::CVT_S_W", "Mips::MTC1", "Mips::PseudoCVT_D32_W", "Mips::CVT_D32_W", "Mips::MTC1", "Mips::PseudoCVT_S_L", "Mips::CVT_S_L", "Mips::DMTC1", "Mips::PseudoCVT_D64_W", "Mips::CVT_D64_W", "Mips::MTC1", "Mips::PseudoCVT_D64_L", "Mips::CVT_D64_L", "Mips::DMTC1", "Mips::BuildPairF64", "Mips::BuildPairF64_64", "Mips::ExtractElementF64", "Mips::ExtractElementF64_64", "Mips::MIPSeh_return32", "Mips::MIPSeh_return64" ]

[]

[ "<s>", "bool", "RISCVRegisterInfo", "::", "hasReservedSpillSlot", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Reg", ",", "int", "&", "FrameIdx", ")", "const", "{", "const", "auto", "*", "RVFI", "=", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "RVFI", "->", "useSaveRestoreLibCalls", "(", ")", ")", "return", "false", ";", "auto", "FII", "=", "FixedCSRFIMap", ".", "find", "(", "Reg", ")", ";", "if", "(", "FII", "==", "FixedCSRFIMap", ".", "end", "(", ")", ")", "return", "false", ";", "FrameIdx", "=", "FII", "->", "second", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "target", "has", "reserved", "a", "spill", "slot", "in", "the", "stack", "frame", "of", "the", "given", "function", "for", "the", "specified", "register", "." ]

[ "RISCV", "RISCV", "RISCV" ]

[]

[ "<s>", "int", "SystemZTTIImpl", "::", "getIntrinsicInstrCost", "(", "Intrinsic", "::", "ID", "ID", ",", "Type", "*", "RetTy", ",", "ArrayRef", "<", "Type", "*", ">", "Tys", ",", "FastMathFlags", "FMF", ",", "unsigned", "ScalarizationCostPassed", ",", "const", "Instruction", "*", "I", ")", "{", "int", "Cost", "=", "getVectorIntrinsicInstrCost", "(", "ID", ",", "RetTy", ")", ";", "if", "(", "Cost", "!=", "-", "1", ")", "return", "Cost", ";", "return", "BaseT", "::", "getIntrinsicInstrCost", "(", "ID", ",", "RetTy", ",", "Tys", ",", "FMF", ",", "ScalarizationCostPassed", ",", "I", ")", ";", "}", "</s>" ]

[ "Get", "intrinsic", "cost", "based", "on", "arguments", "." ]

[ "SystemZ", "SystemZ", "Intrinsic::ID", "1" ]

[]

[ "<s>", "SDNode", "*", "PPCDAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "if", "(", "!", "GlobalBaseReg", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "PPCSubTarget", "->", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", "->", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "const", "Module", "*", "M", "=", "MF", "->", "getFunction", "(", ")", ".", "getParent", "(", ")", ";", "DebugLoc", "dl", ";", "if", "(", "PPCLowering", "->", "getPointerTy", "(", "CurDAG", "->", "getDataLayout", "(", ")", ")", "==", "MVT", "::", "i32", ")", "{", "if", "(", "PPCSubTarget", "->", "isTargetELF", "(", ")", ")", "{", "GlobalBaseReg", "=", "PPC", "::", "R30", ";", "if", "(", "!", "PPCSubTarget", "->", "isSecurePlt", "(", ")", "&&", "M", "->", "getPICLevel", "(", ")", "==", "PICLevel", "::", "SmallPIC", ")", "{", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MoveGOTtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "setUsesPICBase", "(", "true", ")", ";", "}", "else", "{", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "Register", "TempReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "GPRCRegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "UpdateGBR", ")", ",", "GlobalBaseReg", ")", ".", "addReg", "(", "TempReg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "GlobalBaseReg", ")", ";", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "setUsesPICBase", "(", "true", ")", ";", "}", "}", "else", "{", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "GPRC_and_GPRC_NOR0RegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "}", "}", "else", "{", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "setShrinkWrapDisabled", "(", "true", ")", ";", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "G8RC_and_G8RC_NOX0RegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR8", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR8", ")", ",", "GlobalBaseReg", ")", ";", "}", "}", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "PPCLowering", "->", "getPointerTy", "(", "CurDAG", "->", "getDataLayout", "(", ")", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "MVT::i32", "PPC", "PPC::R30", "PPC", "PPC::MoveGOTtoLR", "PPC::MFLR", "PPC", "PPC::MovePCtoLR", "PPC::MFLR", "PPC::GPRCRegClass", "PPC::UpdateGBR", "PPC", "PPC::GPRC_and_GPRC_NOR0RegClass", "PPC::MovePCtoLR", "PPC::MFLR", "PPC", "PPC::G8RC_and_G8RC_NOX0RegClass", "PPC::MovePCtoLR8", "PPC::MFLR8", "PPC" ]

[]

[ "<s>", "static", "tree", "sparc_d_handle_target_float_abi", "(", "void", ")", "{", "const", "char", "*", "abi", ";", "if", "(", "TARGET_FPU", ")", "abi", "=", "\"hard\"", ";", "else", "abi", "=", "\"soft\"", ";", "return", "build_string_literal", "(", "strlen", "(", "abi", ")", "+", "1", ",", "abi", ")", ";", "}", "</s>" ]

[ "Handle", "a", "call", "to", "`", "__traits", "(", "getTargetInfo", ",", "``", "floatAbi", "''", ")", "'", "." ]

[ "sparc", "\"hard\"", "\"soft\"", "1" ]

[]

[ "<s>", "static", "inline", "unsigned", "int", "cr16_ret_register", "(", "void", ")", "{", "return", "0", ";", "}", "</s>" ]

[ "Returns", "register", "number", "for", "function", "return", "value", "." ]

[ "cr16", "0" ]

[]

[ "<s>", "const", "char", "*", "RISCVTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "RISCVISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "RISCVISD", "::", "FIRST_NUMBER", ":", "break", ";", "case", "RISCVISD", "::", "RET_FLAG", ":", "return", "\"RISCVISD::RET_FLAG\"", ";", "case", "RISCVISD", "::", "URET_FLAG", ":", "return", "\"RISCVISD::URET_FLAG\"", ";", "case", "RISCVISD", "::", "SRET_FLAG", ":", "return", "\"RISCVISD::SRET_FLAG\"", ";", "case", "RISCVISD", "::", "MRET_FLAG", ":", "return", "\"RISCVISD::MRET_FLAG\"", ";", "case", "RISCVISD", "::", "CALL", ":", "return", "\"RISCVISD::CALL\"", ";", "case", "RISCVISD", "::", "SELECT_CC", ":", "return", "\"RISCVISD::SELECT_CC\"", ";", "case", "RISCVISD", "::", "BuildPairF64", ":", "return", "\"RISCVISD::BuildPairF64\"", ";", "case", "RISCVISD", "::", "SplitF64", ":", "return", "\"RISCVISD::SplitF64\"", ";", "case", "RISCVISD", "::", "TAIL", ":", "return", "\"RISCVISD::TAIL\"", ";", "case", "RISCVISD", "::", "SLLW", ":", "return", "\"RISCVISD::SLLW\"", ";", "case", "RISCVISD", "::", "SRAW", ":", "return", "\"RISCVISD::SRAW\"", ";", "case", "RISCVISD", "::", "SRLW", ":", "return", "\"RISCVISD::SRLW\"", ";", "case", "RISCVISD", "::", "DIVW", ":", "return", "\"RISCVISD::DIVW\"", ";", "case", "RISCVISD", "::", "DIVUW", ":", "return", "\"RISCVISD::DIVUW\"", ";", "case", "RISCVISD", "::", "REMUW", ":", "return", "\"RISCVISD::REMUW\"", ";", "case", "RISCVISD", "::", "FMV_W_X_RV64", ":", "return", "\"RISCVISD::FMV_W_X_RV64\"", ";", "case", "RISCVISD", "::", "FMV_X_ANYEXTW_RV64", ":", "return", "\"RISCVISD::FMV_X_ANYEXTW_RV64\"", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCVISD::NodeType", "RISCVISD::FIRST_NUMBER", "RISCVISD::RET_FLAG", "\"RISCVISD::RET_FLAG\"", "RISCVISD::URET_FLAG", "\"RISCVISD::URET_FLAG\"", "RISCVISD::SRET_FLAG", "\"RISCVISD::SRET_FLAG\"", "RISCVISD::MRET_FLAG", "\"RISCVISD::MRET_FLAG\"", "RISCVISD::CALL", "\"RISCVISD::CALL\"", "RISCVISD::SELECT_CC", "\"RISCVISD::SELECT_CC\"", "RISCVISD::BuildPairF64", "\"RISCVISD::BuildPairF64\"", "RISCVISD::SplitF64", "\"RISCVISD::SplitF64\"", "RISCVISD::TAIL", "\"RISCVISD::TAIL\"", "RISCVISD::SLLW", "\"RISCVISD::SLLW\"", "RISCVISD::SRAW", "\"RISCVISD::SRAW\"", "RISCVISD::SRLW", "\"RISCVISD::SRLW\"", "RISCVISD::DIVW", "\"RISCVISD::DIVW\"", "RISCVISD::DIVUW", "\"RISCVISD::DIVUW\"", "RISCVISD::REMUW", "\"RISCVISD::REMUW\"", "RISCVISD::FMV_W_X_RV64", "\"RISCVISD::FMV_W_X_RV64\"", "RISCVISD::FMV_X_ANYEXTW_RV64", "\"RISCVISD::FMV_X_ANYEXTW_RV64\"" ]

[]

[ "<s>", "void", "emitSymbolDesc", "(", "MCSymbol", "*", "Symbol", ",", "unsigned", "DescValue", ")", "override", "{", "}", "</s>" ]

[ "Set", "the", "DescValue", "for", "the", "Symbol", "." ]

[ "Patmos" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "canMergeStoresTo", "(", "unsigned", "AddressSpace", ",", "EVT", "MemVT", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "bool", "NoFloat", "=", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ";", "if", "(", "NoFloat", ")", "{", "unsigned", "MaxIntSize", "=", "Subtarget", ".", "is64Bit", "(", ")", "?", "64", ":", "32", ";", "return", "(", "MemVT", ".", "getSizeInBits", "(", ")", "<=", "MaxIntSize", ")", ";", "}", "if", "(", "MemVT", ".", "getSizeInBits", "(", ")", ">", "Subtarget", ".", "getPreferVectorWidth", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "if", "it", "'s", "reasonable", "to", "merge", "stores", "to", "MemVT", "size", "." ]

[ "X86", "X86", "64", "32" ]

[]

[ "<s>", "bool", "AlphaTargetLowering", "::", "isOffsetFoldingLegal", "(", "const", "GlobalAddressSDNode", "*", "GA", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "folding", "a", "constant", "offset", "with", "the", "given", "GlobalAddress", "is", "legal", "." ]

[ "Alpha", "Alpha" ]

[]

[ "<s>", "rtx", "find_addr_reg", "(", "rtx", "addr", ")", "{", "while", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "!=", "0", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "!=", "0", ")", "addr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "if", "(", "CONSTANT_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", "addr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "if", "(", "CONSTANT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "addr", ")", "==", "REG", "&&", "REGNO", "(", "addr", ")", "!=", "0", ")", ";", "return", "addr", ";", "}", "</s>" ]

[ "Return", "a", "REG", "that", "occurs", "in", "ADDR", "with", "coefficient", "1", ".", "ADDR", "can", "be", "effectively", "incremented", "by", "incrementing", "REG", ".", "r0", "is", "special", "and", "we", "must", "not", "select", "it", "as", "an", "address", "register", "by", "this", "routine", "since", "our", "caller", "will", "try", "to", "increment", "the", "returned", "register", "via", "an", "``", "la", "''", "instruction", "." ]

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

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"MOV to LEA transformation pass\"", ";", "}", "</s>" ]

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

[ "X86", "\"MOV to LEA transformation pass\"" ]

[]

[ "<s>", "bool", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "llvm_unreachable", "(", "\"Handled by fixupNeedsRelaxationAdvanced\"", ")", ";", "}", "</s>" ]

[ "Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "." ]

[ "RISCV", "\"Handled by fixupNeedsRelaxationAdvanced\"" ]

[]

[ "<s>", "static", "int", "rs6000_cpu_name_lookup", "(", "const", "char", "*", "name", ")", "{", "size_t", "i", ";", "if", "(", "name", "!=", "NULL", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "processor_target_table", ")", ";", "i", "++", ")", "if", "(", "!", "strcmp", "(", "name", ",", "processor_target_table", "[", "i", "]", ".", "name", ")", ")", "return", "(", "int", ")", "i", ";", "}", "return", "-", "1", ";", "}", "</s>" ]

[ "Look", "up", "a", "processor", "name", "for", "-mcpu=xxx", "and", "-mtune=xxx", ".", "Return", "-1", "if", "the", "name", "is", "invalid", "." ]

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

[]

[ "<s>", "int", "tls_call_delay", "(", "rtx", "trial", ")", "{", "rtx", "pat", ";", "if", "(", "TARGET_GNU_TLS", "||", "!", "TARGET_TLS", ")", "return", "1", ";", "pat", "=", "PATTERN", "(", "trial", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_SRC", "(", "pat", ")", ")", "==", "PLUS", ")", "{", "rtx", "unspec", "=", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "unspec", ")", "==", "UNSPEC", "&&", "(", "XINT", "(", "unspec", ",", "1", ")", "==", "UNSPEC_TLSGD", "||", "XINT", "(", "unspec", ",", "1", ")", "==", "UNSPEC_TLSLDM", ")", ")", "return", "0", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "TRIAL", "can", "go", "into", "the", "call", "delay", "slot", "." ]

[ "sparc", "1", "1", "1", "1", "0", "1" ]

[]

[ "<s>", "bool", "WinEHStatePass", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "StringRef", "WinEHParentName", "=", "F", ".", "getFnAttribute", "(", "\"wineh-parent\"", ")", ".", "getValueAsString", "(", ")", ";", "if", "(", "WinEHParentName", "!=", "F", ".", "getName", "(", ")", "&&", "!", "WinEHParentName", ".", "empty", "(", ")", ")", "return", "false", ";", "LandingPadInst", "*", "LP", "=", "nullptr", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "LP", "=", "BB", ".", "getLandingPadInst", "(", ")", ";", "if", "(", "LP", ")", "break", ";", "}", "if", "(", "!", "LP", ")", "return", "false", ";", "PersonalityFn", "=", "dyn_cast", "<", "Function", ">", "(", "LP", "->", "getPersonalityFn", "(", ")", "->", "stripPointerCasts", "(", ")", ")", ";", "if", "(", "!", "PersonalityFn", ")", "return", "false", ";", "Personality", "=", "classifyEHPersonality", "(", "PersonalityFn", ")", ";", "if", "(", "!", "isMSVCEHPersonality", "(", "Personality", ")", ")", "return", "false", ";", "F", ".", "addFnAttr", "(", "\"no-frame-pointer-elim\"", ",", "\"true\"", ")", ";", "emitExceptionRegistrationRecord", "(", "&", "F", ")", ";", "auto", "*", "MMIPtr", "=", "getAnalysisIfAvailable", "<", "MachineModuleInfo", ">", "(", ")", ";", "assert", "(", "MMIPtr", "&&", "\"MachineModuleInfo should always be available\"", ")", ";", "MachineModuleInfo", "&", "MMI", "=", "*", "MMIPtr", ";", "if", "(", "Personality", "==", "EHPersonality", "::", "MSVC_CXX", ")", "{", "addCXXStateStores", "(", "F", ",", "MMI", ")", ";", "}", "PersonalityFn", "=", "nullptr", ";", "Personality", "=", "EHPersonality", "::", "Unknown", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "\"wineh-parent\"", "\"no-frame-pointer-elim\"", "\"true\"", "\"MachineModuleInfo should always be available\"" ]

[]

[ "<s>", "static", "bool", "examine_argument", "(", "machine_mode", "mode", ",", "const_tree", "type", ",", "int", "in_return", ",", "int", "*", "int_nregs", ",", "int", "*", "sse_nregs", ")", "{", "enum", "x86_64_reg_class", "regclass", "[", "MAX_CLASSES", "]", ";", "int", "n", "=", "classify_argument", "(", "mode", ",", "type", ",", "regclass", ",", "0", ")", ";", "*", "int_nregs", "=", "0", ";", "*", "sse_nregs", "=", "0", ";", "if", "(", "!", "n", ")", "return", "true", ";", "for", "(", "n", "--", ";", "n", ">=", "0", ";", "n", "--", ")", "switch", "(", "regclass", "[", "n", "]", ")", "{", "case", "X86_64_INTEGER_CLASS", ":", "case", "X86_64_INTEGERSI_CLASS", ":", "(", "*", "int_nregs", ")", "++", ";", "break", ";", "case", "X86_64_SSE_CLASS", ":", "case", "X86_64_SSEHF_CLASS", ":", "case", "X86_64_SSESF_CLASS", ":", "case", "X86_64_SSEDF_CLASS", ":", "(", "*", "sse_nregs", ")", "++", ";", "break", ";", "case", "X86_64_NO_CLASS", ":", "case", "X86_64_SSEUP_CLASS", ":", "break", ";", "case", "X86_64_X87_CLASS", ":", "case", "X86_64_X87UP_CLASS", ":", "case", "X86_64_COMPLEX_X87_CLASS", ":", "if", "(", "!", "in_return", ")", "return", "true", ";", "break", ";", "case", "X86_64_MEMORY_CLASS", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Examine", "the", "argument", "and", "return", "set", "number", "of", "register", "required", "in", "each", "class", ".", "Return", "0", "iff", "parameter", "should", "be", "passed", "in", "memory", "." ]

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

[]

[ "<s>", "void", "rs6000_asm_output_opcode", "(", "FILE", "*", "stream", ")", "{", "if", "(", "prepend_p_to_next_insn", ")", "{", "fprintf", "(", "stream", ",", "\"p\"", ")", ";", "prepend_p_to_next_insn", "=", "false", ";", "}", "return", ";", "}", "</s>" ]

[ "Define", "ASM_OUTPUT_OPCODE", "to", "do", "anything", "special", "before", "emitting", "an", "opcode", ".", "We", "use", "it", "to", "emit", "a", "'", "p", "'", "for", "prefixed", "insns", "that", "is", "set", "in", "FINAL_PRESCAN_INSN", "." ]

[ "rs6000", "\"p\"" ]

[]

[ "<s>", "unsigned", "SPURegisterInfo", "::", "getRARegister", "(", ")", "const", "{", "return", "SPU", "::", "R0", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "SPU::R0" ]

[]

[ "<s>", "static", "void", "avr_set_current_function", "(", "tree", "decl", ")", "{", "location_t", "loc", ";", "const", "char", "*", "isr", ";", "if", "(", "decl", "==", "NULL_TREE", "||", "current_function_decl", "==", "NULL_TREE", "||", "current_function_decl", "==", "error_mark_node", "||", "!", "cfun", "->", "machine", "||", "cfun", "->", "machine", "->", "attributes_checked_p", ")", "return", ";", "loc", "=", "DECL_SOURCE_LOCATION", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_naked", "=", "avr_naked_function_p", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_signal", "=", "avr_signal_function_p", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_interrupt", "=", "avr_interrupt_function_p", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_OS_task", "=", "avr_OS_task_function_p", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_OS_main", "=", "avr_OS_main_function_p", "(", "decl", ")", ";", "isr", "=", "cfun", "->", "machine", "->", "is_interrupt", "?", "\"interrupt\"", ":", "\"signal\"", ";", "if", "(", "cfun", "->", "machine", "->", "is_OS_task", "+", "cfun", "->", "machine", "->", "is_OS_main", "+", "(", "cfun", "->", "machine", "->", "is_signal", "||", "cfun", "->", "machine", "->", "is_interrupt", ")", ">", "1", ")", "error_at", "(", "loc", ",", "\"function attributes %qs, %qs and %qs are mutually\"", "\" exclusive\"", ",", "\"OS_task\"", ",", "\"OS_main\"", ",", "isr", ")", ";", "if", "(", "cfun", "->", "machine", "->", "is_naked", "&&", "(", "cfun", "->", "machine", "->", "is_OS_task", "||", "cfun", "->", "machine", "->", "is_OS_main", ")", ")", "warning_at", "(", "loc", ",", "OPT_Wattributes", ",", "\"function attributes %qs and %qs have\"", "\" no effect on %qs function\"", ",", "\"OS_task\"", ",", "\"OS_main\"", ",", "\"naked\"", ")", ";", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", "||", "cfun", "->", "machine", "->", "is_signal", ")", "{", "tree", "args", "=", "TYPE_ARG_TYPES", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "tree", "ret", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "const", "char", "*", "name", ";", "name", "=", "DECL_ASSEMBLER_NAME_SET_P", "(", "decl", ")", "?", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ":", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "decl", ")", ")", ";", "name", "=", "default_strip_name_encoding", "(", "name", ")", ";", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", ")", "cfun", "->", "machine", "->", "is_signal", "=", "0", ";", "if", "(", "args", "&&", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "!=", "VOID_TYPE", ")", "error_at", "(", "loc", ",", "\"%qs function cannot have arguments\"", ",", "isr", ")", ";", "if", "(", "TREE_CODE", "(", "ret", ")", "!=", "VOID_TYPE", ")", "error_at", "(", "loc", ",", "\"%qs function cannot return a value\"", ",", "isr", ")", ";", "if", "(", "!", "STR_PREFIX_P", "(", "name", ",", "\"__vector\"", ")", ")", "warning_at", "(", "loc", ",", "OPT_Wmisspelled_isr", ",", "\"%qs appears to be a misspelled \"", "\"%s handler, missing __vector prefix\"", ",", "name", ",", "isr", ")", ";", "}", "cfun", "->", "machine", "->", "attributes_checked_p", "=", "1", ";", "}", "</s>" ]

[ "Sanity", "cheching", "for", "above", "function", "attributes", "." ]

[ "avr", "\"interrupt\"", "\"signal\"", "1", "\"function attributes %qs, %qs and %qs are mutually\"", "\" exclusive\"", "\"OS_task\"", "\"OS_main\"", "\"function attributes %qs and %qs have\"", "\" no effect on %qs function\"", "\"OS_task\"", "\"OS_main\"", "\"naked\"", "0", "\"%qs function cannot have arguments\"", "\"%qs function cannot return a value\"", "\"__vector\"", "\"%qs appears to be a misspelled \"", "\"%s handler, missing __vector prefix\"", "1" ]

[]

[ "<s>", "bool", "JVMAsmBackend", "::", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "." ]

[ "JVM", "JVM" ]

[]

[ "<s>", "int", "RISCVTTIImpl", "::", "getIntImmCostInst", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", "&&", "\"getIntImmCost can only estimate cost of materialising integers\"", ")", ";", "if", "(", "Imm", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "bool", "Takes12BitImm", "=", "false", ";", "unsigned", "ImmArgIdx", "=", "~", "0U", ";", "switch", "(", "Opcode", ")", "{", "case", "Instruction", "::", "GetElementPtr", ":", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "Add", ":", "case", "Instruction", "::", "And", ":", "case", "Instruction", "::", "Or", ":", "case", "Instruction", "::", "Xor", ":", "case", "Instruction", "::", "Mul", ":", "Takes12BitImm", "=", "true", ";", "break", ";", "case", "Instruction", "::", "Sub", ":", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "Takes12BitImm", "=", "true", ";", "ImmArgIdx", "=", "1", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "Takes12BitImm", ")", "{", "if", "(", "Instruction", "::", "isCommutative", "(", "Opcode", ")", "||", "Idx", "==", "ImmArgIdx", ")", "{", "if", "(", "Imm", ".", "getMinSignedBits", "(", ")", "<=", "64", "&&", "getTLI", "(", ")", "->", "isLegalAddImmediate", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "{", "return", "TTI", "::", "TCC_Free", ";", "}", "}", "return", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "}", "return", "TTI", "::", "TCC_Free", ";", "}", "</s>" ]

[ "Return", "the", "expected", "cost", "of", "materialization", "for", "the", "given", "integer", "immediate", "of", "the", "specified", "type", "for", "a", "given", "instruction", "." ]

[ "RISCV", "RISCV", "\"getIntImmCost can only estimate cost of materialising integers\"", "0", "0U", "1", "64" ]

[]

[ "<s>", "void", "FISCFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "computeStackSize", "(", "MF", ")", ";", "if", "(", "!", "StackSize", ")", "return", ";", "unsigned", "StackReg", "=", "FISC", "::", "SP", ";", "unsigned", "OffsetReg", "=", "materializeOffset", "(", "MF", ",", "MBB", ",", "MBBI", ",", "(", "unsigned", ")", "StackSize", ")", ";", "if", "(", "OffsetReg", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "FISC", "::", "SUBrr", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ")", ".", "addReg", "(", "OffsetReg", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "FISC", "::", "SUBri", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ")", ".", "addImm", "(", "StackSize", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "}", "</s>" ]

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

[ "FISC", "FISC", "FISC::SP", "FISC::SUBrr", "FISC::SUBri" ]

[]

[ "<s>", "bool", "HexagonMCChecker", "::", "check", "(", "bool", "FullCheck", ")", "{", "bool", "chkP", "=", "checkPredicates", "(", ")", ";", "bool", "chkNV", "=", "checkNewValues", "(", ")", ";", "bool", "chkR", "=", "checkRegisters", "(", ")", ";", "bool", "chkRRO", "=", "checkRegistersReadOnly", "(", ")", ";", "checkRegisterCurDefs", "(", ")", ";", "bool", "chkS", "=", "checkSolo", "(", ")", ";", "bool", "chkSh", "=", "true", ";", "if", "(", "FullCheck", ")", "chkSh", "=", "checkShuffle", "(", ")", ";", "bool", "chkSl", "=", "true", ";", "if", "(", "FullCheck", ")", "chkSl", "=", "checkSlots", "(", ")", ";", "bool", "chkAXOK", "=", "checkAXOK", "(", ")", ";", "bool", "chkCofMax1", "=", "checkCOFMax1", "(", ")", ";", "bool", "chkHWLoop", "=", "checkHWLoop", "(", ")", ";", "bool", "chk", "=", "chkP", "&&", "chkNV", "&&", "chkR", "&&", "chkRRO", "&&", "chkS", "&&", "chkSh", "&&", "chkSl", "&&", "chkAXOK", "&&", "chkCofMax1", "&&", "chkHWLoop", ";", "return", "chk", ";", "}", "</s>" ]

[ "Check", "if", "the", "constraints", "are", "satisfiable", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "HSAILTargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ")", "const", "{", "return", "(", "VT", "==", "EVT", "(", "MVT", "::", "f32", ")", "||", "VT", "==", "EVT", "(", "MVT", "::", "f64", ")", ")", ";", "}", "</s>" ]

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

[ "HSAIL", "HSAIL", "MVT::f32", "MVT::f64" ]

[]

[ "<s>", "void", "SHUXIFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "}", "</s>" ]

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

[ "SHUXI", "SHUXI" ]

[]

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

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

[ "SIC", "SIC" ]

[]

[ "<s>", "char", "*", "output_call", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operands", ",", "int", "dest_operand_number", ",", "int", "cookie_operand_number", ")", "{", "static", "char", "buf", "[", "256", "]", ";", "if", "(", "darwin_emit_branch_islands", "&&", "GET_CODE", "(", "operands", "[", "dest_operand_number", "]", ")", "==", "SYMBOL_REF", "&&", "(", "INTVAL", "(", "operands", "[", "cookie_operand_number", "]", ")", "&", "CALL_LONG", ")", ")", "{", "tree", "labelname", ";", "tree", "funname", "=", "get_identifier", "(", "XSTR", "(", "operands", "[", "dest_operand_number", "]", ",", "0", ")", ")", ";", "if", "(", "no_previous_def", "(", "funname", ")", ")", "{", "rtx", "label_rtx", "=", "gen_label_rtx", "(", ")", ";", "char", "*", "label_buf", ",", "temp_buf", "[", "256", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "temp_buf", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "label_rtx", ")", ")", ";", "label_buf", "=", "temp_buf", "[", "0", "]", "==", "'*'", "?", "temp_buf", "+", "1", ":", "temp_buf", ";", "labelname", "=", "get_identifier", "(", "label_buf", ")", ";", "add_compiler_branch_island", "(", "labelname", ",", "funname", ",", "insn_line", "(", "insn", ")", ")", ";", "}", "else", "labelname", "=", "get_prev_label", "(", "funname", ")", ";", "sprintf", "(", "buf", ",", "\"jbsr %%z%d,%.246s\"", ",", "dest_operand_number", ",", "IDENTIFIER_POINTER", "(", "labelname", ")", ")", ";", "}", "else", "sprintf", "(", "buf", ",", "\"bl %%z%d\"", ",", "dest_operand_number", ")", ";", "return", "buf", ";", "}", "</s>" ]

[ "INSN", "is", "either", "a", "function", "call", "or", "a", "millicode", "call", ".", "It", "may", "have", "an", "unconditional", "jump", "in", "its", "delay", "slot", ".", "CALL_DEST", "is", "the", "routine", "we", "are", "calling", "." ]

[ "rs6000", "256", "0", "256", "\"L\"", "0", "1", "\"jbsr %%z%d,%.246s\"", "\"bl %%z%d\"" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "SplitVectorStore", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "StoreSDNode", "*", "Store", "=", "cast", "<", "StoreSDNode", ">", "(", "Op", ")", ";", "SDValue", "Val", "=", "Store", "->", "getValue", "(", ")", ";", "EVT", "VT", "=", "Val", ".", "getValueType", "(", ")", ";", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "2", ")", "return", "scalarizeVectorStore", "(", "Store", ",", "DAG", ")", ";", "EVT", "MemVT", "=", "Store", "->", "getMemoryVT", "(", ")", ";", "SDValue", "Chain", "=", "Store", "->", "getChain", "(", ")", ";", "SDValue", "BasePtr", "=", "Store", "->", "getBasePtr", "(", ")", ";", "SDLoc", "SL", "(", "Op", ")", ";", "EVT", "LoVT", ",", "HiVT", ";", "EVT", "LoMemVT", ",", "HiMemVT", ";", "SDValue", "Lo", ",", "Hi", ";", "std", "::", "tie", "(", "LoVT", ",", "HiVT", ")", "=", "DAG", ".", "GetSplitDestVTs", "(", "VT", ")", ";", "std", "::", "tie", "(", "LoMemVT", ",", "HiMemVT", ")", "=", "DAG", ".", "GetSplitDestVTs", "(", "MemVT", ")", ";", "std", "::", "tie", "(", "Lo", ",", "Hi", ")", "=", "DAG", ".", "SplitVector", "(", "Val", ",", "SL", ",", "LoVT", ",", "HiVT", ")", ";", "EVT", "PtrVT", "=", "BasePtr", ".", "getValueType", "(", ")", ";", "SDValue", "HiPtr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "SL", ",", "PtrVT", ",", "BasePtr", ",", "DAG", ".", "getConstant", "(", "LoMemVT", ".", "getStoreSize", "(", ")", ",", "SL", ",", "PtrVT", ")", ")", ";", "const", "MachinePointerInfo", "&", "SrcValue", "=", "Store", "->", "getMemOperand", "(", ")", "->", "getPointerInfo", "(", ")", ";", "unsigned", "BaseAlign", "=", "Store", "->", "getAlignment", "(", ")", ";", "unsigned", "Size", "=", "LoMemVT", ".", "getStoreSize", "(", ")", ";", "unsigned", "HiAlign", "=", "MinAlign", "(", "BaseAlign", ",", "Size", ")", ";", "SDValue", "LoStore", "=", "DAG", ".", "getTruncStore", "(", "Chain", ",", "SL", ",", "Lo", ",", "BasePtr", ",", "SrcValue", ",", "LoMemVT", ",", "BaseAlign", ",", "Store", "->", "getMemOperand", "(", ")", "->", "getFlags", "(", ")", ")", ";", "SDValue", "HiStore", "=", "DAG", ".", "getTruncStore", "(", "Chain", ",", "SL", ",", "Hi", ",", "HiPtr", ",", "SrcValue", ".", "getWithOffset", "(", "Size", ")", ",", "HiMemVT", ",", "HiAlign", ",", "Store", "->", "getMemOperand", "(", ")", "->", "getFlags", "(", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "SL", ",", "MVT", "::", "Other", ",", "LoStore", ",", "HiStore", ")", ";", "}", "</s>" ]

[ "Split", "a", "vector", "store", "into", "2", "stores", "of", "half", "the", "vector", "." ]

[ "AMDGPU", "AMDGPU", "2", "ISD::ADD", "ISD::TokenFactor", "MVT::Other" ]

[]

[ "<s>", "bool", "MipsAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"ParseInstruction\\n\"", ")", ";", "getTargetStreamer", "(", ")", ".", "forbidModuleDirective", "(", ")", ";", "if", "(", "!", "mnemonicIsValid", "(", "Name", ",", "0", ")", ")", "{", "uint64_t", "FBS", "=", "ComputeAvailableFeatures", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", ")", ";", "std", "::", "string", "Suggestion", "=", "MipsMnemonicSpellCheck", "(", "Name", ",", "FBS", ")", ";", "return", "Error", "(", "NameLoc", ",", "\"unknown instruction\"", "+", "Suggestion", ")", ";", "}", "Operands", ".", "push_back", "(", "MipsOperand", "::", "CreateToken", "(", "Name", ",", "NameLoc", ",", "*", "this", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "LBrac", ")", "&&", "parseBracketSuffix", "(", "Name", ",", "Operands", ")", ")", "return", "true", ";", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "LBrac", ")", ")", "{", "if", "(", "parseBracketSuffix", "(", "Name", ",", "Operands", ")", ")", "return", "true", ";", "}", "else", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "LParen", ")", "&&", "parseParenSuffix", "(", "Name", ",", "Operands", ")", ")", "return", "true", ";", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"ParseInstruction\\n\"", "0", "Mips", "\"unknown instruction\"", "MipsOperand::CreateToken", "\"unexpected token in argument list\"", "\"unexpected token in argument list\"", "\"unexpected token in argument list\"" ]

[]

[ "<s>", "opt_machine_mode", "arm_mode_to_pred_mode", "(", "machine_mode", "mode", ")", "{", "switch", "(", "GET_MODE_NUNITS", "(", "mode", ")", ")", "{", "case", "16", ":", "return", "V16BImode", ";", "case", "8", ":", "return", "V8BImode", ";", "case", "4", ":", "return", "V4BImode", ";", "case", "2", ":", "return", "V2QImode", ";", "}", "return", "opt_machine_mode", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "mode", "for", "the", "MVE", "vector", "of", "predicates", "corresponding", "to", "MODE", "." ]

[ "arm", "16", "8", "4", "2" ]

[]

[ "<s>", "static", "unsigned", "int", "rs6000_function_arg_boundary", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "machine_mode", "elt_mode", ";", "int", "n_elts", ";", "rs6000_discover_homogeneous_aggregate", "(", "mode", ",", "type", ",", "&", "elt_mode", ",", "&", "n_elts", ")", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", "||", "(", "TARGET_HARD_FLOAT", "&&", "!", "is_complex_IBM_long_double", "(", "mode", ")", "&&", "FLOAT128_2REG_P", "(", "mode", ")", ")", ")", ")", "return", "64", ";", "else", "if", "(", "FLOAT128_VECTOR_P", "(", "mode", ")", ")", "return", "128", ";", "else", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">=", "8", "&&", "int_size_in_bytes", "(", "type", ")", "<", "16", ")", "return", "64", ";", "else", "if", "(", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "elt_mode", ")", "||", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">=", "16", ")", ")", "return", "128", ";", "if", "(", "(", "(", "DEFAULT_ABI", "==", "ABI_AIX", "&&", "!", "rs6000_compat_align_parm", ")", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "&&", "type", "&&", "TYPE_ALIGN", "(", "type", ")", ">", "64", ")", "{", "bool", "aggregate_p", "=", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "!", "SCALAR_FLOAT_MODE_P", "(", "elt_mode", ")", ")", ";", "if", "(", "aggregate_p", "!=", "(", "mode", "==", "BLKmode", ")", ")", "{", "static", "bool", "warned", ";", "if", "(", "!", "warned", "&&", "warn_psabi", ")", "{", "warned", "=", "true", ";", "inform", "(", "input_location", ",", "\"the ABI of passing aggregates with %d-byte alignment\"", "\" has changed in GCC 5\"", ",", "(", "int", ")", "TYPE_ALIGN", "(", "type", ")", "/", "BITS_PER_UNIT", ")", ";", "}", "}", "if", "(", "aggregate_p", ")", "return", "128", ";", "}", "if", "(", "TARGET_MACHO", "&&", "rs6000_darwin64_abi", "&&", "mode", "==", "BLKmode", "&&", "type", "&&", "TYPE_ALIGN", "(", "type", ")", ">", "64", ")", "return", "128", ";", "return", "PARM_BOUNDARY", ";", "}", "</s>" ]

[ "If", "defined", ",", "a", "C", "expression", "that", "gives", "the", "alignment", "boundary", ",", "in", "bits", ",", "of", "an", "argument", "with", "the", "specified", "mode", "and", "type", ".", "If", "it", "is", "not", "defined", ",", "PARM_BOUNDARY", "is", "used", "for", "all", "arguments", ".", "V.4", "wants", "long", "longs", "and", "doubles", "to", "be", "double", "word", "aligned", ".", "Just", "testing", "the", "mode", "size", "is", "a", "boneheaded", "way", "to", "do", "this", "as", "it", "means", "that", "other", "types", "such", "as", "complex", "int", "are", "also", "double", "word", "aligned", ".", "However", ",", "we", "'re", "stuck", "with", "this", "because", "changing", "the", "ABI", "might", "break", "existing", "library", "interfaces", ".", "Quadword", "align", "Altivec/VSX", "vectors", ".", "Quadword", "align", "large", "synthetic", "vector", "types", "." ]

[ "rs6000", "8", "64", "128", "8", "16", "64", "16", "128", "64", "\"the ABI of passing aggregates with %d-byte alignment\"", "\" has changed in GCC 5\"", "128", "64", "128" ]

[]

[ "<s>", "SDValue", "WebAssemblyTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "DL", "(", "Op", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unimplemented operation lowering\"", ")", ";", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "FrameIndex", ":", "return", "LowerFrameIndex", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ExternalSymbol", ":", "return", "LowerExternalSymbol", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_JT", ":", "return", "LowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "case", "ISD", "::", "BRIND", ":", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented computed gotos\"", ")", ";", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CopyToReg", ":", "return", "LowerCopyToReg", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "LowerAccessVectorElement", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "LowerIntrinsic", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "LowerSIGN_EXTEND_INREG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "LowerShift", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"unimplemented operation lowering\"", "ISD::FrameIndex", "ISD::GlobalAddress", "ISD::ExternalSymbol", "ISD::JumpTable", "ISD::BR_JT", "ISD::VASTART", "ISD::BlockAddress", "ISD::BRIND", "\"WebAssembly hasn't implemented computed gotos\"", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::CopyToReg", "ISD::EXTRACT_VECTOR_ELT", "ISD::INSERT_VECTOR_ELT", "ISD::INTRINSIC_VOID", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_W_CHAIN", "ISD::SIGN_EXTEND_INREG", "ISD::BUILD_VECTOR", "ISD::VECTOR_SHUFFLE", "ISD::SETCC", "ISD::SHL", "ISD::SRA", "ISD::SRL" ]

[]

[ "<s>", "StackOffset", "SystemZFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "StackOffset", "Offset", "=", "TargetFrameLowering", "::", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ")", ";", "return", "Offset", "+", "StackOffset", "::", "getFixed", "(", "SystemZMC", "::", "CallFrameSize", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZMC::CallFrameSize" ]

[]

[ "<s>", "static", "unsigned", "int", "split_stack_prologue_scratch_regno", "(", "void", ")", "{", "if", "(", "TARGET_64BIT", ")", "return", "R11_REG", ";", "else", "{", "bool", "is_fastcall", ",", "is_thiscall", ";", "int", "regparm", ";", "is_fastcall", "=", "(", "lookup_attribute", "(", "\"fastcall\"", ",", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "cfun", "->", "decl", ")", ")", ")", "!=", "NULL", ")", ";", "is_thiscall", "=", "(", "lookup_attribute", "(", "\"thiscall\"", ",", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "cfun", "->", "decl", ")", ")", ")", "!=", "NULL", ")", ";", "regparm", "=", "ix86_function_regparm", "(", "TREE_TYPE", "(", "cfun", "->", "decl", ")", ",", "cfun", "->", "decl", ")", ";", "if", "(", "is_fastcall", ")", "{", "if", "(", "DECL_STATIC_CHAIN", "(", "cfun", "->", "decl", ")", ")", "{", "sorry", "(", "\"-fsplit-stack does not support fastcall with \"", "\"nested function\"", ")", ";", "return", "INVALID_REGNUM", ";", "}", "return", "AX_REG", ";", "}", "else", "if", "(", "is_thiscall", ")", "{", "if", "(", "!", "DECL_STATIC_CHAIN", "(", "cfun", "->", "decl", ")", ")", "return", "DX_REG", ";", "return", "AX_REG", ";", "}", "else", "if", "(", "regparm", "<", "3", ")", "{", "if", "(", "!", "DECL_STATIC_CHAIN", "(", "cfun", "->", "decl", ")", ")", "return", "CX_REG", ";", "else", "{", "if", "(", "regparm", ">=", "2", ")", "{", "sorry", "(", "\"-fsplit-stack does not support 2 register \"", "\"parameters for a nested function\"", ")", ";", "return", "INVALID_REGNUM", ";", "}", "return", "DX_REG", ";", "}", "}", "else", "{", "sorry", "(", "\"-fsplit-stack does not support 3 register parameters\"", ")", ";", "return", "INVALID_REGNUM", ";", "}", "}", "}", "</s>" ]

[ "Return", "a", "scratch", "register", "to", "use", "in", "the", "split", "stack", "prologue", ".", "The", "split", "stack", "prologue", "is", "used", "for", "-fsplit-stack", ".", "It", "is", "the", "first", "instructions", "in", "the", "function", ",", "even", "before", "the", "regular", "prologue", ".", "The", "scratch", "register", "can", "be", "any", "caller-saved", "register", "which", "is", "not", "used", "for", "parameters", "or", "for", "the", "static", "chain", "." ]

[ "i386", "\"fastcall\"", "\"thiscall\"", "\"-fsplit-stack does not support fastcall with \"", "\"nested function\"", "3", "2", "\"-fsplit-stack does not support 2 register \"", "\"parameters for a nested function\"", "\"-fsplit-stack does not support 3 register parameters\"" ]

[]

[ "<s>", "bool", "RelooperAnalysis", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Relooping function '\"", "<<", "F", ".", "getName", "(", ")", "<<", "\"'\\n\"", ")", ";", "RelooperAlgorithm", "R", ";", "std", "::", "map", "<", "const", "BasicBlock", "*", ",", "Block", "*", ">", "BB2B", ";", "std", "::", "map", "<", "const", "Block", "*", ",", "const", "BasicBlock", "*", ">", "B2BB", ";", "for", "(", "const", "BasicBlock", "&", "BB", ":", "F", ")", "{", "Block", "*", "B", "=", "new", "Block", "(", "BB", ".", "getName", "(", ")", ".", "str", "(", ")", ".", "data", "(", ")", ",", "nullptr", ")", ";", "R", ".", "AddBlock", "(", "B", ")", ";", "assert", "(", "BB2B", ".", "find", "(", "&", "BB", ")", "==", "BB2B", ".", "end", "(", ")", "&&", "\"Inserting the same block twice\"", ")", ";", "assert", "(", "B2BB", ".", "find", "(", "B", ")", "==", "B2BB", ".", "end", "(", ")", "&&", "\"Inserting the same block twice\"", ")", ";", "BB2B", "[", "&", "BB", "]", "=", "B", ";", "B2BB", "[", "B", "]", "=", "&", "BB", ";", "}", "for", "(", "Block", "*", "B", ":", "R", ".", "Blocks", ")", "{", "const", "BasicBlock", "*", "BB", "=", "B2BB", "[", "B", "]", ";", "for", "(", "const", "BasicBlock", "*", "Successor", ":", "successors", "(", "BB", ")", ")", "B", "->", "AddBranchTo", "(", "BB2B", "[", "Successor", "]", ",", "nullptr", ",", "nullptr", ")", ";", "}", "R", ".", "Calculate", "(", "BB2B", "[", "&", "F", ".", "getEntryBlock", "(", ")", "]", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "WebAssembly", "\"Relooping function '\"", "\"'\\n\"", "\"Inserting the same block twice\"", "\"Inserting the same block twice\"" ]

[]

[ "<s>", "void", "PatmosMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "uint64_t", "Binary", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "if", "(", "!", "Binary", ")", "{", "MI", ".", "dump", "(", ")", ";", "llvm_unreachable", "(", "\"Unimplemented opcode in EncodeInstruction(). Maybe you tried to emit '(p0) add r0=r0,0' ?\"", ")", ";", "}", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "uint64_t", "TSFlags", "=", "Desc", ".", "TSFlags", ";", "if", "(", "(", "TSFlags", "&", "PatmosII", "::", "FormMask", ")", "==", "PatmosII", "::", "FrmPseudo", ")", "llvm_unreachable", "(", "\"Pseudo opcode found in EncodeInstruction()\"", ")", ";", "int", "Size", "=", "Desc", ".", "Size", ";", "if", "(", "(", "TSFlags", "&", "PatmosII", "::", "FormMask", ")", "!=", "PatmosII", "::", "FrmALUl", ")", "{", "bool", "isBundled", "=", "MI", ".", "getOperand", "(", "MI", ".", "getNumOperands", "(", ")", "-", "1", ")", ".", "getImm", "(", ")", ">", "0", ";", "if", "(", "isBundled", ")", "{", "Binary", "|=", "(", "1", "<<", "31", ")", ";", "}", "}", "EmitInstruction", "(", "Binary", ",", "Size", ",", "OS", ")", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "\"Unimplemented opcode in EncodeInstruction(). Maybe you tried to emit '(p0) add r0=r0,0' ?\"", "PatmosII::FormMask", "PatmosII::FrmPseudo", "\"Pseudo opcode found in EncodeInstruction()\"", "PatmosII::FormMask", "PatmosII::FrmALUl", "1", "0", "1", "31" ]

[]

[ "<s>", "unsigned", "combineRepeatedFPDivisors", "(", ")", "const", "override", "{", "return", "2", ";", "}", "</s>" ]

[ "Indicate", "whether", "this", "target", "prefers", "to", "combine", "FDIVs", "with", "the", "same", "divisor", "." ]

[ "NVPTX", "2" ]

[]

[ "<s>", "static", "bool", "sparc_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_ARCH32", ")", "return", "(", "TYPE_MODE", "(", "type", ")", "==", "BLKmode", "||", "TYPE_MODE", "(", "type", ")", "==", "TFmode", "||", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "(", "unsigned", "HOST_WIDE_INT", ")", "int_size_in_bytes", "(", "type", ")", ">", "8", ")", ")", ";", "else", "return", "(", "TYPE_MODE", "(", "type", ")", "==", "BLKmode", "&&", "(", "unsigned", "HOST_WIDE_INT", ")", "int_size_in_bytes", "(", "type", ")", ">", "32", ")", ";", "}", "</s>" ]

[ "Handle", "the", "TARGET_RETURN_IN_MEMORY", "target", "hook", ".", "Specify", "whether", "to", "return", "the", "return", "value", "in", "memory", "." ]

[ "sparc", "8", "32" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "SNESTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "auto", "STI", "=", "static_cast", "<", "const", "SNESTargetMachine", "&", ">", "(", "this", "->", "getTargetMachine", "(", ")", ")", ".", "getSubtargetImpl", "(", ")", ";", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'a'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SNES", "::", "MainLoRegsRegClass", ")", ";", "case", "'b'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SNES", "::", "MainRegsRegClass", ")", ";", "case", "'d'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SNES", "::", "MainLoRegsRegClass", ")", ";", "case", "'l'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SNES", "::", "MainRegsRegClass", ")", ";", "case", "'e'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SNES", "::", "IndexRegsRegClass", ")", ";", "case", "'q'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SNES", "::", "StackPointerRegsRegClass", ")", ";", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i8", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SNES", "::", "MainRegsRegClass", ")", ";", "assert", "(", "VT", "==", "MVT", "::", "i16", "&&", "\"inline asm constraint too large\"", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SNES", "::", "MainRegsRegClass", ")", ";", "case", "'t'", ":", "return", "std", "::", "make_pair", "(", "unsigned", "(", "SNES", "::", "A", ")", ",", "&", "SNES", "::", "MainRegsRegClass", ")", ";", "case", "'w'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SNES", "::", "MainRegsRegClass", ")", ";", "case", "'x'", ":", "case", "'X'", ":", "return", "std", "::", "make_pair", "(", "unsigned", "(", "SNES", "::", "X", ")", ",", "&", "SNES", "::", "IndexRegsRegClass", ")", ";", "case", "'y'", ":", "case", "'Y'", ":", "return", "std", "::", "make_pair", "(", "unsigned", "(", "SNES", "::", "Y", ")", ",", "&", "SNES", "::", "IndexRegsRegClass", ")", ";", "case", "'z'", ":", "case", "'Z'", ":", "return", "std", "::", "make_pair", "(", "unsigned", "(", "SNES", "::", "A", ")", ",", "&", "SNES", "::", "IndexRegsRegClass", ")", ";", "default", ":", "break", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "STI", "->", "getRegisterInfo", "(", ")", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "SNES", "SNES", "SNES", "1", "0", "0U", "SNES::MainLoRegsRegClass", "0U", "SNES::MainRegsRegClass", "0U", "SNES::MainLoRegsRegClass", "0U", "SNES::MainRegsRegClass", "0U", "SNES::IndexRegsRegClass", "0U", "SNES::StackPointerRegsRegClass", "MVT::i8", "0U", "SNES::MainRegsRegClass", "MVT::i16", "\"inline asm constraint too large\"", "0U", "SNES::MainRegsRegClass", "SNES::A", "SNES::MainRegsRegClass", "0U", "SNES::MainRegsRegClass", "SNES::X", "SNES::IndexRegsRegClass", "SNES::Y", "SNES::IndexRegsRegClass", "SNES::A", "SNES::IndexRegsRegClass" ]

[]

[ "<s>", "bool", "AArch64LegalizerInfo", "::", "legalizeCustom", "(", "MachineInstr", "&", "MI", ",", "MachineRegisterInfo", "&", "MRI", ",", "MachineIRBuilder", "&", "MIRBuilder", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "TargetOpcode", "::", "G_VAARG", ":", "return", "legalizeVaArg", "(", "MI", ",", "MRI", ",", "MIRBuilder", ")", ";", "}", "llvm_unreachable", "(", "\"expected switch to return\"", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"expected switch to return\"" ]

[]

[ "<s>", "bool", "X86PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createX86ISelDag", "(", "getX86TargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSBinFormatELF", "(", ")", "&&", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createCleanupLocalDynamicTLSPass", "(", ")", ")", ";", "addPass", "(", "createX86GlobalBaseRegPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "ARCExpandPseudos", "::", "expandCTLZ", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "::", "iterator", "MII", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MII", ";", "const", "MachineOperand", "&", "Dest", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "const", "MachineOperand", "&", "Src", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "Register", "Ra", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "ARC", "::", "GPR32RegClass", ")", ";", "Register", "Rb", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "ARC", "::", "GPR32RegClass", ")", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "ARC", "::", "FLS_f_rr", ")", ",", "Ra", ")", ".", "add", "(", "Src", ")", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "ARC", "::", "MOV_cc_ru6", ")", ",", "Rb", ")", ".", "addImm", "(", "32", ")", ".", "addImm", "(", "ARCCC", "::", "EQ", ")", ".", "addReg", "(", "Ra", ")", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "ARC", "::", "RSUB_cc_rru6", ")", ")", ".", "add", "(", "Dest", ")", ".", "addImm", "(", "31", ")", ".", "addImm", "(", "ARCCC", "::", "NE", ")", ".", "addReg", "(", "Rb", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "}", "</s>" ]

[ "Expand", "CTLZ/CTLZ_ZERO_UNDEF", "nodes", "." ]

[ "ARC", "ARC", "0", "1", "ARC::GPR32RegClass", "ARC::GPR32RegClass", "ARC::FLS_f_rr", "ARC::MOV_cc_ru6", "32", "ARCCC::EQ", "ARC::RSUB_cc_rru6", "31", "ARCCC::NE" ]

[]

[ "<s>", "static", "bool", "expand_perm_with_vstbrq", "(", "const", "struct", "expand_vec_perm_d", "&", "d", ")", "{", "if", "(", "TARGET_VXE2", "&&", "d", ".", "op0", "==", "d", ".", "op1", "&&", "is_reverse_perm_mask", "(", "d", ")", "&&", "d", ".", "vmode", "==", "V16QImode", ")", "{", "if", "(", "d", ".", "testing_p", ")", "return", "true", ";", "emit_insn", "(", "gen_eltswapv16qi", "(", "d", ".", "target", ",", "d", ".", "op0", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "we", "reverse", "a", "byte-vector", "this", "is", "the", "same", "as", "byte", "reversing", "it", "which", "can", "be", "done", "with", "vstbrq", "." ]

[ "s390" ]

[]

[ "<s>", "static", "int", "mips_sign_extend_cost", "(", "machine_mode", "mode", ",", "rtx", "op", ")", "{", "if", "(", "MEM_P", "(", "op", ")", ")", "return", "0", ";", "if", "(", "TARGET_64BIT", "&&", "mode", "==", "DImode", "&&", "GET_MODE", "(", "op", ")", "==", "SImode", ")", "return", "0", ";", "if", "(", "ISA_HAS_SEB_SEH", "||", "GENERATE_MIPS16E", ")", "return", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "COSTS_N_INSNS", "(", "TARGET_MIPS16", "?", "4", ":", "2", ")", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "sign-extending", "OP", "to", "mode", "MODE", ",", "not", "including", "the", "cost", "of", "OP", "itself", "." ]

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

[]

[ "<s>", "bool", "ARCRegisterInfo", "::", "needsFrameMoves", "(", "const", "MachineFunction", "&", "MF", ")", "{", "return", "MF", ".", "getMMI", "(", ")", ".", "hasDebugInfo", "(", ")", "||", "MF", ".", "getFunction", "(", ")", ".", "needsUnwindTableEntry", "(", ")", ";", "}", "</s>" ]

[ "Return", "whether", "to", "emit", "frame", "moves", "." ]

[ "ARC", "ARC" ]

[]

[ "<s>", "static", "int", "sequent_regs_live", "(", "void", ")", "{", "int", "live_seq", "=", "0", ";", "int", "cur_seq", "=", "0", ";", "for", "(", "int", "reg", "=", "0", ";", "reg", "<=", "LAST_CALLEE_SAVED_REG", ";", "++", "reg", ")", "{", "if", "(", "fixed_regs", "[", "reg", "]", ")", "{", "if", "(", "live_seq", "!=", "0", ")", "return", "0", ";", "else", "continue", ";", "}", "if", "(", "!", "call_used_or_fixed_reg_p", "(", "reg", ")", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "reg", ")", ")", "{", "++", "live_seq", ";", "++", "cur_seq", ";", "}", "else", "cur_seq", "=", "0", ";", "}", "}", "if", "(", "!", "frame_pointer_needed", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "REG_Y", ")", ")", "{", "++", "live_seq", ";", "++", "cur_seq", ";", "}", "else", "cur_seq", "=", "0", ";", "if", "(", "df_regs_ever_live_p", "(", "REG_Y", "+", "1", ")", ")", "{", "++", "live_seq", ";", "++", "cur_seq", ";", "}", "else", "cur_seq", "=", "0", ";", "}", "else", "{", "cur_seq", "+=", "2", ";", "live_seq", "+=", "2", ";", "}", "return", "(", "cur_seq", "==", "live_seq", ")", "?", "live_seq", ":", "0", ";", "}", "</s>" ]

[ "This", "function", "checks", "sequence", "of", "live", "registers" ]

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

[]

[ "<s>", "static", "rtx", "s390_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "ignore", "ATTRIBUTE_UNUSED", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "unsigned", "int", "fcode", "=", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "enum", "insn_code", "icode", ";", "rtx", "op", "[", "MAX_ARGS", "]", ",", "pat", ";", "int", "arity", ";", "bool", "nonvoid", ";", "tree", "arg", ";", "call_expr_arg_iterator", "iter", ";", "if", "(", "fcode", ">=", "S390_BUILTIN_MAX", ")", "internal_error", "(", "\"bad builtin fcode\"", ")", ";", "icode", "=", "code_for_builtin", "[", "fcode", "]", ";", "if", "(", "icode", "==", "0", ")", "internal_error", "(", "\"bad builtin fcode\"", ")", ";", "if", "(", "!", "TARGET_HTM", "&&", "fcode", "<=", "S390_BUILTIN_TX_ASSIST", ")", "error", "(", "\"Transactional execution builtins not enabled (-mhtm)\\n\"", ")", ";", "if", "(", "fcode", "==", "S390_BUILTIN_TBEGIN", "||", "fcode", "==", "S390_BUILTIN_TBEGIN_RETRY", ")", "cfun", "->", "machine", "->", "tbegin_p", "=", "true", ";", "nonvoid", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "fndecl", ")", ")", "!=", "void_type_node", ";", "arity", "=", "0", ";", "FOR_EACH_CALL_EXPR_ARG", "(", "arg", ",", "iter", ",", "exp", ")", "{", "const", "struct", "insn_operand_data", "*", "insn_op", ";", "if", "(", "arg", "==", "error_mark_node", ")", "return", "NULL_RTX", ";", "if", "(", "arity", ">=", "MAX_ARGS", ")", "return", "NULL_RTX", ";", "insn_op", "=", "&", "insn_data", "[", "icode", "]", ".", "operand", "[", "arity", "+", "nonvoid", "]", ";", "op", "[", "arity", "]", "=", "expand_expr", "(", "arg", ",", "NULL_RTX", ",", "insn_op", "->", "mode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "(", "*", "insn_op", "->", "predicate", ")", "(", "op", "[", "arity", "]", ",", "insn_op", "->", "mode", ")", ")", "{", "if", "(", "insn_op", "->", "predicate", "==", "memory_operand", ")", "{", "if", "(", "op", "[", "arity", "]", "!=", "const0_rtx", ")", "op", "[", "arity", "]", "=", "copy_to_mode_reg", "(", "Pmode", ",", "op", "[", "arity", "]", ")", ";", "op", "[", "arity", "]", "=", "gen_rtx_MEM", "(", "insn_op", "->", "mode", ",", "op", "[", "arity", "]", ")", ";", "}", "else", "op", "[", "arity", "]", "=", "copy_to_mode_reg", "(", "insn_op", "->", "mode", ",", "op", "[", "arity", "]", ")", ";", "}", "arity", "++", ";", "}", "if", "(", "nonvoid", ")", "{", "machine_mode", "tmode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "if", "(", "!", "target", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "predicate", ")", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "}", "switch", "(", "arity", ")", "{", "case", "0", ":", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ")", ";", "break", ";", "case", "1", ":", "if", "(", "nonvoid", ")", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op", "[", "0", "]", ")", ";", "else", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op", "[", "0", "]", ")", ";", "break", ";", "case", "2", ":", "if", "(", "nonvoid", ")", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op", "[", "0", "]", ",", "op", "[", "1", "]", ")", ";", "else", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op", "[", "0", "]", ",", "op", "[", "1", "]", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "if", "(", "nonvoid", ")", "return", "target", ";", "else", "return", "const0_rtx", ";", "}", "</s>" ]

[ "Expand", "an", "expression", "EXP", "that", "calls", "a", "built-in", "function", ",", "with", "result", "going", "to", "TARGET", "if", "that", "'s", "convenient", "(", "and", "in", "mode", "MODE", "if", "that", "'s", "convenient", ")", ".", "SUBTARGET", "may", "be", "used", "as", "the", "target", "for", "computing", "one", "of", "EXP", "'s", "operands", ".", "IGNORE", "is", "nonzero", "if", "the", "value", "is", "to", "be", "ignored", "." ]

[ "s390", "0", "\"bad builtin fcode\"", "0", "\"bad builtin fcode\"", "\"Transactional execution builtins not enabled (-mhtm)\\n\"", "0", "0", "0", "0", "1", "0", "0", "2", "0", "1", "0", "1" ]

[]

[ "<s>", "static", "rtx", "pru_to_int_mode", "(", "rtx", "x", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "return", "VOIDmode", "==", "mode", "?", "x", ":", "simplify_gen_subreg", "(", "int_mode_for_mode", "(", "mode", ")", ".", "require", "(", ")", ",", "x", ",", "mode", ",", "0", ")", ";", "}", "</s>" ]

[ "Access", "some", "RTX", "as", "INT_MODE", ".", "If", "X", "is", "a", "CONST_FIXED", "we", "can", "get", "the", "bit", "representation", "of", "X", "by", "``", "casting", "''", "it", "to", "CONST_INT", "." ]

[ "pru", "0" ]

[]

[ "<s>", "MCSection", "*", "getExplicitSectionGlobal", "(", "const", "GlobalObject", "*", "GO", ",", "SectionKind", "Kind", ",", "const", "TargetMachine", "&", "TM", ")", "const", "override", "{", "llvm_unreachable", "(", "\"Not supported!\"", ")", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "method", "to", "assign", "a", "section", "to", "globals", "with", "an", "explicit", "section", "specfied", "." ]

[ "DirectX", "\"Not supported!\"" ]

[]

[ "<s>", "bool", "HexagonExpandCondsets", "::", "isPredicable", "(", "MachineInstr", "*", "MI", ")", "{", "if", "(", "HII", "->", "isPredicated", "(", "*", "MI", ")", "||", "!", "HII", "->", "isPredicable", "(", "*", "MI", ")", ")", "return", "false", ";", "if", "(", "MI", "->", "hasUnmodeledSideEffects", "(", ")", "||", "MI", "->", "mayStore", "(", ")", ")", "return", "false", ";", "bool", "HasDef", "=", "false", ";", "for", "(", "auto", "&", "Op", ":", "MI", "->", "operands", "(", ")", ")", "{", "if", "(", "!", "Op", ".", "isReg", "(", ")", "||", "!", "Op", ".", "isDef", "(", ")", ")", "continue", ";", "if", "(", "HasDef", ")", "return", "false", ";", "HasDef", "=", "true", ";", "}", "for", "(", "auto", "&", "Mo", ":", "MI", "->", "memoperands", "(", ")", ")", "if", "(", "Mo", "->", "isVolatile", "(", ")", "||", "Mo", "->", "isAtomic", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "instruction", "can", "be", "predicated", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "static", "int", "tilegx_mode_rep_extended", "(", "machine_mode", "mode", ",", "machine_mode", "mode_rep", ")", "{", "if", "(", "mode", "==", "SImode", "&&", "mode_rep", "==", "DImode", ")", "return", "SIGN_EXTEND", ";", "return", "UNKNOWN", ";", "}", "</s>" ]

[ "Implement", "TARGET_MODE_REP_EXTENDED", "." ]

[ "tilegx" ]

[]

[ "<s>", "void", "XtensaRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "}", "</s>" ]

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

[ "Xtensa", "Xtensa" ]

[]

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

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

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

[]

[ "<s>", "static", "reg_class_t", "ix86_preferred_reload_class", "(", "rtx", "x", ",", "reg_class_t", "regclass", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "regclass", "==", "NO_REGS", ")", "return", "NO_REGS", ";", "if", "(", "x", "==", "CONST0_RTX", "(", "mode", ")", ")", "return", "regclass", ";", "if", "(", "CONSTANT_P", "(", "x", ")", "&&", "(", "MAYBE_MMX_CLASS_P", "(", "regclass", ")", "||", "MAYBE_SSE_CLASS_P", "(", "regclass", ")", "||", "MAYBE_MASK_CLASS_P", "(", "regclass", ")", ")", ")", "return", "NO_REGS", ";", "if", "(", "CONST_DOUBLE_P", "(", "x", ")", ")", "{", "if", "(", "INTEGER_CLASS_P", "(", "regclass", ")", ")", "return", "regclass", ";", "if", "(", "IS_STACK_MODE", "(", "mode", ")", "&&", "standard_80387_constant_p", "(", "x", ")", ">", "0", ")", "{", "if", "(", "FLOAT_CLASS_P", "(", "regclass", ")", ")", "return", "FLOAT_REGS", ";", "}", "return", "NO_REGS", ";", "}", "if", "(", "SSE_FLOAT_MODE_P", "(", "mode", ")", "&&", "TARGET_SSE_MATH", ")", "return", "SSE_CLASS_P", "(", "regclass", ")", "?", "regclass", ":", "NO_REGS", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "return", "INTEGER_CLASS_P", "(", "regclass", ")", "?", "regclass", ":", "NO_REGS", ";", "if", "(", "GET_MODE", "(", "x", ")", "==", "QImode", "&&", "!", "CONSTANT_P", "(", "x", ")", ")", "{", "if", "(", "Q_CLASS_P", "(", "regclass", ")", ")", "return", "regclass", ";", "else", "if", "(", "reg_class_subset_p", "(", "Q_REGS", ",", "regclass", ")", ")", "return", "Q_REGS", ";", "else", "if", "(", "MASK_CLASS_P", "(", "regclass", ")", ")", "return", "regclass", ";", "else", "return", "NO_REGS", ";", "}", "return", "regclass", ";", "}", "</s>" ]

[ "Put", "float", "CONST_DOUBLE", "in", "the", "constant", "pool", "instead", "of", "fp", "regs", ".", "QImode", "must", "go", "into", "class", "Q_REGS", ".", "Narrow", "ALL_REGS", "to", "GENERAL_REGS", ".", "This", "supports", "allowing", "movsf", "and", "movdf", "to", "do", "mem-to-mem", "moves", "through", "integer", "regs", "." ]

[ "i386", "0" ]

[]

[ "<s>", "virtual", "bool", "track", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Track", "the", "reference", "to", "metadata", "for", "DebugValueUser", "." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "section", "*", "xtensa_select_rtx_section", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", "ATTRIBUTE_UNUSED", ",", "unsigned", "HOST_WIDE_INT", "align", "ATTRIBUTE_UNUSED", ")", "{", "return", "function_section", "(", "current_function_decl", ")", ";", "}", "</s>" ]

[ "The", "literal", "pool", "stays", "with", "the", "function", "." ]

[ "xtensa" ]

[]

[ "<s>", "static", "int", "mips16_rewrite_pool_refs", "(", "rtx", "*", "x", ",", "void", "*", "data", ")", "{", "struct", "mips16_constant_pool", "*", "pool", "=", "data", ";", "if", "(", "GET_CODE", "(", "*", "x", ")", "==", "SYMBOL_REF", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "*", "x", ")", ")", "*", "x", "=", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "add_constant", "(", "pool", ",", "get_pool_constant", "(", "*", "x", ")", ",", "get_pool_mode", "(", "*", "x", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Rewrite", "*", "X", "so", "that", "constant", "pool", "references", "refer", "to", "the", "constant", "'s", "label", "instead", ".", "DATA", "points", "to", "the", "constant", "pool", "structure", "." ]

[ "mips", "0" ]

[]

[ "<s>", "bool", "arc_expand_movmem", "(", "rtx", "*", "operands", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "rtx", "dst_addr", ",", "src_addr", ";", "HOST_WIDE_INT", "size", ";", "int", "align", "=", "INTVAL", "(", "operands", "[", "3", "]", ")", ";", "unsigned", "n_pieces", ";", "int", "piece", "=", "align", ";", "rtx", "store", "[", "2", "]", ";", "rtx", "tmpx", "[", "2", "]", ";", "int", "i", ";", "if", "(", "!", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", ")", "return", "false", ";", "size", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "align", ">=", "4", ")", "{", "if", "(", "TARGET_LL64", ")", "n_pieces", "=", "(", "size", "+", "4", ")", "/", "8U", "+", "(", "(", "size", ">>", "1", ")", "&", "1", ")", "+", "(", "size", "&", "1", ")", ";", "else", "n_pieces", "=", "(", "size", "+", "2", ")", "/", "4U", "+", "(", "size", "&", "1", ")", ";", "}", "else", "if", "(", "align", "==", "2", ")", "n_pieces", "=", "(", "size", "+", "1", ")", "/", "2U", ";", "else", "n_pieces", "=", "size", ";", "if", "(", "n_pieces", ">=", "(", "unsigned", "int", ")", "(", "optimize_size", "?", "3", ":", "15", ")", ")", "return", "false", ";", "if", "(", "TARGET_LL64", "&&", "(", "piece", ">=", "4", ")", "&&", "(", "size", ">=", "8", ")", ")", "piece", "=", "8", ";", "else", "if", "(", "piece", ">", "4", ")", "piece", "=", "4", ";", "dst_addr", "=", "force_offsettable", "(", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ",", "size", ",", "0", ")", ";", "src_addr", "=", "force_offsettable", "(", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ",", "size", ",", "0", ")", ";", "store", "[", "0", "]", "=", "store", "[", "1", "]", "=", "NULL_RTX", ";", "tmpx", "[", "0", "]", "=", "tmpx", "[", "1", "]", "=", "NULL_RTX", ";", "for", "(", "i", "=", "0", ";", "size", ">", "0", ";", "i", "^=", "1", ",", "size", "-=", "piece", ")", "{", "rtx", "tmp", ";", "machine_mode", "mode", ";", "while", "(", "piece", ">", "size", ")", "piece", ">>=", "1", ";", "mode", "=", "smallest_mode_for_size", "(", "piece", "*", "BITS_PER_UNIT", ",", "MODE_INT", ")", ";", "if", "(", "0", "&&", "tmpx", "[", "i", "]", "&&", "GET_MODE", "(", "tmpx", "[", "i", "]", ")", "==", "mode", ")", "tmp", "=", "tmpx", "[", "i", "]", ";", "else", "tmpx", "[", "i", "]", "=", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "dst_addr", "=", "force_offsettable", "(", "dst_addr", ",", "piece", ",", "1", ")", ";", "src_addr", "=", "force_offsettable", "(", "src_addr", ",", "piece", ",", "1", ")", ";", "if", "(", "store", "[", "i", "]", ")", "emit_insn", "(", "store", "[", "i", "]", ")", ";", "emit_move_insn", "(", "tmp", ",", "change_address", "(", "src", ",", "mode", ",", "src_addr", ")", ")", ";", "store", "[", "i", "]", "=", "gen_move_insn", "(", "change_address", "(", "dst", ",", "mode", ",", "dst_addr", ")", ",", "tmp", ")", ";", "dst_addr", "=", "plus_constant", "(", "Pmode", ",", "dst_addr", ",", "piece", ")", ";", "src_addr", "=", "plus_constant", "(", "Pmode", ",", "src_addr", ",", "piece", ")", ";", "}", "if", "(", "store", "[", "i", "]", ")", "emit_insn", "(", "store", "[", "i", "]", ")", ";", "if", "(", "store", "[", "i", "^", "1", "]", ")", "emit_insn", "(", "store", "[", "i", "^", "1", "]", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Like", "move_by_pieces", ",", "but", "take", "account", "of", "load", "latency", ",", "and", "actual", "offset", "ranges", ".", "Return", "true", "on", "success", "." ]

[ "arc", "0", "1", "3", "2", "2", "2", "2", "4", "4", "8U", "1", "1", "1", "2", "4U", "1", "2", "1", "2U", "3", "15", "4", "8", "8", "4", "4", "0", "0", "0", "1", "0", "0", "0", "1", "0", "1", "0", "0", "1", "1", "0", "1", "1", "1", "1" ]

[]

[ "<s>", "static", "void", "bfin_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "chain_value", ")", "{", "rtx", "t1", "=", "copy_to_reg", "(", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ")", ";", "rtx", "t2", "=", "copy_to_reg", "(", "chain_value", ")", ";", "rtx", "mem", ";", "int", "i", "=", "0", ";", "emit_block_move", "(", "m_tramp", ",", "assemble_trampoline_template", "(", ")", ",", "GEN_INT", "(", "TRAMPOLINE_SIZE", ")", ",", "BLOCK_OP_NORMAL", ")", ";", "if", "(", "TARGET_FDPIC", ")", "{", "rtx", "a", "=", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "XEXP", "(", "m_tramp", ",", "0", ")", ",", "8", ")", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "0", ")", ";", "emit_move_insn", "(", "mem", ",", "a", ")", ";", "i", "=", "8", ";", "}", "mem", "=", "adjust_address", "(", "m_tramp", ",", "HImode", ",", "i", "+", "2", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_lowpart", "(", "HImode", ",", "t1", ")", ")", ";", "emit_insn", "(", "gen_ashrsi3", "(", "t1", ",", "t1", ",", "GEN_INT", "(", "16", ")", ")", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "HImode", ",", "i", "+", "6", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_lowpart", "(", "HImode", ",", "t1", ")", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "HImode", ",", "i", "+", "10", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_lowpart", "(", "HImode", ",", "t2", ")", ")", ";", "emit_insn", "(", "gen_ashrsi3", "(", "t2", ",", "t2", ",", "GEN_INT", "(", "16", ")", ")", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "HImode", ",", "i", "+", "14", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_lowpart", "(", "HImode", ",", "t2", ")", ")", ";", "}", "</s>" ]

[ "Emit", "RTL", "insns", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", "at", "M_TRAMP", ".", "FNDECL", "is", "the", "target", "function", ".", "CHAIN_VALUE", "is", "an", "RTX", "for", "the", "static", "chain", "value", "for", "the", "function", "." ]

[ "bfin", "0", "0", "0", "8", "0", "8", "2", "16", "6", "10", "16", "14" ]

[]

[ "<s>", "void", "Thumb1InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "assert", "(", "(", "RC", "==", "ARM", "::", "tGPRRegisterClass", "||", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "SrcReg", ")", "&&", "isARMLowRegister", "(", "SrcReg", ")", ")", ")", "&&", "\"Unknown regclass!\"", ")", ";", "if", "(", "RC", "==", "ARM", "::", "tGPRRegisterClass", "||", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "SrcReg", ")", "&&", "isARMLowRegister", "(", "SrcReg", ")", ")", ")", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "PseudoSourceValue", "::", "getFixedStack", "(", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "0", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "tSpill", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "}", "}", "</s>" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "ARM", "ARM::tGPRRegisterClass", "ARM", "\"Unknown regclass!\"", "ARM::tGPRRegisterClass", "ARM", "0", "ARM::tSpill", "0" ]

[]

[ "<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "override", "{", "return", "X86", "::", "NumTargetFixupKinds", ";", "}", "</s>" ]

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

[ "X86", "X86::NumTargetFixupKinds" ]

[]

[ "<s>", "static", "rtx", "aarch64_sve_emit_int_cmp", "(", "rtx", "target", ",", "machine_mode", "pred_mode", ",", "rtx_code", "cmp", ",", "machine_mode", "data_mode", ",", "rtx", "op1", ",", "rtx", "op2", ")", "{", "insn_code", "icode", "=", "code_for_aarch64_pred_cmp", "(", "cmp", ",", "data_mode", ")", ";", "expand_operand", "ops", "[", "5", "]", ";", "create_output_operand", "(", "&", "ops", "[", "0", "]", ",", "target", ",", "pred_mode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "1", "]", ",", "CONSTM1_RTX", "(", "pred_mode", ")", ",", "pred_mode", ")", ";", "create_integer_operand", "(", "&", "ops", "[", "2", "]", ",", "SVE_KNOWN_PTRUE", ")", ";", "create_input_operand", "(", "&", "ops", "[", "3", "]", ",", "op1", ",", "data_mode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "4", "]", ",", "op2", ",", "data_mode", ")", ";", "expand_insn", "(", "icode", ",", "5", ",", "ops", ")", ";", "return", "ops", "[", "0", "]", ".", "value", ";", "}", "</s>" ]

[ "Emit", "a", "comparison", "CMP", "between", "OP0", "and", "OP1", ",", "both", "of", "which", "have", "mode", "DATA_MODE", ",", "and", "return", "the", "result", "in", "a", "predicate", "of", "mode", "PRED_MODE", ".", "Use", "TARGET", "as", "the", "target", "register", "if", "nonnull", "and", "convenient", "." ]

[ "aarch64", "5", "0", "1", "2", "3", "4", "5", "0" ]

[]

[ "<s>", "bool", "evaluateBranch", "(", "const", "MCInst", "&", "Inst", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ",", "uint64_t", "&", "Target", ")", "const", "override", "{", "if", "(", "isConditionalBranch", "(", "Inst", ")", ")", "{", "int64_t", "Imm", ";", "if", "(", "Size", "==", "2", ")", "Imm", "=", "Inst", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "else", "Imm", "=", "Inst", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "Target", "=", "Addr", "+", "Imm", ";", "return", "true", ";", "}", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "C_JAL", "||", "Inst", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "C_J", ")", "{", "Target", "=", "Addr", "+", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "}", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "JAL", ")", "{", "Target", "=", "Addr", "+", "Inst", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "RI5CY", "2", "1", "2", "RISCV::C_JAL", "RISCV::C_J", "0", "RISCV::JAL", "1" ]

[]

[ "<s>", "void", "xstormy16_split_cbranch", "(", "machine_mode", "mode", ",", "rtx", "label", ",", "rtx", "comparison", ",", "rtx", "dest", ")", "{", "rtx", "op0", "=", "XEXP", "(", "comparison", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "comparison", ",", "1", ")", ";", "rtx_insn", "*", "seq", ",", "*", "last_insn", ";", "rtx", "compare", ";", "start_sequence", "(", ")", ";", "xstormy16_expand_arith", "(", "mode", ",", "COMPARE", ",", "dest", ",", "op0", ",", "op1", ")", ";", "seq", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "gcc_assert", "(", "INSN_P", "(", "seq", ")", ")", ";", "last_insn", "=", "seq", ";", "while", "(", "NEXT_INSN", "(", "last_insn", ")", "!=", "NULL_RTX", ")", "last_insn", "=", "NEXT_INSN", "(", "last_insn", ")", ";", "compare", "=", "SET_SRC", "(", "XVECEXP", "(", "PATTERN", "(", "last_insn", ")", ",", "0", ",", "0", ")", ")", ";", "PUT_CODE", "(", "XEXP", "(", "compare", ",", "0", ")", ",", "GET_CODE", "(", "comparison", ")", ")", ";", "XEXP", "(", "compare", ",", "1", ")", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "label", ")", ";", "emit_insn", "(", "seq", ")", ";", "}", "</s>" ]

[ "Take", "a", "SImode", "conditional", "branch", ",", "one", "of", "GT/LE/GTU/LEU", ",", "and", "split", "the", "arithmetic", "operation", ".", "Most", "of", "the", "work", "is", "done", "by", "xstormy16_expand_arith", "." ]

[ "stormy16", "0", "1", "0", "0", "0", "1" ]

[]

[ "<s>", "int", "legitimate_const_double_p", "(", "rtx", "address", ")", "{", "long", "sval", "[", "2", "]", ";", "if", "(", "GET_MODE", "(", "address", ")", "==", "VOIDmode", ")", "return", "0", ";", "REAL_VALUE_TO_TARGET_DOUBLE", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "address", ")", ",", "sval", ")", ";", "if", "(", "(", "sval", "[", "0", "]", "&", "0xffff", ")", "==", "0", "&&", "sval", "[", "1", "]", "==", "0", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "This", "function", "checks", "whether", "a", "real", "value", "can", "be", "encoded", "as", "a", "literal", ",", "i.e.", ",", "addressing", "mode", "27", ".", "In", "that", "mode", ",", "real", "values", "are", "one", "word", "values", ",", "so", "the", "remaining", "48", "bits", "have", "to", "be", "zero", "." ]

[ "pdp11", "2", "0", "0", "0xffff", "0", "1", "0", "1", "0" ]

[]

[ "<s>", "static", "int", "ix86_cmp_code_to_pcmp_immediate", "(", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ")", "{", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", ")", "return", "ix86_fp_cmp_code_to_pcmp_immediate", "(", "code", ")", ";", "return", "ix86_int_cmp_code_to_pcmp_immediate", "(", "code", ")", ";", "}", "</s>" ]

[ "Return", "immediate", "value", "to", "be", "used", "in", "UNSPEC_PCMP", "for", "comparison", "CODE", "in", "MODE", "." ]

[ "i386" ]

[]

[ "<s>", "const", "char", "*", "MINA32TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "case", "MINA32ISD", "::", "name", ":", "\\", "return", "#", "name", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "nullptr", ";", "}", "</s>" ]

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

[ "MINA32", "MINA32", "MINA32ISD::name" ]

[]

[ "<s>", "static", "bool", "arm_handle_option", "(", "size_t", "code", ",", "const", "char", "*", "arg", ",", "int", "value", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "code", ")", "{", "case", "OPT_march_", ":", "arm_select", "[", "1", "]", ".", "string", "=", "arg", ";", "return", "true", ";", "case", "OPT_mcpu_", ":", "arm_select", "[", "0", "]", ".", "string", "=", "arg", ";", "return", "true", ";", "case", "OPT_mhard_float", ":", "target_float_abi_name", "=", "\"hard\"", ";", "return", "true", ";", "case", "OPT_msoft_float", ":", "target_float_abi_name", "=", "\"soft\"", ";", "return", "true", ";", "case", "OPT_mtune_", ":", "arm_select", "[", "2", "]", ".", "string", "=", "arg", ";", "return", "true", ";", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_HANDLE_OPTION", "." ]

[ "arm", "1", "0", "\"hard\"", "\"soft\"", "2" ]

[]

[ "<s>", "bool", "rs6000_is_valid_shift_mask", "(", "rtx", "mask", ",", "rtx", "shift", ",", "machine_mode", "mode", ")", "{", "int", "nb", ",", "ne", ";", "if", "(", "!", "rs6000_is_valid_mask", "(", "mask", ",", "&", "nb", ",", "&", "ne", ",", "mode", ")", ")", "return", "false", ";", "int", "n", "=", "GET_MODE_PRECISION", "(", "mode", ")", ";", "int", "sh", "=", "-", "1", ";", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "shift", ",", "1", ")", ")", ")", "{", "sh", "=", "INTVAL", "(", "XEXP", "(", "shift", ",", "1", ")", ")", ";", "if", "(", "sh", "<", "0", "||", "sh", ">=", "n", ")", "return", "false", ";", "}", "rtx_code", "code", "=", "GET_CODE", "(", "shift", ")", ";", "if", "(", "sh", "==", "0", ")", "code", "=", "ROTATE", ";", "if", "(", "code", "==", "ROTATE", "&&", "sh", ">=", "0", "&&", "nb", ">=", "ne", "&&", "ne", ">=", "sh", ")", "code", "=", "ASHIFT", ";", "if", "(", "code", "==", "ROTATE", "&&", "sh", ">=", "0", "&&", "nb", ">=", "ne", "&&", "nb", "<", "sh", ")", "{", "code", "=", "LSHIFTRT", ";", "sh", "=", "n", "-", "sh", ";", "}", "if", "(", "mode", "==", "DImode", "&&", "code", "==", "ROTATE", ")", "return", "(", "nb", "==", "63", "||", "ne", "==", "0", "||", "ne", "==", "sh", ")", ";", "if", "(", "mode", "==", "SImode", "&&", "code", "==", "ROTATE", ")", "return", "(", "nb", "<", "32", "&&", "ne", "<", "32", "&&", "sh", "<", "32", ")", ";", "if", "(", "ne", ">", "nb", ")", "return", "false", ";", "if", "(", "sh", "<", "0", ")", "return", "false", ";", "if", "(", "code", "==", "ASHIFT", "&&", "ne", "<", "sh", ")", "return", "false", ";", "if", "(", "nb", "<", "32", "&&", "ne", "<", "32", "&&", "sh", "<", "32", "&&", "!", "(", "code", "==", "LSHIFTRT", "&&", "nb", ">=", "32", "-", "sh", ")", ")", "return", "true", ";", "if", "(", "code", "==", "LSHIFTRT", ")", "sh", "=", "64", "-", "sh", ";", "if", "(", "nb", "==", "63", "||", "ne", "==", "0", "||", "ne", "==", "sh", ")", "return", "!", "(", "code", "==", "LSHIFTRT", "&&", "nb", ">=", "sh", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "whether", "MASK", "(", "a", "CONST_INT", ")", "is", "a", "valid", "mask", "for", "any", "rlw", "[", "i", "]", "nm", ",", "rld", "[", "i", "]", "cl", ",", "rld", "[", "i", "]", "cr", ",", "or", "rld", "[", "i", "]", "c", "instruction", ",", "to", "implement", "an", "AND", "with", "shift", "SHIFT", "(", "a", "ROTATE", ",", "ASHIFT", ",", "or", "LSHIFTRT", ")", "in", "mode", "MODE", "." ]

[ "rs6000", "1", "1", "1", "0", "0", "0", "0", "63", "0", "32", "32", "32", "0", "32", "32", "32", "32", "64", "63", "0" ]

[]

[ "<s>", "static", "rtx", "frv_read_argument", "(", "tree", "*", "arglistptr", ")", "{", "tree", "next", "=", "TREE_VALUE", "(", "*", "arglistptr", ")", ";", "*", "arglistptr", "=", "TREE_CHAIN", "(", "*", "arglistptr", ")", ";", "return", "expand_expr", "(", "next", ",", "NULL_RTX", ",", "VOIDmode", ",", "0", ")", ";", "}", "</s>" ]

[ "Read", "a", "value", "from", "the", "head", "of", "the", "tree", "list", "pointed", "to", "by", "ARGLISTPTR", ".", "Return", "the", "value", "as", "an", "rtx", "and", "replace", "*", "ARGLISTPTR", "with", "the", "tail", "of", "the", "list", "." ]

[ "frv", "0" ]

[]

[ "<s>", "static", "void", "ix86_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "chain_value", ")", "{", "rtx", "mem", ",", "fnaddr", ";", "int", "opcode", ";", "int", "offset", "=", "0", ";", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "if", "(", "TARGET_64BIT", ")", "{", "int", "size", ";", "if", "(", "ptr_mode", "==", "SImode", "||", "x86_64_zext_immediate_operand", "(", "fnaddr", ",", "VOIDmode", ")", ")", "{", "fnaddr", "=", "copy_addr_to_reg", "(", "fnaddr", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "HImode", ",", "offset", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_int_mode", "(", "0xbb41", ",", "HImode", ")", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "offset", "+", "2", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_lowpart", "(", "SImode", ",", "fnaddr", ")", ")", ";", "offset", "+=", "6", ";", "}", "else", "{", "mem", "=", "adjust_address", "(", "m_tramp", ",", "HImode", ",", "offset", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_int_mode", "(", "0xbb49", ",", "HImode", ")", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "DImode", ",", "offset", "+", "2", ")", ";", "emit_move_insn", "(", "mem", ",", "fnaddr", ")", ";", "offset", "+=", "10", ";", "}", "if", "(", "ptr_mode", "==", "SImode", ")", "{", "opcode", "=", "0xba41", ";", "size", "=", "6", ";", "}", "else", "{", "opcode", "=", "0xba49", ";", "size", "=", "10", ";", "}", "mem", "=", "adjust_address", "(", "m_tramp", ",", "HImode", ",", "offset", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_int_mode", "(", "opcode", ",", "HImode", ")", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "ptr_mode", ",", "offset", "+", "2", ")", ";", "emit_move_insn", "(", "mem", ",", "chain_value", ")", ";", "offset", "+=", "size", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "offset", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_int_mode", "(", "0x90e3ff49", ",", "SImode", ")", ")", ";", "offset", "+=", "4", ";", "}", "else", "{", "rtx", "disp", ",", "chain", ";", "chain", "=", "ix86_static_chain", "(", "fndecl", ",", "true", ")", ";", "if", "(", "REG_P", "(", "chain", ")", ")", "{", "switch", "(", "REGNO", "(", "chain", ")", ")", "{", "case", "AX_REG", ":", "opcode", "=", "0xb8", ";", "break", ";", "case", "CX_REG", ":", "opcode", "=", "0xb9", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "opcode", "=", "0x68", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "QImode", ",", "offset", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_int_mode", "(", "opcode", ",", "QImode", ")", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "offset", "+", "1", ")", ";", "emit_move_insn", "(", "mem", ",", "chain_value", ")", ";", "offset", "+=", "5", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "QImode", ",", "offset", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_int_mode", "(", "0xe9", ",", "QImode", ")", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "offset", "+", "1", ")", ";", "offset", "+=", "5", ";", "disp", "=", "expand_binop", "(", "SImode", ",", "sub_optab", ",", "fnaddr", ",", "plus_constant", "(", "Pmode", ",", "XEXP", "(", "m_tramp", ",", "0", ")", ",", "offset", "-", "(", "MEM_P", "(", "chain", ")", "?", "1", ":", "0", ")", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "emit_move_insn", "(", "mem", ",", "disp", ")", ";", "}", "gcc_assert", "(", "offset", "<=", "TRAMPOLINE_SIZE", ")", ";", "if", "(", "CHECK_EXECUTE_STACK_ENABLED", ")", "emit_library_call", "(", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__enable_execute_stack\"", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "1", ",", "XEXP", "(", "m_tramp", ",", "0", ")", ",", "Pmode", ")", ";", "}", "</s>" ]

[ "Emit", "RTL", "insns", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", ".", "FNDECL", "is", "the", "decl", "of", "the", "target", "address", ";", "M_TRAMP", "is", "a", "MEM", "for", "the", "trampoline", ",", "and", "CHAIN_VALUE", "is", "an", "RTX", "for", "the", "static", "chain", "to", "be", "passed", "to", "the", "target", "function", "." ]

[ "i386", "0", "0", "0xbb41", "2", "6", "0xbb49", "2", "10", "0xba41", "6", "0xba49", "10", "2", "0x90e3ff49", "4", "0xb8", "0xb9", "0x68", "1", "5", "0xe9", "1", "5", "0", "1", "0", "1", "\"__enable_execute_stack\"", "1", "0" ]

[]

[ "<s>", "bool", "AArch64CompressJumpTables", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MFIn", ")", "{", "bool", "Changed", "=", "false", ";", "MF", "=", "&", "MFIn", ";", "const", "auto", "&", "ST", "=", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "if", "(", "ST", ".", "force32BitJumpTables", "(", ")", "&&", "!", "MF", "->", "getFunction", "(", ")", ".", "optForMinSize", "(", ")", ")", "return", "false", ";", "scanFunction", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "*", "MF", ")", "{", "int", "Offset", "=", "BlockInfo", "[", "MBB", ".", "getNumber", "(", ")", "]", ";", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "Changed", "|=", "compressJumpTable", "(", "MI", ",", "Offset", ")", ";", "Offset", "+=", "TII", "->", "getInstSizeInBytes", "(", "MI", ")", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "int", "translate_unix", "(", "char", "*", "name", ",", "int", "type", ")", "{", "strcpy", "(", "filename_buff", ",", "name", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Action", "routine", "called", "by", "decc", "$", "to_vms", ".", "NAME", "is", "a", "file", "name", "or", "directory", "name", ".", "TYPE", "is", "unused", "." ]

[ "vms", "0" ]

[]

[ "<s>", "void", "TLCS900FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "TLCS900MachineFunctionInfo", "*", "TLCS900FI", "=", "MF", ".", "getInfo", "<", "TLCS900MachineFunctionInfo", ">", "(", ")", ";", "const", "TLCS900InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "TLCS900InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "0", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "uint64_t", "FrameSize", "=", "StackSize", "-", "2", ";", "NumBytes", "=", "FrameSize", "-", "TLCS900FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "MFI", "->", "setOffsetAdjustment", "(", "-", "NumBytes", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "TLCS900", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "TLCS900", "::", "FPW", ",", "RegState", "::", "Kill", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "TLCS900", "::", "MOV16rr", ")", ",", "TLCS900", "::", "FPW", ")", ".", "addReg", "(", "TLCS900", "::", "SPW", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "llvm", "::", "next", "(", "MF", ".", "begin", "(", ")", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "I", "->", "addLiveIn", "(", "TLCS900", "::", "FPW", ")", ";", "}", "else", "NumBytes", "=", "StackSize", "-", "TLCS900FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "TLCS900", "::", "PUSH16r", ")", ")", "++", "MBBI", ";", "if", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "NumBytes", ")", "{", "if", "(", "NumBytes", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "TLCS900", "::", "SUB16ri", ")", ",", "TLCS900", "::", "SPW", ")", ".", "addReg", "(", "TLCS900", "::", "SPW", ")", ".", "addImm", "(", "NumBytes", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "}", "</s>" ]

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

[ "TLCS900", "TLCS900", "TLCS900", "TLCS900", "TLCS900", "TLCS900", "TLCS900", "0", "2", "TLCS900", "TLCS900::PUSH16r", "TLCS900::FPW", "TLCS900::MOV16rr", "TLCS900::FPW", "TLCS900::SPW", "TLCS900::FPW", "TLCS900", "TLCS900::PUSH16r", "TLCS900::SUB16ri", "TLCS900::SPW", "TLCS900::SPW", "3" ]

[]

[ "<s>", "virtual", "unsigned", "int", "execute", "(", "function", "*", ")", "{", "return", "mips_machine_reorg2", "(", ")", ";", "}", "</s>" ]

[ "Main", "entry", "point", "for", "this", "pass", "." ]

[ "mips" ]

[]

[ "<s>", "void", "PTXFrameInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "PTX", "PTX" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreSched2", "(", ")", "{", "addPass", "(", "createAArch64ExpandPseudoPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "EnableLoadStoreOpt", ")", "addPass", "(", "createAArch64LoadStoreOptimizationPass", "(", ")", ")", ";", "if", "(", "EnableFalkorHWPFFix", ")", "addPass", "(", "createFalkorHWPFFixPass", "(", ")", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "int", "need_to_save", "(", "int", "regno", ")", "{", "if", "(", "fixed_regs", "[", "regno", "]", ")", "return", "0", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "return", "1", ";", "if", "(", "regno", "==", "FP_REGNO", ")", "return", "0", ";", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", "&&", "(", "!", "cfun", "->", "machine", "->", "is_leaf", "||", "(", "regno", "==", "A0_REGNO", "&&", "m32c_function_needs_enter", "(", ")", ")", ")", ")", "return", "1", ";", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "(", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", "||", "cfun", "->", "machine", "->", "is_interrupt", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "given", "register", "needs", "to", "be", "saved", "by", "the", "current", "function", "." ]

[ "m32c", "0", "1", "0", "1", "1", "0" ]

[]

[ "<s>", "bool", "TPCSingleUseScalarOptimizerPass", "::", "runOnFunction", "(", "Function", "&", "Func", ")", "{", "if", "(", "skipFunction", "(", "Func", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"**** SingleUseScalarOptimizer Pass\\n\"", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "BB", ":", "Func", ")", "{", "for", "(", "auto", "&", "I", ":", "BB", ")", "{", "if", "(", "const", "IntrinsicInst", "*", "intrins", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "&", "I", ")", ")", "{", "Intrinsic", "::", "ID", "inid", "=", "intrins", "->", "getIntrinsicID", "(", ")", ";", "if", "(", "inid", "==", "Intrinsic", "::", "tpc_convert_int", ")", "{", "if", "(", "I", ".", "hasOneUse", "(", ")", ")", "{", "Instruction", "*", "C", "=", "cast", "<", "Instruction", ">", "(", "*", "I", ".", "user_begin", "(", ")", ")", ";", "if", "(", "auto", "*", "inse", "=", "dyn_cast", "<", "InsertElementInst", ">", "(", "C", ")", ")", "{", "if", "(", "inse", "->", "hasOneUse", "(", ")", ")", "{", "Instruction", "*", "D", "=", "cast", "<", "Instruction", ">", "(", "*", "C", "->", "user_begin", "(", ")", ")", ";", "if", "(", "auto", "*", "shuffl", "=", "dyn_cast", "<", "ShuffleVectorInst", ">", "(", "D", ")", ")", "{", "if", "(", "shuffl", "->", "hasOneUse", "(", ")", ")", "{", "for", "(", "auto", "&", "U", ":", "D", "->", "uses", "(", ")", ")", "{", "Instruction", "*", "UI", "=", "cast", "<", "Instruction", ">", "(", "U", ".", "getUser", "(", ")", ")", ";", "if", "(", "IntrinsicInst", "*", "intrins1", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "UI", ")", ")", "{", "Intrinsic", "::", "ID", "inid1", "=", "intrins1", "->", "getIntrinsicID", "(", ")", ";", "if", "(", "inid1", "==", "Intrinsic", "::", "tpc_mac", "&&", "UI", "->", "getParent", "(", ")", "!=", "&", "BB", ")", "{", "C", "->", "moveBefore", "(", "UI", ")", ";", "D", "->", "moveBefore", "(", "UI", ")", ";", "Changed", "=", "true", ";", "}", "}", "}", "}", "}", "}", "}", "}", "}", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "TPC", "TPC", "\"**** SingleUseScalarOptimizer Pass\\n\"", "Intrinsic::ID", "Intrinsic::tpc_convert_int", "Intrinsic::ID", "Intrinsic::tpc_mac" ]

[]

[ "<s>", "bool", "AArch64CollectLOH", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetMachine", "&", "TM", "=", "MF", ".", "getTarget", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "TM", ".", "getRegisterInfo", "(", ")", ";", "const", "MachineDominatorTree", "*", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MapRegToId", "RegToId", ";", "MapIdToReg", "IdToReg", ";", "AArch64FunctionInfo", "*", "AArch64FI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "assert", "(", "AArch64FI", "&&", "\"No MachineFunctionInfo for this function!\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Looking for LOH in \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "collectInvolvedReg", "(", "MF", ",", "RegToId", ",", "IdToReg", ",", "TRI", ")", ";", "if", "(", "RegToId", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineInstr", "*", "DummyOp", "=", "nullptr", ";", "if", "(", "BasicBlockScopeOnly", ")", "{", "const", "AArch64InstrInfo", "*", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "TM", ".", "getInstrInfo", "(", ")", ")", ";", "DummyOp", "=", "MF", ".", "CreateMachineInstr", "(", "TII", "->", "get", "(", "AArch64", "::", "COPY", ")", ",", "DebugLoc", "(", ")", ")", ";", "}", "unsigned", "NbReg", "=", "RegToId", ".", "size", "(", ")", ";", "bool", "Modified", "=", "false", ";", "InstrToInstrs", "*", "ColorOpToReachedUses", "=", "new", "InstrToInstrs", "[", "NbReg", "]", ";", "reachingDef", "(", "MF", ",", "ColorOpToReachedUses", ",", "RegToId", ",", "true", ",", "DummyOp", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"ADRP reaching defs\\n\"", ")", ";", "DEBUG", "(", "printReachingDef", "(", "ColorOpToReachedUses", ",", "NbReg", ",", "TRI", ",", "IdToReg", ")", ")", ";", "InstrToInstrs", "ADRPToReachingDefs", ";", "reachedUsesToDefs", "(", "ADRPToReachingDefs", ",", "ColorOpToReachedUses", ",", "RegToId", ",", "true", ")", ";", "computeADRP", "(", "ADRPToReachingDefs", ",", "*", "AArch64FI", ",", "MDT", ")", ";", "delete", "[", "]", "ColorOpToReachedUses", ";", "ColorOpToReachedUses", "=", "new", "InstrToInstrs", "[", "NbReg", "]", ";", "reachingDef", "(", "MF", ",", "ColorOpToReachedUses", ",", "RegToId", ",", "false", ",", "DummyOp", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"All reaching defs\\n\"", ")", ";", "DEBUG", "(", "printReachingDef", "(", "ColorOpToReachedUses", ",", "NbReg", ",", "TRI", ",", "IdToReg", ")", ")", ";", "InstrToInstrs", "UsesToReachingDefs", ";", "reachedUsesToDefs", "(", "UsesToReachingDefs", ",", "ColorOpToReachedUses", ",", "RegToId", ",", "false", ")", ";", "computeOthers", "(", "UsesToReachingDefs", ",", "ColorOpToReachedUses", ",", "*", "AArch64FI", ",", "RegToId", ",", "MDT", ")", ";", "delete", "[", "]", "ColorOpToReachedUses", ";", "if", "(", "BasicBlockScopeOnly", ")", "MF", ".", "DeleteMachineInstr", "(", "DummyOp", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "\"No MachineFunctionInfo for this function!\"", "\"Looking for LOH in \"", "AArch64", "AArch64", "AArch64::COPY", "\"ADRP reaching defs\\n\"", "AArch64", "\"All reaching defs\\n\"", "AArch64" ]

[]

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

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

[ "PowerPC" ]

[]

[ "<s>", "unsigned", "PPCInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "PPC", "::", "STD", ":", "case", "PPC", "::", "STW", ":", "case", "PPC", "::", "STFS", ":", "case", "PPC", "::", "STFD", ":", "case", "PPC", "::", "SPILL_CR", ":", "case", "PPC", "::", "SPILL_CRBIT", ":", "case", "PPC", "::", "STVX", ":", "case", "PPC", "::", "STXVD2X", ":", "case", "PPC", "::", "STXVX", ":", "case", "PPC", "::", "QVSTFDX", ":", "case", "PPC", "::", "QVSTFSXs", ":", "case", "PPC", "::", "QVSTFDXb", ":", "case", "PPC", "::", "SPILL_VRSAVE", ":", "case", "PPC", "::", "SPILLTOVSR_ST", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "!", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::STD", "PPC::STW", "PPC::STFS", "PPC::STFD", "PPC::SPILL_CR", "PPC::SPILL_CRBIT", "PPC::STVX", "PPC::STXVD2X", "PPC::STXVX", "PPC::QVSTFDX", "PPC::QVSTFSXs", "PPC::QVSTFDXb", "PPC::SPILL_VRSAVE", "PPC::SPILLTOVSR_ST", "1", "1", "2", "2", "0", "0" ]

[]

[ "<s>", "unsigned", "getExceptionSelectorRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "override", "{", "return", "ABI", ".", "IsN64", "(", ")", "?", "Mips", "::", "A1_64", ":", "Mips", "::", "A1", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "typeid", "on", "entry", "to", "a", "landing", "pad", "." ]

[ "Mips", "Mips::A1_64", "Mips::A1" ]

[]

[ "<s>", "static", "void", "output_indirect_thunk_function", "(", "enum", "indirect_thunk_prefix", "need_prefix", ",", "unsigned", "int", "regno", ",", "bool", "ret_p", ")", "{", "char", "name", "[", "32", "]", ";", "tree", "decl", ";", "indirect_thunk_name", "(", "name", ",", "regno", ",", "need_prefix", ",", "ret_p", ")", ";", "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", ";", "DECL_IGNORED_P", "(", "decl", ")", "=", "1", ";", "if", "(", "TARGET_MACHO", ")", "{", "switch_to_section", "(", "darwin_sections", "[", "picbase_thunk_section", "]", ")", ";", "fputs", "(", "\"\\t.weak_definition\\t\"", ",", "asm_out_file", ")", ";", "assemble_name", "(", "asm_out_file", ",", "name", ")", ";", "fputs", "(", "\"\\n\\t.private_extern\\t\"", ",", "asm_out_file", ")", ";", "assemble_name", "(", "asm_out_file", ",", "name", ")", ";", "putc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "ASM_OUTPUT_LABEL", "(", "asm_out_file", ",", "name", ")", ";", "DECL_WEAK", "(", "decl", ")", "=", "1", ";", "}", "else", "if", "(", "USE_HIDDEN_LINKONCE", ")", "{", "cgraph_node", "::", "create", "(", "decl", ")", "->", "set_comdat_group", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ";", "targetm", ".", "asm_out", ".", "unique_section", "(", "decl", ",", "0", ")", ";", "switch_to_section", "(", "get_named_section", "(", "decl", ",", "NULL", ",", "0", ")", ")", ";", "targetm", ".", "asm_out", ".", "globalize_label", "(", "asm_out_file", ",", "name", ")", ";", "fputs", "(", "\"\\t.hidden\\t\"", ",", "asm_out_file", ")", ";", "assemble_name", "(", "asm_out_file", ",", "name", ")", ";", "putc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "ASM_DECLARE_FUNCTION_NAME", "(", "asm_out_file", ",", "name", ",", "decl", ")", ";", "}", "else", "{", "switch_to_section", "(", "text_section", ")", ";", "ASM_OUTPUT_LABEL", "(", "asm_out_file", ",", "name", ")", ";", "}", "DECL_INITIAL", "(", "decl", ")", "=", "make_node", "(", "BLOCK", ")", ";", "current_function_decl", "=", "decl", ";", "allocate_struct_function", "(", "decl", ",", "false", ")", ";", "init_function_start", "(", "decl", ")", ";", "cfun", "->", "is_thunk", "=", "true", ";", "first_function_block_is_cold", "=", "false", ";", "final_start_function", "(", "emit_barrier", "(", ")", ",", "asm_out_file", ",", "1", ")", ";", "output_indirect_thunk", "(", "need_prefix", ",", "regno", ")", ";", "final_end_function", "(", ")", ";", "init_insn_lengths", "(", ")", ";", "free_after_compilation", "(", "cfun", ")", ";", "set_cfun", "(", "NULL", ")", ";", "current_function_decl", "=", "NULL", ";", "}", "</s>" ]

[ "Output", "a", "funtion", "with", "a", "call", "and", "return", "thunk", "for", "indirect", "branch", ".", "If", "BND_P", "is", "true", ",", "the", "BND", "prefix", "is", "needed", ".", "If", "REGNO", "!", "=", "UNVALID_REGNUM", ",", "the", "function", "address", "is", "in", "REGNO", ".", "Otherwise", ",", "the", "function", "address", "is", "on", "the", "top", "of", "stack", ".", "Thunk", "is", "used", "for", "function", "return", "if", "RET_P", "is", "true", "." ]

[ "i386", "32", "1", "1", "1", "\"\\t.weak_definition\\t\"", "\"\\n\\t.private_extern\\t\"", "1", "0", "0", "\"\\t.hidden\\t\"", "1" ]

[]

[ "<s>", "static", "tree", "bpf_resolve_overloaded_builtin", "(", "location_t", "loc", ",", "tree", "fndecl", ",", "void", "*", "arglist", ")", "{", "if", "(", "DECL_MD_FUNCTION_CODE", "(", "fndecl", ")", "!=", "BPF_BUILTIN_PRESERVE_ACCESS_INDEX", ")", "return", "NULL_TREE", ";", "vec", "<", "tree", ",", "va_gc", ">", "*", "params", "=", "static_cast", "<", "vec", "<", "tree", ",", "va_gc", ">", "*", ">", "(", "arglist", ")", ";", "unsigned", "n_params", "=", "params", "?", "params", "->", "length", "(", ")", ":", "0", ";", "if", "(", "n_params", "!=", "1", ")", "{", "error_at", "(", "loc", ",", "\"expected exactly 1 argument\"", ")", ";", "return", "NULL_TREE", ";", "}", "tree", "param", "=", "(", "*", "params", ")", "[", "0", "]", ";", "if", "(", "!", "TARGET_BPF_CORE", ")", "return", "param", ";", "if", "(", "TREE_CODE", "(", "param", ")", "==", "C_MAYBE_CONST_EXPR", ")", "param", "=", "C_MAYBE_CONST_EXPR_EXPR", "(", "param", ")", ";", "walk_tree", "(", "&", "param", ",", "bpf_core_walk", ",", "(", "void", "*", ")", "&", "loc", ",", "NULL", ")", ";", "return", "param", ";", "}", "</s>" ]

[ "Implement", "TARGET_RESOLVE_OVERLOADED_BUILTIN", "(", "see", "gccint", "manual", "section", "Target", "Macros", ":", ":Misc.", ")", ".", "Used", "for", "CO-RE", "support", "builtins", "such", "as", "__builtin_preserve_access_index", "and", "__builtin_preserve_field_info", ".", "FNDECL", "is", "the", "declaration", "of", "the", "builtin", ",", "and", "ARGLIST", "is", "the", "list", "of", "arguments", "passed", "to", "it", ",", "and", "is", "really", "a", "vec", "<", "tree", ",", "_", ">", "*", "." ]

[ "bpf", "0", "1", "\"expected exactly 1 argument\"", "0" ]

[]

[ "<s>", "DecodeStatus", "RISCVDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "CS", ")", "const", "{", "uint32_t", "Insn", ";", "DecodeStatus", "Result", ";", "if", "(", "(", "Bytes", "[", "0", "]", "&", "0x3", ")", "==", "0x3", ")", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "Insn", "=", "support", "::", "endian", "::", "read32le", "(", "Bytes", ".", "data", "(", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying RISCV32 table :\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable32", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "Size", "=", "4", ";", "}", "else", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "2", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "Insn", "=", "support", "::", "endian", "::", "read16le", "(", "Bytes", ".", "data", "(", ")", ")", ";", "if", "(", "!", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "Feature64Bit", "]", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying RISCV32Only_16 table (16-bit Instruction):\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableRISCV32Only_16", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "2", ";", "return", "Result", ";", "}", "}", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureExtZbproposedc", "]", "&&", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureStdExtC", "]", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying RVBC32 table (BitManip 16-bit Instruction):\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableRVBC16", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "2", ";", "return", "Result", ";", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying RISCV_C table (16-bit Instruction):\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable16", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "Size", "=", "2", ";", "}", "return", "Result", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "0", "0x3", "0x3", "4", "0", "support::endian", "\"Trying RISCV32 table :\\n\"", "4", "2", "0", "support::endian", "RISCV::Feature64Bit", "\"Trying RISCV32Only_16 table (16-bit Instruction):\\n\"", "RISCV", "2", "RISCV::FeatureExtZbproposedc", "RISCV::FeatureStdExtC", "\"Trying RVBC32 table (BitManip 16-bit Instruction):\\n\"", "2", "\"Trying RISCV_C table (16-bit Instruction):\\n\"", "2" ]

[]