Datasets:

docz-ict

/

ComBack

like 3

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "return", "createARM64ELFObjectWriter", "(", "OS", ",", "OSABI", ",", "IsLittleEndian", ")", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64" ]

[]

[ "<s>", "bool", "OptimizeLEAPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changed", "=", "false", ";", "if", "(", "!", "EnableX86LEAOpt", "||", "!", "MF", ".", "getFunction", "(", ")", "->", "optForSize", "(", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "SmallVector", "<", "MachineInstr", "*", ",", "16", ">", "LEAs", ";", "InstrPos", ".", "clear", "(", ")", ";", "findLEAs", "(", "MBB", ",", "LEAs", ")", ";", "if", "(", "LEAs", ".", "empty", "(", ")", ")", "continue", ";", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "optForMinSize", "(", ")", ")", "Changed", "|=", "removeRedundantLEAs", "(", "LEAs", ")", ";", "Changed", "|=", "removeRedundantAddrCalc", "(", "LEAs", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "i386_pe_seh_cold_init", "(", "FILE", "*", "f", ",", "const", "char", "*", "name", ")", "{", "struct", "seh_frame_state", "*", "seh", ";", "HOST_WIDE_INT", "alloc_offset", ",", "offset", ";", "if", "(", "!", "TARGET_SEH", ")", "return", ";", "if", "(", "cfun", "->", "is_thunk", ")", "return", ";", "seh", "=", "cfun", "->", "machine", "->", "seh", ";", "fputs", "(", "\"\\t.seh_proc\\t\"", ",", "f", ")", ";", "assemble_name", "(", "f", ",", "name", ")", ";", "fputc", "(", "'\\n'", ",", "f", ")", ";", "offset", "=", "seh", "->", "sp_offset", "-", "INCOMING_FRAME_SP_OFFSET", ";", "if", "(", "offset", "<", "SEH_MAX_FRAME_SIZE", "&&", "!", "crtl", "->", "accesses_prior_frames", ")", "alloc_offset", "=", "seh", "->", "sp_offset", ";", "else", "alloc_offset", "=", "MIN", "(", "seh", "->", "cfa_offset", "+", "240", ",", "seh", "->", "sp_offset", ")", ";", "offset", "=", "alloc_offset", "-", "INCOMING_FRAME_SP_OFFSET", ";", "if", "(", "offset", ">", "0", ")", "fprintf", "(", "f", ",", "\"\\t.seh_stackalloc\\t\"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "offset", ")", ";", "for", "(", "int", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "seh", "->", "reg_offset", "[", "regno", "]", ">", "0", "&&", "seh", "->", "reg_offset", "[", "regno", "]", "<=", "alloc_offset", ")", "{", "if", "(", "SSE_REGNO_P", "(", "regno", ")", ")", "fputs", "(", "\"\\t.seh_savexmm\\t\"", ",", "f", ")", ";", "else", "if", "(", "GENERAL_REGNO_P", "(", "regno", ")", ")", "fputs", "(", "\"\\t.seh_savereg\\t\"", ",", "f", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "print_reg", "(", "gen_rtx_REG", "(", "DImode", ",", "regno", ")", ",", "0", ",", "f", ")", ";", "fprintf", "(", "f", ",", "\", \"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "alloc_offset", "-", "seh", "->", "reg_offset", "[", "regno", "]", ")", ";", "}", "if", "(", "seh", "->", "cfa_reg", "!=", "stack_pointer_rtx", ")", "{", "offset", "=", "alloc_offset", "-", "seh", "->", "cfa_offset", ";", "gcc_assert", "(", "(", "offset", "&", "15", ")", "==", "0", ")", ";", "gcc_assert", "(", "IN_RANGE", "(", "offset", ",", "0", ",", "240", ")", ")", ";", "fputs", "(", "\"\\t.seh_setframe\\t\"", ",", "f", ")", ";", "print_reg", "(", "seh", "->", "cfa_reg", ",", "0", ",", "f", ")", ";", "fprintf", "(", "f", ",", "\", \"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "offset", ")", ";", "}", "if", "(", "alloc_offset", "!=", "seh", "->", "sp_offset", ")", "{", "offset", "=", "seh", "->", "sp_offset", "-", "alloc_offset", ";", "if", "(", "offset", ">", "0", "&&", "offset", "<", "SEH_MAX_FRAME_SIZE", ")", "fprintf", "(", "f", ",", "\"\\t.seh_stackalloc\\t\"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "offset", ")", ";", "for", "(", "int", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "seh", "->", "reg_offset", "[", "regno", "]", ">", "alloc_offset", ")", "{", "if", "(", "SSE_REGNO_P", "(", "regno", ")", ")", "fputs", "(", "\"\\t.seh_savexmm\\t\"", ",", "f", ")", ";", "else", "if", "(", "GENERAL_REGNO_P", "(", "regno", ")", ")", "fputs", "(", "\"\\t.seh_savereg\\t\"", ",", "f", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "print_reg", "(", "gen_rtx_REG", "(", "DImode", ",", "regno", ")", ",", "0", ",", "f", ")", ";", "fprintf", "(", "f", ",", "\", \"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "seh", "->", "sp_offset", "-", "seh", "->", "reg_offset", "[", "regno", "]", ")", ";", "}", "}", "fputs", "(", "\"\\t.seh_endprologue\\n\"", ",", "f", ")", ";", "}", "</s>" ]

[ "Emit", "assembler", "directives", "to", "reconstruct", "the", "SEH", "state", "." ]

[ "i386", "\"\\t.seh_proc\\t\"", "240", "0", "\"\\t.seh_stackalloc\\t\"", "\"\\n\"", "0", "0", "\"\\t.seh_savexmm\\t\"", "\"\\t.seh_savereg\\t\"", "0", "\", \"", "\"\\n\"", "15", "0", "0", "240", "\"\\t.seh_setframe\\t\"", "0", "\", \"", "\"\\n\"", "0", "\"\\t.seh_stackalloc\\t\"", "\"\\n\"", "0", "\"\\t.seh_savexmm\\t\"", "\"\\t.seh_savereg\\t\"", "0", "\", \"", "\"\\n\"", "\"\\t.seh_endprologue\\n\"" ]

[]

[ "<s>", "void", "avr_pass_pre_proep", "::", "compute_maybe_gasisr", "(", "function", "*", "fun", ")", "{", "for", "(", "rtx_insn", "*", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "CALL_P", "(", "insn", ")", ")", "return", ";", "if", "(", "AVR_HAVE_JMP_CALL", "&&", "JUMP_TABLE_DATA_P", "(", "insn", ")", ")", "return", ";", "if", "(", "JUMP_P", "(", "insn", ")", "&&", "find_reg_note", "(", "insn", ",", "REG_NON_LOCAL_GOTO", ",", "NULL_RTX", ")", ")", "return", ";", "}", "fun", "->", "machine", "->", "gasisr", ".", "maybe", "=", "1", ";", "}", "</s>" ]

[ "Set", "fun-", ">", "machine-", ">", "gasisr.maybe", "provided", "we", "do", "n't", "find", "anything", "that", "prohibits", "GAS", "generating", "parts", "of", "ISR", "prologues", "/", "epilogues", "for", "us", "." ]

[ "avr", "1" ]

[]

[ "<s>", "static", "int", "spu_builtin_vectorization_cost", "(", "enum", "vect_cost_for_stmt", "type_of_cost", ",", "tree", "vectype", ",", "int", "misalign", "ATTRIBUTE_UNUSED", ")", "{", "unsigned", "elements", ";", "switch", "(", "type_of_cost", ")", "{", "case", "scalar_stmt", ":", "case", "vector_stmt", ":", "case", "vector_load", ":", "case", "vector_store", ":", "case", "vec_to_scalar", ":", "case", "scalar_to_vec", ":", "case", "cond_branch_not_taken", ":", "case", "vec_perm", ":", "case", "vec_promote_demote", ":", "return", "1", ";", "case", "scalar_store", ":", "return", "10", ";", "case", "scalar_load", ":", "return", "2", ";", "case", "unaligned_load", ":", "return", "2", ";", "case", "cond_branch_taken", ":", "return", "6", ";", "case", "vec_construct", ":", "elements", "=", "TYPE_VECTOR_SUBPARTS", "(", "vectype", ")", ";", "return", "elements", "/", "2", "+", "1", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Implement", "targetm.vectorize.builtin_vectorization_cost", "." ]

[ "spu", "1", "10", "2", "2", "6", "2", "1" ]

[]

[ "<s>", "static", "bool", "set_to_load_agen", "(", "rtx_insn", "*", "out_insn", ",", "rtx_insn", "*", "in_insn", ")", "{", "rtx", "out_set", ",", "in_set", ";", "out_set", "=", "single_set", "(", "out_insn", ")", ";", "if", "(", "out_set", ")", "{", "in_set", "=", "single_set", "(", "in_insn", ")", ";", "if", "(", "in_set", ")", "return", "reg_mentioned_p", "(", "SET_DEST", "(", "out_set", ")", ",", "SET_SRC", "(", "in_set", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "The", "function", "returns", "true", "if", "out_inst", "sets", "a", "value", "that", "is", "used", "in", "the", "address", "generation", "computation", "of", "in_insn" ]

[ "rs6000" ]

[]

[ "<s>", "static", "tree", "mips_builtin_decl", "(", "unsigned", "int", "code", ",", "bool", "initialize_p", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "code", ">=", "ARRAY_SIZE", "(", "mips_builtins", ")", ")", "return", "error_mark_node", ";", "return", "mips_builtin_decls", "[", "code", "]", ";", "}", "</s>" ]

[ "Implement", "TARGET_BUILTIN_DECL", "." ]

[ "mips" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "ARCInstrInfo", "::", "loadImmediate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "Reg", ",", "uint64_t", "Value", ")", "const", "{", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "if", "(", "isInt", "<", "12", ">", "(", "Value", ")", ")", "{", "return", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "ARC", "::", "MOV_rs12", ")", ",", "Reg", ")", ".", "addImm", "(", "Value", ")", ".", "getInstr", "(", ")", ";", "}", "llvm_unreachable", "(", "\"Need Arc long immediate instructions.\"", ")", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "12", "ARC::MOV_rs12", "\"Need Arc long immediate instructions.\"" ]

[]

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

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

[ "PowerPC" ]

[]

[ "<s>", "bool", "GCNTTIImpl", "::", "isAlwaysUniform", "(", "const", "Value", "*", "V", ")", "const", "{", "if", "(", "const", "IntrinsicInst", "*", "Intrinsic", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "V", ")", ")", "{", "switch", "(", "Intrinsic", "->", "getIntrinsicID", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Intrinsic", "::", "amdgcn_readfirstlane", ":", "case", "Intrinsic", "::", "amdgcn_readlane", ":", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Whether", "Val", "will", "always", "return", "a", "uniform", "value", "regardless", "of", "its", "operands", "." ]

[ "AMDGPU", "Intrinsic::amdgcn_readfirstlane", "Intrinsic::amdgcn_readlane" ]

[]

[ "<s>", "void", "calculate", "(", ")", "{", "BlockVector", "WorkList", ";", "BlockSet", "AddedToWorkList", ";", "Blocks", ".", "insert", "(", "Entry", ")", ";", "for", "(", "auto", "*", "Pred", ":", "Entry", "->", "predecessors", "(", ")", ")", "{", "if", "(", "!", "Enterers", ".", "count", "(", "Pred", ")", ")", "{", "WorkList", ".", "push_back", "(", "Pred", ")", ";", "AddedToWorkList", ".", "insert", "(", "Pred", ")", ";", "}", "}", "while", "(", "!", "WorkList", ".", "empty", "(", ")", ")", "{", "auto", "*", "MBB", "=", "WorkList", ".", "pop_back_val", "(", ")", ";", "assert", "(", "!", "Enterers", ".", "count", "(", "MBB", ")", ")", ";", "if", "(", "Blocks", ".", "insert", "(", "MBB", ")", ".", "second", ")", "{", "for", "(", "auto", "*", "Pred", ":", "MBB", "->", "predecessors", "(", ")", ")", "{", "if", "(", "!", "AddedToWorkList", ".", "count", "(", "Pred", ")", ")", "{", "WorkList", ".", "push_back", "(", "Pred", ")", ";", "AddedToWorkList", ".", "insert", "(", "Pred", ")", ";", "}", "}", "}", "}", "}", "</s>" ]

[ "calculate", "-", "compute", "block", "frequency", "info", "for", "the", "given", "function", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "const", "MachineOperand", "*", "getNamedOperand", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OpName", ")", "const", "{", "return", "getNamedOperand", "(", "const_cast", "<", "MachineInstr", "&", ">", "(", "MI", ")", ",", "OpName", ")", ";", "}", "</s>" ]

[ "Returns", "the", "operand", "named", "Op", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "R600InstrInfo", "::", "addFlag", "(", "MachineInstr", "*", "MI", ",", "unsigned", "Operand", ",", "unsigned", "Flag", ")", "const", "{", "unsigned", "TargetFlags", "=", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ".", "TSFlags", ";", "if", "(", "Flag", "==", "0", ")", "{", "return", ";", "}", "if", "(", "HAS_NATIVE_OPERANDS", "(", "TargetFlags", ")", ")", "{", "MachineOperand", "&", "FlagOp", "=", "getFlagOp", "(", "MI", ",", "Operand", ",", "Flag", ")", ";", "if", "(", "Flag", "==", "MO_FLAG_NOT_LAST", ")", "{", "clearFlag", "(", "MI", ",", "Operand", ",", "MO_FLAG_LAST", ")", ";", "}", "else", "if", "(", "Flag", "==", "MO_FLAG_MASK", ")", "{", "clearFlag", "(", "MI", ",", "Operand", ",", "Flag", ")", ";", "}", "else", "{", "FlagOp", ".", "setImm", "(", "1", ")", ";", "}", "}", "else", "{", "MachineOperand", "&", "FlagOp", "=", "getFlagOp", "(", "MI", ",", "Operand", ")", ";", "FlagOp", ".", "setImm", "(", "FlagOp", ".", "getImm", "(", ")", "|", "(", "Flag", "<<", "(", "NUM_MO_FLAGS", "*", "Operand", ")", ")", ")", ";", "}", "}", "</s>" ]

[ "Add", "one", "of", "the", "MO_FLAG", "*", "flags", "to", "the", "specified", "Operand", "." ]

[ "R600", "0", "1" ]

[]

[ "<s>", "unsigned", "char", "X86Subtarget", "::", "classifyGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "GV", "&&", "GV", "->", "isAbsoluteSymbolRef", "(", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "TM", ".", "shouldAssumeDSOLocal", "(", "M", ",", "GV", ")", ")", "return", "classifyLocalReference", "(", "GV", ")", ";", "if", "(", "isTargetCOFF", "(", ")", ")", "return", "X86II", "::", "MO_DLLIMPORT", ";", "if", "(", "is64Bit", "(", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "if", "(", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "!", "isPositionIndependent", "(", ")", ")", "return", "X86II", "::", "MO_DARWIN_NONLAZY", ";", "return", "X86II", "::", "MO_DARWIN_NONLAZY_PIC_BASE", ";", "}", "return", "X86II", "::", "MO_GOT", ";", "}", "</s>" ]

[ "Classify", "a", "global", "variable", "reference", "for", "the", "current", "subtarget", "according", "to", "how", "we", "should", "reference", "it", "in", "a", "non-pcrel", "context", "." ]

[ "X86", "X86", "X86II::MO_NO_FLAG", "X86II::MO_NO_FLAG", "X86II::MO_DLLIMPORT", "X86II::MO_GOTPCREL", "X86II::MO_DARWIN_NONLAZY", "X86II::MO_DARWIN_NONLAZY_PIC_BASE", "X86II::MO_GOT" ]

[]

[ "<s>", "static", "void", "mep_setup_incoming_varargs", "(", "cumulative_args_t", "cum", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "tree", "type", "ATTRIBUTE_UNUSED", ",", "int", "*", "pretend_size", ",", "int", "second_time", "ATTRIBUTE_UNUSED", ")", "{", "int", "nsave", "=", "4", "-", "(", "get_cumulative_args", "(", "cum", ")", "->", "nregs", "+", "1", ")", ";", "if", "(", "nsave", ">", "0", ")", "cfun", "->", "machine", "->", "arg_regs_to_save", "=", "nsave", ";", "*", "pretend_size", "=", "nsave", "*", "4", ";", "}", "</s>" ]

[ "Function", "args", "in", "registers", "." ]

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

[]

[ "<s>", "int", "rl78_hard_regno_nregs", "(", "int", "regno", ",", "machine_mode", "mode", ")", "{", "int", "rs", "=", "register_sizes", "[", "regno", "]", ";", "if", "(", "rs", "<", "1", ")", "rs", "=", "1", ";", "return", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "rs", "-", "1", ")", "/", "rs", ")", ";", "}", "</s>" ]

[ "Implements", "HARD_REGNO_NREGS", "." ]

[ "rl78", "1", "1", "1" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "X86RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "assert", "(", "MF", "&&", "\"MachineFunction required\"", ")", ";", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "bool", "HasSSE", "=", "Subtarget", ".", "hasSSE1", "(", ")", ";", "bool", "HasAVX", "=", "Subtarget", ".", "hasAVX", "(", ")", ";", "bool", "HasAVX512", "=", "Subtarget", ".", "hasAVX512", "(", ")", ";", "bool", "CallsEHReturn", "=", "MF", "->", "callsEHReturn", "(", ")", ";", "switch", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ")", "{", "case", "CallingConv", "::", "GHC", ":", "case", "CallingConv", "::", "HiPE", ":", "return", "CSR_NoRegs_SaveList", ";", "case", "CallingConv", "::", "AnyReg", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_SaveList", ";", "return", "CSR_64_AllRegs_SaveList", ";", "case", "CallingConv", "::", "PreserveMost", ":", "return", "CSR_64_RT_MostRegs_SaveList", ";", "case", "CallingConv", "::", "PreserveAll", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_RT_AllRegs_AVX_SaveList", ";", "return", "CSR_64_RT_AllRegs_SaveList", ";", "case", "CallingConv", "::", "CXX_FAST_TLS", ":", "if", "(", "Is64Bit", ")", "return", "MF", "->", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "isSplitCSR", "(", ")", "?", "CSR_64_CXX_TLS_Darwin_PE_SaveList", ":", "CSR_64_TLS_Darwin_SaveList", ";", "break", ";", "case", "CallingConv", "::", "Intel_OCL_BI", ":", "{", "if", "(", "HasAVX512", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX512_SaveList", ";", "if", "(", "HasAVX512", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX512_SaveList", ";", "if", "(", "HasAVX", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX_SaveList", ";", "if", "(", "HasAVX", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX_SaveList", ";", "if", "(", "!", "HasAVX", "&&", "!", "IsWin64", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_SaveList", ";", "break", ";", "}", "case", "CallingConv", "::", "HHVM", ":", "return", "CSR_64_HHVM_SaveList", ";", "case", "CallingConv", "::", "X86_RegCall", ":", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "{", "return", "(", "HasSSE", "?", "CSR_Win64_RegCall_SaveList", ":", "CSR_Win64_RegCall_NoSSE_SaveList", ")", ";", "}", "else", "{", "return", "(", "HasSSE", "?", "CSR_SysV64_RegCall_SaveList", ":", "CSR_SysV64_RegCall_NoSSE_SaveList", ")", ";", "}", "}", "else", "{", "return", "(", "HasSSE", "?", "CSR_32_RegCall_SaveList", ":", "CSR_32_RegCall_NoSSE_SaveList", ")", ";", "}", "case", "CallingConv", "::", "Cold", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_MostRegs_SaveList", ";", "break", ";", "case", "CallingConv", "::", "X86_64_Win64", ":", "if", "(", "!", "HasSSE", ")", "return", "CSR_Win64_NoSSE_SaveList", ";", "return", "CSR_Win64_SaveList", ";", "case", "CallingConv", "::", "X86_64_SysV", ":", "if", "(", "CallsEHReturn", ")", "return", "CSR_64EHRet_SaveList", ";", "return", "CSR_64_SaveList", ";", "case", "CallingConv", "::", "X86_INTR", ":", "if", "(", "Is64Bit", ")", "{", "if", "(", "HasAVX512", ")", "return", "CSR_64_AllRegs_AVX512_SaveList", ";", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_SaveList", ";", "return", "CSR_64_AllRegs_SaveList", ";", "}", "else", "{", "if", "(", "HasAVX512", ")", "return", "CSR_32_AllRegs_AVX512_SaveList", ";", "if", "(", "HasAVX", ")", "return", "CSR_32_AllRegs_AVX_SaveList", ";", "if", "(", "HasSSE", ")", "return", "CSR_32_AllRegs_SSE_SaveList", ";", "return", "CSR_32_AllRegs_SaveList", ";", "}", "default", ":", "break", ";", "}", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "{", "if", "(", "!", "HasSSE", ")", "return", "CSR_Win64_NoSSE_SaveList", ";", "return", "CSR_Win64_SaveList", ";", "}", "if", "(", "CallsEHReturn", ")", "return", "CSR_64EHRet_SaveList", ";", "if", "(", "Subtarget", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", "->", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_64_SwiftError_SaveList", ";", "return", "CSR_64_SaveList", ";", "}", "if", "(", "CallsEHReturn", ")", "return", "CSR_32EHRet_SaveList", ";", "return", "CSR_32_SaveList", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"MachineFunction required\"", "X86", "X86", "X86", "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "unsigned", "size", "(", ")", "const", "{", "return", "Uses", ".", "size", "(", ")", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "static", "int", "avr_operand_rtx_cost", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "enum", "rtx_code", "outer", ",", "int", "opno", ",", "bool", "speed", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "int", "total", ";", "switch", "(", "code", ")", "{", "case", "REG", ":", "case", "SUBREG", ":", "return", "0", ";", "case", "CONST_INT", ":", "case", "CONST_FIXED", ":", "case", "CONST_DOUBLE", ":", "return", "COSTS_N_INSNS", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "default", ":", "break", ";", "}", "total", "=", "0", ";", "avr_rtx_costs", "(", "x", ",", "code", ",", "outer", ",", "opno", ",", "&", "total", ",", "speed", ")", ";", "return", "total", ";", "}", "</s>" ]

[ "Mutually", "recursive", "subroutine", "of", "avr_rtx_cost", "for", "calculating", "the", "cost", "of", "an", "RTX", "operand", "given", "its", "context", ".", "X", "is", "the", "rtx", "of", "the", "operand", ",", "MODE", "is", "its", "mode", ",", "and", "OUTER", "is", "the", "rtx_code", "of", "this", "operand", "'s", "parent", "operator", "." ]

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

[]

[ "<s>", "int", "valid_dbcc_comparison_p_2", "(", "rtx", "x", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "EQ", ":", "case", "NE", ":", "case", "GTU", ":", "case", "LTU", ":", "case", "GEU", ":", "case", "LEU", ":", "return", "1", ";", "case", "GT", ":", "case", "LT", ":", "case", "GE", ":", "case", "LE", ":", "return", "!", "(", "cc_prev_status", ".", "flags", "&", "CC_NO_OVERFLOW", ")", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "comparison", "operator", "for", "the", "dbcc", "instruction", ".", "Note", "it", "rejects", "floating", "point", "comparison", "operators", ".", "(", "In", "the", "future", "we", "could", "use", "Fdbcc", ")", ".", "It", "also", "rejects", "some", "comparisons", "when", "CC_NO_OVERFLOW", "is", "set", "." ]

[ "m68k", "1", "0" ]

[]

[ "<s>", "static", "tree", "ix86_stack_protect_guard", "(", "void", ")", "{", "if", "(", "TARGET_SSP_TLS_GUARD", ")", "{", "tree", "type_node", "=", "lang_hooks", ".", "types", ".", "type_for_mode", "(", "ptr_mode", ",", "1", ")", ";", "int", "qual", "=", "ENCODE_QUAL_ADDR_SPACE", "(", "ix86_stack_protector_guard_reg", ")", ";", "tree", "type", "=", "build_qualified_type", "(", "type_node", ",", "qual", ")", ";", "tree", "t", ";", "if", "(", "OPTION_SET_P", "(", "ix86_stack_protector_guard_symbol_str", ")", ")", "{", "t", "=", "ix86_tls_stack_chk_guard_decl", ";", "if", "(", "t", "==", "NULL", ")", "{", "rtx", "x", ";", "t", "=", "build_decl", "(", "UNKNOWN_LOCATION", ",", "VAR_DECL", ",", "get_identifier", "(", "ix86_stack_protector_guard_symbol_str", ")", ",", "type", ")", ";", "TREE_STATIC", "(", "t", ")", "=", "1", ";", "TREE_PUBLIC", "(", "t", ")", "=", "1", ";", "DECL_EXTERNAL", "(", "t", ")", "=", "1", ";", "TREE_USED", "(", "t", ")", "=", "1", ";", "TREE_THIS_VOLATILE", "(", "t", ")", "=", "1", ";", "DECL_ARTIFICIAL", "(", "t", ")", "=", "1", ";", "DECL_IGNORED_P", "(", "t", ")", "=", "1", ";", "x", "=", "DECL_RTL", "(", "t", ")", ";", "RTX_FLAG", "(", "x", ",", "used", ")", "=", "1", ";", "ix86_tls_stack_chk_guard_decl", "=", "t", ";", "}", "}", "else", "{", "tree", "asptrtype", "=", "build_pointer_type", "(", "type", ")", ";", "t", "=", "build_int_cst", "(", "asptrtype", ",", "ix86_stack_protector_guard_offset", ")", ";", "t", "=", "build2", "(", "MEM_REF", ",", "asptrtype", ",", "t", ",", "build_int_cst", "(", "asptrtype", ",", "0", ")", ")", ";", "TREE_THIS_VOLATILE", "(", "t", ")", "=", "1", ";", "}", "return", "t", ";", "}", "return", "default_stack_protect_guard", "(", ")", ";", "}", "</s>" ]

[ "If", "using", "TLS", "guards", ",", "do", "n't", "waste", "time", "creating", "and", "expanding", "__stack_chk_guard", "decl", "and", "MEM", "as", "we", "are", "going", "to", "ignore", "it", "." ]

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

[]

[ "<s>", "void", "X86TargetLowering", "::", "insertCopiesSplitCSR", "(", "MachineBasicBlock", "*", "Entry", ",", "const", "SmallVectorImpl", "<", "MachineBasicBlock", "*", ">", "&", "Exits", ")", "const", "{", "const", "X86RegisterInfo", "*", "TRI", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "MCPhysReg", "*", "IStart", "=", "TRI", "->", "getCalleeSavedRegsViaCopy", "(", "Entry", "->", "getParent", "(", ")", ")", ";", "if", "(", "!", "IStart", ")", "return", ";", "const", "TargetInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "*", "MRI", "=", "&", "Entry", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "Entry", "->", "begin", "(", ")", ";", "for", "(", "const", "MCPhysReg", "*", "I", "=", "IStart", ";", "*", "I", ";", "++", "I", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "nullptr", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "*", "I", ")", ")", "RC", "=", "&", "X86", "::", "GR64RegClass", ";", "else", "llvm_unreachable", "(", "\"Unexpected register class in CSRsViaCopy!\"", ")", ";", "Register", "NewVR", "=", "MRI", "->", "createVirtualRegister", "(", "RC", ")", ";", "assert", "(", "Entry", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "NoUnwind", ")", "&&", "\"Function should be nounwind in insertCopiesSplitCSR!\"", ")", ";", "Entry", "->", "addLiveIn", "(", "*", "I", ")", ";", "BuildMI", "(", "*", "Entry", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "NewVR", ")", ".", "addReg", "(", "*", "I", ")", ";", "for", "(", "auto", "*", "Exit", ":", "Exits", ")", "BuildMI", "(", "*", "Exit", ",", "Exit", "->", "getFirstTerminator", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "*", "I", ")", ".", "addReg", "(", "NewVR", ")", ";", "}", "}", "</s>" ]

[ "Insert", "explicit", "copies", "in", "entry", "and", "exit", "blocks", "." ]

[ "X86", "X86", "X86", "X86::GR64RegClass", "X86::GR64RegClass", "\"Unexpected register class in CSRsViaCopy!\"", "\"Function should be nounwind in insertCopiesSplitCSR!\"" ]

[]

[ "<s>", "inline", "void", "function_expander", "::", "add_scalar_move_mask_operand", "(", "machine_mode", "mode", ")", "{", "add_input_operand", "(", "mode", ",", "gen_scalar_move_mask", "(", "mode", ")", ")", ";", "}", "</s>" ]

[ "Add", "mask", "operand", "for", "scalar", "move", "instruction", "." ]

[ "riscv" ]

[]

[ "<s>", "uint32_t", "AMDGPUDevice", "::", "getStackAlignment", "(", ")", "const", "{", "return", "16", ";", "}", "</s>" ]

[ "Returns", "the", "minimum", "alignment", "known", "to", "hold", "of", "the", "stack", "frame", "on", "entry", "to", "the", "function", "and", "which", "must", "be", "maintained", "by", "every", "function", "for", "this", "subtarget", "." ]

[ "R600", "16" ]

[]

[ "<s>", "bool", "SystemZFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "SystemZMachineFunctionInfo", "*", "ZFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "bool", "IsVarArg", "=", "MF", ".", "getFunction", "(", ")", ".", "isVarArg", "(", ")", ";", "DebugLoc", "DL", ";", "SystemZ", "::", "GPRRegs", "SpillGPRs", "=", "ZFI", "->", "getSpillGPRRegs", "(", ")", ";", "if", "(", "SpillGPRs", ".", "LowGPR", ")", "{", "assert", "(", "SpillGPRs", ".", "LowGPR", "!=", "SpillGPRs", ".", "HighGPR", "&&", "\"Should be saving %r15 and something else\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "SystemZ", "::", "STMG", ")", ")", ";", "addSavedGPR", "(", "MBB", ",", "MIB", ",", "SpillGPRs", ".", "LowGPR", ",", "false", ")", ";", "addSavedGPR", "(", "MBB", ",", "MIB", ",", "SpillGPRs", ".", "HighGPR", ",", "false", ")", ";", "MIB", ".", "addReg", "(", "SystemZ", "::", "R15D", ")", ".", "addImm", "(", "SpillGPRs", ".", "GPROffset", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "CSI", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "I", "]", ".", "getReg", "(", ")", ";", "if", "(", "SystemZ", "::", "GR64BitRegClass", ".", "contains", "(", "Reg", ")", ")", "addSavedGPR", "(", "MBB", ",", "MIB", ",", "Reg", ",", "true", ")", ";", "}", "if", "(", "IsVarArg", ")", "for", "(", "unsigned", "I", "=", "ZFI", "->", "getVarArgsFirstGPR", "(", ")", ";", "I", "<", "SystemZ", "::", "ELFNumArgGPRs", ";", "++", "I", ")", "addSavedGPR", "(", "MBB", ",", "MIB", ",", "SystemZ", "::", "ELFArgGPRs", "[", "I", "]", ",", "true", ")", ";", "}", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "CSI", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "I", "]", ".", "getReg", "(", ")", ";", "if", "(", "SystemZ", "::", "FP64BitRegClass", ".", "contains", "(", "Reg", ")", ")", "{", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "TII", "->", "storeRegToStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ",", "true", ",", "CSI", "[", "I", "]", ".", "getFrameIdx", "(", ")", ",", "&", "SystemZ", "::", "FP64BitRegClass", ",", "TRI", ")", ";", "}", "if", "(", "SystemZ", "::", "VR128BitRegClass", ".", "contains", "(", "Reg", ")", ")", "{", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "TII", "->", "storeRegToStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ",", "true", ",", "CSI", "[", "I", "]", ".", "getFrameIdx", "(", ")", ",", "&", "SystemZ", "::", "VR128BitRegClass", ",", "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", "(", ")", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ::GPRRegs", "\"Should be saving %r15 and something else\"", "SystemZ::STMG", "SystemZ::R15D", "0", "SystemZ::GR64BitRegClass", "SystemZ::ELFNumArgGPRs", "SystemZ::ELFArgGPRs", "0", "SystemZ::FP64BitRegClass", "SystemZ::FP64BitRegClass", "SystemZ::VR128BitRegClass", "SystemZ::VR128BitRegClass" ]

[]

[ "<s>", "std", "::", "pair", "<", "uint16_t", ",", "uint16_t", ">", "X86InstrInfo", "::", "getExecutionDomain", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "uint16_t", "domain", "=", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", ">>", "X86II", "::", "SSEDomainShift", ")", "&", "3", ";", "unsigned", "opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "uint16_t", "validDomains", "=", "0", ";", "if", "(", "domain", ")", "{", "validDomains", "=", "getExecutionDomainCustom", "(", "MI", ")", ";", "if", "(", "validDomains", ")", "return", "std", "::", "make_pair", "(", "domain", ",", "validDomains", ")", ";", "if", "(", "lookup", "(", "opcode", ",", "domain", ",", "ReplaceableInstrs", ")", ")", "{", "validDomains", "=", "0xe", ";", "}", "else", "if", "(", "lookup", "(", "opcode", ",", "domain", ",", "ReplaceableInstrsAVX2", ")", ")", "{", "validDomains", "=", "Subtarget", ".", "hasAVX2", "(", ")", "?", "0xe", ":", "0x6", ";", "}", "else", "if", "(", "lookup", "(", "opcode", ",", "domain", ",", "ReplaceableInstrsFP", ")", ")", "{", "validDomains", "=", "0x6", ";", "}", "else", "if", "(", "lookup", "(", "opcode", ",", "domain", ",", "ReplaceableInstrsAVX2InsertExtract", ")", ")", "{", "if", "(", "!", "Subtarget", ".", "hasAVX2", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0", ",", "0", ")", ";", "validDomains", "=", "0xe", ";", "}", "else", "if", "(", "lookupAVX512", "(", "opcode", ",", "domain", ",", "ReplaceableInstrsAVX512", ")", ")", "{", "validDomains", "=", "0xe", ";", "}", "else", "if", "(", "Subtarget", ".", "hasDQI", "(", ")", "&&", "lookupAVX512", "(", "opcode", ",", "domain", ",", "ReplaceableInstrsAVX512DQ", ")", ")", "{", "validDomains", "=", "0xe", ";", "}", "else", "if", "(", "Subtarget", ".", "hasDQI", "(", ")", ")", "{", "if", "(", "const", "uint16_t", "*", "table", "=", "lookupAVX512", "(", "opcode", ",", "domain", ",", "ReplaceableInstrsAVX512DQMasked", ")", ")", "{", "if", "(", "domain", "==", "1", "||", "(", "domain", "==", "3", "&&", "table", "[", "3", "]", "==", "opcode", ")", ")", "validDomains", "=", "0xa", ";", "else", "validDomains", "=", "0xc", ";", "}", "}", "}", "return", "std", "::", "make_pair", "(", "domain", ",", "validDomains", ")", ";", "}", "</s>" ]

[ "Return", "the", "current", "execution", "domain", "and", "bit", "mask", "of", "possible", "domains", "for", "instruction", "." ]

[ "X86", "X86", "X86II::SSEDomainShift", "3", "0", "0xe", "0xe", "0x6", "0x6", "0", "0", "0xe", "0xe", "0xe", "1", "3", "3", "0xa", "0xc" ]

[]

[ "<s>", "void", "TLCS900InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";", "if", "(", "RC", "==", "&", "TLCS900", "::", "GR16RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "TLCS900", "::", "MOV16mr", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "TLCS900", "::", "GR8RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "TLCS900", "::", "MOV8mr", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "llvm_unreachable", "(", "\"Cannot store this register to stack slot!\"", ")", ";", "}", "</s>" ]

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

[ "TLCS900", "TLCS900", "TLCS900::GR16RegClass", "TLCS900::MOV16mr", "0", "TLCS900::GR8RegClass", "TLCS900::MOV8mr", "0", "\"Cannot store this register to stack slot!\"" ]

[]

[ "<s>", "static", "void", "ix86_emit_support_tinfos", "(", "emit_support_tinfos_callback", "callback", ")", "{", "extern", "tree", "ix86_float16_type_node", ";", "extern", "tree", "ix86_bf16_type_node", ";", "if", "(", "!", "TARGET_SSE2", ")", "{", "gcc_checking_assert", "(", "!", "float16_type_node", "&&", "!", "bfloat16_type_node", ")", ";", "float16_type_node", "=", "ix86_float16_type_node", ";", "bfloat16_type_node", "=", "ix86_bf16_type_node", ";", "callback", "(", "float16_type_node", ")", ";", "callback", "(", "bfloat16_type_node", ")", ";", "float16_type_node", "=", "NULL_TREE", ";", "bfloat16_type_node", "=", "NULL_TREE", ";", "}", "}", "</s>" ]

[ "Create", "C++", "tinfo", "symbols", "for", "only", "conditionally", "available", "fundamental", "types", "." ]

[ "i386" ]

[]

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

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

[ "Z80" ]

[]

[ "<s>", "static", "int", "arm_cpymemqi_unaligned", "(", "rtx", "*", "operands", ")", "{", "HOST_WIDE_INT", "length", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "optimize_size", ")", "{", "bool", "src_aligned", "=", "MEM_ALIGN", "(", "operands", "[", "1", "]", ")", ">=", "BITS_PER_WORD", ";", "bool", "dst_aligned", "=", "MEM_ALIGN", "(", "operands", "[", "0", "]", ")", ">=", "BITS_PER_WORD", ";", "unsigned", "int", "interleave_factor", "=", "(", "src_aligned", "||", "dst_aligned", ")", "?", "2", ":", "1", ";", "HOST_WIDE_INT", "bytes_per_iter", "=", "(", "src_aligned", "||", "dst_aligned", ")", "?", "8", ":", "4", ";", "if", "(", "length", ">", "12", ")", "arm_block_move_unaligned_loop", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "length", ",", "interleave_factor", ",", "bytes_per_iter", ")", ";", "else", "arm_block_move_unaligned_straight", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "length", ",", "interleave_factor", ")", ";", "}", "else", "{", "if", "(", "length", ">", "32", ")", "arm_block_move_unaligned_loop", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "length", ",", "4", ",", "16", ")", ";", "else", "arm_block_move_unaligned_straight", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "length", ",", "4", ")", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Emit", "a", "block", "move", "when", "either", "the", "source", "or", "destination", "is", "unaligned", "(", "not", "aligned", "to", "a", "four-byte", "boundary", ")", ".", "This", "may", "need", "further", "tuning", "depending", "on", "core", "type", ",", "optimize_size", "setting", ",", "etc", "." ]

[ "arm", "2", "1", "0", "2", "1", "8", "4", "12", "0", "1", "0", "1", "32", "0", "1", "4", "16", "0", "1", "4", "1" ]

[]

[ "<s>", "unsigned", "SystemZInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "SystemZ", "::", "MOV32mr", ":", "case", "SystemZ", "::", "MOV32mry", ":", "case", "SystemZ", "::", "MOV64mr", ":", "case", "SystemZ", "::", "MOV32m8r", ":", "case", "SystemZ", "::", "MOV32m8ry", ":", "case", "SystemZ", "::", "MOV32m16r", ":", "case", "SystemZ", "::", "MOV32m16ry", ":", "case", "SystemZ", "::", "MOV64m8r", ":", "case", "SystemZ", "::", "MOV64m8ry", ":", "case", "SystemZ", "::", "MOV64m16r", ":", "case", "SystemZ", "::", "MOV64m16ry", ":", "case", "SystemZ", "::", "MOV64m32r", ":", "case", "SystemZ", "::", "MOV64m32ry", ":", "case", "SystemZ", "::", "FMOV32mr", ":", "case", "SystemZ", "::", "FMOV32mry", ":", "case", "SystemZ", "::", "FMOV64mr", ":", "case", "SystemZ", "::", "FMOV64mry", ":", "case", "SystemZ", "::", "MOV64Pmr", ":", "case", "SystemZ", "::", "MOV64Pmry", ":", "case", "SystemZ", "::", "MOV128mr", ":", "if", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "==", "0", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ::MOV32mr", "SystemZ::MOV32mry", "SystemZ::MOV64mr", "SystemZ::MOV32m8r", "SystemZ::MOV32m8ry", "SystemZ::MOV32m16r", "SystemZ::MOV32m16ry", "SystemZ::MOV64m8r", "SystemZ::MOV64m8ry", "SystemZ::MOV64m16r", "SystemZ::MOV64m16ry", "SystemZ::MOV64m32r", "SystemZ::MOV64m32ry", "SystemZ::FMOV32mr", "SystemZ::FMOV32mry", "SystemZ::FMOV64mr", "SystemZ::FMOV64mry", "SystemZ::MOV64Pmr", "SystemZ::MOV64Pmry", "SystemZ::MOV128mr", "0", "1", "2", "1", "0", "2", "0", "0", "3", "0" ]

[]

[ "<s>", "void", "dump", "(", ")", "{", "errs", "(", ")", "<<", "\"TLCS900ISelAddressMode \"", "<<", "this", "<<", "'\\n'", ";", "if", "(", "BaseType", "==", "RegBase", "&&", "Base", ".", "Reg", ".", "getNode", "(", ")", "!=", "0", ")", "{", "errs", "(", ")", "<<", "\"Base.Reg \"", ";", "Base", ".", "Reg", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "}", "else", "if", "(", "BaseType", "==", "FrameIndexBase", ")", "{", "errs", "(", ")", "<<", "\" Base.FrameIndex \"", "<<", "Base", ".", "FrameIndex", "<<", "'\\n'", ";", "}", "errs", "(", ")", "<<", "\" Disp \"", "<<", "Disp", "<<", "'\\n'", ";", "if", "(", "GV", ")", "{", "errs", "(", ")", "<<", "\"GV \"", ";", "GV", "->", "dump", "(", ")", ";", "}", "else", "if", "(", "CP", ")", "{", "errs", "(", ")", "<<", "\" CP \"", ";", "CP", "->", "dump", "(", ")", ";", "errs", "(", ")", "<<", "\" Align\"", "<<", "Align", "<<", "'\\n'", ";", "}", "else", "if", "(", "ES", ")", "{", "errs", "(", ")", "<<", "\"ES \"", ";", "errs", "(", ")", "<<", "ES", "<<", "'\\n'", ";", "}", "else", "if", "(", "JT", "!=", "-", "1", ")", "errs", "(", ")", "<<", "\" JT\"", "<<", "JT", "<<", "\" Align\"", "<<", "Align", "<<", "'\\n'", ";", "}", "</s>" ]

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

[ "TLCS900", "\"TLCS900ISelAddressMode \"", "0", "\"Base.Reg \"", "\" Base.FrameIndex \"", "\" Disp \"", "\"GV \"", "\" CP \"", "\" Align\"", "\"ES \"", "1", "\" JT\"", "\" Align\"" ]

[]

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

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

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

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isSplatValueForTargetNode", "(", "SDValue", "Op", ",", "const", "APInt", "&", "DemandedElts", ",", "APInt", "&", "UndefElts", ",", "unsigned", "Depth", ")", "const", "{", "unsigned", "NumElts", "=", "DemandedElts", ".", "getBitWidth", "(", ")", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "X86ISD", "::", "VBROADCAST", ":", "case", "X86ISD", "::", "VBROADCAST_LOAD", ":", "if", "(", "isTypeLegal", "(", "Op", ".", "getValueType", "(", ")", ".", "getVectorElementType", "(", ")", ")", ")", "{", "UndefElts", "=", "APInt", "::", "getNullValue", "(", "NumElts", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "return", "TargetLowering", "::", "isSplatValueForTargetNode", "(", "Op", ",", "DemandedElts", ",", "UndefElts", ",", "Depth", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "vector", "Op", "has", "the", "same", "value", "across", "all", "DemandedElts", ",", "indicating", "any", "elements", "which", "may", "be", "undef", "in", "the", "output", "UndefElts", "." ]

[ "X86", "X86", "X86ISD::VBROADCAST", "X86ISD::VBROADCAST_LOAD" ]

[]

[ "<s>", "int", "AMDGPUInstrInfo", "::", "pseudoToMCOpcode", "(", "int", "Opcode", ")", "const", "{", "SIEncodingFamily", "Gen", "=", "subtargetEncodingFamily", "(", "ST", ")", ";", "if", "(", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "renamedInGFX9", ")", "!=", "0", "&&", "ST", ".", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "GFX9", ")", "Gen", "=", "SIEncodingFamily", "::", "GFX9", ";", "if", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "SDWA", ")", "Gen", "=", "ST", ".", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "GFX9", "?", "SIEncodingFamily", "::", "SDWA9", ":", "SIEncodingFamily", "::", "SDWA", ";", "if", "(", "ST", ".", "hasUnpackedD16VMem", "(", ")", "&&", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "D16", ")", "&&", "!", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "MIMG", ")", ")", "Gen", "=", "SIEncodingFamily", "::", "GFX80", ";", "int", "MCOp", "=", "AMDGPU", "::", "getMCOpcode", "(", "Opcode", ",", "Gen", ")", ";", "if", "(", "MCOp", "==", "-", "1", ")", "return", "Opcode", ";", "if", "(", "MCOp", "==", "(", "uint16_t", ")", "-", "1", ")", "return", "-", "1", ";", "return", "MCOp", ";", "}", "</s>" ]

[ "Return", "a", "target-specific", "opcode", "if", "Opcode", "is", "a", "pseudo", "instruction", "." ]

[ "AMDGPU", "AMDGPU", "SI", "SIInstrFlags::renamedInGFX9", "0", "AMDGPU", "SIEncodingFamily::GFX9", "SIInstrFlags::SDWA", "AMDGPU", "SIEncodingFamily::SDWA9", "SIEncodingFamily::SDWA", "SIInstrFlags::D16", "SIInstrFlags::MIMG", "SIEncodingFamily::GFX80", "AMDGPU::getMCOpcode", "1", "1", "1" ]

[]

[ "<s>", "static", "void", "alpha_sa_mask", "(", "unsigned", "long", "*", "imaskP", ",", "unsigned", "long", "*", "fmaskP", ")", "{", "unsigned", "long", "imask", "=", "0", ";", "unsigned", "long", "fmask", "=", "0", ";", "unsigned", "int", "i", ";", "if", "(", "current_function_is_thunk", ")", "{", "*", "imaskP", "=", "0", ";", "*", "fmaskP", "=", "0", ";", "return", ";", "}", "if", "(", "TARGET_ABI_OPEN_VMS", "&&", "alpha_procedure_type", "==", "PT_STACK", ")", "imask", "|=", "(", "1UL", "<<", "HARD_FRAME_POINTER_REGNUM", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "!", "fixed_regs", "[", "i", "]", "&&", "!", "call_used_regs", "[", "i", "]", "&&", "regs_ever_live", "[", "i", "]", "&&", "i", "!=", "REG_RA", "&&", "(", "!", "TARGET_ABI_UNICOSMK", "||", "i", "!=", "HARD_FRAME_POINTER_REGNUM", ")", ")", "{", "if", "(", "i", "<", "32", ")", "imask", "|=", "(", "1UL", "<<", "i", ")", ";", "else", "fmask", "|=", "(", "1UL", "<<", "(", "i", "-", "32", ")", ")", ";", "}", "if", "(", "current_function_calls_eh_return", ")", "{", "for", "(", "i", "=", "0", ";", ";", "++", "i", ")", "{", "unsigned", "regno", "=", "EH_RETURN_DATA_REGNO", "(", "i", ")", ";", "if", "(", "regno", "==", "INVALID_REGNUM", ")", "break", ";", "imask", "|=", "1UL", "<<", "regno", ";", "}", "}", "if", "(", "imask", "||", "fmask", "||", "alpha_ra_ever_killed", "(", ")", ")", "imask", "|=", "(", "1UL", "<<", "REG_RA", ")", ";", "*", "imaskP", "=", "imask", ";", "*", "fmaskP", "=", "fmask", ";", "}", "</s>" ]

[ "Compute", "register", "masks", "for", "saved", "registers", "." ]

[ "alpha", "0", "0", "0", "0", "1UL", "0", "32", "1UL", "1UL", "32", "0", "1UL", "1UL" ]

[]

[ "<s>", "const", "char", "*", "nvptx_section_from_addr_space", "(", "addr_space_t", "as", ")", "{", "switch", "(", "as", ")", "{", "case", "ADDR_SPACE_CONST", ":", "return", "\".const\"", ";", "case", "ADDR_SPACE_GLOBAL", ":", "return", "\".global\"", ";", "case", "ADDR_SPACE_SHARED", ":", "return", "\".shared\"", ";", "case", "ADDR_SPACE_GENERIC", ":", "return", "\"\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Convert", "an", "address", "space", "AS", "to", "the", "corresponding", "ptx", "string", "." ]

[ "nvptx", "\".const\"", "\".global\"", "\".shared\"", "\"\"" ]

[]

[ "<s>", "X86GenInstrInfo", "::", "MachineOutlinerInstrType", "X86InstrInfo", "::", "getOutliningType", "(", "MachineBasicBlock", "::", "iterator", "&", "MIT", ",", "unsigned", "Flags", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "MIT", ";", "if", "(", "MI", ".", "isDebugInstr", "(", ")", "||", "MI", ".", "isIndirectDebugValue", "(", ")", ")", "return", "MachineOutlinerInstrType", "::", "Invisible", ";", "if", "(", "MI", ".", "isKill", "(", ")", ")", "return", "MachineOutlinerInstrType", "::", "Invisible", ";", "if", "(", "isTailCall", "(", "MI", ")", ")", "return", "MachineOutlinerInstrType", "::", "Legal", ";", "if", "(", "MI", ".", "isTerminator", "(", ")", "||", "MI", ".", "isReturn", "(", ")", ")", "{", "if", "(", "MI", ".", "getParent", "(", ")", "->", "succ_empty", "(", ")", ")", "return", "MachineOutlinerInstrType", "::", "Legal", ";", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "}", "if", "(", "MI", ".", "modifiesRegister", "(", "X86", "::", "RSP", ",", "&", "RI", ")", "||", "MI", ".", "readsRegister", "(", "X86", "::", "RSP", ",", "&", "RI", ")", "||", "MI", ".", "getDesc", "(", ")", ".", "hasImplicitUseOfPhysReg", "(", "X86", "::", "RSP", ")", "||", "MI", ".", "getDesc", "(", ")", ".", "hasImplicitDefOfPhysReg", "(", "X86", "::", "RSP", ")", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "readsRegister", "(", "X86", "::", "RIP", ",", "&", "RI", ")", "||", "MI", ".", "getDesc", "(", ")", ".", "hasImplicitUseOfPhysReg", "(", "X86", "::", "RIP", ")", "||", "MI", ".", "getDesc", "(", ")", ".", "hasImplicitDefOfPhysReg", "(", "X86", "::", "RIP", ")", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "isPosition", "(", ")", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "for", "(", "const", "MachineOperand", "&", "MOP", ":", "MI", ".", "operands", "(", ")", ")", "if", "(", "MOP", ".", "isCPI", "(", ")", "||", "MOP", ".", "isJTI", "(", ")", "||", "MOP", ".", "isCFIIndex", "(", ")", "||", "MOP", ".", "isFI", "(", ")", "||", "MOP", ".", "isTargetIndex", "(", ")", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "return", "MachineOutlinerInstrType", "::", "Legal", ";", "}", "</s>" ]

[ "Returns", "how", "or", "if", "MIT", "should", "be", "outlined", "." ]

[ "X86", "X86", "X86", "X86::RSP", "X86::RSP", "X86::RSP", "X86::RSP", "X86::RIP", "X86::RIP", "X86::RIP" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintType", "RISCVTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'a'", ":", "case", "'d'", ":", "case", "'f'", ":", "case", "'r'", ":", "return", "C_RegisterClass", ";", "case", "'Q'", ":", "case", "'R'", ":", "case", "'S'", ":", "case", "'T'", ":", "case", "'m'", ":", "return", "C_Memory", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'M'", ":", "return", "C_Other", ";", "default", ":", "break", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

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

[]

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

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

[ "TriCore", "TriCore", "TriCore" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isValidOffset", "(", "const", "int", "Opcode", ",", "const", "int", "Offset", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "Hexagon", "::", "L2_loadri_io", ":", "case", "Hexagon", "::", "LDriw_f", ":", "case", "Hexagon", "::", "S2_storeri_io", ":", "case", "Hexagon", "::", "STriw_f", ":", "return", "(", "Offset", ">=", "Hexagon_MEMW_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMW_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "L2_loadrd_io", ":", "case", "Hexagon", "::", "LDrid_f", ":", "case", "Hexagon", "::", "S2_storerd_io", ":", "case", "Hexagon", "::", "STrid_f", ":", "return", "(", "Offset", ">=", "Hexagon_MEMD_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMD_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "L2_loadrh_io", ":", "case", "Hexagon", "::", "L2_loadruh_io", ":", "case", "Hexagon", "::", "S2_storerh_io", ":", "return", "(", "Offset", ">=", "Hexagon_MEMH_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMH_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "L2_loadrb_io", ":", "case", "Hexagon", "::", "S2_storerb_io", ":", "case", "Hexagon", "::", "L2_loadrub_io", ":", "return", "(", "Offset", ">=", "Hexagon_MEMB_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMB_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "ADD_ri", ":", "case", "Hexagon", "::", "TFR_FI", ":", "return", "(", "Offset", ">=", "Hexagon_ADDI_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_ADDI_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "L4_iadd_memopw_io", ":", "case", "Hexagon", "::", "L4_isub_memopw_io", ":", "case", "Hexagon", "::", "L4_add_memopw_io", ":", "case", "Hexagon", "::", "L4_sub_memopw_io", ":", "case", "Hexagon", "::", "L4_and_memopw_io", ":", "case", "Hexagon", "::", "L4_or_memopw_io", ":", "return", "(", "0", "<=", "Offset", "&&", "Offset", "<=", "255", ")", ";", "case", "Hexagon", "::", "L4_iadd_memoph_io", ":", "case", "Hexagon", "::", "L4_isub_memoph_io", ":", "case", "Hexagon", "::", "L4_add_memoph_io", ":", "case", "Hexagon", "::", "L4_sub_memoph_io", ":", "case", "Hexagon", "::", "L4_and_memoph_io", ":", "case", "Hexagon", "::", "L4_or_memoph_io", ":", "return", "(", "0", "<=", "Offset", "&&", "Offset", "<=", "127", ")", ";", "case", "Hexagon", "::", "L4_iadd_memopb_io", ":", "case", "Hexagon", "::", "L4_isub_memopb_io", ":", "case", "Hexagon", "::", "L4_add_memopb_io", ":", "case", "Hexagon", "::", "L4_sub_memopb_io", ":", "case", "Hexagon", "::", "L4_and_memopb_io", ":", "case", "Hexagon", "::", "L4_or_memopb_io", ":", "return", "(", "0", "<=", "Offset", "&&", "Offset", "<=", "63", ")", ";", "case", "Hexagon", "::", "STriw_pred", ":", "case", "Hexagon", "::", "LDriw_pred", ":", "return", "true", ";", "case", "Hexagon", "::", "J2_loop0i", ":", "return", "isUInt", "<", "10", ">", "(", "Offset", ")", ";", "case", "Hexagon", "::", "INLINEASM", ":", "return", "true", ";", "}", "llvm_unreachable", "(", "\"No offset range is defined for this opcode. \"", "\"Please define it in the above switch statement!\"", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::L2_loadri_io", "Hexagon::LDriw_f", "Hexagon::S2_storeri_io", "Hexagon::STriw_f", "Hexagon", "Hexagon", "Hexagon::L2_loadrd_io", "Hexagon::LDrid_f", "Hexagon::S2_storerd_io", "Hexagon::STrid_f", "Hexagon", "Hexagon", "Hexagon::L2_loadrh_io", "Hexagon::L2_loadruh_io", "Hexagon::S2_storerh_io", "Hexagon", "Hexagon", "Hexagon::L2_loadrb_io", "Hexagon::S2_storerb_io", "Hexagon::L2_loadrub_io", "Hexagon", "Hexagon", "Hexagon::ADD_ri", "Hexagon::TFR_FI", "Hexagon", "Hexagon", "Hexagon::L4_iadd_memopw_io", "Hexagon::L4_isub_memopw_io", "Hexagon::L4_add_memopw_io", "Hexagon::L4_sub_memopw_io", "Hexagon::L4_and_memopw_io", "Hexagon::L4_or_memopw_io", "0", "255", "Hexagon::L4_iadd_memoph_io", "Hexagon::L4_isub_memoph_io", "Hexagon::L4_add_memoph_io", "Hexagon::L4_sub_memoph_io", "Hexagon::L4_and_memoph_io", "Hexagon::L4_or_memoph_io", "0", "127", "Hexagon::L4_iadd_memopb_io", "Hexagon::L4_isub_memopb_io", "Hexagon::L4_add_memopb_io", "Hexagon::L4_sub_memopb_io", "Hexagon::L4_and_memopb_io", "Hexagon::L4_or_memopb_io", "0", "63", "Hexagon::STriw_pred", "Hexagon::LDriw_pred", "Hexagon::J2_loop0i", "10", "Hexagon::INLINEASM", "\"No offset range is defined for this opcode. \"", "\"Please define it in the above switch statement!\"" ]

[]

[ "<s>", "inline", "bool", "vgpr_2reg_mode_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", ")", "mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "return", "(", "mode", "==", "DImode", "||", "mode", "==", "DFmode", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "MODE", "is", "valid", "for", "pair", "of", "VGPR", "registers", "." ]

[ "gcn" ]

[]

[ "<s>", "SDValue", "XtensaTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "Opc", "=", "XtensaISD", "::", "RET_FLAG", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getReturnType", "(", ")", "->", "isAggregateType", "(", ")", ")", "{", "llvm", "::", "errs", "(", ")", "<<", "\"ISelDAG: Can't return aggregate types\\n\"", ";", "llvm_unreachable", "(", "\"Unhandled aggregate type\"", ")", ";", "}", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "CCAssignFnForReturn", "(", "CallConv", ")", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "SDValue", "Arg", "=", "OutVals", "[", "i", "]", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "}", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only support return in registers\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "Arg", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa", "ISD::OutputArg", "XtensaISD::RET_FLAG", "\"ISelDAG: Can't return aggregate types\\n\"", "\"Unhandled aggregate type\"", "16", "4", "1", "0", "\"Unknown loc info!\"", "ISD::BITCAST", "\"Can only support return in registers\"", "1", "0", "MVT::Other" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "PPCRegisterInfo", "::", "getLargestLegalSuperClass", "(", "const", "TargetRegisterClass", "*", "RC", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "const", "auto", "*", "DefaultSuperclass", "=", "TargetRegisterInfo", "::", "getLargestLegalSuperClass", "(", "RC", ",", "MF", ")", ";", "if", "(", "Subtarget", ".", "hasVSX", "(", ")", ")", "{", "if", "(", "TM", ".", "isELFv2ABI", "(", ")", "||", "Subtarget", ".", "isAIXABI", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "hasP9Vector", "(", ")", "&&", "EnableGPRToVecSpills", "&&", "RC", "==", "&", "PPC", "::", "G8RCRegClass", ")", "{", "InflateGP8RC", "++", ";", "return", "&", "PPC", "::", "SPILLTOVSRRCRegClass", ";", "}", "if", "(", "RC", "==", "&", "PPC", "::", "GPRCRegClass", "&&", "EnableGPRToVecSpills", ")", "InflateGPRC", "++", ";", "}", "for", "(", "const", "auto", "*", "I", "=", "RC", "->", "getSuperClasses", "(", ")", ";", "*", "I", ";", "++", "I", ")", "{", "if", "(", "getRegSizeInBits", "(", "*", "*", "I", ")", "!=", "getRegSizeInBits", "(", "*", "RC", ")", ")", "continue", ";", "switch", "(", "(", "*", "I", ")", "->", "getID", "(", ")", ")", "{", "case", "PPC", "::", "VSSRCRegClassID", ":", "return", "Subtarget", ".", "hasP8Vector", "(", ")", "?", "*", "I", ":", "DefaultSuperclass", ";", "case", "PPC", "::", "VSFRCRegClassID", ":", "case", "PPC", "::", "VSRCRegClassID", ":", "return", "*", "I", ";", "case", "PPC", "::", "VSRpRCRegClassID", ":", "return", "Subtarget", ".", "pairedVectorMemops", "(", ")", "?", "*", "I", ":", "DefaultSuperclass", ";", "case", "PPC", "::", "ACCRCRegClassID", ":", "case", "PPC", "::", "UACCRCRegClassID", ":", "return", "Subtarget", ".", "hasMMA", "(", ")", "?", "*", "I", ":", "DefaultSuperclass", ";", "}", "}", "}", "return", "DefaultSuperclass", ";", "}", "</s>" ]

[ "Returns", "the", "largest", "super", "class", "of", "RC", "that", "is", "legal", "to", "use", "in", "the", "current", "sub-target", "and", "has", "the", "same", "spill", "size", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC::G8RCRegClass", "PPC::SPILLTOVSRRCRegClass", "PPC::GPRCRegClass", "PPC::VSSRCRegClassID", "PPC::VSFRCRegClassID", "PPC::VSRCRegClassID", "PPC::VSRpRCRegClassID", "PPC::ACCRCRegClassID", "PPC::UACCRCRegClassID" ]

[]

[ "<s>", "void", "assignValueToAddress", "(", "const", "CallLowering", "::", "ArgInfo", "&", "Arg", ",", "Register", "Addr", ",", "uint64_t", "Size", ",", "MachinePointerInfo", "&", "MPO", ",", "CCValAssign", "&", "VA", ")", "override", "{", "unsigned", "MaxSize", "=", "Size", "*", "8", ";", "if", "(", "!", "Arg", ".", "IsFixed", ")", "MaxSize", "=", "0", ";", "assert", "(", "Arg", ".", "Regs", ".", "size", "(", ")", "==", "1", ")", ";", "Register", "ValVReg", "=", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "LocInfo", "::", "FPExt", "?", "extendRegister", "(", "Arg", ".", "Regs", "[", "0", "]", ",", "VA", ",", "MaxSize", ")", ":", "Arg", ".", "Regs", "[", "0", "]", ";", "const", "LLT", "RegTy", "=", "MRI", ".", "getType", "(", "ValVReg", ")", ";", "if", "(", "RegTy", ".", "getSizeInBytes", "(", ")", ">", "Size", ")", "Size", "=", "RegTy", ".", "getSizeInBytes", "(", ")", ";", "assignValueToAddress", "(", "ValVReg", ",", "Addr", ",", "Size", ",", "MPO", ",", "VA", ")", ";", "}", "</s>" ]

[ "An", "overload", "which", "takes", "an", "ArgInfo", "if", "additional", "information", "about", "the", "arg", "is", "needed", "." ]

[ "AArch64", "8", "0", "1", "0", "0" ]

[]

[ "<s>", "void", "avr_asm_output_aligned_decl_common", "(", "FILE", "*", "stream", ",", "tree", "decl", ",", "const", "char", "*", "name", ",", "unsigned", "HOST_WIDE_INT", "size", ",", "unsigned", "int", "align", ",", "bool", "local_p", ")", "{", "rtx", "mem", "=", "decl", "==", "NULL_TREE", "?", "NULL_RTX", ":", "DECL_RTL", "(", "decl", ")", ";", "rtx", "symbol", ";", "if", "(", "mem", "!=", "NULL_RTX", "&&", "MEM_P", "(", "mem", ")", "&&", "GET_CODE", "(", "(", "symbol", "=", "XEXP", "(", "mem", ",", "0", ")", ")", ")", "==", "SYMBOL_REF", "&&", "(", "SYMBOL_REF_FLAGS", "(", "symbol", ")", "&", "(", "SYMBOL_FLAG_IO", "|", "SYMBOL_FLAG_ADDRESS", ")", ")", ")", "{", "if", "(", "!", "local_p", ")", "{", "fprintf", "(", "stream", ",", "\"\\t.globl\\t\"", ")", ";", "assemble_name", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\"\\n\"", ")", ";", "}", "if", "(", "SYMBOL_REF_FLAGS", "(", "symbol", ")", "&", "SYMBOL_FLAG_ADDRESS", ")", "{", "assemble_name", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\" = %ld\\n\"", ",", "(", "long", ")", "INTVAL", "(", "avr_eval_addr_attrib", "(", "symbol", ")", ")", ")", ";", "}", "else", "if", "(", "local_p", ")", "error_at", "(", "DECL_SOURCE_LOCATION", "(", "decl", ")", ",", "\"static IO declaration for %q+D needs an address\"", ",", "decl", ")", ";", "return", ";", "}", "if", "(", "!", "STR_PREFIX_P", "(", "name", ",", "\"__gnu_lto\"", ")", ")", "avr_need_clear_bss_p", "=", "true", ";", "if", "(", "local_p", ")", "ASM_OUTPUT_ALIGNED_LOCAL", "(", "stream", ",", "name", ",", "size", ",", "align", ")", ";", "else", "ASM_OUTPUT_ALIGNED_COMMON", "(", "stream", ",", "name", ",", "size", ",", "align", ")", ";", "}", "</s>" ]

[ "Track", "need", "of", "__do_clear_bss", "." ]

[ "avr", "0", "\"\\t.globl\\t\"", "\"\\n\"", "\" = %ld\\n\"", "\"static IO declaration for %q+D needs an address\"", "\"__gnu_lto\"" ]

[]

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

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "bool", "X86AsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'b'", ":", "case", "'h'", ":", "case", "'w'", ":", "case", "'k'", ":", "case", "'q'", ":", "break", ";", "case", "'P'", ":", "printMemReference", "(", "MI", ",", "OpNo", ",", "O", ",", "\"no-rip\"", ")", ";", "return", "false", ";", "}", "}", "printMemReference", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "1", "0", "0", "\"no-rip\"" ]

[]

[ "<s>", "void", "X86DAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "OptForSize", "=", "MF", "->", "getFunction", "(", ")", ".", "optForSize", "(", ")", ";", "OptForMinSize", "=", "MF", "->", "getFunction", "(", ")", ".", "optForMinSize", "(", ")", ";", "assert", "(", "(", "!", "OptForMinSize", "||", "OptForSize", ")", "&&", "\"OptForMinSize implies OptForSize\"", ")", ";", "for", "(", "SelectionDAG", "::", "allnodes_iterator", "I", "=", "CurDAG", "->", "allnodes_begin", "(", ")", ",", "E", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "SDNode", "*", "N", "=", "&", "*", "I", "++", ";", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", "&&", "(", "(", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", "&&", "!", "Subtarget", "->", "slowTwoMemOps", "(", ")", ")", "||", "(", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "TC_RETURN", "&&", "(", "Subtarget", "->", "is64Bit", "(", ")", "||", "!", "getTargetMachine", "(", ")", ".", "isPositionIndependent", "(", ")", ")", ")", ")", ")", "{", "bool", "HasCallSeq", "=", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", ";", "SDValue", "Chain", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Load", "=", "N", "->", "getOperand", "(", "1", ")", ";", "if", "(", "!", "isCalleeLoad", "(", "Load", ",", "Chain", ",", "HasCallSeq", ")", ")", "continue", ";", "moveBelowOrigChain", "(", "CurDAG", ",", "Load", ",", "SDValue", "(", "N", ",", "0", ")", ",", "Chain", ")", ";", "++", "NumLoadMoved", ";", "continue", ";", "}", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_ROUND", "&&", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "MVT", "SrcVT", "=", "N", "->", "getOperand", "(", "0", ")", ".", "getSimpleValueType", "(", ")", ";", "MVT", "DstVT", "=", "N", "->", "getSimpleValueType", "(", "0", ")", ";", "if", "(", "SrcVT", ".", "isVector", "(", ")", "||", "DstVT", ".", "isVector", "(", ")", ")", "continue", ";", "const", "X86TargetLowering", "*", "X86Lowering", "=", "static_cast", "<", "const", "X86TargetLowering", "*", ">", "(", "TLI", ")", ";", "bool", "SrcIsSSE", "=", "X86Lowering", "->", "isScalarFPTypeInSSEReg", "(", "SrcVT", ")", ";", "bool", "DstIsSSE", "=", "X86Lowering", "->", "isScalarFPTypeInSSEReg", "(", "DstVT", ")", ";", "if", "(", "SrcIsSSE", "&&", "DstIsSSE", ")", "continue", ";", "if", "(", "!", "SrcIsSSE", "&&", "!", "DstIsSSE", ")", "{", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "if", "(", "N", "->", "getConstantOperandVal", "(", "1", ")", ")", "continue", ";", "}", "MVT", "MemVT", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_ROUND", ")", "MemVT", "=", "DstVT", ";", "else", "MemVT", "=", "SrcIsSSE", "?", "SrcVT", ":", "DstVT", ";", "SDValue", "MemTmp", "=", "CurDAG", "->", "CreateStackTemporary", "(", "MemVT", ")", ";", "SDLoc", "dl", "(", "N", ")", ";", "SDValue", "Store", "=", "CurDAG", "->", "getTruncStore", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "dl", ",", "N", "->", "getOperand", "(", "0", ")", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ")", ";", "SDValue", "Result", "=", "CurDAG", "->", "getExtLoad", "(", "ISD", "::", "EXTLOAD", ",", "dl", ",", "DstVT", ",", "Store", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ")", ";", "--", "I", ";", "CurDAG", "->", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "N", ",", "0", ")", ",", "Result", ")", ";", "++", "I", ";", "CurDAG", "->", "DeleteNode", "(", "N", ")", ";", "}", "}", "</s>" ]

[ "PreprocessISelDAG", "-", "This", "hook", "allows", "targets", "to", "hack", "on", "the", "graph", "before", "instruction", "selection", "starts", "." ]

[ "X86", "X86", "\"OptForMinSize implies OptForSize\"", "X86ISD::CALL", "X86ISD::TC_RETURN", "X86ISD::CALL", "0", "1", "0", "ISD::FP_ROUND", "ISD::FP_EXTEND", "0", "0", "X86", "X86", "X86", "X86", "X86", "ISD::FP_EXTEND", "1", "ISD::FP_ROUND", "0", "ISD::EXTLOAD", "0" ]

[]

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

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

[ "AZPR", "AZPR" ]

[]

[ "<s>", "static", "tree", "ix86_stack_protect_guard", "(", "void", ")", "{", "if", "(", "TARGET_SSP_TLS_GUARD", ")", "{", "tree", "type_node", "=", "lang_hooks", ".", "types", ".", "type_for_mode", "(", "ptr_mode", ",", "1", ")", ";", "int", "qual", "=", "ENCODE_QUAL_ADDR_SPACE", "(", "ix86_stack_protector_guard_reg", ")", ";", "tree", "type", "=", "build_qualified_type", "(", "type_node", ",", "qual", ")", ";", "tree", "t", ";", "if", "(", "global_options_set", ".", "x_ix86_stack_protector_guard_symbol_str", ")", "{", "t", "=", "ix86_tls_stack_chk_guard_decl", ";", "if", "(", "t", "==", "NULL", ")", "{", "rtx", "x", ";", "t", "=", "build_decl", "(", "UNKNOWN_LOCATION", ",", "VAR_DECL", ",", "get_identifier", "(", "ix86_stack_protector_guard_symbol_str", ")", ",", "type", ")", ";", "TREE_STATIC", "(", "t", ")", "=", "1", ";", "TREE_PUBLIC", "(", "t", ")", "=", "1", ";", "DECL_EXTERNAL", "(", "t", ")", "=", "1", ";", "TREE_USED", "(", "t", ")", "=", "1", ";", "TREE_THIS_VOLATILE", "(", "t", ")", "=", "1", ";", "DECL_ARTIFICIAL", "(", "t", ")", "=", "1", ";", "DECL_IGNORED_P", "(", "t", ")", "=", "1", ";", "x", "=", "DECL_RTL", "(", "t", ")", ";", "RTX_FLAG", "(", "x", ",", "used", ")", "=", "1", ";", "ix86_tls_stack_chk_guard_decl", "=", "t", ";", "}", "}", "else", "{", "tree", "asptrtype", "=", "build_pointer_type", "(", "type", ")", ";", "t", "=", "build_int_cst", "(", "asptrtype", ",", "ix86_stack_protector_guard_offset", ")", ";", "t", "=", "build2", "(", "MEM_REF", ",", "asptrtype", ",", "t", ",", "build_int_cst", "(", "asptrtype", ",", "0", ")", ")", ";", "}", "return", "t", ";", "}", "return", "default_stack_protect_guard", "(", ")", ";", "}", "</s>" ]

[ "If", "using", "TLS", "guards", ",", "do", "n't", "waste", "time", "creating", "and", "expanding", "__stack_chk_guard", "decl", "and", "MEM", "as", "we", "are", "going", "to", "ignore", "it", "." ]

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

[]

[ "<s>", "bool", "M680x0FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "auto", "&", "MRI", "=", "*", "static_cast", "<", "const", "M680x0RegisterInfo", "*", ">", "(", "TRI", ")", ";", "auto", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "int", "FI", "=", "0", ";", "unsigned", "Mask", "=", "0", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "{", "FI", "=", "std", "::", "max", "(", "FI", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ")", ";", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "unsigned", "Shift", "=", "MRI", ".", "getSpillRegisterOrder", "(", "Reg", ")", ";", "Mask", "|=", "1", "<<", "Shift", ";", "}", "auto", "I", "=", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "M680x0", "::", "MOVM32mp", ")", ")", ".", "addImm", "(", "Mask", ")", ",", "FI", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "{", "I", ".", "addReg", "(", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ",", "RegState", "::", "ImplicitDefine", ")", ";", "addMemOperand", "(", "I", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "0", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "M680x0", "M680x0", "M680x0", "0", "0", "0", "1", "M680x0::MOVM32mp", "0", "0" ]

[]

[ "<s>", "void", "PPCTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "if", "(", "ST", "->", "getDarwinDirective", "(", ")", "==", "PPC", "::", "DIR_A2", ")", "{", "UP", ".", "Partial", "=", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "AllowExpensiveTripCount", "=", "true", ";", "}", "BaseT", "::", "getUnrollingPreferences", "(", "L", ",", "UP", ")", ";", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "PowerPC", "PPC", "PPC::DIR_A2" ]

[]

[ "<s>", "static", "struct", "machine_function", "*", "epiphany_init_machine_status", "(", "void", ")", "{", "struct", "machine_function", "*", "machine", ";", "current_frame_info", "=", "zero_frame_info", ";", "machine", "=", "ggc_cleared_alloc", "<", "machine_function_t", ">", "(", ")", ";", "return", "machine", ";", "}", "</s>" ]

[ "The", "usual", ";", "we", "set", "up", "our", "machine_function", "data", "." ]

[ "epiphany" ]

[]

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

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

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

[]

[ "<s>", "bool", "ARMFrameLowering", "::", "assignCalleeSavedSpillSlots", "(", "MachineFunction", "&", "MF", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "if", "(", "STI", ".", "hasV8_1MMainlineOps", "(", ")", "&&", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", "->", "isCmseNSEntryFunction", "(", ")", ")", "{", "CSI", ".", "emplace_back", "(", "ARM", "::", "FPCXTNS", ")", ";", "CSI", ".", "back", "(", ")", ".", "setRestored", "(", "false", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "function", "will", "assign", "callee", "saved", "gprs", "to", "volatile", "vector", "registers", "for", "prologue", "spills", "when", "applicable", "." ]

[ "ARM", "ARM", "ARM", "ARM::FPCXTNS" ]

[]

[ "<s>", "bool", "IA64TargetMachine", "::", "addInstSelector", "(", "PassManagerBase", "&", "PM", ",", "bool", "Fast", ")", "{", "PM", ".", "add", "(", "createIA64DAGToDAGInstructionSelector", "(", "*", "this", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "IA64", "IA64", "IA64" ]

[]

[ "<s>", "static", "const", "char", "*", "rs6000_call_template_1", "(", "rtx", "*", "operands", ",", "unsigned", "int", "funop", ",", "bool", "sibcall", ")", "{", "gcc_assert", "(", "funop", "<=", "MAX_RECOG_OPERANDS", ")", ";", "char", "arg", "[", "12", "]", ";", "arg", "[", "0", "]", "=", "0", ";", "if", "(", "TARGET_TLS_MARKERS", "&&", "GET_CODE", "(", "operands", "[", "funop", "+", "1", "]", ")", "==", "UNSPEC", ")", "{", "if", "(", "XINT", "(", "operands", "[", "funop", "+", "1", "]", ",", "1", ")", "==", "UNSPEC_TLSGD", ")", "sprintf", "(", "arg", ",", "\"(%%%u@tlsgd)\"", ",", "funop", "+", "1", ")", ";", "else", "if", "(", "XINT", "(", "operands", "[", "funop", "+", "1", "]", ",", "1", ")", "==", "UNSPEC_TLSLD", ")", "sprintf", "(", "arg", ",", "\"(%%&@tlsld)\"", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "char", "z", "[", "11", "]", ";", "sprintf", "(", "z", ",", "\"%%z%u%s\"", ",", "funop", ",", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "TARGET_SECURE_PLT", "&&", "flag_pic", "==", "2", "?", "\"+32768\"", ":", "\"\"", ")", ")", ";", "static", "char", "str", "[", "32", "]", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "sprintf", "(", "str", ",", "\"b%s %s%s%s\"", ",", "sibcall", "?", "\"\"", ":", "\"l\"", ",", "z", ",", "arg", ",", "sibcall", "?", "\"\"", ":", "\"\\n\\tnop\"", ")", ";", "else", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", ")", "sprintf", "(", "str", ",", "\"b%s %s%s%s\"", ",", "sibcall", "?", "\"\"", ":", "\"l\"", ",", "z", ",", "arg", ",", "flag_pic", "?", "\"@plt\"", ":", "\"\"", ")", ";", "else", "if", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", ")", "{", "gcc_checking_assert", "(", "GET_CODE", "(", "operands", "[", "funop", "+", "2", "]", ")", "==", "CONST_INT", ")", ";", "int", "cookie", "=", "INTVAL", "(", "operands", "[", "funop", "+", "2", "]", ")", ";", "if", "(", "cookie", "&", "CALL_LONG", ")", "{", "tree", "funname", "=", "get_identifier", "(", "XSTR", "(", "operands", "[", "funop", "]", ",", "0", ")", ")", ";", "tree", "labelname", "=", "get_prev_label", "(", "funname", ")", ";", "gcc_checking_assert", "(", "labelname", "&&", "!", "sibcall", ")", ";", "sprintf", "(", "str", ",", "\"jbsr %%z%u,%.10s\"", ",", "funop", ",", "IDENTIFIER_POINTER", "(", "labelname", ")", ")", ";", "}", "else", "sprintf", "(", "str", ",", "\"b%s %s%s\"", ",", "sibcall", "?", "\"\"", ":", "\"l\"", ",", "z", ",", "arg", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "return", "str", ";", "}", "</s>" ]

[ "Return", "a", "template", "string", "for", "assembly", "to", "emit", "when", "making", "an", "external", "call", ".", "FUNOP", "is", "the", "call", "mem", "argument", "operand", "number", "." ]

[ "rs6000", "12", "0", "0", "1", "1", "1", "\"(%%%u@tlsgd)\"", "1", "1", "1", "\"(%%&@tlsld)\"", "11", "\"%%z%u%s\"", "2", "\"+32768\"", "\"\"", "32", "\"b%s %s%s%s\"", "\"\"", "\"l\"", "\"\"", "\"\\n\\tnop\"", "\"b%s %s%s%s\"", "\"\"", "\"l\"", "\"@plt\"", "\"\"", "2", "2", "0", "\"jbsr %%z%u,%.10s\"", "\"b%s %s%s\"", "\"\"", "\"l\"" ]

[]

[ "<s>", "static", "inline", "int", "shiftcosts", "(", "rtx", "x", ")", "{", "int", "value", ";", "if", "(", "TARGET_SHMEDIA", ")", "return", "1", ";", "if", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ">", "UNITS_PER_WORD", ")", "{", "if", "(", "GET_MODE", "(", "x", ")", "==", "DImode", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "1", ")", "return", "2", ";", "return", "-", "1", ";", "}", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "return", "SH_DYNAMIC_SHIFT_COST", ";", "value", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&", "31", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "ASHIFTRT", ")", "{", "int", "cost", "=", "ashiftrt_insns", "[", "value", "]", ";", "if", "(", "cost", ">", "1", "+", "SH_DYNAMIC_SHIFT_COST", ")", "cost", "=", "1", "+", "SH_DYNAMIC_SHIFT_COST", ";", "return", "cost", ";", "}", "else", "return", "ashl_lshr_seq", "[", "value", "]", ".", "insn_count", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "a", "shift", "." ]

[ "sh", "1", "1", "1", "1", "2", "1", "1", "1", "31", "1", "1" ]

[]

[ "<s>", "static", "int", "vax_return_pops_args", "(", "tree", "fundecl", "ATTRIBUTE_UNUSED", ",", "tree", "funtype", "ATTRIBUTE_UNUSED", ",", "int", "size", ")", "{", "return", "size", ">", "255", "*", "4", "?", "0", ":", "size", ";", "}", "</s>" ]

[ "Value", "is", "the", "number", "of", "bytes", "of", "arguments", "automatically", "popped", "when", "returning", "from", "a", "subroutine", "call", ".", "FUNDECL", "is", "the", "declaration", "node", "of", "the", "function", "(", "as", "a", "tree", ")", ",", "FUNTYPE", "is", "the", "data", "type", "of", "the", "function", "(", "as", "a", "tree", ")", ",", "or", "for", "a", "library", "call", "it", "is", "an", "identifier", "node", "for", "the", "subroutine", "name", ".", "SIZE", "is", "the", "number", "of", "bytes", "of", "arguments", "passed", "on", "the", "stack", ".", "On", "the", "VAX", ",", "the", "RET", "insn", "pops", "a", "maximum", "of", "255", "args", "for", "any", "function", "." ]

[ "vax", "255", "4", "0" ]

[]

[ "<s>", "bool", "s390_const_operand_ok", "(", "tree", "arg", ",", "int", "argnum", ",", "int", "op_flags", ",", "tree", "decl", ")", "{", "if", "(", "O_UIMM_P", "(", "op_flags", ")", ")", "{", "int", "bitwidths", "[", "]", "=", "{", "1", ",", "2", ",", "3", ",", "4", ",", "5", ",", "8", ",", "12", ",", "16", ",", "32", "}", ";", "int", "bitwidth", "=", "bitwidths", "[", "op_flags", "-", "O_U1", "]", ";", "if", "(", "!", "tree_fits_uhwi_p", "(", "arg", ")", "||", "tree_to_uhwi", "(", "arg", ")", ">", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "1", "<<", "bitwidth", ")", "-", "1", ")", "{", "error", "(", "\"constant argument %d for builtin %qF is out of range (0..\"", "HOST_WIDE_INT_PRINT_UNSIGNED", "\")\"", ",", "argnum", ",", "decl", ",", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "1", "<<", "bitwidth", ")", "-", "1", ")", ";", "return", "false", ";", "}", "}", "if", "(", "O_SIMM_P", "(", "op_flags", ")", ")", "{", "int", "bitwidths", "[", "]", "=", "{", "2", ",", "3", ",", "4", ",", "5", ",", "8", ",", "12", ",", "16", ",", "32", "}", ";", "int", "bitwidth", "=", "bitwidths", "[", "op_flags", "-", "O_S2", "]", ";", "if", "(", "!", "tree_fits_shwi_p", "(", "arg", ")", "||", "tree_to_shwi", "(", "arg", ")", "<", "-", "(", "(", "HOST_WIDE_INT", ")", "1", "<<", "(", "bitwidth", "-", "1", ")", ")", "||", "tree_to_shwi", "(", "arg", ")", ">", "(", "(", "(", "HOST_WIDE_INT", ")", "1", "<<", "(", "bitwidth", "-", "1", ")", ")", "-", "1", ")", ")", "{", "error", "(", "\"constant argument %d for builtin %qF is out of range (\"", "HOST_WIDE_INT_PRINT_DEC", "\"..\"", "HOST_WIDE_INT_PRINT_DEC", "\")\"", ",", "argnum", ",", "decl", ",", "-", "(", "(", "HOST_WIDE_INT", ")", "1", "<<", "(", "bitwidth", "-", "1", ")", ")", ",", "(", "(", "HOST_WIDE_INT", ")", "1", "<<", "(", "bitwidth", "-", "1", ")", ")", "-", "1", ")", ";", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "ARG", "is", "appropriate", "as", "argument", "number", "ARGNUM", "of", "builtin", "DECL", ".", "The", "operand", "flags", "from", "s390-builtins.def", "have", "to", "passed", "as", "OP_FLAGS", "." ]

[ "s390", "1", "2", "3", "4", "5", "8", "12", "16", "32", "1", "1", "\"constant argument %d for builtin %qF is out of range (0..\"", "\")\"", "1", "1", "2", "3", "4", "5", "8", "12", "16", "32", "1", "1", "1", "1", "1", "\"constant argument %d for builtin %qF is out of range (\"", "\"..\"", "\")\"", "1", "1", "1", "1", "1" ]

[]

[ "<s>", "NVPTXSubtarget", "::", "NVPTXSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ",", "bool", "is64Bit", ")", ":", "NVPTXGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "Is64Bit", "(", "is64Bit", ")", ",", "PTXVersion", "(", "0", ")", ",", "SmVersion", "(", "20", ")", ",", "DL", "(", "computeDataLayout", "(", "is64Bit", ")", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "TLInfo", "(", "(", "NVPTXTargetMachine", "&", ")", "TM", ")", ",", "TSInfo", "(", "&", "DL", ")", ",", "FrameLowering", "(", "*", "this", ")", "{", "Triple", "T", "(", "TT", ")", ";", "if", "(", "T", ".", "getOS", "(", ")", "==", "Triple", "::", "NVCL", ")", "drvInterface", "=", "NVPTX", "::", "NVCL", ";", "else", "drvInterface", "=", "NVPTX", "::", "CUDA", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "NVPTX", "NVPTX", "0", "20", "NVPTX", "NVPTX::NVCL", "NVPTX::CUDA" ]

[]

[ "<s>", "static", "void", "mips_expand_vi_broadcast", "(", "machine_mode", "vmode", ",", "rtx", "target", ",", "rtx", "elt", ")", "{", "struct", "expand_vec_perm_d", "d", ";", "rtx", "t1", ";", "bool", "ok", ";", "if", "(", "elt", "!=", "const0_rtx", ")", "elt", "=", "force_reg", "(", "GET_MODE_INNER", "(", "vmode", ")", ",", "elt", ")", ";", "if", "(", "REG_P", "(", "elt", ")", ")", "elt", "=", "gen_lowpart", "(", "DImode", ",", "elt", ")", ";", "t1", "=", "gen_reg_rtx", "(", "vmode", ")", ";", "switch", "(", "vmode", ")", "{", "case", "V8QImode", ":", "emit_insn", "(", "gen_loongson_vec_init1_v8qi", "(", "t1", ",", "elt", ")", ")", ";", "break", ";", "case", "V4HImode", ":", "emit_insn", "(", "gen_loongson_vec_init1_v4hi", "(", "t1", ",", "elt", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "memset", "(", "&", "d", ",", "0", ",", "sizeof", "(", "d", ")", ")", ";", "d", ".", "target", "=", "target", ";", "d", ".", "op0", "=", "t1", ";", "d", ".", "op1", "=", "t1", ";", "d", ".", "vmode", "=", "vmode", ";", "d", ".", "nelt", "=", "GET_MODE_NUNITS", "(", "vmode", ")", ";", "d", ".", "one_vector_p", "=", "true", ";", "ok", "=", "mips_expand_vec_perm_const_1", "(", "&", "d", ")", ";", "gcc_assert", "(", "ok", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "mips_expand_vec_init", ",", "expand", "via", "broadcast", "." ]

[ "mips", "0" ]

[]

[ "<s>", "unsigned", "ARMFastISel", "::", "fastEmitInst_rr", "(", "unsigned", "MachineInstOpcode", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Op0", ",", "unsigned", "Op1", ")", "{", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "const", "MCInstrDesc", "&", "II", "=", "TII", ".", "get", "(", "MachineInstOpcode", ")", ";", "Op0", "=", "constrainOperandRegClass", "(", "II", ",", "Op0", ",", "1", ")", ";", "Op1", "=", "constrainOperandRegClass", "(", "II", ",", "Op1", ",", "2", ")", ";", "if", "(", "II", ".", "getNumDefs", "(", ")", ">=", "1", ")", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ",", "ResultReg", ")", ".", "addReg", "(", "Op0", ")", ".", "addReg", "(", "Op1", ")", ")", ";", "}", "else", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ")", ".", "addReg", "(", "Op0", ")", ".", "addReg", "(", "Op1", ")", ")", ";", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "ResultReg", ")", ".", "addReg", "(", "II", ".", "ImplicitDefs", "[", "0", "]", ")", ")", ";", "}", "return", "ResultReg", ";", "}", "</s>" ]

[ "Emit", "a", "MachineInstr", "with", "two", "register", "operands", "and", "a", "result", "register", "in", "the", "given", "register", "class", "." ]

[ "ARM", "ARM", "1", "2", "1", "0" ]

[]

[ "<s>", "void", "Cpu0MCInstLower", "::", "Initialize", "(", "MCContext", "*", "C", ")", "{", "Ctx", "=", "C", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "static", "rtx", "altivec_expand_ld_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "bool", "*", "expandedp", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "unsigned", "int", "fcode", "=", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "tree", "arg0", ";", "machine_mode", "tmode", ",", "mode0", ";", "rtx", "pat", ",", "op0", ";", "enum", "insn_code", "icode", ";", "switch", "(", "fcode", ")", "{", "case", "ALTIVEC_BUILTIN_LD_INTERNAL_16qi", ":", "icode", "=", "CODE_FOR_vector_altivec_load_v16qi", ";", "break", ";", "case", "ALTIVEC_BUILTIN_LD_INTERNAL_8hi", ":", "icode", "=", "CODE_FOR_vector_altivec_load_v8hi", ";", "break", ";", "case", "ALTIVEC_BUILTIN_LD_INTERNAL_4si", ":", "icode", "=", "CODE_FOR_vector_altivec_load_v4si", ";", "break", ";", "case", "ALTIVEC_BUILTIN_LD_INTERNAL_4sf", ":", "icode", "=", "CODE_FOR_vector_altivec_load_v4sf", ";", "break", ";", "case", "ALTIVEC_BUILTIN_LD_INTERNAL_2df", ":", "icode", "=", "CODE_FOR_vector_altivec_load_v2df", ";", "break", ";", "case", "ALTIVEC_BUILTIN_LD_INTERNAL_2di", ":", "icode", "=", "CODE_FOR_vector_altivec_load_v2di", ";", "break", ";", "case", "ALTIVEC_BUILTIN_LD_INTERNAL_1ti", ":", "icode", "=", "CODE_FOR_vector_altivec_load_v1ti", ";", "break", ";", "default", ":", "*", "expandedp", "=", "false", ";", "return", "NULL_RTX", ";", "}", "*", "expandedp", "=", "true", ";", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "op0", "=", "expand_normal", "(", "arg0", ")", ";", "tmode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "mode0", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "1", "]", ".", "mode", ";", "if", "(", "target", "==", "0", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "predicate", ")", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "1", "]", ".", "predicate", ")", "(", "op0", ",", "mode0", ")", ")", "op0", "=", "gen_rtx_MEM", "(", "mode0", ",", "copy_to_mode_reg", "(", "Pmode", ",", "op0", ")", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op0", ")", ";", "if", "(", "!", "pat", ")", "return", "0", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

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

[ "powerpcspe", "0", "0", "0", "1", "0", "0", "1", "0" ]

[]

[ "<s>", "bool", "arm_frame_pointer_required", "(", "void", ")", "{", "if", "(", "SUBTARGET_FRAME_POINTER_REQUIRED", ")", "return", "true", ";", "if", "(", "cfun", "->", "has_nonlocal_label", ")", "return", "true", ";", "if", "(", "TARGET_ARM", "&&", "TARGET_APCS_FRAME", "&&", "!", "crtl", "->", "is_leaf", ")", "return", "true", ";", "if", "(", "!", "IS_INTERRUPT", "(", "arm_current_func_type", "(", ")", ")", "&&", "(", "flag_stack_check", "==", "STATIC_BUILTIN_STACK_CHECK", "||", "flag_stack_clash_protection", ")", "&&", "arm_except_unwind_info", "(", "&", "global_options", ")", "==", "UI_TARGET", "&&", "cfun", "->", "can_throw_non_call_exceptions", ")", "{", "HOST_WIDE_INT", "size", "=", "get_frame_size", "(", ")", ";", "if", "(", "size", "<=", "0", ")", "return", "false", ";", "if", "(", "crtl", "->", "is_leaf", "&&", "!", "cfun", "->", "calls_alloca", ")", "{", "size", "+=", "32", "*", "UNITS_PER_WORD", ";", "if", "(", "size", ">", "PROBE_INTERVAL", "&&", "size", ">", "get_stack_check_protect", "(", ")", ")", "return", "true", ";", "}", "else", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_FRAME_POINTER_REQUIRED", "." ]

[ "arm", "0", "32" ]

[]

[ "<s>", "static", "unsigned", "nvptx_process_pars", "(", "parallel", "*", "par", ")", "{", "if", "(", "nvptx_optimize", ")", "nvptx_optimize_inner", "(", "par", ")", ";", "unsigned", "inner_mask", "=", "par", "->", "mask", ";", "if", "(", "par", "->", "inner", ")", "{", "par", "->", "inner_mask", "=", "nvptx_process_pars", "(", "par", "->", "inner", ")", ";", "inner_mask", "|=", "par", "->", "inner_mask", ";", "}", "bool", "is_call", "=", "(", "par", "->", "mask", "&", "GOMP_DIM_MASK", "(", "GOMP_DIM_MAX", ")", ")", "!=", "0", ";", "if", "(", "par", "->", "mask", "&", "GOMP_DIM_MASK", "(", "GOMP_DIM_WORKER", ")", ")", "{", "nvptx_wpropagate", "(", "false", ",", "is_call", ",", "par", "->", "forked_block", ",", "par", "->", "forked_insn", ")", ";", "bool", "empty", "=", "nvptx_wpropagate", "(", "true", ",", "is_call", ",", "par", "->", "forked_block", ",", "par", "->", "fork_insn", ")", ";", "if", "(", "!", "empty", "||", "!", "is_call", ")", "{", "emit_insn_before", "(", "nvptx_wsync", "(", "false", ")", ",", "par", "->", "forked_insn", ")", ";", "emit_insn_before", "(", "nvptx_wsync", "(", "true", ")", ",", "par", "->", "join_insn", ")", ";", "}", "}", "else", "if", "(", "par", "->", "mask", "&", "GOMP_DIM_MASK", "(", "GOMP_DIM_VECTOR", ")", ")", "nvptx_vpropagate", "(", "is_call", ",", "par", "->", "forked_block", ",", "par", "->", "forked_insn", ")", ";", "if", "(", "par", "->", "next", ")", "inner_mask", "|=", "nvptx_process_pars", "(", "par", "->", "next", ")", ";", "return", "inner_mask", ";", "}", "</s>" ]

[ "Process", "the", "parallel", "PAR", "and", "all", "its", "contained", "parallels", ".", "We", "do", "everything", "but", "the", "neutering", ".", "Return", "mask", "of", "partitioned", "modes", "used", "within", "this", "parallel", "." ]

[ "nvptx", "0" ]

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "emitFrameDirective", "(", ")", "{", "const", "TargetRegisterInfo", "&", "RI", "=", "*", "TM", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "stackReg", "=", "RI", ".", "getFrameRegister", "(", "*", "MF", ")", ";", "unsigned", "returnReg", "=", "RI", ".", "getRARegister", "(", ")", ";", "unsigned", "stackSize", "=", "MF", "->", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "O", "<<", "\"\\t.frame\\t\"", "<<", "'$'", "<<", "LowercaseString", "(", "getRegisterName", "(", "stackReg", ")", ")", "<<", "','", "<<", "stackSize", "<<", "','", "<<", "'$'", "<<", "LowercaseString", "(", "getRegisterName", "(", "returnReg", ")", ")", "<<", "'\\n'", ";", "}", "</s>" ]

[ "Frame", "Directive", "." ]

[ "Mips", "Mips", "\"\\t.frame\\t\"" ]

[]

[ "<s>", "SDNode", "*", "SITargetLowering", "::", "legalizeTargetIndependentNode", "(", "SDNode", "*", "Node", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "Node", "->", "getOpcode", "(", ")", "==", "ISD", "::", "CopyToReg", ")", "{", "RegisterSDNode", "*", "DestReg", "=", "cast", "<", "RegisterSDNode", ">", "(", "Node", "->", "getOperand", "(", "1", ")", ")", ";", "SDValue", "SrcVal", "=", "Node", "->", "getOperand", "(", "2", ")", ";", "if", "(", "SrcVal", ".", "getValueType", "(", ")", "==", "MVT", "::", "i1", "&&", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "DestReg", "->", "getReg", "(", ")", ")", ")", "{", "SDLoc", "SL", "(", "Node", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ";", "SDValue", "VReg", "=", "DAG", ".", "getRegister", "(", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "VReg_1RegClass", ")", ",", "MVT", "::", "i1", ")", ";", "SDNode", "*", "Glued", "=", "Node", "->", "getGluedNode", "(", ")", ";", "SDValue", "ToVReg", "=", "DAG", ".", "getCopyToReg", "(", "Node", "->", "getOperand", "(", "0", ")", ",", "SL", ",", "VReg", ",", "SrcVal", ",", "SDValue", "(", "Glued", ",", "Glued", "?", "Glued", "->", "getNumValues", "(", ")", "-", "1", ":", "0", ")", ")", ";", "SDValue", "ToResultReg", "=", "DAG", ".", "getCopyToReg", "(", "ToVReg", ",", "SL", ",", "SDValue", "(", "DestReg", ",", "0", ")", ",", "VReg", ",", "ToVReg", ".", "getValue", "(", "1", ")", ")", ";", "DAG", ".", "ReplaceAllUsesWith", "(", "Node", ",", "ToResultReg", ".", "getNode", "(", ")", ")", ";", "DAG", ".", "RemoveDeadNode", "(", "Node", ")", ";", "return", "ToResultReg", ".", "getNode", "(", ")", ";", "}", "}", "SmallVector", "<", "SDValue", ",", "8", ">", "Ops", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Node", "->", "getNumOperands", "(", ")", ";", "++", "i", ")", "{", "if", "(", "!", "isFrameIndexOp", "(", "Node", "->", "getOperand", "(", "i", ")", ")", ")", "{", "Ops", ".", "push_back", "(", "Node", "->", "getOperand", "(", "i", ")", ")", ";", "continue", ";", "}", "SDLoc", "DL", "(", "Node", ")", ";", "Ops", ".", "push_back", "(", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "AMDGPU", "::", "S_MOV_B32", ",", "DL", ",", "Node", "->", "getOperand", "(", "i", ")", ".", "getValueType", "(", ")", ",", "Node", "->", "getOperand", "(", "i", ")", ")", ",", "0", ")", ")", ";", "}", "return", "DAG", ".", "UpdateNodeOperands", "(", "Node", ",", "Ops", ")", ";", "}", "</s>" ]

[ "Legalize", "target", "independent", "instructions", "(", "e.g", "." ]

[ "AMDGPU", "SI", "ISD::CopyToReg", "1", "2", "MVT::i1", "AMDGPU::VReg_1RegClass", "MVT::i1", "0", "1", "0", "0", "1", "8", "0", "AMDGPU::S_MOV_B32", "0" ]

[]

[ "<s>", "void", "WebAssemblyTargetAsmStreamer", "::", "emitImportModule", "(", "const", "MCSymbolWasm", "*", "Sym", ",", "StringRef", "ModuleName", ")", "{", "OS", "<<", "\"\\t.import_module\\t\"", "<<", "Sym", "->", "getName", "(", ")", "<<", "\", \"", "<<", "ModuleName", "<<", "'\\n'", ";", "}", "</s>" ]

[ ".import_module" ]

[ "WebAssembly", "WebAssembly", "\"\\t.import_module\\t\"", "\", \"" ]

[]

[ "<s>", "static", "bool", "ix86_expand_vector_init_one_var", "(", "bool", "mmx_ok", ",", "machine_mode", "mode", ",", "rtx", "target", ",", "rtx", "vals", ",", "int", "one_var", ")", "{", "rtx", "var", "=", "XVECEXP", "(", "vals", ",", "0", ",", "one_var", ")", ";", "machine_mode", "wmode", ";", "rtx", "const_vec", ",", "x", ";", "const_vec", "=", "copy_rtx", "(", "vals", ")", ";", "XVECEXP", "(", "const_vec", ",", "0", ",", "one_var", ")", "=", "CONST0_RTX", "(", "GET_MODE_INNER", "(", "mode", ")", ")", ";", "const_vec", "=", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "XVEC", "(", "const_vec", ",", "0", ")", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_V2DFmode", ":", "case", "E_V2DImode", ":", "case", "E_V2SFmode", ":", "case", "E_V2SImode", ":", "return", "false", ";", "case", "E_V4DImode", ":", "if", "(", "!", "TARGET_64BIT", ")", "return", "false", ";", "case", "E_V4DFmode", ":", "case", "E_V8SFmode", ":", "case", "E_V8SImode", ":", "case", "E_V16HImode", ":", "case", "E_V32QImode", ":", "case", "E_V4SFmode", ":", "case", "E_V4SImode", ":", "case", "E_V8HImode", ":", "case", "E_V4HImode", ":", "break", ";", "case", "E_V16QImode", ":", "if", "(", "TARGET_SSE4_1", ")", "break", ";", "wmode", "=", "V8HImode", ";", "goto", "widen", ";", "case", "E_V8QImode", ":", "wmode", "=", "V4HImode", ";", "goto", "widen", ";", "widen", ":", "x", "=", "XVECEXP", "(", "vals", ",", "0", ",", "one_var", "^", "1", ")", ";", "if", "(", "one_var", "&", "1", ")", "{", "var", "=", "convert_modes", "(", "HImode", ",", "QImode", ",", "var", ",", "true", ")", ";", "var", "=", "expand_simple_binop", "(", "HImode", ",", "ASHIFT", ",", "var", ",", "GEN_INT", "(", "8", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "x", "=", "GEN_INT", "(", "INTVAL", "(", "x", ")", "&", "0xff", ")", ";", "}", "else", "{", "var", "=", "convert_modes", "(", "HImode", ",", "QImode", ",", "var", ",", "true", ")", ";", "x", "=", "gen_int_mode", "(", "UINTVAL", "(", "x", ")", "<<", "8", ",", "HImode", ")", ";", "}", "if", "(", "x", "!=", "const0_rtx", ")", "var", "=", "expand_simple_binop", "(", "HImode", ",", "IOR", ",", "var", ",", "x", ",", "var", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "x", "=", "gen_reg_rtx", "(", "wmode", ")", ";", "emit_move_insn", "(", "x", ",", "gen_lowpart", "(", "wmode", ",", "const_vec", ")", ")", ";", "ix86_expand_vector_set", "(", "mmx_ok", ",", "x", ",", "var", ",", "one_var", ">>", "1", ")", ";", "emit_move_insn", "(", "target", ",", "gen_lowpart", "(", "mode", ",", "x", ")", ")", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}", "emit_move_insn", "(", "target", ",", "const_vec", ")", ";", "ix86_expand_vector_set", "(", "mmx_ok", ",", "target", ",", "var", ",", "one_var", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "ix86_expand_vector_init", ".", "Store", "into", "TARGET", "a", "vector", "consisting", "of", "the", "values", "in", "VALS", ".", "It", "is", "known", "that", "all", "elements", "except", "ONE_VAR", "are", "constants", ".", "Return", "true", "if", "successful", "." ]

[ "i386", "0", "0", "0", "0", "1", "1", "8", "1", "0xff", "8", "1", "1" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "switch", "(", "Kind", ")", "{", "case", "k_Immediate", ":", "OS", "<<", "\"Imm<\"", ";", "OS", "<<", "*", "Imm", ".", "Val", ";", "OS", "<<", "\">\"", ";", "break", ";", "case", "k_Memory", ":", "OS", "<<", "\"Mem<\"", ";", "Mem", ".", "Base", "->", "print", "(", "OS", ")", ";", "OS", "<<", "\", \"", ";", "OS", "<<", "*", "Mem", ".", "Off", ";", "OS", "<<", "\">\"", ";", "break", ";", "case", "k_RegisterIndex", ":", "OS", "<<", "\"RegIdx<\"", "<<", "RegIdx", ".", "Index", "<<", "\":\"", "<<", "RegIdx", ".", "Kind", "<<", "\", \"", "<<", "StringRef", "(", "RegIdx", ".", "Tok", ".", "Data", ",", "RegIdx", ".", "Tok", ".", "Length", ")", "<<", "\">\"", ";", "break", ";", "case", "k_Token", ":", "OS", "<<", "getToken", "(", ")", ";", "break", ";", "case", "k_RegList", ":", "OS", "<<", "\"RegList< \"", ";", "for", "(", "auto", "Reg", ":", "(", "*", "RegList", ".", "List", ")", ")", "OS", "<<", "Reg", "<<", "\" \"", ";", "OS", "<<", "\">\"", ";", "break", ";", "}", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "Mips", "\"Imm<\"", "\">\"", "\"Mem<\"", "\", \"", "\">\"", "\"RegIdx<\"", "\":\"", "\", \"", "\">\"", "\"RegList< \"", "\" \"", "\">\"" ]

[]

[ "<s>", "bool", "ARMCallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "ArrayRef", "<", "Register", ">>", "VRegs", ",", "FunctionLoweringInfo", "&", "FLI", ")", "const", "{", "auto", "&", "TLI", "=", "*", "getTLI", "<", "ARMTargetLowering", ">", "(", ")", ";", "auto", "Subtarget", "=", "TLI", ".", "getSubtarget", "(", ")", ";", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "return", "false", ";", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "return", "false", ";", "auto", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "auto", "&", "MBB", "=", "MIRBuilder", ".", "getMBB", "(", ")", ";", "auto", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "!", "isSupportedType", "(", "DL", ",", "TLI", ",", "Arg", ".", "getType", "(", ")", ")", ")", "return", "false", ";", "if", "(", "Arg", ".", "hasPassPointeeByValueCopyAttr", "(", ")", ")", "return", "false", ";", "}", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ";", "FormalArgHandler", "ArgHandler", "(", "MIRBuilder", ",", "MIRBuilder", ".", "getMF", "(", ")", ".", "getRegInfo", "(", ")", ",", "AssignFn", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgInfos", ";", "unsigned", "Idx", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "ArgInfo", "OrigArgInfo", "(", "VRegs", "[", "Idx", "]", ",", "Arg", ".", "getType", "(", ")", ")", ";", "setArgFlags", "(", "OrigArgInfo", ",", "Idx", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "OrigArgInfo", ",", "SplitArgInfos", ",", "MF", ")", ";", "Idx", "++", ";", "}", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "setInstr", "(", "*", "MBB", ".", "begin", "(", ")", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgInfos", ",", "ArgHandler", ")", ")", "return", "false", ";", "MIRBuilder", ".", "setMBB", "(", "MBB", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

[ "ARM", "ARM", "ARM", "8", "0" ]

[]

[ "<s>", "std", "::", "pair", "<", "uint16_t", ",", "uint16_t", ">", "ARMBaseInstrInfo", "::", "getExecutionDomain", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "Subtarget", ".", "hasNEON", "(", ")", ")", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "VMOVD", "&&", "!", "isPredicated", "(", "MI", ")", ")", "return", "std", "::", "make_pair", "(", "ExeVFP", ",", "(", "1", "<<", "ExeVFP", ")", "|", "(", "1", "<<", "ExeNEON", ")", ")", ";", "if", "(", "Subtarget", ".", "useNEONForFPMovs", "(", ")", "&&", "!", "isPredicated", "(", "MI", ")", "&&", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "VMOVRS", "||", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "VMOVSR", "||", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "VMOVS", ")", ")", "return", "std", "::", "make_pair", "(", "ExeVFP", ",", "(", "1", "<<", "ExeVFP", ")", "|", "(", "1", "<<", "ExeNEON", ")", ")", ";", "}", "unsigned", "Domain", "=", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ";", "if", "(", "Domain", "&", "ARMII", "::", "DomainNEON", ")", "return", "std", "::", "make_pair", "(", "ExeNEON", ",", "0", ")", ";", "if", "(", "(", "Domain", "&", "ARMII", "::", "DomainNEONA8", ")", "&&", "Subtarget", ".", "isCortexA8", "(", ")", ")", "return", "std", "::", "make_pair", "(", "ExeNEON", ",", "0", ")", ";", "if", "(", "Domain", "&", "ARMII", "::", "DomainVFP", ")", "return", "std", "::", "make_pair", "(", "ExeVFP", ",", "0", ")", ";", "return", "std", "::", "make_pair", "(", "ExeGeneric", ",", "0", ")", ";", "}", "</s>" ]

[ "Return", "the", "current", "execution", "domain", "and", "bit", "mask", "of", "possible", "domains", "for", "instruction", "." ]

[ "ARM", "ARM", "ARM::VMOVD", "1", "1", "ARM::VMOVRS", "ARM::VMOVSR", "ARM::VMOVS", "1", "1", "ARMII::DomainMask", "ARMII::DomainNEON", "0", "ARMII::DomainNEONA8", "0", "ARMII::DomainVFP", "0", "0" ]

[]

[ "<s>", "void", "SIFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "FuncInfo", "->", "isEntryFunction", "(", ")", ")", "{", "emitEntryFunctionPrologue", "(", "MF", ",", "MBB", ")", ";", "return", ";", "}", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "const", "SIRegisterInfo", "&", "TRI", "=", "TII", "->", "getRegisterInfo", "(", ")", ";", "unsigned", "StackPtrReg", "=", "FuncInfo", "->", "getStackPtrOffsetReg", "(", ")", ";", "unsigned", "FramePtrReg", "=", "FuncInfo", "->", "getFrameOffsetReg", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "bool", "NeedFP", "=", "hasFP", "(", "MF", ")", ";", "uint32_t", "NumBytes", "=", "MFI", ".", "getStackSize", "(", ")", ";", "uint32_t", "RoundedSize", "=", "NumBytes", ";", "const", "bool", "NeedsRealignment", "=", "TRI", ".", "needsStackRealignment", "(", "MF", ")", ";", "if", "(", "NeedsRealignment", ")", "{", "assert", "(", "NeedFP", ")", ";", "const", "unsigned", "Alignment", "=", "MFI", ".", "getMaxAlignment", "(", ")", ";", "RoundedSize", "+=", "Alignment", ";", "unsigned", "ScratchSPReg", "=", "findScratchNonCalleeSaveRegister", "(", "MBB", ")", ";", "assert", "(", "ScratchSPReg", "!=", "AMDGPU", "::", "NoRegister", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_ADD_U32", ")", ",", "ScratchSPReg", ")", ".", "addReg", "(", "StackPtrReg", ")", ".", "addImm", "(", "(", "Alignment", "-", "1", ")", "*", "ST", ".", "getWavefrontSize", "(", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_AND_B32", ")", ",", "FramePtrReg", ")", ".", "addReg", "(", "ScratchSPReg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "-", "Alignment", "*", "ST", ".", "getWavefrontSize", "(", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "FuncInfo", "->", "setIsStackRealigned", "(", "true", ")", ";", "}", "else", "if", "(", "NeedFP", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "COPY", ")", ",", "FramePtrReg", ")", ".", "addReg", "(", "StackPtrReg", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "if", "(", "RoundedSize", "!=", "0", "&&", "hasSP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_ADD_U32", ")", ",", "StackPtrReg", ")", ".", "addReg", "(", "StackPtrReg", ")", ".", "addImm", "(", "RoundedSize", "*", "ST", ".", "getWavefrontSize", "(", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "for", "(", "const", "SIMachineFunctionInfo", "::", "SGPRSpillVGPRCSR", "&", "Reg", ":", "FuncInfo", "->", "getSGPRSpillVGPRs", "(", ")", ")", "{", "if", "(", "!", "Reg", ".", "FI", ".", "hasValue", "(", ")", ")", "continue", ";", "TII", "->", "storeRegToStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ".", "VGPR", ",", "true", ",", "Reg", ".", "FI", ".", "getValue", "(", ")", ",", "&", "AMDGPU", "::", "VGPR_32RegClass", ",", "&", "TII", "->", "getRegisterInfo", "(", ")", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "AMDGPU::NoRegister", "AMDGPU::S_ADD_U32", "1", "AMDGPU::S_AND_B32", "AMDGPU::COPY", "0", "AMDGPU::S_ADD_U32", "SI", "AMDGPU::VGPR_32RegClass" ]

[]

[ "<s>", "bool", "evaluateBranch", "(", "const", "MCInst", "&", "Inst", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ",", "uint64_t", "&", "Target", ")", "const", "override", "{", "int16_t", "Imm", ";", "if", "(", "isConditionalBranch", "(", "Inst", ")", ")", "{", "Imm", "=", "Inst", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "}", "else", "if", "(", "isUnconditionalBranch", "(", "Inst", ")", ")", "Imm", "=", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "else", "return", "false", ";", "Target", "=", "Addr", "+", "Size", "+", "Imm", "*", "Size", ";", "return", "true", ";", "}", "</s>" ]

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

[ "BPF", "2", "0" ]

[]

[ "<s>", "MCSymbol", "*", "X86AsmPrinter", "::", "GetCPISymbol", "(", "unsigned", "CPID", ")", "const", "{", "if", "(", "Subtarget", "->", "isTargetKnownWindowsMSVC", "(", ")", ")", "{", "const", "MachineConstantPoolEntry", "&", "CPE", "=", "MF", "->", "getConstantPool", "(", ")", "->", "getConstants", "(", ")", "[", "CPID", "]", ";", "if", "(", "!", "CPE", ".", "isMachineConstantPoolEntry", "(", ")", ")", "{", "const", "DataLayout", "&", "DL", "=", "MF", "->", "getDataLayout", "(", ")", ";", "SectionKind", "Kind", "=", "CPE", ".", "getSectionKind", "(", "&", "DL", ")", ";", "const", "Constant", "*", "C", "=", "CPE", ".", "Val", ".", "ConstVal", ";", "if", "(", "const", "MCSectionCOFF", "*", "S", "=", "dyn_cast", "<", "MCSectionCOFF", ">", "(", "getObjFileLowering", "(", ")", ".", "getSectionForConstant", "(", "DL", ",", "Kind", ",", "C", ")", ")", ")", "{", "if", "(", "MCSymbol", "*", "Sym", "=", "S", "->", "getCOMDATSymbol", "(", ")", ")", "{", "if", "(", "Sym", "->", "isUndefined", "(", ")", ")", "OutStreamer", "->", "EmitSymbolAttribute", "(", "Sym", ",", "MCSA_Global", ")", ";", "return", "Sym", ";", "}", "}", "}", "}", "return", "AsmPrinter", "::", "GetCPISymbol", "(", "CPID", ")", ";", "}", "</s>" ]

[ "Return", "the", "symbol", "for", "the", "specified", "constant", "pool", "entry", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "static", "void", "i386_output_dwarf_dtprel", "(", "FILE", "*", "file", ",", "int", "size", ",", "rtx", "x", ")", "{", "fputs", "(", "ASM_LONG", ",", "file", ")", ";", "output_addr_const", "(", "file", ",", "x", ")", ";", "fputs", "(", "\"@DTPOFF\"", ",", "file", ")", ";", "switch", "(", "size", ")", "{", "case", "4", ":", "break", ";", "case", "8", ":", "fputs", "(", "\", 0\"", ",", "file", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "This", "is", "called", "from", "dwarf2out.cc", "via", "TARGET_ASM_OUTPUT_DWARF_DTPREL", ".", "We", "need", "to", "emit", "DTP-relative", "relocations", "." ]

[ "i386", "\"@DTPOFF\"", "4", "8", "\", 0\"" ]

[]

[ "<s>", "int", "ARM64FrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "return", "resolveFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ")", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64" ]

[]

[ "<s>", "SDValue", "SITargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUTargetLowering", "::", "PerformDAGCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "FADD", ":", "return", "performFAddCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "FSUB", ":", "return", "performFSubCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "performSetCCCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "FMAXNUM", ":", "case", "ISD", "::", "FMINNUM", ":", "case", "ISD", "::", "SMAX", ":", "case", "ISD", "::", "SMIN", ":", "case", "ISD", "::", "UMAX", ":", "case", "ISD", "::", "UMIN", ":", "case", "AMDGPUISD", "::", "FMIN_LEGACY", ":", "case", "AMDGPUISD", "::", "FMAX_LEGACY", ":", "{", "if", "(", "DCI", ".", "getDAGCombineLevel", "(", ")", ">=", "AfterLegalizeDAG", "&&", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "return", "performMinMaxCombine", "(", "N", ",", "DCI", ")", ";", "break", ";", "}", "case", "ISD", "::", "LOAD", ":", "case", "ISD", "::", "STORE", ":", "case", "ISD", "::", "ATOMIC_LOAD", ":", "case", "ISD", "::", "ATOMIC_STORE", ":", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "case", "ISD", "::", "ATOMIC_CMP_SWAP_WITH_SUCCESS", ":", "case", "ISD", "::", "ATOMIC_SWAP", ":", "case", "ISD", "::", "ATOMIC_LOAD_ADD", ":", "case", "ISD", "::", "ATOMIC_LOAD_SUB", ":", "case", "ISD", "::", "ATOMIC_LOAD_AND", ":", "case", "ISD", "::", "ATOMIC_LOAD_OR", ":", "case", "ISD", "::", "ATOMIC_LOAD_XOR", ":", "case", "ISD", "::", "ATOMIC_LOAD_NAND", ":", "case", "ISD", "::", "ATOMIC_LOAD_MIN", ":", "case", "ISD", "::", "ATOMIC_LOAD_MAX", ":", "case", "ISD", "::", "ATOMIC_LOAD_UMIN", ":", "case", "ISD", "::", "ATOMIC_LOAD_UMAX", ":", "case", "AMDGPUISD", "::", "ATOMIC_INC", ":", "case", "AMDGPUISD", "::", "ATOMIC_DEC", ":", "if", "(", "DCI", ".", "isBeforeLegalize", "(", ")", ")", "break", ";", "return", "performMemSDNodeCombine", "(", "cast", "<", "MemSDNode", ">", "(", "N", ")", ",", "DCI", ")", ";", "case", "ISD", "::", "AND", ":", "return", "performAndCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "OR", ":", "return", "performOrCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "XOR", ":", "return", "performXorCombine", "(", "N", ",", "DCI", ")", ";", "case", "AMDGPUISD", "::", "FP_CLASS", ":", "return", "performClassCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "FCANONICALIZE", ":", "return", "performFCanonicalizeCombine", "(", "N", ",", "DCI", ")", ";", "case", "AMDGPUISD", "::", "FRACT", ":", "case", "AMDGPUISD", "::", "RCP", ":", "case", "AMDGPUISD", "::", "RSQ", ":", "case", "AMDGPUISD", "::", "RCP_LEGACY", ":", "case", "AMDGPUISD", "::", "RSQ_LEGACY", ":", "case", "AMDGPUISD", "::", "RSQ_CLAMP", ":", "case", "AMDGPUISD", "::", "LDEXP", ":", "{", "SDValue", "Src", "=", "N", "->", "getOperand", "(", "0", ")", ";", "if", "(", "Src", ".", "isUndef", "(", ")", ")", "return", "Src", ";", "break", ";", "}", "case", "ISD", "::", "SINT_TO_FP", ":", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "performUCharToFloatCombine", "(", "N", ",", "DCI", ")", ";", "case", "AMDGPUISD", "::", "CVT_F32_UBYTE0", ":", "case", "AMDGPUISD", "::", "CVT_F32_UBYTE1", ":", "case", "AMDGPUISD", "::", "CVT_F32_UBYTE2", ":", "case", "AMDGPUISD", "::", "CVT_F32_UBYTE3", ":", "return", "performCvtF32UByteNCombine", "(", "N", ",", "DCI", ")", ";", "case", "AMDGPUISD", "::", "FMED3", ":", "return", "performFMed3Combine", "(", "N", ",", "DCI", ")", ";", "case", "AMDGPUISD", "::", "CVT_PKRTZ_F16_F32", ":", "return", "performCvtPkRTZCombine", "(", "N", ",", "DCI", ")", ";", "}", "return", "AMDGPUTargetLowering", "::", "PerformDAGCombine", "(", "N", ",", "DCI", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU", "ISD::FADD", "ISD::FSUB", "ISD::SETCC", "ISD::FMAXNUM", "ISD::FMINNUM", "ISD::SMAX", "ISD::SMIN", "ISD::UMAX", "ISD::UMIN", "AMDGPUISD::FMIN_LEGACY", "AMDGPUISD::FMAX_LEGACY", "ISD::LOAD", "ISD::STORE", "ISD::ATOMIC_LOAD", "ISD::ATOMIC_STORE", "ISD::ATOMIC_CMP_SWAP", "ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS", "ISD::ATOMIC_SWAP", "ISD::ATOMIC_LOAD_ADD", "ISD::ATOMIC_LOAD_SUB", "ISD::ATOMIC_LOAD_AND", "ISD::ATOMIC_LOAD_OR", "ISD::ATOMIC_LOAD_XOR", "ISD::ATOMIC_LOAD_NAND", "ISD::ATOMIC_LOAD_MIN", "ISD::ATOMIC_LOAD_MAX", "ISD::ATOMIC_LOAD_UMIN", "ISD::ATOMIC_LOAD_UMAX", "AMDGPUISD::ATOMIC_INC", "AMDGPUISD::ATOMIC_DEC", "ISD::AND", "ISD::OR", "ISD::XOR", "AMDGPUISD::FP_CLASS", "ISD::FCANONICALIZE", "AMDGPUISD::FRACT", "AMDGPUISD::RCP", "AMDGPUISD::RSQ", "AMDGPUISD::RCP_LEGACY", "AMDGPUISD::RSQ_LEGACY", "AMDGPUISD::RSQ_CLAMP", "AMDGPUISD::LDEXP", "0", "ISD::SINT_TO_FP", "ISD::UINT_TO_FP", "AMDGPUISD::CVT_F32_UBYTE0", "AMDGPUISD::CVT_F32_UBYTE1", "AMDGPUISD::CVT_F32_UBYTE2", "AMDGPUISD::CVT_F32_UBYTE3", "AMDGPUISD::FMED3", "AMDGPUISD::CVT_PKRTZ_F16_F32", "AMDGPU" ]

[]

[ "<s>", "Register", "getStackAddress", "(", "uint64_t", "Size", ",", "int64_t", "Offset", ",", "MachinePointerInfo", "&", "MPO", ")", "override", "{", "assert", "(", "(", "Size", "==", "1", "||", "Size", "==", "2", "||", "Size", "==", "4", "||", "Size", "==", "8", ")", "&&", "\"Unsupported size\"", ")", ";", "auto", "&", "MFI", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFrameInfo", "(", ")", ";", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "Size", ",", "Offset", ",", "true", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MIRBuilder", ".", "getMF", "(", ")", ",", "FI", ")", ";", "return", "MIRBuilder", ".", "buildFrameIndex", "(", "LLT", "::", "pointer", "(", "MPO", ".", "getAddrSpace", "(", ")", ",", "32", ")", ",", "FI", ")", ".", "getReg", "(", "0", ")", ";", "}", "</s>" ]

[ "Materialize", "a", "VReg", "containing", "the", "address", "of", "the", "specified", "stack-based", "object", "." ]

[ "ARM", "1", "2", "4", "8", "\"Unsupported size\"", "32", "0" ]

[]

[ "<s>", "void", "tilegx_expand_smuldi3_highpart", "(", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "op2", ")", "{", "tilegx_expand_high_multiply", "(", "op0", ",", "op1", ",", "op2", ",", "true", ")", ";", "}", "</s>" ]

[ "Implement", "smuldi3_highpart", "." ]

[ "tilegx" ]

[]

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

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

[ "i386", "0" ]

[]

[ "<s>", "static", "int", "rs6000_issue_rate", "(", "void", ")", "{", "if", "(", "!", "reload_completed", "&&", "!", "flag_sched_pressure", ")", "return", "1", ";", "switch", "(", "rs6000_tune", ")", "{", "case", "PROCESSOR_RS64A", ":", "case", "PROCESSOR_PPC601", ":", "case", "PROCESSOR_PPC7450", ":", "return", "3", ";", "case", "PROCESSOR_PPC440", ":", "case", "PROCESSOR_PPC603", ":", "case", "PROCESSOR_PPC750", ":", "case", "PROCESSOR_PPC7400", ":", "case", "PROCESSOR_PPC8540", ":", "case", "PROCESSOR_PPC8548", ":", "case", "PROCESSOR_CELL", ":", "case", "PROCESSOR_PPCE300C2", ":", "case", "PROCESSOR_PPCE300C3", ":", "case", "PROCESSOR_PPCE500MC", ":", "case", "PROCESSOR_PPCE500MC64", ":", "case", "PROCESSOR_PPCE5500", ":", "case", "PROCESSOR_PPCE6500", ":", "case", "PROCESSOR_TITAN", ":", "return", "2", ";", "case", "PROCESSOR_PPC476", ":", "case", "PROCESSOR_PPC604", ":", "case", "PROCESSOR_PPC604e", ":", "case", "PROCESSOR_PPC620", ":", "case", "PROCESSOR_PPC630", ":", "return", "4", ";", "case", "PROCESSOR_POWER4", ":", "case", "PROCESSOR_POWER5", ":", "case", "PROCESSOR_POWER6", ":", "case", "PROCESSOR_POWER7", ":", "return", "5", ";", "case", "PROCESSOR_POWER8", ":", "return", "7", ";", "case", "PROCESSOR_POWER9", ":", "return", "6", ";", "default", ":", "return", "1", ";", "}", "}", "</s>" ]

[ "Return", "how", "many", "instructions", "the", "machine", "can", "issue", "per", "cycle", "." ]

[ "rs6000", "1", "3", "2", "4", "5", "7", "6", "1" ]

[]

[ "<s>", "static", "void", "write_return_mode", "(", "std", "::", "stringstream", "&", "s", ",", "bool", "for_proto", ",", "machine_mode", "mode", ")", "{", "const", "char", "*", "ptx_type", "=", "nvptx_ptx_type_from_mode", "(", "mode", ",", "false", ")", ";", "const", "char", "*", "pfx", "=", "\"\\t.reg\"", ";", "const", "char", "*", "sfx", "=", "\";\\n\"", ";", "if", "(", "for_proto", ")", "pfx", "=", "\"(.param\"", ",", "sfx", "=", "\"_out) \"", ";", "s", "<<", "pfx", "<<", "ptx_type", "<<", "\" \"", "<<", "reg_names", "[", "NVPTX_RETURN_REGNUM", "]", "<<", "sfx", ";", "}", "</s>" ]

[ "Emit", "a", "PTX", "return", "as", "a", "prototype", "or", "function", "prologue", "declaration", "for", "MODE", "." ]

[ "nvptx", "\"\\t.reg\"", "\";\\n\"", "\"(.param\"", "\"_out) \"", "\" \"" ]

[]

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

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

[ "Dcpu16", "DCPU16", "0" ]

[]

[ "<s>", "bool", "AMDGPUCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "B", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "Register", ">", "VRegs", ",", "FunctionLoweringInfo", "&", "FLI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "B", ".", "getMF", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setIfReturnsVoid", "(", "!", "Val", ")", ";", "assert", "(", "!", "Val", "==", "VRegs", ".", "empty", "(", ")", "&&", "\"Return value without a vreg\"", ")", ";", "CallingConv", "::", "ID", "CC", "=", "B", ".", "getMF", "(", ")", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "const", "bool", "IsShader", "=", "AMDGPU", "::", "isShader", "(", "CC", ")", ";", "const", "bool", "IsWaveEnd", "=", "(", "IsShader", "&&", "MFI", "->", "returnsVoid", "(", ")", ")", "||", "AMDGPU", "::", "isKernel", "(", "CC", ")", ";", "if", "(", "IsWaveEnd", ")", "{", "B", ".", "buildInstr", "(", "AMDGPU", "::", "S_ENDPGM", ")", ".", "addImm", "(", "0", ")", ";", "return", "true", ";", "}", "auto", "const", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "unsigned", "ReturnOpc", "=", "IsShader", "?", "AMDGPU", "::", "SI_RETURN_TO_EPILOG", ":", "AMDGPU", "::", "S_SETPC_B64_return", ";", "auto", "Ret", "=", "B", ".", "buildInstrNoInsert", "(", "ReturnOpc", ")", ";", "Register", "ReturnAddrVReg", ";", "if", "(", "ReturnOpc", "==", "AMDGPU", "::", "S_SETPC_B64_return", ")", "{", "ReturnAddrVReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "CCR_SGPR_64RegClass", ")", ";", "Ret", ".", "addUse", "(", "ReturnAddrVReg", ")", ";", "}", "if", "(", "!", "FLI", ".", "CanLowerReturn", ")", "insertSRetStores", "(", "B", ",", "Val", "->", "getType", "(", ")", ",", "VRegs", ",", "FLI", ".", "DemoteRegister", ")", ";", "else", "if", "(", "!", "lowerReturnVal", "(", "B", ",", "Val", ",", "VRegs", ",", "Ret", ")", ")", "return", "false", ";", "if", "(", "ReturnOpc", "==", "AMDGPU", "::", "S_SETPC_B64_return", ")", "{", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "Register", "LiveInReturn", "=", "MF", ".", "addLiveIn", "(", "TRI", "->", "getReturnAddressReg", "(", "MF", ")", ",", "&", "AMDGPU", "::", "SGPR_64RegClass", ")", ";", "B", ".", "buildCopy", "(", "ReturnAddrVReg", ",", "LiveInReturn", ")", ";", "}", "B", ".", "insertInstr", "(", "Ret", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "AMDGPU", "AMDGPU", "SI", "SI", "\"Return value without a vreg\"", "AMDGPU::isShader", "AMDGPU::isKernel", "AMDGPU::S_ENDPGM", "0", "AMDGPU::SI_RETURN_TO_EPILOG", "AMDGPU::S_SETPC_B64_return", "AMDGPU::S_SETPC_B64_return", "AMDGPU::CCR_SGPR_64RegClass", "AMDGPU::S_SETPC_B64_return", "SI", "AMDGPU::SGPR_64RegClass" ]

[]

[ "<s>", "void", "MBlazeInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "llvm", "::", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "MBlaze", "::", "ADDK", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addReg", "(", "MBlaze", "::", "R0", ")", ";", "}", "</s>" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "MBlaze", "MBlaze", "MBlaze::ADDK", "MBlaze::R0" ]

[]

[ "<s>", "bool", "ARMAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'a'", ":", "if", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "isReg", "(", ")", ")", "{", "O", "<<", "\"[\"", "<<", "ARMInstPrinter", "::", "getRegisterName", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", ")", "<<", "\"]\"", ";", "return", "false", ";", "}", "case", "'c'", ":", "if", "(", "!", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "isImm", "(", ")", ")", "return", "true", ";", "O", "<<", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getImm", "(", ")", ";", "return", "false", ";", "case", "'P'", ":", "case", "'q'", ":", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "case", "'Q'", ":", "case", "'R'", ":", "case", "'H'", ":", "return", "true", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "1", "0", "0", "\"[\"", "ARM", "\"]\"" ]

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DstReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opcode", ";", "if", "(", "RISCV", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "TRI", "->", "getRegSizeInBits", "(", "RISCV", "::", "GPRRegClass", ")", "==", "32", "?", "RISCV", "::", "LW", ":", "RISCV", "::", "LD", ";", "else", "if", "(", "RISCV", "::", "FPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FLW", ";", "else", "if", "(", "RISCV", "::", "FPR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FLD", ";", "else", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DstReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::GPRRegClass", "RISCV::GPRRegClass", "32", "RISCV::LW", "RISCV::LD", "RISCV::FPR32RegClass", "RISCV::FLW", "RISCV::FPR64RegClass", "RISCV::FLD", "\"Can't load this register from stack slot\"", "0" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "assert", "(", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectSize", "(", "FrameIdx", ")", ">=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", "&&", "\"Stack slot too small for store\"", ")", ";", "unsigned", "Alignment", "=", "std", "::", "max", "<", "uint32_t", ">", "(", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ",", "16", ")", ";", "bool", "isAligned", "=", "(", "Subtarget", ".", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ">=", "Alignment", ")", "||", "RI", ".", "canRealignStack", "(", "MF", ")", ";", "unsigned", "Opc", "=", "getStoreRegOpcode", "(", "SrcReg", ",", "RC", ",", "isAligned", ",", "Subtarget", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ")", ",", "FrameIdx", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"Stack slot too small for store\"", "16" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "getGOT", "(", "NodeTy", "*", "N", ",", "SelectionDAG", "&", "DAG", ",", "unsigned", "Flags", ")", "const", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"AArch64TargetLowering::getGOT\\n\"", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "EVT", "Ty", "=", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "SDValue", "GotAddr", "=", "getTargetNode", "(", "N", ",", "Ty", ",", "DAG", ",", "AArch64II", "::", "MO_GOT", "|", "Flags", ")", ";", "return", "DAG", ".", "getNode", "(", "AArch64ISD", "::", "LOADgot", ",", "DL", ",", "Ty", ",", "GotAddr", ")", ";", "}", "</s>" ]

[ "Return", "a", "pseudo", "source", "value", "referencing", "the", "global", "offset", "table", "(", "or", "something", "the", "like", ")", "." ]

[ "AArch64", "AArch64", "\"AArch64TargetLowering::getGOT\\n\"", "AArch64II::MO_GOT", "AArch64ISD::LOADgot" ]

[]

[ "<s>", "unsigned", "MipsMCCodeEmitter", "::", "getBranchTarget21OpValueMM", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ">>", "1", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"getBranchTarget21OpValueMM expects only expressions or immediates\"", ")", ";", "const", "MCExpr", "*", "FixupExpression", "=", "MCBinaryExpr", "::", "createAdd", "(", "MO", ".", "getExpr", "(", ")", ",", "MCConstantExpr", "::", "create", "(", "-", "4", ",", "Ctx", ")", ",", "Ctx", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "FixupExpression", ",", "MCFixupKind", "(", "Mips", "::", "fixup_MICROMIPS_PC21_S1", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getBranchTarget21OpValueMM", "-", "Return", "binary", "encoding", "of", "the", "branch", "target", "operand", "for", "microMIPS", "." ]

[ "Mips", "Mips", "1", "\"getBranchTarget21OpValueMM expects only expressions or immediates\"", "4", "0", "Mips::fixup_MICROMIPS_PC21_S1", "0" ]

[]

[ "<s>", "static", "bool", "mips_valid_pointer_mode", "(", "machine_mode", "mode", ")", "{", "return", "mode", "==", "SImode", "||", "(", "TARGET_64BIT", "&&", "mode", "==", "DImode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_VALID_POINTER_MODE", "." ]

[ "mips" ]

[]

[ "<s>", "MachineInstr", "*", "SPUInstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "Ops", ",", "int", "FrameIndex", ")", "const", "{", "if", "(", "Ops", ".", "size", "(", ")", "!=", "1", ")", "return", "0", ";", "unsigned", "OpNum", "=", "Ops", "[", "0", "]", ";", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "MachineInstr", "*", "NewMI", "=", "0", ";", "switch", "(", "Opc", ")", "{", "case", "SPU", "::", "ORv16i8", ":", "case", "SPU", "::", "ORv8i16", ":", "case", "SPU", "::", "ORv4i32", ":", "case", "SPU", "::", "ORv2i64", ":", "case", "SPU", "::", "ORr8", ":", "case", "SPU", "::", "ORr16", ":", "case", "SPU", "::", "ORr32", ":", "case", "SPU", "::", "ORr64", ":", "case", "SPU", "::", "ORf32", ":", "case", "SPU", "::", "ORf64", ":", "if", "(", "OpNum", "==", "0", ")", "{", "unsigned", "InReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "bool", "isKill", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "isKill", "(", ")", ";", "bool", "isUndef", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "isUndef", "(", ")", ";", "if", "(", "FrameIndex", "<", "SPUFrameInfo", "::", "maxFrameOffset", "(", ")", ")", "{", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "SPU", "::", "STQDr32", ")", ")", ";", "MIB", ".", "addReg", "(", "InReg", ",", "getKillRegState", "(", "isKill", ")", "|", "getUndefRegState", "(", "isUndef", ")", ")", ";", "NewMI", "=", "addFrameReference", "(", "MIB", ",", "FrameIndex", ")", ";", "}", "}", "else", "{", "unsigned", "OutReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "bool", "isDead", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ";", "bool", "isUndef", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "isUndef", "(", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ")", ";", "MIB", ".", "addReg", "(", "OutReg", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "isDead", ")", "|", "getUndefRegState", "(", "isUndef", ")", ")", ";", "Opc", "=", "(", "FrameIndex", "<", "SPUFrameInfo", "::", "maxFrameOffset", "(", ")", ")", "?", "SPU", "::", "STQDr32", ":", "SPU", "::", "STQXr32", ";", "NewMI", "=", "addFrameReference", "(", "MIB", ",", "FrameIndex", ")", ";", "break", ";", "}", "}", "return", "NewMI", ";", "}", "</s>" ]

[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]

[ "CellSPU", "SPU", "1", "0", "0", "0", "SPU::ORv16i8", "SPU::ORv8i16", "SPU::ORv4i32", "SPU::ORv2i64", "SPU::ORr8", "SPU::ORr16", "SPU::ORr32", "SPU::ORr64", "SPU::ORf32", "SPU::ORf64", "0", "1", "1", "1", "SPU", "SPU::STQDr32", "0", "0", "0", "SPU", "SPU::STQDr32", "SPU::STQXr32" ]

[]

[ "<s>", "SDValue", "MipsSETargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "SDValue", "Val", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "AND", ":", "Val", "=", "performANDCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "OR", ":", "Val", "=", "performORCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "MUL", ":", "return", "performMULCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "this", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SHL", ":", "Val", "=", "performSHLCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "SRA", ":", "return", "performSRACombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SRL", ":", "return", "performSRLCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "VSELECT", ":", "return", "performVSELECTCombine", "(", "N", ",", "DAG", ")", ";", "case", "ISD", "::", "XOR", ":", "Val", "=", "performXORCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "SETCC", ":", "Val", "=", "performSETCCCombine", "(", "N", ",", "DAG", ")", ";", "break", ";", "}", "if", "(", "Val", ".", "getNode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nMipsSE DAG Combine:\\n\"", ";", "N", "->", "printrWithDepth", "(", "dbgs", "(", ")", ",", "&", "DAG", ")", ";", "dbgs", "(", ")", "<<", "\"\\n=> \\n\"", ";", "Val", ".", "getNode", "(", ")", "->", "printrWithDepth", "(", "dbgs", "(", ")", ",", "&", "DAG", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "Val", ";", "}", "return", "MipsTargetLowering", "::", "PerformDAGCombine", "(", "N", ",", "DCI", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::AND", "ISD::OR", "ISD::MUL", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::VSELECT", "ISD::XOR", "ISD::SETCC", "\"\\nMipsSE DAG Combine:\\n\"", "\"\\n=> \\n\"", "\"\\n\"", "Mips" ]

[]

[ "<s>", "bool", "AMDGPUCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "unsigned", ">", "VRegs", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setIfReturnsVoid", "(", "!", "Val", ")", ";", "if", "(", "!", "Val", ")", "{", "MIRBuilder", ".", "buildInstr", "(", "AMDGPU", "::", "S_ENDPGM", ")", ".", "addImm", "(", "0", ")", ";", "return", "true", ";", "}", "unsigned", "VReg", "=", "VRegs", "[", "0", "]", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "auto", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "if", "(", "!", "AMDGPU", "::", "isShader", "(", "F", ".", "getCallingConv", "(", ")", ")", ")", "return", "false", ";", "const", "AMDGPUTargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AMDGPUTargetLowering", ">", "(", ")", ";", "SmallVector", "<", "EVT", ",", "4", ">", "SplitVTs", ";", "SmallVector", "<", "uint64_t", ",", "4", ">", "Offsets", ";", "ArgInfo", "OrigArg", "{", "VReg", ",", "Val", "->", "getType", "(", ")", "}", ";", "setArgFlags", "(", "OrigArg", ",", "AttributeList", "::", "ReturnIndex", ",", "DL", ",", "F", ")", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "OrigArg", ".", "Ty", ",", "SplitVTs", ",", "&", "Offsets", ",", "0", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "CCAssignFn", "*", "AssignFn", "=", "CCAssignFnForReturn", "(", "F", ".", "getCallingConv", "(", ")", ",", "false", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Offsets", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "Type", "*", "SplitTy", "=", "SplitVTs", "[", "i", "]", ".", "getTypeForEVT", "(", "F", ".", "getContext", "(", ")", ")", ";", "SplitArgs", ".", "push_back", "(", "{", "VRegs", "[", "i", "]", ",", "SplitTy", ",", "OrigArg", ".", "Flags", ",", "OrigArg", ".", "IsFixed", "}", ")", ";", "}", "auto", "RetInstr", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "AMDGPU", "::", "SI_RETURN_TO_EPILOG", ")", ";", "OutgoingArgHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "RetInstr", ",", "AssignFn", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "MIRBuilder", ".", "insertInstr", "(", "RetInstr", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "AMDGPU", "AMDGPU", "SI", "SI", "AMDGPU::S_ENDPGM", "0", "0", "AMDGPU::isShader", "AMDGPU", "AMDGPU", "4", "4", "0", "8", "0", "AMDGPU::SI_RETURN_TO_EPILOG" ]

[]

[ "<s>", "bool", "AMDGPULegalizerInfo", "::", "legalizeCustom", "(", "LegalizerHelper", "&", "Helper", ",", "MachineInstr", "&", "MI", ")", "const", "{", "MachineIRBuilder", "&", "B", "=", "Helper", ".", "MIRBuilder", ";", "MachineRegisterInfo", "&", "MRI", "=", "*", "B", ".", "getMRI", "(", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "G_ADDRSPACE_CAST", ":", "return", "legalizeAddrSpaceCast", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FRINT", ":", "return", "legalizeFrint", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FCEIL", ":", "return", "legalizeFceil", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FREM", ":", "return", "legalizeFrem", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_INTRINSIC_TRUNC", ":", "return", "legalizeIntrinsicTrunc", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_SITOFP", ":", "return", "legalizeITOFP", "(", "MI", ",", "MRI", ",", "B", ",", "true", ")", ";", "case", "TargetOpcode", "::", "G_UITOFP", ":", "return", "legalizeITOFP", "(", "MI", ",", "MRI", ",", "B", ",", "false", ")", ";", "case", "TargetOpcode", "::", "G_FPTOSI", ":", "return", "legalizeFPTOI", "(", "MI", ",", "MRI", ",", "B", ",", "true", ")", ";", "case", "TargetOpcode", "::", "G_FPTOUI", ":", "return", "legalizeFPTOI", "(", "MI", ",", "MRI", ",", "B", ",", "false", ")", ";", "case", "TargetOpcode", "::", "G_FMINNUM", ":", "case", "TargetOpcode", "::", "G_FMAXNUM", ":", "case", "TargetOpcode", "::", "G_FMINNUM_IEEE", ":", "case", "TargetOpcode", "::", "G_FMAXNUM_IEEE", ":", "return", "legalizeMinNumMaxNum", "(", "Helper", ",", "MI", ")", ";", "case", "TargetOpcode", "::", "G_EXTRACT_VECTOR_ELT", ":", "return", "legalizeExtractVectorElt", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_INSERT_VECTOR_ELT", ":", "return", "legalizeInsertVectorElt", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_SHUFFLE_VECTOR", ":", "return", "legalizeShuffleVector", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FSIN", ":", "case", "TargetOpcode", "::", "G_FCOS", ":", "return", "legalizeSinCos", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_GLOBAL_VALUE", ":", "return", "legalizeGlobalValue", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_LOAD", ":", "return", "legalizeLoad", "(", "Helper", ",", "MI", ")", ";", "case", "TargetOpcode", "::", "G_FMAD", ":", "return", "legalizeFMad", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FDIV", ":", "return", "legalizeFDIV", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_UDIV", ":", "case", "TargetOpcode", "::", "G_UREM", ":", "case", "TargetOpcode", "::", "G_UDIVREM", ":", "return", "legalizeUnsignedDIV_REM", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_SDIV", ":", "case", "TargetOpcode", "::", "G_SREM", ":", "case", "TargetOpcode", "::", "G_SDIVREM", ":", "return", "legalizeSignedDIV_REM", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_ATOMIC_CMPXCHG", ":", "return", "legalizeAtomicCmpXChg", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FLOG", ":", "return", "legalizeFlog", "(", "MI", ",", "B", ",", "numbers", "::", "ln2f", ")", ";", "case", "TargetOpcode", "::", "G_FLOG10", ":", "return", "legalizeFlog", "(", "MI", ",", "B", ",", "numbers", "::", "ln2f", "/", "numbers", "::", "ln10f", ")", ";", "case", "TargetOpcode", "::", "G_FEXP", ":", "return", "legalizeFExp", "(", "MI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FPOW", ":", "return", "legalizeFPow", "(", "MI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FFLOOR", ":", "return", "legalizeFFloor", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_BUILD_VECTOR", ":", "return", "legalizeBuildVector", "(", "MI", ",", "MRI", ",", "B", ")", ";", "default", ":", "return", "false", ";", "}", "llvm_unreachable", "(", "\"expected switch to return\"", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "SI", "SI", "SI", "SI", "\"expected switch to return\"" ]

[]

[ "<s>", "DecodeStatus", "PatmosDisassembler", "::", "getInstruction", "(", "MCInst", "&", "instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "CStream", ")", "const", "{", "uint32_t", "Insn", ";", "Size", "=", "0", ";", "DecodeStatus", "Result", "=", "readInstruction32", "(", "Bytes", ",", "Size", ",", "Insn", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "bool", "isBundled", "=", "(", "Insn", ">>", "31", ")", ";", "Insn", "&=", "~", "(", "1", "<<", "31", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTablePatmos32", ",", "instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "{", "if", "(", "!", "isBundled", ")", "return", "MCDisassembler", "::", "Fail", ";", "uint32_t", "InsnL", ";", "Result", "=", "readInstruction32", "(", "Bytes", ",", "Size", ",", "InsnL", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "{", "return", "MCDisassembler", "::", "Fail", ";", "}", "uint64_t", "Insn64", "=", "(", "1ULL", "<<", "63", ")", "|", "(", "(", "uint64_t", ")", "Insn", "<<", "32", ")", "|", "InsnL", ";", "Result", "=", "decodeInstruction", "(", "DecoderTablePatmos64", ",", "instr", ",", "Insn64", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "isBundled", "=", "false", ";", "}", "instr", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "isBundled", ")", ")", ";", "adjustSignedImm", "(", "instr", ")", ";", "return", "Result", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "0", "31", "1", "31", "Patmos", "1ULL", "63", "32", "Patmos" ]

[]