Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "void", "reorg_emit_nops", "(", "rtx", "*", "call_labels", ")", "{", "bool", "first", ";", "rtx", "last_call", ";", "rtx_insn", "*", "prev", ";", "int", "prev_clock", ",", "earliest_bb_end", ";", "int", "prev_implicit_nops", ";", "rtx_insn", "*", "insn", "=", "get_insns", "(", ")", ";", "insn", "=", "next_real_insn", "(", "insn", ")", ";", "last_call", "=", "prev", "=", "NULL", ";", "prev_clock", "=", "-", "1", ";", "earliest_bb_end", "=", "0", ";", "prev_implicit_nops", "=", "0", ";", "first", "=", "true", ";", "while", "(", "insn", ")", "{", "int", "this_clock", "=", "-", "1", ";", "rtx_insn", "*", "next", ";", "int", "max_cycles", "=", "0", ";", "next", "=", "next_real_insn", "(", "insn", ")", ";", "if", "(", "DEBUG_INSN_P", "(", "insn", ")", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", "||", "shadow_or_blockage_p", "(", "insn", ")", "||", "JUMP_TABLE_DATA_P", "(", "insn", ")", ")", "goto", "next_insn", ";", "if", "(", "!", "c6x_flag_schedule_insns2", ")", "PUT_MODE", "(", "insn", ",", "TImode", ")", ";", "else", "{", "int", "cycles", ";", "this_clock", "=", "insn_get_clock", "(", "insn", ")", ";", "if", "(", "this_clock", "!=", "prev_clock", ")", "{", "PUT_MODE", "(", "insn", ",", "TImode", ")", ";", "if", "(", "!", "first", ")", "{", "cycles", "=", "this_clock", "-", "prev_clock", ";", "cycles", "-=", "prev_implicit_nops", ";", "if", "(", "cycles", ">", "1", ")", "{", "rtx", "nop", "=", "emit_nop_after", "(", "cycles", "-", "1", ",", "prev", ")", ";", "insn_set_clock", "(", "nop", ",", "prev_clock", "+", "prev_implicit_nops", "+", "1", ")", ";", "}", "}", "prev_clock", "=", "this_clock", ";", "if", "(", "last_call", "&&", "insn_get_clock", "(", "last_call", ")", "+", "6", "<=", "this_clock", ")", "{", "emit_label_before", "(", "call_labels", "[", "INSN_UID", "(", "last_call", ")", "]", ",", "insn", ")", ";", "last_call", "=", "NULL_RTX", ";", "}", "prev_implicit_nops", "=", "0", ";", "}", "}", "if", "(", "recog_memoized", "(", "insn", ")", ">=", "0", "&&", "(", "c6x_flag_schedule_insns2", "||", "!", "returning_call_p", "(", "insn", ")", ")", ")", "{", "max_cycles", "=", "get_attr_cycles", "(", "insn", ")", ";", "if", "(", "get_attr_type", "(", "insn", ")", "==", "TYPE_CALLP", ")", "prev_implicit_nops", "=", "5", ";", "}", "else", "max_cycles", "=", "1", ";", "if", "(", "returning_call_p", "(", "insn", ")", ")", "last_call", "=", "insn", ";", "if", "(", "c6x_flag_schedule_insns2", ")", "{", "gcc_assert", "(", "this_clock", ">=", "0", ")", ";", "if", "(", "earliest_bb_end", "<", "this_clock", "+", "max_cycles", ")", "earliest_bb_end", "=", "this_clock", "+", "max_cycles", ";", "}", "else", "if", "(", "max_cycles", ">", "1", ")", "emit_nop_after", "(", "max_cycles", "-", "1", ",", "insn", ")", ";", "prev", "=", "insn", ";", "first", "=", "false", ";", "next_insn", ":", "if", "(", "c6x_flag_schedule_insns2", "&&", "(", "next", "==", "NULL_RTX", "||", "(", "GET_MODE", "(", "next", ")", "==", "TImode", "&&", "INSN_INFO_ENTRY", "(", "INSN_UID", "(", "next", ")", ")", ".", "ebb_start", ")", ")", "&&", "earliest_bb_end", ">", "0", ")", "{", "int", "cycles", "=", "earliest_bb_end", "-", "prev_clock", ";", "if", "(", "cycles", ">", "1", ")", "{", "prev", "=", "emit_nop_after", "(", "cycles", "-", "1", ",", "prev", ")", ";", "insn_set_clock", "(", "prev", ",", "prev_clock", "+", "prev_implicit_nops", "+", "1", ")", ";", "}", "earliest_bb_end", "=", "0", ";", "prev_clock", "=", "-", "1", ";", "first", "=", "true", ";", "if", "(", "last_call", ")", "emit_label_after", "(", "call_labels", "[", "INSN_UID", "(", "last_call", ")", "]", ",", "prev", ")", ";", "last_call", "=", "NULL_RTX", ";", "}", "insn", "=", "next", ";", "}", "}", "</s>" ]

[ "Called", "as", "part", "of", "c6x_reorg", ".", "This", "function", "emits", "multi-cycle", "NOP", "insns", "as", "required", "for", "correctness", ".", "CALL_LABELS", "is", "the", "array", "that", "holds", "the", "return", "labels", "for", "call", "insns", ";", "we", "emit", "these", "here", "if", "scheduling", "was", "run", "earlier", "." ]

[ "c6x", "1", "0", "0", "1", "0", "1", "1", "1", "6", "0", "0", "5", "1", "0", "1", "1", "0", "1", "1", "1", "0", "1" ]

[]

[ "<s>", "static", "int", "hppa_address_cost", "(", "rtx", "X", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "GET_CODE", "(", "X", ")", ")", "{", "case", "REG", ":", "case", "PLUS", ":", "case", "LO_SUM", ":", "return", "1", ";", "case", "HIGH", ":", "return", "2", ";", "default", ":", "return", "4", ";", "}", "}", "</s>" ]

[ "For", "the", "HPPA", ",", "REG", "and", "REG+CONST", "is", "cost", "0", "and", "addresses", "involving", "symbolic", "constants", "are", "cost", "2", ".", "PIC", "addresses", "are", "very", "expensive", ".", "It", "is", "no", "coincidence", "that", "this", "has", "the", "same", "structure", "as", "GO_IF_LEGITIMATE_ADDRESS", "." ]

[ "pa", "1", "2", "4" ]

[]

[ "<s>", "MachineBasicBlock", "*", "WebAssemblyTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected instr type to insert\"", ")", ";", "case", "WebAssembly", "::", "FP_TO_SINT_I32_F32", ":", "return", "LowerFPToInt", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ",", "false", ",", "false", ",", "false", ",", "WebAssembly", "::", "I32_TRUNC_S_F32", ")", ";", "case", "WebAssembly", "::", "FP_TO_UINT_I32_F32", ":", "return", "LowerFPToInt", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ",", "true", ",", "false", ",", "false", ",", "WebAssembly", "::", "I32_TRUNC_U_F32", ")", ";", "case", "WebAssembly", "::", "FP_TO_SINT_I64_F32", ":", "return", "LowerFPToInt", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ",", "false", ",", "true", ",", "false", ",", "WebAssembly", "::", "I64_TRUNC_S_F32", ")", ";", "case", "WebAssembly", "::", "FP_TO_UINT_I64_F32", ":", "return", "LowerFPToInt", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ",", "true", ",", "true", ",", "false", ",", "WebAssembly", "::", "I64_TRUNC_U_F32", ")", ";", "case", "WebAssembly", "::", "FP_TO_SINT_I32_F64", ":", "return", "LowerFPToInt", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ",", "false", ",", "false", ",", "true", ",", "WebAssembly", "::", "I32_TRUNC_S_F64", ")", ";", "case", "WebAssembly", "::", "FP_TO_UINT_I32_F64", ":", "return", "LowerFPToInt", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ",", "true", ",", "false", ",", "true", ",", "WebAssembly", "::", "I32_TRUNC_U_F64", ")", ";", "case", "WebAssembly", "::", "FP_TO_SINT_I64_F64", ":", "return", "LowerFPToInt", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ",", "false", ",", "true", ",", "true", ",", "WebAssembly", "::", "I64_TRUNC_S_F64", ")", ";", "case", "WebAssembly", "::", "FP_TO_UINT_I64_F64", ":", "return", "LowerFPToInt", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ",", "true", ",", "true", ",", "true", ",", "WebAssembly", "::", "I64_TRUNC_U_F64", ")", ";", "case", "WebAssembly", "::", "CALL_RESULTS", ":", "case", "WebAssembly", "::", "RET_CALL_RESULTS", ":", "return", "LowerCallResults", "(", "MI", ",", "DL", ",", "BB", ",", "Subtarget", ",", "TII", ")", ";", "}", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"Unexpected instr type to insert\"", "WebAssembly::FP_TO_SINT_I32_F32", "WebAssembly::I32_TRUNC_S_F32", "WebAssembly::FP_TO_UINT_I32_F32", "WebAssembly::I32_TRUNC_U_F32", "WebAssembly::FP_TO_SINT_I64_F32", "WebAssembly::I64_TRUNC_S_F32", "WebAssembly::FP_TO_UINT_I64_F32", "WebAssembly::I64_TRUNC_U_F32", "WebAssembly::FP_TO_SINT_I32_F64", "WebAssembly::I32_TRUNC_S_F64", "WebAssembly::FP_TO_UINT_I32_F64", "WebAssembly::I32_TRUNC_U_F64", "WebAssembly::FP_TO_SINT_I64_F64", "WebAssembly::I64_TRUNC_S_F64", "WebAssembly::FP_TO_UINT_I64_F64", "WebAssembly::I64_TRUNC_U_F64", "WebAssembly::CALL_RESULTS", "WebAssembly::RET_CALL_RESULTS" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "B", ":", "llvm", "::", "make_early_inc_range", "(", "MF", ")", ")", "if", "(", "processBlock", "(", "B", ")", ")", "Changed", "=", "true", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "PowerPC" ]

[]

[ "<s>", "bool", "isMem", "(", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "isMem", "-", "Is", "this", "a", "memory", "operand", "?" ]

[ "WebAssembly" ]

[]

[ "<s>", "void", "scalar_chain", "::", "add_insn", "(", "bitmap", "candidates", ",", "unsigned", "int", "insn_uid", ")", "{", "if", "(", "bitmap_bit_p", "(", "insns", ",", "insn_uid", ")", ")", "return", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\" Adding insn %d to chain #%d\\n\"", ",", "insn_uid", ",", "chain_id", ")", ";", "bitmap_set_bit", "(", "insns", ",", "insn_uid", ")", ";", "rtx_insn", "*", "insn", "=", "DF_INSN_UID_GET", "(", "insn_uid", ")", "->", "insn", ";", "rtx", "def_set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "def_set", "&&", "REG_P", "(", "SET_DEST", "(", "def_set", ")", ")", "&&", "!", "HARD_REGISTER_P", "(", "SET_DEST", "(", "def_set", ")", ")", ")", "bitmap_set_bit", "(", "defs", ",", "REGNO", "(", "SET_DEST", "(", "def_set", ")", ")", ")", ";", "df_ref", "ref", ";", "for", "(", "ref", "=", "DF_INSN_UID_DEFS", "(", "insn_uid", ")", ";", "ref", ";", "ref", "=", "DF_REF_NEXT_LOC", "(", "ref", ")", ")", "if", "(", "!", "HARD_REGISTER_P", "(", "DF_REF_REG", "(", "ref", ")", ")", ")", "analyze_register_chain", "(", "candidates", ",", "ref", ")", ";", "for", "(", "ref", "=", "DF_INSN_UID_USES", "(", "insn_uid", ")", ";", "ref", ";", "ref", "=", "DF_REF_NEXT_LOC", "(", "ref", ")", ")", "if", "(", "!", "DF_REF_REG_MEM_P", "(", "ref", ")", ")", "analyze_register_chain", "(", "candidates", ",", "ref", ")", ";", "}", "</s>" ]

[ "Add", "instruction", "into", "a", "chain", ".", "Return", "true", "if", "OK", ",", "false", "if", "the", "search", "was", "aborted", "." ]

[ "i386", "\" Adding insn %d to chain #%d\\n\"" ]

[]

[ "<s>", "std", "::", "vector", "<", "std", "::", "string", ">", "push", "(", "Px", "a", ")", "{", "return", "D", "(", "\"push\"", ",", "R", "(", "a", ")", ")", ";", "}", "</s>" ]

[ "Push", "the", "current", "solver", "state", "." ]

[ "Teak", "\"push\"" ]

[]

[ "<s>", "X86TargetLowering", "::", "ConstraintType", "X86TargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'R'", ":", "case", "'q'", ":", "case", "'Q'", ":", "case", "'f'", ":", "case", "'t'", ":", "case", "'u'", ":", "case", "'y'", ":", "case", "'x'", ":", "case", "'v'", ":", "case", "'Y'", ":", "case", "'l'", ":", "case", "'k'", ":", "return", "C_RegisterClass", ";", "case", "'a'", ":", "case", "'b'", ":", "case", "'c'", ":", "case", "'d'", ":", "case", "'S'", ":", "case", "'D'", ":", "case", "'A'", ":", "return", "C_Register", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'M'", ":", "case", "'N'", ":", "case", "'G'", ":", "case", "'C'", ":", "case", "'e'", ":", "case", "'Z'", ":", "return", "C_Other", ";", "default", ":", "break", ";", "}", "}", "else", "if", "(", "Constraint", ".", "size", "(", ")", "==", "2", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'Y'", ":", "switch", "(", "Constraint", "[", "1", "]", ")", "{", "default", ":", "break", ";", "case", "'z'", ":", "case", "'0'", ":", "return", "C_Register", ";", "case", "'i'", ":", "case", "'m'", ":", "case", "'k'", ":", "case", "'t'", ":", "case", "'2'", ":", "return", "C_RegisterClass", ";", "}", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "1", "0", "2", "0", "1" ]

[]

[ "<s>", "Register", "AMDGPURegisterBankInfo", "::", "handleD16VData", "(", "MachineIRBuilder", "&", "B", ",", "MachineRegisterInfo", "&", "MRI", ",", "Register", "Reg", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "hasUnpackedD16VMem", "(", ")", ")", "return", "Reg", ";", "const", "LLT", "S16", "=", "LLT", "::", "scalar", "(", "16", ")", ";", "LLT", "StoreVT", "=", "MRI", ".", "getType", "(", "Reg", ")", ";", "if", "(", "!", "StoreVT", ".", "isVector", "(", ")", "||", "StoreVT", ".", "getElementType", "(", ")", "!=", "S16", ")", "return", "Reg", ";", "auto", "Unmerge", "=", "B", ".", "buildUnmerge", "(", "S16", ",", "Reg", ")", ";", "SmallVector", "<", "Register", ",", "4", ">", "WideRegs", ";", "for", "(", "int", "I", "=", "0", ",", "E", "=", "Unmerge", "->", "getNumOperands", "(", ")", "-", "1", ";", "I", "!=", "E", ";", "++", "I", ")", "WideRegs", ".", "push_back", "(", "Unmerge", ".", "getReg", "(", "I", ")", ")", ";", "const", "LLT", "S32", "=", "LLT", "::", "scalar", "(", "32", ")", ";", "int", "NumElts", "=", "StoreVT", ".", "getNumElements", "(", ")", ";", "return", "B", ".", "buildMerge", "(", "LLT", "::", "fixed_vector", "(", "NumElts", ",", "S32", ")", ",", "WideRegs", ")", ".", "getReg", "(", "0", ")", ";", "}", "</s>" ]

[ "Handle", "register", "layout", "difference", "for", "f16", "images", "for", "some", "subtargets", "." ]

[ "AMDGPU", "AMDGPU", "16", "4", "0", "1", "32", "0" ]

[]

[ "<s>", "static", "void", "arm_relayout_function", "(", "tree", "fndecl", ")", "{", "if", "(", "DECL_USER_ALIGN", "(", "fndecl", ")", ")", "return", ";", "tree", "callee_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", ";", "if", "(", "!", "callee_tree", ")", "callee_tree", "=", "target_option_default_node", ";", "struct", "cl_target_option", "*", "opts", "=", "TREE_TARGET_OPTION", "(", "callee_tree", ")", ";", "SET_DECL_ALIGN", "(", "fndecl", ",", "FUNCTION_ALIGNMENT", "(", "FUNCTION_BOUNDARY_P", "(", "opts", "->", "x_target_flags", ")", ")", ")", ";", "}", "</s>" ]

[ "Hook", "to", "fix", "function", "'s", "alignment", "affected", "by", "target", "attribute", "." ]

[ "arm" ]

[]

[ "<s>", "BitVector", "M68kRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "M68kFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "auto", "setBitVector", "=", "[", "&", "Reserved", ",", "this", "]", "(", "unsigned", "Reg", ")", "{", "for", "(", "MCRegAliasIterator", "I", "(", "Reg", ",", "this", ",", "true", ")", ";", "I", ".", "isValid", "(", ")", ";", "++", "I", ")", "{", "Reserved", ".", "set", "(", "*", "I", ")", ";", "}", "for", "(", "MCSubRegIterator", "I", "(", "Reg", ",", "this", ",", "true", ")", ";", "I", ".", "isValid", "(", ")", ";", "++", "I", ")", "{", "Reserved", ".", "set", "(", "*", "I", ")", ";", "}", "}", ";", "setBitVector", "(", "M68k", "::", "PC", ")", ";", "setBitVector", "(", "M68k", "::", "SP", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "setBitVector", "(", "FramePtr", ")", ";", "}", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "{", "CallingConv", "::", "ID", "CC", "=", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "const", "uint32_t", "*", "RegMask", "=", "getCallPreservedMask", "(", "MF", ",", "CC", ")", ";", "if", "(", "MachineOperand", "::", "clobbersPhysReg", "(", "RegMask", ",", "getBaseRegister", "(", ")", ")", ")", "report_fatal_error", "(", "\"Stack realignment in presence of dynamic allocas is \"", "\"not supported with\"", "\"this calling convention.\"", ")", ";", "setBitVector", "(", "getBaseRegister", "(", ")", ")", ";", "}", "return", "Reserved", ";", "}", "</s>" ]

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

[ "M68k", "M68k", "M68k", "M68k::PC", "M68k::SP", "\"Stack realignment in presence of dynamic allocas is \"", "\"not supported with\"", "\"this calling convention.\"" ]

[]

[ "<s>", "InstructionCost", "GCNTTIImpl", "::", "getArithmeticReductionCost", "(", "unsigned", "Opcode", ",", "VectorType", "*", "Ty", ",", "Optional", "<", "FastMathFlags", ">", "FMF", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "if", "(", "TTI", "::", "requiresOrderedReduction", "(", "FMF", ")", ")", "return", "BaseT", "::", "getArithmeticReductionCost", "(", "Opcode", ",", "Ty", ",", "FMF", ",", "CostKind", ")", ";", "EVT", "OrigTy", "=", "TLI", "->", "getValueType", "(", "DL", ",", "Ty", ")", ";", "if", "(", "!", "ST", "->", "hasVOP3PInsts", "(", ")", "||", "OrigTy", ".", "getScalarSizeInBits", "(", ")", "!=", "16", ")", "return", "BaseT", "::", "getArithmeticReductionCost", "(", "Opcode", ",", "Ty", ",", "FMF", ",", "CostKind", ")", ";", "std", "::", "pair", "<", "InstructionCost", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "Ty", ")", ";", "return", "LT", ".", "first", "*", "getFullRateInstrCost", "(", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "vector", "reduction", "intrinsics", "." ]

[ "AMDGPU", "16" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "ARMBaseRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MF", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "const", "MCPhysReg", "*", "RegList", "=", "STI", ".", "isTargetDarwin", "(", ")", "?", "CSR_iOS_SaveList", ":", "CSR_AAPCS_SaveList", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "if", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "{", "return", "CSR_NoRegs_SaveList", ";", "}", "else", "if", "(", "F", "->", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "{", "if", "(", "STI", ".", "isMClass", "(", ")", ")", "{", "return", "CSR_AAPCS_SaveList", ";", "}", "else", "if", "(", "F", "->", "getFnAttribute", "(", "\"interrupt\"", ")", ".", "getValueAsString", "(", ")", "==", "\"FIQ\"", ")", "{", "return", "CSR_FIQ_SaveList", ";", "}", "else", "{", "return", "CSR_GenericInt_SaveList", ";", "}", "}", "if", "(", "STI", ".", "isTargetDarwin", "(", ")", "&&", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CXX_FAST_TLS", ")", "return", "MF", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", "->", "isSplitCSR", "(", ")", "?", "CSR_iOS_CXX_TLS_PE_SaveList", ":", "CSR_iOS_CXX_TLS_SaveList", ";", "return", "RegList", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "\"interrupt\"", "\"interrupt\"", "\"FIQ\"", "ARM" ]

[]

[ "<s>", "MachineBasicBlock", "*", "MipsSETargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "MipsTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "BPOSGE32_PSEUDO", ":", "return", "emitBPOSGE32", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "SNZ_B_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BNZ_B", ")", ";", "case", "Mips", "::", "SNZ_H_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BNZ_H", ")", ";", "case", "Mips", "::", "SNZ_W_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BNZ_W", ")", ";", "case", "Mips", "::", "SNZ_D_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BNZ_D", ")", ";", "case", "Mips", "::", "SNZ_V_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BNZ_V", ")", ";", "case", "Mips", "::", "SZ_B_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BZ_B", ")", ";", "case", "Mips", "::", "SZ_H_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BZ_H", ")", ";", "case", "Mips", "::", "SZ_W_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BZ_W", ")", ";", "case", "Mips", "::", "SZ_D_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BZ_D", ")", ";", "case", "Mips", "::", "SZ_V_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BZ_V", ")", ";", "case", "Mips", "::", "COPY_FW_PSEUDO", ":", "return", "emitCOPY_FW", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "COPY_FD_PSEUDO", ":", "return", "emitCOPY_FD", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "INSERT_FW_PSEUDO", ":", "return", "emitINSERT_FW", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "INSERT_FD_PSEUDO", ":", "return", "emitINSERT_FD", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "FILL_FW_PSEUDO", ":", "return", "emitFILL_FW", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "FILL_FD_PSEUDO", ":", "return", "emitFILL_FD", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "FEXP2_W_1_PSEUDO", ":", "return", "emitFEXP2_W_1", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "FEXP2_D_1_PSEUDO", ":", "return", "emitFEXP2_D_1", "(", "MI", ",", "BB", ")", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips::BPOSGE32_PSEUDO", "Mips::SNZ_B_PSEUDO", "Mips::BNZ_B", "Mips::SNZ_H_PSEUDO", "Mips::BNZ_H", "Mips::SNZ_W_PSEUDO", "Mips::BNZ_W", "Mips::SNZ_D_PSEUDO", "Mips::BNZ_D", "Mips::SNZ_V_PSEUDO", "Mips::BNZ_V", "Mips::SZ_B_PSEUDO", "Mips::BZ_B", "Mips::SZ_H_PSEUDO", "Mips::BZ_H", "Mips::SZ_W_PSEUDO", "Mips::BZ_W", "Mips::SZ_D_PSEUDO", "Mips::BZ_D", "Mips::SZ_V_PSEUDO", "Mips::BZ_V", "Mips::COPY_FW_PSEUDO", "Mips::COPY_FD_PSEUDO", "Mips::INSERT_FW_PSEUDO", "Mips::INSERT_FD_PSEUDO", "Mips::FILL_FW_PSEUDO", "Mips::FILL_FD_PSEUDO", "Mips::FEXP2_W_1_PSEUDO", "Mips::FEXP2_D_1_PSEUDO" ]

[]

[ "<s>", "const", "ARMSubtarget", "*", "ARMBaseTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "CPUAttr", ".", "isValid", "(", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "FSAttr", ".", "isValid", "(", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "bool", "SoftFloat", "=", "F", ".", "getFnAttribute", "(", "\"use-soft-float\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", ";", "if", "(", "SoftFloat", ")", "FS", "+=", "FS", ".", "empty", "(", ")", "?", "\"+soft-float\"", ":", "\",+soft-float\"", ";", "std", "::", "string", "Key", "=", "CPU", "+", "FS", ";", "if", "(", "F", ".", "hasMinSize", "(", ")", ")", "Key", "+=", "\"+minsize\"", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "std", "::", "make_unique", "<", "ARMSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "isLittle", ",", "F", ".", "hasMinSize", "(", ")", ")", ";", "if", "(", "!", "I", "->", "isThumb", "(", ")", "&&", "!", "I", "->", "hasARMOps", "(", ")", ")", "F", ".", "getContext", "(", ")", ".", "emitError", "(", "\"Function '\"", "+", "F", ".", "getName", "(", ")", "+", "\"' uses ARM \"", "\"instructions, but the target does not support ARM mode execution.\"", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "\"target-cpu\"", "\"target-features\"", "\"use-soft-float\"", "\"true\"", "\"+soft-float\"", "\",+soft-float\"", "\"+minsize\"", "ARM", "ARM", "\"Function '\"", "\"' uses ARM \"", "\"instructions, but the target does not support ARM mode execution.\"" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom lower this!\"", ")", ";", "case", "ISD", "::", "FADD", ":", "return", "LowerF128ToCall", "(", "Op", ",", "DAG", ",", "RTLIB", "::", "ADD_F128", ")", ";", "case", "ISD", "::", "FSUB", ":", "return", "LowerF128ToCall", "(", "Op", ",", "DAG", ",", "RTLIB", "::", "SUB_F128", ")", ";", "case", "ISD", "::", "FMUL", ":", "return", "LowerF128ToCall", "(", "Op", ",", "DAG", ",", "RTLIB", "::", "MUL_F128", ")", ";", "case", "ISD", "::", "FDIV", ":", "return", "LowerF128ToCall", "(", "Op", ",", "DAG", ",", "RTLIB", "::", "DIV_F128", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_INT", "(", "Op", ",", "DAG", ",", "true", ")", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "LowerFP_TO_INT", "(", "Op", ",", "DAG", ",", "false", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerINT_TO_FP", "(", "Op", ",", "DAG", ",", "true", ")", ";", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerINT_TO_FP", "(", "Op", ",", "DAG", ",", "false", ")", ";", "case", "ISD", "::", "FP_ROUND", ":", "return", "LowerFP_ROUND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_EXTEND", ":", "return", "LowerFP_EXTEND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddressELF", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VACOPY", ":", "return", "LowerVACOPY", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ",", "getSubtarget", "(", ")", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Don't know how to custom lower this!\"", "ISD::FADD", "ISD::FSUB", "ISD::FMUL", "ISD::FDIV", "ISD::FP_TO_SINT", "ISD::FP_TO_UINT", "ISD::SINT_TO_FP", "ISD::UINT_TO_FP", "ISD::FP_ROUND", "ISD::FP_EXTEND", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::BlockAddress", "ISD::BRCOND", "ISD::BR_CC", "ISD::GlobalAddress", "ISD::ConstantPool", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::SELECT", "ISD::SELECT_CC", "ISD::SETCC", "ISD::VACOPY", "ISD::VASTART", "ISD::BUILD_VECTOR", "ISD::CONCAT_VECTORS", "ISD::VECTOR_SHUFFLE" ]

[]

[ "<s>", "void", "WebAssemblyFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "auto", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "assert", "(", "MFI", "->", "getCalleeSavedInfo", "(", ")", ".", "empty", "(", ")", "&&", "\"WebAssembly should not have callee-saved registers\"", ")", ";", "assert", "(", "!", "hasFP", "(", "MF", ")", "&&", "\"Functions needing frame pointers not yet supported\"", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "!", "StackSize", "&&", "(", "!", "MFI", "->", "adjustsStack", "(", ")", "||", "MFI", "->", "getMaxCallFrameSize", "(", ")", "==", "0", ")", ")", "return", ";", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "auto", "InsertPt", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "adjustStackPointer", "(", "StackSize", ",", "false", ",", "MF", ",", "MBB", ",", "TII", ",", "InsertPt", ",", "DL", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"WebAssembly should not have callee-saved registers\"", "\"Functions needing frame pointers not yet supported\"", "0" ]

[]

[ "<s>", "void", "PPCPostRASchedStrategy", "::", "tryCandidate", "(", "SchedCandidate", "&", "Cand", ",", "SchedCandidate", "&", "TryCand", ")", "{", "PostGenericScheduler", "::", "tryCandidate", "(", "Cand", ",", "TryCand", ")", ";", "if", "(", "!", "Cand", ".", "isValid", "(", ")", ")", "return", ";", "if", "(", "TryCand", ".", "Reason", "!=", "NodeOrder", "&&", "TryCand", ".", "Reason", "!=", "NoCand", ")", "return", ";", "if", "(", "biasAddiCandidate", "(", "Cand", ",", "TryCand", ")", ")", "return", ";", "}", "</s>" ]

[ "Apply", "a", "set", "of", "heuristics", "to", "a", "new", "candidate", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "SMRange", "getLocRange", "(", ")", "const", "{", "return", "SMRange", "(", "StartLoc", ",", "EndLoc", ")", ";", "}", "</s>" ]

[ "getLocRange", "-", "Get", "the", "range", "between", "the", "first", "and", "last", "token", "of", "this", "operand", "." ]

[ "X86" ]

[]

[ "<s>", "void", "ix86_set_current_function", "(", "tree", "fndecl", ")", "{", "if", "(", "fndecl", "==", "ix86_previous_fndecl", ")", "{", "if", "(", "fndecl", "!=", "NULL_TREE", ")", "{", "ix86_set_func_type", "(", "fndecl", ")", ";", "ix86_set_indirect_branch_type", "(", "fndecl", ")", ";", "}", "return", ";", "}", "tree", "old_tree", ";", "if", "(", "ix86_previous_fndecl", "==", "NULL_TREE", ")", "old_tree", "=", "target_option_current_node", ";", "else", "if", "(", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "ix86_previous_fndecl", ")", ")", "old_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "ix86_previous_fndecl", ")", ";", "else", "old_tree", "=", "target_option_default_node", ";", "if", "(", "fndecl", "==", "NULL_TREE", ")", "{", "if", "(", "old_tree", "!=", "target_option_current_node", ")", "ix86_reset_previous_fndecl", "(", ")", ";", "return", ";", "}", "ix86_set_func_type", "(", "fndecl", ")", ";", "ix86_set_indirect_branch_type", "(", "fndecl", ")", ";", "tree", "new_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", ";", "if", "(", "new_tree", "==", "NULL_TREE", ")", "new_tree", "=", "target_option_default_node", ";", "if", "(", "old_tree", "!=", "new_tree", ")", "{", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "TREE_TARGET_OPTION", "(", "new_tree", ")", ")", ";", "if", "(", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", ")", "restore_target_globals", "(", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", ")", ";", "else", "if", "(", "new_tree", "==", "target_option_default_node", ")", "restore_target_globals", "(", "&", "default_target_globals", ")", ";", "else", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", "=", "save_target_globals_default_opts", "(", ")", ";", "}", "else", "if", "(", "flag_unsafe_math_optimizations", "!=", "TREE_TARGET_OPTION", "(", "new_tree", ")", "->", "x_ix86_unsafe_math_optimizations", "||", "(", "flag_excess_precision", "!=", "TREE_TARGET_OPTION", "(", "new_tree", ")", "->", "x_ix86_excess_precision", ")", ")", "{", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "TREE_TARGET_OPTION", "(", "new_tree", ")", ")", ";", "ix86_excess_precision", "=", "flag_excess_precision", ";", "ix86_unsafe_math_optimizations", "=", "flag_unsafe_math_optimizations", ";", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", "=", "new_tree", "=", "build_target_option_node", "(", "&", "global_options", ",", "&", "global_options_set", ")", ";", "if", "(", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", ")", "restore_target_globals", "(", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", ")", ";", "else", "if", "(", "new_tree", "==", "target_option_default_node", ")", "restore_target_globals", "(", "&", "default_target_globals", ")", ";", "else", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", "=", "save_target_globals_default_opts", "(", ")", ";", "}", "ix86_previous_fndecl", "=", "fndecl", ";", "static", "bool", "prev_no_caller_saved_registers", ";", "if", "(", "TARGET_64BIT", "&&", "(", "call_used_or_fixed_reg_p", "(", "SI_REG", ")", "==", "(", "cfun", "->", "machine", "->", "call_abi", "==", "MS_ABI", ")", ")", ")", "reinit_regs", "(", ")", ";", "else", "if", "(", "prev_no_caller_saved_registers", "!=", "cfun", "->", "machine", "->", "no_caller_saved_registers", ")", "reinit_regs", "(", ")", ";", "if", "(", "cfun", "->", "machine", "->", "func_type", "!=", "TYPE_NORMAL", "||", "cfun", "->", "machine", "->", "no_caller_saved_registers", ")", "{", "const", "char", "*", "isa", ";", "if", "(", "TARGET_SSE", ")", "isa", "=", "\"SSE\"", ";", "else", "if", "(", "TARGET_MMX", ")", "isa", "=", "\"MMX/3Dnow\"", ";", "else", "if", "(", "TARGET_80387", ")", "isa", "=", "\"80387\"", ";", "else", "isa", "=", "NULL", ";", "if", "(", "isa", "!=", "NULL", ")", "{", "if", "(", "cfun", "->", "machine", "->", "func_type", "!=", "TYPE_NORMAL", ")", "sorry", "(", "cfun", "->", "machine", "->", "func_type", "==", "TYPE_EXCEPTION", "?", "G_", "(", "\"%s instructions aren%'t allowed in an\"", "\" exception service routine\"", ")", ":", "G_", "(", "\"%s instructions aren%'t allowed in an\"", "\" interrupt service routine\"", ")", ",", "isa", ")", ";", "else", "sorry", "(", "\"%s instructions aren%'t allowed in a function with \"", "\"the %<no_caller_saved_registers%> attribute\"", ",", "isa", ")", ";", "cfun", "->", "machine", "->", "func_type", "=", "TYPE_NORMAL", ";", "cfun", "->", "machine", "->", "no_caller_saved_registers", "=", "false", ";", "}", "}", "prev_no_caller_saved_registers", "=", "cfun", "->", "machine", "->", "no_caller_saved_registers", ";", "}", "</s>" ]

[ "Establish", "appropriate", "back-end", "context", "for", "processing", "the", "function", "FNDECL", ".", "The", "argument", "might", "be", "NULL", "to", "indicate", "processing", "at", "top", "level", ",", "outside", "of", "any", "function", "scope", "." ]

[ "i386", "\"SSE\"", "\"MMX/3Dnow\"", "\"80387\"", "\"%s instructions aren%'t allowed in an\"", "\" exception service routine\"", "\"%s instructions aren%'t allowed in an\"", "\" interrupt service routine\"", "\"%s instructions aren%'t allowed in a function with \"", "\"the %<no_caller_saved_registers%> attribute\"" ]

[]

[ "<s>", "unsigned", "AArch64RegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "AArch64FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "AArch64", "::", "GPR32RegClassID", ":", "case", "AArch64", "::", "GPR32spRegClassID", ":", "case", "AArch64", "::", "GPR32allRegClassID", ":", "case", "AArch64", "::", "GPR64spRegClassID", ":", "case", "AArch64", "::", "GPR64allRegClassID", ":", "case", "AArch64", "::", "GPR64RegClassID", ":", "case", "AArch64", "::", "GPR32commonRegClassID", ":", "case", "AArch64", "::", "GPR64commonRegClassID", ":", "return", "32", "-", "1", "-", "(", "TFI", "->", "hasFP", "(", "MF", ")", "||", "TT", ".", "isOSDarwin", "(", ")", ")", "-", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getNumXRegisterReserved", "(", ")", "-", "hasBasePointer", "(", "MF", ")", ";", "case", "AArch64", "::", "FPR8RegClassID", ":", "case", "AArch64", "::", "FPR16RegClassID", ":", "case", "AArch64", "::", "FPR32RegClassID", ":", "case", "AArch64", "::", "FPR64RegClassID", ":", "case", "AArch64", "::", "FPR128RegClassID", ":", "return", "32", ";", "case", "AArch64", "::", "MatrixIndexGPR32_12_15RegClassID", ":", "return", "4", ";", "case", "AArch64", "::", "DDRegClassID", ":", "case", "AArch64", "::", "DDDRegClassID", ":", "case", "AArch64", "::", "DDDDRegClassID", ":", "case", "AArch64", "::", "QQRegClassID", ":", "case", "AArch64", "::", "QQQRegClassID", ":", "case", "AArch64", "::", "QQQQRegClassID", ":", "return", "32", ";", "case", "AArch64", "::", "FPR128_loRegClassID", ":", "case", "AArch64", "::", "FPR64_loRegClassID", ":", "case", "AArch64", "::", "FPR16_loRegClassID", ":", "return", "16", ";", "}", "}", "</s>" ]

[ "Return", "the", "register", "pressure", "``", "high", "water", "mark", "''", "for", "the", "specific", "register", "class", "." ]

[ "AArch64", "AArch64", "AArch64", "0", "AArch64::GPR32RegClassID", "AArch64::GPR32spRegClassID", "AArch64::GPR32allRegClassID", "AArch64::GPR64spRegClassID", "AArch64::GPR64allRegClassID", "AArch64::GPR64RegClassID", "AArch64::GPR32commonRegClassID", "AArch64::GPR64commonRegClassID", "32", "1", "AArch64", "AArch64::FPR8RegClassID", "AArch64::FPR16RegClassID", "AArch64::FPR32RegClassID", "AArch64::FPR64RegClassID", "AArch64::FPR128RegClassID", "32", "AArch64::MatrixIndexGPR32_12_15RegClassID", "4", "AArch64::DDRegClassID", "AArch64::DDDRegClassID", "AArch64::DDDDRegClassID", "AArch64::QQRegClassID", "AArch64::QQQRegClassID", "AArch64::QQQQRegClassID", "32", "AArch64::FPR128_loRegClassID", "AArch64::FPR64_loRegClassID", "AArch64::FPR16_loRegClassID", "16" ]

[]

[ "<s>", "bool", "WebAssemblyMemIntrinsicResults", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Memory Intrinsic Results **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "&", "MDT", "=", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "const", "WebAssemblyTargetLowering", "&", "TLI", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", ";", "const", "auto", "&", "LibInfo", "=", "getAnalysis", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ".", "getTLI", "(", "MF", ".", "getFunction", "(", ")", ")", ";", "auto", "&", "LIS", "=", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "bool", "Changed", "=", "false", ";", "MRI", ".", "leaveSSA", "(", ")", ";", "assert", "(", "MRI", ".", "tracksLiveness", "(", ")", "&&", "\"MemIntrinsicResults expects liveness tracking\"", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Basic Block: \"", "<<", "MBB", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "WebAssembly", "::", "CALL", ":", "Changed", "|=", "optimizeCall", "(", "MBB", ",", "MI", ",", "MRI", ",", "MDT", ",", "LIS", ",", "TLI", ",", "LibInfo", ")", ";", "break", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Memory Intrinsic Results **********\\n\"", "\"********** Function: \"", "WebAssembly", "WebAssembly", "\"MemIntrinsicResults expects liveness tracking\"", "\"Basic Block: \"", "WebAssembly::CALL" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Res", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom expand this!\"", ")", ";", "case", "ISD", "::", "BITCAST", ":", "Res", "=", "ExpandBITCAST", "(", "N", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "Res", "=", "ExpandVectorExtension", "(", "N", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "Res", "=", "Expand64BitShift", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "ATOMIC_LOAD_ADD", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMADD64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_AND", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMAND64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_NAND", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMNAND64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_OR", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMOR64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_SUB", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMSUB64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_XOR", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMXOR64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_SWAP", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMSWAP64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMCMPXCHG64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_MIN", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMMIN64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_UMIN", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMUMIN64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_MAX", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMMAX64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_UMAX", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMUMAX64_DAG", ")", ";", "return", ";", "}", "if", "(", "Res", ".", "getNode", "(", ")", ")", "Results", ".", "push_back", "(", "Res", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"Don't know how to custom expand this!\"", "ISD::BITCAST", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "ISD::SRL", "ISD::SRA", "ISD::ATOMIC_LOAD_ADD", "ARMISD::ATOMADD64_DAG", "ISD::ATOMIC_LOAD_AND", "ARMISD::ATOMAND64_DAG", "ISD::ATOMIC_LOAD_NAND", "ARMISD::ATOMNAND64_DAG", "ISD::ATOMIC_LOAD_OR", "ARMISD::ATOMOR64_DAG", "ISD::ATOMIC_LOAD_SUB", "ARMISD::ATOMSUB64_DAG", "ISD::ATOMIC_LOAD_XOR", "ARMISD::ATOMXOR64_DAG", "ISD::ATOMIC_SWAP", "ARMISD::ATOMSWAP64_DAG", "ISD::ATOMIC_CMP_SWAP", "ARMISD::ATOMCMPXCHG64_DAG", "ISD::ATOMIC_LOAD_MIN", "ARMISD::ATOMMIN64_DAG", "ISD::ATOMIC_LOAD_UMIN", "ARMISD::ATOMUMIN64_DAG", "ISD::ATOMIC_LOAD_MAX", "ARMISD::ATOMMAX64_DAG", "ISD::ATOMIC_LOAD_UMAX", "ARMISD::ATOMUMAX64_DAG" ]

[]

[ "<s>", "void", "NVPTXFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MF", ".", "getFrameInfo", "(", ")", "->", "hasStackObjects", "(", ")", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "DebugLoc", "(", ")", ";", "if", "(", "tm", ".", "getSubtargetImpl", "(", ")", "->", "hasGenericLdSt", "(", ")", ")", "{", "if", "(", "is64bit", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "tm", ".", "getInstrInfo", "(", ")", "->", "get", "(", "NVPTX", "::", "cvta_local_yes_64", ")", ",", "NVPTX", "::", "VRFrame", ")", ".", "addReg", "(", "NVPTX", "::", "VRFrameLocal", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "tm", ".", "getInstrInfo", "(", ")", "->", "get", "(", "NVPTX", "::", "IMOV64rr", ")", ",", "NVPTX", "::", "VRFrameLocal", ")", ".", "addReg", "(", "NVPTX", "::", "VRDepot", ")", ";", "}", "else", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "tm", ".", "getInstrInfo", "(", ")", "->", "get", "(", "NVPTX", "::", "cvta_local_yes", ")", ",", "NVPTX", "::", "VRFrame", ")", ".", "addReg", "(", "NVPTX", "::", "VRFrameLocal", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "tm", ".", "getInstrInfo", "(", ")", "->", "get", "(", "NVPTX", "::", "IMOV32rr", ")", ",", "NVPTX", "::", "VRFrameLocal", ")", ".", "addReg", "(", "NVPTX", "::", "VRDepot", ")", ";", "}", "}", "else", "{", "if", "(", "is64bit", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "tm", ".", "getInstrInfo", "(", ")", "->", "get", "(", "NVPTX", "::", "IMOV64rr", ")", ",", "NVPTX", "::", "VRFrame", ")", ".", "addReg", "(", "NVPTX", "::", "VRDepot", ")", ";", "else", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "tm", ".", "getInstrInfo", "(", ")", "->", "get", "(", "NVPTX", "::", "IMOV32rr", ")", ",", "NVPTX", "::", "VRFrame", ")", ".", "addReg", "(", "NVPTX", "::", "VRDepot", ")", ";", "}", "}", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "NVPTX::cvta_local_yes_64", "NVPTX::VRFrame", "NVPTX::VRFrameLocal", "NVPTX::IMOV64rr", "NVPTX::VRFrameLocal", "NVPTX::VRDepot", "NVPTX::cvta_local_yes", "NVPTX::VRFrame", "NVPTX::VRFrameLocal", "NVPTX::IMOV32rr", "NVPTX::VRFrameLocal", "NVPTX::VRDepot", "NVPTX::IMOV64rr", "NVPTX::VRFrame", "NVPTX::VRDepot", "NVPTX::IMOV32rr", "NVPTX::VRFrame", "NVPTX::VRDepot" ]

[]

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

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

[ "R600" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "setExecutionDomain", "(", "MachineInstr", "*", "MI", ",", "unsigned", "Domain", ")", "const", "{", "assert", "(", "Domain", ">", "0", "&&", "Domain", "<", "4", "&&", "\"Invalid execution domain\"", ")", ";", "uint16_t", "dom", "=", "(", "MI", "->", "getDesc", "(", ")", ".", "TSFlags", ">>", "X86II", "::", "SSEDomainShift", ")", "&", "3", ";", "assert", "(", "dom", "&&", "\"Not an SSE instruction\"", ")", ";", "const", "unsigned", "*", "table", "=", "lookup", "(", "MI", "->", "getOpcode", "(", ")", ",", "dom", ")", ";", "if", "(", "!", "table", ")", "{", "assert", "(", "(", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "hasAVX2", "(", ")", "||", "Domain", "<", "3", ")", "&&", "\"256-bit vector operations only available in AVX2\"", ")", ";", "table", "=", "lookupAVX2", "(", "MI", "->", "getOpcode", "(", ")", ",", "dom", ")", ";", "}", "assert", "(", "table", "&&", "\"Cannot change domain\"", ")", ";", "MI", "->", "setDesc", "(", "get", "(", "table", "[", "Domain", "-", "1", "]", ")", ")", ";", "}", "</s>" ]

[ "Change", "the", "opcode", "of", "MI", "to", "execute", "in", "Domain", "." ]

[ "X86", "X86", "0", "4", "\"Invalid execution domain\"", "X86II::SSEDomainShift", "3", "\"Not an SSE instruction\"", "X86", "3", "\"256-bit vector operations only available in AVX2\"", "\"Cannot change domain\"", "1" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isShuffleMaskLegal", "(", "ArrayRef", "<", "int", ">", "M", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "if", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "getScalarType", "(", ")", "==", "MVT", "::", "i1", ")", "return", "false", ";", "if", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "false", ";", "return", "isTypeLegal", "(", "VT", ".", "getSimpleVT", "(", ")", ")", ";", "}", "</s>" ]

[ "Targets", "can", "use", "this", "to", "indicate", "that", "they", "only", "support", "some", "VECTOR_SHUFFLE", "operations", ",", "those", "with", "specific", "masks", "." ]

[ "X86", "X86", "MVT::i1", "64" ]

[]

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

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

[ "CellSPU", "\"STI CBEA SPU Assembly Printer\"" ]

[]

[ "<s>", "bool", "MipsTargetObjectFile", "::", "IsConstantInSmallSection", "(", "const", "Constant", "*", "CN", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "return", "(", "static_cast", "<", "const", "MipsTargetMachine", "&", ">", "(", "TM", ")", ".", "getSubtargetImpl", "(", ")", "->", "useSmallSection", "(", ")", "&&", "LocalSData", "&&", "IsInSmallSection", "(", "TM", ".", "getDataLayout", "(", ")", "->", "getTypeAllocSize", "(", "CN", "->", "getType", "(", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "constant", "should", "be", "placed", "into", "small", "data", "section", "." ]

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

[]

[ "<s>", "uint64_t", "HexagonInstrInfo", "::", "getType", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "uint64_t", "F", "=", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", ";", "return", "(", "F", ">>", "HexagonII", "::", "TypePos", ")", "&", "HexagonII", "::", "TypeMask", ";", "}", "</s>" ]

[ "Overload", "to", "return", "most", "specific", "vector", "type", "." ]

[ "Hexagon", "Hexagon", "HexagonII::TypePos", "HexagonII::TypeMask" ]

[]

[ "<s>", "static", "bool", "ix86_notrack_prefixed_insn_p", "(", "rtx", "insn", ")", "{", "if", "(", "!", "insn", "||", "!", "(", "(", "flag_cf_protection", "&", "CF_BRANCH", ")", ")", ")", "return", "false", ";", "if", "(", "CALL_P", "(", "insn", ")", ")", "{", "rtx", "call", "=", "get_call_rtx_from", "(", "insn", ")", ";", "gcc_assert", "(", "call", "!=", "NULL_RTX", ")", ";", "rtx", "addr", "=", "XEXP", "(", "call", ",", "0", ")", ";", "if", "(", "MEM_P", "(", "addr", ")", "&&", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", "return", "false", ";", "else", "return", "find_reg_note", "(", "insn", ",", "REG_CALL_NOCF_CHECK", ",", "0", ")", ";", "}", "if", "(", "JUMP_P", "(", "insn", ")", "&&", "!", "flag_cet_switch", ")", "{", "rtx", "target", "=", "JUMP_LABEL", "(", "insn", ")", ";", "if", "(", "target", "==", "NULL_RTX", "||", "ANY_RETURN_P", "(", "target", ")", ")", "return", "false", ";", "rtx_insn", "*", "label", "=", "as_a", "<", "rtx_insn", "*", ">", "(", "target", ")", ";", "rtx_insn", "*", "table", "=", "next_insn", "(", "label", ")", ";", "if", "(", "table", "==", "NULL_RTX", "||", "!", "JUMP_TABLE_DATA_P", "(", "table", ")", ")", "return", "false", ";", "else", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "1", "if", "control", "tansfer", "instruction", "INSN", "should", "be", "encoded", "with", "notrack", "prefix", "." ]

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

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "{", "if", "(", "MI", ".", "getParent", "(", ")", "&&", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ")", "{", "const", "auto", "MF", "=", "MI", ".", "getMF", "(", ")", ";", "const", "auto", "&", "TM", "=", "static_cast", "<", "const", "RISCVTargetMachine", "&", ">", "(", "MF", "->", "getTarget", "(", ")", ")", ";", "const", "MCRegisterInfo", "&", "MRI", "=", "*", "TM", ".", "getMCRegisterInfo", "(", ")", ";", "const", "MCSubtargetInfo", "&", "STI", "=", "*", "TM", ".", "getMCSubtargetInfo", "(", ")", ";", "const", "RISCVSubtarget", "&", "ST", "=", "MF", "->", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ";", "if", "(", "isCompressibleInst", "(", "MI", ",", "&", "ST", ",", "MRI", ",", "STI", ")", ")", "return", "2", ";", "}", "return", "get", "(", "Opcode", ")", ".", "getSize", "(", ")", ";", "}", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", "0", ";", "case", "RISCV", "::", "PseudoCALLReg", ":", "case", "RISCV", "::", "PseudoCALL", ":", "case", "RISCV", "::", "PseudoJump", ":", "case", "RISCV", "::", "PseudoTAIL", ":", "case", "RISCV", "::", "PseudoLLA", ":", "case", "RISCV", "::", "PseudoLA", ":", "case", "RISCV", "::", "PseudoLA_TLS_IE", ":", "case", "RISCV", "::", "PseudoLA_TLS_GD", ":", "return", "8", ";", "case", "RISCV", "::", "PseudoAtomicLoadNand32", ":", "case", "RISCV", "::", "PseudoAtomicLoadNand64", ":", "return", "20", ";", "case", "RISCV", "::", "PseudoMaskedAtomicSwap32", ":", "case", "RISCV", "::", "PseudoMaskedAtomicLoadAdd32", ":", "case", "RISCV", "::", "PseudoMaskedAtomicLoadSub32", ":", "return", "28", ";", "case", "RISCV", "::", "PseudoMaskedAtomicLoadNand32", ":", "return", "32", ";", "case", "RISCV", "::", "PseudoMaskedAtomicLoadMax32", ":", "case", "RISCV", "::", "PseudoMaskedAtomicLoadMin32", ":", "return", "44", ";", "case", "RISCV", "::", "PseudoMaskedAtomicLoadUMax32", ":", "case", "RISCV", "::", "PseudoMaskedAtomicLoadUMin32", ":", "return", "36", ";", "case", "RISCV", "::", "PseudoCmpXchg32", ":", "case", "RISCV", "::", "PseudoCmpXchg64", ":", "return", "16", ";", "case", "RISCV", "::", "PseudoMaskedCmpXchg32", ":", "return", "32", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "case", "TargetOpcode", "::", "INLINEASM_BR", ":", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "auto", "&", "TM", "=", "static_cast", "<", "const", "RISCVTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ";", "return", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "TM", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "RISCV", "RISCV", "2", "0", "RISCV::PseudoCALLReg", "RISCV::PseudoCALL", "RISCV::PseudoJump", "RISCV::PseudoTAIL", "RISCV::PseudoLLA", "RISCV::PseudoLA", "RISCV::PseudoLA_TLS_IE", "RISCV::PseudoLA_TLS_GD", "8", "RISCV::PseudoAtomicLoadNand32", "RISCV::PseudoAtomicLoadNand64", "20", "RISCV::PseudoMaskedAtomicSwap32", "RISCV::PseudoMaskedAtomicLoadAdd32", "RISCV::PseudoMaskedAtomicLoadSub32", "28", "RISCV::PseudoMaskedAtomicLoadNand32", "32", "RISCV::PseudoMaskedAtomicLoadMax32", "RISCV::PseudoMaskedAtomicLoadMin32", "44", "RISCV::PseudoMaskedAtomicLoadUMax32", "RISCV::PseudoMaskedAtomicLoadUMin32", "36", "RISCV::PseudoCmpXchg32", "RISCV::PseudoCmpXchg64", "16", "RISCV::PseudoMaskedCmpXchg32", "32", "RISCV", "0" ]

[]

[ "<s>", "void", "split_double_mode", "(", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ",", "int", "num", ",", "rtx", "lo_half", "[", "]", ",", "rtx", "hi_half", "[", "]", ")", "{", "machine_mode", "half_mode", ";", "unsigned", "int", "byte", ";", "switch", "(", "mode", ")", "{", "case", "TImode", ":", "half_mode", "=", "DImode", ";", "break", ";", "case", "DImode", ":", "half_mode", "=", "SImode", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "byte", "=", "GET_MODE_SIZE", "(", "half_mode", ")", ";", "while", "(", "num", "--", ")", "{", "rtx", "op", "=", "operands", "[", "num", "]", ";", "if", "(", "MEM_P", "(", "op", ")", ")", "{", "lo_half", "[", "num", "]", "=", "adjust_address", "(", "op", ",", "half_mode", ",", "0", ")", ";", "hi_half", "[", "num", "]", "=", "adjust_address", "(", "op", ",", "half_mode", ",", "byte", ")", ";", "}", "else", "{", "lo_half", "[", "num", "]", "=", "simplify_gen_subreg", "(", "half_mode", ",", "op", ",", "GET_MODE", "(", "op", ")", "==", "VOIDmode", "?", "mode", ":", "GET_MODE", "(", "op", ")", ",", "0", ")", ";", "hi_half", "[", "num", "]", "=", "simplify_gen_subreg", "(", "half_mode", ",", "op", ",", "GET_MODE", "(", "op", ")", "==", "VOIDmode", "?", "mode", ":", "GET_MODE", "(", "op", ")", ",", "byte", ")", ";", "}", "}", "}", "</s>" ]

[ "Split", "one", "or", "more", "double-mode", "RTL", "references", "into", "pairs", "of", "half-mode", "references", ".", "The", "RTL", "can", "be", "REG", ",", "offsettable", "MEM", ",", "integer", "constant", ",", "or", "CONST_DOUBLE", ".", "``", "operands", "''", "is", "a", "pointer", "to", "an", "array", "of", "double-mode", "RTLs", "to", "split", "and", "``", "num", "''", "is", "its", "length", ".", "lo_half", "and", "hi_half", "are", "output", "arrays", "that", "parallel", "``", "operands", "''", "." ]

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

[]

[ "<s>", "static", "void", "ix86_expand_divmod_libfunc", "(", "rtx", "libfunc", ",", "machine_mode", "mode", ",", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "*", "quot_p", ",", "rtx", "*", "rem_p", ")", "{", "rtx", "rem", "=", "assign_386_stack_local", "(", "mode", ",", "SLOT_TEMP", ")", ";", "rtx", "quot", "=", "emit_library_call_value", "(", "libfunc", ",", "NULL_RTX", ",", "LCT_NORMAL", ",", "mode", ",", "op0", ",", "mode", ",", "op1", ",", "mode", ",", "XEXP", "(", "rem", ",", "0", ")", ",", "Pmode", ")", ";", "*", "quot_p", "=", "quot", ";", "*", "rem_p", "=", "rem", ";", "}", "</s>" ]

[ "Generate", "call", "to", "__divmoddi4", "." ]

[ "i386", "0" ]

[]

[ "<s>", "void", "changedInstr", "(", "MachineInstr", "&", "MI", ")", "override", "{", "}", "</s>" ]

[ "This", "instruction", "was", "mutated", "in", "some", "way", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "const", "char", "*", "AMDGPUTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "nullptr", ";", "NODE_NAME_CASE", "(", "CALL", ")", ";", "NODE_NAME_CASE", "(", "UMUL", ")", ";", "NODE_NAME_CASE", "(", "RET_FLAG", ")", ";", "NODE_NAME_CASE", "(", "BRANCH_COND", ")", ";", "NODE_NAME_CASE", "(", "DWORDADDR", ")", "NODE_NAME_CASE", "(", "FRACT", ")", "NODE_NAME_CASE", "(", "CLAMP", ")", "NODE_NAME_CASE", "(", "MAD", ")", "NODE_NAME_CASE", "(", "FMAX_LEGACY", ")", "NODE_NAME_CASE", "(", "SMAX", ")", "NODE_NAME_CASE", "(", "UMAX", ")", "NODE_NAME_CASE", "(", "FMIN_LEGACY", ")", "NODE_NAME_CASE", "(", "SMIN", ")", "NODE_NAME_CASE", "(", "UMIN", ")", "NODE_NAME_CASE", "(", "FMAX3", ")", "NODE_NAME_CASE", "(", "SMAX3", ")", "NODE_NAME_CASE", "(", "UMAX3", ")", "NODE_NAME_CASE", "(", "FMIN3", ")", "NODE_NAME_CASE", "(", "SMIN3", ")", "NODE_NAME_CASE", "(", "UMIN3", ")", "NODE_NAME_CASE", "(", "URECIP", ")", "NODE_NAME_CASE", "(", "DIV_SCALE", ")", "NODE_NAME_CASE", "(", "DIV_FMAS", ")", "NODE_NAME_CASE", "(", "DIV_FIXUP", ")", "NODE_NAME_CASE", "(", "TRIG_PREOP", ")", "NODE_NAME_CASE", "(", "RCP", ")", "NODE_NAME_CASE", "(", "RSQ", ")", "NODE_NAME_CASE", "(", "RSQ_LEGACY", ")", "NODE_NAME_CASE", "(", "RSQ_CLAMPED", ")", "NODE_NAME_CASE", "(", "LDEXP", ")", "NODE_NAME_CASE", "(", "FP_CLASS", ")", "NODE_NAME_CASE", "(", "DOT4", ")", "NODE_NAME_CASE", "(", "BFE_U32", ")", "NODE_NAME_CASE", "(", "BFE_I32", ")", "NODE_NAME_CASE", "(", "BFI", ")", "NODE_NAME_CASE", "(", "BFM", ")", "NODE_NAME_CASE", "(", "BREV", ")", "NODE_NAME_CASE", "(", "MUL_U24", ")", "NODE_NAME_CASE", "(", "MUL_I24", ")", "NODE_NAME_CASE", "(", "MAD_U24", ")", "NODE_NAME_CASE", "(", "MAD_I24", ")", "NODE_NAME_CASE", "(", "EXPORT", ")", "NODE_NAME_CASE", "(", "CONST_ADDRESS", ")", "NODE_NAME_CASE", "(", "REGISTER_LOAD", ")", "NODE_NAME_CASE", "(", "REGISTER_STORE", ")", "NODE_NAME_CASE", "(", "LOAD_CONSTANT", ")", "NODE_NAME_CASE", "(", "LOAD_INPUT", ")", "NODE_NAME_CASE", "(", "SAMPLE", ")", "NODE_NAME_CASE", "(", "SAMPLEB", ")", "NODE_NAME_CASE", "(", "SAMPLED", ")", "NODE_NAME_CASE", "(", "SAMPLEL", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE0", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE1", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE2", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE3", ")", "NODE_NAME_CASE", "(", "BUILD_VERTICAL_VECTOR", ")", "NODE_NAME_CASE", "(", "CONST_DATA_PTR", ")", "NODE_NAME_CASE", "(", "STORE_MSKOR", ")", "NODE_NAME_CASE", "(", "TBUFFER_STORE_FORMAT", ")", "}", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "bool", "AArch64AsmPrinter", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "const", "{", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "return", "false", ";", "assert", "(", "!", "MO", ".", "getSubReg", "(", ")", "&&", "\"Subregs should be eliminated!\"", ")", ";", "MCOp", "=", "MCOperand", "::", "CreateReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "CreateImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_FPImmediate", ":", "{", "assert", "(", "MO", ".", "getFPImm", "(", ")", "->", "isZero", "(", ")", "&&", "\"Only fp imm 0.0 is supported\"", ")", ";", "MCOp", "=", "MCOperand", "::", "CreateFPImm", "(", "0.0", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "Mang", "->", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "CreateExpr", "(", "MCSymbolRefExpr", "::", "Create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "OutContext", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "GetCPISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_RegisterMask", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"unknown operand type\"", "\"Subregs should be eliminated!\"", "\"Only fp imm 0.0 is supported\"", "0.0" ]

[]

[ "<s>", "SDValue", "XCoreTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "XCoreFunctionInfo", "*", "XFI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFrameInfo", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "if", "(", "!", "isVarArg", ")", "CCInfo", ".", "AllocateStack", "(", "XFI", "->", "getReturnStackOffset", "(", ")", ",", "4", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_XCore", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "0", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "MemOpChains", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "continue", ";", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "if", "(", "isVarArg", ")", "{", "report_fatal_error", "(", "\"Can't return value from vararg function in memory\"", ")", ";", "}", "int", "Offset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "ObjSize", "=", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", "/", "8", ";", "int", "FI", "=", "MFI", "->", "CreateFixedObject", "(", "ObjSize", ",", "Offset", ",", "false", ")", ";", "SDValue", "FIN", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "MemOpChains", ".", "push_back", "(", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "OutVals", "[", "i", "]", ",", "FIN", ",", "MachinePointerInfo", "::", "getFixedStack", "(", "FI", ")", ",", "false", ",", "false", ",", "0", ")", ")", ";", "}", "if", "(", "!", "MemOpChains", ".", "empty", "(", ")", ")", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", ",", "MemOpChains", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "if", "(", "!", "VA", ".", "isRegLoc", "(", ")", ")", "continue", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "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", "(", "XCoreISD", "::", "RETSP", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "ISD::OutputArg", "XCore", "XCore", "16", "4", "XCore", "4", "1", "0", "MVT::i32", "4", "0", "\"Can't return value from vararg function in memory\"", "8", "MVT::i32", "0", "ISD::TokenFactor", "MVT::Other", "0", "1", "0", "XCoreISD::RETSP", "MVT::Other" ]

[]

[ "<s>", "static", "void", "recombine_lvx_pattern", "(", "rtx_insn", "*", "insn", ",", "del_info", "*", "to_delete", ")", "{", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "body", ")", "==", "SET", "&&", "(", "GET_CODE", "(", "SET_SRC", "(", "body", ")", ")", "==", "VEC_SELECT", "||", "pattern_is_rotate64", "(", "body", ")", ")", "&&", "MEM_P", "(", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ")", ")", ";", "rtx", "mem", "=", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ";", "rtx", "base_reg", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "auto_vec", "<", "rtx_insn", "*", ">", "and_insns", ";", "auto_vec", "<", "rtx", ">", "and_ops", ";", "bool", "is_any_def_and", "=", "find_alignment_op", "(", "insn", ",", "base_reg", ",", "&", "and_insns", ",", "&", "and_ops", ")", ";", "if", "(", "is_any_def_and", ")", "{", "gcc_assert", "(", "and_insns", ".", "length", "(", ")", "==", "and_ops", ".", "length", "(", ")", ")", ";", "df_ref", "def", ";", "struct", "df_insn_info", "*", "insn_info", "=", "DF_INSN_INFO_GET", "(", "insn", ")", ";", "FOR_EACH_INSN_INFO_DEF", "(", "def", ",", "insn_info", ")", "{", "struct", "df_link", "*", "link", "=", "DF_REF_CHAIN", "(", "def", ")", ";", "if", "(", "!", "link", "||", "link", "->", "next", ")", "break", ";", "rtx_insn", "*", "swap_insn", "=", "DF_REF_INSN", "(", "link", "->", "ref", ")", ";", "if", "(", "!", "insn_is_swap_p", "(", "swap_insn", ")", "||", "insn_is_load_p", "(", "swap_insn", ")", "||", "insn_is_store_p", "(", "swap_insn", ")", ")", "break", ";", "to_delete", "[", "INSN_UID", "(", "swap_insn", ")", "]", ".", "replace", "=", "true", ";", "to_delete", "[", "INSN_UID", "(", "swap_insn", ")", "]", ".", "replace_insn", "=", "swap_insn", ";", "rtx", "new_reg", "=", "0", ";", "rtx", "and_mask", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "and_insns", ".", "length", "(", ")", ";", "i", "++", ")", "{", "rtx_insn", "*", "and_insn", "=", "and_insns", "[", "i", "]", ";", "rtx", "and_op", "=", "and_ops", "[", "i", "]", ";", "rtx", "and_base", "=", "XEXP", "(", "and_op", ",", "0", ")", ";", "if", "(", "!", "new_reg", ")", "{", "new_reg", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "and_base", ")", ")", ";", "and_mask", "=", "XEXP", "(", "and_op", ",", "1", ")", ";", "}", "rtx", "copy", "=", "gen_rtx_SET", "(", "new_reg", ",", "and_base", ")", ";", "rtx_insn", "*", "new_insn", "=", "emit_insn_after", "(", "copy", ",", "and_insn", ")", ";", "set_block_for_insn", "(", "new_insn", ",", "BLOCK_FOR_INSN", "(", "and_insn", ")", ")", ";", "df_insn_rescan", "(", "new_insn", ")", ";", "}", "XEXP", "(", "mem", ",", "0", ")", "=", "gen_rtx_AND", "(", "GET_MODE", "(", "new_reg", ")", ",", "new_reg", ",", "and_mask", ")", ";", "SET_SRC", "(", "body", ")", "=", "mem", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "df_insn_rescan", "(", "insn", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"lvx opportunity found at %d\\n\"", ",", "INSN_UID", "(", "insn", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "If", "INSN", "is", "the", "load", "for", "an", "lvx", "pattern", ",", "put", "it", "in", "canonical", "form", "." ]

[ "rs6000", "0", "0", "0", "0", "0", "0", "0", "1", "0", "1", "\"lvx opportunity found at %d\\n\"" ]

[]

[ "<s>", "void", "ARMCodeEmitter", "::", "emitInstruction", "(", "const", "MachineInstr", "&", "MI", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"JIT: \"", "<<", "(", "void", "*", ")", "MCE", ".", "getCurrentPCValue", "(", ")", "<<", "\":\\t\"", "<<", "MI", ")", ";", "MCE", ".", "processDebugLoc", "(", "MI", ".", "getDebugLoc", "(", ")", ",", "true", ")", ";", "++", "NumEmitted", ";", "switch", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", "&", "ARMII", "::", "FormMask", ")", "{", "default", ":", "{", "llvm_unreachable", "(", "\"Unhandled instruction encoding format!\"", ")", ";", "}", "case", "ARMII", "::", "MiscFrm", ":", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "LEApcrelJT", ")", "{", "emitLEApcrelJTInstruction", "(", "MI", ")", ";", "break", ";", "}", "llvm_unreachable", "(", "\"Unhandled instruction encoding!\"", ")", ";", "case", "ARMII", "::", "Pseudo", ":", "emitPseudoInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "DPFrm", ":", "case", "ARMII", "::", "DPSoRegFrm", ":", "emitDataProcessingInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "LdFrm", ":", "case", "ARMII", "::", "StFrm", ":", "emitLoadStoreInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "LdMiscFrm", ":", "case", "ARMII", "::", "StMiscFrm", ":", "emitMiscLoadStoreInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "LdStMulFrm", ":", "emitLoadStoreMultipleInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "MulFrm", ":", "emitMulFrmInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "ExtFrm", ":", "emitExtendInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "ArithMiscFrm", ":", "emitMiscArithInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "SatFrm", ":", "emitSaturateInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "BrFrm", ":", "emitBranchInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "BrMiscFrm", ":", "emitMiscBranchInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "VFPUnaryFrm", ":", "case", "ARMII", "::", "VFPBinaryFrm", ":", "emitVFPArithInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "VFPConv1Frm", ":", "case", "ARMII", "::", "VFPConv2Frm", ":", "case", "ARMII", "::", "VFPConv3Frm", ":", "case", "ARMII", "::", "VFPConv4Frm", ":", "case", "ARMII", "::", "VFPConv5Frm", ":", "emitVFPConversionInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "VFPLdStFrm", ":", "emitVFPLoadStoreInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "VFPLdStMulFrm", ":", "emitVFPLoadStoreMultipleInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "NGetLnFrm", ":", "case", "ARMII", "::", "NSetLnFrm", ":", "emitNEONLaneInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "NDupFrm", ":", "emitNEONDupInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "N1RegModImmFrm", ":", "emitNEON1RegModImmInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "N2RegFrm", ":", "emitNEON2RegInstruction", "(", "MI", ")", ";", "break", ";", "case", "ARMII", "::", "N3RegFrm", ":", "emitNEON3RegInstruction", "(", "MI", ")", ";", "break", ";", "}", "MCE", ".", "processDebugLoc", "(", "MI", ".", "getDebugLoc", "(", ")", ",", "false", ")", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "ARM", "ARM", "\"JIT: \"", "\":\\t\"", "ARMII::FormMask", "\"Unhandled instruction encoding format!\"", "ARMII::MiscFrm", "ARM::LEApcrelJT", "\"Unhandled instruction encoding!\"", "ARMII::Pseudo", "ARMII::DPFrm", "ARMII::DPSoRegFrm", "ARMII::LdFrm", "ARMII::StFrm", "ARMII::LdMiscFrm", "ARMII::StMiscFrm", "ARMII::LdStMulFrm", "ARMII::MulFrm", "ARMII::ExtFrm", "ARMII::ArithMiscFrm", "ARMII::SatFrm", "ARMII::BrFrm", "ARMII::BrMiscFrm", "ARMII::VFPUnaryFrm", "ARMII::VFPBinaryFrm", "ARMII::VFPConv1Frm", "ARMII::VFPConv2Frm", "ARMII::VFPConv3Frm", "ARMII::VFPConv4Frm", "ARMII::VFPConv5Frm", "ARMII::VFPLdStFrm", "ARMII::VFPLdStMulFrm", "ARMII::NGetLnFrm", "ARMII::NSetLnFrm", "ARMII::NDupFrm", "ARMII::N1RegModImmFrm", "ARMII::N2RegFrm", "ARMII::N3RegFrm" ]

[]

[ "<s>", "static", "void", "arm_reorg", "(", "void", ")", "{", "rtx", "insn", ";", "HOST_WIDE_INT", "address", "=", "0", ";", "Mfix", "*", "fix", ";", "minipool_fix_head", "=", "minipool_fix_tail", "=", "NULL", ";", "insn", "=", "get_insns", "(", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "insn", ")", "==", "NOTE", ")", ";", "for", "(", "insn", "=", "next_nonnote_insn", "(", "insn", ")", ";", "insn", ";", "insn", "=", "next_nonnote_insn", "(", "insn", ")", ")", "{", "if", "(", "TARGET_CIRRUS_FIX_INVALID_INSNS", "&&", "(", "arm_cirrus_insn_p", "(", "insn", ")", "||", "GET_CODE", "(", "insn", ")", "==", "JUMP_INSN", "||", "arm_memory_load_p", "(", "insn", ")", ")", ")", "cirrus_reorg", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "BARRIER", ")", "push_minipool_barrier", "(", "insn", ",", "address", ")", ";", "else", "if", "(", "INSN_P", "(", "insn", ")", ")", "{", "rtx", "table", ";", "note_invalid_constants", "(", "insn", ",", "address", ",", "true", ")", ";", "address", "+=", "get_attr_length", "(", "insn", ")", ";", "if", "(", "(", "table", "=", "is_jump_table", "(", "insn", ")", ")", "!=", "NULL", ")", "{", "address", "+=", "get_jump_table_size", "(", "table", ")", ";", "insn", "=", "table", ";", "}", "}", "}", "fix", "=", "minipool_fix_head", ";", "while", "(", "fix", ")", "{", "Mfix", "*", "ftmp", ";", "Mfix", "*", "fdel", ";", "Mfix", "*", "last_added_fix", ";", "Mfix", "*", "last_barrier", "=", "NULL", ";", "Mfix", "*", "this_fix", ";", "while", "(", "fix", "&&", "GET_CODE", "(", "fix", "->", "insn", ")", "==", "BARRIER", ")", "fix", "=", "fix", "->", "next", ";", "if", "(", "fix", "==", "NULL", ")", "break", ";", "last_added_fix", "=", "NULL", ";", "for", "(", "ftmp", "=", "fix", ";", "ftmp", ";", "ftmp", "=", "ftmp", "->", "next", ")", "{", "if", "(", "GET_CODE", "(", "ftmp", "->", "insn", ")", "==", "BARRIER", ")", "{", "if", "(", "ftmp", "->", "address", ">=", "minipool_vector_head", "->", "max_address", ")", "break", ";", "last_barrier", "=", "ftmp", ";", "}", "else", "if", "(", "(", "ftmp", "->", "minipool", "=", "add_minipool_forward_ref", "(", "ftmp", ")", ")", "==", "NULL", ")", "break", ";", "last_added_fix", "=", "ftmp", ";", "}", "if", "(", "last_barrier", "!=", "NULL", ")", "{", "for", "(", "fdel", "=", "last_barrier", "->", "next", ";", "fdel", "&&", "fdel", "!=", "ftmp", ";", "fdel", "=", "fdel", "->", "next", ")", "{", "fdel", "->", "minipool", "->", "refcount", "--", ";", "fdel", "->", "minipool", "=", "NULL", ";", "}", "ftmp", "=", "last_barrier", ";", "}", "else", "{", "HOST_WIDE_INT", "max_address", ";", "gcc_assert", "(", "ftmp", ")", ";", "max_address", "=", "minipool_vector_head", "->", "max_address", ";", "if", "(", "ftmp", "->", "address", "<", "max_address", ")", "max_address", "=", "ftmp", "->", "address", ";", "last_barrier", "=", "create_fix_barrier", "(", "last_added_fix", ",", "max_address", ")", ";", "}", "assign_minipool_offsets", "(", "last_barrier", ")", ";", "while", "(", "ftmp", ")", "{", "if", "(", "GET_CODE", "(", "ftmp", "->", "insn", ")", "!=", "BARRIER", "&&", "(", "(", "ftmp", "->", "minipool", "=", "add_minipool_backward_ref", "(", "ftmp", ")", ")", "==", "NULL", ")", ")", "break", ";", "ftmp", "=", "ftmp", "->", "next", ";", "}", "for", "(", "this_fix", "=", "fix", ";", "this_fix", "&&", "ftmp", "!=", "this_fix", ";", "this_fix", "=", "this_fix", "->", "next", ")", "if", "(", "GET_CODE", "(", "this_fix", "->", "insn", ")", "!=", "BARRIER", ")", "{", "rtx", "addr", "=", "plus_constant", "(", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "minipool_vector_label", ")", ",", "this_fix", "->", "minipool", "->", "offset", ")", ";", "*", "this_fix", "->", "loc", "=", "gen_rtx_MEM", "(", "this_fix", "->", "mode", ",", "addr", ")", ";", "}", "dump_minipool", "(", "last_barrier", "->", "insn", ")", ";", "fix", "=", "ftmp", ";", "}", "after_arm_reorg", "=", "1", ";", "obstack_free", "(", "&", "minipool_obstack", ",", "minipool_startobj", ")", ";", "}", "</s>" ]

[ "Gcc", "puts", "the", "pool", "in", "the", "wrong", "place", "for", "ARM", ",", "since", "we", "can", "only", "load", "addresses", "a", "limited", "distance", "around", "the", "pc", ".", "We", "do", "some", "special", "munging", "to", "move", "the", "constant", "pool", "values", "to", "the", "correct", "point", "in", "the", "code", "." ]

[ "arm", "0", "1" ]

[]

[ "<s>", "int", "mmix_print_operand_punct_valid_p", "(", "int", "code", "ATTRIBUTE_UNUSED", ")", "{", "return", "code", "==", "'+'", "||", "code", "==", "'.'", ";", "}", "</s>" ]

[ "PRINT_OPERAND_PUNCT_VALID_P", "." ]

[ "mmix" ]

[]

[ "<s>", "static", "void", "frv_io_union", "(", "struct", "frv_io", "*", "x", ",", "const", "struct", "frv_io", "*", "y", ")", "{", "if", "(", "x", "->", "type", "!=", "y", "->", "type", ")", "x", "->", "type", "=", "FRV_IO_UNKNOWN", ";", "if", "(", "!", "frv_same_doubleword_p", "(", "x", ",", "y", ")", ")", "{", "x", "->", "const_address", "=", "0", ";", "x", "->", "var_address", "=", "0", ";", "}", "}", "</s>" ]

[ "Generalize", "I/O", "operation", "X", "so", "that", "it", "covers", "both", "X", "and", "Y", "." ]

[ "frv", "0", "0" ]

[]

[ "<s>", "bool", "HexagonNoExtendOperand", "::", "classof", "(", "MCExpr", "const", "*", "E", ")", "{", "return", "E", "->", "getKind", "(", ")", "==", "MCExpr", "::", "Target", ";", "}", "</s>" ]

[ "Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":" ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "Register", "&", "SrcReg", ",", "Register", "&", "SrcReg2", ",", "int64_t", "&", "Mask", ",", "int64_t", "&", "Value", ")", "const", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "return", "false", ";", "case", "PPC", "::", "CMPWI", ":", "case", "PPC", "::", "CMPLWI", ":", "case", "PPC", "::", "CMPDI", ":", "case", "PPC", "::", "CMPLDI", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "Value", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "Mask", "=", "0xFFFF", ";", "return", "true", ";", "case", "PPC", "::", "CMPW", ":", "case", "PPC", "::", "CMPLW", ":", "case", "PPC", "::", "CMPD", ":", "case", "PPC", "::", "CMPLD", ":", "case", "PPC", "::", "FCMPUS", ":", "case", "PPC", "::", "FCMPUD", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "Value", "=", "0", ";", "Mask", "=", "0", ";", "return", "true", ";", "}", "}", "</s>" ]

[ "analyzeCompare", "-", "For", "a", "comparison", "instruction", ",", "return", "the", "source", "registers", "in", "SrcReg", "and", "SrcReg2", "if", "having", "two", "register", "operands", ",", "and", "the", "value", "it", "compares", "against", "in", "CmpValue", "." ]

[ "PowerPC", "PPC", "PPC::CMPWI", "PPC::CMPLWI", "PPC::CMPDI", "PPC::CMPLDI", "1", "0", "2", "0xFFFF", "PPC::CMPW", "PPC::CMPLW", "PPC::CMPD", "PPC::CMPLD", "PPC::FCMPUS", "PPC::FCMPUD", "1", "2", "0", "0" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "SubsumesPredicate", "(", "ArrayRef", "<", "MachineOperand", ">", "Pred1", ",", "ArrayRef", "<", "MachineOperand", ">", "Pred2", ")", "const", "{", "assert", "(", "Pred1", ".", "size", "(", ")", "==", "2", "&&", "\"Invalid PPC first predicate\"", ")", ";", "assert", "(", "Pred2", ".", "size", "(", ")", "==", "2", "&&", "\"Invalid PPC second predicate\"", ")", ";", "if", "(", "Pred1", "[", "1", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR8", "||", "Pred1", "[", "1", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR", ")", "return", "false", ";", "if", "(", "Pred2", "[", "1", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR8", "||", "Pred2", "[", "1", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR", ")", "return", "false", ";", "if", "(", "Pred1", "[", "1", "]", ".", "getReg", "(", ")", "!=", "Pred2", "[", "1", "]", ".", "getReg", "(", ")", ")", "return", "false", ";", "PPC", "::", "Predicate", "P1", "=", "(", "PPC", "::", "Predicate", ")", "Pred1", "[", "0", "]", ".", "getImm", "(", ")", ";", "PPC", "::", "Predicate", "P2", "=", "(", "PPC", "::", "Predicate", ")", "Pred2", "[", "0", "]", ".", "getImm", "(", ")", ";", "if", "(", "P1", "==", "P2", ")", "return", "true", ";", "if", "(", "P1", "==", "PPC", "::", "PRED_LE", "&&", "(", "P2", "==", "PPC", "::", "PRED_LT", "||", "P2", "==", "PPC", "::", "PRED_EQ", ")", ")", "return", "true", ";", "if", "(", "P1", "==", "PPC", "::", "PRED_GE", "&&", "(", "P2", "==", "PPC", "::", "PRED_GT", "||", "P2", "==", "PPC", "::", "PRED_EQ", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "first", "specified", "predicate", "subsumes", "the", "second", ",", "e.g", "." ]

[ "PowerPC", "PPC", "2", "\"Invalid PPC first predicate\"", "2", "\"Invalid PPC second predicate\"", "1", "PPC::CTR8", "1", "PPC::CTR", "1", "PPC::CTR8", "1", "PPC::CTR", "1", "1", "PPC::Predicate", "PPC::Predicate", "0", "PPC::Predicate", "PPC::Predicate", "0", "PPC::PRED_LE", "PPC::PRED_LT", "PPC::PRED_EQ", "PPC::PRED_GE", "PPC::PRED_GT", "PPC::PRED_EQ" ]

[]

[ "<s>", "static", "void", "avr_move_bits", "(", "rtx", "*", "xop", ",", "unsigned", "int", "map", ",", "bool", "fixp_p", ",", "int", "*", "plen", ")", "{", "int", "t_bit_src", "=", "-", "1", ";", "for", "(", "int", "b", "=", "0", ";", "b", "<", "8", ";", "b", "++", ")", "for", "(", "int", "bit_dest", "=", "0", ";", "bit_dest", "<", "8", ";", "bit_dest", "++", ")", "{", "int", "bit_src", "=", "avr_map", "(", "map", ",", "bit_dest", ")", ";", "if", "(", "b", "!=", "bit_src", "||", "bit_src", ">=", "8", "||", "(", "bit_dest", "==", "bit_src", "&&", "!", "fixp_p", ")", ")", "continue", ";", "if", "(", "t_bit_src", "!=", "bit_src", ")", "{", "t_bit_src", "=", "bit_src", ";", "xop", "[", "3", "]", "=", "GEN_INT", "(", "bit_src", ")", ";", "avr_asm_len", "(", "\"bst %T1%T3\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "}", "xop", "[", "3", "]", "=", "GEN_INT", "(", "bit_dest", ")", ";", "avr_asm_len", "(", "\"bld %T0%T3\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "}", "}", "</s>" ]

[ "Insert", "bits", "from", "XOP", "[", "1", "]", "into", "XOP", "[", "0", "]", "according", "to", "MAP", ".", "XOP", "[", "0", "]", "and", "XOP", "[", "1", "]", "do", "n't", "overlap", ".", "If", "FIXP_P", "=", "true", ":", "Move", "all", "bits", "according", "to", "MAP", "using", "BLD/BST", "sequences", ".", "If", "FIXP_P", "=", "false", ":", "Just", "move", "the", "bit", "if", "its", "position", "in", "the", "destination", "is", "different", "to", "its", "source", "position", "." ]

[ "avr", "1", "0", "8", "0", "8", "8", "3", "\"bst %T1%T3\"", "1", "3", "\"bld %T0%T3\"", "1" ]

[]

[ "<s>", "static", "rtx", "mips_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "int", "ignore", ")", "{", "tree", "fndecl", ";", "unsigned", "int", "fcode", ",", "avail", ";", "const", "struct", "mips_builtin_description", "*", "d", ";", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "fcode", "=", "DECL_MD_FUNCTION_CODE", "(", "fndecl", ")", ";", "gcc_assert", "(", "fcode", "<", "ARRAY_SIZE", "(", "mips_builtins", ")", ")", ";", "d", "=", "&", "mips_builtins", "[", "fcode", "]", ";", "avail", "=", "d", "->", "avail", "(", ")", ";", "gcc_assert", "(", "avail", "!=", "0", ")", ";", "if", "(", "TARGET_MIPS16", "&&", "!", "(", "avail", "&", "BUILTIN_AVAIL_MIPS16", ")", ")", "{", "error", "(", "\"built-in function %qE not supported for MIPS16\"", ",", "DECL_NAME", "(", "fndecl", ")", ")", ";", "return", "ignore", "?", "const0_rtx", ":", "CONST0_RTX", "(", "mode", ")", ";", "}", "switch", "(", "d", "->", "builtin_type", ")", "{", "case", "MIPS_BUILTIN_DIRECT", ":", "return", "mips_expand_builtin_direct", "(", "d", "->", "icode", ",", "target", ",", "exp", ",", "true", ")", ";", "case", "MIPS_BUILTIN_DIRECT_NO_TARGET", ":", "return", "mips_expand_builtin_direct", "(", "d", "->", "icode", ",", "target", ",", "exp", ",", "false", ")", ";", "case", "MIPS_BUILTIN_MOVT", ":", "case", "MIPS_BUILTIN_MOVF", ":", "return", "mips_expand_builtin_movtf", "(", "d", "->", "builtin_type", ",", "d", "->", "icode", ",", "d", "->", "cond", ",", "target", ",", "exp", ")", ";", "case", "MIPS_BUILTIN_CMP_ANY", ":", "case", "MIPS_BUILTIN_CMP_ALL", ":", "case", "MIPS_BUILTIN_CMP_UPPER", ":", "case", "MIPS_BUILTIN_CMP_LOWER", ":", "case", "MIPS_BUILTIN_CMP_SINGLE", ":", "return", "mips_expand_builtin_compare", "(", "d", "->", "builtin_type", ",", "d", "->", "icode", ",", "d", "->", "cond", ",", "target", ",", "exp", ")", ";", "case", "MIPS_BUILTIN_MSA_TEST_BRANCH", ":", "return", "mips_expand_builtin_msa_test_branch", "(", "d", "->", "icode", ",", "exp", ")", ";", "case", "MIPS_BUILTIN_BPOSGE32", ":", "return", "mips_expand_builtin_bposge", "(", "d", "->", "builtin_type", ",", "target", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Expand", "builtin", "functions", ".", "This", "is", "called", "from", "TARGET_EXPAND_BUILTIN", "." ]

[ "mips", "0", "0", "\"built-in function %qE not supported for MIPS16\"" ]

[]

[ "<s>", "const", "MachineBasicBlock", "::", "const_iterator", "getNext", "(", ")", "const", "{", "return", "NextMI", ";", "}", "</s>" ]

[ "Get", "the", "next", "SDUse", "in", "the", "use", "list", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "AArch64RegisterInfo", "::", "canRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "\"no-realign-stack\"", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "True", "if", "the", "stack", "can", "be", "realigned", "for", "the", "target", "." ]

[ "AArch64", "AArch64", "\"no-realign-stack\"" ]

[]

[ "<s>", "void", "Z80InstrInfo", "::", "reMaterialize", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DstReg", ",", "unsigned", "SubIdx", ",", "const", "MachineInstr", "&", "Orig", ",", "const", "TargetRegisterInfo", "&", "TRI", ")", "const", "{", "if", "(", "!", "Orig", ".", "modifiesRegister", "(", "Z80", "::", "F", ",", "&", "TRI", ")", "||", "MBB", ".", "computeRegisterLiveness", "(", "&", "TRI", ",", "Z80", "::", "F", ",", "I", ")", "==", "MachineBasicBlock", "::", "LQR_Dead", ")", "return", "TargetInstrInfo", "::", "reMaterialize", "(", "MBB", ",", "I", ",", "DstReg", ",", "SubIdx", ",", "Orig", ",", "TRI", ")", ";", "unsigned", "Opc", ";", "int", "Val", ";", "switch", "(", "Orig", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected instruction!\"", ")", ";", "case", "Z80", "::", "LD8r0", ":", "Opc", "=", "Z80", "::", "LD8ri", ";", "Val", "=", "0", ";", "break", ";", "case", "Z80", "::", "LD24r0", ":", "Opc", "=", "Z80", "::", "LD24ri", ";", "Val", "=", "0", ";", "break", ";", "case", "Z80", "::", "LD24r_1", ":", "Opc", "=", "Z80", "::", "LD24ri", ";", "Val", "=", "-", "1", ";", "break", ";", "}", "BuildMI", "(", "MBB", ",", "I", ",", "Orig", ".", "getDebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "DstReg", ",", "RegState", "::", "Define", ",", "SubIdx", ")", ".", "addImm", "(", "Val", ")", ";", "}", "</s>" ]

[ "Re-issue", "the", "specified", "'original", "'", "instruction", "at", "the", "specific", "location", "targeting", "a", "new", "destination", "register", "." ]

[ "Z80", "Z80", "Z80::F", "Z80::F", "\"Unexpected instruction!\"", "Z80::LD8r0", "Z80::LD8ri", "0", "Z80::LD24r0", "Z80::LD24ri", "0", "Z80::LD24r_1", "Z80::LD24ri", "1" ]

[]

[ "<s>", "int", "pa_fpstore_bypass_p", "(", "rtx_insn", "*", "out_insn", ",", "rtx_insn", "*", "in_insn", ")", "{", "machine_mode", "store_mode", ";", "machine_mode", "other_mode", ";", "rtx", "set", ";", "if", "(", "recog_memoized", "(", "in_insn", ")", "<", "0", "||", "(", "get_attr_type", "(", "in_insn", ")", "!=", "TYPE_FPSTORE", "&&", "get_attr_type", "(", "in_insn", ")", "!=", "TYPE_FPSTORE_LOAD", ")", "||", "recog_memoized", "(", "out_insn", ")", "<", "0", ")", "return", "0", ";", "store_mode", "=", "GET_MODE", "(", "SET_SRC", "(", "PATTERN", "(", "in_insn", ")", ")", ")", ";", "set", "=", "single_set", "(", "out_insn", ")", ";", "if", "(", "!", "set", ")", "return", "0", ";", "other_mode", "=", "GET_MODE", "(", "SET_SRC", "(", "set", ")", ")", ";", "return", "(", "GET_MODE_SIZE", "(", "store_mode", ")", "==", "GET_MODE_SIZE", "(", "other_mode", ")", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "there", "is", "a", "bypass", "for", "the", "output", "of", "OUT_INSN", "and", "the", "fp", "store", "IN_INSN", "." ]

[ "pa", "0", "0", "0", "0" ]

[]

[ "<s>", "BitVector", "TMS320C64XRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "TMS320C64X", "::", "B15", ")", ";", "Reserved", ".", "set", "(", "TMS320C64X", "::", "A15", ")", ";", "Reserved", ".", "set", "(", "TMS320C64X", "::", "A14", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "TMS320C64X", "TMS320C64X", "TMS320C64X::B15", "TMS320C64X::A15", "TMS320C64X::A14" ]

[]

[ "<s>", "void", "emit_fusion_addis", "(", "rtx", "target", ",", "rtx", "addis_value", ")", "{", "rtx", "fuse_ops", "[", "10", "]", ";", "const", "char", "*", "addis_str", "=", "NULL", ";", "fuse_ops", "[", "0", "]", "=", "target", ";", "if", "(", "satisfies_constraint_L", "(", "addis_value", ")", ")", "{", "fuse_ops", "[", "1", "]", "=", "addis_value", ";", "addis_str", "=", "\"lis %0,%v1\"", ";", "}", "else", "if", "(", "GET_CODE", "(", "addis_value", ")", "==", "PLUS", ")", "{", "rtx", "op0", "=", "XEXP", "(", "addis_value", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "addis_value", ",", "1", ")", ";", "if", "(", "REG_P", "(", "op0", ")", "&&", "CONST_INT_P", "(", "op1", ")", "&&", "satisfies_constraint_L", "(", "op1", ")", ")", "{", "fuse_ops", "[", "1", "]", "=", "op0", ";", "fuse_ops", "[", "2", "]", "=", "op1", ";", "addis_str", "=", "\"addis %0,%1,%v2\"", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "addis_value", ")", "==", "HIGH", ")", "{", "rtx", "value", "=", "XEXP", "(", "addis_value", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "value", ")", "==", "UNSPEC", "&&", "XINT", "(", "value", ",", "1", ")", "==", "UNSPEC_TOCREL", ")", "{", "fuse_ops", "[", "1", "]", "=", "XVECEXP", "(", "value", ",", "0", ",", "0", ")", ";", "fuse_ops", "[", "2", "]", "=", "XVECEXP", "(", "value", ",", "0", ",", "1", ")", ";", "if", "(", "TARGET_ELF", ")", "addis_str", "=", "\"addis %0,%2,%1@toc@ha\"", ";", "else", "if", "(", "TARGET_XCOFF", ")", "addis_str", "=", "\"addis %0,%1@u(%2)\"", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "value", ")", "==", "PLUS", ")", "{", "rtx", "op0", "=", "XEXP", "(", "value", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "value", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "UNSPEC", "&&", "XINT", "(", "op0", ",", "1", ")", "==", "UNSPEC_TOCREL", "&&", "CONST_INT_P", "(", "op1", ")", ")", "{", "fuse_ops", "[", "1", "]", "=", "XVECEXP", "(", "op0", ",", "0", ",", "0", ")", ";", "fuse_ops", "[", "2", "]", "=", "XVECEXP", "(", "op0", ",", "0", ",", "1", ")", ";", "fuse_ops", "[", "3", "]", "=", "op1", ";", "if", "(", "TARGET_ELF", ")", "addis_str", "=", "\"addis %0,%2,%1+%3@toc@ha\"", ";", "else", "if", "(", "TARGET_XCOFF", ")", "addis_str", "=", "\"addis %0,%1+%3@u(%2)\"", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "if", "(", "satisfies_constraint_L", "(", "value", ")", ")", "{", "fuse_ops", "[", "1", "]", "=", "value", ";", "addis_str", "=", "\"lis %0,%v1\"", ";", "}", "else", "if", "(", "TARGET_ELF", "&&", "!", "TARGET_POWERPC64", "&&", "CONSTANT_P", "(", "value", ")", ")", "{", "fuse_ops", "[", "1", "]", "=", "value", ";", "addis_str", "=", "\"lis %0,%1@ha\"", ";", "}", "}", "if", "(", "!", "addis_str", ")", "fatal_insn", "(", "\"Could not generate addis value for fusion\"", ",", "addis_value", ")", ";", "output_asm_insn", "(", "addis_str", ",", "fuse_ops", ")", ";", "}", "</s>" ]

[ "Emit", "the", "addis", "instruction", "that", "will", "be", "part", "of", "a", "fused", "instruction", "sequence", "." ]

[ "rs6000", "10", "0", "1", "\"lis %0,%v1\"", "0", "1", "1", "2", "\"addis %0,%1,%v2\"", "0", "1", "1", "0", "0", "2", "0", "1", "\"addis %0,%2,%1@toc@ha\"", "\"addis %0,%1@u(%2)\"", "0", "1", "1", "1", "0", "0", "2", "0", "1", "3", "\"addis %0,%2,%1+%3@toc@ha\"", "\"addis %0,%1+%3@u(%2)\"", "1", "\"lis %0,%v1\"", "1", "\"lis %0,%1@ha\"", "\"Could not generate addis value for fusion\"" ]

[]

[ "<s>", "const", "uint16_t", "*", "AVRRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "CallingConv", "::", "ID", "CC", "=", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "return", "(", "(", "CC", "==", "CallingConv", "::", "AVR_INTR", "||", "CC", "==", "CallingConv", "::", "AVR_SIGNAL", ")", "?", "CSR_Interrupts_SaveList", ":", "CSR_Normal_SaveList", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "AVR" ]

[]

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

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

[ "Hexagon" ]

[]

[ "<s>", "static", "rtx", "mips_call_tls_get_addr", "(", "rtx", "sym", ",", "enum", "mips_symbol_type", "type", ",", "rtx", "v0", ")", "{", "rtx", "insn", ",", "loc", ",", "tga", ",", "a0", ";", "a0", "=", "gen_rtx_REG", "(", "Pmode", ",", "GP_ARG_FIRST", ")", ";", "if", "(", "!", "mips_tls_symbol", ")", "mips_tls_symbol", "=", "init_one_libfunc", "(", "\"__tls_get_addr\"", ")", ";", "loc", "=", "mips_unspec_address", "(", "sym", ",", "type", ")", ";", "start_sequence", "(", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "Pmode", ",", "a0", ",", "gen_rtx_LO_SUM", "(", "Pmode", ",", "pic_offset_table_rtx", ",", "loc", ")", ")", ")", ";", "tga", "=", "gen_rtx_MEM", "(", "Pmode", ",", "mips_tls_symbol", ")", ";", "insn", "=", "emit_call_insn", "(", "gen_call_value", "(", "v0", ",", "tga", ",", "const0_rtx", ",", "const0_rtx", ")", ")", ";", "CONST_OR_PURE_CALL_P", "(", "insn", ")", "=", "1", ";", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ",", "v0", ")", ";", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ",", "a0", ")", ";", "insn", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "return", "insn", ";", "}", "</s>" ]

[ "Return", "an", "instruction", "sequence", "that", "calls", "__tls_get_addr", ".", "SYM", "is", "the", "TLS", "symbol", "we", "are", "referencing", "and", "TYPE", "is", "the", "symbol", "type", "to", "use", "(", "either", "global", "dynamic", "or", "local", "dynamic", ")", ".", "V0", "is", "an", "RTX", "for", "the", "return", "value", "location", "." ]

[ "mips", "\"__tls_get_addr\"", "1" ]

[]

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

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

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

[]

[ "<s>", "unsigned", "AArch64InstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64", "::", "STRWui", ":", "case", "AArch64", "::", "STRXui", ":", "case", "AArch64", "::", "STRBui", ":", "case", "AArch64", "::", "STRHui", ":", "case", "AArch64", "::", "STRSui", ":", "case", "AArch64", "::", "STRDui", ":", "case", "AArch64", "::", "STRQui", ":", "case", "AArch64", "::", "STR_PXI", ":", "case", "AArch64", "::", "STR_ZXI", ":", "case", "AArch64", "::", "STR_ZZXI", ":", "case", "AArch64", "::", "STR_ZZZXI", ":", "case", "AArch64", "::", "STR_ZZZZXI", ":", "if", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64::STRWui", "AArch64::STRXui", "AArch64::STRBui", "AArch64::STRHui", "AArch64::STRSui", "AArch64::STRDui", "AArch64::STRQui", "AArch64::STR_PXI", "AArch64::STR_ZXI", "AArch64::STR_ZZXI", "AArch64::STR_ZZZXI", "AArch64::STR_ZZZZXI", "0", "0", "1", "2", "2", "0", "1", "0", "0" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "compute_frame_size", "(", "HOST_WIDE_INT", "size", ",", "HOST_WIDE_INT", "sa_size", ")", "{", "if", "(", "TARGET_ABI_OPEN_VMS", ")", "return", "ALPHA_ROUND", "(", "sa_size", "+", "(", "alpha_procedure_type", "==", "PT_STACK", "?", "8", ":", "0", ")", "+", "size", "+", "crtl", "->", "args", ".", "pretend_args_size", ")", ";", "else", "return", "ALPHA_ROUND", "(", "crtl", "->", "outgoing_args_size", ")", "+", "sa_size", "+", "ALPHA_ROUND", "(", "size", "+", "crtl", "->", "args", ".", "pretend_args_size", ")", ";", "}", "</s>" ]

[ "Typical", "stack", "layout", "should", "looks", "like", "this", "after", "the", "function", "'s", "prologue", ":", "|", "|", "--", "^", "|", "|", "\\", "|", "|", "|", "arguments", "saved", "|", "Increasing", "|", "|", "on", "the", "stack", "|", "addresses", "PARENT", "arg", "pointer", "-", ">", "|", "|", "/", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "-", "|", "|", "-", "space", "for", "argument", "split", "between", "regs", "&", "stack", "--", "CHILD", "|", "|", "\\", "<", "--", "(", "return", "address", "here", ")", "|", "|", "other", "call", "|", "|", "saved", "registers", "|", "|", "/", "--", "frame", "pointer", "-", ">", "|", "|", "\\", "___", "|", "|", "local", "|", "|", "|", "variables", "|f", "|", "|", "/", "|r", "--", "|a", "|", "|", "\\", "|m", "|", "|", "outgoing", "|e", "|", "|", "arguments", "|", "|", "Decreasing", "(", "hard", ")", "frame", "pointer", "|", "|", "/", "|", "|", "addresses", "and", "stack", "pointer", "-", ">", "|", "|", "/", "_|_", "|", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "V" ]

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

[]

[ "<s>", "int", "mt_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "mt_compute_frame_size", "(", "get_frame_size", "(", ")", ")", ";", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "return", "0", ";", "else", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "return", "current_frame_info", ".", "total_size", ";", "else", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "FRAME_POINTER_REGNUM", ")", "return", "current_frame_info", ".", "total_size", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "INITIAL_ELIMINATION_OFFSET", "." ]

[ "mt", "0" ]

[]

[ "<s>", "inline", "const", "AMDGPURegisterInfo", "*", "AMDGPUSubtarget", "::", "getRegisterInfo", "(", ")", "const", "{", "if", "(", "getGeneration", "(", ")", ">=", "SOUTHERN_ISLANDS", ")", "return", "static_cast", "<", "const", "SISubtarget", "*", ">", "(", "this", ")", "->", "getRegisterInfo", "(", ")", ";", "return", "static_cast", "<", "const", "R600Subtarget", "*", ">", "(", "this", ")", "->", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU", "SI", "R600" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "isLegalMaskedScatter", "(", "Type", "*", "DataType", ")", "{", "return", "isLegalMaskedGather", "(", "DataType", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "masked", "scatter", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "void", "avr_cpu_cpp_builtins", "(", "struct", "cpp_reader", "*", "pfile", ")", "{", "builtin_define_std", "(", "\"AVR\"", ")", ";", "if", "(", "avr_arch", "->", "macro", ")", "cpp_define_formatted", "(", "pfile", ",", "\"__AVR_ARCH__=%s\"", ",", "avr_arch", "->", "macro", ")", ";", "if", "(", "AVR_HAVE_RAMPD", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_RAMPD__\"", ")", ";", "if", "(", "AVR_HAVE_RAMPX", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_RAMPX__\"", ")", ";", "if", "(", "AVR_HAVE_RAMPY", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_RAMPY__\"", ")", ";", "if", "(", "AVR_HAVE_RAMPZ", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_RAMPZ__\"", ")", ";", "if", "(", "AVR_HAVE_ELPM", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_ELPM__\"", ")", ";", "if", "(", "AVR_HAVE_ELPMX", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_ELPMX__\"", ")", ";", "if", "(", "AVR_HAVE_MOVW", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_MOVW__\"", ")", ";", "if", "(", "AVR_HAVE_LPMX", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_LPMX__\"", ")", ";", "if", "(", "avr_arch", "->", "asm_only", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_ASM_ONLY__\"", ")", ";", "if", "(", "AVR_HAVE_MUL", ")", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_ENHANCED__\"", ")", ";", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_MUL__\"", ")", ";", "}", "if", "(", "AVR_HAVE_JMP_CALL", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_JMP_CALL__\"", ")", ";", "if", "(", "avr_arch", "->", "have_jmp_call", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_MEGA__\"", ")", ";", "if", "(", "AVR_SHORT_CALLS", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_SHORT_CALLS__\"", ")", ";", "if", "(", "AVR_XMEGA", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_XMEGA__\"", ")", ";", "if", "(", "AVR_TINY", ")", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_TINY__\"", ")", ";", "cpp_define_formatted", "(", "pfile", ",", "\"__AVR_TINY_PM_BASE_ADDRESS__=0x%x\"", ",", "avr_arch", "->", "flash_pm_offset", ")", ";", "}", "if", "(", "avr_arch", "->", "flash_pm_offset", ")", "cpp_define_formatted", "(", "pfile", ",", "\"__AVR_PM_BASE_ADDRESS__=0x%x\"", ",", "avr_arch", "->", "flash_pm_offset", ")", ";", "if", "(", "AVR_HAVE_EIJMP_EICALL", ")", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_EIJMP_EICALL__\"", ")", ";", "cpp_define", "(", "pfile", ",", "\"__AVR_3_BYTE_PC__\"", ")", ";", "}", "else", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_2_BYTE_PC__\"", ")", ";", "}", "if", "(", "AVR_HAVE_8BIT_SP", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_8BIT_SP__\"", ")", ";", "else", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_16BIT_SP__\"", ")", ";", "if", "(", "AVR_HAVE_SPH", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_SPH__\"", ")", ";", "else", "cpp_define", "(", "pfile", ",", "\"__AVR_SP8__\"", ")", ";", "if", "(", "TARGET_NO_INTERRUPTS", ")", "cpp_define", "(", "pfile", ",", "\"__NO_INTERRUPTS__\"", ")", ";", "if", "(", "TARGET_SKIP_BUG", ")", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_ERRATA_SKIP__\"", ")", ";", "if", "(", "AVR_HAVE_JMP_CALL", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_ERRATA_SKIP_JMP_CALL__\"", ")", ";", "}", "if", "(", "TARGET_RMW", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_ISA_RMW__\"", ")", ";", "cpp_define_formatted", "(", "pfile", ",", "\"__AVR_SFR_OFFSET__=0x%x\"", ",", "avr_arch", "->", "sfr_offset", ")", ";", "cpp_define", "(", "pfile", ",", "\"__WITH_AVRLIBC__\"", ")", ";", "if", "(", "lang_GNU_C", "(", ")", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "ADDR_SPACE_COUNT", ";", "i", "++", ")", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "i", ")", "&&", "avr_addr_space_supported_p", "(", "(", "addr_space_t", ")", "i", ")", ")", "{", "const", "char", "*", "name", "=", "avr_addrspace", "[", "i", "]", ".", "name", ";", "char", "*", "Name", "=", "(", "char", "*", ")", "alloca", "(", "1", "+", "strlen", "(", "name", ")", ")", ";", "cpp_define", "(", "pfile", ",", "avr_toupper", "(", "Name", ",", "name", ")", ")", ";", "}", "}", "cpp_define", "(", "pfile", ",", "\"__BUILTIN_AVR_\"", "#", "NAME", ")", ";", "cpp_define_formatted", "(", "pfile", ",", "\"__INT24_MAX__=8388607%s\"", ",", "INT_TYPE_SIZE", "==", "8", "?", "\"LL\"", ":", "\"L\"", ")", ";", "cpp_define", "(", "pfile", ",", "\"__INT24_MIN__=(-__INT24_MAX__-1)\"", ")", ";", "cpp_define_formatted", "(", "pfile", ",", "\"__UINT24_MAX__=16777215%s\"", ",", "INT_TYPE_SIZE", "==", "8", "?", "\"ULL\"", ":", "\"UL\"", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_CPU_CPP_BUILTINS", "." ]

[ "avr", "\"AVR\"", "\"__AVR_ARCH__=%s\"", "\"__AVR_HAVE_RAMPD__\"", "\"__AVR_HAVE_RAMPX__\"", "\"__AVR_HAVE_RAMPY__\"", "\"__AVR_HAVE_RAMPZ__\"", "\"__AVR_HAVE_ELPM__\"", "\"__AVR_HAVE_ELPMX__\"", "\"__AVR_HAVE_MOVW__\"", "\"__AVR_HAVE_LPMX__\"", "\"__AVR_ASM_ONLY__\"", "\"__AVR_ENHANCED__\"", "\"__AVR_HAVE_MUL__\"", "\"__AVR_HAVE_JMP_CALL__\"", "\"__AVR_MEGA__\"", "\"__AVR_SHORT_CALLS__\"", "\"__AVR_XMEGA__\"", "\"__AVR_TINY__\"", "\"__AVR_TINY_PM_BASE_ADDRESS__=0x%x\"", "\"__AVR_PM_BASE_ADDRESS__=0x%x\"", "\"__AVR_HAVE_EIJMP_EICALL__\"", "\"__AVR_3_BYTE_PC__\"", "\"__AVR_2_BYTE_PC__\"", "\"__AVR_HAVE_8BIT_SP__\"", "\"__AVR_HAVE_16BIT_SP__\"", "\"__AVR_HAVE_SPH__\"", "\"__AVR_SP8__\"", "\"__NO_INTERRUPTS__\"", "\"__AVR_ERRATA_SKIP__\"", "\"__AVR_ERRATA_SKIP_JMP_CALL__\"", "\"__AVR_ISA_RMW__\"", "\"__AVR_SFR_OFFSET__=0x%x\"", "\"__WITH_AVRLIBC__\"", "0", "1", "\"__BUILTIN_AVR_\"", "\"__INT24_MAX__=8388607%s\"", "8", "\"LL\"", "\"L\"", "\"__INT24_MIN__=(-__INT24_MAX__-1)\"", "\"__UINT24_MAX__=16777215%s\"", "8", "\"ULL\"", "\"UL\"" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "Op", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "llvm_unreachable", "(", "\"Custom lowering code for this\"", "\"instruction is not implemented yet!\"", ")", ";", "break", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "LowerSIGN_EXTEND_INREG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "return", "LowerEXTRACT_SUBVECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FrameIndex", ":", "return", "LowerFrameIndex", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UDIVREM", ":", "return", "LowerUDIVREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SDIVREM", ":", "return", "LowerSDIVREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FREM", ":", "return", "LowerFREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCEIL", ":", "return", "LowerFCEIL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FTRUNC", ":", "return", "LowerFTRUNC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRINT", ":", "return", "LowerFRINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FNEARBYINT", ":", "return", "LowerFNEARBYINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FROUND", ":", "return", "LowerFROUND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FFLOOR", ":", "return", "LowerFFLOOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerSINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerUINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_SINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "LowerFP_TO_UINT", "(", "Op", ",", "DAG", ")", ";", "}", "return", "Op", ";", "}", "</s>" ]

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

[ "R600", "\"Custom lowering code for this\"", "\"instruction is not implemented yet!\"", "ISD::SIGN_EXTEND_INREG", "SI", "ISD::CONCAT_VECTORS", "ISD::EXTRACT_SUBVECTOR", "ISD::FrameIndex", "ISD::INTRINSIC_WO_CHAIN", "SI", "ISD::UDIVREM", "ISD::SDIVREM", "ISD::FREM", "ISD::FCEIL", "ISD::FTRUNC", "ISD::FRINT", "ISD::FNEARBYINT", "ISD::FROUND", "ISD::FFLOOR", "ISD::SINT_TO_FP", "SI", "ISD::UINT_TO_FP", "ISD::FP_TO_SINT", "SI", "ISD::FP_TO_UINT" ]

[]

[ "<s>", "void", "rs6000_emit_cbranch", "(", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "rtx", "condition_rtx", ",", "loc_ref", ";", "condition_rtx", "=", "rs6000_generate_compare", "(", "operands", "[", "0", "]", ",", "mode", ")", ";", "loc_ref", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "operands", "[", "3", "]", ")", ";", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "condition_rtx", ",", "loc_ref", ",", "pc_rtx", ")", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "branch", "of", "kind", "CODE", "to", "location", "LOC", "." ]

[ "rs6000", "0", "3" ]

[]

[ "<s>", "void", "MipsTargetELFStreamer", "::", "finish", "(", ")", "{", "MCAssembler", "&", "MCA", "=", "getStreamer", "(", ")", ".", "getAssembler", "(", ")", ";", "const", "MCObjectFileInfo", "&", "OFI", "=", "*", "MCA", ".", "getContext", "(", ")", ".", "getObjectFileInfo", "(", ")", ";", "MCSection", "&", "TextSection", "=", "*", "OFI", ".", "getTextSection", "(", ")", ";", "MCA", ".", "registerSection", "(", "TextSection", ")", ";", "MCSection", "&", "DataSection", "=", "*", "OFI", ".", "getDataSection", "(", ")", ";", "MCA", ".", "registerSection", "(", "DataSection", ")", ";", "MCSection", "&", "BSSSection", "=", "*", "OFI", ".", "getBSSSection", "(", ")", ";", "MCA", ".", "registerSection", "(", "BSSSection", ")", ";", "TextSection", ".", "setAlignment", "(", "std", "::", "max", "(", "16u", ",", "TextSection", ".", "getAlignment", "(", ")", ")", ")", ";", "DataSection", ".", "setAlignment", "(", "std", "::", "max", "(", "16u", ",", "DataSection", ".", "getAlignment", "(", ")", ")", ")", ";", "BSSSection", ".", "setAlignment", "(", "std", "::", "max", "(", "16u", ",", "BSSSection", ".", "getAlignment", "(", ")", ")", ")", ";", "const", "FeatureBitset", "&", "Features", "=", "STI", ".", "getFeatureBits", "(", ")", ";", "unsigned", "EFlags", "=", "MCA", ".", "getELFHeaderEFlags", "(", ")", ";", "if", "(", "getABI", "(", ")", ".", "IsO32", "(", ")", ")", "EFlags", "|=", "ELF", "::", "EF_MIPS_ABI_O32", ";", "else", "if", "(", "getABI", "(", ")", ".", "IsN32", "(", ")", ")", "EFlags", "|=", "ELF", "::", "EF_MIPS_ABI2", ";", "if", "(", "Features", "[", "Mips", "::", "FeatureGP64Bit", "]", ")", "{", "if", "(", "getABI", "(", ")", ".", "IsO32", "(", ")", ")", "EFlags", "|=", "ELF", "::", "EF_MIPS_32BITMODE", ";", "}", "else", "if", "(", "Features", "[", "Mips", "::", "FeatureMips64r2", "]", "||", "Features", "[", "Mips", "::", "FeatureMips64", "]", ")", "EFlags", "|=", "ELF", "::", "EF_MIPS_32BITMODE", ";", "if", "(", "EFlags", "&", "ELF", "::", "EF_MIPS_CPIC", "&&", "getABI", "(", ")", ".", "IsN64", "(", ")", ")", "EFlags", "|=", "ELF", "::", "EF_MIPS_PIC", ";", "MCA", ".", "setELFHeaderEFlags", "(", "EFlags", ")", ";", "MipsELFStreamer", "&", "MEF", "=", "static_cast", "<", "MipsELFStreamer", "&", ">", "(", "Streamer", ")", ";", "MEF", ".", "EmitMipsOptionRecords", "(", ")", ";", "emitMipsAbiFlags", "(", ")", ";", "}", "</s>" ]

[ "finish", "-", "after", "all", "the", "new", "live", "ranges", "have", "been", "created", ",", "compute", "the", "remaining", "live", "range", ",", "and", "rewrite", "instructions", "to", "use", "the", "new", "registers", "." ]

[ "Mips", "Mips", "16u", "16u", "16u", "Mips::FeatureGP64Bit", "Mips::FeatureMips64r2", "Mips::FeatureMips64", "Mips", "Mips", "Mips", "Mips" ]

[]

[ "<s>", "unsigned", "ARMAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "Kind", ")", "{", "ARMOperand", "&", "Op", "=", "static_cast", "<", "ARMOperand", "&", ">", "(", "AsmOp", ")", ";", "switch", "(", "Kind", ")", "{", "default", ":", "break", ";", "case", "MCK__HASH_0", ":", "if", "(", "Op", ".", "isImm", "(", ")", ")", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getImm", "(", ")", ")", ")", "if", "(", "CE", "->", "getValue", "(", ")", "==", "0", ")", "return", "Match_Success", ";", "break", ";", "case", "MCK__HASH_8", ":", "if", "(", "Op", ".", "isImm", "(", ")", ")", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getImm", "(", ")", ")", ")", "if", "(", "CE", "->", "getValue", "(", ")", "==", "8", ")", "return", "Match_Success", ";", "break", ";", "case", "MCK__HASH_16", ":", "if", "(", "Op", ".", "isImm", "(", ")", ")", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getImm", "(", ")", ")", ")", "if", "(", "CE", "->", "getValue", "(", ")", "==", "16", ")", "return", "Match_Success", ";", "break", ";", "case", "MCK_ModImm", ":", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "const", "MCExpr", "*", "SOExpr", "=", "Op", ".", "getImm", "(", ")", ";", "int64_t", "Value", ";", "if", "(", "!", "SOExpr", "->", "evaluateAsAbsolute", "(", "Value", ")", ")", "return", "Match_Success", ";", "assert", "(", "(", "Value", ">=", "std", "::", "numeric_limits", "<", "int32_t", ">", "::", "min", "(", ")", "&&", "Value", "<=", "std", "::", "numeric_limits", "<", "uint32_t", ">", "::", "max", "(", ")", ")", "&&", "\"expression value must be representable in 32 bits\"", ")", ";", "}", "break", ";", "case", "MCK_rGPR", ":", "if", "(", "hasV8Ops", "(", ")", "&&", "Op", ".", "isReg", "(", ")", "&&", "Op", ".", "getReg", "(", ")", "==", "ARM", "::", "SP", ")", "return", "Match_Success", ";", "return", "Match_rGPR", ";", "case", "MCK_GPRPair", ":", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "MRI", "->", "getRegClass", "(", "ARM", "::", "GPRRegClassID", ")", ".", "contains", "(", "Op", ".", "getReg", "(", ")", ")", ")", "return", "Match_Success", ";", "break", ";", "}", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

[ "ARM", "ARM", "ARM", "ARM", "0", "8", "16", "\"expression value must be representable in 32 bits\"", "ARM::SP", "ARM::GPRRegClassID" ]

[]

[ "<s>", "void", "WebAssemblyAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"EmitInstruction: \"", "<<", "*", "MI", "<<", "'\\n'", ")", ";", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "unsigned", "NumDefs", "=", "MI", "->", "getDesc", "(", ")", ".", "getNumDefs", "(", ")", ";", "assert", "(", "NumDefs", "<=", "1", "&&", "\"Instructions with multiple result values not implemented\"", ")", ";", "OS", "<<", "'\\t'", ";", "if", "(", "NumDefs", "!=", "0", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "0", ")", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "OS", "<<", "\"(setlocal @\"", "<<", "TargetRegisterInfo", "::", "virtReg2Index", "(", "Reg", ")", "<<", "' '", ";", "}", "OS", "<<", "'('", "<<", "OpcodeName", "(", "TII", ",", "MI", ")", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "uses", "(", ")", ")", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unexpected machine operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "{", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "OS", "<<", "\" @\"", "<<", "TargetRegisterInfo", "::", "virtReg2Index", "(", "Reg", ")", ";", "}", "break", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "{", "OS", "<<", "' '", "<<", "MO", ".", "getImm", "(", ")", ";", "}", "break", ";", "case", "MachineOperand", "::", "MO_FPImmediate", ":", "{", "OS", "<<", "' '", "<<", "toString", "(", "MO", ".", "getFPImm", "(", ")", "->", "getValueAPF", "(", ")", ")", ";", "}", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "{", "OS", "<<", "' '", "<<", "toSymbol", "(", "MO", ".", "getGlobal", "(", ")", "->", "getName", "(", ")", ")", ";", "}", "break", ";", "}", "OS", "<<", "')'", ";", "if", "(", "NumDefs", "!=", "0", ")", "OS", "<<", "')'", ";", "OS", "<<", "'\\n'", ";", "OutStreamer", "->", "EmitRawText", "(", "OS", ".", "str", "(", ")", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"EmitInstruction: \"", "128", "1", "\"Instructions with multiple result values not implemented\"", "0", "0", "\"(setlocal @\"", "\"unexpected machine operand type\"", "\" @\"", "0" ]

[]

[ "<s>", "bool", "MVEGatherScatterLowering", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "EnableMaskedGatherScatters", ")", "return", "false", ";", "auto", "&", "TPC", "=", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "auto", "&", "TM", "=", "TPC", ".", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "auto", "*", "ST", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ";", "if", "(", "!", "ST", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "SmallVector", "<", "IntrinsicInst", "*", ",", "4", ">", "Gathers", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "for", "(", "Instruction", "&", "I", ":", "BB", ")", "{", "IntrinsicInst", "*", "II", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "&", "I", ")", ";", "if", "(", "II", "&&", "II", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "masked_gather", ")", "Gathers", ".", "push_back", "(", "II", ")", ";", "}", "}", "if", "(", "Gathers", ".", "empty", "(", ")", ")", "return", "false", ";", "for", "(", "IntrinsicInst", "*", "I", ":", "Gathers", ")", "lowerGather", "(", "I", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "4", "Intrinsic::masked_gather" ]

[]

[ "<s>", "bool", "NVPTXPrologEpilogPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetSubtargetInfo", "&", "STI", "=", "MF", ".", "getSubtarget", "(", ")", ";", "const", "TargetFrameLowering", "&", "TFI", "=", "*", "STI", ".", "getFrameLowering", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "calculateFrameObjectOffsets", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "E", ";", "++", "BB", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "BB", "->", "begin", "(", ")", ";", "I", "!=", "BB", "->", "end", "(", ")", ";", "++", "I", ")", "{", "MachineInstr", "*", "MI", "=", "I", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "!", "MI", "->", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "continue", ";", "TRI", ".", "eliminateFrameIndex", "(", "MI", ",", "0", ",", "i", ",", "nullptr", ")", ";", "Modified", "=", "true", ";", "}", "}", "}", "TFI", ".", "emitPrologue", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "!", "I", "->", "empty", "(", ")", "&&", "I", "->", "back", "(", ")", ".", "isReturn", "(", ")", ")", "TFI", ".", "emitEpilogue", "(", "MF", ",", "*", "I", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "rtx", "xstormy16_function_value", "(", "const_tree", "valtype", ",", "const_tree", "func", "ATTRIBUTE_UNUSED", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "machine_mode", "mode", ";", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "PROMOTE_MODE", "(", "mode", ",", "0", ",", "valtype", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "RETURN_VALUE_REGNUM", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "FUNCTION_VALUE", "." ]

[ "stormy16", "0" ]

[]

[ "<s>", "bool", "isFMAFasterThanFMulAndFAdd", "(", "EVT", "VT", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "FMA", "operation", "is", "faster", "than", "a", "pair", "of", "fmul", "and", "fadd", "instructions", "." ]

[ "ARM" ]

[]

[ "<s>", "unsigned", "PPCMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "assert", "(", "(", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "MTOCRF", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "MTOCRF8", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "MFOCRF", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "MFOCRF8", ")", "||", "MO", ".", "getReg", "(", ")", "<", "PPC", "::", "CR0", "||", "MO", ".", "getReg", "(", ")", ">", "PPC", "::", "CR7", ")", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "unsigned", "Encode", "=", "CTX", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "Reg", ")", ";", "if", "(", "(", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ".", "TSFlags", "&", "PPCII", "::", "UseVSXReg", ")", ")", "if", "(", "PPCInstrInfo", "::", "isVRRegister", "(", "Reg", ")", ")", "Encode", "+=", "32", ";", "return", "Encode", ";", "}", "assert", "(", "MO", ".", "isImm", "(", ")", "&&", "\"Relocation required in an instruction that we cannot encode!\"", ")", ";", "return", "MO", ".", "getImm", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::MTOCRF", "PPC::MTOCRF8", "PPC::MFOCRF", "PPC::MFOCRF8", "PPC::CR0", "PPC::CR7", "PPCII::UseVSXReg", "PPC", "32", "\"Relocation required in an instruction that we cannot encode!\"" ]

[]

[ "<s>", "yaml", "::", "MachineFunctionInfo", "*", "AArch64TargetMachine", "::", "convertFuncInfoToYAML", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "auto", "*", "MFI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "return", "new", "yaml", "::", "AArch64FunctionInfo", "(", "*", "MFI", ")", ";", "}", "</s>" ]

[ "Allocate", "and", "initialize", "an", "instance", "of", "the", "YAML", "representation", "of", "the", "MachineFunctionInfo", "." ]

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

[]

[ "<s>", "static", "ARMOperand", "*", "CreateMem", "(", "unsigned", "BaseRegNum", ",", "const", "MCConstantExpr", "*", "OffsetImm", ",", "unsigned", "OffsetRegNum", ",", "ARM_AM", "::", "ShiftOpc", "ShiftType", ",", "unsigned", "ShiftImm", ",", "unsigned", "Alignment", ",", "bool", "isNegative", ",", "SMLoc", "S", ",", "SMLoc", "E", ",", "SMLoc", "AlignmentLoc", "=", "SMLoc", "(", ")", ")", "{", "ARMOperand", "*", "Op", "=", "new", "ARMOperand", "(", "k_Memory", ")", ";", "Op", "->", "Memory", ".", "BaseRegNum", "=", "BaseRegNum", ";", "Op", "->", "Memory", ".", "OffsetImm", "=", "OffsetImm", ";", "Op", "->", "Memory", ".", "OffsetRegNum", "=", "OffsetRegNum", ";", "Op", "->", "Memory", ".", "ShiftType", "=", "ShiftType", ";", "Op", "->", "Memory", ".", "ShiftImm", "=", "ShiftImm", ";", "Op", "->", "Memory", ".", "Alignment", "=", "Alignment", ";", "Op", "->", "Memory", ".", "isNegative", "=", "isNegative", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "Op", "->", "AlignmentLoc", "=", "AlignmentLoc", ";", "return", "Op", ";", "}", "</s>" ]

[ "Create", "a", "generalized", "memory", "operand", "." ]

[ "ARM", "ARM", "ARM_AM::ShiftOpc", "ARM", "ARM" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "SPUTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'b'", ":", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "SPU", "::", "R64CRegisterClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "SPU", "::", "R32CRegisterClass", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "SPU", "::", "R32FPRegisterClass", ")", ";", "else", "if", "(", "VT", "==", "MVT", "::", "f64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "SPU", "::", "R64FPRegisterClass", ")", ";", "break", ";", "case", "'v'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "SPU", "::", "GPRCRegisterClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "1", "0", "MVT::i64", "0U", "SPU::R64CRegisterClass", "0U", "SPU::R32CRegisterClass", "MVT::f32", "0U", "SPU::R32FPRegisterClass", "MVT::f64", "0U", "SPU::R64FPRegisterClass", "0U", "SPU::GPRCRegisterClass" ]

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "ReplaceTailWithBranchTo", "(", "MachineBasicBlock", "::", "iterator", "Tail", ",", "MachineBasicBlock", "*", "NewDest", ")", "const", "{", "MachineBasicBlock", "*", "MBB", "=", "Tail", "->", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MBB", "->", "getParent", "(", ")", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "AFI", "->", "hasITBlocks", "(", ")", ")", "{", "TargetInstrInfoImpl", "::", "ReplaceTailWithBranchTo", "(", "Tail", ",", "NewDest", ")", ";", "return", ";", "}", "unsigned", "PredReg", "=", "0", ";", "ARMCC", "::", "CondCodes", "CC", "=", "getInstrPredicate", "(", "Tail", ",", "PredReg", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "Tail", ";", "if", "(", "CC", "!=", "ARMCC", "::", "AL", ")", "--", "MBBI", ";", "TargetInstrInfoImpl", "::", "ReplaceTailWithBranchTo", "(", "Tail", ",", "NewDest", ")", ";", "if", "(", "CC", "!=", "ARMCC", "::", "AL", ")", "{", "MachineBasicBlock", "::", "iterator", "E", "=", "MBB", "->", "begin", "(", ")", ";", "unsigned", "Count", "=", "4", ";", "while", "(", "Count", "&&", "MBBI", "!=", "E", ")", "{", "if", "(", "MBBI", "->", "isDebugValue", "(", ")", ")", "{", "--", "MBBI", ";", "continue", ";", "}", "if", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2IT", ")", "{", "unsigned", "Mask", "=", "MBBI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "Count", "==", "4", ")", "MBBI", "->", "eraseFromParent", "(", ")", ";", "else", "{", "unsigned", "MaskOn", "=", "1", "<<", "Count", ";", "unsigned", "MaskOff", "=", "~", "(", "MaskOn", "-", "1", ")", ";", "MBBI", "->", "getOperand", "(", "1", ")", ".", "setImm", "(", "(", "Mask", "&", "MaskOff", ")", "|", "MaskOn", ")", ";", "}", "return", ";", "}", "--", "MBBI", ";", "--", "Count", ";", "}", "}", "}", "</s>" ]

[ "Delete", "the", "instruction", "OldInst", "and", "everything", "after", "it", ",", "replacing", "it", "with", "an", "unconditional", "branch", "to", "NewDest", "." ]

[ "ARM", "ARM", "ARM", "0", "ARMCC::CondCodes", "ARMCC::AL", "ARMCC::AL", "4", "ARM::t2IT", "1", "4", "1", "1", "1" ]

[]

[ "<s>", "static", "unsigned", "long", "arm_compute_save_reg0_reg12_mask", "(", "void", ")", "{", "unsigned", "long", "func_type", "=", "arm_current_func_type", "(", ")", ";", "unsigned", "long", "save_reg_mask", "=", "0", ";", "unsigned", "int", "reg", ";", "if", "(", "IS_INTERRUPT", "(", "func_type", ")", ")", "{", "unsigned", "int", "max_reg", ";", "if", "(", "ARM_FUNC_TYPE", "(", "func_type", ")", "==", "ARM_FT_FIQ", ")", "max_reg", "=", "7", ";", "else", "max_reg", "=", "12", ";", "for", "(", "reg", "=", "0", ";", "reg", "<=", "max_reg", ";", "reg", "++", ")", "if", "(", "reg_needs_saving_p", "(", "reg", ")", ")", "save_reg_mask", "|=", "(", "1", "<<", "reg", ")", ";", "if", "(", "PIC_REGISTER_MAY_NEED_SAVING", "&&", "crtl", "->", "uses_pic_offset_table", ")", "save_reg_mask", "|=", "1", "<<", "PIC_OFFSET_TABLE_REGNUM", ";", "}", "else", "if", "(", "IS_VOLATILE", "(", "func_type", ")", ")", "{", "if", "(", "frame_pointer_needed", ")", "save_reg_mask", "|=", "1", "<<", "HARD_FRAME_POINTER_REGNUM", ";", "if", "(", "df_regs_ever_live_p", "(", "ARM_HARD_FRAME_POINTER_REGNUM", ")", ")", "save_reg_mask", "|=", "1", "<<", "ARM_HARD_FRAME_POINTER_REGNUM", ";", "if", "(", "df_regs_ever_live_p", "(", "THUMB_HARD_FRAME_POINTER_REGNUM", ")", ")", "save_reg_mask", "|=", "1", "<<", "THUMB_HARD_FRAME_POINTER_REGNUM", ";", "}", "else", "{", "for", "(", "reg", "=", "0", ";", "reg", "<=", "11", ";", "reg", "++", ")", "if", "(", "df_regs_ever_live_p", "(", "reg", ")", "&&", "callee_saved_reg_p", "(", "reg", ")", ")", "save_reg_mask", "|=", "(", "1", "<<", "reg", ")", ";", "if", "(", "frame_pointer_needed", ")", "save_reg_mask", "|=", "1", "<<", "HARD_FRAME_POINTER_REGNUM", ";", "if", "(", "PIC_REGISTER_MAY_NEED_SAVING", "&&", "(", "df_regs_ever_live_p", "(", "PIC_OFFSET_TABLE_REGNUM", ")", "||", "crtl", "->", "uses_pic_offset_table", ")", ")", "save_reg_mask", "|=", "1", "<<", "PIC_OFFSET_TABLE_REGNUM", ";", "if", "(", "IS_STACKALIGN", "(", "func_type", ")", ")", "save_reg_mask", "|=", "1", ";", "}", "if", "(", "crtl", "->", "calls_eh_return", ")", "{", "unsigned", "int", "i", ";", "for", "(", "i", "=", "0", ";", ";", "i", "++", ")", "{", "reg", "=", "EH_RETURN_DATA_REGNO", "(", "i", ")", ";", "if", "(", "reg", "==", "INVALID_REGNUM", ")", "break", ";", "save_reg_mask", "|=", "1", "<<", "reg", ";", "}", "}", "return", "save_reg_mask", ";", "}", "</s>" ]

[ "Compute", "the", "register", "save", "mask", "for", "registers", "0", "through", "12", "inclusive", ".", "This", "code", "is", "used", "by", "arm_compute_save_reg_mask", "." ]

[ "arm", "0", "7", "12", "0", "1", "1", "1", "1", "1", "0", "11", "1", "1", "1", "1", "0", "1" ]

[]

[ "<s>", "bool", "SIFoldOperands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "const", "SIRegisterInfo", "&", "TRI", "=", "TII", "->", "getRegisterInfo", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "MachineBasicBlock", "::", "iterator", "I", ",", "Next", ";", "for", "(", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "if", "(", "!", "isSafeToFold", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "continue", ";", "unsigned", "OpSize", "=", "TII", "->", "getOpSize", "(", "MI", ",", "1", ")", ";", "MachineOperand", "&", "OpToFold", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "bool", "FoldingImm", "=", "OpToFold", ".", "isImm", "(", ")", ";", "if", "(", "!", "FoldingImm", "&&", "!", "OpToFold", ".", "isReg", "(", ")", ")", "continue", ";", "if", "(", "FoldingImm", "&&", "!", "TII", "->", "isInlineConstant", "(", "OpToFold", ",", "OpSize", ")", "&&", "!", "MRI", ".", "hasOneUse", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", "continue", ";", "if", "(", "OpToFold", ".", "isReg", "(", ")", "&&", "(", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "OpToFold", ".", "getReg", "(", ")", ")", "||", "OpToFold", ".", "getSubReg", "(", ")", ")", ")", "continue", ";", "SmallVector", "<", "MachineInstr", "*", ",", "4", ">", "CopiesToReplace", ";", "std", "::", "vector", "<", "FoldCandidate", ">", "FoldList", ";", "for", "(", "MachineRegisterInfo", "::", "use_iterator", "Use", "=", "MRI", ".", "use_begin", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ",", "E", "=", "MRI", ".", "use_end", "(", ")", ";", "Use", "!=", "E", ";", "++", "Use", ")", "{", "MachineInstr", "*", "UseMI", "=", "Use", "->", "getParent", "(", ")", ";", "foldOperand", "(", "OpToFold", ",", "UseMI", ",", "Use", ".", "getOperandNo", "(", ")", ",", "FoldList", ",", "CopiesToReplace", ",", "TII", ",", "TRI", ",", "MRI", ")", ";", "}", "for", "(", "MachineInstr", "*", "Copy", ":", "CopiesToReplace", ")", "Copy", "->", "addImplicitDefUseOperands", "(", "MF", ")", ";", "for", "(", "FoldCandidate", "&", "Fold", ":", "FoldList", ")", "{", "if", "(", "updateOperand", "(", "Fold", ",", "TRI", ")", ")", "{", "if", "(", "!", "Fold", ".", "isImm", "(", ")", ")", "{", "assert", "(", "Fold", ".", "OpToFold", "&&", "Fold", ".", "OpToFold", "->", "isReg", "(", ")", ")", ";", "MRI", ".", "clearKillFlags", "(", "Fold", ".", "OpToFold", "->", "getReg", "(", ")", ")", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Folded source from \"", "<<", "MI", "<<", "\" into OpNo \"", "<<", "Fold", ".", "UseOpNo", "<<", "\" of \"", "<<", "*", "Fold", ".", "UseMI", "<<", "'\\n'", ")", ";", "}", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "SI", "1", "1", "0", "4", "0", "\"Folded source from \"", "\" into OpNo \"", "\" of \"" ]

[]

[ "<s>", "bool", "X86TargetMachine", "::", "addInstSelector", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "PM", ".", "add", "(", "createX86ISelDag", "(", "*", "this", ",", "OptLevel", ")", ")", ";", "if", "(", "EnableFastISel", ")", "PM", ".", "add", "(", "createDeadMachineInstructionElimPass", "(", ")", ")", ";", "PM", ".", "add", "(", "createX87FPRegKillInserterPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "const", "char", "*", "avr_out_store_psi", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "op", "[", "0", "]", ";", "rtx", "src", "=", "op", "[", "1", "]", ";", "rtx", "base", "=", "XEXP", "(", "dest", ",", "0", ")", ";", "int", "reg_base", "=", "true_regnum", "(", "base", ")", ";", "if", "(", "CONSTANT_ADDRESS_P", "(", "base", ")", ")", "{", "int", "n_words", "=", "AVR_TINY", "?", "3", ":", "6", ";", "return", "avr_asm_len", "(", "\"sts %m0,%A1\"", "CR_TAB", "\"sts %m0+1,%B1\"", "CR_TAB", "\"sts %m0+2,%C1\"", ",", "op", ",", "plen", ",", "-", "n_words", ")", ";", "}", "if", "(", "reg_base", ">", "0", ")", "{", "if", "(", "AVR_TINY", ")", "return", "avr_out_store_psi_reg_no_disp_tiny", "(", "insn", ",", "op", ",", "plen", ")", ";", "if", "(", "reg_base", "==", "REG_X", ")", "{", "gcc_assert", "(", "!", "reg_overlap_mentioned_p", "(", "base", ",", "src", ")", ")", ";", "avr_asm_len", "(", "\"st %0+,%A1\"", "CR_TAB", "\"st %0+,%B1\"", "CR_TAB", "\"st %0,%C1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "if", "(", "!", "reg_unused_after", "(", "insn", ",", "base", ")", ")", "avr_asm_len", "(", "\"sbiw r26,2\"", ",", "op", ",", "plen", ",", "1", ")", ";", "return", "\"\"", ";", "}", "else", "return", "avr_asm_len", "(", "\"st %0,%A1\"", "CR_TAB", "\"std %0+1,%B1\"", "CR_TAB", "\"std %0+2,%C1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "{", "int", "disp", "=", "INTVAL", "(", "XEXP", "(", "base", ",", "1", ")", ")", ";", "if", "(", "AVR_TINY", ")", "return", "avr_out_store_psi_reg_disp_tiny", "(", "insn", ",", "op", ",", "plen", ")", ";", "reg_base", "=", "REGNO", "(", "XEXP", "(", "base", ",", "0", ")", ")", ";", "if", "(", "disp", ">", "MAX_LD_OFFSET", "(", "GET_MODE", "(", "dest", ")", ")", ")", "{", "if", "(", "reg_base", "!=", "REG_Y", ")", "fatal_insn", "(", "\"incorrect insn:\"", ",", "insn", ")", ";", "if", "(", "disp", "<=", "63", "+", "MAX_LD_OFFSET", "(", "GET_MODE", "(", "dest", ")", ")", ")", "return", "avr_asm_len", "(", "\"adiw r28,%o0-61\"", "CR_TAB", "\"std Y+61,%A1\"", "CR_TAB", "\"std Y+62,%B1\"", "CR_TAB", "\"std Y+63,%C1\"", "CR_TAB", "\"sbiw r28,%o0-61\"", ",", "op", ",", "plen", ",", "-", "5", ")", ";", "return", "avr_asm_len", "(", "\"subi r28,lo8(-%o0)\"", "CR_TAB", "\"sbci r29,hi8(-%o0)\"", "CR_TAB", "\"st Y,%A1\"", "CR_TAB", "\"std Y+1,%B1\"", "CR_TAB", "\"std Y+2,%C1\"", "CR_TAB", "\"subi r28,lo8(%o0)\"", "CR_TAB", "\"sbci r29,hi8(%o0)\"", ",", "op", ",", "plen", ",", "-", "7", ")", ";", "}", "if", "(", "reg_base", "==", "REG_X", ")", "{", "gcc_assert", "(", "!", "reg_overlap_mentioned_p", "(", "XEXP", "(", "base", ",", "0", ")", ",", "src", ")", ")", ";", "avr_asm_len", "(", "\"adiw r26,%o0\"", "CR_TAB", "\"st X+,%A1\"", "CR_TAB", "\"st X+,%B1\"", "CR_TAB", "\"st X,%C1\"", ",", "op", ",", "plen", ",", "-", "4", ")", ";", "if", "(", "!", "reg_unused_after", "(", "insn", ",", "XEXP", "(", "base", ",", "0", ")", ")", ")", "avr_asm_len", "(", "\"sbiw r26,%o0+2\"", ",", "op", ",", "plen", ",", "1", ")", ";", "return", "\"\"", ";", "}", "return", "avr_asm_len", "(", "\"std %A0,%A1\"", "CR_TAB", "\"std %B0,%B1\"", "CR_TAB", "\"std %C0,%C1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "base", ")", "==", "PRE_DEC", ")", "return", "avr_asm_len", "(", "\"st %0,%C1\"", "CR_TAB", "\"st %0,%B1\"", "CR_TAB", "\"st %0,%A1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "else", "if", "(", "GET_CODE", "(", "base", ")", "==", "POST_INC", ")", "return", "avr_asm_len", "(", "\"st %0,%A1\"", "CR_TAB", "\"st %0,%B1\"", "CR_TAB", "\"st %0,%C1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "fatal_insn", "(", "\"unknown move insn:\"", ",", "insn", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Handle", "store", "of", "24-bit", "type", "from", "register", "or", "zero", "to", "memory", "." ]

[ "avr", "0", "1", "0", "3", "6", "\"sts %m0,%A1\"", "\"sts %m0+1,%B1\"", "\"sts %m0+2,%C1\"", "0", "\"st %0+,%A1\"", "\"st %0+,%B1\"", "\"st %0,%C1\"", "3", "\"sbiw r26,2\"", "1", "\"\"", "\"st %0,%A1\"", "\"std %0+1,%B1\"", "\"std %0+2,%C1\"", "3", "1", "0", "\"incorrect insn:\"", "63", "\"adiw r28,%o0-61\"", "\"std Y+61,%A1\"", "\"std Y+62,%B1\"", "\"std Y+63,%C1\"", "\"sbiw r28,%o0-61\"", "5", "\"subi r28,lo8(-%o0)\"", "\"sbci r29,hi8(-%o0)\"", "\"st Y,%A1\"", "\"std Y+1,%B1\"", "\"std Y+2,%C1\"", "\"subi r28,lo8(%o0)\"", "\"sbci r29,hi8(%o0)\"", "7", "0", "\"adiw r26,%o0\"", "\"st X+,%A1\"", "\"st X+,%B1\"", "\"st X,%C1\"", "4", "0", "\"sbiw r26,%o0+2\"", "1", "\"\"", "\"std %A0,%A1\"", "\"std %B0,%B1\"", "\"std %C0,%C1\"", "3", "\"st %0,%C1\"", "\"st %0,%B1\"", "\"st %0,%A1\"", "3", "\"st %0,%A1\"", "\"st %0,%B1\"", "\"st %0,%C1\"", "3", "\"unknown move insn:\"", "\"\"" ]

[]

[ "<s>", "std", "::", "string", "getNodeLabel", "(", "const", "SCANode", "*", "N", ",", "const", "SpillCostAnalysisGraph", "&", "G", ")", "{", "MCGNode", "*", "mcgNode", "=", "N", "->", "getMCGNode", "(", ")", ";", "std", "::", "string", "tmp", ";", "raw_string_ostream", "s", "(", "tmp", ")", ";", "if", "(", "mcgNode", "->", "isUnknown", "(", ")", ")", "s", "<<", "\"<UNKNOWN-\"", "<<", "*", "mcgNode", "->", "getType", "(", ")", "<<", "\">\"", ";", "else", "{", "s", "<<", "mcgNode", "->", "getMF", "(", ")", "->", "getFunction", "(", ")", "->", "getName", "(", ")", ";", "}", "s", "<<", "(", "N", "->", "hasCallFreePath", "(", ")", "?", "\"* (occ:\"", ":", "\" (occ:\"", ")", "<<", "N", "->", "getOccupancy", "(", ")", "<<", "\", spill:\"", "<<", "N", "->", "getSpillCost", "(", ")", "<<", "\")\\n\"", "<<", "\"[rem:\"", "<<", "N", "->", "getRemainingOccupancy", "(", ")", "<<", "\", maxdisp:\"", "<<", "N", "->", "getMaxDisplacement", "(", ")", "<<", "\"]\"", ";", "return", "s", ".", "str", "(", ")", ";", "}", "</s>" ]

[ "Print", "a", "DDG", "node", "either", "in", "concise", "form", "(", "-ddg-dot-only", ")", "or", "verbose", "mode", "(", "-ddg-dot", ")", "." ]

[ "Patmos", "\"<UNKNOWN-\"", "\">\"", "\"* (occ:\"", "\" (occ:\"", "\", spill:\"", "\")\\n\"", "\"[rem:\"", "\", maxdisp:\"", "\"]\"" ]

[]

[ "<s>", "void", "MipsMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "MCInst", "TmpInst", "=", "MI", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "Mips", "::", "DSLL", ":", "case", "Mips", "::", "DSRL", ":", "case", "Mips", "::", "DSRA", ":", "case", "Mips", "::", "DROTR", ":", "LowerLargeShift", "(", "TmpInst", ")", ";", "break", ";", "case", "Mips", "::", "DINS", ":", "LowerDins", "(", "TmpInst", ")", ";", "break", ";", "case", "Mips", "::", "BEQC", ":", "case", "Mips", "::", "BNEC", ":", "case", "Mips", "::", "BOVC", ":", "case", "Mips", "::", "BNVC", ":", "LowerCompactBranch", "(", "TmpInst", ")", ";", "}", "unsigned", "long", "N", "=", "Fixups", ".", "size", "(", ")", ";", "uint32_t", "Binary", "=", "getBinaryCodeForInstr", "(", "TmpInst", ",", "Fixups", ",", "STI", ")", ";", "unsigned", "Opcode", "=", "TmpInst", ".", "getOpcode", "(", ")", ";", "if", "(", "(", "Opcode", "!=", "Mips", "::", "NOP", ")", "&&", "(", "Opcode", "!=", "Mips", "::", "SLL", ")", "&&", "(", "Opcode", "!=", "Mips", "::", "SLL_MM", ")", "&&", "!", "Binary", ")", "llvm_unreachable", "(", "\"unimplemented opcode in encodeInstruction()\"", ")", ";", "int", "NewOpcode", "=", "-", "1", ";", "if", "(", "isMicroMips", "(", "STI", ")", ")", "{", "if", "(", "isMips32r6", "(", "STI", ")", ")", "{", "NewOpcode", "=", "Mips", "::", "MipsR62MicroMipsR6", "(", "Opcode", ",", "Mips", "::", "Arch_micromipsr6", ")", ";", "if", "(", "NewOpcode", "==", "-", "1", ")", "NewOpcode", "=", "Mips", "::", "Std2MicroMipsR6", "(", "Opcode", ",", "Mips", "::", "Arch_micromipsr6", ")", ";", "}", "else", "NewOpcode", "=", "Mips", "::", "Std2MicroMips", "(", "Opcode", ",", "Mips", "::", "Arch_micromips", ")", ";", "if", "(", "NewOpcode", "==", "-", "1", ")", "NewOpcode", "=", "Mips", "::", "Dsp2MicroMips", "(", "Opcode", ",", "Mips", "::", "Arch_mmdsp", ")", ";", "if", "(", "NewOpcode", "!=", "-", "1", ")", "{", "if", "(", "Fixups", ".", "size", "(", ")", ">", "N", ")", "Fixups", ".", "pop_back", "(", ")", ";", "Opcode", "=", "NewOpcode", ";", "TmpInst", ".", "setOpcode", "(", "NewOpcode", ")", ";", "Binary", "=", "getBinaryCodeForInstr", "(", "TmpInst", ",", "Fixups", ",", "STI", ")", ";", "}", "}", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "TmpInst", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "Size", "=", "Desc", ".", "getSize", "(", ")", ";", "if", "(", "!", "Size", ")", "llvm_unreachable", "(", "\"Desc.getSize() returns 0\"", ")", ";", "EmitInstruction", "(", "Binary", ",", "Size", ",", "STI", ",", "OS", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::DSLL", "Mips::DSRL", "Mips::DSRA", "Mips::DROTR", "Mips::DINS", "Mips::BEQC", "Mips::BNEC", "Mips::BOVC", "Mips::BNVC", "Mips::NOP", "Mips::SLL", "Mips::SLL_MM", "\"unimplemented opcode in encodeInstruction()\"", "1", "Mips", "Mips", "Mips::MipsR62MicroMipsR6", "Mips::Arch_micromipsr6", "1", "Mips::Std2MicroMipsR6", "Mips::Arch_micromipsr6", "Mips::Std2MicroMips", "Mips::Arch_micromips", "1", "Mips::Dsp2MicroMips", "Mips::Arch_mmdsp", "1", "\"Desc.getSize() returns 0\"" ]

[]

[ "<s>", "void", "X86TargetLowering", "::", "insertSSPDeclarations", "(", "Module", "&", "M", ")", "const", "{", "if", "(", "Subtarget", ".", "getTargetTriple", "(", ")", ".", "isWindowsMSVCEnvironment", "(", ")", "||", "Subtarget", ".", "getTargetTriple", "(", ")", ".", "isWindowsItaniumEnvironment", "(", ")", ")", "{", "M", ".", "getOrInsertGlobal", "(", "\"__security_cookie\"", ",", "Type", "::", "getInt8PtrTy", "(", "M", ".", "getContext", "(", ")", ")", ")", ";", "FunctionCallee", "SecurityCheckCookie", "=", "M", ".", "getOrInsertFunction", "(", "\"__security_check_cookie\"", ",", "Type", "::", "getVoidTy", "(", "M", ".", "getContext", "(", ")", ")", ",", "Type", "::", "getInt8PtrTy", "(", "M", ".", "getContext", "(", ")", ")", ")", ";", "if", "(", "Function", "*", "F", "=", "dyn_cast", "<", "Function", ">", "(", "SecurityCheckCookie", ".", "getCallee", "(", ")", ")", ")", "{", "F", "->", "setCallingConv", "(", "CallingConv", "::", "X86_FastCall", ")", ";", "F", "->", "addAttribute", "(", "1", ",", "Attribute", "::", "AttrKind", "::", "InReg", ")", ";", "}", "return", ";", "}", "StringRef", "GuardMode", "=", "M", ".", "getStackProtectorGuard", "(", ")", ";", "if", "(", "(", "GuardMode", "==", "\"tls\"", "||", "GuardMode", ".", "empty", "(", ")", ")", "&&", "hasStackGuardSlotTLS", "(", "Subtarget", ".", "getTargetTriple", "(", ")", ")", ")", "return", ";", "TargetLowering", "::", "insertSSPDeclarations", "(", "M", ")", ";", "}", "</s>" ]

[ "Inserts", "necessary", "declarations", "for", "SSP", "(", "stack", "protection", ")", "purpose", "." ]

[ "X86", "X86", "\"__security_cookie\"", "\"__security_check_cookie\"", "X86", "1", "\"tls\"" ]

[]

[ "<s>", "static", "void", "iq2000_emit_frame_related_store", "(", "rtx", "mem", ",", "rtx", "reg", ",", "HOST_WIDE_INT", "offset", ")", "{", "rtx", "dwarf_address", "=", "plus_constant", "(", "stack_pointer_rtx", ",", "offset", ")", ";", "rtx", "dwarf_mem", "=", "gen_rtx_MEM", "(", "GET_MODE", "(", "reg", ")", ",", "dwarf_address", ")", ";", "iq2000_annotate_frame_insn", "(", "emit_move_insn", "(", "mem", ",", "reg", ")", ",", "gen_rtx_SET", "(", "GET_MODE", "(", "reg", ")", ",", "dwarf_mem", ",", "reg", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "move", "instruction", "that", "stores", "REG", "in", "MEM", ".", "Make", "the", "instruction", "frame", "related", "and", "note", "that", "it", "stores", "REG", "at", "(", "SP", "+", "OFFSET", ")", "." ]

[ "iq2000" ]

[]

[ "<s>", "bool", "sh_cfun_attr_renesas_p", "(", "void", ")", "{", "return", "sh_attr_renesas_p", "(", "current_function_decl", ")", ";", "}", "</s>" ]

[ "True", "if", "__attribute__", "(", "(", "renesas", ")", ")", "or", "-mrenesas", ",", "for", "the", "current", "function", "." ]

[ "sh" ]

[]

[ "<s>", "const", "unsigned", "&", "getLoc", "(", ")", "const", "{", "return", "loc", ";", "}", "</s>" ]

[ "Get", "the", "source", "location", "of", "the", "point", "where", "the", "field", "was", "defined", "." ]

[ "Patmos" ]

[]

[ "<s>", "const", "MipsTargetLowering", "*", "MipsTargetLowering", "::", "create", "(", "const", "MipsTargetMachine", "&", "TM", ",", "const", "MipsSubtarget", "&", "STI", ")", "{", "if", "(", "STI", ".", "inMips16Mode", "(", ")", ")", "return", "createMips16TargetLowering", "(", "TM", ",", "STI", ")", ";", "return", "createMipsSETargetLowering", "(", "TM", ",", "STI", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "LanaiMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "Inst", ",", "raw_ostream", "&", "Ostream", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "SubtargetInfo", ")", "const", "{", "unsigned", "Value", "=", "getBinaryCodeForInstr", "(", "Inst", ",", "Fixups", ",", "SubtargetInfo", ")", ";", "++", "MCNumEmitted", ";", "for", "(", "int", "i", "=", "(", "4", "-", "1", ")", "*", "8", ";", "i", ">=", "0", ";", "i", "-=", "8", ")", "Ostream", "<<", "static_cast", "<", "char", ">", "(", "(", "Value", ">>", "i", ")", "&", "0xff", ")", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "4", "1", "8", "0", "8", "0xff" ]

[]

[ "<s>", "void", "RISCVDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "MVT", "XLenVT", "=", "Subtarget", "->", "getXLenVT", "(", ")", ";", "SDLoc", "DL", "(", "Node", ")", ";", "EVT", "VT", "=", "Node", "->", "getValueType", "(", "0", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "ISD", "::", "Constant", ":", "{", "auto", "ConstNode", "=", "cast", "<", "ConstantSDNode", ">", "(", "Node", ")", ";", "if", "(", "VT", "==", "XLenVT", "&&", "ConstNode", "->", "isNullValue", "(", ")", ")", "{", "SDValue", "New", "=", "CurDAG", "->", "getCopyFromReg", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "SDLoc", "(", "Node", ")", ",", "RISCV", "::", "X0", ",", "XLenVT", ")", ";", "ReplaceNode", "(", "Node", ",", "New", ".", "getNode", "(", ")", ")", ";", "return", ";", "}", "int64_t", "Imm", "=", "ConstNode", "->", "getSExtValue", "(", ")", ";", "if", "(", "XLenVT", "==", "MVT", "::", "i64", ")", "{", "ReplaceNode", "(", "Node", ",", "selectImm", "(", "CurDAG", ",", "SDLoc", "(", "Node", ")", ",", "Imm", ",", "XLenVT", ")", ")", ";", "return", ";", "}", "break", ";", "}", "case", "ISD", "::", "FrameIndex", ":", "{", "SDValue", "Imm", "=", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "DL", ",", "XLenVT", ")", ";", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "VT", ")", ";", "ReplaceNode", "(", "Node", ",", "CurDAG", "->", "getMachineNode", "(", "RISCV", "::", "ADDI", ",", "DL", ",", "VT", ",", "TFI", ",", "Imm", ")", ")", ";", "return", ";", "}", "case", "ISD", "::", "SRL", ":", "{", "if", "(", "!", "Subtarget", "->", "is64Bit", "(", ")", ")", "break", ";", "SDValue", "Op0", "=", "Node", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Op1", "=", "Node", "->", "getOperand", "(", "1", ")", ";", "uint64_t", "Mask", ";", "if", "(", "Op1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", "&&", "isConstantMask", "(", "Op0", ".", "getNode", "(", ")", ",", "Mask", ")", ")", "{", "uint64_t", "ShAmt", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op1", ".", "getNode", "(", ")", ")", "->", "getZExtValue", "(", ")", ";", "if", "(", "(", "Mask", "|", "maskTrailingOnes", "<", "uint64_t", ">", "(", "ShAmt", ")", ")", "==", "0xffffffff", ")", "{", "SDValue", "ShAmtVal", "=", "CurDAG", "->", "getTargetConstant", "(", "ShAmt", ",", "SDLoc", "(", "Node", ")", ",", "XLenVT", ")", ";", "CurDAG", "->", "SelectNodeTo", "(", "Node", ",", "RISCV", "::", "SRLIW", ",", "XLenVT", ",", "Op0", ".", "getOperand", "(", "0", ")", ",", "ShAmtVal", ")", ";", "return", ";", "}", "}", "}", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"== \"", "\"\\n\"", "1", "0", "ISD::Constant", "RISCV::X0", "MVT::i64", "ISD::FrameIndex", "0", "RISCV::ADDI", "ISD::SRL", "0", "1", "ISD::Constant", "0xffffffff", "RISCV::SRLIW", "0" ]

[]

[ "<s>", "static", "void", "mips_setup_incoming_varargs", "(", "cumulative_args_t", "cum", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_size", "ATTRIBUTE_UNUSED", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "local_cum", ";", "int", "gp_saved", ",", "fp_saved", ";", "local_cum", "=", "*", "get_cumulative_args", "(", "cum", ")", ";", "if", "(", "!", "TYPE_NO_NAMED_ARGS_STDARG_P", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", "mips_function_arg_advance", "(", "pack_cumulative_args", "(", "&", "local_cum", ")", ",", "arg", ")", ";", "gp_saved", "=", "MAX_ARGS_IN_REGISTERS", "-", "local_cum", ".", "num_gprs", ";", "fp_saved", "=", "(", "EABI_FLOAT_VARARGS_P", "?", "MAX_ARGS_IN_REGISTERS", "-", "local_cum", ".", "num_fprs", ":", "0", ")", ";", "if", "(", "!", "no_rtl", ")", "{", "if", "(", "gp_saved", ">", "0", ")", "{", "rtx", "ptr", ",", "mem", ";", "ptr", "=", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "REG_PARM_STACK_SPACE", "(", "cfun", "->", "decl", ")", "-", "gp_saved", "*", "UNITS_PER_WORD", ")", ";", "mem", "=", "gen_frame_mem", "(", "BLKmode", ",", "ptr", ")", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "move_block_from_reg", "(", "local_cum", ".", "num_gprs", "+", "GP_ARG_FIRST", ",", "mem", ",", "gp_saved", ")", ";", "}", "if", "(", "fp_saved", ">", "0", ")", "{", "machine_mode", "mode", ";", "int", "off", ",", "i", ";", "off", "=", "ROUND_DOWN", "(", "-", "gp_saved", "*", "UNITS_PER_WORD", ",", "UNITS_PER_FPVALUE", ")", ";", "off", "-=", "fp_saved", "*", "UNITS_PER_FPREG", ";", "mode", "=", "TARGET_SINGLE_FLOAT", "?", "SFmode", ":", "DFmode", ";", "for", "(", "i", "=", "local_cum", ".", "num_fprs", ";", "i", "<", "MAX_ARGS_IN_REGISTERS", ";", "i", "+=", "MAX_FPRS_PER_FMT", ")", "{", "rtx", "ptr", ",", "mem", ";", "ptr", "=", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "off", ")", ";", "mem", "=", "gen_frame_mem", "(", "mode", ",", "ptr", ")", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "mips_emit_move", "(", "mem", ",", "gen_rtx_REG", "(", "mode", ",", "FP_ARG_FIRST", "+", "i", ")", ")", ";", "off", "+=", "UNITS_PER_HWFPVALUE", ";", "}", "}", "}", "if", "(", "REG_PARM_STACK_SPACE", "(", "cfun", "->", "decl", ")", "==", "0", ")", "cfun", "->", "machine", "->", "varargs_size", "=", "(", "gp_saved", "*", "UNITS_PER_WORD", "+", "fp_saved", "*", "UNITS_PER_FPREG", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_SETUP_INCOMING_VARARGS", "." ]

[ "mips", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "int", "avr_num_arg_regs", "(", "enum", "machine_mode", "mode", ",", "tree", "type", ")", "{", "int", "size", ";", "if", "(", "mode", "==", "BLKmode", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "return", "(", "size", "+", "1", ")", "&", "~", "1", ";", "}", "</s>" ]

[ "Returns", "the", "number", "of", "registers", "to", "allocate", "for", "a", "function", "argument", "." ]

[ "avr", "1", "1" ]

[]

[ "<s>", "bool", "HSAILInstrInfo", "::", "isCoalescableExtInstr", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "DstReg", ",", "unsigned", "&", "SubIdx", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "isCoalescableExtInstr", "-", "Return", "true", "if", "the", "instruction", "is", "a", "``", "coalescable", "''", "extension", "instruction", "." ]

[ "HSAIL", "HSAIL" ]

[]

[ "<s>", "bool", "preferZeroCompareBranch", "(", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "heuristic", "to", "prefer", "icmp", "eq", "zero", "should", "be", "used", "in", "code", "gen", "prepare", "." ]

[ "SystemZ" ]

[]

[ "<s>", "bool", "isMem", "(", ")", "const", "override", "{", "return", "Kind", "==", "k_Memory", ";", "}", "</s>" ]

[ "isMem", "-", "Is", "this", "a", "memory", "operand", "?" ]

[ "ARM64" ]

[]

[ "<s>", "static", "bool", "mips_expand_vpc_loongson_bcast", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "i", ",", "elt", ";", "rtx", "t0", ",", "t1", ";", "if", "(", "!", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_LOONGSON_VECTORS", ")", ")", "return", "false", ";", "if", "(", "d", "->", "vmode", "!=", "V8QImode", ")", "return", "false", ";", "if", "(", "!", "d", "->", "one_vector_p", ")", "return", "false", ";", "elt", "=", "d", "->", "perm", "[", "0", "]", ";", "for", "(", "i", "=", "1", ";", "i", "<", "8", ";", "++", "i", ")", "if", "(", "d", "->", "perm", "[", "i", "]", "!=", "elt", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "t0", "=", "gen_reg_rtx", "(", "V8QImode", ")", ";", "if", "(", "elt", "<", "4", ")", "emit_insn", "(", "gen_loongson_punpcklbh", "(", "t0", ",", "d", "->", "op0", ",", "d", "->", "op0", ")", ")", ";", "else", "emit_insn", "(", "gen_loongson_punpckhbh", "(", "t0", ",", "d", "->", "op0", ",", "d", "->", "op0", ")", ")", ";", "elt", "&=", "3", ";", "elt", "*=", "0x55", ";", "t1", "=", "gen_reg_rtx", "(", "V4HImode", ")", ";", "emit_insn", "(", "gen_loongson_pshufh", "(", "t1", ",", "gen_lowpart", "(", "V4HImode", ",", "t0", ")", ",", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "elt", ")", ")", ")", ")", ";", "emit_move_insn", "(", "d", "->", "target", ",", "gen_lowpart", "(", "V8QImode", ",", "t1", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "broadcast", "patterns", "for", "the", "Loongson", "." ]

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

[]

[ "<s>", "static", "void", "adjust_splat", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "unspec", "=", "XEXP", "(", "body", ",", "1", ")", ";", "int", "half_elts", "=", "GET_MODE_NUNITS", "(", "GET_MODE", "(", "unspec", ")", ")", ">>", "1", ";", "int", "lane", "=", "INTVAL", "(", "XVECEXP", "(", "unspec", ",", "0", ",", "1", ")", ")", ";", "lane", "=", "lane", ">=", "half_elts", "?", "lane", "-", "half_elts", ":", "lane", "+", "half_elts", ";", "XVECEXP", "(", "unspec", ",", "0", ",", "1", ")", "=", "GEN_INT", "(", "lane", ")", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "df_insn_rescan", "(", "insn", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Changing lane for splat %d\\n\"", ",", "INSN_UID", "(", "insn", ")", ")", ";", "}", "</s>" ]

[ "Given", "OP", "that", "contains", "a", "vector", "direct-splat", "operation", ",", "adjust", "the", "index", "of", "the", "source", "lane", "to", "account", "for", "the", "doubleword", "swap", "." ]

[ "powerpcspe", "1", "1", "0", "1", "0", "1", "1", "\"Changing lane for splat %d\\n\"" ]

[]

[ "<s>", "static", "MCAsmInfo", "*", "createMCAsmInfo", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ")", "{", "Triple", "TheTriple", "(", "TT", ")", ";", "switch", "(", "TheTriple", ".", "getOS", "(", ")", ")", "{", "default", ":", "return", "new", "MBlazeMCAsmInfo", "(", ")", ";", "}", "}", "</s>" ]

[ "createMCAsmInfo", "-", "Create", "a", "MCAsmInfo", "implementation", "for", "the", "specified", "target", "triple", "." ]

[ "MBlaze", "MBlaze" ]

[]

[ "<s>", "static", "void", "ix86_set_func_type", "(", "tree", "fndecl", ")", "{", "if", "(", "cfun", "->", "machine", "->", "func_type", "==", "TYPE_UNKNOWN", ")", "{", "if", "(", "lookup_attribute", "(", "\"interrupt\"", ",", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "fndecl", ")", ")", ")", ")", "{", "if", "(", "ix86_function_naked", "(", "fndecl", ")", ")", "error_at", "(", "DECL_SOURCE_LOCATION", "(", "fndecl", ")", ",", "\"interrupt and naked attributes are not compatible\"", ")", ";", "int", "nargs", "=", "0", ";", "for", "(", "tree", "arg", "=", "DECL_ARGUMENTS", "(", "fndecl", ")", ";", "arg", ";", "arg", "=", "TREE_CHAIN", "(", "arg", ")", ")", "nargs", "++", ";", "cfun", "->", "machine", "->", "no_caller_saved_registers", "=", "true", ";", "cfun", "->", "machine", "->", "func_type", "=", "nargs", "==", "2", "?", "TYPE_EXCEPTION", ":", "TYPE_INTERRUPT", ";", "ix86_optimize_mode_switching", "[", "X86_DIRFLAG", "]", "=", "1", ";", "if", "(", "write_symbols", "!=", "NO_DEBUG", "&&", "write_symbols", "!=", "DWARF2_DEBUG", ")", "sorry", "(", "\"only DWARF debug format is supported for interrupt \"", "\"service routine\"", ")", ";", "}", "else", "{", "cfun", "->", "machine", "->", "func_type", "=", "TYPE_NORMAL", ";", "if", "(", "lookup_attribute", "(", "\"no_caller_saved_registers\"", ",", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "fndecl", ")", ")", ")", ")", "cfun", "->", "machine", "->", "no_caller_saved_registers", "=", "true", ";", "}", "}", "}", "</s>" ]

[ "Set", "the", "func_type", "field", "from", "the", "function", "FNDECL", "." ]

[ "i386", "\"interrupt\"", "\"interrupt and naked attributes are not compatible\"", "0", "2", "1", "\"only DWARF debug format is supported for interrupt \"", "\"service routine\"", "\"no_caller_saved_registers\"" ]

[]