Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "OperandMatchResultTy", "tryParseRegister", "(", "unsigned", "&", ",", "SMLoc", "&", ",", "SMLoc", "&", ")", "override", "{", "llvm_unreachable", "(", "\"tryParseRegister is not implemented.\"", ")", ";", "}", "</s>" ]

[ "tryParseRegister", "-", "parse", "one", "register", "if", "possible" ]

[ "WebAssembly", "\"tryParseRegister is not implemented.\"" ]

[]

[ "<s>", "unsigned", "VEInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "!", "isUncondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "&&", "!", "isCondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "break", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

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

[ "VE", "VE", "\"code size not handled\"", "0" ]

[]

[ "<s>", "bool", "shouldConvertConstantLoadToIntImm", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "it", "is", "beneficial", "to", "convert", "a", "load", "of", "a", "constant", "to", "just", "the", "constant", "itself", "." ]

[ "MMIX" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "shouldExpandAtomicCmpXchgInIR", "(", "AtomicCmpXchgInst", "*", "AI", ")", "const", "{", "return", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", "!=", "0", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "tryAddingPcLoadReferenceComment", "(", "uint64_t", "Address", ",", "int", "Value", ",", "const", "void", "*", "Decoder", ")", "{", "const", "MCDisassembler", "*", "Dis", "=", "static_cast", "<", "const", "MCDisassembler", "*", ">", "(", "Decoder", ")", ";", "Dis", "->", "tryAddingPcLoadReferenceComment", "(", "Value", ",", "Address", ")", ";", "}", "</s>" ]

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

[ "ARM" ]

[]

[ "<s>", "MCRegister", "SIRegisterInfo", "::", "reservedPrivateSegmentBufferReg", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "unsigned", "BaseIdx", "=", "alignDown", "(", "ST", ".", "getMaxNumSGPRs", "(", "MF", ")", ",", "4", ")", "-", "4", ";", "MCRegister", "BaseReg", "(", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "BaseIdx", ")", ")", ";", "return", "getMatchingSuperReg", "(", "BaseReg", ",", "AMDGPU", "::", "sub0", ",", "&", "AMDGPU", "::", "SGPR_128RegClass", ")", ";", "}", "</s>" ]

[ "Return", "the", "end", "register", "initially", "reserved", "for", "the", "scratch", "buffer", "in", "case", "spilling", "is", "needed", "." ]

[ "AMDGPU", "SI", "4", "4", "AMDGPU::SGPR_32RegClass", "AMDGPU::sub0", "AMDGPU::SGPR_128RegClass" ]

[]

[ "<s>", "static", "void", "mmix_option_override", "(", "void", ")", "{", "if", "(", "flag_pic", ")", "{", "warning", "(", "0", ",", "\"-f%s not supported: ignored\"", ",", "(", "flag_pic", ">", "1", ")", "?", "\"PIC\"", ":", "\"pic\"", ")", ";", "flag_pic", "=", "0", ";", "}", "}", "</s>" ]

[ "TARGET_OPTION_OVERRIDE", "." ]

[ "mmix", "0", "\"-f%s not supported: ignored\"", "1", "\"PIC\"", "\"pic\"", "0" ]

[]

[ "<s>", "unsigned", "int", "UPTInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "return", "TargetInstrInfo", "::", "isLoadFromStackSlot", "(", "MI", ",", "FrameIndex", ")", ";", "}", "</s>" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "UPT", "UPT" ]

[]

[ "<s>", "static", "bool", "ix86_legitimate_constant_p", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "if", "(", "POINTER_BOUNDS_MODE_P", "(", "GET_MODE", "(", "x", ")", ")", ")", "return", "false", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST", ":", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "return", "false", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "}", "if", "(", "TARGET_MACHO", "&&", "darwin_local_data_pic", "(", "x", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "UNSPEC_GOT", ":", "case", "UNSPEC_GOTOFF", ":", "case", "UNSPEC_PLTOFF", ":", "return", "TARGET_64BIT", ";", "case", "UNSPEC_TPOFF", ":", "case", "UNSPEC_NTPOFF", ":", "x", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "return", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "==", "TLS_MODEL_LOCAL_EXEC", ")", ";", "case", "UNSPEC_DTPOFF", ":", "x", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "return", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "==", "TLS_MODEL_LOCAL_DYNAMIC", ")", ";", "default", ":", "return", "false", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "SYMBOL_REF", ")", "return", "false", ";", "case", "SYMBOL_REF", ":", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ")", "return", "false", ";", "if", "(", "TARGET_DLLIMPORT_DECL_ATTRIBUTES", "&&", "SYMBOL_REF_DLLIMPORT_P", "(", "x", ")", ")", "return", "false", ";", "if", "(", "MACHO_DYNAMIC_NO_PIC_P", ")", "return", "machopic_symbol_defined_p", "(", "x", ")", ";", "if", "(", "ix86_force_load_from_GOT_p", "(", "x", ")", ")", "return", "false", ";", "break", ";", "CASE_CONST_SCALAR_INT", ":", "switch", "(", "mode", ")", "{", "case", "E_TImode", ":", "if", "(", "TARGET_64BIT", ")", "return", "true", ";", "case", "E_OImode", ":", "case", "E_XImode", ":", "if", "(", "!", "standard_sse_constant_p", "(", "x", ",", "mode", ")", ")", "return", "false", ";", "default", ":", "break", ";", "}", "break", ";", "case", "CONST_VECTOR", ":", "if", "(", "!", "standard_sse_constant_p", "(", "x", ",", "mode", ")", ")", "return", "false", ";", "default", ":", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Determine", "if", "a", "given", "RTX", "is", "a", "valid", "constant", ".", "We", "already", "know", "this", "satisfies", "CONSTANT_P", "." ]

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

[]

[ "<s>", "static", "void", "nds32_emit_stack_v3push", "(", "rtx", "Rb", ",", "rtx", "Re", ",", "rtx", "En4", "ATTRIBUTE_UNUSED", ",", "rtx", "imm8u", ")", "{", "int", "regno", ";", "int", "num_use_regs", ";", "int", "par_index", ";", "int", "offset", ";", "rtx", "reg", ";", "rtx", "mem", ";", "rtx", "push_rtx", ";", "rtx", "adjust_sp_rtx", ";", "rtx", "parallel_insn", ";", "num_use_regs", "=", "REGNO", "(", "Re", ")", "-", "REGNO", "(", "Rb", ")", "+", "1", "+", "3", ";", "parallel_insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "num_use_regs", "+", "1", ")", ")", ";", "par_index", "=", "0", ";", "offset", "=", "-", "(", "num_use_regs", "*", "4", ")", ";", "for", "(", "regno", "=", "REGNO", "(", "Rb", ")", ";", "regno", "<=", "(", "int", ")", "REGNO", "(", "Re", ")", ";", "regno", "++", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "push_rtx", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "XVECEXP", "(", "parallel_insn", ",", "0", ",", "par_index", ")", "=", "push_rtx", ";", "RTX_FRAME_RELATED_P", "(", "push_rtx", ")", "=", "1", ";", "offset", "=", "offset", "+", "4", ";", "par_index", "++", ";", "}", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "FP_REGNUM", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "push_rtx", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "XVECEXP", "(", "parallel_insn", ",", "0", ",", "par_index", ")", "=", "push_rtx", ";", "RTX_FRAME_RELATED_P", "(", "push_rtx", ")", "=", "1", ";", "offset", "=", "offset", "+", "4", ";", "par_index", "++", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "GP_REGNUM", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "push_rtx", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "XVECEXP", "(", "parallel_insn", ",", "0", ",", "par_index", ")", "=", "push_rtx", ";", "RTX_FRAME_RELATED_P", "(", "push_rtx", ")", "=", "1", ";", "offset", "=", "offset", "+", "4", ";", "par_index", "++", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "LP_REGNUM", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "push_rtx", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "XVECEXP", "(", "parallel_insn", ",", "0", ",", "par_index", ")", "=", "push_rtx", ";", "RTX_FRAME_RELATED_P", "(", "push_rtx", ")", "=", "1", ";", "offset", "=", "offset", "+", "4", ";", "par_index", "++", ";", "offset", "=", "-", "(", "num_use_regs", "*", "4", ")", ";", "adjust_sp_rtx", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", "-", "INTVAL", "(", "imm8u", ")", ")", ")", ";", "XVECEXP", "(", "parallel_insn", ",", "0", ",", "par_index", ")", "=", "adjust_sp_rtx", ";", "RTX_FRAME_RELATED_P", "(", "adjust_sp_rtx", ")", "=", "1", ";", "parallel_insn", "=", "emit_insn", "(", "parallel_insn", ")", ";", "RTX_FRAME_RELATED_P", "(", "parallel_insn", ")", "=", "1", ";", "}", "</s>" ]

[ "Function", "to", "create", "a", "parallel", "rtx", "pattern", "which", "presents", "stack", "v3push", "behavior", ".", "The", "overall", "concept", "are", ":", "``", "push", "registers", "to", "memory", "''", ",", "``", "adjust", "stack", "pointer", "''", "." ]

[ "nds32", "1", "3", "1", "0", "4", "0", "1", "4", "0", "1", "4", "0", "1", "4", "0", "1", "4", "4", "0", "1", "1" ]

[]

[ "<s>", "BitVector", "M88kRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "M88k", "::", "R0", ")", ";", "Reserved", ".", "set", "(", "M88k", "::", "R28", ")", ";", "Reserved", ".", "set", "(", "M88k", "::", "R29", ")", ";", "Reserved", ".", "set", "(", "M88k", "::", "R31", ")", ";", "if", "(", "getFrameLowering", "(", "MF", ")", "->", "hasFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "M88k", "::", "R30", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "M88k", "M88k", "M88k::R0", "M88k::R28", "M88k::R29", "M88k::R31", "M88k::R30" ]

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "shouldReduceLoadWidth", "(", "SDNode", "*", "N", ",", "ISD", "::", "LoadExtType", "ExtTy", ",", "EVT", "NewVT", ")", "const", "{", "if", "(", "!", "TargetLoweringBase", "::", "shouldReduceLoadWidth", "(", "N", ",", "ExtTy", ",", "NewVT", ")", ")", "return", "false", ";", "unsigned", "NewSize", "=", "NewVT", ".", "getStoreSizeInBits", "(", ")", ";", "if", "(", "NewSize", ">=", "32", ")", "return", "true", ";", "EVT", "OldVT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "unsigned", "OldSize", "=", "OldVT", ".", "getStoreSizeInBits", "(", ")", ";", "MemSDNode", "*", "MN", "=", "cast", "<", "MemSDNode", ">", "(", "N", ")", ";", "unsigned", "AS", "=", "MN", "->", "getAddressSpace", "(", ")", ";", "if", "(", "OldSize", ">=", "32", "&&", "NewSize", "<", "32", "&&", "MN", "->", "getAlignment", "(", ")", ">=", "4", "&&", "(", "AS", "==", "AMDGPUAS", "::", "CONSTANT_ADDRESS", "||", "AS", "==", "AMDGPUAS", "::", "CONSTANT_ADDRESS_32BIT", "||", "(", "isa", "<", "LoadSDNode", ">", "(", "N", ")", "&&", "AS", "==", "AMDGPUAS", "::", "GLOBAL_ADDRESS", "&&", "MN", "->", "isInvariant", "(", ")", ")", ")", "&&", "AMDGPUInstrInfo", "::", "isUniformMMO", "(", "MN", "->", "getMemOperand", "(", ")", ")", ")", "return", "false", ";", "return", "(", "OldSize", "<", "32", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "believe", "it", "is", "correct", "and", "profitable", "to", "reduce", "the", "load", "node", "to", "a", "smaller", "type", "." ]

[ "AMDGPU", "AMDGPU", "ISD::LoadExtType", "32", "0", "32", "32", "4", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "32" ]

[]

[ "<s>", "static", "void", "rs6000_setup_reg_addr_masks", "(", "void", ")", "{", "ssize_t", "rc", ",", "reg", ",", "m", ",", "nregs", ";", "addr_mask_type", "any_addr_mask", ",", "addr_mask", ";", "for", "(", "m", "=", "0", ";", "m", "<", "NUM_MACHINE_MODES", ";", "++", "m", ")", "{", "machine_mode", "m2", "=", "(", "machine_mode", ")", "m", ";", "bool", "indexed_only_p", "=", "(", "m", "==", "SDmode", "&&", "TARGET_NO_SDMODE_STACK", ")", ";", "any_addr_mask", "=", "0", ";", "for", "(", "rc", "=", "FIRST_RELOAD_REG_CLASS", ";", "rc", "<=", "LAST_RELOAD_REG_CLASS", ";", "rc", "++", ")", "{", "addr_mask", "=", "0", ";", "reg", "=", "reload_reg_map", "[", "rc", "]", ".", "reg", ";", "if", "(", "reg", ">=", "0", "&&", "rs6000_hard_regno_mode_ok_p", "[", "m", "]", "[", "reg", "]", ")", "{", "nregs", "=", "rs6000_hard_regno_nregs", "[", "m", "]", "[", "reg", "]", ";", "addr_mask", "|=", "RELOAD_REG_VALID", ";", "if", "(", "nregs", ">", "1", "||", "m", "==", "BLKmode", ")", "addr_mask", "|=", "RELOAD_REG_MULTIPLE", ";", "else", "addr_mask", "|=", "RELOAD_REG_INDEXED", ";", "if", "(", "TARGET_UPDATE", "&&", "(", "rc", "==", "RELOAD_REG_GPR", "||", "rc", "==", "RELOAD_REG_FPR", ")", "&&", "GET_MODE_SIZE", "(", "m2", ")", "<=", "8", "&&", "!", "VECTOR_MODE_P", "(", "m2", ")", "&&", "!", "COMPLEX_MODE_P", "(", "m2", ")", "&&", "!", "indexed_only_p", "&&", "!", "(", "TARGET_E500_DOUBLE", "&&", "GET_MODE_SIZE", "(", "m2", ")", "==", "8", ")", ")", "{", "addr_mask", "|=", "RELOAD_REG_PRE_INCDEC", ";", "switch", "(", "m", ")", "{", "default", ":", "addr_mask", "|=", "RELOAD_REG_PRE_MODIFY", ";", "break", ";", "case", "DImode", ":", "if", "(", "TARGET_POWERPC64", ")", "addr_mask", "|=", "RELOAD_REG_PRE_MODIFY", ";", "break", ";", "case", "DFmode", ":", "case", "DDmode", ":", "if", "(", "TARGET_DF_INSN", ")", "addr_mask", "|=", "RELOAD_REG_PRE_MODIFY", ";", "break", ";", "}", "}", "}", "if", "(", "(", "addr_mask", "!=", "0", ")", "&&", "!", "indexed_only_p", "&&", "(", "rc", "==", "RELOAD_REG_GPR", "||", "rc", "==", "RELOAD_REG_FPR", ")", ")", "addr_mask", "|=", "RELOAD_REG_OFFSET", ";", "if", "(", "rc", "==", "RELOAD_REG_VMX", "&&", "GET_MODE_SIZE", "(", "m2", ")", "==", "16", "&&", "(", "addr_mask", "&", "RELOAD_REG_VALID", ")", "!=", "0", ")", "addr_mask", "|=", "RELOAD_REG_AND_M16", ";", "reg_addr", "[", "m", "]", ".", "addr_mask", "[", "rc", "]", "=", "addr_mask", ";", "any_addr_mask", "|=", "addr_mask", ";", "}", "reg_addr", "[", "m", "]", ".", "addr_mask", "[", "RELOAD_REG_ANY", "]", "=", "any_addr_mask", ";", "}", "}", "</s>" ]

[ "Update", "the", "addr", "mask", "bits", "in", "reg_addr", "to", "help", "secondary", "reload", "and", "go", "if", "legitimate", "address", "support", "to", "figure", "out", "the", "appropriate", "addressing", "to", "use", "." ]

[ "rs6000", "0", "0", "0", "0", "1", "8", "8", "0", "16", "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>", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "RISCVInstrInfo", "::", "decomposeMachineOperandsTargetFlags", "(", "unsigned", "TF", ")", "const", "{", "const", "unsigned", "Mask", "=", "RISCVII", "::", "MO_DIRECT_FLAG_MASK", ";", "return", "std", "::", "make_pair", "(", "TF", "&", "Mask", ",", "TF", "&", "~", "Mask", ")", ";", "}", "</s>" ]

[ "Decompose", "the", "machine", "operand", "'s", "target", "flags", "into", "two", "values", "-", "the", "direct", "target", "flag", "value", "and", "any", "of", "bit", "flags", "that", "are", "applied", "." ]

[ "RI5CY", "RISCV", "RISCVII::MO_DIRECT_FLAG_MASK" ]

[]

[ "<s>", "static", "void", "arc_setup_incoming_varargs", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", "ATTRIBUTE_UNUSED", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", ")", "{", "int", "first_anon_arg", ";", "gcc_assert", "(", "mode", "!=", "BLKmode", ")", ";", "first_anon_arg", "=", "*", "cum", "+", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", ";", "if", "(", "first_anon_arg", "<", "MAX_ARC_PARM_REGS", "&&", "!", "no_rtl", ")", "{", "int", "first_reg_offset", "=", "first_anon_arg", ";", "int", "size", "=", "MAX_ARC_PARM_REGS", "-", "first_reg_offset", ";", "int", "align_slop", "=", "size", "&", "1", ";", "rtx", "regblock", ";", "regblock", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "arg_pointer_rtx", ",", "FIRST_PARM_OFFSET", "(", "0", ")", "+", "align_slop", "*", "UNITS_PER_WORD", ")", ")", ";", "set_mem_alias_set", "(", "regblock", ",", "get_varargs_alias_set", "(", ")", ")", ";", "set_mem_align", "(", "regblock", ",", "BITS_PER_WORD", ")", ";", "move_block_from_reg", "(", "first_reg_offset", ",", "regblock", ",", "MAX_ARC_PARM_REGS", "-", "first_reg_offset", ")", ";", "*", "pretend_size", "=", "(", "(", "MAX_ARC_PARM_REGS", "-", "first_reg_offset", "+", "align_slop", ")", "*", "UNITS_PER_WORD", ")", ";", "}", "}", "</s>" ]

[ "Do", "any", "needed", "setup", "for", "a", "variadic", "function", ".", "For", "the", "ARC", ",", "we", "must", "create", "a", "register", "parameter", "block", ",", "and", "then", "copy", "any", "anonymous", "arguments", "in", "registers", "to", "memory", ".", "CUM", "has", "not", "been", "updated", "for", "the", "last", "named", "argument", "which", "has", "type", "TYPE", "and", "mode", "MODE", ",", "and", "we", "rely", "on", "this", "fact", "." ]

[ "arc", "1", "1", "0" ]

[]

[ "<s>", "bool", "RISCVAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MCSubtargetInfo", "&", "NewSTI", "=", "OutStreamer", "->", "getContext", "(", ")", ".", "getSubtargetCopy", "(", "*", "TM", ".", "getMCSubtargetInfo", "(", ")", ")", ";", "NewSTI", ".", "setFeatureBits", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getFeatureBits", "(", ")", ")", ";", "MCSTI", "=", "&", "NewSTI", ";", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "emitFunctionBody", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "SparcPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createSparcDelaySlotFillerPass", "(", "getSparcTargetMachine", "(", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "SystemZHazardRecognizer", "::", "EmitInstruction", "(", "SUnit", "*", "SU", ")", "{", "const", "MCSchedClassDesc", "*", "SC", "=", "getSchedClass", "(", "SU", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"++ HazardRecognizer emitting \"", ";", "dumpSU", "(", "SU", ",", "dbgs", "(", ")", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ";", ")", ";", "LLVM_DEBUG", "(", "dumpCurrGroup", "(", "\"Decode group before emission\"", ")", ";", ")", ";", "if", "(", "!", "fitsIntoCurrentGroup", "(", "SU", ")", ")", "nextGroup", "(", ")", ";", "LLVM_DEBUG", "(", "raw_string_ostream", "cgd", "(", "CurGroupDbg", ")", ";", "if", "(", "CurGroupDbg", ".", "length", "(", ")", ")", "cgd", "<<", "\", \"", ";", "dumpSU", "(", "SU", ",", "cgd", ")", ";", ")", ";", "LastEmittedMI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "SU", "->", "isCall", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"++ Clearing state after call.\\n\"", ";", ")", ";", "Reset", "(", ")", ";", "LastEmittedMI", "=", "SU", "->", "getInstr", "(", ")", ";", "return", ";", "}", "for", "(", "TargetSchedModel", "::", "ProcResIter", "PI", "=", "SchedModel", "->", "getWriteProcResBegin", "(", "SC", ")", ",", "PE", "=", "SchedModel", "->", "getWriteProcResEnd", "(", "SC", ")", ";", "PI", "!=", "PE", ";", "++", "PI", ")", "{", "if", "(", "SchedModel", "->", "getProcResource", "(", "PI", "->", "ProcResourceIdx", ")", "->", "BufferSize", "==", "1", ")", "continue", ";", "int", "&", "CurrCounter", "=", "ProcResourceCounters", "[", "PI", "->", "ProcResourceIdx", "]", ";", "CurrCounter", "+=", "PI", "->", "Cycles", ";", "if", "(", "(", "CurrCounter", ">", "ProcResCostLim", ")", "&&", "(", "CriticalResourceIdx", "==", "UINT_MAX", "||", "(", "PI", "->", "ProcResourceIdx", "!=", "CriticalResourceIdx", "&&", "CurrCounter", ">", "ProcResourceCounters", "[", "CriticalResourceIdx", "]", ")", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"++ New critical resource: \"", "<<", "SchedModel", "->", "getProcResource", "(", "PI", "->", "ProcResourceIdx", ")", "->", "Name", "<<", "\"\\n\"", ";", ")", ";", "CriticalResourceIdx", "=", "PI", "->", "ProcResourceIdx", ";", "}", "}", "if", "(", "SU", "->", "isUnbuffered", ")", "{", "LastFPdOpCycleIdx", "=", "getCurrCycleIdx", "(", "SU", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"++ Last FPd cycle index: \"", "<<", "LastFPdOpCycleIdx", "<<", "\"\\n\"", ";", ")", ";", "}", "CurrGroupSize", "+=", "getNumDecoderSlots", "(", "SU", ")", ";", "assert", "(", "CurrGroupSize", "<=", "3", ")", ";", "if", "(", "CurrGroupSize", "==", "3", "||", "SC", "->", "EndGroup", ")", "nextGroup", "(", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "\"++ HazardRecognizer emitting \"", "\"\\n\"", "\"Decode group before emission\"", "\", \"", "\"++ Clearing state after call.\\n\"", "1", "\"++ New critical resource: \"", "\"\\n\"", "\"++ Last FPd cycle index: \"", "\"\\n\"", "3", "3" ]

[]

[ "<s>", "void", "RV16KFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "unsigned", "FPReg", "=", "getFPReg", "(", ")", ";", "unsigned", "SPReg", "=", "getSPReg", "(", ")", ";", "DebugLoc", "DL", ";", "determineFrameLayout", "(", "MF", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", ".", "adjustsStack", "(", ")", ")", "return", ";", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "-", "StackSize", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "std", "::", "advance", "(", "MBBI", ",", "CSI", ".", "size", "(", ")", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "FPReg", ",", "SPReg", ",", "StackSize", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "</s>" ]

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

[ "RV16K", "RV16K", "\"Shrink-wrapping not yet supported\"", "0" ]

[]

[ "<s>", "static", "cpp_hashnode", "*", "s390_macro_to_expand", "(", "cpp_reader", "*", "pfile", ",", "const", "cpp_token", "*", "tok", ")", "{", "cpp_hashnode", "*", "expand_this", "=", "tok", "->", "val", ".", "node", ".", "node", ";", "cpp_hashnode", "*", "ident", ";", "static", "bool", "expand_bool_p", "=", "false", ";", "int", "idx", "=", "0", ";", "enum", "rid", "rid_code", ";", "if", "(", "!", "TARGET_ZVECTOR", ")", "return", "NULL", ";", "ident", "=", "s390_categorize_keyword", "(", "tok", ")", ";", "if", "(", "ident", "!=", "expand_this", ")", "expand_this", "=", "NULL", ";", "if", "(", "expand_bool_p", "&&", "ident", "==", "C_CPP_HASHNODE", "(", "__bool_keyword", ")", ")", "{", "expand_bool_p", "=", "false", ";", "return", "ident", ";", "}", "if", "(", "ident", "!=", "C_CPP_HASHNODE", "(", "__vector_keyword", ")", ")", "return", "expand_this", ";", "do", "tok", "=", "cpp_peek_token", "(", "pfile", ",", "idx", "++", ")", ";", "while", "(", "tok", "->", "type", "==", "CPP_PADDING", ")", ";", "ident", "=", "s390_categorize_keyword", "(", "tok", ")", ";", "if", "(", "!", "ident", ")", "return", "expand_this", ";", "if", "(", "ident", "==", "C_CPP_HASHNODE", "(", "__bool_keyword", ")", ")", "{", "expand_bool_p", "=", "true", ";", "return", "C_CPP_HASHNODE", "(", "__vector_keyword", ")", ";", "}", "if", "(", "ident", "==", "C_CPP_HASHNODE", "(", "__vector_keyword", ")", ")", "return", "expand_this", ";", "rid_code", "=", "(", "enum", "rid", ")", "(", "ident", "->", "rid_code", ")", ";", "if", "(", "ident", "->", "type", "==", "NT_MACRO", ")", "{", "do", "(", "void", ")", "cpp_get_token", "(", "pfile", ")", ";", "while", "(", "--", "idx", ">", "0", ")", ";", "do", "tok", "=", "cpp_peek_token", "(", "pfile", ",", "idx", "++", ")", ";", "while", "(", "tok", "->", "type", "==", "CPP_PADDING", ")", ";", "ident", "=", "s390_categorize_keyword", "(", "tok", ")", ";", "if", "(", "ident", "==", "C_CPP_HASHNODE", "(", "__bool_keyword", ")", ")", "{", "expand_bool_p", "=", "true", ";", "return", "C_CPP_HASHNODE", "(", "__vector_keyword", ")", ";", "}", "else", "if", "(", "ident", ")", "rid_code", "=", "(", "enum", "rid", ")", "(", "ident", "->", "rid_code", ")", ";", "}", "if", "(", "rid_code", "==", "RID_UNSIGNED", "||", "rid_code", "==", "RID_LONG", "||", "rid_code", "==", "RID_SHORT", "||", "rid_code", "==", "RID_SIGNED", "||", "rid_code", "==", "RID_INT", "||", "rid_code", "==", "RID_CHAR", "||", "(", "rid_code", "==", "RID_FLOAT", "&&", "TARGET_VXE", ")", "||", "rid_code", "==", "RID_DOUBLE", ")", "{", "expand_this", "=", "C_CPP_HASHNODE", "(", "__vector_keyword", ")", ";", "do", "tok", "=", "cpp_peek_token", "(", "pfile", ",", "idx", "++", ")", ";", "while", "(", "tok", "->", "type", "==", "CPP_PADDING", ")", ";", "ident", "=", "s390_categorize_keyword", "(", "tok", ")", ";", "if", "(", "ident", "==", "C_CPP_HASHNODE", "(", "__bool_keyword", ")", ")", "expand_bool_p", "=", "true", ";", "else", "{", "do", "tok", "=", "cpp_peek_token", "(", "pfile", ",", "idx", "++", ")", ";", "while", "(", "tok", "->", "type", "==", "CPP_PADDING", ")", ";", "ident", "=", "s390_categorize_keyword", "(", "tok", ")", ";", "if", "(", "ident", "==", "C_CPP_HASHNODE", "(", "__bool_keyword", ")", ")", "expand_bool_p", "=", "true", ";", "}", "}", "return", "expand_this", ";", "}", "</s>" ]

[ "Called", "to", "decide", "whether", "a", "conditional", "macro", "should", "be", "expanded", ".", "Since", "we", "have", "exactly", "one", "such", "macro", "(", "i.e", ",", "'vector", "'", ")", ",", "we", "do", "not", "need", "to", "examine", "the", "'tok", "'", "parameter", "." ]

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

[]

[ "<s>", "static", "rtx", "nios2_expand_ldst_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "const", "struct", "nios2_builtin_desc", "*", "d", ")", "{", "bool", "has_target_p", ";", "rtx", "addr", ",", "mem", ",", "val", ";", "struct", "expand_operand", "ops", "[", "MAX_RECOG_OPERANDS", "]", ";", "machine_mode", "mode", "=", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "addr", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "mode", ",", "addr", ")", ";", "if", "(", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "0", "]", ".", "allows_mem", ")", "{", "val", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ")", ";", "if", "(", "CONST_INT_P", "(", "val", ")", ")", "val", "=", "force_reg", "(", "mode", ",", "gen_int_mode", "(", "INTVAL", "(", "val", ")", ",", "mode", ")", ")", ";", "val", "=", "simplify_gen_subreg", "(", "mode", ",", "val", ",", "GET_MODE", "(", "val", ")", ",", "0", ")", ";", "create_output_operand", "(", "&", "ops", "[", "0", "]", ",", "mem", ",", "mode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "1", "]", ",", "val", ",", "mode", ")", ";", "if", "(", "insn_data", "[", "d", "->", "icode", "]", ".", "n_operands", "==", "3", ")", "{", "create_output_operand", "(", "&", "ops", "[", "2", "]", ",", "target", ",", "mode", ")", ";", "has_target_p", "=", "true", ";", "}", "else", "has_target_p", "=", "false", ";", "}", "else", "{", "create_output_operand", "(", "&", "ops", "[", "0", "]", ",", "target", ",", "mode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "1", "]", ",", "mem", ",", "mode", ")", ";", "has_target_p", "=", "true", ";", "}", "return", "nios2_expand_builtin_insn", "(", "d", ",", "insn_data", "[", "d", "->", "icode", "]", ".", "n_operands", ",", "ops", ",", "has_target_p", ")", ";", "}", "</s>" ]

[ "Expand", "ldio/stio", "and", "ldex/ldsex/stex/stsex", "form", "load-store", "instruction", "builtins", "." ]

[ "nios2", "0", "0", "0", "1", "0", "0", "1", "3", "2", "0", "1" ]

[]

[ "<s>", "bool", "R600Packetizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "TargetInstrInfo", "*", "TII", "=", "Fn", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineLoopInfo", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MachineDominatorTree", "&", "MDT", "=", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "R600PacketizerList", "Packetizer", "(", "Fn", ",", "MLI", ",", "MDT", ")", ";", "assert", "(", "Packetizer", ".", "getResourceTracker", "(", ")", "&&", "\"Empty DFA table!\"", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "MachineBasicBlock", "::", "iterator", "End", "=", "MBB", "->", "end", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MI", "=", "MBB", "->", "begin", "(", ")", ";", "while", "(", "MI", "!=", "End", ")", "{", "if", "(", "MI", "->", "isKill", "(", ")", "||", "(", "MI", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "CF_ALU", "&&", "!", "MI", "->", "getOperand", "(", "8", ")", ".", "getImm", "(", ")", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "DeleteMI", "=", "MI", ";", "++", "MI", ";", "MBB", "->", "erase", "(", "DeleteMI", ")", ";", "End", "=", "MBB", "->", "end", "(", ")", ";", "continue", ";", "}", "++", "MI", ";", "}", "}", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "unsigned", "RemainingCount", "=", "MBB", "->", "size", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "RegionEnd", "=", "MBB", "->", "end", "(", ")", ";", "RegionEnd", "!=", "MBB", "->", "begin", "(", ")", ";", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "RegionEnd", ";", "for", "(", ";", "I", "!=", "MBB", "->", "begin", "(", ")", ";", "--", "I", ",", "--", "RemainingCount", ")", "{", "if", "(", "TII", "->", "isSchedulingBoundary", "(", "llvm", "::", "prior", "(", "I", ")", ",", "MBB", ",", "Fn", ")", ")", "break", ";", "}", "I", "=", "MBB", "->", "begin", "(", ")", ";", "if", "(", "I", "==", "RegionEnd", ")", "{", "RegionEnd", "=", "llvm", "::", "prior", "(", "RegionEnd", ")", ";", "--", "RemainingCount", ";", "continue", ";", "}", "if", "(", "I", "==", "llvm", "::", "prior", "(", "RegionEnd", ")", ")", "{", "RegionEnd", "=", "llvm", "::", "prior", "(", "RegionEnd", ")", ";", "continue", ";", "}", "Packetizer", ".", "PacketizeMIs", "(", "MBB", ",", "I", ",", "RegionEnd", ")", ";", "RegionEnd", "=", "I", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "R600", "\"Empty DFA table!\"", "8" ]

[]

[ "<s>", "SDNode", "*", "BPFDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "NULL", ";", "}", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "FrameIndex", ":", "{", "int", "FI", "=", "dyn_cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "EVT", "VT", "=", "Node", "->", "getValueType", "(", "0", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "VT", ")", ";", "unsigned", "Opc", "=", "BPF", "::", "MOV_rr", ";", "if", "(", "Node", "->", "hasOneUse", "(", ")", ")", "return", "CurDAG", "->", "SelectNodeTo", "(", "Node", ",", "Opc", ",", "VT", ",", "TFI", ")", ";", "return", "CurDAG", "->", "getMachineNode", "(", "Opc", ",", "SDLoc", "(", "Node", ")", ",", "VT", ",", "TFI", ")", ";", "return", "CurDAG", "->", "getMachineNode", "(", "Opc", ",", "Node", "->", "getDebugLoc", "(", ")", ",", "VT", ",", "TFI", ")", ";", "}", "}", "SDNode", "*", "ResNode", "=", "SelectCode", "(", "Node", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"=> \"", ")", ";", "if", "(", "ResNode", "==", "NULL", "||", "ResNode", "==", "Node", ")", "DEBUG", "(", "Node", "->", "dump", "(", "CurDAG", ")", ")", ";", "else", "DEBUG", "(", "ResNode", "->", "dump", "(", "CurDAG", ")", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "ResNode", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "\"Selecting: \"", "\"\\n\"", "\"== \"", "\"\\n\"", "ISD::FrameIndex", "0", "BPF::MOV_rr", "\"=> \"", "\"\\n\"" ]

[]

[ "<s>", "static", "bool", "scalar_to_vector_candidate_p", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "def_set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "!", "def_set", ")", "return", "false", ";", "if", "(", "has_non_address_hard_reg", "(", "insn", ")", ")", "return", "false", ";", "rtx", "src", "=", "SET_SRC", "(", "def_set", ")", ";", "rtx", "dst", "=", "SET_DEST", "(", "def_set", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "COMPARE", ")", "return", "convertible_comparison_p", "(", "insn", ")", ";", "if", "(", "GET_MODE", "(", "src", ")", "!=", "DImode", "||", "GET_MODE", "(", "dst", ")", "!=", "DImode", ")", "return", "false", ";", "if", "(", "!", "REG_P", "(", "dst", ")", "&&", "!", "MEM_P", "(", "dst", ")", ")", "return", "false", ";", "switch", "(", "GET_CODE", "(", "src", ")", ")", "{", "case", "PLUS", ":", "case", "MINUS", ":", "case", "IOR", ":", "case", "XOR", ":", "case", "AND", ":", "break", ";", "case", "REG", ":", "return", "true", ";", "case", "MEM", ":", "return", "REG_P", "(", "dst", ")", ";", "default", ":", "return", "false", ";", "}", "if", "(", "!", "REG_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", "&&", "!", "MEM_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", "&&", "(", "GET_CODE", "(", "src", ")", "!=", "AND", "||", "GET_CODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "!=", "NOT", "||", "!", "REG_P", "(", "XEXP", "(", "XEXP", "(", "src", ",", "0", ")", ",", "0", ")", ")", ")", ")", "return", "false", ";", "if", "(", "!", "REG_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", "&&", "!", "MEM_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", ")", "return", "false", ";", "if", "(", "GET_MODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "!=", "DImode", "||", "GET_MODE", "(", "XEXP", "(", "src", ",", "1", ")", ")", "!=", "DImode", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "1", "if", "INSN", "may", "be", "converted", "into", "vector", "instruction", "." ]

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

[]

[ "<s>", "bool", "Emitter", "<", "CodeEmitter", ">", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MMI", "=", "&", "getAnalysis", "<", "MachineModuleInfo", ">", "(", ")", ";", "MCE", ".", "setModuleInfo", "(", "MMI", ")", ";", "II", "=", "TM", ".", "getInstrInfo", "(", ")", ";", "TD", "=", "TM", ".", "getTargetData", "(", ")", ";", "Is64BitMode", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ";", "IsPIC", "=", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ";", "do", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"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", "::", "iterator", "I", "=", "MBB", "->", "begin", "(", ")", ",", "E", "=", "MBB", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "const", "MCInstrDesc", "&", "Desc", "=", "I", "->", "getDesc", "(", ")", ";", "emitInstruction", "(", "*", "I", ",", "&", "Desc", ")", ";", "if", "(", "Desc", ".", "getOpcode", "(", ")", "==", "X86", "::", "MOVPC32r", ")", "emitInstruction", "(", "*", "I", ",", "&", "II", "->", "get", "(", "X86", "::", "POP32r", ")", ")", ";", "++", "NumEmitted", ";", "}", "}", "}", "while", "(", "MCE", ".", "finishFunction", "(", "MF", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"JITTing function '\"", "\"'\\n\"", "X86::MOVPC32r", "X86::POP32r" ]

[]

[ "<s>", "static", "int", "loongarch_adjust_cost", "(", "rtx_insn", "*", ",", "int", "dep_type", ",", "rtx_insn", "*", ",", "int", "cost", ",", "unsigned", "int", ")", "{", "if", "(", "dep_type", "!=", "0", "&&", "(", "dep_type", "!=", "REG_DEP_OUTPUT", ")", ")", "return", "0", ";", "return", "cost", ";", "}", "</s>" ]

[ "Implement", "TARGET_SCHED_ADJUST_COST", ".", "We", "assume", "that", "anti", "and", "output", "dependencies", "have", "no", "cost", "." ]

[ "loongarch", "0", "0" ]

[]

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

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

[ "BPF", "\"BPF Assembly Printer\"" ]

[]

[ "<s>", "static", "void", "insert_hbrp", "(", "void", ")", "{", "rtx_insn", "*", "insn", ";", "if", "(", "TARGET_SAFE_HINTS", ")", "{", "shorten_branches", "(", "get_insns", "(", ")", ")", ";", "insn", "=", "next_active_insn", "(", "get_insns", "(", ")", ")", ";", "if", "(", "insn", ")", "insert_hbrp_for_ilb_runout", "(", "insn", ")", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "(", "LABEL_P", "(", "insn", ")", "&&", "HINTED_P", "(", "insn", ")", ")", "||", "CALL_P", "(", "insn", ")", ")", "insert_hbrp_for_ilb_runout", "(", "next_active_insn", "(", "insn", ")", ")", ";", "}", "}", "</s>" ]

[ "The", "SPU", "might", "hang", "when", "it", "executes", "48", "inline", "instructions", "after", "a", "hinted", "branch", "jumps", "to", "its", "hinted", "target", ".", "The", "beginning", "of", "a", "function", "and", "the", "return", "from", "a", "call", "might", "have", "been", "hinted", ",", "and", "must", "be", "handled", "as", "well", ".", "To", "prevent", "a", "hang", "we", "insert", "2", "hbrps", ".", "The", "first", "should", "be", "within", "6", "insns", "of", "the", "branch", "target", ".", "The", "second", "should", "be", "within", "22", "insns", "of", "the", "branch", "target", ".", "When", "determining", "if", "hbrps", "are", "necessary", ",", "we", "look", "for", "only", "32", "inline", "instructions", ",", "because", "up", "to", "12", "nops", "and", "4", "hbrps", "could", "be", "inserted", ".", "Similarily", ",", "when", "inserting", "new", "hbrps", ",", "we", "insert", "them", "within", "4", "and", "16", "insns", "of", "the", "target", "." ]

[ "spu" ]

[]

[ "<s>", "static", "__inline__", "struct", "quot_rem", "do_31div", "(", "unsigned", "long", "a", ",", "unsigned", "long", "b", ")", "{", "long", "extra", "=", "0", ";", "int", "quot_digits", "=", "0", ";", "if", "(", "b", "==", "0", ")", "{", "struct", "quot_rem", "ret", ";", "ret", ".", "quot", "=", "0xffffffff", ";", "ret", ".", "rem", "=", "0xffffffff", ";", "return", "ret", ";", "}", "if", "(", "a", "<", "b", ")", "return", "(", "struct", "quot_rem", ")", "{", "0", ",", "a", "}", ";", "if", "(", "b", "<=", "a", ")", "{", "quot_digits", "=", "LZ", "(", "b", ")", "-", "LZ", "(", "a", ")", ";", "quot_digits", "+=", "(", "a", ">=", "(", "b", "<<", "quot_digits", ")", ")", ";", "b", "<<=", "quot_digits", ";", "}", "while", "(", "b", "<=", "a", ")", "{", "b", "<<=", "1", ";", "quot_digits", "++", ";", "}", "if", "(", "a", "&", "0x40000000", ")", "{", "b", ">>=", "1", ";", "if", "(", "a", ">=", "b", ")", "{", "a", "-=", "b", ";", "extra", "=", "1", "<<", "(", "quot_digits", "-", "1", ")", ";", "}", "else", "{", "a", "-=", "b", ">>", "1", ";", "extra", "=", "1", "<<", "quot_digits", ";", "}", "quot_digits", "--", ";", "}", "b", "--", ";", "switch", "(", "quot_digits", ")", "{", "case", "32", ":", "DS", ";", "case", "31", ":", "DS", ";", "case", "30", ":", "DS", ";", "case", "29", ":", "DS", ";", "case", "28", ":", "DS", ";", "case", "27", ":", "DS", ";", "case", "26", ":", "DS", ";", "case", "25", ":", "DS", ";", "case", "24", ":", "DS", ";", "case", "23", ":", "DS", ";", "case", "22", ":", "DS", ";", "case", "21", ":", "DS", ";", "case", "20", ":", "DS", ";", "case", "19", ":", "DS", ";", "case", "18", ":", "DS", ";", "case", "17", ":", "DS", ";", "case", "16", ":", "DS", ";", "case", "15", ":", "DS", ";", "case", "14", ":", "DS", ";", "case", "13", ":", "DS", ";", "case", "12", ":", "DS", ";", "case", "11", ":", "DS", ";", "case", "10", ":", "DS", ";", "case", "9", ":", "DS", ";", "case", "8", ":", "DS", ";", "case", "7", ":", "DS", ";", "case", "6", ":", "DS", ";", "case", "5", ":", "DS", ";", "case", "4", ":", "DS", ";", "case", "3", ":", "DS", ";", "case", "2", ":", "DS", ";", "case", "1", ":", "DS", ";", "case", "0", ":", ";", "}", "{", "struct", "quot_rem", "ret", ";", "ret", ".", "quot", "=", "(", "a", "&", "(", "(", "1", "<<", "quot_digits", ")", "-", "1", ")", ")", "+", "extra", ";", "ret", ".", "rem", "=", "a", ">>", "quot_digits", ";", "return", "ret", ";", "}", "}", "</s>" ]

[ "This", "is", "the", "worker", "function", "for", "div", "and", "mod", ".", "It", "is", "inlined", "into", "the", "respective", "library", "function", "." ]

[ "cris", "0", "0", "0", "0xffffffff", "0xffffffff", "0", "1", "0x40000000", "1", "1", "1", "1", "1", "32", "31", "30", "29", "28", "27", "26", "25", "24", "23", "22", "21", "20", "19", "18", "17", "16", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "1", "0", "1", "1" ]

[]

[ "<s>", "static", "rtx_code_label", "*", "add_constant", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "rtx", "last_value", ")", "{", "rtx_code_label", "*", "lab", ",", "*", "new_rtx", ";", "label_ref_list_t", "ref", ",", "newref", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "pool_size", ";", "i", "++", ")", "{", "if", "(", "x", "->", "code", "==", "pool_vector", "[", "i", "]", ".", "value", "->", "code", "&&", "mode", "==", "pool_vector", "[", "i", "]", ".", "mode", ")", "{", "if", "(", "x", "->", "code", "==", "CODE_LABEL", ")", "{", "if", "(", "XINT", "(", "x", ",", "3", ")", "!=", "XINT", "(", "pool_vector", "[", "i", "]", ".", "value", ",", "3", ")", ")", "continue", ";", "}", "if", "(", "rtx_equal_p", "(", "x", ",", "pool_vector", "[", "i", "]", ".", "value", ")", ")", "{", "lab", "=", "new_rtx", "=", "0", ";", "if", "(", "!", "last_value", "||", "!", "i", "||", "!", "rtx_equal_p", "(", "last_value", ",", "pool_vector", "[", "i", "-", "1", "]", ".", "value", ")", ")", "{", "new_rtx", "=", "gen_label_rtx", "(", ")", ";", "LABEL_REFS", "(", "new_rtx", ")", "=", "pool_vector", "[", "i", "]", ".", "label", ";", "pool_vector", "[", "i", "]", ".", "label", "=", "lab", "=", "new_rtx", ";", "}", "if", "(", "lab", "&&", "pool_window_label", ")", "{", "newref", "=", "label_ref_list_d_pool", ".", "allocate", "(", ")", ";", "newref", "->", "label", "=", "pool_window_label", ";", "ref", "=", "pool_vector", "[", "pool_window_last", "]", ".", "wend", ";", "newref", "->", "next", "=", "ref", ";", "pool_vector", "[", "pool_window_last", "]", ".", "wend", "=", "newref", ";", "}", "if", "(", "new_rtx", ")", "pool_window_label", "=", "new_rtx", ";", "pool_window_last", "=", "i", ";", "return", "lab", ";", "}", "}", "}", "pool_vector", "[", "pool_size", "]", ".", "value", "=", "x", ";", "if", "(", "last_value", "&&", "rtx_equal_p", "(", "last_value", ",", "pool_vector", "[", "pool_size", "-", "1", "]", ".", "value", ")", ")", "{", "lab", "=", "0", ";", "pool_vector", "[", "pool_size", "-", "1", "]", ".", "part_of_sequence_p", "=", "true", ";", "}", "else", "lab", "=", "gen_label_rtx", "(", ")", ";", "pool_vector", "[", "pool_size", "]", ".", "mode", "=", "mode", ";", "pool_vector", "[", "pool_size", "]", ".", "label", "=", "lab", ";", "pool_vector", "[", "pool_size", "]", ".", "wend", "=", "NULL", ";", "pool_vector", "[", "pool_size", "]", ".", "part_of_sequence_p", "=", "(", "lab", "==", "0", ")", ";", "if", "(", "lab", "&&", "pool_window_label", ")", "{", "newref", "=", "label_ref_list_d_pool", ".", "allocate", "(", ")", ";", "newref", "->", "label", "=", "pool_window_label", ";", "ref", "=", "pool_vector", "[", "pool_window_last", "]", ".", "wend", ";", "newref", "->", "next", "=", "ref", ";", "pool_vector", "[", "pool_window_last", "]", ".", "wend", "=", "newref", ";", "}", "if", "(", "lab", ")", "pool_window_label", "=", "lab", ";", "pool_window_last", "=", "pool_size", ";", "pool_size", "++", ";", "return", "lab", ";", "}", "</s>" ]

[ "Add", "a", "constant", "to", "the", "pool", "and", "return", "its", "label", "." ]

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

[]

[ "<s>", "bool", "X86FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "TRI", "->", "hasStackRealignment", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "MFI", ".", "isFrameAddressTaken", "(", ")", "||", "MFI", ".", "hasOpaqueSPAdjustment", "(", ")", "||", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getForceFramePointer", "(", ")", "||", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "hasPreallocatedCall", "(", ")", "||", "MF", ".", "callsUnwindInit", "(", ")", "||", "MF", ".", "hasEHFunclets", "(", ")", "||", "MF", ".", "callsEHReturn", "(", ")", "||", "MFI", ".", "hasStackMap", "(", ")", "||", "MFI", ".", "hasPatchPoint", "(", ")", "||", "(", "isWin64Prologue", "(", "MF", ")", "&&", "MFI", ".", "hasCopyImplyingStackAdjustment", "(", ")", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "frv_final_prescan_insn", "(", "rtx", "insn", ",", "rtx", "*", "opvec", ",", "int", "noperands", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "INSN_P", "(", "insn", ")", ")", "{", "if", "(", "frv_insn_packing_flag", ">=", "0", ")", "{", "frv_insn_operands", "=", "opvec", ";", "frv_insn_packing_flag", "=", "PACKING_FLAG_P", "(", "insn", ")", ";", "}", "else", "if", "(", "recog_memoized", "(", "insn", ")", ">=", "0", "&&", "get_attr_acc_group", "(", "insn", ")", "==", "ACC_GROUP_ODD", ")", "fprintf", "(", "asm_out_file", ",", "\"\\tmnop.p\\n\"", ")", ";", "}", "}", "</s>" ]

[ "Set", "up", "the", "packing", "bit", "for", "the", "current", "output", "insn", ".", "Note", "that", "this", "function", "is", "not", "called", "for", "asm", "insns", "." ]

[ "frv", "0", "0", "\"\\tmnop.p\\n\"" ]

[]

[ "<s>", "void", "PPCTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "TargetMachine", "&", "TM", "=", "getTargetMachine", "(", ")", ";", "SDLoc", "dl", "(", "N", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Do not know how to custom type legalize this operation!\"", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "if", "(", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "1", ")", ")", "->", "getZExtValue", "(", ")", "!=", "Intrinsic", "::", "ppc_is_decremented_ctr_nonzero", ")", "break", ";", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i1", "&&", "\"Unexpected result type for CTR decrement intrinsic\"", ")", ";", "EVT", "SVT", "=", "getSetCCResultType", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "N", "->", "getValueType", "(", "0", ")", ")", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "SVT", ",", "MVT", "::", "Other", ")", ";", "SDValue", "NewInt", "=", "DAG", ".", "getNode", "(", "N", "->", "getOpcode", "(", ")", ",", "dl", ",", "VTs", ",", "N", "->", "getOperand", "(", "0", ")", ",", "N", "->", "getOperand", "(", "1", ")", ")", ";", "Results", ".", "push_back", "(", "NewInt", ")", ";", "Results", ".", "push_back", "(", "NewInt", ".", "getValue", "(", "1", ")", ")", ";", "break", ";", "}", "case", "ISD", "::", "VAARG", ":", "{", "if", "(", "!", "TM", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "isSVR4ABI", "(", ")", "||", "TM", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "isPPC64", "(", ")", ")", "return", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "{", "SDValue", "NewNode", "=", "LowerVAARG", "(", "SDValue", "(", "N", ",", "1", ")", ",", "DAG", ",", "PPCSubTarget", ")", ";", "Results", ".", "push_back", "(", "NewNode", ")", ";", "Results", ".", "push_back", "(", "NewNode", ".", "getValue", "(", "1", ")", ")", ";", "}", "return", ";", "}", "case", "ISD", "::", "FP_ROUND_INREG", ":", "{", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "ppcf128", ")", ";", "assert", "(", "N", "->", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "ppcf128", ")", ";", "SDValue", "Lo", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_ELEMENT", ",", "dl", ",", "MVT", "::", "f64", ",", "N", "->", "getOperand", "(", "0", ")", ",", "DAG", ".", "getIntPtrConstant", "(", "0", ")", ")", ";", "SDValue", "Hi", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_ELEMENT", ",", "dl", ",", "MVT", "::", "f64", ",", "N", "->", "getOperand", "(", "0", ")", ",", "DAG", ".", "getIntPtrConstant", "(", "1", ")", ")", ";", "SDValue", "FPreg", "=", "DAG", ".", "getNode", "(", "PPCISD", "::", "FADDRTZ", ",", "dl", ",", "MVT", "::", "f64", ",", "Lo", ",", "Hi", ")", ";", "Results", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_PAIR", ",", "dl", ",", "MVT", "::", "ppcf128", ",", "FPreg", ",", "FPreg", ")", ")", ";", "return", ";", "}", "case", "ISD", "::", "FP_TO_SINT", ":", "Results", ".", "push_back", "(", "LowerFP_TO_INT", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ",", "dl", ")", ")", ";", "return", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"Do not know how to custom type legalize this operation!\"", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::ppc_is_decremented_ctr_nonzero", "0", "MVT::i1", "\"Unexpected result type for CTR decrement intrinsic\"", "0", "MVT::Other", "0", "1", "1", "ISD::VAARG", "PPC", "PPC", "PPC", "0", "MVT::i64", "1", "PPC", "1", "ISD::FP_ROUND_INREG", "0", "MVT::ppcf128", "0", "MVT::ppcf128", "ISD::EXTRACT_ELEMENT", "MVT::f64", "0", "0", "ISD::EXTRACT_ELEMENT", "MVT::f64", "0", "1", "PPCISD::FADDRTZ", "MVT::f64", "ISD::BUILD_PAIR", "MVT::ppcf128", "ISD::FP_TO_SINT", "0" ]

[]

[ "<s>", "void", "NyuziFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "NyuziInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "NyuziInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "const", "MCRegisterInfo", "*", "MRI", "=", "MF", ".", "getMMI", "(", ")", ".", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "int", "StackSize", "=", "alignTo", "(", "MFI", ".", "getStackSize", "(", ")", ",", "getStackAlignment", "(", ")", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", ".", "adjustsStack", "(", ")", ")", "return", ";", "TII", ".", "adjustStackPointer", "(", "MBB", ",", "MBBI", ",", "DL", ",", "-", "StackSize", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaOffset", "(", "nullptr", ",", "-", "StackSize", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "if", "(", "CSI", ".", "size", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "++", "MBBI", ";", "for", "(", "const", "auto", "&", "I", ":", "CSI", ")", "{", "int64_t", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "I", ".", "getFrameIdx", "(", ")", ")", ";", "unsigned", "Reg", "=", "I", ".", "getReg", "(", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "MRI", "->", "getDwarfRegNum", "(", "Reg", ",", "1", ")", ",", "Offset", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Nyuzi", "::", "MOVESS", ")", ")", ".", "addReg", "(", "Nyuzi", "::", "FP_REG", ")", ".", "addReg", "(", "Nyuzi", "::", "SP_REG", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaRegister", "(", "nullptr", ",", "MRI", "->", "getDwarfRegNum", "(", "Nyuzi", "::", "FP_REG", ",", "true", ")", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "}", "</s>" ]

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

[ "Nyuzi", "Nyuzi", "Nyuzi", "Nyuzi", "0", "0", "1", "Nyuzi::MOVESS", "Nyuzi::FP_REG", "Nyuzi::SP_REG", "Nyuzi::FP_REG" ]

[]

[ "<s>", "enum", "indirect_thunk_prefix", "indirect_thunk_need_prefix", "(", "rtx_insn", "*", "insn", ")", "{", "enum", "indirect_thunk_prefix", "need_prefix", ";", "if", "(", "(", "cfun", "->", "machine", "->", "indirect_branch_type", "==", "indirect_branch_thunk_extern", ")", "&&", "ix86_notrack_prefixed_insn_p", "(", "insn", ")", ")", "{", "need_prefix", "=", "indirect_thunk_prefix_nt", ";", "}", "else", "need_prefix", "=", "indirect_thunk_prefix_none", ";", "return", "need_prefix", ";", "}", "</s>" ]

[ "Return", "the", "prefix", "needed", "for", "an", "indirect", "branch", "INSN", "." ]

[ "i386" ]

[]

[ "<s>", "void", "SystemZHazardRecognizer", "::", "copyState", "(", "SystemZHazardRecognizer", "*", "Incoming", ")", "{", "CurrGroupSize", "=", "Incoming", "->", "CurrGroupSize", ";", "DEBUG", "(", "CurGroupDbg", "=", "Incoming", "->", "CurGroupDbg", ";", ")", ";", "ProcResourceCounters", "=", "Incoming", "->", "ProcResourceCounters", ";", "CriticalResourceIdx", "=", "Incoming", "->", "CriticalResourceIdx", ";", "LastFPdOpCycleIdx", "=", "Incoming", "->", "LastFPdOpCycleIdx", ";", "GrpCount", "=", "Incoming", "->", "GrpCount", ";", "}", "</s>" ]

[ "Copy", "counters", "from", "end", "of", "single", "predecessor", "." ]

[ "SystemZ", "SystemZ", "SystemZ" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "HandleByVal", "(", "CCState", "*", "State", ",", "unsigned", "&", "size", ",", "unsigned", "Align", ")", "const", "{", "unsigned", "reg", "=", "State", "->", "AllocateReg", "(", "GPRArgRegs", ",", "4", ")", ";", "assert", "(", "(", "State", "->", "getCallOrPrologue", "(", ")", "==", "Prologue", "||", "State", "->", "getCallOrPrologue", "(", ")", "==", "Call", ")", "&&", "\"unhandled ParmContext\"", ")", ";", "if", "(", "Subtarget", "->", "isTargetNaCl", "(", ")", ")", "{", "if", "(", "(", "!", "State", "->", "isFirstByValRegValid", "(", ")", ")", "&&", "(", "ARM", "::", "R0", "<=", "reg", ")", "&&", "(", "reg", "<=", "ARM", "::", "R3", ")", ")", "{", "State", "->", "setHasByValInRegPosition", "(", ")", ";", "}", "while", "(", "State", "->", "AllocateReg", "(", "GPRArgRegs", ",", "4", ")", ")", ";", "return", ";", "}", "if", "(", "(", "!", "State", "->", "isFirstByValRegValid", "(", ")", ")", "&&", "(", "ARM", "::", "R0", "<=", "reg", ")", "&&", "(", "reg", "<=", "ARM", "::", "R3", ")", ")", "{", "if", "(", "Subtarget", "->", "isAAPCS_ABI", "(", ")", "&&", "Align", ">", "4", ")", "{", "unsigned", "AlignInRegs", "=", "Align", "/", "4", ";", "unsigned", "Waste", "=", "(", "ARM", "::", "R4", "-", "reg", ")", "%", "AlignInRegs", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Waste", ";", "++", "i", ")", "reg", "=", "State", "->", "AllocateReg", "(", "GPRArgRegs", ",", "4", ")", ";", "}", "if", "(", "reg", "!=", "0", ")", "{", "State", "->", "setFirstByValReg", "(", "reg", ")", ";", "if", "(", "State", "->", "getCallOrPrologue", "(", ")", "==", "Call", ")", "{", "unsigned", "excess", "=", "4", "*", "(", "ARM", "::", "R4", "-", "reg", ")", ";", "assert", "(", "size", ">=", "excess", "&&", "\"expected larger existing stack allocation\"", ")", ";", "size", "-=", "excess", ";", "}", "}", "}", "while", "(", "State", "->", "AllocateReg", "(", "GPRArgRegs", ",", "4", ")", ")", ";", "}", "</s>" ]

[ "Target-specific", "cleanup", "for", "formal", "ByVal", "parameters", "." ]

[ "ARM", "ARM", "4", "\"unhandled ParmContext\"", "ARM::R0", "ARM::R3", "4", "ARM::R0", "ARM::R3", "4", "4", "ARM::R4", "0", "4", "0", "4", "ARM::R4", "\"expected larger existing stack allocation\"", "4" ]

[]

[ "<s>", "BaseKind", "getKind", "(", ")", "const", "{", "return", "Kind", ";", "}", "</s>" ]

[ "Returns", "the", "Kind", "of", "lane", "offset", "." ]

[ "ARM64" ]

[]

[ "<s>", "void", "SIRegisterInfo", "::", "materializeFrameBaseRegister", "(", "MachineBasicBlock", "*", "MBB", ",", "unsigned", "BaseReg", ",", "int", "FrameIdx", ",", "int64_t", "Offset", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "Ins", "=", "MBB", "->", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "Ins", "!=", "MBB", "->", "end", "(", ")", ")", "DL", "=", "Ins", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "if", "(", "Offset", "==", "0", ")", "{", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "BaseReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ";", "return", ";", "}", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "Register", "OffsetReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "Register", "FIReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ")", ";", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B32", ")", ",", "OffsetReg", ")", ".", "addImm", "(", "Offset", ")", ";", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "FIReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ";", "TII", "->", "getAddNoCarry", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "BaseReg", ")", ".", "addReg", "(", "OffsetReg", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "FIReg", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

[ "Insert", "defining", "instruction", "(", "s", ")", "for", "a", "pointer", "to", "FrameIdx", "before", "insertion", "point", "I", "." ]

[ "AMDGPU", "SI", "SI", "0", "AMDGPU::V_MOV_B32_e32", "AMDGPU::SReg_32_XM0RegClass", "AMDGPU::VGPR_32RegClass", "AMDGPU::S_MOV_B32", "AMDGPU::V_MOV_B32_e32", "0" ]

[]

[ "<s>", "SDValue", "MBlazeTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "ISD::ConstantPool", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::SELECT_CC", "ISD::VASTART" ]

[]

[ "<s>", "bool", "MipsAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "const_cast", "<", "TargetLoweringObjectFile", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ".", "Initialize", "(", "OutContext", ",", "TM", ")", ";", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "MCP", "=", "MF", ".", "getConstantPool", "(", ")", ";", "if", "(", "Subtarget", "->", "isTargetNaCl", "(", ")", ")", "NaClAlignIndirectJumpTargets", "(", "MF", ")", ";", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "R600SchedStrategy", "::", "initialize", "(", "ScheduleDAGMI", "*", "dag", ")", "{", "assert", "(", "dag", "->", "hasVRegLiveness", "(", ")", "&&", "\"R600SchedStrategy needs vreg liveness\"", ")", ";", "DAG", "=", "static_cast", "<", "ScheduleDAGMILive", "*", ">", "(", "dag", ")", ";", "const", "R600Subtarget", "&", "ST", "=", "DAG", "->", "MF", ".", "getSubtarget", "<", "R600Subtarget", ">", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "R600InstrInfo", "*", ">", "(", "DAG", "->", "TII", ")", ";", "TRI", "=", "static_cast", "<", "const", "R600RegisterInfo", "*", ">", "(", "DAG", "->", "TRI", ")", ";", "VLIW5", "=", "!", "ST", ".", "hasCaymanISA", "(", ")", ";", "MRI", "=", "&", "DAG", "->", "MRI", ";", "CurInstKind", "=", "IDOther", ";", "CurEmitted", "=", "0", ";", "OccupiedSlotsMask", "=", "31", ";", "InstKindLimit", "[", "IDAlu", "]", "=", "TII", "->", "getMaxAlusPerClause", "(", ")", ";", "InstKindLimit", "[", "IDOther", "]", "=", "32", ";", "InstKindLimit", "[", "IDFetch", "]", "=", "ST", ".", "getTexVTXClauseSize", "(", ")", ";", "AluInstCount", "=", "0", ";", "FetchInstCount", "=", "0", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "\"R600SchedStrategy needs vreg liveness\"", "R600", "R600", "R600", "R600", "0", "31", "32", "0", "0" ]

[]

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

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

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "preferred_la_operand_p", "(", "rtx", "op1", ",", "rtx", "op2", ")", "{", "struct", "s390_address", "addr", ";", "if", "(", "op2", "!=", "const0_rtx", ")", "op1", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "op1", ",", "op2", ")", ";", "if", "(", "!", "s390_decompose_address", "(", "op1", ",", "&", "addr", ")", ")", "return", "false", ";", "if", "(", "addr", ".", "base", "&&", "!", "REG_OK_FOR_BASE_STRICT_P", "(", "addr", ".", "base", ")", ")", "return", "false", ";", "if", "(", "addr", ".", "indx", "&&", "!", "REG_OK_FOR_INDEX_STRICT_P", "(", "addr", ".", "indx", ")", ")", "return", "false", ";", "if", "(", "!", "TARGET_64BIT", "&&", "!", "addr", ".", "pointer", ")", "return", "false", ";", "if", "(", "addr", ".", "pointer", ")", "return", "true", ";", "if", "(", "(", "addr", ".", "base", "&&", "REG_P", "(", "addr", ".", "base", ")", "&&", "REG_POINTER", "(", "addr", ".", "base", ")", ")", "||", "(", "addr", ".", "indx", "&&", "REG_P", "(", "addr", ".", "indx", ")", "&&", "REG_POINTER", "(", "addr", ".", "indx", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "valid", "*", "and", "*", "preferable", "to", "use", "LA", "to", "compute", "the", "sum", "of", "OP1", "and", "OP2", "." ]

[ "s390" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "insertNoop", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "insertNoops", "(", "MBB", ",", "MI", ",", "1", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "const", "simd_vec_cost", "*", "aarch64_simd_vec_costs", "(", "tree", "vectype", ")", "{", "const", "cpu_vector_cost", "*", "costs", "=", "aarch64_tune_params", ".", "vec_costs", ";", "if", "(", "vectype", "!=", "NULL", "&&", "aarch64_sve_mode_p", "(", "TYPE_MODE", "(", "vectype", ")", ")", "&&", "costs", "->", "sve", "!=", "NULL", ")", "return", "costs", "->", "sve", ";", "return", "costs", "->", "advsimd", ";", "}", "</s>" ]

[ "Return", "the", "appropriate", "SIMD", "costs", "for", "vectors", "of", "type", "VECTYPE", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "FixupLEAPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Func", ")", "{", "MF", "=", "&", "Func", ";", "TM", "=", "&", "Func", ".", "getTarget", "(", ")", ";", "const", "X86Subtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "LEAusesAG", "(", ")", "&&", "!", "ST", ".", "slowLEA", "(", ")", ")", "return", "false", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Start X86FixupLEAs\\n\"", ";", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "Func", ".", "begin", "(", ")", ",", "E", "=", "Func", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "processBasicBlock", "(", "Func", ",", "I", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"End X86FixupLEAs\\n\"", ";", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"Start X86FixupLEAs\\n\"", "\"End X86FixupLEAs\\n\"" ]

[]

[ "<s>", "static", "int", "nvptx_simt_vf", "(", ")", "{", "return", "PTX_VECTOR_LENGTH", ";", "}", "</s>" ]

[ "Implement", "TARGET_SIMT_VF", "target", "hook", ":", "number", "of", "threads", "in", "a", "warp", "." ]

[ "nvptx" ]

[]

[ "<s>", "bool", "ARMFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "unsigned", "PushOpc", "=", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "t2STMDB_UPD", ":", "ARM", "::", "STMDB_UPD", ";", "unsigned", "PushOneOpc", "=", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "t2STR_PRE", ":", "ARM", "::", "STR_PRE_IMM", ";", "unsigned", "FltOpc", "=", "ARM", "::", "VSTMDDB_UPD", ";", "unsigned", "NumAlignedDPRCS2Regs", "=", "AFI", "->", "getNumAlignedDPRCS2Regs", "(", ")", ";", "emitPushInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "PushOpc", ",", "PushOneOpc", ",", "false", ",", "&", "isARMArea1Register", ",", "0", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "emitPushInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "PushOpc", ",", "PushOneOpc", ",", "false", ",", "&", "isARMArea2Register", ",", "0", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "emitPushInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "FltOpc", ",", "0", ",", "true", ",", "&", "isARMArea3Register", ",", "NumAlignedDPRCS2Regs", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "if", "(", "NumAlignedDPRCS2Regs", ")", "emitAlignedDPRCS2Spills", "(", "MBB", ",", "MI", ",", "NumAlignedDPRCS2Regs", ",", "CSI", ",", "TRI", ")", ";", "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", "(", ")", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM::t2STMDB_UPD", "ARM::STMDB_UPD", "ARM::t2STR_PRE", "ARM::STR_PRE_IMM", "ARM::VSTMDDB_UPD", "ARM", "0", "ARM", "0", "0", "ARM" ]

[]

[ "<s>", "TargetLoweringBase", "::", "LegalizeTypeAction", "NVPTXTargetLowering", "::", "getPreferredVectorAction", "(", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "!=", "1", "&&", "VT", ".", "getScalarType", "(", ")", "==", "MVT", "::", "i1", ")", "return", "TypeSplitVector", ";", "if", "(", "VT", "==", "MVT", "::", "v2f16", ")", "return", "TypeLegal", ";", "return", "TargetLoweringBase", "::", "getPreferredVectorAction", "(", "VT", ")", ";", "}", "</s>" ]

[ "Customize", "the", "preferred", "legalization", "strategy", "for", "certain", "types", "." ]

[ "NVPTX", "NVPTX", "1", "MVT::i1", "MVT::v2f16" ]

[]

[ "<s>", "const", "AMDGPUSubtarget", "*", "getSubtargetImpl", "(", "const", "Function", "&", ")", "const", "override", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "MachineInstr", "*", "SIInstrInfo", "::", "commuteInstruction", "(", "MachineInstr", "*", "MI", ",", "bool", "NewMI", ")", "const", "{", "if", "(", "MI", "->", "getNumOperands", "(", ")", "<", "3", "||", "!", "MI", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "||", "!", "MI", "->", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", ")", "return", "0", ";", "MI", "=", "TargetInstrInfo", "::", "commuteInstruction", "(", "MI", ",", "NewMI", ")", ";", "if", "(", "MI", ")", "MI", "->", "setDesc", "(", "get", "(", "commuteOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ")", ";", "return", "MI", ";", "}", "</s>" ]

[ "This", "method", "commutes", "the", "operands", "of", "the", "given", "machine", "instruction", "MI", "." ]

[ "R600", "SI", "3", "1", "2", "0" ]

[]

[ "<s>", "void", "TL45FrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ",", "bool", "hasFP", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TL45RegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "uint64_t", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", ")", "{", "unsigned", "MaxStackAlign", "=", "std", "::", "max", "(", "StackAlign", ",", "MFI", ".", "getMaxAlignment", "(", ")", ")", ";", "FrameSize", "+=", "(", "MaxStackAlign", "-", "StackAlign", ")", ";", "StackAlign", "=", "MaxStackAlign", ";", "}", "uint64_t", "MaxCallSize", "=", "alignTo", "(", "MFI", ".", "getMaxCallFrameSize", "(", ")", ",", "StackAlign", ")", ";", "MFI", ".", "setMaxCallFrameSize", "(", "MaxCallSize", ")", ";", "FrameSize", "=", "alignTo", "(", "FrameSize", ",", "StackAlign", ")", ";", "if", "(", "hasFP", ")", "{", "auto", "TMDL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "uint64_t", "ptr_size", "=", "TMDL", ".", "getPointerSizeInBits", "(", ")", "/", "TMDL", ".", "getBitsPerMemoryUnit", "(", ")", ";", "FrameSize", "+=", "ptr_size", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"[TL45FrameLowering::determineFrameLayout] MF: '\"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"' has frame pointer, incrementing stack frame size by ptr_size.\\n\"", ")", ";", "}", "MFI", ".", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

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

[ "TL45", "TL45", "TL45", "\"[TL45FrameLowering::determineFrameLayout] MF: '\"", "\"' has frame pointer, incrementing stack frame size by ptr_size.\\n\"" ]

[]

[ "<s>", "void", "notice_update_cc", "(", "rtx", "body", "ATTRIBUTE_UNUSED", ",", "rtx", "insn", ")", "{", "rtx", "set", ";", "switch", "(", "get_attr_cc", "(", "insn", ")", ")", "{", "case", "CC_NONE", ":", "break", ";", "case", "CC_SET_N", ":", "CC_STATUS_INIT", ";", "break", ";", "case", "CC_SET_ZN", ":", "set", "=", "single_set", "(", "insn", ")", ";", "CC_STATUS_INIT", ";", "if", "(", "set", ")", "{", "cc_status", ".", "flags", "|=", "CC_NO_OVERFLOW", ";", "cc_status", ".", "value1", "=", "SET_DEST", "(", "set", ")", ";", "}", "break", ";", "case", "CC_SET_CZN", ":", "set", "=", "single_set", "(", "insn", ")", ";", "CC_STATUS_INIT", ";", "if", "(", "set", ")", "{", "cc_status", ".", "value1", "=", "SET_DEST", "(", "set", ")", ";", "cc_status", ".", "flags", "|=", "CC_OVERFLOW_UNUSABLE", ";", "}", "break", ";", "case", "CC_COMPARE", ":", "set", "=", "single_set", "(", "insn", ")", ";", "CC_STATUS_INIT", ";", "if", "(", "set", ")", "cc_status", ".", "value1", "=", "SET_SRC", "(", "set", ")", ";", "break", ";", "case", "CC_CLOBBER", ":", "CC_STATUS_INIT", ";", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", ")", "{", "rtx", "src", "=", "SET_SRC", "(", "set", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "ASHIFTRT", "&&", "GET_MODE", "(", "src", ")", "==", "QImode", ")", "{", "rtx", "x", "=", "XEXP", "(", "src", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "x", ")", ">", "0", "&&", "INTVAL", "(", "x", ")", "!=", "6", ")", "{", "cc_status", ".", "value1", "=", "SET_DEST", "(", "set", ")", ";", "cc_status", ".", "flags", "|=", "CC_OVERFLOW_UNUSABLE", ";", "}", "}", "}", "break", ";", "}", "}", "</s>" ]

[ "On", "the", "68000", ",", "all", "the", "insns", "to", "store", "in", "an", "address", "register", "fail", "to", "set", "the", "cc", "'s", ".", "However", ",", "in", "some", "cases", "these", "instructions", "can", "make", "it", "possibly", "invalid", "to", "use", "the", "saved", "cc", "'s", ".", "In", "those", "cases", "we", "clear", "out", "some", "or", "all", "of", "the", "saved", "cc", "'s", "so", "they", "wo", "n't", "be", "used", "." ]

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

[]

[ "<s>", "static", "int", "thumb_find_work_register", "(", "unsigned", "long", "pushed_regs_mask", ")", "{", "int", "reg", ";", "unsigned", "long", "unused_regs", "=", "thumb1_prologue_unused_call_clobbered_lo_regs", "(", ")", ";", "for", "(", "reg", "=", "LAST_LO_REGNUM", ";", "reg", ">=", "FIRST_LO_REGNUM", ";", "reg", "--", ")", "if", "(", "unused_regs", "&", "(", "1", "<<", "(", "reg", "-", "FIRST_LO_REGNUM", ")", ")", ")", "return", "reg", ";", "for", "(", "reg", "=", "LAST_LO_REGNUM", ";", "reg", ">", "LAST_ARG_REGNUM", ";", "reg", "--", ")", "if", "(", "pushed_regs_mask", "&", "(", "1", "<<", "reg", ")", ")", "return", "reg", ";", "if", "(", "TARGET_THUMB2", ")", "{", "for", "(", "reg", "=", "FIRST_HI_REGNUM", ";", "reg", "<", "15", ";", "reg", "++", ")", "if", "(", "pushed_regs_mask", "&", "(", "1", "<<", "reg", ")", ")", "return", "reg", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Find", "a", "spare", "low", "register", "to", "use", "during", "the", "prolog", "of", "a", "function", "." ]

[ "arm", "1", "1", "15", "1" ]

[]

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

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

[ "AGC", "AGC" ]

[]

[ "<s>", "enum", "reg_class", "avr_reg_class_from_letter", "(", "int", "c", ")", "{", "switch", "(", "c", ")", "{", "case", "'t'", ":", "return", "R0_REG", ";", "case", "'b'", ":", "return", "BASE_POINTER_REGS", ";", "case", "'e'", ":", "return", "POINTER_REGS", ";", "case", "'w'", ":", "return", "ADDW_REGS", ";", "case", "'d'", ":", "return", "LD_REGS", ";", "case", "'l'", ":", "return", "NO_LD_REGS", ";", "case", "'a'", ":", "return", "SIMPLE_LD_REGS", ";", "case", "'x'", ":", "return", "POINTER_X_REGS", ";", "case", "'y'", ":", "return", "POINTER_Y_REGS", ";", "case", "'z'", ":", "return", "POINTER_Z_REGS", ";", "case", "'q'", ":", "return", "STACK_REG", ";", "default", ":", "break", ";", "}", "return", "NO_REGS", ";", "}", "</s>" ]

[ "A", "C", "expression", "which", "defines", "the", "machine-dependent", "operand", "constraint", "letters", "for", "register", "classes", ".", "If", "C", "is", "such", "a", "letter", ",", "the", "value", "should", "be", "the", "register", "class", "corresponding", "to", "it", ".", "Otherwise", ",", "the", "value", "should", "be", "`", "NO_REGS", "'", ".", "The", "register", "letter", "`", "r", "'", ",", "corresponding", "to", "class", "`", "GENERAL_REGS", "'", ",", "will", "not", "be", "passed", "to", "this", "macro", ";", "you", "do", "not", "need", "to", "handle", "it", "." ]

[ "avr" ]

[]

[ "<s>", "static", "int", "rs6000_hard_regno_nregs_internal", "(", "int", "regno", ",", "machine_mode", "mode", ")", "{", "unsigned", "HOST_WIDE_INT", "reg_size", ";", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "reg_size", "=", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "||", "FLOAT128_VECTOR_P", "(", "mode", ")", "?", "UNITS_PER_VSX_WORD", ":", "UNITS_PER_FP_WORD", ")", ";", "else", "if", "(", "SPE_SIMD_REGNO_P", "(", "regno", ")", "&&", "TARGET_SPE", "&&", "SPE_VECTOR_MODE", "(", "mode", ")", ")", "reg_size", "=", "UNITS_PER_SPE_WORD", ";", "else", "if", "(", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "reg_size", "=", "UNITS_PER_ALTIVEC_WORD", ";", "else", "if", "(", "TARGET_E500_DOUBLE", "&&", "FLOAT_MODE_P", "(", "mode", ")", "&&", "mode", "!=", "SCmode", "&&", "!", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", "&&", "SPE_SIMD_REGNO_P", "(", "regno", ")", ")", "reg_size", "=", "UNITS_PER_FP_WORD", ";", "else", "reg_size", "=", "UNITS_PER_WORD", ";", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "reg_size", "-", "1", ")", "/", "reg_size", ";", "}", "</s>" ]

[ "Return", "number", "of", "consecutive", "hard", "regs", "needed", "starting", "at", "reg", "REGNO", "to", "hold", "something", "of", "mode", "MODE", ".", "This", "is", "ordinarily", "the", "length", "in", "words", "of", "a", "value", "of", "mode", "MODE", "but", "can", "be", "less", "for", "certain", "modes", "in", "special", "long", "registers", ".", "POWER", "and", "PowerPC", "GPRs", "hold", "32", "bits", "worth", ";", "PowerPC64", "GPRs", "and", "FPRs", "point", "register", "holds", "64", "bits", "worth", "." ]

[ "rs6000", "1" ]

[]

[ "<s>", "bool", "AVRAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "llvm_unreachable", "(", "\"This branch is not implemented yet\"", ")", ";", "}", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "(", "void", ")", "MO", ";", "assert", "(", "MO", ".", "isReg", "(", ")", "&&", "\"Unexpected inline asm memory operand\"", ")", ";", "if", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", "==", "AVR", "::", "R31R30", ")", "{", "O", "<<", "\"Z\"", ";", "}", "else", "{", "assert", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", "==", "AVR", "::", "R29R28", "&&", "\"Wrong register class for memory operand.\"", ")", ";", "O", "<<", "\"Y\"", ";", "}", "unsigned", "OpFlags", "=", "MI", "->", "getOperand", "(", "OpNum", "-", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "NumOpRegs", "=", "InlineAsm", "::", "getNumOperandRegisters", "(", "OpFlags", ")", ";", "if", "(", "NumOpRegs", "==", "2", ")", "{", "O", "<<", "'+'", "<<", "MI", "->", "getOperand", "(", "OpNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "0", "\"This branch is not implemented yet\"", "\"Unexpected inline asm memory operand\"", "AVR::R31R30", "\"Z\"", "AVR::R29R28", "\"Wrong register class for memory operand.\"", "\"Y\"", "1", "2", "1" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", "=", "0", ")", "const", "override", "{", "return", "&", "TL45", "::", "GRRegsRegClass", ";", "}", "</s>" ]

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

[ "TL45", "0", "TL45::GRRegsRegClass" ]

[]

[ "<s>", "static", "rtx", "visium_libcall_value", "(", "enum", "machine_mode", "mode", ",", "const_rtx", "fun", "ATTRIBUTE_UNUSED", ")", "{", "return", "visium_function_value_1", "(", "mode", ")", ";", "}", "</s>" ]

[ "Return", "an", "RTX", "representing", "the", "place", "where", "the", "library", "function", "result", "will", "be", "returned", "." ]

[ "visium" ]

[]

[ "<s>", "const", "uint16_t", "*", "WDC65816RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "return", "CSR_NoRegs_SaveList", ";", "}", "</s>" ]

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

[ "WDC65816", "WDC" ]

[]

[ "<s>", "static", "void", "splitBlock", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineInstr", "&", "MI", ",", "MachineDominatorTree", "*", "MDT", ")", "{", "MachineBasicBlock", "*", "SplitBB", "=", "MBB", ".", "splitAt", "(", "MI", ",", "true", ")", ";", "using", "DomTreeT", "=", "DomTreeBase", "<", "MachineBasicBlock", ">", ";", "SmallVector", "<", "DomTreeT", "::", "UpdateType", ",", "16", ">", "DTUpdates", ";", "for", "(", "MachineBasicBlock", "*", "Succ", ":", "SplitBB", "->", "successors", "(", ")", ")", "{", "DTUpdates", ".", "push_back", "(", "{", "DomTreeT", "::", "Insert", ",", "SplitBB", ",", "Succ", "}", ")", ";", "DTUpdates", ".", "push_back", "(", "{", "DomTreeT", "::", "Delete", ",", "&", "MBB", ",", "Succ", "}", ")", ";", "}", "DTUpdates", ".", "push_back", "(", "{", "DomTreeT", "::", "Insert", ",", "&", "MBB", ",", "SplitBB", "}", ")", ";", "MDT", "->", "getBase", "(", ")", ".", "applyUpdates", "(", "DTUpdates", ")", ";", "}", "</s>" ]

[ "splitBlock", "-", "BB", "is", "split", "and", "now", "it", "has", "one", "successor", "." ]

[ "AMDGPU", "16" ]

[]

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

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

[ "AGC", "AGC", "AGC" ]

[]

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

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

[ "ARM64" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "areInlineCompatible", "(", "const", "Function", "*", "Caller", ",", "const", "Function", "*", "Callee", ")", "const", "{", "const", "TargetMachine", "&", "TM", "=", "getTLI", "(", ")", "->", "getTargetMachine", "(", ")", ";", "const", "FeatureBitset", "&", "CallerBits", "=", "TM", ".", "getSubtargetImpl", "(", "*", "Caller", ")", "->", "getFeatureBits", "(", ")", ";", "const", "FeatureBitset", "&", "CalleeBits", "=", "TM", ".", "getSubtargetImpl", "(", "*", "Callee", ")", "->", "getFeatureBits", "(", ")", ";", "FeatureBitset", "RealCallerBits", "=", "CallerBits", "&", "~", "InlineFeatureIgnoreList", ";", "FeatureBitset", "RealCalleeBits", "=", "CalleeBits", "&", "~", "InlineFeatureIgnoreList", ";", "if", "(", "RealCallerBits", "==", "RealCalleeBits", ")", "return", "true", ";", "if", "(", "(", "RealCallerBits", "&", "RealCalleeBits", ")", "!=", "RealCalleeBits", ")", "return", "false", ";", "for", "(", "const", "Instruction", "&", "I", ":", "instructions", "(", "Callee", ")", ")", "{", "if", "(", "const", "auto", "*", "CB", "=", "dyn_cast", "<", "CallBase", ">", "(", "&", "I", ")", ")", "{", "SmallVector", "<", "Type", "*", ",", "8", ">", "Types", ";", "for", "(", "Value", "*", "Arg", ":", "CB", "->", "args", "(", ")", ")", "Types", ".", "push_back", "(", "Arg", "->", "getType", "(", ")", ")", ";", "if", "(", "!", "CB", "->", "getType", "(", ")", "->", "isVoidTy", "(", ")", ")", "Types", ".", "push_back", "(", "CB", "->", "getType", "(", ")", ")", ";", "auto", "IsSimpleTy", "=", "[", "]", "(", "Type", "*", "Ty", ")", "{", "return", "!", "Ty", "->", "isVectorTy", "(", ")", "&&", "!", "Ty", "->", "isAggregateType", "(", ")", ";", "}", ";", "if", "(", "all_of", "(", "Types", ",", "IsSimpleTy", ")", ")", "continue", ";", "if", "(", "Function", "*", "NestedCallee", "=", "CB", "->", "getCalledFunction", "(", ")", ")", "{", "if", "(", "NestedCallee", "->", "isIntrinsic", "(", ")", ")", "continue", ";", "if", "(", "!", "areTypesABICompatible", "(", "Caller", ",", "NestedCallee", ",", "Types", ")", ")", "return", "false", ";", "}", "else", "{", "return", "false", ";", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

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

[]

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

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

[ "CellSPU", "SPU", "SPU", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 DAG->DAG Instruction Selection\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 DAG->DAG Instruction Selection\"" ]

[]

[ "<s>", "static", "void", "rename_fma_node", "(", "fma_forest", "*", "forest", ",", "fma_node", "*", "node", ")", "{", "node", "->", "rename", "(", "forest", ")", ";", "}", "</s>" ]

[ "Wrapper", "around", "fma_node", ":", ":dump_info", "for", "use", "as", "parameter", "of", "function", "pointer", "type", "in", "func_fma_steering", ":", ":dfs", "." ]

[ "aarch64" ]

[]

[ "<s>", "uint32_t", "ARMMCCodeEmitter", "::", "getBranchTargetOpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpIdx", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "if", "(", "isThumb2", "(", ")", ")", "return", "::", "getBranchTargetOpValue", "(", "MI", ",", "OpIdx", ",", "ARM", "::", "fixup_t2_condbranch", ",", "Fixups", ")", ";", "return", "getARMBranchTargetOpValue", "(", "MI", ",", "OpIdx", ",", "Fixups", ")", ";", "}", "</s>" ]

[ "getBranchTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "branch", "target", "operand", "." ]

[ "ARM", "ARM", "ARM::fixup_t2_condbranch", "ARM" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "getPreIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "DisablePPCPreinc", ")", "return", "false", ";", "SDValue", "Ptr", ";", "EVT", "VT", ";", "if", "(", "LoadSDNode", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ")", "{", "Ptr", "=", "LD", "->", "getBasePtr", "(", ")", ";", "VT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "}", "else", "if", "(", "StoreSDNode", "*", "ST", "=", "dyn_cast", "<", "StoreSDNode", ">", "(", "N", ")", ")", "{", "Ptr", "=", "ST", "->", "getBasePtr", "(", ")", ";", "VT", "=", "ST", "->", "getMemoryVT", "(", ")", ";", "}", "else", "return", "false", ";", "if", "(", "VT", ".", "isVector", "(", ")", ")", "return", "false", ";", "if", "(", "SelectAddressRegReg", "(", "Ptr", ",", "Offset", ",", "Base", ",", "DAG", ")", ")", "{", "AM", "=", "ISD", "::", "PRE_INC", ";", "return", "true", ";", "}", "if", "(", "VT", "!=", "MVT", "::", "i64", ")", "{", "if", "(", "!", "SelectAddressRegImm", "(", "Ptr", ",", "Offset", ",", "Base", ",", "DAG", ")", ")", "return", "false", ";", "}", "else", "{", "if", "(", "!", "SelectAddressRegImmShift", "(", "Ptr", ",", "Offset", ",", "Base", ",", "DAG", ")", ")", "return", "false", ";", "}", "if", "(", "LoadSDNode", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ")", "{", "if", "(", "LD", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i64", "&&", "LD", "->", "getMemoryVT", "(", ")", "==", "MVT", "::", "i32", "&&", "LD", "->", "getExtensionType", "(", ")", "==", "ISD", "::", "SEXTLOAD", "&&", "isa", "<", "ConstantSDNode", ">", "(", "Offset", ")", ")", "return", "false", ";", "}", "AM", "=", "ISD", "::", "PRE_INC", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "the", "node", "'s", "address", "can", "be", "legally", "represented", "as", "pre-indexed", "load", "/", "store", "address", "." ]

[ "PowerPC", "PPC", "ISD::MemIndexedMode", "PPC", "ISD::PRE_INC", "MVT::i64", "0", "MVT::i64", "MVT::i32", "ISD::SEXTLOAD", "ISD::PRE_INC" ]

[]

[ "<s>", "const", "char", "*", "PPCTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "case", "PPCISD", "::", "FSEL", ":", "return", "\"PPCISD::FSEL\"", ";", "case", "PPCISD", "::", "FCFID", ":", "return", "\"PPCISD::FCFID\"", ";", "case", "PPCISD", "::", "FCTIDZ", ":", "return", "\"PPCISD::FCTIDZ\"", ";", "case", "PPCISD", "::", "FCTIWZ", ":", "return", "\"PPCISD::FCTIWZ\"", ";", "case", "PPCISD", "::", "STFIWX", ":", "return", "\"PPCISD::STFIWX\"", ";", "case", "PPCISD", "::", "VMADDFP", ":", "return", "\"PPCISD::VMADDFP\"", ";", "case", "PPCISD", "::", "VNMSUBFP", ":", "return", "\"PPCISD::VNMSUBFP\"", ";", "case", "PPCISD", "::", "VPERM", ":", "return", "\"PPCISD::VPERM\"", ";", "case", "PPCISD", "::", "Hi", ":", "return", "\"PPCISD::Hi\"", ";", "case", "PPCISD", "::", "Lo", ":", "return", "\"PPCISD::Lo\"", ";", "case", "PPCISD", "::", "TOC_ENTRY", ":", "return", "\"PPCISD::TOC_ENTRY\"", ";", "case", "PPCISD", "::", "TOC_RESTORE", ":", "return", "\"PPCISD::TOC_RESTORE\"", ";", "case", "PPCISD", "::", "LOAD", ":", "return", "\"PPCISD::LOAD\"", ";", "case", "PPCISD", "::", "LOAD_TOC", ":", "return", "\"PPCISD::LOAD_TOC\"", ";", "case", "PPCISD", "::", "DYNALLOC", ":", "return", "\"PPCISD::DYNALLOC\"", ";", "case", "PPCISD", "::", "GlobalBaseReg", ":", "return", "\"PPCISD::GlobalBaseReg\"", ";", "case", "PPCISD", "::", "SRL", ":", "return", "\"PPCISD::SRL\"", ";", "case", "PPCISD", "::", "SRA", ":", "return", "\"PPCISD::SRA\"", ";", "case", "PPCISD", "::", "SHL", ":", "return", "\"PPCISD::SHL\"", ";", "case", "PPCISD", "::", "EXTSW_32", ":", "return", "\"PPCISD::EXTSW_32\"", ";", "case", "PPCISD", "::", "STD_32", ":", "return", "\"PPCISD::STD_32\"", ";", "case", "PPCISD", "::", "CALL_SVR4", ":", "return", "\"PPCISD::CALL_SVR4\"", ";", "case", "PPCISD", "::", "CALL_NOP_SVR4", ":", "return", "\"PPCISD::CALL_NOP_SVR4\"", ";", "case", "PPCISD", "::", "CALL_Darwin", ":", "return", "\"PPCISD::CALL_Darwin\"", ";", "case", "PPCISD", "::", "NOP", ":", "return", "\"PPCISD::NOP\"", ";", "case", "PPCISD", "::", "MTCTR", ":", "return", "\"PPCISD::MTCTR\"", ";", "case", "PPCISD", "::", "BCTRL_Darwin", ":", "return", "\"PPCISD::BCTRL_Darwin\"", ";", "case", "PPCISD", "::", "BCTRL_SVR4", ":", "return", "\"PPCISD::BCTRL_SVR4\"", ";", "case", "PPCISD", "::", "RET_FLAG", ":", "return", "\"PPCISD::RET_FLAG\"", ";", "case", "PPCISD", "::", "MFCR", ":", "return", "\"PPCISD::MFCR\"", ";", "case", "PPCISD", "::", "VCMP", ":", "return", "\"PPCISD::VCMP\"", ";", "case", "PPCISD", "::", "VCMPo", ":", "return", "\"PPCISD::VCMPo\"", ";", "case", "PPCISD", "::", "LBRX", ":", "return", "\"PPCISD::LBRX\"", ";", "case", "PPCISD", "::", "STBRX", ":", "return", "\"PPCISD::STBRX\"", ";", "case", "PPCISD", "::", "LARX", ":", "return", "\"PPCISD::LARX\"", ";", "case", "PPCISD", "::", "STCX", ":", "return", "\"PPCISD::STCX\"", ";", "case", "PPCISD", "::", "COND_BRANCH", ":", "return", "\"PPCISD::COND_BRANCH\"", ";", "case", "PPCISD", "::", "MFFS", ":", "return", "\"PPCISD::MFFS\"", ";", "case", "PPCISD", "::", "MTFSB0", ":", "return", "\"PPCISD::MTFSB0\"", ";", "case", "PPCISD", "::", "MTFSB1", ":", "return", "\"PPCISD::MTFSB1\"", ";", "case", "PPCISD", "::", "FADDRTZ", ":", "return", "\"PPCISD::FADDRTZ\"", ";", "case", "PPCISD", "::", "MTFSF", ":", "return", "\"PPCISD::MTFSF\"", ";", "case", "PPCISD", "::", "TC_RETURN", ":", "return", "\"PPCISD::TC_RETURN\"", ";", "case", "PPCISD", "::", "CR6SET", ":", "return", "\"PPCISD::CR6SET\"", ";", "case", "PPCISD", "::", "CR6UNSET", ":", "return", "\"PPCISD::CR6UNSET\"", ";", "case", "PPCISD", "::", "ADDIS_TOC_HA", ":", "return", "\"PPCISD::ADDIS_TOC_HA\"", ";", "case", "PPCISD", "::", "LD_TOC_L", ":", "return", "\"PPCISD::LD_TOC_L\"", ";", "case", "PPCISD", "::", "ADDI_TOC_L", ":", "return", "\"PPCISD::ADDI_TOC_L\"", ";", "case", "PPCISD", "::", "ADDIS_GOT_TPREL_HA", ":", "return", "\"PPCISD::ADDIS_GOT_TPREL_HA\"", ";", "case", "PPCISD", "::", "LD_GOT_TPREL_L", ":", "return", "\"PPCISD::LD_GOT_TPREL_L\"", ";", "case", "PPCISD", "::", "ADD_TLS", ":", "return", "\"PPCISD::ADD_TLS\"", ";", "case", "PPCISD", "::", "ADDIS_TLSGD_HA", ":", "return", "\"PPCISD::ADDIS_TLSGD_HA\"", ";", "case", "PPCISD", "::", "ADDI_TLSGD_L", ":", "return", "\"PPCISD::ADDI_TLSGD_L\"", ";", "case", "PPCISD", "::", "GET_TLS_ADDR", ":", "return", "\"PPCISD::GET_TLS_ADDR\"", ";", "case", "PPCISD", "::", "ADDIS_TLSLD_HA", ":", "return", "\"PPCISD::ADDIS_TLSLD_HA\"", ";", "case", "PPCISD", "::", "ADDI_TLSLD_L", ":", "return", "\"PPCISD::ADDI_TLSLD_L\"", ";", "case", "PPCISD", "::", "GET_TLSLD_ADDR", ":", "return", "\"PPCISD::GET_TLSLD_ADDR\"", ";", "case", "PPCISD", "::", "ADDIS_DTPREL_HA", ":", "return", "\"PPCISD::ADDIS_DTPREL_HA\"", ";", "case", "PPCISD", "::", "ADDI_DTPREL_L", ":", "return", "\"PPCISD::ADDI_DTPREL_L\"", ";", "case", "PPCISD", "::", "VADD_SPLAT", ":", "return", "\"PPCISD::VADD_SPLAT\"", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC", "0", "PPCISD::FSEL", "\"PPCISD::FSEL\"", "PPCISD::FCFID", "\"PPCISD::FCFID\"", "PPCISD::FCTIDZ", "\"PPCISD::FCTIDZ\"", "PPCISD::FCTIWZ", "\"PPCISD::FCTIWZ\"", "PPCISD::STFIWX", "\"PPCISD::STFIWX\"", "PPCISD::VMADDFP", "\"PPCISD::VMADDFP\"", "PPCISD::VNMSUBFP", "\"PPCISD::VNMSUBFP\"", "PPCISD::VPERM", "\"PPCISD::VPERM\"", "PPCISD::Hi", "\"PPCISD::Hi\"", "PPCISD::Lo", "\"PPCISD::Lo\"", "PPCISD::TOC_ENTRY", "\"PPCISD::TOC_ENTRY\"", "PPCISD::TOC_RESTORE", "\"PPCISD::TOC_RESTORE\"", "PPCISD::LOAD", "\"PPCISD::LOAD\"", "PPCISD::LOAD_TOC", "\"PPCISD::LOAD_TOC\"", "PPCISD::DYNALLOC", "\"PPCISD::DYNALLOC\"", "PPCISD::GlobalBaseReg", "\"PPCISD::GlobalBaseReg\"", "PPCISD::SRL", "\"PPCISD::SRL\"", "PPCISD::SRA", "\"PPCISD::SRA\"", "PPCISD::SHL", "\"PPCISD::SHL\"", "PPCISD::EXTSW_32", "\"PPCISD::EXTSW_32\"", "PPCISD::STD_32", "\"PPCISD::STD_32\"", "PPCISD::CALL_SVR4", "\"PPCISD::CALL_SVR4\"", "PPCISD::CALL_NOP_SVR4", "\"PPCISD::CALL_NOP_SVR4\"", "PPCISD::CALL_Darwin", "\"PPCISD::CALL_Darwin\"", "PPCISD::NOP", "\"PPCISD::NOP\"", "PPCISD::MTCTR", "\"PPCISD::MTCTR\"", "PPCISD::BCTRL_Darwin", "\"PPCISD::BCTRL_Darwin\"", "PPCISD::BCTRL_SVR4", "\"PPCISD::BCTRL_SVR4\"", "PPCISD::RET_FLAG", "\"PPCISD::RET_FLAG\"", "PPCISD::MFCR", "\"PPCISD::MFCR\"", "PPCISD::VCMP", "\"PPCISD::VCMP\"", "PPCISD::VCMPo", "\"PPCISD::VCMPo\"", "PPCISD::LBRX", "\"PPCISD::LBRX\"", "PPCISD::STBRX", "\"PPCISD::STBRX\"", "PPCISD::LARX", "\"PPCISD::LARX\"", "PPCISD::STCX", "\"PPCISD::STCX\"", "PPCISD::COND_BRANCH", "\"PPCISD::COND_BRANCH\"", "PPCISD::MFFS", "\"PPCISD::MFFS\"", "PPCISD::MTFSB0", "\"PPCISD::MTFSB0\"", "PPCISD::MTFSB1", "\"PPCISD::MTFSB1\"", "PPCISD::FADDRTZ", "\"PPCISD::FADDRTZ\"", "PPCISD::MTFSF", "\"PPCISD::MTFSF\"", "PPCISD::TC_RETURN", "\"PPCISD::TC_RETURN\"", "PPCISD::CR6SET", "\"PPCISD::CR6SET\"", "PPCISD::CR6UNSET", "\"PPCISD::CR6UNSET\"", "PPCISD::ADDIS_TOC_HA", "\"PPCISD::ADDIS_TOC_HA\"", "PPCISD::LD_TOC_L", "\"PPCISD::LD_TOC_L\"", "PPCISD::ADDI_TOC_L", "\"PPCISD::ADDI_TOC_L\"", "PPCISD::ADDIS_GOT_TPREL_HA", "\"PPCISD::ADDIS_GOT_TPREL_HA\"", "PPCISD::LD_GOT_TPREL_L", "\"PPCISD::LD_GOT_TPREL_L\"", "PPCISD::ADD_TLS", "\"PPCISD::ADD_TLS\"", "PPCISD::ADDIS_TLSGD_HA", "\"PPCISD::ADDIS_TLSGD_HA\"", "PPCISD::ADDI_TLSGD_L", "\"PPCISD::ADDI_TLSGD_L\"", "PPCISD::GET_TLS_ADDR", "\"PPCISD::GET_TLS_ADDR\"", "PPCISD::ADDIS_TLSLD_HA", "\"PPCISD::ADDIS_TLSLD_HA\"", "PPCISD::ADDI_TLSLD_L", "\"PPCISD::ADDI_TLSLD_L\"", "PPCISD::GET_TLSLD_ADDR", "\"PPCISD::GET_TLSLD_ADDR\"", "PPCISD::ADDIS_DTPREL_HA", "\"PPCISD::ADDIS_DTPREL_HA\"", "PPCISD::ADDI_DTPREL_L", "\"PPCISD::ADDI_DTPREL_L\"", "PPCISD::VADD_SPLAT", "\"PPCISD::VADD_SPLAT\"" ]

[]

[ "<s>", "static", "rtx", "nvptx_gen_pack", "(", "rtx", "dst", ",", "rtx", "src0", ",", "rtx", "src1", ")", "{", "rtx", "res", ";", "switch", "(", "GET_MODE", "(", "dst", ")", ")", "{", "case", "E_DImode", ":", "res", "=", "gen_packsidi2", "(", "dst", ",", "src0", ",", "src1", ")", ";", "break", ";", "case", "E_DFmode", ":", "res", "=", "gen_packsidf2", "(", "dst", ",", "src0", ",", "src1", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "res", ";", "}", "</s>" ]

[ "Generate", "instruction", "(", "s", ")", "to", "pack", "2", "32", "bit", "objects", "into", "a", "64", "bit", "object", "." ]

[ "nvptx" ]

[]

[ "<s>", "static", "rtx", "vax_function_arg", "(", "cumulative_args_t", ",", "const", "function_arg_info", "&", ")", "{", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "On", "the", "VAX", "all", "args", "are", "pushed", "." ]

[ "vax" ]

[]

[ "<s>", "bool", "MipsSEFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "bool", "IsRAAndRetAddrIsTaken", "=", "(", "Reg", "==", "Mips", "::", "RA", "||", "Reg", "==", "Mips", "::", "RA_64", ")", "&&", "MF", "->", "getFrameInfo", "(", ")", ".", "isReturnAddressTaken", "(", ")", ";", "if", "(", "!", "IsRAAndRetAddrIsTaken", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "bool", "IsLOHI", "=", "(", "Reg", "==", "Mips", "::", "LO0", "||", "Reg", "==", "Mips", "::", "LO0_64", "||", "Reg", "==", "Mips", "::", "HI0", "||", "Reg", "==", "Mips", "::", "HI0_64", ")", ";", "const", "Function", "&", "Func", "=", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", ";", "if", "(", "IsLOHI", "&&", "Func", ".", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "{", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Op", "=", "0", ";", "if", "(", "!", "STI", ".", "getABI", "(", ")", ".", "ArePtrs64bit", "(", ")", ")", "{", "Op", "=", "(", "Reg", "==", "Mips", "::", "HI0", ")", "?", "Mips", "::", "MFHI", ":", "Mips", "::", "MFLO", ";", "Reg", "=", "Mips", "::", "K0", ";", "}", "else", "{", "Op", "=", "(", "Reg", "==", "Mips", "::", "HI0", ")", "?", "Mips", "::", "MFHI64", ":", "Mips", "::", "MFLO64", ";", "Reg", "=", "Mips", "::", "K0_64", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Op", ")", ",", "Mips", "::", "K0", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "bool", "IsKill", "=", "!", "IsRAAndRetAddrIsTaken", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "IsKill", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "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", "(", ")", "." ]

[ "Mips", "Mips", "0", "Mips::RA", "Mips::RA_64", "Mips::LO0", "Mips::LO0_64", "Mips::HI0", "Mips::HI0_64", "\"interrupt\"", "0", "Mips::HI0", "Mips::MFHI", "Mips::MFLO", "Mips::K0", "Mips::HI0", "Mips::MFHI64", "Mips::MFLO64", "Mips::K0_64", "Mips::K0" ]

[]

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

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

[ "WDC65816", "\"WDC65816 Assembly Printer\"" ]

[]

[ "<s>", "void", "reset", "(", ")", "{", "Packet", ".", "clear", "(", ")", ";", "ResourcesModel", "->", "clearResources", "(", ")", ";", "}", "</s>" ]

[ "Reset", "an", "existing", "scalar", "value", "for", "Def", "and", "a", "given", "Instance", "." ]

[ "Hexagon" ]

[]

[ "<s>", "int", "sh_attr_renesas_p", "(", "tree", "td", ")", "{", "if", "(", "TARGET_HITACHI", ")", "return", "1", ";", "if", "(", "td", "==", "0", ")", "return", "0", ";", "if", "(", "DECL_P", "(", "td", ")", ")", "td", "=", "TREE_TYPE", "(", "td", ")", ";", "if", "(", "td", "==", "error_mark_node", ")", "return", "0", ";", "return", "(", "lookup_attribute", "(", "\"renesas\"", ",", "TYPE_ATTRIBUTES", "(", "td", ")", ")", "!=", "NULL_TREE", ")", ";", "}", "</s>" ]

[ "True", "if", "__attribute__", "(", "(", "renesas", ")", ")", "or", "-mrenesas", "." ]

[ "sh", "1", "0", "0", "0", "\"renesas\"" ]

[]

[ "<s>", "static", "rtx", "altivec_expand_dst_builtin", "(", "tree", "exp", ",", "rtx", "target", "ATTRIBUTE_UNUSED", ",", "bool", "*", "expandedp", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "enum", "rs6000_builtins", "fcode", "=", "(", "enum", "rs6000_builtins", ")", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "tree", "arg0", ",", "arg1", ",", "arg2", ";", "machine_mode", "mode0", ",", "mode1", ";", "rtx", "pat", ",", "op0", ",", "op1", ",", "op2", ";", "const", "struct", "builtin_description", "*", "d", ";", "size_t", "i", ";", "*", "expandedp", "=", "false", ";", "d", "=", "bdesc_dst", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "bdesc_dst", ")", ";", "i", "++", ",", "d", "++", ")", "if", "(", "d", "->", "code", "==", "fcode", ")", "{", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "arg1", "=", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ";", "arg2", "=", "CALL_EXPR_ARG", "(", "exp", ",", "2", ")", ";", "op0", "=", "expand_normal", "(", "arg0", ")", ";", "op1", "=", "expand_normal", "(", "arg1", ")", ";", "op2", "=", "expand_normal", "(", "arg2", ")", ";", "mode0", "=", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "mode1", "=", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "1", "]", ".", "mode", ";", "if", "(", "arg0", "==", "error_mark_node", "||", "arg1", "==", "error_mark_node", "||", "arg2", "==", "error_mark_node", ")", "return", "const0_rtx", ";", "*", "expandedp", "=", "true", ";", "STRIP_NOPS", "(", "arg2", ")", ";", "if", "(", "TREE_CODE", "(", "arg2", ")", "!=", "INTEGER_CST", "||", "TREE_INT_CST_LOW", "(", "arg2", ")", "&", "~", "0x3", ")", "{", "error", "(", "\"argument to %qs must be a 2-bit unsigned literal\"", ",", "d", "->", "name", ")", ";", "return", "const0_rtx", ";", "}", "if", "(", "!", "(", "*", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "0", "]", ".", "predicate", ")", "(", "op0", ",", "mode0", ")", ")", "op0", "=", "copy_to_mode_reg", "(", "Pmode", ",", "op0", ")", ";", "if", "(", "!", "(", "*", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "1", "]", ".", "predicate", ")", "(", "op1", ",", "mode1", ")", ")", "op1", "=", "copy_to_mode_reg", "(", "mode1", ",", "op1", ")", ";", "pat", "=", "GEN_FCN", "(", "d", "->", "icode", ")", "(", "op0", ",", "op1", ",", "op2", ")", ";", "if", "(", "pat", "!=", "0", ")", "emit_insn", "(", "pat", ")", ";", "return", "NULL_RTX", ";", "}", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Expand", "the", "dst", "builtins", "." ]

[ "powerpcspe", "0", "0", "0", "1", "2", "0", "1", "0x3", "\"argument to %qs must be a 2-bit unsigned literal\"", "0", "1", "0" ]

[]

[ "<s>", "void", "VEFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "assert", "(", "isLeafProc", "(", "MF", ")", "&&", "\"TODO implement for non-leaf procs\"", ")", ";", "}", "</s>" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

[ "VE", "VE", "\"TODO implement for non-leaf procs\"" ]

[]

[ "<s>", "static", "void", "dump_forest_info", "(", "fma_forest", "*", "forest", ")", "{", "forest", "->", "dump_info", "(", ")", ";", "}", "</s>" ]

[ "Wrapper", "around", "fma_forest", ":", ":dump_info", "for", "use", "as", "parameter", "of", "function", "pointer", "type", "in", "func_fma_steering", ":", ":dfs", "." ]

[ "aarch64" ]

[]

[ "<s>", "int", "xtensa_emit_move_sequence", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", ")", "{", "rtx", "src", "=", "operands", "[", "1", "]", ";", "if", "(", "CONSTANT_P", "(", "src", ")", "&&", "(", "GET_CODE", "(", "src", ")", "!=", "CONST_INT", "||", "!", "xtensa_simm12b", "(", "INTVAL", "(", "src", ")", ")", ")", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "if", "(", "xtensa_tls_referenced_p", "(", "src", ")", ")", "{", "rtx", "addend", "=", "NULL", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "==", "PLUS", ")", "{", "addend", "=", "XEXP", "(", "XEXP", "(", "src", ",", "0", ")", ",", "1", ")", ";", "src", "=", "XEXP", "(", "XEXP", "(", "src", ",", "0", ")", ",", "0", ")", ";", "}", "src", "=", "xtensa_legitimize_tls_address", "(", "src", ")", ";", "if", "(", "addend", ")", "{", "src", "=", "gen_rtx_PLUS", "(", "mode", ",", "src", ",", "addend", ")", ";", "src", "=", "force_operand", "(", "src", ",", "dst", ")", ";", "}", "emit_move_insn", "(", "dst", ",", "src", ")", ";", "return", "1", ";", "}", "if", "(", "!", "TARGET_AUTO_LITPOOLS", "&&", "!", "TARGET_CONST16", ")", "{", "if", "(", "optimize_size", "&&", "mode", "==", "SImode", "&&", "CONST_INT_P", "(", "src", ")", "&&", "register_operand", "(", "dst", ",", "mode", ")", ")", "{", "HOST_WIDE_INT", "srcval", "=", "INTVAL", "(", "src", ")", ";", "int", "shift", "=", "ctz_hwi", "(", "srcval", ")", ";", "if", "(", "xtensa_simm12b", "(", "srcval", ">>", "shift", ")", ")", "{", "emit_move_insn", "(", "dst", ",", "GEN_INT", "(", "srcval", ">>", "shift", ")", ")", ";", "emit_insn", "(", "gen_ashlsi3_internal", "(", "dst", ",", "dst", ",", "GEN_INT", "(", "shift", ")", ")", ")", ";", "return", "1", ";", "}", "}", "src", "=", "force_const_mem", "(", "SImode", ",", "src", ")", ";", "operands", "[", "1", "]", "=", "src", ";", "}", "if", "(", "mode", "!=", "SImode", ")", "{", "if", "(", "register_operand", "(", "dst", ",", "mode", ")", ")", "{", "emit_move_insn", "(", "simplify_gen_subreg", "(", "SImode", ",", "dst", ",", "mode", ",", "0", ")", ",", "src", ")", ";", "return", "1", ";", "}", "else", "{", "src", "=", "force_reg", "(", "SImode", ",", "src", ")", ";", "src", "=", "gen_lowpart_SUBREG", "(", "mode", ",", "src", ")", ";", "operands", "[", "1", "]", "=", "src", ";", "}", "}", "}", "if", "(", "!", "(", "reload_in_progress", "|", "reload_completed", ")", "&&", "!", "xtensa_valid_move", "(", "mode", ",", "operands", ")", ")", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "operands", "[", "1", "]", "=", "xtensa_copy_incoming_a7", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "reload_in_progress", ")", "{", "operands", "[", "0", "]", "=", "fixup_subreg_mem", "(", "operands", "[", "0", "]", ")", ";", "operands", "[", "1", "]", "=", "fixup_subreg_mem", "(", "operands", "[", "1", "]", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Emit", "insns", "to", "move", "operands", "[", "1", "]", "into", "operands", "[", "0", "]", ".", "Return", "1", "if", "we", "have", "written", "out", "everything", "that", "needs", "to", "be", "done", "to", "do", "the", "move", ".", "Otherwise", ",", "return", "0", "and", "the", "caller", "will", "emit", "the", "move", "normally", "." ]

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

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"MIPS: Optimize calls to math library functions.\"", ";", "}", "</s>" ]

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

[ "Mips", "\"MIPS: Optimize calls to math library functions.\"" ]

[]

[ "<s>", "int", "ix86_expand_fp_movcc", "(", "rtx", "operands", "[", "]", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "1", "]", ")", ";", "rtx", "tmp", ",", "compare_op", ",", "second_test", ",", "bypass_test", ";", "if", "(", "TARGET_SSE_MATH", "&&", "SSE_FLOAT_MODE_P", "(", "mode", ")", ")", "{", "enum", "machine_mode", "cmode", ";", "cmode", "=", "GET_MODE", "(", "ix86_compare_op0", ")", ";", "if", "(", "cmode", "==", "VOIDmode", ")", "cmode", "=", "GET_MODE", "(", "ix86_compare_op1", ")", ";", "if", "(", "cmode", "!=", "mode", ")", "return", "0", ";", "code", "=", "ix86_prepare_sse_fp_compare_args", "(", "operands", "[", "0", "]", ",", "code", ",", "&", "ix86_compare_op0", ",", "&", "ix86_compare_op1", ")", ";", "if", "(", "code", "==", "UNKNOWN", ")", "return", "0", ";", "if", "(", "ix86_expand_sse_fp_minmax", "(", "operands", "[", "0", "]", ",", "code", ",", "ix86_compare_op0", ",", "ix86_compare_op1", ",", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ")", ")", "return", "1", ";", "tmp", "=", "ix86_expand_sse_cmp", "(", "operands", "[", "0", "]", ",", "code", ",", "ix86_compare_op0", ",", "ix86_compare_op1", ",", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ")", ";", "ix86_expand_sse_movcc", "(", "operands", "[", "0", "]", ",", "tmp", ",", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ")", ";", "return", "1", ";", "}", "compare_op", "=", "ix86_expand_compare", "(", "code", ",", "&", "second_test", ",", "&", "bypass_test", ")", ";", "if", "(", "!", "fcmov_comparison_operator", "(", "compare_op", ",", "VOIDmode", ")", ")", "{", "gcc_assert", "(", "!", "second_test", "&&", "!", "bypass_test", ")", ";", "tmp", "=", "gen_reg_rtx", "(", "QImode", ")", ";", "ix86_expand_setcc", "(", "code", ",", "tmp", ")", ";", "code", "=", "NE", ";", "ix86_compare_op0", "=", "tmp", ";", "ix86_compare_op1", "=", "const0_rtx", ";", "compare_op", "=", "ix86_expand_compare", "(", "code", ",", "&", "second_test", ",", "&", "bypass_test", ")", ";", "}", "if", "(", "bypass_test", "&&", "reg_overlap_mentioned_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "3", "]", ")", ")", "{", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_move_insn", "(", "tmp", ",", "operands", "[", "3", "]", ")", ";", "operands", "[", "3", "]", "=", "tmp", ";", "}", "if", "(", "second_test", "&&", "reg_overlap_mentioned_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ")", ")", "{", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_move_insn", "(", "tmp", ",", "operands", "[", "2", "]", ")", ";", "operands", "[", "2", "]", "=", "tmp", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operands", "[", "0", "]", ",", "gen_rtx_IF_THEN_ELSE", "(", "mode", ",", "compare_op", ",", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ")", ")", ")", ";", "if", "(", "bypass_test", ")", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operands", "[", "0", "]", ",", "gen_rtx_IF_THEN_ELSE", "(", "mode", ",", "bypass_test", ",", "operands", "[", "3", "]", ",", "operands", "[", "0", "]", ")", ")", ")", ";", "if", "(", "second_test", ")", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operands", "[", "0", "]", ",", "gen_rtx_IF_THEN_ELSE", "(", "mode", ",", "second_test", ",", "operands", "[", "2", "]", ",", "operands", "[", "0", "]", ")", ")", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Expand", "a", "floating-point", "conditional", "move", ".", "Return", "true", "if", "successful", "." ]

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

[]

[ "<s>", "static", "void", "load_pic_register", "(", "bool", "delay_pic_helper", "ATTRIBUTE_UNUSED", ")", "{", "int", "orig_flag_pic", "=", "flag_pic", ";", "rtx", "got_symbol", "=", "tilegx_got_symbol", "(", ")", ";", "rtx", "text_label_symbol", "=", "tilegx_text_label_symbol", "(", ")", ";", "rtx", "text_label_rtx", "=", "tilegx_text_label_rtx", "(", ")", ";", "flag_pic", "=", "0", ";", "if", "(", "TARGET_32BIT", ")", "{", "emit_insn", "(", "gen_insn_lnk_and_label_32bit", "(", "text_label_rtx", ",", "text_label_symbol", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_insn_lnk_and_label", "(", "text_label_rtx", ",", "text_label_symbol", ")", ")", ";", "}", "tilegx_compute_pcrel_address", "(", "tilegx_got_rtx", "(", ")", ",", "got_symbol", ")", ";", "flag_pic", "=", "orig_flag_pic", ";", "emit_use", "(", "tilegx_got_rtx", "(", ")", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "load", "the", "PIC", "register", "." ]

[ "tilegx", "0" ]

[]

[ "<s>", "unsigned", "PPCTargetLowering", "::", "getByValTypeAlignment", "(", "Type", "*", "Ty", ",", "const", "DataLayout", "&", "DL", ")", "const", "{", "if", "(", "Subtarget", ".", "isDarwin", "(", ")", ")", "return", "4", ";", "unsigned", "Align", "=", "Subtarget", ".", "isPPC64", "(", ")", "?", "8", ":", "4", ";", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", "||", "Subtarget", ".", "hasQPX", "(", ")", ")", "getMaxByValAlign", "(", "Ty", ",", "Align", ",", "Subtarget", ".", "hasQPX", "(", ")", "?", "32", ":", "16", ")", ";", "return", "Align", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "4", "PPC", "8", "4", "32", "16" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "NyuziRegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "return", "&", "Nyuzi", "::", "GPR32RegClass", ";", "}", "</s>" ]

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

[ "Nyuzi", "Nyuzi", "Nyuzi::GPR32RegClass" ]

[]

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

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

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

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ",", "Instruction", "*", "I", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "if", "(", "!", "isInt", "<", "12", ">", "(", "AM", ".", "BaseOffs", ")", ")", "return", "false", ";", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "break", ";", "case", "1", ":", "if", "(", "!", "AM", ".", "HasBaseReg", ")", "break", ";", "return", "false", ";", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "12", "0", "1" ]

[]

[ "<s>", "int", "ix86_can_use_return_insn_p", "(", "void", ")", "{", "struct", "ix86_frame", "frame", ";", "if", "(", "!", "reload_completed", "||", "frame_pointer_needed", ")", "return", "0", ";", "if", "(", "current_function_pops_args", "&&", "current_function_args_size", ">=", "32768", ")", "return", "0", ";", "ix86_compute_frame_layout", "(", "&", "frame", ")", ";", "return", "frame", ".", "to_allocate", "==", "0", "&&", "frame", ".", "nregs", "==", "0", ";", "}", "</s>" ]

[ "Return", "1", "if", "it", "is", "appropriate", "to", "emit", "`", "ret", "'", "instructions", "in", "the", "body", "of", "a", "function", ".", "Do", "this", "only", "if", "the", "epilogue", "is", "simple", ",", "needing", "a", "couple", "of", "insns", ".", "Prior", "to", "reloading", ",", "we", "ca", "n't", "tell", "how", "many", "registers", "must", "be", "saved", ",", "so", "return", "0", "then", ".", "Return", "0", "if", "there", "is", "no", "frame", "marker", "to", "de-allocate", "." ]

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

[]

[ "<s>", "static", "unsigned", "int", "aarch64_classify_vector_mode", "(", "machine_mode", "mode", ")", "{", "if", "(", "aarch64_advsimd_struct_mode_p", "(", "mode", ")", ")", "return", "VEC_ADVSIMD", "|", "VEC_STRUCT", ";", "if", "(", "aarch64_sve_pred_mode_p", "(", "mode", ")", ")", "return", "VEC_SVE_PRED", ";", "scalar_mode", "inner", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", "&&", "(", "inner", "==", "QImode", "||", "inner", "==", "HImode", "||", "inner", "==", "HFmode", "||", "inner", "==", "SImode", "||", "inner", "==", "SFmode", "||", "inner", "==", "DImode", "||", "inner", "==", "DFmode", ")", ")", "{", "if", "(", "TARGET_SVE", ")", "{", "if", "(", "known_eq", "(", "GET_MODE_BITSIZE", "(", "mode", ")", ",", "BITS_PER_SVE_VECTOR", ")", ")", "return", "VEC_SVE_DATA", ";", "if", "(", "known_eq", "(", "GET_MODE_BITSIZE", "(", "mode", ")", ",", "BITS_PER_SVE_VECTOR", "*", "2", ")", "||", "known_eq", "(", "GET_MODE_BITSIZE", "(", "mode", ")", ",", "BITS_PER_SVE_VECTOR", "*", "3", ")", "||", "known_eq", "(", "GET_MODE_BITSIZE", "(", "mode", ")", ",", "BITS_PER_SVE_VECTOR", "*", "4", ")", ")", "return", "VEC_SVE_DATA", "|", "VEC_STRUCT", ";", "}", "if", "(", "TARGET_SIMD", "&&", "(", "known_eq", "(", "GET_MODE_BITSIZE", "(", "mode", ")", ",", "64", ")", "||", "known_eq", "(", "GET_MODE_BITSIZE", "(", "mode", ")", ",", "128", ")", ")", ")", "return", "VEC_ADVSIMD", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "a", "set", "of", "flags", "describing", "the", "vector", "properties", "of", "mode", "MODE", ".", "Ignore", "modes", "that", "are", "not", "supported", "by", "the", "current", "target", "." ]

[ "aarch64", "2", "3", "4", "64", "128", "0" ]

[]

[ "<s>", "void", "addFastRegAlloc", "(", ")", "override", "{", "addPass", "(", "createTPCExpandHWRegCopies", "(", ")", ")", ";", "addPass", "(", "&", "LiveVariablesID", ",", "false", ")", ";", "addPass", "(", "&", "PHIEliminationID", ",", "false", ")", ";", "addPass", "(", "&", "TwoAddressInstructionPassID", ",", "false", ")", ";", "addPass", "(", "&", "RegisterCoalescerID", ")", ";", "addPass", "(", "createRegAllocPass", "(", "true", ")", ")", ";", "addPreRewrite", "(", ")", ";", "addPass", "(", "&", "VirtRegRewriterID", ")", ";", "}", "</s>" ]

[ "addFastRegAlloc", "-", "Add", "the", "minimum", "set", "of", "target-independent", "passes", "that", "are", "required", "for", "fast", "register", "allocation", "." ]

[ "TPC", "TPC" ]

[]

[ "<s>", "bool", "SystemZMCAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "for", "(", "uint64_t", "I", "=", "0", ";", "I", "!=", "Count", ";", "++", "I", ")", "OS", "<<", "'\\x7'", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AArch64AsmBackend", "::", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "if", "(", "Count", "%", "4", "!=", "0", ")", "return", "false", ";", "uint64_t", "NumNops", "=", "Count", "/", "4", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "!=", "NumNops", ";", "++", "i", ")", "OW", "->", "Write32", "(", "0xd503201f", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "4", "0", "4", "0", "0xd503201f" ]

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "Module", "::", "GlobalListType", "&", "global_list", "=", "M", ".", "getGlobalList", "(", ")", ";", "int", "i", ",", "n", "=", "global_list", ".", "size", "(", ")", ";", "GlobalVariable", "*", "*", "gv_array", "=", "new", "GlobalVariable", "*", "[", "n", "]", ";", "i", "=", "0", ";", "for", "(", "Module", "::", "global_iterator", "I", "=", "global_list", ".", "begin", "(", ")", ",", "E", "=", "global_list", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "gv_array", "[", "i", "++", "]", "=", "&", "*", "I", ";", "while", "(", "!", "global_list", ".", "empty", "(", ")", ")", "global_list", ".", "remove", "(", "global_list", ".", "begin", "(", ")", ")", ";", "bool", "ret", "=", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "global_list", ".", "insert", "(", "global_list", ".", "end", "(", ")", ",", "gv_array", "[", "i", "]", ")", ";", "delete", "[", "]", "gv_array", ";", "return", "ret", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "getPreIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "DisablePPCPreinc", ")", "return", "false", ";", "bool", "isLoad", "=", "true", ";", "SDValue", "Ptr", ";", "EVT", "VT", ";", "unsigned", "Alignment", ";", "if", "(", "LoadSDNode", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ")", "{", "Ptr", "=", "LD", "->", "getBasePtr", "(", ")", ";", "VT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "Alignment", "=", "LD", "->", "getAlignment", "(", ")", ";", "}", "else", "if", "(", "StoreSDNode", "*", "ST", "=", "dyn_cast", "<", "StoreSDNode", ">", "(", "N", ")", ")", "{", "Ptr", "=", "ST", "->", "getBasePtr", "(", ")", ";", "VT", "=", "ST", "->", "getMemoryVT", "(", ")", ";", "Alignment", "=", "ST", "->", "getAlignment", "(", ")", ";", "isLoad", "=", "false", ";", "}", "else", "return", "false", ";", "if", "(", "VT", ".", "isVector", "(", ")", ")", "{", "if", "(", "!", "Subtarget", ".", "hasQPX", "(", ")", "||", "(", "VT", "!=", "MVT", "::", "v4f64", "&&", "VT", "!=", "MVT", "::", "v4f32", ")", ")", "{", "return", "false", ";", "}", "else", "if", "(", "SelectAddressRegRegOnly", "(", "Ptr", ",", "Offset", ",", "Base", ",", "DAG", ")", ")", "{", "AM", "=", "ISD", "::", "PRE_INC", ";", "return", "true", ";", "}", "}", "if", "(", "SelectAddressRegReg", "(", "Ptr", ",", "Base", ",", "Offset", ",", "DAG", ")", ")", "{", "bool", "Swap", "=", "false", ";", "if", "(", "isa", "<", "FrameIndexSDNode", ">", "(", "Base", ")", "||", "isa", "<", "RegisterSDNode", ">", "(", "Base", ")", ")", "Swap", "=", "true", ";", "else", "if", "(", "!", "isLoad", ")", "{", "SDValue", "Val", "=", "cast", "<", "StoreSDNode", ">", "(", "N", ")", "->", "getValue", "(", ")", ";", "if", "(", "Val", "==", "Base", "||", "Base", ".", "getNode", "(", ")", "->", "isPredecessorOf", "(", "Val", ".", "getNode", "(", ")", ")", ")", "Swap", "=", "true", ";", "}", "if", "(", "Swap", ")", "std", "::", "swap", "(", "Base", ",", "Offset", ")", ";", "AM", "=", "ISD", "::", "PRE_INC", ";", "return", "true", ";", "}", "if", "(", "VT", "!=", "MVT", "::", "i64", ")", "{", "if", "(", "!", "SelectAddressRegImm", "(", "Ptr", ",", "Offset", ",", "Base", ",", "DAG", ",", "false", ")", ")", "return", "false", ";", "}", "else", "{", "if", "(", "Alignment", "<", "4", ")", "return", "false", ";", "if", "(", "!", "SelectAddressRegImm", "(", "Ptr", ",", "Offset", ",", "Base", ",", "DAG", ",", "true", ")", ")", "return", "false", ";", "}", "if", "(", "LoadSDNode", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ")", "{", "if", "(", "LD", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i64", "&&", "LD", "->", "getMemoryVT", "(", ")", "==", "MVT", "::", "i32", "&&", "LD", "->", "getExtensionType", "(", ")", "==", "ISD", "::", "SEXTLOAD", "&&", "isa", "<", "ConstantSDNode", ">", "(", "Offset", ")", ")", "return", "false", ";", "}", "AM", "=", "ISD", "::", "PRE_INC", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "the", "node", "'s", "address", "can", "be", "legally", "represented", "as", "pre-indexed", "load", "/", "store", "address", "." ]

[ "PowerPC", "PPC", "ISD::MemIndexedMode", "PPC", "MVT::v4f64", "MVT::v4f32", "ISD::PRE_INC", "ISD::PRE_INC", "MVT::i64", "4", "0", "MVT::i64", "MVT::i32", "ISD::SEXTLOAD", "ISD::PRE_INC" ]

[]

[ "<s>", "bool", "ARMOptimizeBarriersPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "std", "::", "vector", "<", "MachineInstr", "*", ">", "ToRemove", ";", "int64_t", "DMBType", "=", "-", "1", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "bool", "IsRemovableNextDMB", "=", "false", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "DMB", ")", "{", "if", "(", "IsRemovableNextDMB", ")", "{", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", "==", "DMBType", ")", "{", "ToRemove", ".", "push_back", "(", "&", "MI", ")", ";", "}", "else", "{", "DMBType", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "}", "}", "else", "{", "IsRemovableNextDMB", "=", "true", ";", "DMBType", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "}", "}", "else", "if", "(", "!", "CanMovePastDMB", "(", "&", "MI", ")", ")", "{", "IsRemovableNextDMB", "=", "false", ";", "}", "}", "}", "for", "(", "auto", "MI", ":", "ToRemove", ")", "{", "MI", "->", "eraseFromParent", "(", ")", ";", "++", "NumDMBsRemoved", ";", "}", "return", "NumDMBsRemoved", ">", "0", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "1", "ARM::DMB", "0", "0", "0", "0" ]

[]

[ "<s>", "rtx", "nds32_legitimize_tls_address", "(", "rtx", "x", ")", "{", "rtx", "tmp_reg", ";", "rtx", "tp_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "TP_REGNUM", ")", ";", "rtx", "pat", ",", "insns", ",", "reg0", ";", "int", "relax_group_id", "=", "nds32_alloc_relax_group_id", "(", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "switch", "(", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ")", "{", "case", "TLS_MODEL_GLOBAL_DYNAMIC", ":", "case", "TLS_MODEL_LOCAL_DYNAMIC", ":", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "==", "TLS_MODEL_GLOBAL_DYNAMIC", ")", "pat", "=", "gen_rtx_UNSPEC", "(", "SImode", ",", "gen_rtvec", "(", "1", ",", "x", ")", ",", "UNSPEC_TLSGD", ")", ";", "else", "pat", "=", "gen_rtx_UNSPEC", "(", "SImode", ",", "gen_rtvec", "(", "1", ",", "x", ")", ",", "UNSPEC_TLSLD", ")", ";", "pat", "=", "gen_rtx_CONST", "(", "SImode", ",", "pat", ")", ";", "reg0", "=", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ";", "insns", "=", "emit_call_insn", "(", "gen_tls_desc", "(", "pat", ",", "GEN_INT", "(", "relax_group_id", ")", ")", ")", ";", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insns", ")", ",", "pic_offset_table_rtx", ")", ";", "RTL_CONST_CALL_P", "(", "insns", ")", "=", "1", ";", "tmp_reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_move_insn", "(", "tmp_reg", ",", "reg0", ")", ";", "x", "=", "tmp_reg", ";", "break", ";", "case", "TLS_MODEL_INITIAL_EXEC", ":", "pat", "=", "gen_rtx_UNSPEC", "(", "SImode", ",", "gen_rtvec", "(", "1", ",", "x", ")", ",", "UNSPEC_TLSIE", ")", ";", "tmp_reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "pat", "=", "gen_rtx_CONST", "(", "SImode", ",", "pat", ")", ";", "emit_insn", "(", "gen_tls_ie", "(", "tmp_reg", ",", "pat", ",", "GEN_INT", "(", "relax_group_id", ")", ")", ")", ";", "if", "(", "flag_pic", ")", "emit_use", "(", "pic_offset_table_rtx", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "tmp_reg", ",", "tp_reg", ")", ";", "break", ";", "case", "TLS_MODEL_LOCAL_EXEC", ":", "tmp_reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "pat", "=", "gen_rtx_UNSPEC", "(", "SImode", ",", "gen_rtvec", "(", "1", ",", "x", ")", ",", "UNSPEC_TLSLE", ")", ";", "pat", "=", "gen_rtx_CONST", "(", "SImode", ",", "pat", ")", ";", "emit_insn", "(", "gen_tls_le", "(", "tmp_reg", ",", "pat", ",", "GEN_INT", "(", "relax_group_id", ")", ")", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "tmp_reg", ",", "tp_reg", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "{", "rtx", "base", ",", "addend", ";", "split_const", "(", "x", ",", "&", "base", ",", "&", "addend", ")", ";", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "base", ")", "==", "TLS_MODEL_LOCAL_EXEC", ")", "{", "tmp_reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "pat", "=", "gen_rtx_UNSPEC", "(", "SImode", ",", "gen_rtvec", "(", "1", ",", "base", ")", ",", "UNSPEC_TLSLE", ")", ";", "pat", "=", "gen_rtx_PLUS", "(", "SImode", ",", "pat", ",", "addend", ")", ";", "pat", "=", "gen_rtx_CONST", "(", "SImode", ",", "pat", ")", ";", "emit_insn", "(", "gen_tls_le", "(", "tmp_reg", ",", "pat", ",", "GEN_INT", "(", "relax_group_id", ")", ")", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "tmp_reg", ",", "tp_reg", ")", ";", "}", "}", "return", "x", ";", "}", "</s>" ]

[ "ADDR", "contains", "a", "thread-local", "SYMBOL_REF", ".", "Generate", "code", "to", "compute", "this", "(", "thread-local", ")", "address", "." ]

[ "nds32", "1", "1", "0", "1", "1", "1", "1" ]

[]

[ "<s>", "static", "int", "compare_sign_p", "(", "rtx", "insn", ")", "{", "RTX_CODE", "cond", "=", "compare_condition", "(", "insn", ")", ";", "return", "(", "cond", "==", "GE", "||", "cond", "==", "LT", ")", ";", "}", "</s>" ]

[ "Returns", "nonzero", "if", "INSN", "is", "a", "tst", "insn", "that", "only", "tests", "the", "sign", "." ]

[ "avr" ]

[]