Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "const", "RISCVSubtarget", "*", "RISCVTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "TuneAttr", "=", "F", ".", "getFnAttribute", "(", "\"tune-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "CPUAttr", ".", "isValid", "(", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "TuneCPU", "=", "TuneAttr", ".", "isValid", "(", ")", "?", "TuneAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "CPU", ";", "std", "::", "string", "FS", "=", "FSAttr", ".", "isValid", "(", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "std", "::", "string", "Key", "=", "CPU", "+", "TuneCPU", "+", "FS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "auto", "ABIName", "=", "Options", ".", "MCOptions", ".", "getABIName", "(", ")", ";", "if", "(", "const", "MDString", "*", "ModuleTargetABI", "=", "dyn_cast_or_null", "<", "MDString", ">", "(", "F", ".", "getParent", "(", ")", "->", "getModuleFlag", "(", "\"target-abi\"", ")", ")", ")", "{", "auto", "TargetABI", "=", "RISCVABI", "::", "getTargetABI", "(", "ABIName", ")", ";", "if", "(", "TargetABI", "!=", "RISCVABI", "::", "ABI_Unknown", "&&", "ModuleTargetABI", "->", "getString", "(", ")", "!=", "ABIName", ")", "{", "report_fatal_error", "(", "\"-target-abi option != target-abi module flag\"", ")", ";", "}", "ABIName", "=", "ModuleTargetABI", "->", "getString", "(", ")", ";", "}", "I", "=", "std", "::", "make_unique", "<", "RISCVSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "TuneCPU", ",", "FS", ",", "ABIName", ",", "*", "this", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "RISCV", "\"target-cpu\"", "\"tune-cpu\"", "\"target-features\"", "\"target-abi\"", "RISCVABI::getTargetABI", "RISCVABI::ABI_Unknown", "\"-target-abi option != target-abi module flag\"", "RISCV" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "hasUnwantedEffectsWhenEXECEmpty", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "MI", ".", "mayStore", "(", ")", "&&", "isSMRD", "(", "MI", ")", ")", "return", "true", ";", "if", "(", "MI", ".", "isReturn", "(", ")", ")", "return", "true", ";", "if", "(", "Opcode", "==", "AMDGPU", "::", "S_SENDMSG", "||", "Opcode", "==", "AMDGPU", "::", "S_SENDMSGHALT", "||", "Opcode", "==", "AMDGPU", "::", "EXP", "||", "Opcode", "==", "AMDGPU", "::", "EXP_DONE", "||", "Opcode", "==", "AMDGPU", "::", "DS_ORDERED_COUNT", "||", "Opcode", "==", "AMDGPU", "::", "S_TRAP", "||", "Opcode", "==", "AMDGPU", "::", "DS_GWS_INIT", "||", "Opcode", "==", "AMDGPU", "::", "DS_GWS_BARRIER", ")", "return", "true", ";", "if", "(", "MI", ".", "isCall", "(", ")", "||", "MI", ".", "isInlineAsm", "(", ")", ")", "return", "true", ";", "if", "(", "Opcode", "==", "AMDGPU", "::", "V_READFIRSTLANE_B32", "||", "Opcode", "==", "AMDGPU", "::", "V_READLANE_B32", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Whether", "we", "must", "prevent", "this", "instruction", "from", "executing", "with", "EXEC", "=", "0", "." ]

[ "AMDGPU", "SI", "AMDGPU::S_SENDMSG", "AMDGPU::S_SENDMSGHALT", "AMDGPU::EXP", "AMDGPU::EXP_DONE", "AMDGPU::DS_ORDERED_COUNT", "AMDGPU::S_TRAP", "AMDGPU::DS_GWS_INIT", "AMDGPU::DS_GWS_BARRIER", "AMDGPU::V_READFIRSTLANE_B32", "AMDGPU::V_READLANE_B32" ]

[]

[ "<s>", "rtx_insn", "*", "s390_emit_call", "(", "rtx", "addr_location", ",", "rtx", "tls_call", ",", "rtx", "result_reg", ",", "rtx", "retaddr_reg", ")", "{", "bool", "plt31_call_p", "=", "false", ";", "rtx_insn", "*", "insn", ";", "rtx", "vec", "[", "4", "]", "=", "{", "NULL_RTX", "}", ";", "int", "elts", "=", "0", ";", "rtx", "*", "call", "=", "&", "vec", "[", "0", "]", ";", "rtx", "*", "clobber_ret_reg", "=", "&", "vec", "[", "1", "]", ";", "rtx", "*", "use", "=", "&", "vec", "[", "2", "]", ";", "rtx", "*", "clobber_thunk_reg", "=", "&", "vec", "[", "3", "]", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "addr_location", ")", "==", "SYMBOL_REF", ")", "{", "if", "(", "flag_pic", "&&", "!", "SYMBOL_REF_LOCAL_P", "(", "addr_location", ")", "&&", "!", "TARGET_64BIT", ")", "{", "if", "(", "retaddr_reg", "!=", "NULL_RTX", ")", "{", "addr_location", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "addr_location", ")", ",", "UNSPEC_PLT31", ")", ";", "addr_location", "=", "gen_rtx_CONST", "(", "Pmode", ",", "addr_location", ")", ";", "plt31_call_p", "=", "true", ";", "}", "else", "addr_location", "=", "force_reg", "(", "Pmode", ",", "addr_location", ")", ";", "}", "}", "if", "(", "retaddr_reg", "==", "NULL_RTX", "&&", "GET_CODE", "(", "addr_location", ")", "!=", "SYMBOL_REF", "&&", "!", "plt31_call_p", ")", "{", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "SIBCALL_REGNUM", ")", ",", "addr_location", ")", ";", "addr_location", "=", "gen_rtx_REG", "(", "Pmode", ",", "SIBCALL_REGNUM", ")", ";", "}", "if", "(", "TARGET_INDIRECT_BRANCH_NOBP_CALL", "&&", "GET_CODE", "(", "addr_location", ")", "!=", "SYMBOL_REF", "&&", "!", "plt31_call_p", ")", "{", "addr_location", "=", "force_reg", "(", "Pmode", ",", "addr_location", ")", ";", "if", "(", "!", "TARGET_CPU_Z10", ")", "{", "*", "clobber_thunk_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "INDIRECT_BRANCH_THUNK_REGNUM", ")", ";", "*", "clobber_thunk_reg", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "*", "clobber_thunk_reg", ")", ";", "}", "}", "addr_location", "=", "gen_rtx_MEM", "(", "QImode", ",", "addr_location", ")", ";", "*", "call", "=", "gen_rtx_CALL", "(", "VOIDmode", ",", "addr_location", ",", "const0_rtx", ")", ";", "if", "(", "result_reg", "!=", "NULL_RTX", ")", "*", "call", "=", "gen_rtx_SET", "(", "result_reg", ",", "*", "call", ")", ";", "if", "(", "retaddr_reg", "!=", "NULL_RTX", ")", "{", "*", "clobber_ret_reg", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "retaddr_reg", ")", ";", "if", "(", "tls_call", "!=", "NULL_RTX", ")", "*", "use", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "tls_call", ")", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "4", ";", "i", "++", ")", "if", "(", "vec", "[", "i", "]", "!=", "NULL_RTX", ")", "elts", "++", ";", "if", "(", "elts", ">", "1", ")", "{", "rtvec", "v", ";", "int", "e", "=", "0", ";", "v", "=", "rtvec_alloc", "(", "elts", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "4", ";", "i", "++", ")", "if", "(", "vec", "[", "i", "]", "!=", "NULL_RTX", ")", "{", "RTVEC_ELT", "(", "v", ",", "e", ")", "=", "vec", "[", "i", "]", ";", "e", "++", ";", "}", "*", "call", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "v", ")", ";", "}", "insn", "=", "emit_call_insn", "(", "*", "call", ")", ";", "if", "(", "plt31_call_p", "||", "tls_call", "!=", "NULL_RTX", ")", "{", "gcc_assert", "(", "retaddr_reg", "!=", "NULL_RTX", ")", ";", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ",", "gen_rtx_REG", "(", "Pmode", ",", "12", ")", ")", ";", "}", "return", "insn", ";", "}", "</s>" ]

[ "This", "function", "is", "used", "by", "the", "call", "expanders", "of", "the", "machine", "description", ".", "It", "emits", "the", "call", "insn", "itself", "together", "with", "the", "necessary", "operations", "to", "adjust", "the", "target", "address", "and", "returns", "the", "emitted", "insn", ".", "ADDR_LOCATION", "is", "the", "target", "address", "rtx", "TLS_CALL", "the", "location", "of", "the", "thread-local", "symbol", "RESULT_REG", "the", "register", "where", "the", "result", "of", "the", "call", "should", "be", "stored", "RETADDR_REG", "the", "register", "where", "the", "return", "address", "should", "be", "stored", "If", "this", "parameter", "is", "NULL_RTX", "the", "call", "is", "considered", "to", "be", "a", "sibling", "call", "." ]

[ "s390", "4", "0", "0", "1", "2", "3", "1", "0", "4", "1", "0", "0", "4", "12" ]

[]

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

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

[ "Xtensa", "Xtensa" ]

[]

[ "<s>", "void", "RISCVPassConfig", "::", "addMachineSSAOptimization", "(", ")", "{", "TargetPassConfig", "::", "addMachineSSAOptimization", "(", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "riscv64", ")", "addPass", "(", "createRISCVSExtWRemovalPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Methods", "with", "trivial", "inline", "returns", "are", "convenient", "points", "in", "the", "common", "codegen", "pass", "pipeline", "where", "targets", "may", "insert", "passes", "." ]

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

[]

[ "<s>", "const", "Cpu0TargetLowering", "*", "Cpu0TargetLowering", "::", "create", "(", "const", "Cpu0TargetMachine", "&", "TM", ",", "const", "Cpu0Subtarget", "&", "STI", ")", "{", "return", "llvm", "::", "createCpu0SETargetLowering", "(", "TM", ",", "STI", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "override", "{", "if", "(", "(", "Count", "%", "8", ")", "!=", "0", ")", "return", "false", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "<", "Count", ";", "i", "+=", "8", ")", "support", "::", "endian", "::", "write", "<", "uint64_t", ">", "(", "OS", ",", "0x7900000000000000ULL", ",", "support", "::", "little", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]

[ "VE", "8", "0", "0", "8", "support::endian", "0x7900000000000000ULL", "support::little" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 Speculative Execution Side Effect Suppression\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 Speculative Execution Side Effect Suppression\"" ]

[]

[ "<s>", "inline", "static", "rtx_insn", "*", "emit_set_insn", "(", "rtx", "x", ",", "rtx", "y", ")", "{", "return", "emit_insn", "(", "gen_rtx_SET", "(", "x", ",", "y", ")", ")", ";", "}", "</s>" ]

[ "Emit", "an", "insn", "that", "'s", "a", "simple", "single-set", ".", "Both", "the", "operands", "must", "be", "known", "to", "be", "valid", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "struct", "machine_function", "*", "rs6000_init_machine_status", "(", "void", ")", "{", "return", "ggc_alloc_cleared", "(", "sizeof", "(", "machine_function", ")", ")", ";", "}", "</s>" ]

[ "Functions", "to", "init", ",", "mark", "and", "free", "struct", "machine_function", ".", "These", "will", "be", "called", ",", "via", "pointer", "variables", ",", "from", "push_function_context", "and", "pop_function_context", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "LoopInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "LegacyDivergenceAnalysis", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "LoopInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "TargetPassConfig", ">", "(", ")", ";", "FunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]

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

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

[ "RISCV", "RISCV" ]

[]

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

[ "For", "targets", "which", "want", "to", "use", "big-endian", "can", "enable", "it", "with", "enableBigEndian", "(", ")", "hook", "." ]

[ "M68k", "M68k" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "TeakRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "return", "CSR_SaveList", ";", "}", "</s>" ]

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

[ "Teak", "Teak" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Cheri128 fail hard\"", ";", "}", "</s>" ]

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

[ "Mips", "\"Cheri128 fail hard\"" ]

[]

[ "<s>", "void", "ThumbRegisterInfo", "::", "emitLoadConstPool", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "const", "DebugLoc", "&", "dl", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "int", "Val", ",", "ARMCC", "::", "CondCodes", "Pred", ",", "unsigned", "PredReg", ",", "unsigned", "MIFlags", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "ARMSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "STI", ".", "isThumb1Only", "(", ")", ")", "{", "assert", "(", "(", "isARMLowRegister", "(", "DestReg", ")", "||", "isVirtualRegister", "(", "DestReg", ")", ")", "&&", "\"Thumb1 does not have ldr to high register\"", ")", ";", "return", "emitThumb1LoadConstPool", "(", "MBB", ",", "MBBI", ",", "dl", ",", "DestReg", ",", "SubIdx", ",", "Val", ",", "Pred", ",", "PredReg", ",", "MIFlags", ")", ";", "}", "return", "emitThumb2LoadConstPool", "(", "MBB", ",", "MBBI", ",", "dl", ",", "DestReg", ",", "SubIdx", ",", "Val", ",", "Pred", ",", "PredReg", ",", "MIFlags", ")", ";", "}", "</s>" ]

[ "emitLoadConstPool", "-", "Emits", "a", "load", "from", "constpool", "to", "materialize", "the", "specified", "immediate", "." ]

[ "ARM", "ARMCC::CondCodes", "ARM", "ARM", "ARM", "\"Thumb1 does not have ldr to high register\"" ]

[]

[ "<s>", "bool", "AMDGPUStructurizeCFG", "::", "runOnRegion", "(", "Region", "*", "R", ",", "RGPassManager", "&", "RGM", ")", "{", "if", "(", "R", "->", "isTopLevelRegion", "(", ")", ")", "return", "false", ";", "Func", "=", "R", "->", "getEntry", "(", ")", "->", "getParent", "(", ")", ";", "ParentRegion", "=", "R", ";", "DT", "=", "&", "getAnalysis", "<", "DominatorTree", ">", "(", ")", ";", "orderNodes", "(", ")", ";", "collectInfos", "(", ")", ";", "createFlow", "(", ")", ";", "insertConditions", "(", ")", ";", "rebuildSSA", "(", ")", ";", "Order", ".", "clear", "(", ")", ";", "Visited", ".", "clear", "(", ")", ";", "Predicates", ".", "clear", "(", ")", ";", "DeletedPhis", ".", "clear", "(", ")", ";", "FlowsInserted", ".", "clear", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Run", "the", "pass", "on", "a", "specific", "Region", "." ]

[ "R600" ]

[]

[ "<s>", "static", "void", "undo_split_delayed_nonbranch", "(", "rtx_insn", "*", "insn", ")", "{", "int", "icode", "=", "recog_memoized", "(", "insn", ")", ";", "enum", "attr_type", "type", ";", "rtx", "prev_pat", ",", "insn_pat", ";", "rtx_insn", "*", "prev", ";", "if", "(", "icode", "<", "0", ")", "return", ";", "type", "=", "get_attr_type", "(", "insn", ")", ";", "if", "(", "type", "!=", "TYPE_LOAD_SHADOW", "&&", "type", "!=", "TYPE_MULT_SHADOW", ")", "return", ";", "prev", "=", "PREV_INSN", "(", "insn", ")", ";", "prev_pat", "=", "PATTERN", "(", "prev", ")", ";", "insn_pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "prev_pat", ")", "==", "COND_EXEC", ")", "{", "prev_pat", "=", "COND_EXEC_CODE", "(", "prev_pat", ")", ";", "insn_pat", "=", "COND_EXEC_CODE", "(", "insn_pat", ")", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "prev_pat", ")", "==", "UNSPEC", "&&", "(", "(", "XINT", "(", "prev_pat", ",", "1", ")", "==", "UNSPEC_REAL_LOAD", "&&", "type", "==", "TYPE_LOAD_SHADOW", ")", "||", "(", "XINT", "(", "prev_pat", ",", "1", ")", "==", "UNSPEC_REAL_MULT", "&&", "type", "==", "TYPE_MULT_SHADOW", ")", ")", ")", ";", "insn_pat", "=", "gen_rtx_SET", "(", "SET_DEST", "(", "insn_pat", ")", ",", "XVECEXP", "(", "prev_pat", ",", "0", ",", "1", ")", ")", ";", "insn_pat", "=", "duplicate_cond", "(", "insn_pat", ",", "prev", ")", ";", "PATTERN", "(", "insn", ")", "=", "insn_pat", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "delete_insn", "(", "prev", ")", ";", "}", "</s>" ]

[ "Examine", "if", "INSN", "is", "the", "result", "of", "splitting", "a", "load", "into", "a", "real", "load", "and", "a", "shadow", ",", "and", "if", "so", ",", "undo", "the", "transformation", "." ]

[ "c6x", "0", "1", "1", "0", "1", "1" ]

[]

[ "<s>", "static", "rtx_insn", "*", "emit_frame_insn", "(", "rtx", "x", ")", "{", "rtx_insn", "*", "insn", "=", "emit_insn", "(", "x", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "return", "insn", ";", "}", "</s>" ]

[ "Wrapper", "around", "emit_insn", "that", "sets", "RTX_FRAME_RELATED_P", "on", "the", "insn", "." ]

[ "sh", "1" ]

[]

[ "<s>", "void", "fpscr_set_from_mem", "(", "int", "mode", ",", "HARD_REG_SET", "regs_live", ")", "{", "enum", "attr_fp_mode", "fp_mode", "=", "(", "enum", "attr_fp_mode", ")", "mode", ";", "enum", "attr_fp_mode", "norm_mode", "=", "ACTUAL_NORMAL_MODE", "(", "FP_MODE", ")", ";", "rtx", "addr_reg", "=", "!", "can_create_pseudo_p", "(", ")", "?", "get_free_reg", "(", "regs_live", ")", ":", "NULL_RTX", ";", "emit_fpu_switch", "(", "addr_reg", ",", "fp_mode", "==", "norm_mode", ")", ";", "}", "</s>" ]

[ "This", "function", "will", "set", "the", "fpscr", "from", "memory", ".", "MODE", "is", "the", "mode", "we", "are", "setting", "it", "to", "." ]

[ "sh" ]

[]

[ "<s>", "static", "void", "write_init_ovld_table", "(", "void", ")", "{", "fprintf", "(", "init_file", ",", "\" int base = RS6000_OVLD_NONE;\\n\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" /* The fndecl for an overload is arbitrarily the first one\\n\"", "\" for the overload. We sort out the real types when\\n\"", "\" processing the overload in the gcc front end. */\\n\"", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<=", "curr_ovld", ";", "i", "++", ")", "{", "fprintf", "(", "init_file", ",", "\" rs6000_instance_info[RS6000_INST_%s].fntype\"", "\"\\n = %s;\\n\"", ",", "ovlds", "[", "i", "]", ".", "ovld_id_name", ",", "ovlds", "[", "i", "]", ".", "fndecl", ")", ";", "if", "(", "i", "==", "0", "||", "ovlds", "[", "i", "]", ".", "stanza", "!=", "ovlds", "[", "i", "-", "1", "]", ".", "stanza", ")", "{", "ovld_stanza", "*", "stanza", "=", "&", "ovld_stanzas", "[", "ovlds", "[", "i", "]", ".", "stanza", "]", ";", "fprintf", "(", "init_file", ",", "\"\\n\"", ")", ";", "int", "tf_found", "=", "strstr", "(", "ovlds", "[", "i", "]", ".", "fndecl", ",", "\"tf\"", ")", "!=", "NULL", ";", "int", "dfp_found", "=", "(", "strstr", "(", "ovlds", "[", "i", "]", ".", "fndecl", ",", "\"sd\"", ")", "!=", "NULL", "||", "strstr", "(", "ovlds", "[", "i", "]", ".", "fndecl", ",", "\"dd\"", ")", "!=", "NULL", "||", "strstr", "(", "ovlds", "[", "i", "]", ".", "fndecl", ",", "\"td\"", ")", "!=", "NULL", ")", ";", "if", "(", "tf_found", ")", "{", "fprintf", "(", "init_file", ",", "\" if (float128_type_node)\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" {\\n\"", ")", ";", "}", "else", "if", "(", "dfp_found", ")", "{", "fprintf", "(", "init_file", ",", "\" if (dfloat64_type_node)\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" {\\n\"", ")", ";", "}", "fprintf", "(", "init_file", ",", "\" rs6000_builtin_decls[(int)RS6000_OVLD_%s] = t\\n\"", ",", "stanza", "->", "stanza_id", ")", ";", "fprintf", "(", "init_file", ",", "\" = add_builtin_function (\\\"%s\\\",\\n\"", ",", "stanza", "->", "intern_name", ")", ";", "fprintf", "(", "init_file", ",", "\" %s,\\n\"", ",", "ovlds", "[", "i", "]", ".", "fndecl", ")", ";", "fprintf", "(", "init_file", ",", "\" (int)RS6000_OVLD_%s,\"", "\" BUILT_IN_MD,\\n\"", ",", "stanza", "->", "stanza_id", ")", ";", "fprintf", "(", "init_file", ",", "\" NULL, NULL_TREE);\\n\"", ")", ";", "if", "(", "tf_found", "||", "dfp_found", ")", "fprintf", "(", "init_file", ",", "\" }\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\"\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" rs6000_overload_info[RS6000_OVLD_%s - base]\"", "\".first_instance\\n\"", ",", "stanza", "->", "stanza_id", ")", ";", "fprintf", "(", "init_file", ",", "\" = &rs6000_instance_info[RS6000_INST_%s];\\n\\n\"", ",", "ovlds", "[", "i", "]", ".", "ovld_id_name", ")", ";", "}", "}", "}", "</s>" ]

[ "Write", "code", "to", "initialize", "the", "overload", "table", "." ]

[ "rs6000", "\" int base = RS6000_OVLD_NONE;\\n\\n\"", "\" /* The fndecl for an overload is arbitrarily the first one\\n\"", "\" for the overload. We sort out the real types when\\n\"", "\" processing the overload in the gcc front end. */\\n\"", "0", "\" rs6000_instance_info[RS6000_INST_%s].fntype\"", "\"\\n = %s;\\n\"", "0", "1", "\"\\n\"", "\"tf\"", "\"sd\"", "\"dd\"", "\"td\"", "\" if (float128_type_node)\\n\"", "\" {\\n\"", "\" if (dfloat64_type_node)\\n\"", "\" {\\n\"", "\" rs6000_builtin_decls[(int)RS6000_OVLD_%s] = t\\n\"", "\" = add_builtin_function (\\\"%s\\\",\\n\"", "\" %s,\\n\"", "\" (int)RS6000_OVLD_%s,\"", "\" BUILT_IN_MD,\\n\"", "\" NULL, NULL_TREE);\\n\"", "\" }\\n\"", "\"\\n\"", "\" rs6000_overload_info[RS6000_OVLD_%s - base]\"", "\".first_instance\\n\"", "\" = &rs6000_instance_info[RS6000_INST_%s];\\n\\n\"" ]

[]

[ "<s>", "bool", "reg_unused_after", "(", "rtx", "reg", ",", "rtx_insn", "*", "insn", ")", "{", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", "&&", "!", "MEM_P", "(", "SET_DEST", "(", "set", ")", ")", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "SET_DEST", "(", "set", ")", ")", ")", "return", "true", ";", "while", "(", "(", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", ")", "{", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "continue", ";", "rtx_code", "code", "=", "GET_CODE", "(", "insn", ")", ";", "if", "(", "code", "==", "CODE_LABEL", ")", "return", "1", ";", "if", "(", "code", "==", "JUMP_INSN", ")", "return", "false", ";", "else", "if", "(", "code", "==", "INSN", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SEQUENCE", ")", "{", "rtx_sequence", "*", "seq", "=", "as_a", "<", "rtx_sequence", "*", ">", "(", "PATTERN", "(", "insn", ")", ")", ";", "bool", "retval", "=", "false", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "seq", "->", "len", "(", ")", ";", "i", "++", ")", "{", "rtx_insn", "*", "this_insn", "=", "seq", "->", "insn", "(", "i", ")", ";", "rtx", "set", "=", "single_set", "(", "this_insn", ")", ";", "if", "(", "CALL_P", "(", "this_insn", ")", ")", "code", "=", "CALL_INSN", ";", "else", "if", "(", "JUMP_P", "(", "this_insn", ")", ")", "{", "if", "(", "INSN_ANNULLED_BRANCH_P", "(", "this_insn", ")", ")", "return", "false", ";", "code", "=", "JUMP_INSN", ";", "}", "if", "(", "set", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "SET_SRC", "(", "set", ")", ")", ")", "return", "false", ";", "if", "(", "set", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "SET_DEST", "(", "set", ")", ")", ")", "{", "if", "(", "!", "MEM_P", "(", "SET_DEST", "(", "set", ")", ")", ")", "retval", "=", "true", ";", "else", "return", "false", ";", "}", "if", "(", "set", "==", "NULL_RTX", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "PATTERN", "(", "this_insn", ")", ")", ")", "return", "false", ";", "}", "if", "(", "retval", ")", "return", "true", ";", "else", "if", "(", "code", "==", "JUMP_INSN", ")", "return", "false", ";", "}", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "SET_SRC", "(", "set", ")", ")", ")", "return", "false", ";", "if", "(", "set", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "SET_DEST", "(", "set", ")", ")", ")", "return", "!", "MEM_P", "(", "SET_DEST", "(", "set", ")", ")", ";", "if", "(", "set", "==", "NULL", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "PATTERN", "(", "insn", ")", ")", ")", "return", "false", ";", "if", "(", "code", "==", "CALL_INSN", "&&", "call_used_regs", "[", "REGNO", "(", "reg", ")", "]", ")", "return", "true", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "REG", "is", "not", "used", "after", "INSN", ".", "We", "assume", "REG", "is", "a", "reload", "reg", ",", "and", "therefore", "does", "not", "live", "past", "labels", "or", "calls", "or", "jumps", "." ]

[ "sh", "1", "0" ]

[]

[ "<s>", "ARMPLT1", "*", "ARMPLT", "::", "create", "(", ")", "{", "ARMPLT1", "*", "plt1_entry", "=", "new", "(", "std", "::", "nothrow", ")", "ARMPLT1", "(", "*", "m_pSectionData", ")", ";", "if", "(", "!", "plt1_entry", ")", "fatal", "(", "diag", "::", "fail_allocate_memory_plt", ")", ";", "return", "plt1_entry", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "dump", "(", ")", "{", "cerr", "<<", "\"X86ISelAddressMode \"", "<<", "this", "<<", "'\\n'", ";", "cerr", "<<", "\"Base.Reg \"", ";", "if", "(", "Base", ".", "Reg", ".", "getNode", "(", ")", "!=", "0", ")", "Base", ".", "Reg", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "else", "cerr", "<<", "\"nul\"", ";", "cerr", "<<", "\" Base.FrameIndex \"", "<<", "Base", ".", "FrameIndex", "<<", "'\\n'", ";", "cerr", "<<", "\" Scale\"", "<<", "Scale", "<<", "'\\n'", ";", "cerr", "<<", "\"IndexReg \"", ";", "if", "(", "IndexReg", ".", "getNode", "(", ")", "!=", "0", ")", "IndexReg", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "else", "cerr", "<<", "\"nul\"", ";", "cerr", "<<", "\" Disp \"", "<<", "Disp", "<<", "'\\n'", ";", "cerr", "<<", "\"GV \"", ";", "if", "(", "GV", ")", "GV", "->", "dump", "(", ")", ";", "else", "cerr", "<<", "\"nul\"", ";", "cerr", "<<", "\" CP \"", ";", "if", "(", "CP", ")", "CP", "->", "dump", "(", ")", ";", "else", "cerr", "<<", "\"nul\"", ";", "cerr", "<<", "'\\n'", ";", "cerr", "<<", "\"ES \"", ";", "if", "(", "ES", ")", "cerr", "<<", "ES", ";", "else", "cerr", "<<", "\"nul\"", ";", "cerr", "<<", "\" JT\"", "<<", "JT", "<<", "\" Align\"", "<<", "Align", "<<", "'\\n'", ";", "}", "</s>" ]

[ "Dump", "the", "plan", "to", "stderr", "(", "for", "debugging", ")", "." ]

[ "X86", "\"X86ISelAddressMode \"", "\"Base.Reg \"", "0", "\"nul\"", "\" Base.FrameIndex \"", "\" Scale\"", "\"IndexReg \"", "0", "\"nul\"", "\" Disp \"", "\"GV \"", "\"nul\"", "\" CP \"", "\"nul\"", "\"ES \"", "\"nul\"", "\" JT\"", "\" Align\"" ]

[]

[ "<s>", "static", "bool", "m32r_rtx_ok_for_base_p", "(", "const_rtx", "x", ",", "bool", "strict", ")", "{", "if", "(", "!", "REG_P", "(", "x", ")", ")", "return", "false", ";", "if", "(", "strict", ")", "{", "if", "(", "GPR_P", "(", "REGNO", "(", "x", ")", ")", ")", "return", "true", ";", "}", "else", "{", "if", "(", "GPR_P", "(", "REGNO", "(", "x", ")", ")", "||", "REGNO", "(", "x", ")", "==", "ARG_POINTER_REGNUM", "||", "!", "HARD_REGISTER_P", "(", "x", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "True", "if", "X", "is", "a", "reg", "that", "can", "be", "used", "as", "a", "base", "reg", "." ]

[ "m32r" ]

[]

[ "<s>", "const", "uint32_t", "*", "AArch64RegisterInfo", "::", "getWindowsStackProbePreservedMask", "(", ")", "const", "{", "return", "CSR_AArch64_StackProbe_Windows_RegMask", ";", "}", "</s>" ]

[ "Stack", "probing", "calls", "preserve", "different", "CSRs", "to", "the", "normal", "CC", "." ]

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

[]

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

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

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

[]

[ "<s>", "static", "bool", "riscv_function_ok_for_sibcall", "(", "tree", "decl", "ATTRIBUTE_UNUSED", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_SAVE_RESTORE", ")", "return", "false", ";", "if", "(", "cfun", "->", "machine", "->", "naked_p", ")", "return", "false", ";", "if", "(", "cfun", "->", "machine", "->", "interrupt_handler_p", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_OK_FOR_SIBCALL", "." ]

[ "riscv" ]

[]

[ "<s>", "int", "GCNTTIImpl", "::", "getMinMaxReductionCost", "(", "VectorType", "*", "Ty", ",", "VectorType", "*", "CondTy", ",", "bool", "IsPairwise", ",", "bool", "IsUnsigned", ")", "{", "EVT", "OrigTy", "=", "TLI", "->", "getValueType", "(", "DL", ",", "Ty", ")", ";", "if", "(", "IsPairwise", "||", "!", "ST", "->", "hasVOP3PInsts", "(", ")", "||", "OrigTy", ".", "getScalarSizeInBits", "(", ")", "!=", "16", ")", "return", "BaseT", "::", "getMinMaxReductionCost", "(", "Ty", ",", "CondTy", ",", "IsPairwise", ",", "IsUnsigned", ")", ";", "std", "::", "pair", "<", "int", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "Ty", ")", ";", "return", "LT", ".", "first", "*", "getHalfRateInstrCost", "(", ")", ";", "}", "</s>" ]

[ "Try", "to", "calculate", "op", "costs", "for", "min/max", "reduction", "operations", "." ]

[ "AMDGPU", "16" ]

[]

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

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

[ "TeeRISC", "\"TeeRISC Assembly Printer\"" ]

[]

[ "<s>", "bool", "X86SpeculativeExecutionSideEffectSuppression", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "EnableSpeculativeExecutionSideEffectSuppression", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** \"", "<<", "getPassName", "(", ")", "<<", "\" : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\" **********\\n\"", ")", ";", "bool", "Modified", "=", "false", ";", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "const", "X86InstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "MachineInstr", "*", "FirstTerminator", "=", "nullptr", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "MI", ".", "mayLoadOrStore", "(", ")", "&&", "!", "MI", ".", "isTerminator", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "X86", "::", "LFENCE", ")", ")", ";", "NumLFENCEsInserted", "++", ";", "Modified", "=", "true", ";", "if", "(", "OneLFENCEPerBasicBlock", ")", "break", ";", "}", "if", "(", "MI", ".", "isTerminator", "(", ")", "&&", "FirstTerminator", "==", "nullptr", ")", "FirstTerminator", "=", "&", "MI", ";", "if", "(", "!", "MI", ".", "isBranch", "(", ")", "||", "OmitBranchLFENCEs", ")", "continue", ";", "if", "(", "OnlyLFENCENonConst", "&&", "hasConstantAddressingMode", "(", "MI", ")", ")", "continue", ";", "BuildMI", "(", "MBB", ",", "FirstTerminator", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "X86", "::", "LFENCE", ")", ")", ";", "NumLFENCEsInserted", "++", ";", "Modified", "=", "true", ";", "break", ";", "}", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"********** \"", "\" : \"", "\" **********\\n\"", "X86", "X86", "X86", "X86::LFENCE", "X86::LFENCE" ]

[]

[ "<s>", "static", "void", "frv_io_handle_use", "(", "rtx", "*", "x", ",", "void", "*", "data", ")", "{", "find_all_hard_regs", "(", "*", "x", ",", "(", "HARD_REG_SET", "*", ")", "data", ")", ";", "}", "</s>" ]

[ "A", "note_stores", "callback", "that", "applies", "frv_io_handle_use_1", "to", "an", "entire", "rhs", "value", "." ]

[ "frv" ]

[]

[ "<s>", "static", "rtx", "gen_reg_or_parallel", "(", "machine_mode", "mode", ",", "machine_mode", "orig_mode", ",", "unsigned", "int", "regno", ")", "{", "rtx", "tmp", ";", "if", "(", "orig_mode", "!=", "BLKmode", ")", "tmp", "=", "gen_rtx_REG", "(", "orig_mode", ",", "regno", ")", ";", "else", "{", "tmp", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "tmp", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "tmp", ",", "const0_rtx", ")", ";", "tmp", "=", "gen_rtx_PARALLEL", "(", "orig_mode", ",", "gen_rtvec", "(", "1", ",", "tmp", ")", ")", ";", "}", "return", "tmp", ";", "}", "</s>" ]

[ "We", "want", "to", "pass", "a", "value", "in", "REGNO", "whose", "``", "natural", "''", "mode", "is", "MODE", ".", "However", ",", "this", "may", "not", "agree", "with", "the", "mode", "that", "the", "type", "system", "has", "chosen", "for", "the", "register", ",", "which", "is", "ORIG_MODE", ".", "If", "ORIG_MODE", "is", "not", "BLKmode", ",", "then", "we", "can", "go", "ahead", "and", "use", "it", ".", "Otherwise", "we", "have", "to", "build", "a", "PARALLEL", "instead", "." ]

[ "i386", "1" ]

[]

[ "<s>", "bool", "RISCVRI5CYIR", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "errs", "(", ")", "<<", "\"runOnFunction(\"", "<<", "F", ".", "getName", "(", ")", ".", "str", "(", ")", "<<", "\")\\n\"", ";", "this", "->", "transformBitManipulation", "(", "F", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"runOnFunction(\"", "\")\\n\"" ]

[]

[ "<s>", "unsigned", "MipsSEInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "(", "Opc", "==", "Mips", "::", "SW", ")", "||", "(", "Opc", "==", "Mips", "::", "SD", ")", "||", "(", "Opc", "==", "Mips", "::", "SWC1", ")", "||", "(", "Opc", "==", "Mips", "::", "SDC1", ")", "||", "(", "Opc", "==", "Mips", "::", "SDC164", ")", ")", "{", "if", "(", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "&&", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "&&", "(", "isZeroImm", "(", "MI", ".", "getOperand", "(", "2", ")", ")", ")", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "}", "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", "." ]

[ "Mips", "Mips", "Mips::SW", "Mips::SD", "Mips::SWC1", "Mips::SDC1", "Mips::SDC164", "1", "2", "2", "1", "0", "0" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "if", "(", "MBB", ".", "isEHFuncletEntry", "(", ")", "&&", "STI", ".", "is32Bit", "(", ")", "&&", "STI", ".", "isOSWindows", "(", ")", ")", "return", "true", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "Opc", "=", "STI", ".", "is64Bit", "(", ")", "?", "X86", "::", "PUSH64r", ":", "X86", "::", "PUSH32r", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "isLiveIn", "=", "MRI", ".", "isLiveIn", "(", "Reg", ")", ";", "if", "(", "!", "isLiveIn", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "bool", "CanKill", "=", "!", "isLiveIn", ";", "if", "(", "CanKill", ")", "{", "for", "(", "MCRegAliasIterator", "AReg", "(", "Reg", ",", "TRI", ",", "false", ")", ";", "AReg", ".", "isValid", "(", ")", ";", "++", "AReg", ")", "{", "if", "(", "MRI", ".", "isLiveIn", "(", "*", "AReg", ")", ")", "{", "CanKill", "=", "false", ";", "break", ";", "}", "}", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "CanKill", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "||", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "MVT", "VT", "=", "MVT", "::", "Other", ";", "if", "(", "X86", "::", "VK16RegClass", ".", "contains", "(", "Reg", ")", ")", "VT", "=", "STI", ".", "hasBWI", "(", ")", "?", "MVT", "::", "v64i1", ":", "MVT", "::", "v16i1", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ",", "VT", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CSI", "[", "i", "-", "1", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "--", "MI", ";", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "++", "MI", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::PUSH64r", "X86::PUSH32r", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "MVT::Other", "X86::VK16RegClass", "MVT::v64i1", "MVT::v16i1", "1" ]

[]

[ "<s>", "unsigned", "X86TargetLowering", "::", "getByValTypeAlignment", "(", "Type", "*", "Ty", ",", "const", "DataLayout", "&", "DL", ")", "const", "{", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "{", "unsigned", "TyAlign", "=", "DL", ".", "getABITypeAlignment", "(", "Ty", ")", ";", "if", "(", "TyAlign", ">", "8", ")", "return", "TyAlign", ";", "return", "8", ";", "}", "unsigned", "Align", "=", "4", ";", "if", "(", "Subtarget", ".", "hasSSE1", "(", ")", ")", "getMaxByValAlign", "(", "Ty", ",", "Align", ")", ";", "return", "Align", ";", "}", "</s>" ]

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

[ "X86", "X86", "8", "8", "4" ]

[]

[ "<s>", "virtual", "void", "EmitInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "EmitA64MappingSymbol", "(", ")", ";", "MCELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "ARM64" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Thumb2 instruction size reduction pass\"", ";", "}", "</s>" ]

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

[ "ARM", "\"Thumb2 instruction size reduction pass\"" ]

[]

[ "<s>", "void", "SparcInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "if", "(", "RC", "==", "&", "SP", "::", "I64RegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDXri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "SP", "::", "IntRegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "SP", "::", "FPRegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDFri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "SP", "::", "DFPRegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDDFri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "Sparc", "Sparc", "SP::I64RegsRegClass", "SP::LDXri", "0", "SP::IntRegsRegClass", "SP::LDri", "0", "SP::FPRegsRegClass", "SP::LDFri", "0", "SP::DFPRegsRegClass", "SP::LDDFri", "0", "\"Can't load this register from stack slot\"" ]

[]

[ "<s>", "bool", "iq2000_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "return", "(", "regno", "==", "GP_RETURN", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "FUNCTION_VALUE_REGNO_P", ".", "On", "the", "IQ2000", ",", "R2", "and", "R3", "are", "the", "only", "register", "thus", "used", "." ]

[ "iq2000" ]

[]

[ "<s>", "static", "void", "sh_insert_attributes", "(", "tree", "node", ",", "tree", "*", "attributes", ")", "{", "if", "(", "TREE_CODE", "(", "node", ")", "!=", "FUNCTION_DECL", ")", "return", ";", "if", "(", "!", "DECL_P", "(", "node", ")", ")", "return", ";", "*", "sh_deferred_function_attributes_tail", "=", "*", "attributes", ";", "tree", "attrs", "=", "sh_deferred_function_attributes", ";", "if", "(", "!", "attrs", ")", "return", ";", "if", "(", "!", "lookup_attribute", "(", "\"interrupt_handler\"", ",", "attrs", ")", "&&", "!", "lookup_attribute", "(", "\"interrupt_handler\"", ",", "DECL_ATTRIBUTES", "(", "node", ")", ")", ")", "{", "if", "(", "lookup_attribute", "(", "\"trapa_handler\"", ",", "attrs", ")", "!=", "NULL_TREE", ")", "attrs", "=", "tree_cons", "(", "get_identifier", "(", "\"interrupt_handler\"", ")", ",", "NULL_TREE", ",", "attrs", ")", ";", "else", "if", "(", "lookup_attribute", "(", "\"sp_switch\"", ",", "attrs", ")", "||", "lookup_attribute", "(", "\"trap_exit\"", ",", "attrs", ")", "||", "lookup_attribute", "(", "\"nosave_low_regs\"", ",", "attrs", ")", "||", "lookup_attribute", "(", "\"resbank\"", ",", "attrs", ")", ")", "{", "tree", "*", "tail", ";", "for", "(", "tail", "=", "attributes", ";", "attrs", ";", "attrs", "=", "TREE_CHAIN", "(", "attrs", ")", ")", "{", "if", "(", "is_attribute_p", "(", "\"sp_switch\"", ",", "TREE_PURPOSE", "(", "attrs", ")", ")", "||", "is_attribute_p", "(", "\"trap_exit\"", ",", "TREE_PURPOSE", "(", "attrs", ")", ")", "||", "is_attribute_p", "(", "\"nosave_low_regs\"", ",", "TREE_PURPOSE", "(", "attrs", ")", ")", "||", "is_attribute_p", "(", "\"resbank\"", ",", "TREE_PURPOSE", "(", "attrs", ")", ")", ")", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute only applies to interrupt functions\"", ",", "TREE_PURPOSE", "(", "attrs", ")", ")", ";", "else", "{", "*", "tail", "=", "tree_cons", "(", "TREE_PURPOSE", "(", "attrs", ")", ",", "NULL_TREE", ",", "NULL_TREE", ")", ";", "tail", "=", "&", "TREE_CHAIN", "(", "*", "tail", ")", ";", "}", "}", "attrs", "=", "*", "attributes", ";", "}", "}", "*", "attributes", "=", "attrs", ";", "sh_deferred_function_attributes", "=", "NULL_TREE", ";", "sh_deferred_function_attributes_tail", "=", "&", "sh_deferred_function_attributes", ";", "return", ";", "}", "</s>" ]

[ "Generate", "'handle_interrupt", "'", "attribute", "for", "decls" ]

[ "sh", "\"interrupt_handler\"", "\"interrupt_handler\"", "\"trapa_handler\"", "\"interrupt_handler\"", "\"sp_switch\"", "\"trap_exit\"", "\"nosave_low_regs\"", "\"resbank\"", "\"sp_switch\"", "\"trap_exit\"", "\"nosave_low_regs\"", "\"resbank\"", "\"%qE attribute only applies to interrupt functions\"" ]

[]

[ "<s>", "Register", "ARMBaseRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "const", "ARMFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "return", "getFramePointerReg", "(", "STI", ")", ";", "return", "ARM", "::", "SP", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM::SP" ]

[]

[ "<s>", "static", "bool", "aarch64_valid_floating_const", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "if", "(", "!", "CONST_DOUBLE_P", "(", "x", ")", ")", "return", "false", ";", "if", "(", "aarch64_float_const_zero_rtx_p", "(", "x", ")", ")", "return", "true", ";", "if", "(", "!", "(", "mode", "==", "SFmode", "||", "mode", "==", "DFmode", ")", ")", "return", "false", ";", "return", "aarch64_float_const_representable_p", "(", "x", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "holds", "either", "a", "quarter-precision", "or", "floating-point", "+0.0", "constant", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "MBlazeInstrInfo", "::", "insertNoop", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MBlaze", "::", "NOP", ")", ")", ";", "}", "</s>" ]

[ "Insert", "a", "noop", "into", "the", "instruction", "stream", "at", "the", "specified", "point", "." ]

[ "MBlaze", "MBlaze", "MBlaze::NOP" ]

[]

[ "<s>", "void", "mmix_asm_output_label", "(", "FILE", "*", "stream", ",", "const", "char", "*", "name", ")", "{", "assemble_name", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\"\\tIS @\\n\"", ")", ";", "}", "</s>" ]

[ "ASM_OUTPUT_LABEL", "." ]

[ "mmix", "\"\\tIS @\\n\"" ]

[]

[ "<s>", "void", "X86RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "X86FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "unsigned", "BasePtr", ";", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "bool", "AfterFPPop", "=", "Opc", "==", "X86", "::", "TAILJMPm64", "||", "Opc", "==", "X86", "::", "TAILJMPm", "||", "Opc", "==", "X86", "::", "TCRETURNmi", "||", "Opc", "==", "X86", "::", "TCRETURNmi64", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "BasePtr", "=", "(", "FrameIndex", "<", "0", "?", "FramePtr", ":", "getBaseRegister", "(", ")", ")", ";", "else", "if", "(", "needsStackRealignment", "(", "MF", ")", ")", "BasePtr", "=", "(", "FrameIndex", "<", "0", "?", "FramePtr", ":", "StackPtr", ")", ";", "else", "if", "(", "AfterFPPop", ")", "BasePtr", "=", "StackPtr", ";", "else", "BasePtr", "=", "(", "TFI", "->", "hasFP", "(", "MF", ")", "?", "FramePtr", ":", "StackPtr", ")", ";", "unsigned", "IgnoredFrameReg", ";", "if", "(", "Opc", "==", "TargetOpcode", "::", "LOCAL_ESCAPE", ")", "{", "MachineOperand", "&", "FI", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "int", "Offset", ";", "Offset", "=", "TFI", "->", "getFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "IgnoredFrameReg", ")", ";", "FI", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "if", "(", "Opc", "==", "X86", "::", "LEA64_32r", "&&", "X86", "::", "GR32RegClass", ".", "contains", "(", "BasePtr", ")", ")", "BasePtr", "=", "getX86SubSuperRegister", "(", "BasePtr", ",", "MVT", "::", "i64", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "int", "FIOffset", ";", "if", "(", "AfterFPPop", ")", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "FIOffset", "=", "MFI", "->", "getObjectOffset", "(", "FrameIndex", ")", "-", "TFI", "->", "getOffsetOfLocalArea", "(", ")", ";", "}", "else", "FIOffset", "=", "TFI", "->", "getFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "IgnoredFrameReg", ")", ";", "if", "(", "BasePtr", "==", "StackPtr", ")", "FIOffset", "+=", "SPAdj", ";", "if", "(", "Opc", "==", "TargetOpcode", "::", "STACKMAP", "||", "Opc", "==", "TargetOpcode", "::", "PATCHPOINT", ")", "{", "assert", "(", "BasePtr", "==", "FramePtr", "&&", "\"Expected the FP as base register\"", ")", ";", "int64_t", "Offset", "=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", "+", "FIOffset", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "if", "(", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "isImm", "(", ")", ")", "{", "int", "Imm", "=", "(", "int", ")", "(", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "getImm", "(", ")", ")", ";", "int", "Offset", "=", "FIOffset", "+", "Imm", ";", "assert", "(", "(", "!", "Is64Bit", "||", "isInt", "<", "32", ">", "(", "(", "long", "long", ")", "FIOffset", "+", "Imm", ")", ")", "&&", "\"Requesting 64-bit offset in 32-bit immediate!\"", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "else", "{", "uint64_t", "Offset", "=", "FIOffset", "+", "(", "uint64_t", ")", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "getOffset", "(", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "setOffset", "(", "Offset", ")", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86::TAILJMPm64", "X86::TAILJMPm", "X86::TCRETURNmi", "X86::TCRETURNmi64", "0", "0", "X86::LEA64_32r", "X86::GR32RegClass", "X86", "MVT::i64", "\"Expected the FP as base register\"", "1", "1", "3", "3", "32", "\"Requesting 64-bit offset in 32-bit immediate!\"", "3", "3", "3" ]

[]

[ "<s>", "static", "int", "mep_insn_dependent_p", "(", "rtx", "x", ",", "rtx", "y", ")", "{", "rtx", "tmp", ";", "gcc_assert", "(", "INSN_P", "(", "x", ")", ")", ";", "gcc_assert", "(", "INSN_P", "(", "y", ")", ")", ";", "tmp", "=", "PATTERN", "(", "y", ")", ";", "note_stores", "(", "PATTERN", "(", "x", ")", ",", "mep_insn_dependent_p_1", ",", "&", "tmp", ")", ";", "if", "(", "tmp", "==", "NULL_RTX", ")", "return", "1", ";", "tmp", "=", "PATTERN", "(", "x", ")", ";", "note_stores", "(", "PATTERN", "(", "y", ")", ",", "mep_insn_dependent_p_1", ",", "&", "tmp", ")", ";", "if", "(", "tmp", "==", "NULL_RTX", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "anything", "in", "insn", "X", "is", "(", "anti", ",", "output", ",", "true", ")", "dependent", "on", "anything", "in", "insn", "Y", "." ]

[ "mep", "1", "1", "0" ]

[]

[ "<s>", "unsigned", "NVPTXTTIImpl", "::", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ",", "TTI", "::", "OperandValueKind", "Opd1Info", ",", "TTI", "::", "OperandValueKind", "Opd2Info", ",", "TTI", "::", "OperandValueProperties", "Opd1PropInfo", ",", "TTI", "::", "OperandValueProperties", "Opd2PropInfo", ")", "{", "std", "::", "pair", "<", "unsigned", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "Ty", ")", ";", "int", "ISD", "=", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", ";", "switch", "(", "ISD", ")", "{", "default", ":", "return", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "Opd1Info", ",", "Opd2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "MUL", ":", "case", "ISD", "::", "XOR", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "AND", ":", "if", "(", "LT", ".", "second", ".", "SimpleTy", "==", "MVT", "::", "i64", ")", "return", "2", "*", "LT", ".", "first", ";", "return", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "Opd1Info", ",", "Opd2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "}", "}", "</s>" ]

[ "This", "is", "an", "approximation", "of", "reciprocal", "throughput", "of", "a", "math/logic", "op", "." ]

[ "NVPTX", "NVPTX", "ISD::ADD", "ISD::MUL", "ISD::XOR", "ISD::OR", "ISD::AND", "MVT::i64", "2" ]

[]

[ "<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", "(", "MachinePointerInfo", "(", "PseudoSourceValue", "::", "getFixedStack", "(", "FI", ")", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "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", "ARM::tSpill", "0" ]

[]

[ "<s>", "bool", "SITypeRewriter", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "AttributeSet", "Set", "=", "F", ".", "getAttributes", "(", ")", ";", "Attribute", "A", "=", "Set", ".", "getAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "\"ShaderType\"", ")", ";", "unsigned", "ShaderType", "=", "ShaderType", "::", "COMPUTE", ";", "if", "(", "A", ".", "isStringAttribute", "(", ")", ")", "{", "StringRef", "Str", "=", "A", ".", "getValueAsString", "(", ")", ";", "Str", ".", "getAsInteger", "(", "0", ",", "ShaderType", ")", ";", "}", "if", "(", "ShaderType", "==", "ShaderType", "::", "COMPUTE", ")", "return", "false", ";", "visit", "(", "F", ")", ";", "visit", "(", "F", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "R600", "SI", "\"ShaderType\"", "0" ]

[]

[ "<s>", "void", "PPCMIPeephole", "::", "initialize", "(", "MachineFunction", "&", "MFParm", ")", "{", "MF", "=", "&", "MFParm", ";", "MRI", "=", "&", "MF", "->", "getRegInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "TII", "=", "MF", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** PowerPC MI peephole pass ***\\n\\n\"", ")", ";", "LLVM_DEBUG", "(", "MF", "->", "dump", "(", ")", ")", ";", "}", "</s>" ]

[ "Initialize", "the", "strategy", "after", "building", "the", "DAG", "for", "a", "new", "region", "." ]

[ "PowerPC", "PPC", "PPC", "\"*** PowerPC MI peephole pass ***\\n\\n\"" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "if", "(", "CallConv", "==", "CallingConv", "::", "MSP430_INTR", "&&", "!", "Outs", ".", "empty", "(", ")", ")", "report_fatal_error", "(", "\"ISRs cannot return any value\"", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "AnalyzeReturnValues", "(", "CCInfo", ",", "RVLocs", ",", "Outs", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "unsigned", "Opc", "=", "(", "CallConv", "==", "CallingConv", "::", "MSP430_INTR", "?", "MSP430ISD", "::", "RETI_FLAG", ":", "MSP430ISD", "::", "RET_FLAG", ")", ";", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "ISD::OutputArg", "16", "MSP430", "\"ISRs cannot return any value\"", "4", "1", "0", "\"Can only return in registers!\"", "1", "MSP430", "MSP430ISD::RETI_FLAG", "MSP430ISD::RET_FLAG", "0", "MVT::Other" ]

[]

[ "<s>", "static", "int", "rs6000_variable_issue", "(", "FILE", "*", "stream", ",", "int", "verbose", ",", "rtx_insn", "*", "insn", ",", "int", "more", ")", "{", "int", "r", "=", "rs6000_variable_issue_1", "(", "insn", ",", "more", ")", ";", "if", "(", "verbose", ")", "fprintf", "(", "stream", ",", "\"// rs6000_variable_issue (more = %d) = %d\\n\"", ",", "more", ",", "r", ")", ";", "return", "r", ";", "}", "</s>" ]

[ "Power4", "load", "update", "and", "store", "update", "instructions", "are", "cracked", "into", "a", "load", "or", "store", "and", "an", "integer", "insn", "which", "are", "executed", "in", "the", "same", "cycle", ".", "Branches", "have", "their", "own", "dispatch", "slot", "which", "does", "not", "count", "against", "the", "GCC", "issue", "rate", ",", "but", "it", "changes", "the", "program", "flow", "so", "there", "are", "no", "other", "instructions", "to", "issue", "in", "this", "cycle", "." ]

[ "rs6000", "\"// rs6000_variable_issue (more = %d) = %d\\n\"" ]

[]

[ "<s>", "static", "bool", "ix86_pragma_target_parse", "(", "tree", "args", ",", "tree", "pop_target", ")", "{", "tree", "prev_tree", "=", "build_target_option_node", "(", "&", "global_options", ",", "&", "global_options_set", ")", ";", "tree", "cur_tree", ";", "struct", "cl_target_option", "*", "prev_opt", ";", "struct", "cl_target_option", "*", "cur_opt", ";", "HOST_WIDE_INT", "prev_isa", ";", "HOST_WIDE_INT", "cur_isa", ";", "HOST_WIDE_INT", "diff_isa", ";", "HOST_WIDE_INT", "prev_isa2", ";", "HOST_WIDE_INT", "cur_isa2", ";", "HOST_WIDE_INT", "diff_isa2", ";", "enum", "processor_type", "prev_arch", ";", "enum", "processor_type", "prev_tune", ";", "enum", "processor_type", "cur_arch", ";", "enum", "processor_type", "cur_tune", ";", "if", "(", "!", "args", ")", "{", "cur_tree", "=", "(", "pop_target", "?", "pop_target", ":", "target_option_default_node", ")", ";", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "TREE_TARGET_OPTION", "(", "cur_tree", ")", ")", ";", "}", "else", "{", "cur_tree", "=", "ix86_valid_target_attribute_tree", "(", "NULL_TREE", ",", "args", ",", "&", "global_options", ",", "&", "global_options_set", ",", "0", ")", ";", "if", "(", "!", "cur_tree", "||", "cur_tree", "==", "error_mark_node", ")", "{", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "TREE_TARGET_OPTION", "(", "prev_tree", ")", ")", ";", "return", "false", ";", "}", "}", "target_option_current_node", "=", "cur_tree", ";", "ix86_reset_previous_fndecl", "(", ")", ";", "prev_opt", "=", "TREE_TARGET_OPTION", "(", "prev_tree", ")", ";", "cur_opt", "=", "TREE_TARGET_OPTION", "(", "cur_tree", ")", ";", "prev_isa", "=", "prev_opt", "->", "x_ix86_isa_flags", ";", "cur_isa", "=", "cur_opt", "->", "x_ix86_isa_flags", ";", "diff_isa", "=", "(", "prev_isa", "^", "cur_isa", ")", ";", "prev_isa2", "=", "prev_opt", "->", "x_ix86_isa_flags2", ";", "cur_isa2", "=", "cur_opt", "->", "x_ix86_isa_flags2", ";", "diff_isa2", "=", "(", "prev_isa2", "^", "cur_isa2", ")", ";", "prev_arch", "=", "(", "enum", "processor_type", ")", "prev_opt", "->", "arch", ";", "prev_tune", "=", "(", "enum", "processor_type", ")", "prev_opt", "->", "tune", ";", "cur_arch", "=", "(", "enum", "processor_type", ")", "cur_opt", "->", "arch", ";", "cur_tune", "=", "(", "enum", "processor_type", ")", "cur_opt", "->", "tune", ";", "if", "(", "cur_arch", "==", "prev_arch", ")", "cur_arch", "=", "prev_arch", "=", "PROCESSOR_max", ";", "if", "(", "cur_tune", "==", "prev_tune", ")", "cur_tune", "=", "prev_tune", "=", "PROCESSOR_max", ";", "ix86_target_macros_internal", "(", "prev_isa", "&", "diff_isa", ",", "prev_isa2", "&", "diff_isa2", ",", "prev_arch", ",", "prev_tune", ",", "(", "enum", "fpmath_unit", ")", "prev_opt", "->", "x_ix86_fpmath", ",", "cpp_undef", ")", ";", "cpp_options", "*", "cpp_opts", "=", "cpp_get_options", "(", "parse_in", ")", ";", "unsigned", "char", "saved_warn_unused_macros", "=", "cpp_opts", "->", "warn_unused_macros", ";", "cpp_opts", "->", "warn_unused_macros", "=", "0", ";", "ix86_target_macros_internal", "(", "cur_isa", "&", "diff_isa", ",", "cur_isa2", "&", "diff_isa2", ",", "cur_arch", ",", "cur_tune", ",", "(", "enum", "fpmath_unit", ")", "cur_opt", "->", "x_ix86_fpmath", ",", "cpp_define", ")", ";", "cpp_opts", "->", "warn_unused_macros", "=", "saved_warn_unused_macros", ";", "return", "true", ";", "}", "</s>" ]

[ "Hook", "to", "validate", "the", "current", "#", "pragma", "GCC", "target", "and", "set", "the", "state", ",", "and", "update", "the", "macros", "based", "on", "what", "was", "changed", ".", "If", "ARGS", "is", "NULL", ",", "then", "POP_TARGET", "is", "used", "to", "reset", "the", "options", "." ]

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

[]

[ "<s>", "static", "bool", "call_ABI_of_interest", "(", "tree", "fndecl", ")", "{", "if", "(", "rs6000_gnu_attr", "&&", "symtab", "->", "state", "==", "EXPANSION", ")", "{", "struct", "cgraph_node", "*", "c_node", ";", "if", "(", "fndecl", "==", "NULL_TREE", ")", "return", "true", ";", "if", "(", "DECL_EXTERNAL", "(", "fndecl", ")", ")", "return", "true", ";", "c_node", "=", "cgraph_node", "::", "get", "(", "fndecl", ")", ";", "c_node", "=", "c_node", "->", "ultimate_alias_target", "(", ")", ";", "return", "!", "c_node", "->", "only_called_directly_p", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "a", "call", "to", "function", "FNDECL", "may", "be", "one", "that", "potentially", "affects", "the", "function", "calling", "ABI", "of", "the", "object", "file", "." ]

[ "rs6000" ]

[]

[ "<s>", "bool", "RISCVPassConfig", "::", "addPreISel", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createHardwareLoopsPass", "(", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "if", "(", "Expr", "==", "0", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "else", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "CE", "->", "getValue", "(", ")", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "Expr", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "new", "MCExpr", "operand", "." ]

[ "OR1K", "0", "0" ]

[]

[ "<s>", "bool", "SIAnnotateControlFlow", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "DT", "=", "&", "getAnalysis", "<", "DominatorTreeWrapperPass", ">", "(", ")", ".", "getDomTree", "(", ")", ";", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "DA", "=", "&", "getAnalysis", "<", "LegacyDivergenceAnalysis", ">", "(", ")", ";", "TargetPassConfig", "&", "TPC", "=", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "const", "TargetMachine", "&", "TM", "=", "TPC", ".", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "initialize", "(", "*", "F", ".", "getParent", "(", ")", ",", "TM", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", "F", ")", ")", ";", "for", "(", "df_iterator", "<", "BasicBlock", "*", ">", "I", "=", "df_begin", "(", "&", "F", ".", "getEntryBlock", "(", ")", ")", ",", "E", "=", "df_end", "(", "&", "F", ".", "getEntryBlock", "(", ")", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "BasicBlock", "*", "BB", "=", "*", "I", ";", "BranchInst", "*", "Term", "=", "dyn_cast", "<", "BranchInst", ">", "(", "BB", "->", "getTerminator", "(", ")", ")", ";", "if", "(", "!", "Term", "||", "Term", "->", "isUnconditional", "(", ")", ")", "{", "if", "(", "isTopOfStack", "(", "BB", ")", ")", "closeControlFlow", "(", "BB", ")", ";", "continue", ";", "}", "if", "(", "I", ".", "nodeVisited", "(", "Term", "->", "getSuccessor", "(", "1", ")", ")", ")", "{", "if", "(", "isTopOfStack", "(", "BB", ")", ")", "closeControlFlow", "(", "BB", ")", ";", "if", "(", "DT", "->", "dominates", "(", "Term", "->", "getSuccessor", "(", "1", ")", ",", "BB", ")", ")", "handleLoop", "(", "Term", ")", ";", "continue", ";", "}", "if", "(", "isTopOfStack", "(", "BB", ")", ")", "{", "PHINode", "*", "Phi", "=", "dyn_cast", "<", "PHINode", ">", "(", "Term", "->", "getCondition", "(", ")", ")", ";", "if", "(", "Phi", "&&", "Phi", "->", "getParent", "(", ")", "==", "BB", "&&", "isElse", "(", "Phi", ")", "&&", "!", "hasKill", "(", "BB", ")", ")", "{", "insertElse", "(", "Term", ")", ";", "eraseIfUnused", "(", "Phi", ")", ";", "continue", ";", "}", "closeControlFlow", "(", "BB", ")", ";", "}", "openIf", "(", "Term", ")", ";", "}", "if", "(", "!", "Stack", ".", "empty", "(", ")", ")", "{", "report_fatal_error", "(", "\"failed to annotate CFG\"", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "1", "1", "\"failed to annotate CFG\"" ]

[]

[ "<s>", "rtx", "spu_float_const", "(", "const", "char", "*", "string", ",", "machine_mode", "mode", ")", "{", "REAL_VALUE_TYPE", "value", ";", "value", "=", "REAL_VALUE_ATOF", "(", "string", ",", "mode", ")", ";", "return", "CONST_DOUBLE_FROM_REAL_VALUE", "(", "value", ",", "mode", ")", ";", "}", "</s>" ]

[ "Create", "a", "CONST_DOUBLE", "from", "a", "string", "." ]

[ "spu" ]

[]

[ "<s>", "int", "legitimate_pic_operand_p", "(", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "SYMBOL_REF", ":", "return", "0", ";", "case", "LABEL_REF", ":", "return", "0", ";", "case", "CONST", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "(", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "LABEL_REF", ")", "&&", "(", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", "==", "CONST_INT", ")", ")", "return", "0", ";", "break", ";", "case", "MEM", ":", "return", "legitimate_pic_operand_p", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "default", ":", "break", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "legitimate", "general", "operand", "when", "generating", "PIC", "code", ".", "It", "is", "given", "that", "flag_pic", "is", "on", "and", "that", "OP", "satisfies", "CONSTANT_P", "or", "is", "a", "CONST_DOUBLE", "." ]

[ "cr16", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "1" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "functionArgumentNeedsConsecutiveRegisters", "(", "Type", "*", "Ty", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ")", "const", "{", "if", "(", "getEffectiveCallingConv", "(", "CallConv", ",", "isVarArg", ")", "!=", "CallingConv", "::", "ARM_AAPCS_VFP", ")", "return", "false", ";", "HABaseType", "Base", "=", "HA_UNKNOWN", ";", "uint64_t", "Members", "=", "0", ";", "bool", "IsHA", "=", "isHomogeneousAggregate", "(", "Ty", ",", "Base", ",", "Members", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"isHA: \"", "<<", "IsHA", "<<", "\" \"", ";", "Ty", "->", "dump", "(", ")", ")", ";", "bool", "IsIntArray", "=", "Ty", "->", "isArrayTy", "(", ")", "&&", "Ty", "->", "getArrayElementType", "(", ")", "->", "isIntegerTy", "(", ")", ";", "return", "IsHA", "||", "IsIntArray", ";", "}", "</s>" ]

[ "Returns", "true", "if", "an", "argument", "of", "type", "Ty", "needs", "to", "be", "passed", "in", "a", "contiguous", "block", "of", "registers", "in", "calling", "convention", "CallConv", "." ]

[ "ARM", "ARM", "ARM", "0", "\"isHA: \"", "\" \"" ]

[]

[ "<s>", "unsigned", "HexagonTTIImpl", "::", "getIntrinsicInstrCost", "(", "Intrinsic", "::", "ID", "ID", ",", "Type", "*", "RetTy", ",", "ArrayRef", "<", "Type", "*", ">", "Tys", ",", "FastMathFlags", "FMF", ",", "unsigned", "ScalarizationCostPassed", ")", "{", "if", "(", "ID", "==", "Intrinsic", "::", "bswap", ")", "{", "std", "::", "pair", "<", "int", ",", "MVT", ">", "LT", "=", "TLI", ".", "getTypeLegalizationCost", "(", "DL", ",", "RetTy", ")", ";", "return", "LT", ".", "first", "+", "2", ";", "}", "return", "BaseT", "::", "getIntrinsicInstrCost", "(", "ID", ",", "RetTy", ",", "Tys", ",", "FMF", ",", "ScalarizationCostPassed", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Intrinsic::ID", "Intrinsic::bswap", "2" ]

[]

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

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

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

[]

[ "<s>", "bool", "PPCLinuxAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "const", "DataLayout", "*", "TD", "=", "TM", ".", "getDataLayout", "(", ")", ";", "bool", "isPPC64", "=", "TD", "->", "getPointerSizeInBits", "(", ")", "==", "64", ";", "PPCTargetStreamer", "&", "TS", "=", "static_cast", "<", "PPCTargetStreamer", "&", ">", "(", "OutStreamer", ".", "getTargetStreamer", "(", ")", ")", ";", "if", "(", "isPPC64", "&&", "!", "TOC", ".", "empty", "(", ")", ")", "{", "const", "MCSectionELF", "*", "Section", "=", "OutStreamer", ".", "getContext", "(", ")", ".", "getELFSection", "(", "\".toc\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getReadOnly", "(", ")", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "Section", ")", ";", "for", "(", "MapVector", "<", "MCSymbol", "*", ",", "MCSymbol", "*", ">", "::", "iterator", "I", "=", "TOC", ".", "begin", "(", ")", ",", "E", "=", "TOC", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "OutStreamer", ".", "EmitLabel", "(", "I", "->", "second", ")", ";", "MCSymbol", "*", "S", "=", "OutContext", ".", "GetOrCreateSymbol", "(", "I", "->", "first", "->", "getName", "(", ")", ")", ";", "TS", ".", "emitTCEntry", "(", "*", "S", ")", ";", "}", "}", "MachineModuleInfoELF", "&", "MMIELF", "=", "MMI", "->", "getObjFileInfo", "<", "MachineModuleInfoELF", ">", "(", ")", ";", "MachineModuleInfoELF", "::", "SymbolListTy", "Stubs", "=", "MMIELF", ".", "GetGVStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "{", "OutStreamer", ".", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getDataSection", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Stubs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "OutStreamer", ".", "EmitLabel", "(", "Stubs", "[", "i", "]", ".", "first", ")", ";", "OutStreamer", ".", "EmitValue", "(", "MCSymbolRefExpr", "::", "Create", "(", "Stubs", "[", "i", "]", ".", "second", ".", "getPointer", "(", ")", ",", "OutContext", ")", ",", "isPPC64", "?", "8", ":", "4", ")", ";", "}", "Stubs", ".", "clear", "(", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "64", "PPC", "PPC", "PPC", "\".toc\"", "0", "PPC", "8", "4" ]

[]

[ "<s>", "static", "int", "mep_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "rtx", "link", ",", "rtx_insn", "*", "dep_insn", ",", "int", "cost", ")", "{", "int", "cost_specified", ";", "if", "(", "REG_NOTE_KIND", "(", "link", ")", "!=", "0", ")", "{", "if", "(", "REG_NOTE_KIND", "(", "link", ")", "==", "REG_DEP_OUTPUT", "&&", "global_reg_mentioned_p", "(", "PATTERN", "(", "insn", ")", ")", "&&", "global_reg_mentioned_p", "(", "PATTERN", "(", "dep_insn", ")", ")", ")", "return", "1", ";", "return", "0", ";", "}", "if", "(", "recog_memoized", "(", "dep_insn", ")", "<", "0", ")", "return", "cost", ";", "if", "(", "!", "TARGET_H1", ")", "{", "cost_specified", "=", "get_attr_latency", "(", "dep_insn", ")", ";", "if", "(", "cost_specified", "!=", "0", ")", "return", "cost_specified", ";", "}", "return", "cost", ";", "}", "</s>" ]

[ "Scheduling", "hooks", "for", "VLIW", "mode", ".", "Conceptually", "this", "is", "very", "simple", ":", "we", "have", "a", "two-pack", "architecture", "that", "takes", "one", "core", "insn", "and", "one", "coprocessor", "insn", "to", "make", "up", "either", "a", "32-", "or", "64-bit", "instruction", "word", "(", "depending", "on", "the", "option", "bit", "set", "in", "the", "chip", ")", ".", "I.e", ".", "in", "VL32", "mode", ",", "we", "can", "pack", "one", "16-bit", "core", "insn", "and", "one", "16-bit", "cop", "insn", ";", "in", "VL64", "mode", "we", "can", "pack", "one", "16-bit", "core", "insn", "and", "one", "48-bit", "cop", "insn", "or", "two", "32-bit", "core/cop", "insns", ".", "In", "practice", ",", "instruction", "selection", "will", "be", "a", "bear", ".", "Consider", "in", "VL64", "mode", "the", "following", "insns", "add", "$", "1", ",", "1", "cmov", "$", "cr0", ",", "$", "0", "these", "can", "not", "pack", ",", "since", "the", "add", "is", "a", "16-bit", "core", "insn", "and", "cmov", "is", "a", "32-bit", "cop", "insn", ".", "However", ",", "add3", "$", "1", ",", "$", "1", ",", "1", "cmov", "$", "cr0", ",", "$", "0", "packs", "just", "fine", ".", "For", "good", "VLIW", "code", "generation", "in", "VL64", "mode", ",", "we", "will", "have", "to", "have", "32-bit", "alternatives", "for", "many", "of", "the", "common", "core", "insns", ".", "Not", "implemented", "." ]

[ "mep", "0", "1", "0", "0", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 Lower Tile Copy\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 Lower Tile Copy\"" ]

[]

[ "<s>", "scalar_chain", "::", "~", "scalar_chain", "(", ")", "{", "BITMAP_FREE", "(", "insns", ")", ";", "BITMAP_FREE", "(", "defs", ")", ";", "BITMAP_FREE", "(", "defs_conv", ")", ";", "BITMAP_FREE", "(", "insns_conv", ")", ";", "bitmap_obstack_release", "(", "NULL", ")", ";", "}", "</s>" ]

[ "Free", "chain", "'s", "data", "." ]

[ "i386" ]

[]

[ "<s>", "rtx", "tilepro_eh_return_handler_rtx", "(", "void", ")", "{", "rtx", "tmp", "=", "gen_frame_mem", "(", "Pmode", ",", "hard_frame_pointer_rtx", ")", ";", "MEM_VOLATILE_P", "(", "tmp", ")", "=", "true", ";", "return", "tmp", ";", "}", "</s>" ]

[ "Implement", "EH_RETURN_HANDLER_RTX", "." ]

[ "tilepro" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "X86InstrInfo", "::", "getSerializableDirectMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "X86II", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "TargetFlags", "[", "]", "=", "{", "{", "MO_GOT_ABSOLUTE_ADDRESS", ",", "\"x86-got-absolute-address\"", "}", ",", "{", "MO_PIC_BASE_OFFSET", ",", "\"x86-pic-base-offset\"", "}", ",", "{", "MO_GOT", ",", "\"x86-got\"", "}", ",", "{", "MO_GOTOFF", ",", "\"x86-gotoff\"", "}", ",", "{", "MO_GOTPCREL", ",", "\"x86-gotpcrel\"", "}", ",", "{", "MO_PLT", ",", "\"x86-plt\"", "}", ",", "{", "MO_TLSGD", ",", "\"x86-tlsgd\"", "}", ",", "{", "MO_TLSLD", ",", "\"x86-tlsld\"", "}", ",", "{", "MO_TLSLDM", ",", "\"x86-tlsldm\"", "}", ",", "{", "MO_GOTTPOFF", ",", "\"x86-gottpoff\"", "}", ",", "{", "MO_INDNTPOFF", ",", "\"x86-indntpoff\"", "}", ",", "{", "MO_TPOFF", ",", "\"x86-tpoff\"", "}", ",", "{", "MO_DTPOFF", ",", "\"x86-dtpoff\"", "}", ",", "{", "MO_NTPOFF", ",", "\"x86-ntpoff\"", "}", ",", "{", "MO_GOTNTPOFF", ",", "\"x86-gotntpoff\"", "}", ",", "{", "MO_DLLIMPORT", ",", "\"x86-dllimport\"", "}", ",", "{", "MO_DARWIN_NONLAZY", ",", "\"x86-darwin-nonlazy\"", "}", ",", "{", "MO_DARWIN_NONLAZY_PIC_BASE", ",", "\"x86-darwin-nonlazy-pic-base\"", "}", ",", "{", "MO_TLVP", ",", "\"x86-tlvp\"", "}", ",", "{", "MO_TLVP_PIC_BASE", ",", "\"x86-tlvp-pic-base\"", "}", ",", "{", "MO_SECREL", ",", "\"x86-secrel\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetFlags", ")", ";", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "direct", "target", "flag", "values", "and", "their", "names", "." ]

[ "X86", "X86", "X86", "\"x86-got-absolute-address\"", "\"x86-pic-base-offset\"", "\"x86-got\"", "\"x86-gotoff\"", "\"x86-gotpcrel\"", "\"x86-plt\"", "\"x86-tlsgd\"", "\"x86-tlsld\"", "\"x86-tlsldm\"", "\"x86-gottpoff\"", "\"x86-indntpoff\"", "\"x86-tpoff\"", "\"x86-dtpoff\"", "\"x86-ntpoff\"", "\"x86-gotntpoff\"", "\"x86-dllimport\"", "\"x86-darwin-nonlazy\"", "\"x86-darwin-nonlazy-pic-base\"", "\"x86-tlvp\"", "\"x86-tlvp-pic-base\"", "\"x86-secrel\"" ]

[]

[ "<s>", "int", "pa_attr_length_call", "(", "rtx_insn", "*", "insn", ",", "int", "sibcall", ")", "{", "int", "local_call", ";", "rtx", "call", ",", "call_dest", ";", "tree", "call_decl", ";", "int", "length", "=", "0", ";", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "unsigned", "long", "distance", "=", "-", "1", ";", "gcc_assert", "(", "CALL_P", "(", "insn", ")", ")", ";", "if", "(", "INSN_ADDRESSES_SET_P", "(", ")", ")", "{", "unsigned", "long", "total", ";", "total", "=", "IN_NAMED_SECTION_P", "(", "cfun", "->", "decl", ")", "?", "0", ":", "total_code_bytes", ";", "distance", "=", "(", "total", "+", "insn_current_reference_address", "(", "insn", ")", ")", ";", "if", "(", "distance", "<", "total", ")", "distance", "=", "-", "1", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", ";", "call", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "call", ")", "==", "SET", ")", "call", "=", "SET_SRC", "(", "call", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "call", ")", "==", "CALL", ")", ";", "call_dest", "=", "XEXP", "(", "XEXP", "(", "call", ",", "0", ")", ",", "0", ")", ";", "call_decl", "=", "SYMBOL_REF_DECL", "(", "call_dest", ")", ";", "local_call", "=", "call_decl", "&&", "targetm", ".", "binds_local_p", "(", "call_decl", ")", ";", "if", "(", "!", "TARGET_LONG_CALLS", "&&", "(", "(", "TARGET_PA_20", "&&", "!", "sibcall", "&&", "distance", "<", "7600000", ")", "||", "distance", "<", "MAX_PCREL17F_OFFSET", ")", ")", "length", "+=", "8", ";", "else", "if", "(", "TARGET_64BIT", "&&", "!", "local_call", ")", "length", "+=", "24", ";", "else", "if", "(", "(", "TARGET_LONG_ABS_CALL", "||", "local_call", ")", "&&", "!", "flag_pic", ")", "length", "+=", "12", ";", "else", "if", "(", "TARGET_LONG_PIC_SDIFF_CALL", "||", "(", "TARGET_GAS", "&&", "!", "TARGET_SOM", "&&", "local_call", ")", ")", "{", "length", "+=", "20", ";", "if", "(", "!", "TARGET_PA_20", "&&", "!", "TARGET_NO_SPACE_REGS", "&&", "(", "!", "local_call", "||", "flag_pic", ")", ")", "length", "+=", "8", ";", "}", "else", "{", "length", "+=", "32", ";", "if", "(", "TARGET_SOM", ")", "length", "+=", "length_fp_args", "(", "insn", ")", ";", "if", "(", "flag_pic", ")", "length", "+=", "4", ";", "if", "(", "!", "TARGET_PA_20", ")", "{", "if", "(", "!", "sibcall", ")", "length", "+=", "8", ";", "if", "(", "!", "TARGET_NO_SPACE_REGS", "&&", "(", "!", "local_call", "||", "flag_pic", ")", ")", "length", "+=", "8", ";", "}", "}", "return", "length", ";", "}", "</s>" ]

[ "Return", "the", "attribute", "length", "of", "the", "call", "instruction", "INSN", ".", "The", "SIBCALL", "flag", "indicates", "whether", "INSN", "is", "a", "regular", "call", "or", "a", "sibling", "call", ".", "The", "length", "returned", "must", "be", "longer", "than", "the", "code", "actually", "generated", "by", "pa_output_call", ".", "Since", "branch", "shortening", "is", "done", "before", "delay", "branch", "sequencing", ",", "there", "is", "no", "way", "to", "determine", "whether", "or", "not", "the", "delay", "slot", "will", "be", "filled", "during", "branch", "shortening", ".", "Even", "when", "the", "delay", "slot", "is", "filled", ",", "we", "may", "have", "to", "add", "a", "nop", "if", "the", "delay", "slot", "contains", "a", "branch", "that", "ca", "n't", "reach", "its", "target", ".", "Thus", ",", "we", "always", "have", "to", "include", "the", "delay", "slot", "in", "the", "length", "estimate", ".", "This", "used", "to", "be", "done", "in", "pa_adjust_insn_length", "but", "we", "do", "it", "here", "now", "as", "some", "sequences", "always", "fill", "the", "delay", "slot", "and", "we", "can", "save", "four", "bytes", "in", "the", "estimate", "for", "these", "sequences", "." ]

[ "pa", "0", "1", "0", "1", "0", "0", "0", "0", "7600000", "8", "24", "12", "20", "8", "32", "4", "8", "8" ]

[]

[ "<s>", "bool", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "const", "{", "return", "LowerMMIXMachineOperandToMCOperand", "(", "MO", ",", "MCOp", ",", "*", "this", ")", ";", "}", "</s>" ]

[ "Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "." ]

[ "MMIX", "MMIX" ]

[]

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

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "AMDGPUPromoteAlloca", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "if", "(", "auto", "*", "TPC", "=", "getAnalysisIfAvailable", "<", "TargetPassConfig", ">", "(", ")", ")", "TM", "=", "&", "TPC", "->", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "else", "return", "false", ";", "const", "Triple", "&", "TT", "=", "TM", "->", "getTargetTriple", "(", ")", ";", "IsAMDGCN", "=", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ";", "IsAMDHSA", "=", "TT", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", ";", "const", "AMDGPUSubtarget", "&", "ST", "=", "AMDGPUSubtarget", "::", "get", "(", "*", "TM", ",", "F", ")", ";", "if", "(", "!", "ST", ".", "isPromoteAllocaEnabled", "(", ")", ")", "return", "false", ";", "AS", "=", "AMDGPU", "::", "getAMDGPUAS", "(", "*", "F", ".", "getParent", "(", ")", ")", ";", "bool", "SufficientLDS", "=", "hasSufficientLocalMem", "(", "F", ")", ";", "bool", "Changed", "=", "false", ";", "BasicBlock", "&", "EntryBB", "=", "*", "F", ".", "begin", "(", ")", ";", "for", "(", "auto", "I", "=", "EntryBB", ".", "begin", "(", ")", ",", "E", "=", "EntryBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "AllocaInst", "*", "AI", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "I", ")", ";", "++", "I", ";", "if", "(", "AI", ")", "Changed", "|=", "handleAlloca", "(", "*", "AI", ",", "SufficientLDS", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU::getAMDGPUAS" ]

[]

[ "<s>", "bool", "VEAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "VE", "VE" ]

[]

[ "<s>", "bool", "mips_store_data_bypass_p", "(", "rtx_insn", "*", "out_insn", ",", "rtx_insn", "*", "in_insn", ")", "{", "if", "(", "GET_CODE", "(", "PATTERN", "(", "in_insn", ")", ")", "==", "UNSPEC_VOLATILE", ")", "return", "false", ";", "return", "store_data_bypass_p", "(", "out_insn", ",", "in_insn", ")", ";", "}", "</s>" ]

[ "True", "if", "the", "dependency", "between", "OUT_INSN", "and", "IN_INSN", "is", "on", "the", "store", "data", "rather", "than", "the", "address", ".", "We", "need", "this", "because", "the", "cprestore", "pattern", "is", "type", "``", "store", "''", ",", "but", "is", "defined", "using", "an", "UNSPEC_VOLATILE", ",", "which", "causes", "the", "default", "routine", "to", "abort", ".", "We", "just", "return", "false", "for", "that", "case", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "SIDebuggerInsertNops", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "debuggerInsertNops", "(", ")", ")", "return", "false", ";", "if", "(", "!", "MF", ".", "getMMI", "(", ")", ".", "hasDebugInfo", "(", ")", ")", "return", "false", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "DenseSet", "<", "unsigned", ">", "NopInserted", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "MI", "=", "MBB", ".", "begin", "(", ")", ";", "MI", "!=", "MBB", ".", "end", "(", ")", ";", "++", "MI", ")", "{", "if", "(", "MI", "->", "isDebugValue", "(", ")", "||", "!", "MI", "->", "getDebugLoc", "(", ")", ")", "continue", ";", "auto", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "NopInserted", ".", "find", "(", "DL", ".", "getLine", "(", ")", ")", "==", "NopInserted", ".", "end", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "*", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_NOP", ")", ")", ".", "addImm", "(", "0", ")", ";", "NopInserted", ".", "insert", "(", "DL", ".", "getLine", "(", ")", ")", ";", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "SI", "AMDGPU::S_NOP", "0" ]

[]

[ "<s>", "void", "ARM64InstrInfo", "::", "suppressLdStPair", "(", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "MI", "->", "memoperands_empty", "(", ")", ")", "return", ";", "assert", "(", "MOSuppressPair", "<", "(", "1", "<<", "MachineMemOperand", "::", "MOTargetNumBits", ")", "&&", "\"Too many target MO flags\"", ")", ";", "(", "*", "MI", "->", "memoperands_begin", "(", ")", ")", "->", "setFlags", "(", "MOSuppressPair", "<<", "MachineMemOperand", "::", "MOTargetStartBit", ")", ";", "}", "</s>" ]

[ "Hint", "that", "pairing", "the", "given", "load", "or", "store", "is", "unprofitable", "." ]

[ "ARM64", "ARM64", "1", "\"Too many target MO flags\"" ]

[]

[ "<s>", "static", "rtx", "xtensa_builtin_saveregs", "(", "void", ")", "{", "rtx", "gp_regs", ",", "dest", ";", "int", "arg_words", "=", "current_function_args_info", ".", "arg_words", ";", "int", "gp_left", "=", "MAX_ARGS_IN_REGISTERS", "-", "arg_words", ";", "if", "(", "gp_left", "<=", "0", ")", "return", "const0_rtx", ";", "gp_regs", "=", "assign_stack_local", "(", "BLKmode", ",", "MAX_ARGS_IN_REGISTERS", "*", "UNITS_PER_WORD", ",", "-", "1", ")", ";", "set_mem_alias_set", "(", "gp_regs", ",", "get_varargs_alias_set", "(", ")", ")", ";", "dest", "=", "change_address", "(", "gp_regs", ",", "SImode", ",", "plus_constant", "(", "XEXP", "(", "gp_regs", ",", "0", ")", ",", "arg_words", "*", "UNITS_PER_WORD", ")", ")", ";", "cfun", "->", "machine", "->", "need_a7_copy", "=", "true", ";", "cfun", "->", "machine", "->", "vararg_a7", "=", "true", ";", "move_block_from_reg", "(", "GP_ARG_FIRST", "+", "arg_words", ",", "dest", ",", "gp_left", ")", ";", "return", "XEXP", "(", "gp_regs", ",", "0", ")", ";", "}", "</s>" ]

[ "Save", "the", "incoming", "argument", "registers", "on", "the", "stack", ".", "Returns", "the", "address", "of", "the", "saved", "registers", "." ]

[ "xtensa", "0", "1", "0", "0" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "findCommutedOpIndices", "(", "MachineInstr", "*", "MI", ",", "unsigned", "&", "SrcOpIdx1", ",", "unsigned", "&", "SrcOpIdx2", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "X86", "::", "BLENDPDrri", ":", "case", "X86", "::", "BLENDPSrri", ":", "case", "X86", "::", "PBLENDWrri", ":", "case", "X86", "::", "VBLENDPDrri", ":", "case", "X86", "::", "VBLENDPSrri", ":", "case", "X86", "::", "VBLENDPDYrri", ":", "case", "X86", "::", "VBLENDPSYrri", ":", "case", "X86", "::", "VPBLENDDrri", ":", "case", "X86", "::", "VPBLENDDYrri", ":", "case", "X86", "::", "VPBLENDWrri", ":", "case", "X86", "::", "VPBLENDWYrri", ":", "SrcOpIdx1", "=", "1", ";", "SrcOpIdx2", "=", "2", ";", "return", "true", ";", "case", "X86", "::", "VFMADDPDr231r", ":", "case", "X86", "::", "VFMADDPSr231r", ":", "case", "X86", "::", "VFMADDSDr231r", ":", "case", "X86", "::", "VFMADDSSr231r", ":", "case", "X86", "::", "VFMSUBPDr231r", ":", "case", "X86", "::", "VFMSUBPSr231r", ":", "case", "X86", "::", "VFMSUBSDr231r", ":", "case", "X86", "::", "VFMSUBSSr231r", ":", "case", "X86", "::", "VFNMADDPDr231r", ":", "case", "X86", "::", "VFNMADDPSr231r", ":", "case", "X86", "::", "VFNMADDSDr231r", ":", "case", "X86", "::", "VFNMADDSSr231r", ":", "case", "X86", "::", "VFNMSUBPDr231r", ":", "case", "X86", "::", "VFNMSUBPSr231r", ":", "case", "X86", "::", "VFNMSUBSDr231r", ":", "case", "X86", "::", "VFNMSUBSSr231r", ":", "case", "X86", "::", "VFMADDPDr231rY", ":", "case", "X86", "::", "VFMADDPSr231rY", ":", "case", "X86", "::", "VFMSUBPDr231rY", ":", "case", "X86", "::", "VFMSUBPSr231rY", ":", "case", "X86", "::", "VFNMADDPDr231rY", ":", "case", "X86", "::", "VFNMADDPSr231rY", ":", "case", "X86", "::", "VFNMSUBPDr231rY", ":", "case", "X86", "::", "VFNMSUBPSr231rY", ":", "SrcOpIdx1", "=", "2", ";", "SrcOpIdx2", "=", "3", ";", "return", "true", ";", "default", ":", "return", "TargetInstrInfo", "::", "findCommutedOpIndices", "(", "MI", ",", "SrcOpIdx1", ",", "SrcOpIdx2", ")", ";", "}", "}", "</s>" ]

[ "Returns", "true", "iff", "the", "routine", "could", "find", "two", "commutable", "operands", "in", "the", "given", "machine", "instruction", "." ]

[ "X86", "X86", "X86::BLENDPDrri", "X86::BLENDPSrri", "X86::PBLENDWrri", "X86::VBLENDPDrri", "X86::VBLENDPSrri", "X86::VBLENDPDYrri", "X86::VBLENDPSYrri", "X86::VPBLENDDrri", "X86::VPBLENDDYrri", "X86::VPBLENDWrri", "X86::VPBLENDWYrri", "1", "2", "X86::VFMADDPDr231r", "X86::VFMADDPSr231r", "X86::VFMADDSDr231r", "X86::VFMADDSSr231r", "X86::VFMSUBPDr231r", "X86::VFMSUBPSr231r", "X86::VFMSUBSDr231r", "X86::VFMSUBSSr231r", "X86::VFNMADDPDr231r", "X86::VFNMADDPSr231r", "X86::VFNMADDSDr231r", "X86::VFNMADDSSr231r", "X86::VFNMSUBPDr231r", "X86::VFNMSUBPSr231r", "X86::VFNMSUBSDr231r", "X86::VFNMSUBSSr231r", "X86::VFMADDPDr231rY", "X86::VFMADDPSr231rY", "X86::VFMSUBPDr231rY", "X86::VFMSUBPSr231rY", "X86::VFNMADDPDr231rY", "X86::VFNMADDPSr231rY", "X86::VFNMSUBPDr231rY", "X86::VFNMSUBPSr231rY", "2", "3" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "IsEligibleForTailCallOptimization", "(", "SDValue", "Callee", ",", "CallingConv", "::", "ID", "CalleeCC", ",", "bool", "IsVarArg", ",", "bool", "IsCalleeStructRet", ",", "bool", "IsCallerStructRet", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "Function", "&", "CallerF", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ";", "CallingConv", "::", "ID", "CallerCC", "=", "CallerF", ".", "getCallingConv", "(", ")", ";", "bool", "CCMatch", "=", "CallerCC", "==", "CalleeCC", ";", "if", "(", "!", "isa", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", "&&", "!", "isa", "<", "ExternalSymbolSDNode", ">", "(", "Callee", ")", ")", "{", "return", "false", ";", "}", "if", "(", "!", "CCMatch", ")", "{", "bool", "R", "=", "(", "CallerCC", "==", "CallingConv", "::", "C", "||", "CallerCC", "==", "CallingConv", "::", "Fast", ")", ";", "bool", "E", "=", "(", "CalleeCC", "==", "CallingConv", "::", "C", "||", "CalleeCC", "==", "CallingConv", "::", "Fast", ")", ";", "if", "(", "!", "R", "||", "!", "E", ")", "return", "false", ";", "}", "if", "(", "IsVarArg", ")", "return", "false", ";", "if", "(", "IsCalleeStructRet", "||", "IsCallerStructRet", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "IsEligibleForTailCallOptimization", "-", "Check", "whether", "the", "call", "is", "eligible", "for", "tail", "call", "optimization", "." ]

[ "Hexagon", "Hexagon", "ISD::OutputArg", "ISD::InputArg" ]

[]

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

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

[ "rs6000", "12" ]

[]

[ "<s>", "int", "X86FrameLowering", "::", "mergeSPUpdates", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "bool", "doMergeWithPrevious", ")", "const", "{", "if", "(", "(", "doMergeWithPrevious", "&&", "MBBI", "==", "MBB", ".", "begin", "(", ")", ")", "||", "(", "!", "doMergeWithPrevious", "&&", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", ")", "return", "0", ";", "MachineBasicBlock", "::", "iterator", "PI", "=", "doMergeWithPrevious", "?", "std", "::", "prev", "(", "MBBI", ")", ":", "MBBI", ";", "PI", "=", "skipDebugInstructionsBackward", "(", "PI", ",", "MBB", ".", "begin", "(", ")", ")", ";", "if", "(", "doMergeWithPrevious", "&&", "PI", "!=", "MBB", ".", "begin", "(", ")", "&&", "PI", "->", "isCFIInstruction", "(", ")", ")", "PI", "=", "std", "::", "prev", "(", "PI", ")", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "int", "Offset", "=", "0", ";", "if", "(", "(", "Opc", "==", "X86", "::", "ADD64ri32", "||", "Opc", "==", "X86", "::", "ADD64ri8", "||", "Opc", "==", "X86", "::", "ADD32ri", "||", "Opc", "==", "X86", "::", "ADD32ri8", ")", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", "{", "assert", "(", "PI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", ";", "Offset", "=", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "}", "else", "if", "(", "(", "Opc", "==", "X86", "::", "LEA32r", "||", "Opc", "==", "X86", "::", "LEA64_32r", ")", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", "&&", "PI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "StackPtr", "&&", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "1", "&&", "PI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", "==", "X86", "::", "NoRegister", "&&", "PI", "->", "getOperand", "(", "5", ")", ".", "getReg", "(", ")", "==", "X86", "::", "NoRegister", ")", "{", "Offset", "=", "PI", "->", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", ";", "}", "else", "if", "(", "(", "Opc", "==", "X86", "::", "SUB64ri32", "||", "Opc", "==", "X86", "::", "SUB64ri8", "||", "Opc", "==", "X86", "::", "SUB32ri", "||", "Opc", "==", "X86", "::", "SUB32ri8", ")", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", "{", "assert", "(", "PI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", ";", "Offset", "=", "-", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "}", "else", "return", "0", ";", "PI", "=", "MBB", ".", "erase", "(", "PI", ")", ";", "if", "(", "PI", "!=", "MBB", ".", "end", "(", ")", "&&", "PI", "->", "isCFIInstruction", "(", ")", ")", "{", "auto", "CIs", "=", "MBB", ".", "getParent", "(", ")", "->", "getFrameInstructions", "(", ")", ";", "MCCFIInstruction", "CI", "=", "CIs", "[", "PI", "->", "getOperand", "(", "0", ")", ".", "getCFIIndex", "(", ")", "]", ";", "if", "(", "CI", ".", "getOperation", "(", ")", "==", "MCCFIInstruction", "::", "OpDefCfaOffset", "||", "CI", ".", "getOperation", "(", ")", "==", "MCCFIInstruction", "::", "OpAdjustCfaOffset", ")", "PI", "=", "MBB", ".", "erase", "(", "PI", ")", ";", "}", "if", "(", "!", "doMergeWithPrevious", ")", "MBBI", "=", "skipDebugInstructionsForward", "(", "PI", ",", "MBB", ".", "end", "(", ")", ")", ";", "return", "Offset", ";", "}", "</s>" ]

[ "Check", "the", "instruction", "before/after", "the", "passed", "instruction", "." ]

[ "X86", "X86", "0", "0", "X86::ADD64ri32", "X86::ADD64ri8", "X86::ADD32ri", "X86::ADD32ri8", "0", "1", "2", "X86::LEA32r", "X86::LEA64_32r", "0", "1", "2", "1", "3", "X86::NoRegister", "5", "X86::NoRegister", "4", "X86::SUB64ri32", "X86::SUB64ri8", "X86::SUB32ri", "X86::SUB32ri8", "0", "1", "2", "0", "0" ]

[]

[ "<s>", "static", "void", "mips_emit_probe_stack_range", "(", "HOST_WIDE_INT", "first", ",", "HOST_WIDE_INT", "size", ")", "{", "if", "(", "TARGET_MIPS16", ")", "sorry", "(", "\"-fstack-check=specific not implemented for MIPS16\"", ")", ";", "if", "(", "first", "+", "size", "<=", "32768", ")", "{", "HOST_WIDE_INT", "i", ";", "for", "(", "i", "=", "PROBE_INTERVAL", ";", "i", "<", "size", ";", "i", "+=", "PROBE_INTERVAL", ")", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "first", "+", "i", ")", ")", ")", ";", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "first", "+", "size", ")", ")", ")", ";", "}", "else", "{", "HOST_WIDE_INT", "rounded_size", ";", "rtx", "r3", "=", "MIPS_PROLOGUE_TEMP", "(", "Pmode", ")", ";", "rtx", "r12", "=", "MIPS_PROLOGUE_TEMP2", "(", "Pmode", ")", ";", "gcc_assert", "(", "first", "<=", "32768", ")", ";", "rounded_size", "=", "ROUND_DOWN", "(", "size", ",", "PROBE_INTERVAL", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "r3", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "first", ")", ")", ")", ";", "if", "(", "rounded_size", ">", "32768", ")", "{", "emit_move_insn", "(", "r12", ",", "GEN_INT", "(", "rounded_size", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "r12", ",", "gen_rtx_MINUS", "(", "Pmode", ",", "r3", ",", "r12", ")", ")", ")", ";", "}", "else", "emit_insn", "(", "gen_rtx_SET", "(", "r12", ",", "plus_constant", "(", "Pmode", ",", "r3", ",", "-", "rounded_size", ")", ")", ")", ";", "emit_insn", "(", "PMODE_INSN", "(", "gen_probe_stack_range", ",", "(", "r3", ",", "r3", ",", "r12", ")", ")", ")", ";", "if", "(", "size", "!=", "rounded_size", ")", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "r12", ",", "rounded_size", "-", "size", ")", ")", ";", "}", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "probe", "a", "range", "of", "stack", "addresses", "from", "FIRST", "to", "FIRST+SIZE", ",", "inclusive", ".", "These", "are", "offsets", "from", "the", "current", "stack", "pointer", "." ]

[ "mips", "\"-fstack-check=specific not implemented for MIPS16\"", "32768", "32768", "32768" ]

[]

[ "<s>", "void", "WebAssemblyInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", ")", "{", "printInstruction", "(", "MI", ",", "OS", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MII", ".", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "Desc", ".", "isVariadic", "(", ")", ")", "for", "(", "auto", "i", "=", "Desc", ".", "getNumOperands", "(", ")", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "if", "(", "i", "!=", "0", ")", "OS", "<<", "\", \"", ";", "printOperand", "(", "MI", ",", "i", ",", "OS", ")", ";", "}", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "if", "(", "CommentStream", ")", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "WebAssembly", "::", "LOOP", ":", "{", "uint64_t", "TopLabel", "=", "ControlFlowCounter", "++", ";", "ControlFlowStack", ".", "push_back", "(", "std", "::", "make_pair", "(", "ControlFlowCounter", "++", ",", "false", ")", ")", ";", "printAnnotation", "(", "OS", ",", "\"label\"", "+", "utostr", "(", "TopLabel", ")", "+", "':'", ")", ";", "ControlFlowStack", ".", "push_back", "(", "std", "::", "make_pair", "(", "TopLabel", ",", "true", ")", ")", ";", "break", ";", "}", "case", "WebAssembly", "::", "BLOCK", ":", "ControlFlowStack", ".", "push_back", "(", "std", "::", "make_pair", "(", "ControlFlowCounter", "++", ",", "false", ")", ")", ";", "break", ";", "case", "WebAssembly", "::", "END_LOOP", ":", "ControlFlowStack", ".", "pop_back", "(", ")", ";", "printAnnotation", "(", "OS", ",", "\"label\"", "+", "utostr", "(", "ControlFlowStack", ".", "pop_back_val", "(", ")", ".", "first", ")", "+", "':'", ")", ";", "break", ";", "case", "WebAssembly", "::", "END_BLOCK", ":", "printAnnotation", "(", "OS", ",", "\"label\"", "+", "utostr", "(", "ControlFlowStack", ".", "pop_back_val", "(", ")", ".", "first", ")", "+", "':'", ")", ";", "break", ";", "}", "unsigned", "NumFixedOperands", "=", "Desc", ".", "NumOperands", ";", "SmallSet", "<", "uint64_t", ",", "8", ">", "Printed", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "const", "MCOperandInfo", "&", "Info", "=", "Desc", ".", "OpInfo", "[", "i", "]", ";", "if", "(", "!", "(", "i", "<", "NumFixedOperands", "?", "(", "Info", ".", "OperandType", "==", "WebAssembly", "::", "OPERAND_BASIC_BLOCK", ")", ":", "(", "Desc", ".", "TSFlags", "&", "WebAssemblyII", "::", "VariableOpImmediateIsLabel", ")", ")", ")", "continue", ";", "uint64_t", "Depth", "=", "MI", "->", "getOperand", "(", "i", ")", ".", "getImm", "(", ")", ";", "if", "(", "!", "Printed", ".", "insert", "(", "Depth", ")", ".", "second", ")", "continue", ";", "const", "auto", "&", "Pair", "=", "ControlFlowStack", ".", "rbegin", "(", ")", "[", "Depth", "]", ";", "printAnnotation", "(", "OS", ",", "utostr", "(", "Depth", ")", "+", "\": \"", "+", "(", "Pair", ".", "second", "?", "\"up\"", ":", "\"down\"", ")", "+", "\" to label\"", "+", "utostr", "(", "Pair", ".", "first", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "0", "\", \"", "WebAssembly::LOOP", "\"label\"", "WebAssembly::BLOCK", "WebAssembly::END_LOOP", "\"label\"", "WebAssembly::END_BLOCK", "\"label\"", "8", "0", "WebAssembly::OPERAND_BASIC_BLOCK", "WebAssemblyII::VariableOpImmediateIsLabel", "\": \"", "\"up\"", "\"down\"", "\" to label\"" ]

[]

[ "<s>", "void", "emitSparcRegisterScratch", "(", "unsigned", "reg", ")", "override", "{", "}", "</s>" ]

[ "Emit", "``", ".register", "<", "reg", ">", ",", "#", "scratch", "''", "." ]

[ "Sparc", "Sparc" ]

[]

[ "<s>", "const", "char", "*", "nds32_output_32bit_load_s", "(", "rtx", "*", "operands", ",", "int", "byte", ")", "{", "char", "pattern", "[", "100", "]", ";", "unsigned", "char", "size", ";", "rtx", "code", ";", "code", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ";", "size", "=", "nds32_byte_to_size", "(", "byte", ")", ";", "switch", "(", "GET_CODE", "(", "code", ")", ")", "{", "case", "REG", ":", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "\"l%csi\\t%%0, %%1\"", ",", "size", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "case", "CONST", ":", "operands", "[", "1", "]", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ";", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "\"l%csi.gp\\t%%0, [ + %%1]\"", ",", "size", ")", ";", "break", ";", "case", "POST_INC", ":", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "\"l%csi.bi\\t%%0, %%1, %d\"", ",", "size", ",", "byte", ")", ";", "break", ";", "case", "POST_DEC", ":", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "\"l%csi.bi\\t%%0, %%1, -%d\"", ",", "size", ",", "byte", ")", ";", "break", ";", "case", "POST_MODIFY", ":", "switch", "(", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "code", ",", "1", ")", ",", "1", ")", ")", ")", "{", "case", "REG", ":", "case", "SUBREG", ":", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "\"l%cs.bi\\t%%0, %%1\"", ",", "size", ")", ";", "break", ";", "case", "CONST_INT", ":", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "\"l%csi.bi\\t%%0, %%1\"", ",", "size", ")", ";", "break", ";", "default", ":", "abort", "(", ")", ";", "}", "break", ";", "case", "PLUS", ":", "switch", "(", "GET_CODE", "(", "XEXP", "(", "code", ",", "1", ")", ")", ")", "{", "case", "REG", ":", "case", "SUBREG", ":", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "\"l%cs\\t%%0, %%1\"", ",", "size", ")", ";", "break", ";", "case", "CONST_INT", ":", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "\"l%csi\\t%%0, %%1\"", ",", "size", ")", ";", "break", ";", "default", ":", "abort", "(", ")", ";", "}", "break", ";", "case", "LO_SUM", ":", "operands", "[", "2", "]", "=", "XEXP", "(", "code", ",", "1", ")", ";", "operands", "[", "1", "]", "=", "XEXP", "(", "code", ",", "0", ")", ";", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "\"l%csi\\t%%0, [%%1 + lo12(%%2)]\"", ",", "size", ")", ";", "break", ";", "default", ":", "abort", "(", ")", ";", "}", "output_asm_insn", "(", "pattern", ",", "operands", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "32-bit", "load", "with", "signed", "extension", "." ]

[ "nds32", "100", "1", "0", "\"l%csi\\t%%0, %%1\"", "1", "1", "0", "\"l%csi.gp\\t%%0, [ + %%1]\"", "\"l%csi.bi\\t%%0, %%1, %d\"", "\"l%csi.bi\\t%%0, %%1, -%d\"", "1", "1", "\"l%cs.bi\\t%%0, %%1\"", "\"l%csi.bi\\t%%0, %%1\"", "1", "\"l%cs\\t%%0, %%1\"", "\"l%csi\\t%%0, %%1\"", "2", "1", "1", "0", "\"l%csi\\t%%0, [%%1 + lo12(%%2)]\"", "\"\"" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "*", "MI", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "MOV8rm", ":", "case", "X86", "::", "MOV16rm", ":", "case", "X86", "::", "MOV32rm", ":", "case", "X86", "::", "MOV64rm", ":", "case", "X86", "::", "LD_Fp64m", ":", "case", "X86", "::", "MOVSSrm", ":", "case", "X86", "::", "MOVSDrm", ":", "case", "X86", "::", "MOVAPSrm", ":", "case", "X86", "::", "MOVUPSrm", ":", "case", "X86", "::", "MOVAPDrm", ":", "case", "X86", "::", "MOVDQArm", ":", "case", "X86", "::", "MOVDQUrm", ":", "case", "X86", "::", "VMOVSSrm", ":", "case", "X86", "::", "VMOVSDrm", ":", "case", "X86", "::", "VMOVAPSrm", ":", "case", "X86", "::", "VMOVUPSrm", ":", "case", "X86", "::", "VMOVAPDrm", ":", "case", "X86", "::", "VMOVDQArm", ":", "case", "X86", "::", "VMOVDQUrm", ":", "case", "X86", "::", "VMOVAPSYrm", ":", "case", "X86", "::", "VMOVUPSYrm", ":", "case", "X86", "::", "VMOVAPDYrm", ":", "case", "X86", "::", "VMOVDQAYrm", ":", "case", "X86", "::", "VMOVDQUYrm", ":", "case", "X86", "::", "MMX_MOVD64rm", ":", "case", "X86", "::", "MMX_MOVQ64rm", ":", "case", "X86", "::", "FsVMOVAPSrm", ":", "case", "X86", "::", "FsVMOVAPDrm", ":", "case", "X86", "::", "FsMOVAPSrm", ":", "case", "X86", "::", "FsMOVAPDrm", ":", "{", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", "==", "0", "&&", "MI", "->", "isInvariantLoad", "(", "AA", ")", ")", "{", "unsigned", "BaseReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "BaseReg", "==", "0", "||", "BaseReg", "==", "X86", "::", "RIP", ")", "return", "true", ";", "if", "(", "!", "ReMatPICStubLoad", "&&", "MI", "->", "getOperand", "(", "4", ")", ".", "isGlobal", "(", ")", ")", "return", "false", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "return", "regIsPICBase", "(", "BaseReg", ",", "MRI", ")", ";", "}", "return", "false", ";", "}", "case", "X86", "::", "LEA32r", ":", "case", "X86", "::", "LEA64r", ":", "{", "if", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", "==", "0", "&&", "!", "MI", "->", "getOperand", "(", "4", ")", ".", "isReg", "(", ")", ")", "{", "if", "(", "!", "MI", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", ")", "return", "true", ";", "unsigned", "BaseReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "BaseReg", "==", "0", ")", "return", "true", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "return", "regIsPICBase", "(", "BaseReg", ",", "MRI", ")", ";", "}", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "For", "instructions", "with", "opcodes", "for", "which", "the", "M_REMATERIALIZABLE", "flag", "is", "set", ",", "this", "hook", "lets", "the", "target", "specify", "whether", "the", "instruction", "is", "actually", "trivially", "rematerializable", ",", "taking", "into", "consideration", "its", "operands", "." ]

[ "X86", "X86", "X86::MOV8rm", "X86::MOV16rm", "X86::MOV32rm", "X86::MOV64rm", "X86::LD_Fp64m", "X86::MOVSSrm", "X86::MOVSDrm", "X86::MOVAPSrm", "X86::MOVUPSrm", "X86::MOVAPDrm", "X86::MOVDQArm", "X86::MOVDQUrm", "X86::VMOVSSrm", "X86::VMOVSDrm", "X86::VMOVAPSrm", "X86::VMOVUPSrm", "X86::VMOVAPDrm", "X86::VMOVDQArm", "X86::VMOVDQUrm", "X86::VMOVAPSYrm", "X86::VMOVUPSYrm", "X86::VMOVAPDYrm", "X86::VMOVDQAYrm", "X86::VMOVDQUYrm", "X86::MMX_MOVD64rm", "X86::MMX_MOVQ64rm", "X86::FsVMOVAPSrm", "X86::FsVMOVAPDrm", "X86::FsMOVAPSrm", "X86::FsMOVAPDrm", "1", "2", "3", "3", "0", "1", "0", "X86::RIP", "4", "X86::LEA32r", "X86::LEA64r", "2", "3", "3", "0", "4", "1", "1", "0" ]

[]

[ "<s>", "rtx", "resolve_reload_operand", "(", "rtx", "op", ")", "{", "if", "(", "reload_in_progress", ")", "{", "rtx", "tmp", "=", "op", ";", "if", "(", "GET_CODE", "(", "tmp", ")", "==", "SUBREG", ")", "tmp", "=", "SUBREG_REG", "(", "tmp", ")", ";", "if", "(", "GET_CODE", "(", "tmp", ")", "==", "REG", "&&", "REGNO", "(", "tmp", ")", ">=", "FIRST_PSEUDO_REGISTER", ")", "{", "op", "=", "reg_equiv_memory_loc", "[", "REGNO", "(", "tmp", ")", "]", ";", "if", "(", "op", "==", "0", ")", "return", "0", ";", "}", "}", "return", "op", ";", "}", "</s>" ]

[ "Used", "by", "aligned_memory_operand", "and", "unaligned_memory_operand", "to", "resolve", "what", "reload", "is", "going", "to", "do", "with", "OP", "if", "it", "'s", "a", "register", "." ]

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

[]

[ "<s>", "HOST_WIDE_INT", "alpha_initial_elimination_offset", "(", "unsigned", "int", "from", ",", "unsigned", "int", "to", "ATTRIBUTE_UNUSED", ")", "{", "HOST_WIDE_INT", "ret", ";", "ret", "=", "cfun", "->", "machine", "->", "sa_size", ";", "ret", "+=", "ALPHA_ROUND", "(", "crtl", "->", "outgoing_args_size", ")", ";", "switch", "(", "from", ")", "{", "case", "FRAME_POINTER_REGNUM", ":", "break", ";", "case", "ARG_POINTER_REGNUM", ":", "ret", "+=", "(", "ALPHA_ROUND", "(", "get_frame_size", "(", ")", "+", "crtl", "->", "args", ".", "pretend_args_size", ")", "-", "crtl", "->", "args", ".", "pretend_args_size", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "Define", "the", "offset", "between", "two", "registers", ",", "one", "to", "be", "eliminated", ",", "and", "the", "other", "its", "replacement", ",", "at", "the", "start", "of", "a", "routine", "." ]

[ "alpha" ]

[]

[ "<s>", "rtx", "thumb_legitimize_address", "(", "rtx", "x", ",", "rtx", "orig_x", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "arm_tls_symbol_p", "(", "x", ")", ")", "return", "legitimize_tls_address", "(", "x", ",", "NULL_RTX", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">=", "32", "*", "GET_MODE_SIZE", "(", "mode", ")", "||", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "<", "0", ")", ")", "{", "rtx", "xop0", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "xop1", "=", "XEXP", "(", "x", ",", "1", ")", ";", "HOST_WIDE_INT", "offset", "=", "INTVAL", "(", "xop1", ")", ";", "if", "(", "optimize_size", "&&", "offset", ">=", "0", "&&", "offset", "<", "256", "+", "31", "*", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "HOST_WIDE_INT", "delta", ";", "if", "(", "offset", ">=", "256", ")", "delta", "=", "offset", "-", "(", "256", "-", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "else", "if", "(", "offset", "<", "32", "*", "GET_MODE_SIZE", "(", "mode", ")", "+", "8", ")", "delta", "=", "31", "*", "GET_MODE_SIZE", "(", "mode", ")", ";", "else", "delta", "=", "offset", "&", "(", "~", "31", "*", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "xop0", "=", "force_operand", "(", "plus_constant", "(", "xop0", ",", "offset", "-", "delta", ")", ",", "NULL_RTX", ")", ";", "x", "=", "plus_constant", "(", "xop0", ",", "delta", ")", ";", "}", "else", "if", "(", "offset", "<", "0", "&&", "offset", ">", "-", "256", ")", "x", "=", "force_operand", "(", "x", ",", "NULL_RTX", ")", ";", "else", "{", "xop1", "=", "force_reg", "(", "SImode", ",", "xop1", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "SImode", ",", "xop0", ",", "xop1", ")", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "s_register_operand", "(", "XEXP", "(", "x", ",", "1", ")", ",", "SImode", ")", "&&", "!", "s_register_operand", "(", "XEXP", "(", "x", ",", "0", ")", ",", "SImode", ")", ")", "{", "rtx", "xop0", "=", "force_operand", "(", "XEXP", "(", "x", ",", "0", ")", ",", "NULL_RTX", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "SImode", ",", "xop0", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "}", "if", "(", "flag_pic", ")", "{", "rtx", "new_x", "=", "legitimize_pic_address", "(", "orig_x", ",", "mode", ",", "NULL_RTX", ")", ";", "if", "(", "new_x", "!=", "orig_x", ")", "x", "=", "new_x", ";", "}", "return", "x", ";", "}", "</s>" ]

[ "Try", "machine-dependent", "ways", "of", "modifying", "an", "illegitimate", "Thumb", "address", "to", "be", "legitimate", ".", "If", "we", "find", "one", ",", "return", "the", "new", ",", "valid", "address", "." ]

[ "arm", "1", "1", "32", "1", "0", "0", "1", "0", "256", "31", "256", "256", "32", "8", "31", "31", "0", "256", "1", "0", "0", "1" ]

[]

[ "<s>", "static", "bool", "cbranch_predicted_p", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "x", "=", "find_reg_note", "(", "insn", ",", "REG_BR_PROB", ",", "0", ")", ";", "if", "(", "x", ")", "{", "int", "pred_val", "=", "XINT", "(", "x", ",", "0", ")", ";", "return", "pred_val", ">=", "REG_BR_PROB_BASE", "/", "2", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "INSN", "is", "annotated", "with", "a", "REG_BR_PROB", "note", "that", "indicates", "it", "'s", "a", "branch", "that", "'s", "predicted", "taken", "." ]

[ "tilegx", "0", "0", "2" ]

[]

[ "<s>", "static", "void", "vms_asm_out_constructor", "(", "rtx", "symbol", ",", "int", "priority", "ATTRIBUTE_UNUSED", ")", "{", "ctors_section", "(", ")", ";", "assemble_align", "(", "BITS_PER_WORD", ")", ";", "assemble_integer", "(", "symbol", ",", "UNITS_PER_WORD", ",", "BITS_PER_WORD", ",", "1", ")", ";", "}", "</s>" ]

[ "Record", "an", "element", "in", "the", "table", "of", "global", "constructors", ".", "SYMBOL", "is", "a", "SYMBOL_REF", "of", "the", "function", "to", "be", "called", ";", "PRIORITY", "is", "a", "number", "between", "0", "and", "MAX_INIT_PRIORITY", ".", "Differs", "from", "default_ctors_section_asm_out_constructor", "in", "that", "the", "width", "of", "the", ".ctors", "entry", "is", "always", "64", "bits", ",", "rather", "than", "the", "32", "bits", "used", "by", "a", "normal", "pointer", "." ]

[ "alpha", "1" ]

[]

[ "<s>", "bool", "AArch64AsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "if", "(", "!", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNum", ",", "ExtraCode", ",", "O", ")", ")", "return", "false", ";", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'w'", ":", "case", "'x'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "printAsmMRegister", "(", "MO", ",", "ExtraCode", "[", "0", "]", ",", "O", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", "&&", "MO", ".", "getImm", "(", ")", "==", "0", ")", "{", "unsigned", "Reg", "=", "ExtraCode", "[", "0", "]", "==", "'w'", "?", "AArch64", "::", "WZR", ":", "AArch64", "::", "XZR", ";", "O", "<<", "AArch64InstPrinter", "::", "getRegisterName", "(", "Reg", ")", ";", "return", "false", ";", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "case", "'b'", ":", "case", "'h'", ":", "case", "'s'", ":", "case", "'d'", ":", "case", "'q'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "const", "TargetRegisterClass", "*", "RC", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "case", "'b'", ":", "RC", "=", "&", "AArch64", "::", "FPR8RegClass", ";", "break", ";", "case", "'h'", ":", "RC", "=", "&", "AArch64", "::", "FPR16RegClass", ";", "break", ";", "case", "'s'", ":", "RC", "=", "&", "AArch64", "::", "FPR32RegClass", ";", "break", ";", "case", "'d'", ":", "RC", "=", "&", "AArch64", "::", "FPR64RegClass", ";", "break", ";", "case", "'q'", ":", "RC", "=", "&", "AArch64", "::", "FPR128RegClass", ";", "break", ";", "default", ":", "return", "true", ";", "}", "return", "printAsmRegInClass", "(", "MO", ",", "RC", ",", "false", ",", "O", ")", ";", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "}", "}", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "Register", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "AArch64", "::", "GPR32allRegClass", ".", "contains", "(", "Reg", ")", "||", "AArch64", "::", "GPR64allRegClass", ".", "contains", "(", "Reg", ")", ")", "return", "printAsmMRegister", "(", "MO", ",", "'x'", ",", "O", ")", ";", "return", "printAsmRegInClass", "(", "MO", ",", "&", "AArch64", "::", "FPR128RegClass", ",", "true", ",", "O", ")", ";", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "0", "1", "0", "0", "0", "0", "0", "AArch64::WZR", "AArch64::XZR", "AArch64", "0", "AArch64::FPR8RegClass", "AArch64::FPR16RegClass", "AArch64::FPR32RegClass", "AArch64::FPR64RegClass", "AArch64::FPR128RegClass", "AArch64::GPR32allRegClass", "AArch64::GPR64allRegClass", "AArch64::FPR128RegClass" ]

[]

[ "<s>", "bool", "WebAssemblyFrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "!", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "getNegatedExpression", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ",", "bool", "LegalOperations", ",", "bool", "ForCodeSize", ",", "NegatibleCost", "&", "Cost", ",", "unsigned", "Depth", ")", "const", "{", "if", "(", "SDValue", "Arg", "=", "isFNEG", "(", "DAG", ",", "Op", ".", "getNode", "(", ")", ",", "Depth", ")", ")", "{", "Cost", "=", "NegatibleCost", "::", "Cheaper", ";", "return", "DAG", ".", "getBitcast", "(", "Op", ".", "getValueType", "(", ")", ",", "Arg", ")", ";", "}", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "EVT", "SVT", "=", "VT", ".", "getScalarType", "(", ")", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "ISD", "::", "FMA", ":", "case", "X86ISD", "::", "FMSUB", ":", "case", "X86ISD", "::", "FNMADD", ":", "case", "X86ISD", "::", "FNMSUB", ":", "case", "X86ISD", "::", "FMADD_RND", ":", "case", "X86ISD", "::", "FMSUB_RND", ":", "case", "X86ISD", "::", "FNMADD_RND", ":", "case", "X86ISD", "::", "FNMSUB_RND", ":", "{", "if", "(", "!", "Op", ".", "hasOneUse", "(", ")", "||", "!", "Subtarget", ".", "hasAnyFMA", "(", ")", "||", "!", "isTypeLegal", "(", "VT", ")", "||", "!", "(", "SVT", "==", "MVT", "::", "f32", "||", "SVT", "==", "MVT", "::", "f64", ")", "||", "!", "isOperationLegal", "(", "ISD", "::", "FMA", ",", "VT", ")", ")", "break", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "NewOps", "(", "Op", ".", "getNumOperands", "(", ")", ",", "SDValue", "(", ")", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "!=", "3", ";", "++", "i", ")", "NewOps", "[", "i", "]", "=", "getCheaperNegatedExpression", "(", "Op", ".", "getOperand", "(", "i", ")", ",", "DAG", ",", "LegalOperations", ",", "ForCodeSize", ",", "Depth", "+", "1", ")", ";", "bool", "NegA", "=", "!", "!", "NewOps", "[", "0", "]", ";", "bool", "NegB", "=", "!", "!", "NewOps", "[", "1", "]", ";", "bool", "NegC", "=", "!", "!", "NewOps", "[", "2", "]", ";", "unsigned", "NewOpc", "=", "negateFMAOpcode", "(", "Opc", ",", "NegA", "!=", "NegB", ",", "NegC", ",", "true", ")", ";", "Cost", "=", "(", "NegA", "||", "NegB", "||", "NegC", ")", "?", "NegatibleCost", "::", "Cheaper", ":", "NegatibleCost", "::", "Neutral", ";", "for", "(", "int", "i", "=", "0", ",", "e", "=", "Op", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "if", "(", "!", "NewOps", "[", "i", "]", ")", "NewOps", "[", "i", "]", "=", "Op", ".", "getOperand", "(", "i", ")", ";", "return", "DAG", ".", "getNode", "(", "NewOpc", ",", "SDLoc", "(", "Op", ")", ",", "VT", ",", "NewOps", ")", ";", "}", "case", "X86ISD", "::", "FRCP", ":", "if", "(", "SDValue", "NegOp0", "=", "getNegatedExpression", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "DAG", ",", "LegalOperations", ",", "ForCodeSize", ",", "Cost", ",", "Depth", "+", "1", ")", ")", "return", "DAG", ".", "getNode", "(", "Opc", ",", "SDLoc", "(", "Op", ")", ",", "VT", ",", "NegOp0", ")", ";", "break", ";", "}", "return", "TargetLowering", "::", "getNegatedExpression", "(", "Op", ",", "DAG", ",", "LegalOperations", ",", "ForCodeSize", ",", "Cost", ",", "Depth", ")", ";", "}", "</s>" ]

[ "Return", "the", "newly", "negated", "expression", "if", "the", "cost", "is", "not", "expensive", "and", "set", "the", "cost", "in", "Cost", "to", "indicate", "that", "if", "it", "is", "cheaper", "or", "neutral", "to", "do", "the", "negation", "." ]

[ "X86", "X86", "ISD::FMA", "X86ISD::FMSUB", "X86ISD::FNMADD", "X86ISD::FNMSUB", "X86ISD::FMADD_RND", "X86ISD::FMSUB_RND", "X86ISD::FNMADD_RND", "X86ISD::FNMSUB_RND", "MVT::f32", "MVT::f64", "ISD::FMA", "4", "0", "3", "1", "0", "1", "2", "0", "X86ISD::FRCP", "0", "1" ]

[]

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

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

[ "X86" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "ClobbersPredicate", "(", "MachineInstr", "&", "MI", ",", "std", "::", "vector", "<", "MachineOperand", ">", "&", "Pred", ",", "bool", "SkipDead", ")", "const", "{", "const", "TargetRegisterClass", "*", "RCs", "[", "]", "=", "{", "&", "PPC", "::", "CRRCRegClass", ",", "&", "PPC", "::", "CRBITRCRegClass", ",", "&", "PPC", "::", "CTRRCRegClass", ",", "&", "PPC", "::", "CTRRC8RegClass", "}", ";", "bool", "Found", "=", "false", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "{", "for", "(", "unsigned", "c", "=", "0", ";", "c", "<", "array_lengthof", "(", "RCs", ")", "&&", "!", "Found", ";", "++", "c", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "RCs", "[", "c", "]", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "if", "(", "MO", ".", "isDef", "(", ")", "&&", "RC", "->", "contains", "(", "MO", ".", "getReg", "(", ")", ")", ")", "{", "Pred", ".", "push_back", "(", "MO", ")", ";", "Found", "=", "true", ";", "}", "}", "else", "if", "(", "MO", ".", "isRegMask", "(", ")", ")", "{", "for", "(", "TargetRegisterClass", "::", "iterator", "I", "=", "RC", "->", "begin", "(", ")", ",", "IE", "=", "RC", "->", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "if", "(", "MO", ".", "clobbersPhysReg", "(", "*", "I", ")", ")", "{", "Pred", ".", "push_back", "(", "MO", ")", ";", "Found", "=", "true", ";", "}", "}", "}", "}", "return", "Found", ";", "}", "</s>" ]

[ "If", "the", "specified", "instruction", "defines", "any", "predicate", "or", "condition", "code", "register", "(", "s", ")", "used", "for", "predication", ",", "returns", "true", "as", "well", "as", "the", "definition", "predicate", "(", "s", ")", "by", "reference", "." ]

[ "PowerPC", "PPC", "PPC::CRRCRegClass", "PPC::CRBITRCRegClass", "PPC::CTRRCRegClass", "PPC::CTRRC8RegClass", "0" ]

[]

[ "<s>", "bool", "VideocorePassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createVideocoreISelDag", "(", "getVideocoreTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Videocore", "Videocore", "Videocore", "Videocore" ]

[]

[ "<s>", "SDValue", "LanaiTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "MUL", ":", "return", "LowerMUL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "LowerSHL_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "return", "LowerSRL_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unimplemented operand\"", ")", ";", "}", "}", "</s>" ]

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

[ "Lanai", "Lanai", "ISD::MUL", "ISD::BR_CC", "ISD::ConstantPool", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::JumpTable", "ISD::SELECT_CC", "ISD::SETCC", "ISD::SHL_PARTS", "ISD::SRL_PARTS", "ISD::VASTART", "ISD::DYNAMIC_STACKALLOC", "ISD::RETURNADDR", "ISD::FRAMEADDR", "\"unimplemented operand\"" ]

[]