Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "Value", "*", "AArch64TargetLowering", "::", "emitLoadLinked", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "Type", "*", "ValTy", "=", "cast", "<", "PointerType", ">", "(", "Addr", "->", "getType", "(", ")", ")", "->", "getElementType", "(", ")", ";", "bool", "IsAcquire", "=", "isAcquireOrStronger", "(", "Ord", ")", ";", "if", "(", "ValTy", "->", "getPrimitiveSizeInBits", "(", ")", "==", "128", ")", "{", "Intrinsic", "::", "ID", "Int", "=", "IsAcquire", "?", "Intrinsic", "::", "aarch64_ldaxp", ":", "Intrinsic", "::", "aarch64_ldxp", ";", "Function", "*", "Ldxr", "=", "llvm", "::", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "Type", "::", "getInt8PtrTy", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "Value", "*", "LoHi", "=", "Builder", ".", "CreateCall", "(", "Ldxr", ",", "Addr", ",", "\"lohi\"", ")", ";", "Value", "*", "Lo", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "0", ",", "\"lo\"", ")", ";", "Value", "*", "Hi", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "1", ",", "\"hi\"", ")", ";", "Lo", "=", "Builder", ".", "CreateZExt", "(", "Lo", ",", "ValTy", ",", "\"lo64\"", ")", ";", "Hi", "=", "Builder", ".", "CreateZExt", "(", "Hi", ",", "ValTy", ",", "\"hi64\"", ")", ";", "return", "Builder", ".", "CreateOr", "(", "Lo", ",", "Builder", ".", "CreateShl", "(", "Hi", ",", "ConstantInt", "::", "get", "(", "ValTy", ",", "64", ")", ")", ",", "\"val64\"", ")", ";", "}", "Type", "*", "Tys", "[", "]", "=", "{", "Addr", "->", "getType", "(", ")", "}", ";", "Intrinsic", "::", "ID", "Int", "=", "IsAcquire", "?", "Intrinsic", "::", "aarch64_ldaxr", ":", "Intrinsic", "::", "aarch64_ldxr", ";", "Function", "*", "Ldxr", "=", "llvm", "::", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ",", "Tys", ")", ";", "return", "Builder", ".", "CreateTruncOrBitCast", "(", "Builder", ".", "CreateCall", "(", "Ldxr", ",", "Addr", ")", ",", "cast", "<", "PointerType", ">", "(", "Addr", "->", "getType", "(", ")", ")", "->", "getElementType", "(", ")", ")", ";", "}", "</s>" ]

[ "Perform", "a", "load-linked", "operation", "on", "Addr", ",", "returning", "a", "``", "Value", "*", "''", "with", "the", "corresponding", "pointee", "type", "." ]

[ "AArch64", "AArch64", "128", "Intrinsic::ID", "Intrinsic::aarch64_ldaxp", "Intrinsic::aarch64_ldxp", "Intrinsic::getDeclaration", "\"lohi\"", "0", "\"lo\"", "1", "\"hi\"", "\"lo64\"", "\"hi64\"", "64", "\"val64\"", "Intrinsic::ID", "Intrinsic::aarch64_ldaxr", "Intrinsic::aarch64_ldxr", "Intrinsic::getDeclaration" ]

[]

[ "<s>", "InstructionCost", "ARMTTIImpl", "::", "getArithmeticReductionCost", "(", "unsigned", "Opcode", ",", "VectorType", "*", "ValTy", ",", "bool", "IsPairwiseForm", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "EVT", "ValVT", "=", "TLI", "->", "getValueType", "(", "DL", ",", "ValTy", ")", ";", "int", "ISD", "=", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", ";", "if", "(", "!", "ST", "->", "hasMVEIntegerOps", "(", ")", "||", "!", "ValVT", ".", "isSimple", "(", ")", "||", "ISD", "!=", "ISD", "::", "ADD", ")", "return", "BaseT", "::", "getArithmeticReductionCost", "(", "Opcode", ",", "ValTy", ",", "IsPairwiseForm", ",", "CostKind", ")", ";", "std", "::", "pair", "<", "InstructionCost", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "ValTy", ")", ";", "static", "const", "CostTblEntry", "CostTblAdd", "[", "]", "{", "{", "ISD", "::", "ADD", ",", "MVT", "::", "v16i8", ",", "1", "}", ",", "{", "ISD", "::", "ADD", ",", "MVT", "::", "v8i16", ",", "1", "}", ",", "{", "ISD", "::", "ADD", ",", "MVT", "::", "v4i32", ",", "1", "}", ",", "}", ";", "if", "(", "const", "auto", "*", "Entry", "=", "CostTableLookup", "(", "CostTblAdd", ",", "ISD", ",", "LT", ".", "second", ")", ")", "return", "Entry", "->", "Cost", "*", "ST", "->", "getMVEVectorCostFactor", "(", "CostKind", ")", "*", "LT", ".", "first", ";", "return", "BaseT", "::", "getArithmeticReductionCost", "(", "Opcode", ",", "ValTy", ",", "IsPairwiseForm", ",", "CostKind", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ISD::ADD", "ISD::ADD", "MVT::v16i8", "1", "ISD::ADD", "MVT::v8i16", "1", "ISD::ADD", "MVT::v4i32", "1" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "*", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "Align", "=", "FrameInfo", "->", "getObjectAlignment", "(", "FrameIndex", ")", ";", "unsigned", "Size", "=", "FrameInfo", "->", "getObjectSize", "(", "FrameIndex", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOLoad", ",", "Size", ",", "Align", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "unsigned", "Opcode", "=", "getSGPRSpillRestoreOpcode", "(", "RC", "->", "getSize", "(", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "return", ";", "}", "if", "(", "!", "ST", ".", "isVGPRSpillingEnabled", "(", "MFI", ")", ")", "{", "LLVMContext", "&", "Ctx", "=", "MF", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Ctx", ".", "emitError", "(", "\"SIInstrInfo::loadRegFromStackSlot - Do not know how to\"", "\" restore register\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "IMPLICIT_DEF", ")", ",", "DestReg", ")", ";", "return", ";", "}", "assert", "(", "RI", ".", "hasVGPRs", "(", "RC", ")", "&&", "\"Only VGPR spilling expected\"", ")", ";", "unsigned", "Opcode", "=", "getVGPRSpillRestoreOpcode", "(", "RC", "->", "getSize", "(", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ")", ".", "addReg", "(", "MFI", "->", "getScratchWaveOffsetReg", "(", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "\"SIInstrInfo::loadRegFromStackSlot - Do not know how to\"", "\" restore register\"", "AMDGPU::IMPLICIT_DEF", "\"Only VGPR spilling expected\"" ]

[]

[ "<s>", "static", "void", "ix86_emit_restore_sse_regs_using_mov", "(", "HOST_WIDE_INT", "cfa_offset", ",", "bool", "maybe_eh_return", ")", "{", "unsigned", "int", "regno", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "SSE_REGNO_P", "(", "regno", ")", "&&", "ix86_save_reg", "(", "regno", ",", "maybe_eh_return", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "V4SFmode", ",", "regno", ")", ";", "rtx", "mem", ";", "unsigned", "int", "align", ";", "mem", "=", "choose_baseaddr", "(", "cfa_offset", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "V4SFmode", ",", "mem", ")", ";", "align", "=", "MIN", "(", "GET_MODE_ALIGNMENT", "(", "V4SFmode", ")", ",", "INCOMING_STACK_BOUNDARY", ")", ";", "set_mem_align", "(", "mem", ",", "align", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "reg", ",", "mem", ")", ")", ";", "ix86_add_cfa_restore_note", "(", "NULL", ",", "reg", ",", "cfa_offset", ")", ";", "cfa_offset", "-=", "GET_MODE_SIZE", "(", "V4SFmode", ")", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "restore", "saved", "registers", "using", "MOV", "insns", ".", "First", "register", "is", "restored", "from", "CFA", "-", "CFA_OFFSET", "." ]

[ "i386", "0" ]

[]

[ "<s>", "void", "sparc_emit_fixunsdi", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", ")", "{", "rtx", "i0", ",", "i1", ",", "f0", ",", "in", ",", "out", ",", "limit", ";", "out", "=", "operands", "[", "0", "]", ";", "in", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "rtx_code_label", "*", "neglab", "=", "gen_label_rtx", "(", ")", ";", "rtx_code_label", "*", "donelab", "=", "gen_label_rtx", "(", ")", ";", "i0", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "i1", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "limit", "=", "gen_reg_rtx", "(", "mode", ")", ";", "f0", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_move_insn", "(", "limit", ",", "CONST_DOUBLE_FROM_REAL_VALUE", "(", "REAL_VALUE_ATOF", "(", "\"9223372036854775808.0\"", ",", "mode", ")", ",", "mode", ")", ")", ";", "emit_cmp_and_jump_insns", "(", "in", ",", "limit", ",", "GE", ",", "NULL_RTX", ",", "mode", ",", "0", ",", "neglab", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "out", ",", "gen_rtx_FIX", "(", "DImode", ",", "gen_rtx_FIX", "(", "mode", ",", "in", ")", ")", ")", ")", ";", "emit_jump_insn", "(", "gen_jump", "(", "donelab", ")", ")", ";", "emit_barrier", "(", ")", ";", "emit_label", "(", "neglab", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "f0", ",", "gen_rtx_MINUS", "(", "mode", ",", "in", ",", "limit", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "i0", ",", "gen_rtx_FIX", "(", "DImode", ",", "gen_rtx_FIX", "(", "mode", ",", "f0", ")", ")", ")", ")", ";", "emit_insn", "(", "gen_movdi", "(", "i1", ",", "const1_rtx", ")", ")", ";", "emit_insn", "(", "gen_ashldi3", "(", "i1", ",", "i1", ",", "GEN_INT", "(", "63", ")", ")", ")", ";", "emit_insn", "(", "gen_xordi3", "(", "out", ",", "i0", ",", "i1", ")", ")", ";", "emit_label", "(", "donelab", ")", ";", "}", "</s>" ]

[ "Generate", "an", "FP", "to", "unsigned", "DImode", "conversion", ".", "This", "is", "the", "same", "code", "optabs", "would", "emit", "if", "we", "did", "n't", "have", "TFmode", "patterns", "." ]

[ "sparc", "0", "1", "\"9223372036854775808.0\"", "0", "63" ]

[]

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

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

[ "PowerPC", "PPC", "PPC", "PPC::G8RCRegClass", "PPC::G8RCRegClass", "PPC::F8RCRegClass", "PPC::F8RCRegClass", "PPC::CRRCRegClass", "PPC::CRRCRegClass", "PPC::VRRCRegClass", "PPC::VRRCRegClass", "\"Unexpected register class in CSRsViaCopy!\"", "\"Function should be nounwind in insertCopiesSplitCSR!\"" ]

[]

[ "<s>", "static", "inline", "HOST_WIDE_INT", "htm_spr_num", "(", "enum", "rs6000_gen_builtins", "code", ")", "{", "if", "(", "code", "==", "RS6000_BIF_GET_TFHAR", "||", "code", "==", "RS6000_BIF_SET_TFHAR", ")", "return", "TFHAR_SPR", ";", "else", "if", "(", "code", "==", "RS6000_BIF_GET_TFIAR", "||", "code", "==", "RS6000_BIF_SET_TFIAR", ")", "return", "TFIAR_SPR", ";", "else", "if", "(", "code", "==", "RS6000_BIF_GET_TEXASR", "||", "code", "==", "RS6000_BIF_SET_TEXASR", ")", "return", "TEXASR_SPR", ";", "gcc_assert", "(", "code", "==", "RS6000_BIF_GET_TEXASRU", "||", "code", "==", "RS6000_BIF_SET_TEXASRU", ")", ";", "return", "TEXASRU_SPR", ";", "}", "</s>" ]

[ "Return", "the", "appropriate", "SPR", "number", "associated", "with", "the", "given", "builtin", "." ]

[ "rs6000" ]

[]

[ "<s>", "const", "char", "*", "host_detect_local_cpu", "(", "int", "argc", ",", "const", "char", "*", "*", "argv", ")", "{", "const", "char", "*", "val", "=", "NULL", ";", "char", "buf", "[", "128", "]", ";", "FILE", "*", "f", "=", "NULL", ";", "bool", "arch", ";", "const", "struct", "vendor_cpu", "*", "cpu_table", "=", "NULL", ";", "if", "(", "argc", "<", "1", ")", "goto", "not_found", ";", "arch", "=", "strcmp", "(", "argv", "[", "0", "]", ",", "\"arch\"", ")", "==", "0", ";", "if", "(", "!", "arch", "&&", "strcmp", "(", "argv", "[", "0", "]", ",", "\"cpu\"", ")", "!=", "0", "&&", "strcmp", "(", "argv", "[", "0", "]", ",", "\"tune\"", ")", ")", "goto", "not_found", ";", "f", "=", "fopen", "(", "\"/proc/cpuinfo\"", ",", "\"r\"", ")", ";", "if", "(", "f", "==", "NULL", ")", "goto", "not_found", ";", "while", "(", "fgets", "(", "buf", ",", "sizeof", "(", "buf", ")", ",", "f", ")", "!=", "NULL", ")", "{", "if", "(", "strncmp", "(", "buf", ",", "\"CPU implementer\"", ",", "sizeof", "(", "\"CPU implementer\"", ")", "-", "1", ")", "==", "0", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "vendors", "[", "i", "]", ".", "vendor_no", "!=", "NULL", ";", "i", "++", ")", "if", "(", "strstr", "(", "buf", ",", "vendors", "[", "i", "]", ".", "vendor_no", ")", "!=", "NULL", ")", "{", "cpu_table", "=", "vendors", "[", "i", "]", ".", "vendor_parts", ";", "break", ";", "}", "}", "if", "(", "strncmp", "(", "buf", ",", "\"CPU part\"", ",", "sizeof", "(", "\"CPU part\"", ")", "-", "1", ")", "==", "0", ")", "{", "int", "i", ";", "if", "(", "cpu_table", "==", "NULL", ")", "goto", "not_found", ";", "for", "(", "i", "=", "0", ";", "cpu_table", "[", "i", "]", ".", "part_no", "!=", "NULL", ";", "i", "++", ")", "if", "(", "strstr", "(", "buf", ",", "cpu_table", "[", "i", "]", ".", "part_no", ")", "!=", "NULL", ")", "{", "val", "=", "arch", "?", "cpu_table", "[", "i", "]", ".", "arch_name", ":", "cpu_table", "[", "i", "]", ".", "cpu_name", ";", "break", ";", "}", "break", ";", "}", "}", "fclose", "(", "f", ")", ";", "if", "(", "val", "==", "NULL", ")", "goto", "not_found", ";", "return", "concat", "(", "\"-m\"", ",", "argv", "[", "0", "]", ",", "\"=\"", ",", "val", ",", "NULL", ")", ";", "not_found", ":", "{", "unsigned", "int", "i", ";", "unsigned", "int", "opt", ";", "const", "char", "*", "search", "[", "]", "=", "{", "NULL", ",", "\"arch\"", "}", ";", "if", "(", "f", ")", "fclose", "(", "f", ")", ";", "search", "[", "0", "]", "=", "argv", "[", "0", "]", ";", "for", "(", "opt", "=", "0", ";", "opt", "<", "ARRAY_SIZE", "(", "search", ")", ";", "opt", "++", ")", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "configure_default_options", ")", ";", "i", "++", ")", "if", "(", "strcmp", "(", "configure_default_options", "[", "i", "]", ".", "name", ",", "search", "[", "opt", "]", ")", "==", "0", ")", "return", "concat", "(", "\"-m\"", ",", "search", "[", "opt", "]", ",", "\"=\"", ",", "configure_default_options", "[", "i", "]", ".", "value", ",", "NULL", ")", ";", "return", "NULL", ";", "}", "}", "</s>" ]

[ "This", "will", "be", "called", "by", "the", "spec", "parser", "in", "gcc.cc", "when", "it", "sees", "a", "%", ":", "local_cpu_detect", "(", "args", ")", "construct", ".", "Currently", "it", "will", "be", "called", "with", "either", "``", "cpu", "''", "or", "``", "tune", "''", "as", "argument", "depending", "on", "if", "-mcpu=native", "or", "-mtune=native", "is", "to", "be", "substituted", ".", "It", "returns", "a", "string", "containing", "new", "command", "line", "parameters", "to", "be", "put", "at", "the", "place", "of", "the", "above", "two", "options", ",", "depending", "on", "what", "CPU", "this", "is", "executed", ".", "E.g", ".", "``", "-mcpu=ultrasparc3", "''", "on", "an", "UltraSPARC", "III", "for", "-mcpu=native", ".", "If", "the", "routine", "ca", "n't", "detect", "a", "known", "processor", ",", "the", "-mcpu", "or", "-mtune", "option", "is", "discarded", ".", "ARGC", "and", "ARGV", "are", "set", "depending", "on", "the", "actual", "arguments", "given", "in", "the", "spec", "." ]

[ "arm", "128", "1", "0", "\"arch\"", "0", "0", "\"cpu\"", "0", "0", "\"tune\"", "\"/proc/cpuinfo\"", "\"r\"", "\"CPU implementer\"", "\"CPU implementer\"", "1", "0", "0", "\"CPU part\"", "\"CPU part\"", "1", "0", "0", "\"-m\"", "0", "\"=\"", "\"arch\"", "0", "0", "0", "0", "0", "\"-m\"", "\"=\"" ]

[]

[ "<s>", "void", "MSP430InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";", "if", "(", "RC", "==", "&", "MSP430", "::", "GR16RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV16rm", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "MSP430", "::", "GR8RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV8rm", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "llvm_unreachable", "(", "\"Cannot store this register to stack slot!\"", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430::GR16RegClass", "MSP430::MOV16rm", "0", "MSP430::GR8RegClass", "MSP430::MOV8rm", "0", "\"Cannot store this register to stack slot!\"" ]

[]

[ "<s>", "void", "ix86_split_convert_uns_si_sse", "(", "rtx", "operands", "[", "]", ")", "{", "machine_mode", "vecmode", ";", "rtx", "value", ",", "large", ",", "zero_or_two31", ",", "input", ",", "two31", ",", "x", ";", "large", "=", "operands", "[", "1", "]", ";", "zero_or_two31", "=", "operands", "[", "2", "]", ";", "input", "=", "operands", "[", "3", "]", ";", "two31", "=", "operands", "[", "4", "]", ";", "vecmode", "=", "GET_MODE", "(", "large", ")", ";", "value", "=", "gen_rtx_REG", "(", "vecmode", ",", "REGNO", "(", "operands", "[", "0", "]", ")", ")", ";", "if", "(", "MEM_P", "(", "input", ")", ")", "{", "if", "(", "vecmode", "==", "V4SFmode", ")", "emit_insn", "(", "gen_vec_setv4sf_0", "(", "value", ",", "CONST0_RTX", "(", "V4SFmode", ")", ",", "input", ")", ")", ";", "else", "emit_insn", "(", "gen_sse2_loadlpd", "(", "value", ",", "CONST0_RTX", "(", "V2DFmode", ")", ",", "input", ")", ")", ";", "}", "else", "{", "input", "=", "gen_rtx_REG", "(", "vecmode", ",", "REGNO", "(", "input", ")", ")", ";", "emit_move_insn", "(", "value", ",", "CONST0_RTX", "(", "vecmode", ")", ")", ";", "if", "(", "vecmode", "==", "V4SFmode", ")", "emit_insn", "(", "gen_sse_movss", "(", "value", ",", "value", ",", "input", ")", ")", ";", "else", "emit_insn", "(", "gen_sse2_movsd", "(", "value", ",", "value", ",", "input", ")", ")", ";", "}", "emit_move_insn", "(", "large", ",", "two31", ")", ";", "emit_move_insn", "(", "zero_or_two31", ",", "MEM_P", "(", "two31", ")", "?", "large", ":", "two31", ")", ";", "x", "=", "gen_rtx_fmt_ee", "(", "LE", ",", "vecmode", ",", "large", ",", "value", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "large", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_AND", "(", "vecmode", ",", "zero_or_two31", ",", "large", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "zero_or_two31", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_MINUS", "(", "vecmode", ",", "value", ",", "zero_or_two31", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "value", ",", "x", ")", ")", ";", "large", "=", "gen_rtx_REG", "(", "V4SImode", ",", "REGNO", "(", "large", ")", ")", ";", "emit_insn", "(", "gen_ashlv4si3", "(", "large", ",", "large", ",", "GEN_INT", "(", "31", ")", ")", ")", ";", "x", "=", "gen_rtx_REG", "(", "V4SImode", ",", "REGNO", "(", "value", ")", ")", ";", "if", "(", "vecmode", "==", "V4SFmode", ")", "emit_insn", "(", "gen_fix_truncv4sfv4si2", "(", "x", ",", "value", ")", ")", ";", "else", "emit_insn", "(", "gen_sse2_cvttpd2dq", "(", "x", ",", "value", ")", ")", ";", "value", "=", "x", ";", "emit_insn", "(", "gen_xorv4si3", "(", "value", ",", "value", ",", "large", ")", ")", ";", "}", "</s>" ]

[ "Post-reload", "splitter", "for", "converting", "an", "SF", "or", "DFmode", "value", "in", "an", "SSE", "register", "into", "an", "unsigned", "SImode", "." ]

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

[]

[ "<s>", "void", "WebAssemblyFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "auto", "*", "TII", "=", "static_cast", "<", "const", "WebAssemblyInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "IsDestroy", "=", "Opc", "==", "TII", "->", "getCallFrameDestroyOpcode", "(", ")", ";", "unsigned", "Amount", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", ")", "adjustStackPointer", "(", "Amount", ",", "IsDestroy", ",", "MF", ",", "MBB", ",", "TII", ",", "I", ",", "DL", ")", ";", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "0" ]

[]

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

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

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

[]

[ "<s>", "EVT", "X86TargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsZeroVal", ",", "bool", "MemcpyStrSrc", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "IsZeroVal", "&&", "!", "F", "->", "getFnAttributes", "(", ")", ".", "hasNoImplicitFloatAttr", "(", ")", ")", "{", "if", "(", "Size", ">=", "16", "&&", "(", "Subtarget", "->", "isUnalignedMemAccessFast", "(", ")", "||", "(", "(", "DstAlign", "==", "0", "||", "DstAlign", ">=", "16", ")", "&&", "(", "SrcAlign", "==", "0", "||", "SrcAlign", ">=", "16", ")", ")", ")", "&&", "Subtarget", "->", "getStackAlignment", "(", ")", ">=", "16", ")", "{", "if", "(", "Subtarget", "->", "getStackAlignment", "(", ")", ">=", "32", ")", "{", "if", "(", "Subtarget", "->", "hasAVX2", "(", ")", ")", "return", "MVT", "::", "v8i32", ";", "if", "(", "Subtarget", "->", "hasAVX", "(", ")", ")", "return", "MVT", "::", "v8f32", ";", "}", "if", "(", "Subtarget", "->", "hasSSE2", "(", ")", ")", "return", "MVT", "::", "v4i32", ";", "if", "(", "Subtarget", "->", "hasSSE1", "(", ")", ")", "return", "MVT", "::", "v4f32", ";", "}", "else", "if", "(", "!", "MemcpyStrSrc", "&&", "Size", ">=", "8", "&&", "!", "Subtarget", "->", "is64Bit", "(", ")", "&&", "Subtarget", "->", "getStackAlignment", "(", ")", ">=", "8", "&&", "Subtarget", "->", "hasSSE2", "(", ")", ")", "{", "return", "MVT", "::", "f64", ";", "}", "}", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", "&&", "Size", ">=", "8", ")", "return", "MVT", "::", "i64", ";", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "X86", "X86", "16", "0", "16", "0", "16", "16", "32", "MVT::v8i32", "MVT::v8f32", "MVT::v4i32", "MVT::v4f32", "8", "8", "MVT::f64", "8", "MVT::i64", "MVT::i32" ]

[]

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

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

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

[]

[ "<s>", "bool", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "override", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "TRC", "=", "TRI", "->", "getPointerRegClass", "(", "*", "MF", ",", "1", ")", ";", "SDValue", "RC", "=", "CurDAG", "->", "getTargetConstant", "(", "TRC", "->", "getID", "(", ")", ",", "MVT", "::", "i32", ")", ";", "SDValue", "NewOp", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "TargetOpcode", "::", "COPY_TO_REGCLASS", ",", "SDLoc", "(", "Op", ")", ",", "Op", ".", "getValueType", "(", ")", ",", "Op", ",", "RC", ")", ",", "0", ")", ";", "OutOps", ".", "push_back", "(", "NewOp", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "1", "MVT::i32", "0" ]

[]

[ "<s>", "void", "AArch64FrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "assert", "(", "getStackGrowthDirection", "(", ")", "==", "TargetFrameLowering", "::", "StackGrowsDown", "&&", "\"Upwards growing stack unsupported\"", ")", ";", "int", "MinCSFrameIndex", ",", "MaxCSFrameIndex", ";", "int64_t", "SVEStackSize", "=", "assignSVEStackObjectOffsets", "(", "MFI", ",", "MinCSFrameIndex", ",", "MaxCSFrameIndex", ")", ";", "AArch64FunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "AFI", "->", "setStackSizeSVE", "(", "alignTo", "(", "SVEStackSize", ",", "16U", ")", ")", ";", "AFI", "->", "setMinMaxSVECSFrameIndex", "(", "MinCSFrameIndex", ",", "MaxCSFrameIndex", ")", ";", "if", "(", "!", "MF", ".", "hasEHFunclets", "(", ")", ")", "return", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "WinEHFuncInfo", "&", "EHInfo", "=", "*", "MF", ".", "getWinEHFuncInfo", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "auto", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "MBBI", "->", "getFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ")", "++", "MBBI", ";", "int64_t", "FixedObject", "=", "getFixedObjectSize", "(", "MF", ",", "AFI", ",", "true", ",", "false", ")", ";", "int", "UnwindHelpFI", "=", "MFI", ".", "CreateFixedObject", "(", "8", ",", "-", "FixedObject", ",", "false", ")", ";", "EHInfo", ".", "UnwindHelpFrameIdx", "=", "UnwindHelpFI", ";", "DebugLoc", "DL", ";", "RS", "->", "enterBasicBlockEnd", "(", "MBB", ")", ";", "RS", "->", "backward", "(", "std", "::", "prev", "(", "MBBI", ")", ")", ";", "Register", "DstReg", "=", "RS", "->", "FindUnusedReg", "(", "&", "AArch64", "::", "GPR64commonRegClass", ")", ";", "assert", "(", "DstReg", "&&", "\"There must be a free register after frame setup\"", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AArch64", "::", "MOVi64imm", ")", ",", "DstReg", ")", ".", "addImm", "(", "-", "2", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AArch64", "::", "STURXi", ")", ")", ".", "addReg", "(", "DstReg", ",", "getKillRegState", "(", "true", ")", ")", ".", "addFrameIndex", "(", "UnwindHelpFI", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "AArch64", "AArch64", "\"Upwards growing stack unsupported\"", "AArch64", "AArch64", "16U", "8", "AArch64::GPR64commonRegClass", "\"There must be a free register after frame setup\"", "AArch64::MOVi64imm", "2", "AArch64::STURXi", "0" ]

[]

[ "<s>", "bool", "X86AsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "SMShadowTracker", ".", "startFunction", "(", "MF", ")", ";", "CodeEmitter", ".", "reset", "(", "TM", ".", "getTarget", "(", ")", ".", "createMCCodeEmitter", "(", "*", "Subtarget", "->", "getInstrInfo", "(", ")", ",", "*", "Subtarget", "->", "getRegisterInfo", "(", ")", ",", "MF", ".", "getContext", "(", ")", ")", ")", ";", "EmitFPOData", "=", "Subtarget", "->", "isTargetWin32", "(", ")", "&&", "MF", ".", "getMMI", "(", ")", ".", "getModule", "(", ")", "->", "getCodeViewFlag", "(", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "if", "(", "Subtarget", "->", "isTargetCOFF", "(", ")", ")", "{", "bool", "Local", "=", "MF", ".", "getFunction", "(", ")", ".", "hasLocalLinkage", "(", ")", ";", "OutStreamer", "->", "BeginCOFFSymbolDef", "(", "CurrentFnSym", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolStorageClass", "(", "Local", "?", "COFF", "::", "IMAGE_SYM_CLASS_STATIC", ":", "COFF", "::", "IMAGE_SYM_CLASS_EXTERNAL", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolType", "(", "COFF", "::", "IMAGE_SYM_DTYPE_FUNCTION", "<<", "COFF", "::", "SCT_COMPLEX_TYPE_SHIFT", ")", ";", "OutStreamer", "->", "EndCOFFSymbolDef", "(", ")", ";", "}", "emitFunctionBody", "(", ")", ";", "emitXRayTable", "(", ")", ";", "EmitFPOData", "=", "false", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

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

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

[ "XCore", "\"XCore Assembly Printer\"" ]

[]

[ "<s>", "void", "LM32InstPrinter", "::", "printSymbol", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ",", "bool", "hi", ")", "const", "{", "assert", "(", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isImm", "(", ")", "||", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isExpr", "(", ")", ")", "&&", "\"Unknown symbol operand\"", ")", ";", "O", "<<", "(", "hi", "?", "\"hi\"", ":", "\"lo\"", ")", "<<", "\"(\"", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "O", "<<", "')'", ";", "}", "</s>" ]

[ "Print", "a", "MCSymbol", "as", "an", "operand", "." ]

[ "LM32", "LM32", "\"Unknown symbol operand\"", "\"hi\"", "\"lo\"", "\"(\"" ]

[]

[ "<s>", "static", "machine_mode", "type_natural_mode", "(", "const_tree", "type", ",", "const", "CUMULATIVE_ARGS", "*", "cum", ",", "bool", "in_return", ")", "{", "machine_mode", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "!", "VECTOR_MODE_P", "(", "mode", ")", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "(", "size", "==", "8", "||", "size", "==", "16", "||", "size", "==", "32", "||", "size", "==", "64", ")", "&&", "TYPE_VECTOR_SUBPARTS", "(", "type", ")", ">", "1", ")", "{", "machine_mode", "innermode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type", ")", ")", ";", "if", "(", "TREE_CODE", "(", "TREE_TYPE", "(", "type", ")", ")", "==", "REAL_TYPE", ")", "mode", "=", "MIN_MODE_VECTOR_FLOAT", ";", "else", "mode", "=", "MIN_MODE_VECTOR_INT", ";", "for", "(", ";", "mode", "!=", "VOIDmode", ";", "mode", "=", "GET_MODE_WIDER_MODE", "(", "mode", ")", ")", "if", "(", "GET_MODE_NUNITS", "(", "mode", ")", "==", "TYPE_VECTOR_SUBPARTS", "(", "type", ")", "&&", "GET_MODE_INNER", "(", "mode", ")", "==", "innermode", ")", "{", "if", "(", "size", "==", "64", "&&", "!", "TARGET_AVX512F", ")", "{", "static", "bool", "warnedavx512f", ";", "static", "bool", "warnedavx512f_ret", ";", "if", "(", "cum", "&&", "cum", "->", "warn_avx512f", "&&", "!", "warnedavx512f", ")", "{", "if", "(", "warning", "(", "OPT_Wpsabi", ",", "\"AVX512F vector argument \"", "\"without AVX512F enabled changes the ABI\"", ")", ")", "warnedavx512f", "=", "true", ";", "}", "else", "if", "(", "in_return", "&&", "!", "warnedavx512f_ret", ")", "{", "if", "(", "warning", "(", "OPT_Wpsabi", ",", "\"AVX512F vector return \"", "\"without AVX512F enabled changes the ABI\"", ")", ")", "warnedavx512f_ret", "=", "true", ";", "}", "return", "TYPE_MODE", "(", "type", ")", ";", "}", "else", "if", "(", "size", "==", "32", "&&", "!", "TARGET_AVX", ")", "{", "static", "bool", "warnedavx", ";", "static", "bool", "warnedavx_ret", ";", "if", "(", "cum", "&&", "cum", "->", "warn_avx", "&&", "!", "warnedavx", ")", "{", "if", "(", "warning", "(", "OPT_Wpsabi", ",", "\"AVX vector argument \"", "\"without AVX enabled changes the ABI\"", ")", ")", "warnedavx", "=", "true", ";", "}", "else", "if", "(", "in_return", "&&", "!", "warnedavx_ret", ")", "{", "if", "(", "warning", "(", "OPT_Wpsabi", ",", "\"AVX vector return \"", "\"without AVX enabled changes the ABI\"", ")", ")", "warnedavx_ret", "=", "true", ";", "}", "return", "TYPE_MODE", "(", "type", ")", ";", "}", "else", "if", "(", "(", "(", "size", "==", "8", "&&", "TARGET_64BIT", ")", "||", "size", "==", "16", ")", "&&", "!", "TARGET_SSE", ")", "{", "static", "bool", "warnedsse", ";", "static", "bool", "warnedsse_ret", ";", "if", "(", "cum", "&&", "cum", "->", "warn_sse", "&&", "!", "warnedsse", ")", "{", "if", "(", "warning", "(", "OPT_Wpsabi", ",", "\"SSE vector argument \"", "\"without SSE enabled changes the ABI\"", ")", ")", "warnedsse", "=", "true", ";", "}", "else", "if", "(", "!", "TARGET_64BIT", "&&", "in_return", "&&", "!", "warnedsse_ret", ")", "{", "if", "(", "warning", "(", "OPT_Wpsabi", ",", "\"SSE vector return \"", "\"without SSE enabled changes the ABI\"", ")", ")", "warnedsse_ret", "=", "true", ";", "}", "}", "else", "if", "(", "(", "size", "==", "8", "&&", "!", "TARGET_64BIT", ")", "&&", "!", "TARGET_MMX", ")", "{", "static", "bool", "warnedmmx", ";", "static", "bool", "warnedmmx_ret", ";", "if", "(", "cum", "&&", "cum", "->", "warn_mmx", "&&", "!", "warnedmmx", ")", "{", "if", "(", "warning", "(", "OPT_Wpsabi", ",", "\"MMX vector argument \"", "\"without MMX enabled changes the ABI\"", ")", ")", "warnedmmx", "=", "true", ";", "}", "else", "if", "(", "in_return", "&&", "!", "warnedmmx_ret", ")", "{", "if", "(", "warning", "(", "OPT_Wpsabi", ",", "\"MMX vector return \"", "\"without MMX enabled changes the ABI\"", ")", ")", "warnedmmx_ret", "=", "true", ";", "}", "}", "return", "mode", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "}", "return", "mode", ";", "}", "</s>" ]

[ "Return", "the", "``", "natural", "''", "mode", "for", "TYPE", ".", "In", "most", "cases", ",", "this", "is", "just", "TYPE_MODE", ".", "But", "in", "the", "case", "of", "vector", "types", ",", "it", "is", "some", "vector", "mode", ".", "When", "we", "have", "only", "some", "of", "our", "vector", "isa", "extensions", "enabled", ",", "then", "there", "are", "some", "modes", "for", "which", "vector_mode_supported_p", "is", "false", ".", "For", "these", "modes", ",", "the", "generic", "vector", "support", "in", "gcc", "will", "choose", "some", "non-vector", "mode", "in", "order", "to", "implement", "the", "type", ".", "By", "computing", "the", "natural", "mode", ",", "we", "'ll", "select", "the", "proper", "ABI", "location", "for", "the", "operand", "and", "not", "depend", "on", "whatever", "the", "middle-end", "decides", "to", "do", "with", "these", "vector", "types", "." ]

[ "i386", "8", "16", "32", "64", "1", "64", "\"AVX512F vector argument \"", "\"without AVX512F enabled changes the ABI\"", "\"AVX512F vector return \"", "\"without AVX512F enabled changes the ABI\"", "32", "\"AVX vector argument \"", "\"without AVX enabled changes the ABI\"", "\"AVX vector return \"", "\"without AVX enabled changes the ABI\"", "8", "16", "\"SSE vector argument \"", "\"without SSE enabled changes the ABI\"", "\"SSE vector return \"", "\"without SSE enabled changes the ABI\"", "8", "\"MMX vector argument \"", "\"without MMX enabled changes the ABI\"", "\"MMX vector return \"", "\"without MMX enabled changes the ABI\"" ]

[]

[ "<s>", "const", "Cpu0FrameLowering", "*", "Cpu0FrameLowering", "::", "create", "(", "const", "Cpu0Subtarget", "&", "ST", ")", "{", "return", "llvm", "::", "createCpu0SEFrameLowering", "(", "ST", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "unsigned", "riscv_pass_aggregate_in_fpr_pair_p", "(", "const_tree", "type", ",", "riscv_aggregate_field", "fields", "[", "2", "]", ")", "{", "int", "n", "=", "riscv_flatten_aggregate_argument", "(", "type", ",", "fields", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "if", "(", "!", "SCALAR_FLOAT_TYPE_P", "(", "fields", "[", "i", "]", ".", "type", ")", ")", "return", "0", ";", "return", "n", ">", "0", "?", "n", ":", "0", ";", "}", "</s>" ]

[ "See", "whether", "TYPE", "is", "a", "record", "whose", "fields", "should", "be", "returned", "in", "one", "or", "two", "floating-point", "registers", ".", "If", "so", ",", "populate", "FIELDS", "accordingly", "." ]

[ "riscv", "2", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "void", "preprocess_args", "(", "int", "*", "p_argc", ",", "char", "*", "argv", "[", "]", ")", "{", "int", "i", ";", "for", "(", "i", "=", "1", ";", "i", "<", "*", "p_argc", ";", "i", "++", ")", "{", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-o\"", ")", "==", "0", ")", "{", "char", "*", "buff", ",", "*", "ptr", ";", "i", "++", ";", "ptr", "=", "to_host_file_spec", "(", "argv", "[", "i", "]", ")", ";", "objfilename", "=", "xstrdup", "(", "ptr", ")", ";", "buff", "=", "concat", "(", "\"/obj=\"", ",", "ptr", ",", "NULL", ")", ";", "addarg", "(", "buff", ")", ";", "}", "}", "}", "</s>" ]

[ "Preprocess", "the", "number", "of", "args", "P_ARGC", "in", "ARGV", ".", "Look", "for", "special", "flags", ",", "etc", ".", "that", "must", "be", "handled", "first", "." ]

[ "alpha", "1", "\"-o\"", "0", "\"/obj=\"" ]

[]

[ "<s>", "unsigned", "SIRegisterInfo", "::", "getRegPressureSetLimit", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Idx", ")", "const", "{", "const", "AMDGPUSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "unsigned", "SGPRLimit", "=", "getNumSGPRsAllowed", "(", "STI", ".", "getGeneration", "(", ")", ",", "STI", ".", "getMaxWavesPerCU", "(", ")", ")", ";", "unsigned", "VGPRLimit", "=", "getNumVGPRsAllowed", "(", "STI", ".", "getMaxWavesPerCU", "(", ")", ")", ";", "for", "(", "regclass_iterator", "I", "=", "regclass_begin", "(", ")", ",", "E", "=", "regclass_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "NumSubRegs", "=", "std", "::", "max", "(", "(", "int", ")", "(", "*", "I", ")", "->", "getSize", "(", ")", "/", "4", ",", "1", ")", ";", "unsigned", "Limit", ";", "if", "(", "isSGPRClass", "(", "*", "I", ")", ")", "{", "Limit", "=", "SGPRLimit", "/", "NumSubRegs", ";", "}", "else", "{", "Limit", "=", "VGPRLimit", "/", "NumSubRegs", ";", "}", "const", "int", "*", "Sets", "=", "getRegClassPressureSets", "(", "*", "I", ")", ";", "assert", "(", "Sets", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "Sets", "[", "i", "]", "!=", "-", "1", ";", "++", "i", ")", "{", "if", "(", "Sets", "[", "i", "]", "==", "(", "int", ")", "Idx", ")", "return", "Limit", ";", "}", "}", "return", "256", ";", "}", "</s>" ]

[ "Get", "the", "register", "unit", "pressure", "limit", "for", "this", "dimension", "." ]

[ "AMDGPU", "SI", "AMDGPU", "AMDGPU", "4", "1", "0", "1", "256" ]

[]

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

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

[ "X86", "X86" ]

[]

[ "<s>", "void", "WDC65816TargetAsmStreamer", "::", "EmitInstruction", "(", "StringRef", "instruction", ")", "{", "instruction", "=", "instruction", ".", "ltrim", "(", ")", ";", "OS", "<<", "indent", ";", "OS", "<<", "instruction", ";", "OS", "<<", "'\\n'", ";", "}", "</s>" ]

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

[ "WDC65816", "WDC" ]

[]

[ "<s>", "static", "void", "push", "(", "struct", "unw_state_record", "*", "sr", ")", "{", "struct", "unw_reg_state", "*", "rs", "=", "alloc_reg_state", "(", ")", ";", "memcpy", "(", "rs", ",", "&", "sr", "->", "curr", ",", "sizeof", "(", "*", "rs", ")", ")", ";", "sr", "->", "curr", ".", "next", "=", "rs", ";", "}", "</s>" ]

[ "Output", "RTL", "to", "push", "register", "RN", "onto", "the", "stack", "." ]

[ "ia64" ]

[]

[ "<s>", "void", "ix86_emit_i387_atanh", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx", "e1", "=", "gen_reg_rtx", "(", "XFmode", ")", ";", "rtx", "e2", "=", "gen_reg_rtx", "(", "XFmode", ")", ";", "rtx", "scratch", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "rtx", "flags", "=", "gen_rtx_REG", "(", "CCNOmode", ",", "FLAGS_REG", ")", ";", "rtx", "half", "=", "const_double_from_real_value", "(", "dconsthalf", ",", "XFmode", ")", ";", "rtx", "cst1", ",", "tmp", ";", "rtx_code_label", "*", "jump_label", "=", "gen_label_rtx", "(", ")", ";", "rtx_insn", "*", "insn", ";", "emit_insn", "(", "gen_fxamxf2_i387", "(", "scratch", ",", "op1", ")", ")", ";", "emit_insn", "(", "gen_absxf2", "(", "e2", ",", "op1", ")", ")", ";", "cst1", "=", "force_reg", "(", "XFmode", ",", "CONST1_RTX", "(", "XFmode", ")", ")", ";", "emit_insn", "(", "gen_addxf3", "(", "e1", ",", "e2", ",", "cst1", ")", ")", ";", "emit_insn", "(", "gen_addxf3", "(", "e2", ",", "e2", ",", "e2", ")", ")", ";", "emit_insn", "(", "gen_negxf2", "(", "e2", ",", "e2", ")", ")", ";", "emit_insn", "(", "gen_divxf3", "(", "e1", ",", "e2", ",", "e1", ")", ")", ";", "ix86_emit_i387_log1p", "(", "e2", ",", "e1", ")", ";", "emit_insn", "(", "gen_testqi_ext_1_ccno", "(", "scratch", ",", "GEN_INT", "(", "0x02", ")", ")", ")", ";", "tmp", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "gen_rtx_NE", "(", "VOIDmode", ",", "flags", ",", "const0_rtx", ")", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "jump_label", ")", ",", "pc_rtx", ")", ";", "insn", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "tmp", ")", ")", ";", "predict_jump", "(", "REG_BR_PROB_BASE", "*", "50", "/", "100", ")", ";", "JUMP_LABEL", "(", "insn", ")", "=", "jump_label", ";", "emit_insn", "(", "gen_negxf2", "(", "e2", ",", "e2", ")", ")", ";", "emit_label", "(", "jump_label", ")", ";", "LABEL_NUSES", "(", "jump_label", ")", "=", "1", ";", "half", "=", "force_reg", "(", "XFmode", ",", "half", ")", ";", "emit_insn", "(", "gen_mulxf3", "(", "op0", ",", "e2", ",", "half", ")", ")", ";", "}", "</s>" ]

[ "Output", "code", "to", "perform", "an", "atanh", "XFmode", "calculation", "." ]

[ "i386", "0x02", "50", "100", "1" ]

[]

[ "<s>", "static", "void", "h8300_print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "rtx", "index", ";", "int", "size", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "\"%s\"", ",", "h8_reg_names", "[", "REGNO", "(", "addr", ")", "]", ")", ";", "break", ";", "case", "PRE_DEC", ":", "fprintf", "(", "file", ",", "\"-%s\"", ",", "h8_reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "]", ")", ";", "break", ";", "case", "POST_INC", ":", "fprintf", "(", "file", ",", "\"%s+\"", ",", "h8_reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "]", ")", ";", "break", ";", "case", "PRE_INC", ":", "fprintf", "(", "file", ",", "\"+%s\"", ",", "h8_reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "]", ")", ";", "break", ";", "case", "POST_DEC", ":", "fprintf", "(", "file", ",", "\"%s-\"", ",", "h8_reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "]", ")", ";", "break", ";", "case", "PLUS", ":", "fprintf", "(", "file", ",", "\"(\"", ")", ";", "index", "=", "h8300_get_index", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "VOIDmode", ",", "&", "size", ")", ";", "if", "(", "GET_CODE", "(", "index", ")", "==", "REG", ")", "{", "h8300_print_operand_address", "(", "file", ",", "XEXP", "(", "addr", ",", "1", ")", ")", ";", "fprintf", "(", "file", ",", "\",\"", ")", ";", "switch", "(", "size", ")", "{", "case", "0", ":", "h8300_print_operand_address", "(", "file", ",", "index", ")", ";", "break", ";", "case", "1", ":", "h8300_print_operand", "(", "file", ",", "index", ",", "'X'", ")", ";", "fputs", "(", "\".b\"", ",", "file", ")", ";", "break", ";", "case", "2", ":", "h8300_print_operand", "(", "file", ",", "index", ",", "'T'", ")", ";", "fputs", "(", "\".w\"", ",", "file", ")", ";", "break", ";", "case", "4", ":", "h8300_print_operand", "(", "file", ",", "index", ",", "'S'", ")", ";", "fputs", "(", "\".l\"", ",", "file", ")", ";", "break", ";", "}", "}", "else", "{", "h8300_print_operand_address", "(", "file", ",", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"+\"", ")", ";", "h8300_print_operand_address", "(", "file", ",", "XEXP", "(", "addr", ",", "1", ")", ")", ";", "}", "fprintf", "(", "file", ",", "\")\"", ")", ";", "break", ";", "case", "CONST_INT", ":", "{", "int", "n", "=", "INTVAL", "(", "addr", ")", ";", "if", "(", "TARGET_H8300", ")", "n", "=", "(", "int", ")", "(", "short", ")", "n", ";", "fprintf", "(", "file", ",", "\"%d\"", ",", "n", ")", ";", "break", ";", "}", "default", ":", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Output", "assembly", "language", "output", "for", "the", "address", "ADDR", "to", "FILE", "." ]

[ "h8300", "\"%s\"", "\"-%s\"", "0", "\"%s+\"", "0", "\"+%s\"", "0", "\"%s-\"", "0", "\"(\"", "0", "1", "\",\"", "0", "1", "\".b\"", "2", "\".w\"", "4", "\".l\"", "0", "\"+\"", "1", "\")\"", "\"%d\"" ]

[]

[ "<s>", "int", "cr16_operand_bit_pos", "(", "int", "val", ",", "int", "bitval", ")", "{", "int", "i", ";", "if", "(", "bitval", "==", "0", ")", "val", "=", "~", "val", ";", "for", "(", "i", "=", "0", ";", "i", "<", "16", ";", "i", "++", ")", "if", "(", "val", "&", "(", "1", "<<", "i", ")", ")", "break", ";", "return", "i", ";", "}", "</s>" ]

[ "Returns", "bit", "position", "of", "first", "0", "or", "1", "bit", ".", "It", "is", "safe", "to", "assume", "val", "as", "16-bit", "wide", "." ]

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

[]

[ "<s>", "SDValue", "CAHPTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "IsVarArg", ")", "{", "report_fatal_error", "(", "\"VarArg not supported\"", ")", ";", "}", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_CAHP", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "{", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "CAHPISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "CAHP", "CAHP", "ISD::OutputArg", "\"VarArg not supported\"", "16", "CAHP", "4", "1", "0", "\"Can only return in registers!\"", "1", "0", "CAHPISD::RET_FLAG", "MVT::Other" ]

[]

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

[ "Implement", "EH_RETURN_HANDLER_RTX", ".", "EH", "returns", "need", "to", "either", "return", "normally", "or", "return", "to", "a", "previous", "frame", "after", "unwinding", ".", "An", "EH", "return", "uses", "a", "single", "shared", "return", "sequence", ".", "The", "epilogue", "is", "exactly", "like", "a", "normal", "epilogue", "except", "that", "it", "has", "an", "extra", "input", "register", "(", "EH_RETURN_STACKADJ_RTX", ")", "which", "contains", "the", "stack", "adjustment", "that", "must", "be", "applied", "after", "the", "frame", "has", "been", "destroyed", ".", "An", "extra", "label", "is", "inserted", "before", "the", "epilogue", "which", "initializes", "this", "register", "to", "zero", ",", "and", "this", "is", "the", "entry", "point", "for", "a", "normal", "return", ".", "An", "actual", "EH", "return", "updates", "the", "return", "address", ",", "initializes", "the", "stack", "adjustment", "and", "jumps", "directly", "into", "the", "epilogue", "(", "bypassing", "the", "zeroing", "of", "the", "adjustment", ")", ".", "Since", "the", "return", "address", "is", "typically", "saved", "on", "the", "stack", "when", "a", "function", "makes", "a", "call", ",", "the", "saved", "LR", "must", "be", "updated", "outside", "the", "epilogue", ".", "This", "poses", "problems", "as", "the", "store", "is", "generated", "well", "before", "the", "epilogue", ",", "so", "the", "offset", "of", "LR", "is", "not", "known", "yet", ".", "Also", "optimizations", "will", "remove", "the", "store", "as", "it", "appears", "dead", ",", "even", "after", "the", "epilogue", "is", "generated", "(", "as", "the", "base", "or", "offset", "for", "loading", "LR", "is", "different", "in", "many", "cases", ")", ".", "To", "avoid", "these", "problems", "this", "implementation", "forces", "the", "frame", "pointer", "in", "eh_return", "functions", "so", "that", "the", "location", "of", "LR", "is", "fixed", "and", "known", "early", ".", "It", "also", "marks", "the", "store", "volatile", ",", "so", "no", "optimization", "is", "permitted", "to", "remove", "the", "store", "." ]

[ "aarch64" ]

[]

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

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

[ "Patmos", "Patmos", "ISD::OutputArg", "16", "Patmos", "4", "1", "0", "\"Can only return in registers!\"", "1", "PatmosISD::RET_FLAG", "0", "MVT::Other", "0" ]

[]

[ "<s>", "static", "void", "gen_ashift", "(", "int", "type", ",", "int", "n", ",", "rtx", "reg", ")", "{", "rtx", "n_rtx", ";", "if", "(", "n", "<", "0", ")", "{", "if", "(", "type", "==", "ASHIFT", ")", "type", "=", "LSHIFTRT", ";", "else", "type", "=", "ASHIFT", ";", "n", "=", "-", "n", ";", "}", "n_rtx", "=", "GEN_INT", "(", "n", ")", ";", "gcc_assert", "(", "satisfies_constraint_P27", "(", "n_rtx", ")", ")", ";", "switch", "(", "type", ")", "{", "case", "ASHIFTRT", ":", "emit_insn", "(", "gen_ashrsi3_k", "(", "reg", ",", "reg", ",", "n_rtx", ")", ")", ";", "break", ";", "case", "LSHIFTRT", ":", "if", "(", "n", "==", "1", ")", "emit_insn", "(", "gen_shlr", "(", "reg", ",", "reg", ")", ")", ";", "else", "emit_insn", "(", "gen_lshrsi3_k", "(", "reg", ",", "reg", ",", "n_rtx", ")", ")", ";", "break", ";", "case", "ASHIFT", ":", "emit_insn", "(", "gen_ashlsi3_k", "(", "reg", ",", "reg", ",", "n_rtx", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Code", "to", "expand", "a", "shift", "." ]

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

[]

[ "<s>", "void", "i386_pe_record_external_function", "(", "tree", "decl", ",", "const", "char", "*", "name", ")", "{", "struct", "extern_list", "*", "p", ";", "p", "=", "ggc_alloc", "<", "extern_list", ">", "(", ")", ";", "p", "->", "next", "=", "extern_head", ";", "p", "->", "decl", "=", "decl", ";", "p", "->", "name", "=", "name", ";", "extern_head", "=", "p", ";", "}", "</s>" ]

[ "Assemble", "an", "external", "function", "reference", ".", "We", "need", "to", "keep", "a", "list", "of", "these", ",", "so", "that", "we", "can", "output", "the", "function", "types", "at", "the", "end", "of", "the", "assembly", ".", "We", "ca", "n't", "output", "the", "types", "now", ",", "because", "we", "might", "see", "a", "definition", "of", "the", "function", "later", "on", "and", "emit", "debugging", "information", "for", "it", "then", "." ]

[ "i386" ]

[]

[ "<s>", "static", "rtx", "aarch64_strip_extend", "(", "rtx", "x", ",", "bool", "strip_shift", ")", "{", "scalar_int_mode", "mode", ";", "rtx", "op", "=", "x", ";", "if", "(", "!", "is_a", "<", "scalar_int_mode", ">", "(", "GET_MODE", "(", "op", ")", ",", "&", "mode", ")", ")", "return", "op", ";", "if", "(", "(", "GET_CODE", "(", "op", ")", "==", "ZERO_EXTRACT", "||", "GET_CODE", "(", "op", ")", "==", "SIGN_EXTRACT", ")", "&&", "XEXP", "(", "op", ",", "2", ")", "==", "const0_rtx", "&&", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "MULT", "&&", "aarch64_is_extend_from_extract", "(", "mode", ",", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ",", "XEXP", "(", "op", ",", "1", ")", ")", ")", "return", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "AND", "&&", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "MULT", "&&", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", "&&", "aarch64_uxt_size", "(", "exact_log2", "(", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", ")", ",", "INTVAL", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "!=", "0", ")", "return", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ";", "if", "(", "strip_shift", "&&", "GET_CODE", "(", "op", ")", "==", "ASHIFT", "&&", "CONST_INT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", "&&", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "INTVAL", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "<=", "4", ")", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "ZERO_EXTEND", "||", "GET_CODE", "(", "op", ")", "==", "SIGN_EXTEND", ")", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "op", "!=", "x", ")", "return", "op", ";", "return", "x", ";", "}", "</s>" ]

[ "Helper", "function", "for", "rtx", "cost", "calculation", ".", "Strip", "an", "extend", "expression", "from", "X", ".", "Returns", "the", "inner", "operand", "if", "successful", ",", "or", "the", "original", "expression", "on", "failure", ".", "We", "deal", "with", "a", "number", "of", "possible", "canonicalization", "variations", "here", "." ]

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

[]

[ "<s>", "bool", "nds32_n9_3r2w_mm_to_ex_p", "(", "rtx_insn", "*", "producer", ",", "rtx_insn", "*", "consumer", ")", "{", "rtx", "def_reg", ";", "switch", "(", "get_attr_type", "(", "producer", ")", ")", "{", "case", "TYPE_LOAD", ":", "case", "TYPE_MUL", ":", "case", "TYPE_MAC", ":", "def_reg", "=", "SET_DEST", "(", "PATTERN", "(", "producer", ")", ")", ";", "break", ";", "case", "TYPE_DIV", ":", "if", "(", "divmod_p", "(", "producer", ")", ")", "{", "rtx", "def_reg1", "=", "SET_DEST", "(", "parallel_element", "(", "producer", ",", "0", ")", ")", ";", "rtx", "def_reg2", "=", "SET_DEST", "(", "parallel_element", "(", "producer", ",", "1", ")", ")", ";", "return", "(", "n9_3r2w_consumed_by_ex_dep_p", "(", "consumer", ",", "def_reg1", ")", "||", "n9_3r2w_consumed_by_ex_dep_p", "(", "consumer", ",", "def_reg2", ")", ")", ";", "}", "def_reg", "=", "SET_DEST", "(", "PATTERN", "(", "producer", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "n9_3r2w_consumed_by_ex_dep_p", "(", "consumer", ",", "def_reg", ")", ";", "}", "</s>" ]

[ "Check", "dependencies", "from", "MM", "to", "EX", "." ]

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

[]

[ "<s>", "Register", "OutgoingValueHandler", "::", "getStackAddress", "(", "const", "CCValAssign", "&", "VA", ",", "MachineMemOperand", "*", "&", "MMO", ")", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFL", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "LLT", "p0", "=", "LLT", "::", "pointer", "(", "0", ",", "32", ")", ";", "LLT", "s32", "=", "LLT", "::", "scalar", "(", "32", ")", ";", "auto", "SPReg", "=", "MIRBuilder", ".", "buildCopy", "(", "p0", ",", "Register", "(", "Mips", "::", "SP", ")", ")", ";", "unsigned", "Offset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "auto", "OffsetReg", "=", "MIRBuilder", ".", "buildConstant", "(", "s32", ",", "Offset", ")", ";", "auto", "AddrReg", "=", "MIRBuilder", ".", "buildPtrAdd", "(", "p0", ",", "SPReg", ",", "OffsetReg", ")", ";", "MachinePointerInfo", "MPO", "=", "MachinePointerInfo", "::", "getStack", "(", "MIRBuilder", ".", "getMF", "(", ")", ",", "Offset", ")", ";", "unsigned", "Size", "=", "alignTo", "(", "VA", ".", "getValVT", "(", ")", ".", "getSizeInBits", "(", ")", ",", "8", ")", "/", "8", ";", "Align", "Alignment", "=", "commonAlignment", "(", "TFL", "->", "getStackAlign", "(", ")", ",", "Offset", ")", ";", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MPO", ",", "MachineMemOperand", "::", "MOStore", ",", "Size", ",", "Alignment", ")", ";", "return", "AddrReg", ".", "getReg", "(", "0", ")", ";", "}", "</s>" ]

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

[ "Mips", "0", "32", "32", "Mips::SP", "8", "8", "0" ]

[]

[ "<s>", "void", "MOSFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "MF", ".", "getRegInfo", "(", ")", ".", "getTargetRegisterInfo", "(", ")", ";", "MachineIRBuilder", "Builder", "(", "MBB", ",", "MBB", ".", "getFirstTerminator", "(", ")", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "auto", "MBBI", "=", "find_if_not", "(", "mbb_reverse", "(", "MBB", ".", "begin", "(", ")", ",", "Builder", ".", "getInsertPt", "(", ")", ")", ",", "[", "]", "(", "const", "MachineInstr", "&", "MI", ")", "{", "return", "MI", ".", "getFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", ")", ";", "Builder", ".", "setInsertPt", "(", "MBB", ",", "MachineBasicBlock", "::", "iterator", "(", "MBBI", ")", ")", ";", "Builder", ".", "buildCopy", "(", "MOS", "::", "RS0", ",", "TRI", ".", "getFrameRegister", "(", "MF", ")", ")", ";", "Builder", ".", "setInsertPt", "(", "MBB", ",", "MBB", ".", "getFirstTerminator", "(", ")", ")", ";", "}", "int64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "isISR", "(", "MF", ")", ")", "StackSize", "+=", "256", ";", "if", "(", "StackSize", ")", "offsetSP", "(", "Builder", ",", "StackSize", ")", ";", "}", "</s>" ]

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

[ "MOS", "MOS", "MOS::RS0", "256" ]

[]

[ "<s>", "unsigned", "MipsTargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", "VT", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "Subtarget", ".", "isGP64bit", "(", ")", ")", "{", "unsigned", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"$28\"", ",", "Mips", "::", "GP_64", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "}", "else", "{", "unsigned", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"$28\"", ",", "Mips", "::", "GP", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "}", "report_fatal_error", "(", "\"Invalid register name global variable\"", ")", ";", "}", "</s>" ]

[ "Return", "the", "register", "ID", "of", "the", "name", "passed", "in", "." ]

[ "Mips", "Mips", "\"$28\"", "Mips::GP_64", "0", "\"$28\"", "Mips::GP", "0", "\"Invalid register name global variable\"" ]

[]

[ "<s>", "XCoreTargetMachine", "::", "XCoreTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ")", ":", "LLVMTargetMachine", "(", "T", ",", "\"e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32-f64:32-a:0:32-n32\"", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "RM", ")", ",", "getEffectiveXCoreCodeModel", "(", "CM", ")", ",", "OL", ")", ",", "TLOF", "(", "std", "::", "make_unique", "<", "XCoreTargetObjectFile", ">", "(", ")", ")", ",", "Subtarget", "(", "TT", ",", "std", "::", "string", "(", "CPU", ")", ",", "std", "::", "string", "(", "FS", ")", ",", "*", "this", ")", "{", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore", "\"e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32-f64:32-a:0:32-n32\"", "XCore", "XCore" ]

[]

[ "<s>", "bool", "NVVMIntrRange", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "bool", "Changed", "=", "false", ";", "for", "(", "Instruction", "&", "I", ":", "instructions", "(", "F", ")", ")", "{", "CallInst", "*", "Call", "=", "dyn_cast", "<", "CallInst", ">", "(", "&", "I", ")", ";", "if", "(", "!", "Call", ")", "continue", ";", "if", "(", "Function", "*", "Callee", "=", "Call", "->", "getCalledFunction", "(", ")", ")", "{", "switch", "(", "Callee", "->", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "nvvm_read_ptx_sreg_tid_x", ":", "Changed", "|=", "addRangeMetadata", "(", "0", ",", "MaxBlockSize", ".", "x", ",", "Call", ")", ";", "break", ";", "case", "Intrinsic", "::", "nvvm_read_ptx_sreg_tid_y", ":", "Changed", "|=", "addRangeMetadata", "(", "0", ",", "MaxBlockSize", ".", "y", ",", "Call", ")", ";", "break", ";", "case", "Intrinsic", "::", "nvvm_read_ptx_sreg_tid_z", ":", "Changed", "|=", "addRangeMetadata", "(", "0", ",", "MaxBlockSize", ".", "z", ",", "Call", ")", ";", "break", ";", "case", "Intrinsic", "::", "nvvm_read_ptx_sreg_ntid_x", ":", "Changed", "|=", "addRangeMetadata", "(", "1", ",", "MaxBlockSize", ".", "x", "+", "1", ",", "Call", ")", ";", "break", ";", "case", "Intrinsic", "::", "nvvm_read_ptx_sreg_ntid_y", ":", "Changed", "|=", "addRangeMetadata", "(", "1", ",", "MaxBlockSize", ".", "y", "+", "1", ",", "Call", ")", ";", "break", ";", "case", "Intrinsic", "::", "nvvm_read_ptx_sreg_ntid_z", ":", "Changed", "|=", "addRangeMetadata", "(", "1", ",", "MaxBlockSize", ".", "z", "+", "1", ",", "Call", ")", ";", "break", ";", "case", "Intrinsic", "::", "nvvm_read_ptx_sreg_ctaid_x", ":", "Changed", "|=", "addRangeMetadata", "(", "0", ",", "MaxGridSize", ".", "x", ",", "Call", ")", ";", "break", ";", "case", "Intrinsic", "::", "nvvm_read_ptx_sreg_ctaid_y", ":", "Changed", "|=", "addRangeMetadata", "(", "0", ",", "MaxGridSize", ".", "y", ",", "Call", ")", ";", "break", ";", "case", "Intrinsic", "::", "nvvm_read_ptx_sreg_ctaid_z", ":", "Changed", "|=", "addRangeMetadata", "(", "0", ",", "MaxGridSize", ".", "z", ",", "Call", ")", ";", "break", ";", "case", "Intrinsic", "::", "nvvm_read_ptx_sreg_nctaid_x", ":", "Changed", "|=", "addRangeMetadata", "(", "1", ",", "MaxGridSize", ".", "x", "+", "1", ",", "Call", ")", ";", "break", ";", "case", "Intrinsic", "::", "nvvm_read_ptx_sreg_nctaid_y", ":", "Changed", "|=", "addRangeMetadata", "(", "1", ",", "MaxGridSize", ".", "y", "+", "1", ",", "Call", ")", ";", "break", ";", "case", "Intrinsic", "::", "nvvm_read_ptx_sreg_nctaid_z", ":", "Changed", "|=", "addRangeMetadata", "(", "1", ",", "MaxGridSize", ".", "z", "+", "1", ",", "Call", ")", ";", "break", ";", "case", "Intrinsic", "::", "nvvm_read_ptx_sreg_warpsize", ":", "Changed", "|=", "addRangeMetadata", "(", "32", ",", "32", "+", "1", ",", "Call", ")", ";", "break", ";", "case", "Intrinsic", "::", "nvvm_read_ptx_sreg_laneid", ":", "Changed", "|=", "addRangeMetadata", "(", "0", ",", "32", ",", "Call", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "NVPTX", "Intrinsic::nvvm_read_ptx_sreg_tid_x", "0", "Intrinsic::nvvm_read_ptx_sreg_tid_y", "0", "Intrinsic::nvvm_read_ptx_sreg_tid_z", "0", "Intrinsic::nvvm_read_ptx_sreg_ntid_x", "1", "1", "Intrinsic::nvvm_read_ptx_sreg_ntid_y", "1", "1", "Intrinsic::nvvm_read_ptx_sreg_ntid_z", "1", "1", "Intrinsic::nvvm_read_ptx_sreg_ctaid_x", "0", "Intrinsic::nvvm_read_ptx_sreg_ctaid_y", "0", "Intrinsic::nvvm_read_ptx_sreg_ctaid_z", "0", "Intrinsic::nvvm_read_ptx_sreg_nctaid_x", "1", "1", "Intrinsic::nvvm_read_ptx_sreg_nctaid_y", "1", "1", "Intrinsic::nvvm_read_ptx_sreg_nctaid_z", "1", "1", "Intrinsic::nvvm_read_ptx_sreg_warpsize", "32", "32", "1", "Intrinsic::nvvm_read_ptx_sreg_laneid", "0", "32" ]

[]

[ "<s>", "static", "rtx", "aarch64_gen_unspec_cond", "(", "rtx_code", "code", ",", "machine_mode", "pred_mode", ",", "rtx", "pred", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtvec", "vec", "=", "gen_rtvec", "(", "3", ",", "pred", ",", "op0", ",", "op1", ")", ";", "return", "gen_rtx_UNSPEC", "(", "pred_mode", ",", "vec", ",", "aarch64_unspec_cond_code", "(", "code", ")", ")", ";", "}", "</s>" ]

[ "Return", "an", "(", "unspec", ":", "PRED_MODE", "[", "PRED", "OP0", "OP1", "]", "UNSPEC_COND_", "<", "X", ">", ")", "expression", ",", "where", "<", "X", ">", "is", "the", "operation", "associated", "with", "comparison", "CODE", "." ]

[ "aarch64", "3" ]

[]

[ "<s>", "void", "aarch64_split_compare_and_swap", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "rval", ",", "mem", ",", "oldval", ",", "newval", ",", "scratch", ";", "machine_mode", "mode", ";", "bool", "is_weak", ";", "rtx_code_label", "*", "label1", ",", "*", "label2", ";", "rtx", "x", ",", "cond", ";", "enum", "memmodel", "model", ";", "rtx", "model_rtx", ";", "rval", "=", "operands", "[", "0", "]", ";", "mem", "=", "operands", "[", "1", "]", ";", "oldval", "=", "operands", "[", "2", "]", ";", "newval", "=", "operands", "[", "3", "]", ";", "is_weak", "=", "(", "operands", "[", "4", "]", "!=", "const0_rtx", ")", ";", "model_rtx", "=", "operands", "[", "5", "]", ";", "scratch", "=", "operands", "[", "7", "]", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "model", "=", "memmodel_from_int", "(", "INTVAL", "(", "model_rtx", ")", ")", ";", "bool", "strong_zero_p", "=", "!", "is_weak", "&&", "oldval", "==", "const0_rtx", ";", "label1", "=", "NULL", ";", "if", "(", "!", "is_weak", ")", "{", "label1", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label1", ")", ";", "}", "label2", "=", "gen_label_rtx", "(", ")", ";", "if", "(", "is_mm_sync", "(", "model", ")", ")", "aarch64_emit_load_exclusive", "(", "mode", ",", "rval", ",", "mem", ",", "GEN_INT", "(", "MEMMODEL_RELAXED", ")", ")", ";", "else", "aarch64_emit_load_exclusive", "(", "mode", ",", "rval", ",", "mem", ",", "model_rtx", ")", ";", "if", "(", "strong_zero_p", ")", "{", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "rval", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "label2", ")", ",", "pc_rtx", ")", ";", "aarch64_emit_unlikely_jump", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";", "}", "else", "{", "cond", "=", "aarch64_gen_compare_reg", "(", "NE", ",", "rval", ",", "oldval", ")", ";", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cond", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "label2", ")", ",", "pc_rtx", ")", ";", "aarch64_emit_unlikely_jump", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";", "}", "aarch64_emit_store_exclusive", "(", "mode", ",", "scratch", ",", "mem", ",", "newval", ",", "model_rtx", ")", ";", "if", "(", "!", "is_weak", ")", "{", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "scratch", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "label1", ")", ",", "pc_rtx", ")", ";", "aarch64_emit_unlikely_jump", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";", "}", "else", "{", "cond", "=", "gen_rtx_REG", "(", "CCmode", ",", "CC_REGNUM", ")", ";", "x", "=", "gen_rtx_COMPARE", "(", "CCmode", ",", "scratch", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "cond", ",", "x", ")", ")", ";", "}", "emit_label", "(", "label2", ")", ";", "if", "(", "strong_zero_p", ")", "{", "cond", "=", "gen_rtx_REG", "(", "CCmode", ",", "CC_REGNUM", ")", ";", "x", "=", "gen_rtx_COMPARE", "(", "CCmode", ",", "rval", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "cond", ",", "x", ")", ")", ";", "}", "if", "(", "is_mm_sync", "(", "model", ")", ")", "aarch64_emit_post_barrier", "(", "model", ")", ";", "}", "</s>" ]

[ "Split", "a", "compare", "and", "swap", "pattern", "." ]

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

[]

[ "<s>", "std", "::", "unique_ptr", "<", "MCObjectWriter", ">", "MipsAsmBackend", "::", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "{", "return", "createMipsELFObjectWriter", "(", "OS", ",", "TheTriple", ",", "IsN32", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "AArch64AsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "if", "(", "Kind", ">=", "FirstLiteralRelocationKind", ")", "return", ";", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Kind", ")", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "MCContext", "&", "Ctx", "=", "Asm", ".", "getContext", "(", ")", ";", "int64_t", "SignedValue", "=", "static_cast", "<", "int64_t", ">", "(", "Value", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Target", ",", "Value", ",", "Ctx", ",", "TheTriple", ",", "IsResolved", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "unsigned", "FulleSizeInBytes", "=", "getFixupKindContainereSizeInBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "if", "(", "FulleSizeInBytes", "==", "0", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "else", "{", "assert", "(", "(", "Offset", "+", "FulleSizeInBytes", ")", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup size!\"", ")", ";", "assert", "(", "NumBytes", "<=", "FulleSizeInBytes", "&&", "\"Invalid fixup size!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "FulleSizeInBytes", "-", "1", "-", "i", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "AArch64MCExpr", "::", "VariantKind", "RefKind", "=", "static_cast", "<", "AArch64MCExpr", "::", "VariantKind", ">", "(", "Target", ".", "getRefKind", "(", ")", ")", ";", "if", "(", "AArch64MCExpr", "::", "getSymbolLoc", "(", "RefKind", ")", "==", "AArch64MCExpr", "::", "VK_SABS", ")", "{", "if", "(", "SignedValue", "<", "0", ")", "Data", "[", "Offset", "+", "3", "]", "&=", "~", "(", "1", "<<", "6", ")", ";", "else", "Data", "[", "Offset", "+", "3", "]", "|=", "(", "1", "<<", "6", ")", ";", "}", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "AArch64", "AArch64", "\"Invalid fixup offset!\"", "0", "0", "8", "0xff", "\"Invalid fixup size!\"", "\"Invalid fixup size!\"", "0", "1", "8", "0xff", "AArch64", "AArch64", "AArch64", "AArch64", "0", "3", "1", "6", "3", "1", "6" ]

[]

[ "<s>", "const", "char", "*", "LanaiTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "LanaiISD", "::", "ADJDYNALLOC", ":", "return", "\"LanaiISD::ADJDYNALLOC\"", ";", "case", "LanaiISD", "::", "RET_FLAG", ":", "return", "\"LanaiISD::RET_FLAG\"", ";", "case", "LanaiISD", "::", "CALL", ":", "return", "\"LanaiISD::CALL\"", ";", "case", "LanaiISD", "::", "SELECT_CC", ":", "return", "\"LanaiISD::SELECT_CC\"", ";", "case", "LanaiISD", "::", "SETCC", ":", "return", "\"LanaiISD::SETCC\"", ";", "case", "LanaiISD", "::", "SUBBF", ":", "return", "\"LanaiISD::SUBBF\"", ";", "case", "LanaiISD", "::", "SET_FLAG", ":", "return", "\"LanaiISD::SET_FLAG\"", ";", "case", "LanaiISD", "::", "BR_CC", ":", "return", "\"LanaiISD::BR_CC\"", ";", "case", "LanaiISD", "::", "Wrapper", ":", "return", "\"LanaiISD::Wrapper\"", ";", "case", "LanaiISD", "::", "HI", ":", "return", "\"LanaiISD::HI\"", ";", "case", "LanaiISD", "::", "LO", ":", "return", "\"LanaiISD::LO\"", ";", "case", "LanaiISD", "::", "SMALL", ":", "return", "\"LanaiISD::SMALL\"", ";", "default", ":", "return", "nullptr", ";", "}", "}", "</s>" ]

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

[ "Lanai", "Lanai", "LanaiISD::ADJDYNALLOC", "\"LanaiISD::ADJDYNALLOC\"", "LanaiISD::RET_FLAG", "\"LanaiISD::RET_FLAG\"", "LanaiISD::CALL", "\"LanaiISD::CALL\"", "LanaiISD::SELECT_CC", "\"LanaiISD::SELECT_CC\"", "LanaiISD::SETCC", "\"LanaiISD::SETCC\"", "LanaiISD::SUBBF", "\"LanaiISD::SUBBF\"", "LanaiISD::SET_FLAG", "\"LanaiISD::SET_FLAG\"", "LanaiISD::BR_CC", "\"LanaiISD::BR_CC\"", "LanaiISD::Wrapper", "\"LanaiISD::Wrapper\"", "LanaiISD::HI", "\"LanaiISD::HI\"", "LanaiISD::LO", "\"LanaiISD::LO\"", "LanaiISD::SMALL", "\"LanaiISD::SMALL\"" ]

[]

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

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

[ "AMDGPU", "SI", "1", "MVT::i16" ]

[]

[ "<s>", "bool", "ARMAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "bool", "Result", "=", "AsmPrinter", "::", "doInitialization", "(", "M", ")", ";", "MMI", "=", "getAnalysisIfAvailable", "<", "MachineModuleInfo", ">", "(", ")", ";", "assert", "(", "MMI", ")", ";", "DW", "=", "getAnalysisIfAvailable", "<", "DwarfWriter", ">", "(", ")", ";", "assert", "(", "DW", "&&", "\"Dwarf Writer is not available\"", ")", ";", "DW", "->", "BeginModule", "(", "&", "M", ",", "MMI", ",", "O", ",", "this", ",", "TAI", ")", ";", "if", "(", "Subtarget", "->", "isTargetDarwin", "(", ")", ")", "Mang", "->", "setUseQuotes", "(", "true", ")", ";", "return", "Result", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "ARM", "ARM", "\"Dwarf Writer is not available\"" ]

[]

[ "<s>", "bool", "Z80RegisterInfo", "::", "saveScavengerRegister", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "MachineBasicBlock", "::", "iterator", "&", "UseMI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Reg", ")", "const", "{", "return", "false", ";", "const", "Z80Subtarget", "&", "STI", "=", "MBB", ".", "getParent", "(", ")", "->", "getSubtarget", "<", "Z80Subtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "Reg", "==", "Z80", "::", "AF", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Is24Bit", "?", "Z80", "::", "PUSH24AF", ":", "Z80", "::", "PUSH16AF", ")", ")", ";", "else", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Is24Bit", "?", "Z80", "::", "PUSH24r", ":", "Z80", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "Reg", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "II", "=", "MI", ";", "II", "!=", "UseMI", ";", "++", "II", ")", "{", "if", "(", "II", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "II", "->", "modifiesRegister", "(", "Reg", ",", "TRI", ")", ")", "UseMI", "=", "II", ";", "}", "if", "(", "Reg", "==", "Z80", "::", "AF", ")", "BuildMI", "(", "MBB", ",", "UseMI", ",", "DL", ",", "TII", ".", "get", "(", "Is24Bit", "?", "Z80", "::", "POP24AF", ":", "Z80", "::", "POP16AF", ")", ")", ";", "else", "BuildMI", "(", "MBB", ",", "UseMI", ",", "DL", ",", "TII", ".", "get", "(", "Is24Bit", "?", "Z80", "::", "POP24r", ":", "Z80", "::", "POP16r", ")", ",", "Reg", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Spill", "the", "register", "so", "it", "can", "be", "used", "by", "the", "register", "scavenger", "." ]

[ "Z80", "Z80", "Z80", "Z80", "Z80::AF", "Z80::PUSH24AF", "Z80::PUSH16AF", "Z80::PUSH24r", "Z80::PUSH16r", "Z80::AF", "Z80::POP24AF", "Z80::POP16AF", "Z80::POP24r", "Z80::POP16r" ]

[]

[ "<s>", "void", "PPCDispatchGroupSBHazardRecognizer", "::", "EmitNoop", "(", ")", "{", "unsigned", "Directive", "=", "DAG", "->", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getCPUDirective", "(", ")", ";", "if", "(", "Directive", "==", "PPC", "::", "DIR_PWR6", "||", "Directive", "==", "PPC", "::", "DIR_PWR7", "||", "Directive", "==", "PPC", "::", "DIR_PWR8", "||", "Directive", "==", "PPC", "::", "DIR_PWR9", "||", "CurSlots", "==", "6", ")", "{", "CurGroup", ".", "clear", "(", ")", ";", "CurSlots", "=", "CurBranches", "=", "0", ";", "}", "else", "{", "CurGroup", ".", "push_back", "(", "nullptr", ")", ";", "++", "CurSlots", ";", "}", "}", "</s>" ]

[ "EmitNoop", "-", "This", "callback", "is", "invoked", "when", "a", "noop", "was", "added", "to", "the", "instruction", "stream", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::DIR_PWR6", "PPC::DIR_PWR7", "PPC::DIR_PWR8", "PPC::DIR_PWR9", "6", "0" ]

[]

[ "<s>", "static", "inline", "hashval_t", "hash", "(", "tree_map", "*", "m", ")", "{", "return", "m", "->", "hash", ";", "}", "</s>" ]

[ "Hash", "function", "for", "builtin", "functions", "with", "up", "to", "3", "arguments", "and", "a", "return", "type", "." ]

[ "i386" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"ARM A15 S->D optimizer\"", ";", "}", "</s>" ]

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

[ "ARM", "\"ARM A15 S->D optimizer\"" ]

[]

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

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

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

[]

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

[ "Returns", "true", "if", "the", "target", "requires", "post", "PEI", "scavenging", "of", "registers", "for", "materializing", "frame", "index", "constants", "." ]

[ "PowerPC" ]

[]

[ "<s>", "bool", "aarch64_uimm12_shift", "(", "HOST_WIDE_INT", "val", ")", "{", "return", "(", "(", "val", "&", "(", "(", "(", "HOST_WIDE_INT", ")", "0xfff", ")", "<<", "0", ")", ")", "==", "val", "||", "(", "val", "&", "(", "(", "(", "HOST_WIDE_INT", ")", "0xfff", ")", "<<", "12", ")", ")", "==", "val", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "val", "can", "be", "encoded", "as", "a", "12-bit", "unsigned", "immediate", "with", "a", "left", "shift", "of", "0", "or", "12", "bits", "." ]

[ "aarch64", "0xfff", "0", "0xfff", "12" ]

[]

[ "<s>", "bool", "FalkorMarkStridedAccessesLegacy", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "TargetPassConfig", "&", "TPC", "=", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "const", "AArch64Subtarget", "*", "ST", "=", "TPC", ".", "getTM", "<", "AArch64TargetMachine", ">", "(", ")", ".", "getSubtargetImpl", "(", "F", ")", ";", "if", "(", "ST", "->", "getProcFamily", "(", ")", "!=", "AArch64Subtarget", "::", "Falkor", ")", "return", "false", ";", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "LoopInfo", "&", "LI", "=", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "ScalarEvolution", "&", "SE", "=", "getAnalysis", "<", "ScalarEvolutionWrapperPass", ">", "(", ")", ".", "getSE", "(", ")", ";", "FalkorMarkStridedAccesses", "LDP", "(", "LI", ",", "SE", ")", ";", "return", "LDP", ".", "run", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "compute_a_shift_cc", "(", "rtx", "insn", "ATTRIBUTE_UNUSED", ",", "rtx", "*", "operands", ")", "{", "rtx", "shift", "=", "operands", "[", "3", "]", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "shift", ")", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "shift", ")", ";", "enum", "shift_type", "shift_type", ";", "enum", "shift_mode", "shift_mode", ";", "struct", "shift_info", "info", ";", "int", "n", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "shift_mode", "=", "QIshift", ";", "break", ";", "case", "E_HImode", ":", "shift_mode", "=", "HIshift", ";", "break", ";", "case", "E_SImode", ":", "shift_mode", "=", "SIshift", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "code", ")", "{", "case", "ASHIFTRT", ":", "shift_type", "=", "SHIFT_ASHIFTRT", ";", "break", ";", "case", "LSHIFTRT", ":", "shift_type", "=", "SHIFT_LSHIFTRT", ";", "break", ";", "case", "ASHIFT", ":", "shift_type", "=", "SHIFT_ASHIFT", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", ";", "n", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "n", "<", "0", ")", "n", "=", "0", ";", "else", "if", "(", "(", "unsigned", "int", ")", "n", ">", "GET_MODE_BITSIZE", "(", "mode", ")", ")", "n", "=", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "get_shift_alg", "(", "shift_type", ",", "shift_mode", ",", "n", ",", "&", "info", ")", ";", "switch", "(", "info", ".", "alg", ")", "{", "case", "SHIFT_SPECIAL", ":", "if", "(", "info", ".", "remainder", "==", "0", ")", "return", "info", ".", "cc_special", ";", "case", "SHIFT_INLINE", ":", "return", "info", ".", "cc_inline", ";", "case", "SHIFT_ROT_AND", ":", "return", "OLD_CC_SET_ZNV", ";", "case", "SHIFT_LOOP", ":", "if", "(", "info", ".", "shift2", "!=", "NULL", ")", "{", "if", "(", "n", "%", "2", ")", "return", "info", ".", "cc_inline", ";", "}", "return", "OLD_CC_CLOBBER", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Compute", "which", "flag", "bits", "are", "valid", "after", "a", "shift", "insn", "." ]

[ "h8300", "3", "2", "2", "0", "0", "0", "2" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "PPCRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "if", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AnyReg", ")", "{", "if", "(", "Subtarget", ".", "hasVSX", "(", ")", ")", "return", "CSR_64_AllRegs_VSX_SaveList", ";", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "CSR_64_AllRegs_Altivec_SaveList", ";", "return", "CSR_64_AllRegs_SaveList", ";", "}", "if", "(", "Subtarget", ".", "isDarwinABI", "(", ")", ")", "return", "Subtarget", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_Darwin64_Altivec_SaveList", ":", "CSR_Darwin64_SaveList", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_Darwin32_Altivec_SaveList", ":", "CSR_Darwin32_SaveList", ")", ";", "return", "Subtarget", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR464_Altivec_SaveList", ":", "CSR_SVR464_SaveList", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR432_Altivec_SaveList", ":", "CSR_SVR432_SaveList", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "static", "void", "adjust_extract", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "PARALLEL", ")", "pattern", "=", "XVECEXP", "(", "pattern", ",", "0", ",", "0", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pattern", ")", ";", "rtx", "sel", "=", "GET_CODE", "(", "src", ")", "==", "VEC_DUPLICATE", "?", "XEXP", "(", "src", ",", "0", ")", ":", "src", ";", "rtx", "par", "=", "XEXP", "(", "sel", ",", "1", ")", ";", "int", "half_elts", "=", "GET_MODE_NUNITS", "(", "GET_MODE", "(", "XEXP", "(", "sel", ",", "0", ")", ")", ")", ">>", "1", ";", "int", "lane", "=", "INTVAL", "(", "XVECEXP", "(", "par", ",", "0", ",", "0", ")", ")", ";", "lane", "=", "lane", ">=", "half_elts", "?", "lane", "-", "half_elts", ":", "lane", "+", "half_elts", ";", "XVECEXP", "(", "par", ",", "0", ",", "0", ")", "=", "GEN_INT", "(", "lane", ")", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "df_insn_rescan", "(", "insn", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Changing lane for extract %d\\n\"", ",", "INSN_UID", "(", "insn", ")", ")", ";", "}", "</s>" ]

[ "Given", "OP", "that", "contains", "a", "vector", "extract", "operation", ",", "adjust", "the", "index", "of", "the", "extracted", "lane", "to", "account", "for", "the", "doubleword", "swap", "." ]

[ "rs6000", "0", "0", "0", "1", "0", "1", "0", "0", "0", "0", "1", "\"Changing lane for extract %d\\n\"" ]

[]

[ "<s>", "bool", "RISCVAsmBackend", "::", "shouldForceRelocation", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ")", "{", "switch", "(", "Fixup", ".", "getTargetKind", "(", ")", ")", "{", "default", ":", "break", ";", "case", "FK_Data_1", ":", "case", "FK_Data_2", ":", "case", "FK_Data_4", ":", "case", "FK_Data_8", ":", "if", "(", "Target", ".", "isAbsolute", "(", ")", ")", "return", "false", ";", "break", ";", "case", "RISCV", "::", "fixup_riscv_got_hi20", ":", "case", "RISCV", "::", "fixup_riscv_tls_got_hi20", ":", "case", "RISCV", "::", "fixup_riscv_tls_gd_hi20", ":", "return", "true", ";", "}", "return", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureRelax", "]", "||", "ForceRelocs", ";", "}", "</s>" ]

[ "Hook", "to", "check", "if", "a", "relocation", "is", "needed", "for", "some", "target", "specific", "reason", "." ]

[ "RISCV", "RISCV", "RISCV::fixup_riscv_got_hi20", "RISCV::fixup_riscv_tls_got_hi20", "RISCV::fixup_riscv_tls_gd_hi20", "RISCV::FeatureRelax" ]

[]

[ "<s>", "virtual", "bool", "isVerboseAsm", "(", ")", "const", "{", "return", "IsVerboseAsm", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "streamer", "supports", "verbose", "assembly", "and", "if", "it", "is", "enabled", "." ]

[ "PTX" ]

[]

[ "<s>", "void", "AlphaRegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "uint64_t", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "unsigned", "Align", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", "->", "getStackAlignment", "(", ")", ";", "Amount", "=", "(", "Amount", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "MachineInstr", "*", "New", ";", "if", "(", "Old", "->", "getOpcode", "(", ")", "==", "Alpha", "::", "ADJUSTSTACKDOWN", ")", "{", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Alpha", "::", "LDA", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "-", "Amount", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "}", "else", "{", "assert", "(", "Old", "->", "getOpcode", "(", ")", "==", "Alpha", "::", "ADJUSTSTACKUP", ")", ";", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Alpha", "::", "LDA", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "Amount", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "}", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "Alpha", "Alpha", "0", "0", "1", "Alpha::ADJUSTSTACKDOWN", "Alpha::LDA", "Alpha::R30", "Alpha::R30", "Alpha::ADJUSTSTACKUP", "Alpha::LDA", "Alpha::R30", "Alpha::R30" ]

[]

[ "<s>", "int", "mmix_legitimate_constant_p", "(", "rtx", "x", ")", "{", "RTX_CODE", "code", "=", "GET_CODE", "(", "x", ")", ";", "if", "(", "code", "==", "CONST_INT", "||", "code", "==", "CONST_DOUBLE", ")", "return", "1", ";", "return", "CONSTANT_ADDRESS_P", "(", "x", ")", ";", "}", "</s>" ]

[ "LEGITIMATE_CONSTANT_P", "." ]

[ "mmix", "1" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "hasStackProbeSymbol", "(", "MachineFunction", "&", "MF", ")", "const", "{", "return", "!", "getStackProbeSymbolName", "(", "MF", ")", ".", "empty", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "stack", "probing", "through", "a", "function", "call", "is", "requested", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "override", "{", "assert", "(", "isRegKind", "(", ")", ")", ";", "return", "Reg", ".", "RegNo", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]

[ "<s>", "bool", "AMDGPUSetWavePriority", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "unsigned", "HighPriority", "=", "3", ";", "const", "unsigned", "LowPriority", "=", "0", ";", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "skipFunction", "(", "F", ")", "||", "!", "AMDGPU", "::", "isEntryFunctionCC", "(", "F", ".", "getCallingConv", "(", ")", ")", ")", "return", "false", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MBBInfoSet", "MBBInfos", ";", "SmallVector", "<", "const", "MachineBasicBlock", "*", ",", "16", ">", "Worklist", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "if", "(", "any_of", "(", "MBB", ",", "isVMEMLoad", ")", ")", "Worklist", ".", "push_back", "(", "&", "MBB", ")", ";", "}", "while", "(", "!", "Worklist", ".", "empty", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "Worklist", ".", "pop_back_val", "(", ")", ";", "MBBInfo", "&", "Info", "=", "MBBInfos", "[", "MBB", "]", ";", "if", "(", "!", "Info", ".", "MayReachVMEMLoad", ")", "{", "Info", ".", "MayReachVMEMLoad", "=", "true", ";", "Worklist", ".", "append", "(", "MBB", "->", "pred_begin", "(", ")", ",", "MBB", "->", "pred_end", "(", ")", ")", ";", "}", "}", "MachineBasicBlock", "&", "Entry", "=", "MF", ".", "front", "(", ")", ";", "if", "(", "!", "MBBInfos", "[", "&", "Entry", "]", ".", "MayReachVMEMLoad", ")", "return", "false", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "Entry", ".", "begin", "(", ")", ",", "E", "=", "Entry", ".", "end", "(", ")", ";", "while", "(", "I", "!=", "E", "&&", "!", "SIInstrInfo", "::", "isVALU", "(", "*", "I", ")", "&&", "!", "I", "->", "isTerminator", "(", ")", ")", "++", "I", ";", "Entry", ".", "insert", "(", "I", ",", "BuildSetprioMI", "(", "MF", ",", "HighPriority", ")", ")", ";", "SmallSet", "<", "MachineBasicBlock", "*", ",", "16", ">", "PriorityLoweringBlocks", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "if", "(", "MBBInfos", "[", "&", "MBB", "]", ".", "MayReachVMEMLoad", ")", "{", "if", "(", "MBB", ".", "succ_empty", "(", ")", ")", "PriorityLoweringBlocks", ".", "insert", "(", "&", "MBB", ")", ";", "continue", ";", "}", "if", "(", "CanLowerPriorityDirectlyInPredecessors", "(", "MBB", ",", "MBBInfos", ")", ")", "{", "for", "(", "MachineBasicBlock", "*", "Pred", ":", "MBB", ".", "predecessors", "(", ")", ")", "{", "if", "(", "MBBInfos", "[", "Pred", "]", ".", "MayReachVMEMLoad", ")", "PriorityLoweringBlocks", ".", "insert", "(", "Pred", ")", ";", "}", "continue", ";", "}", "PriorityLoweringBlocks", ".", "insert", "(", "&", "MBB", ")", ";", "}", "for", "(", "MachineBasicBlock", "*", "MBB", ":", "PriorityLoweringBlocks", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", "->", "end", "(", ")", ",", "B", "=", "MBB", "->", "begin", "(", ")", ";", "while", "(", "I", "!=", "B", ")", "{", "if", "(", "isVMEMLoad", "(", "*", "--", "I", ")", ")", "{", "++", "I", ";", "break", ";", "}", "}", "MBB", "->", "insert", "(", "I", ",", "BuildSetprioMI", "(", "MF", ",", "LowPriority", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "3", "0", "AMDGPU::isEntryFunctionCC", "16", "SI", "16" ]

[]

[ "<s>", "bool", "AArch64DeadRegisterDefinitions", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64DeadRegisterDefinitions *****\\n\"", ")", ";", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "processMachineBasicBlock", "(", "MBB", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"***** AArch64DeadRegisterDefinitions *****\\n\"" ]

[]

[ "<s>", "static", "int", "sparc_arg_partial_bytes", "(", "cumulative_args_t", "cum", ",", "const", "function_arg_info", "&", "arg", ")", "{", "int", "slotno", ",", "regno", ",", "padding", ";", "slotno", "=", "function_arg_slotno", "(", "get_cumulative_args", "(", "cum", ")", ",", "arg", ".", "mode", ",", "arg", ".", "type", ",", "arg", ".", "named", ",", "false", ",", "&", "regno", ",", "&", "padding", ")", ";", "if", "(", "slotno", "==", "-", "1", ")", "return", "0", ";", "if", "(", "TARGET_ARCH32", ")", "{", "const", "int", "size", "=", "GET_MODE_SIZE", "(", "arg", ".", "mode", ")", ";", "if", "(", "size", ">", "UNITS_PER_WORD", "&&", "slotno", "==", "SPARC_INT_ARG_MAX", "-", "1", ")", "return", "UNITS_PER_WORD", ";", "}", "else", "{", "if", "(", "arg", ".", "aggregate_type_p", "(", ")", ")", "{", "const", "int", "size", "=", "int_size_in_bytes", "(", "arg", ".", "type", ")", ";", "if", "(", "size", ">", "UNITS_PER_WORD", "&&", "(", "slotno", "==", "SPARC_INT_ARG_MAX", "-", "1", "||", "slotno", "==", "SPARC_FP_ARG_MAX", "-", "1", ")", ")", "return", "UNITS_PER_WORD", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "arg", ".", "mode", ")", "==", "MODE_COMPLEX_INT", "||", "(", "(", "GET_MODE_CLASS", "(", "arg", ".", "mode", ")", "==", "MODE_COMPLEX_FLOAT", "||", "(", "arg", ".", "type", "&&", "VECTOR_TYPE_P", "(", "arg", ".", "type", ")", ")", ")", "&&", "!", "(", "TARGET_FPU", "&&", "arg", ".", "named", ")", ")", ")", "{", "const", "int", "size", "=", "(", "arg", ".", "type", "&&", "VECTOR_FLOAT_TYPE_P", "(", "arg", ".", "type", ")", ")", "?", "int_size_in_bytes", "(", "arg", ".", "type", ")", ":", "GET_MODE_SIZE", "(", "arg", ".", "mode", ")", ";", "if", "(", "size", ">", "UNITS_PER_WORD", "&&", "slotno", "==", "SPARC_INT_ARG_MAX", "-", "1", ")", "return", "UNITS_PER_WORD", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "arg", ".", "mode", ")", "==", "MODE_COMPLEX_FLOAT", "||", "(", "arg", ".", "type", "&&", "VECTOR_TYPE_P", "(", "arg", ".", "type", ")", ")", ")", "{", "const", "int", "size", "=", "(", "arg", ".", "type", "&&", "VECTOR_FLOAT_TYPE_P", "(", "arg", ".", "type", ")", ")", "?", "int_size_in_bytes", "(", "arg", ".", "type", ")", ":", "GET_MODE_SIZE", "(", "arg", ".", "mode", ")", ";", "if", "(", "size", ">", "UNITS_PER_WORD", "&&", "slotno", "==", "SPARC_FP_ARG_MAX", "-", "1", ")", "return", "UNITS_PER_WORD", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "For", "an", "arg", "passed", "partly", "in", "registers", "and", "partly", "in", "memory", ",", "this", "is", "the", "number", "of", "bytes", "of", "registers", "used", ".", "For", "args", "passed", "entirely", "in", "registers", "or", "entirely", "in", "memory", ",", "zero", ".", "Any", "arg", "that", "starts", "in", "the", "first", "6", "regs", "but", "wo", "n't", "entirely", "fit", "in", "them", "needs", "partial", "registers", "on", "v8", ".", "On", "v9", ",", "structures", "with", "integer", "values", "in", "arg", "slots", "5,6", "will", "be", "passed", "in", "%", "o5", "and", "SP+176", ",", "and", "complex", "fp", "values", "that", "begin", "in", "the", "last", "fp", "reg", "[", "where", "``", "last", "fp", "reg", "''", "varies", "with", "the", "mode", "]", "will", "be", "split", "between", "that", "reg", "and", "memory", "." ]

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

[]

[ "<s>", "unsigned", "AArch64RegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "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", ")", "||", "STI", "->", "isTargetDarwin", "(", ")", ")", "-", "(", "STI", "->", "isTargetDarwin", "(", ")", "||", "ReserveX18", ")", "-", "hasBasePointer", "(", "MF", ")", ";", "case", "AArch64", "::", "FPR8RegClassID", ":", "case", "AArch64", "::", "FPR16RegClassID", ":", "case", "AArch64", "::", "FPR32RegClassID", ":", "case", "AArch64", "::", "FPR64RegClassID", ":", "case", "AArch64", "::", "FPR128RegClassID", ":", "return", "32", ";", "case", "AArch64", "::", "DDRegClassID", ":", "case", "AArch64", "::", "DDDRegClassID", ":", "case", "AArch64", "::", "DDDDRegClassID", ":", "case", "AArch64", "::", "QQRegClassID", ":", "case", "AArch64", "::", "QQQRegClassID", ":", "case", "AArch64", "::", "QQQQRegClassID", ":", "return", "32", ";", "case", "AArch64", "::", "FPR128_loRegClassID", ":", "return", "16", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "SIRegisterInfo", "::", "materializeFrameBaseRegister", "(", "MachineBasicBlock", "*", "MBB", ",", "unsigned", "BaseReg", ",", "int", "FrameIdx", ",", "int64_t", "Offset", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "Ins", "=", "MBB", "->", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "Ins", "!=", "MBB", "->", "end", "(", ")", ")", "DL", "=", "Ins", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "const", "SISubtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "if", "(", "Offset", "==", "0", ")", "{", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "BaseReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ";", "return", ";", "}", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "unsigned", "UnusedCarry", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "unsigned", "OffsetReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_32RegClass", ")", ";", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B32", ")", ",", "OffsetReg", ")", ".", "addImm", "(", "Offset", ")", ";", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_ADD_I32_e64", ")", ",", "BaseReg", ")", ".", "addReg", "(", "UnusedCarry", ",", "RegState", "::", "Define", "|", "RegState", "::", "Dead", ")", ".", "addReg", "(", "OffsetReg", ",", "RegState", "::", "Kill", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "SI", "0", "AMDGPU::V_MOV_B32_e32", "AMDGPU::SReg_64RegClass", "AMDGPU::SReg_32RegClass", "AMDGPU::S_MOV_B32", "AMDGPU::V_ADD_I32_e64" ]

[]

[ "<s>", "BitVector", "AArch64RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "AArch64FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "WSP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "WZR", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", "||", "TT", ".", "isOSDarwin", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "W29", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "AArch64", "::", "GPR32commonRegClass", ".", "getNumRegs", "(", ")", ";", "++", "i", ")", "{", "if", "(", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isXRegisterReserved", "(", "i", ")", ")", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "GPR32commonRegClass", ".", "getRegister", "(", "i", ")", ")", ";", "}", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "W19", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "SpeculativeLoadHardening", ")", ")", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "W16", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "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", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64::WSP", "AArch64::WZR", "AArch64::W29", "0", "AArch64::GPR32commonRegClass", "AArch64", "AArch64::GPR32commonRegClass", "AArch64::W19", "AArch64::W16" ]

[]

[ "<s>", "bool", "GCNHazardRecognizer", "::", "ShouldPreferAnother", "(", "SUnit", "*", "SU", ")", "{", "if", "(", "!", "SU", "->", "isInstr", "(", ")", ")", "return", "false", ";", "MachineInstr", "*", "MAI", "=", "nullptr", ";", "auto", "IsMFMAFn", "=", "[", "&", "MAI", "]", "(", "MachineInstr", "*", "MI", ")", "{", "MAI", "=", "nullptr", ";", "if", "(", "SIInstrInfo", "::", "isMAI", "(", "*", "MI", ")", "&&", "MI", "->", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "V_ACCVGPR_WRITE_B32", "&&", "MI", "->", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "V_ACCVGPR_READ_B32", ")", "MAI", "=", "MI", ";", "return", "MAI", "!=", "nullptr", ";", "}", ";", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "IsMFMAFn", "(", "MI", ")", ")", "{", "int", "W", "=", "getWaitStatesSince", "(", "IsMFMAFn", ",", "16", ")", ";", "if", "(", "MAI", ")", "return", "W", "<", "(", "int", ")", "TSchedModel", ".", "computeInstrLatency", "(", "MAI", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "ShouldPreferAnother", "-", "This", "callback", "may", "be", "invoked", "if", "getHazardType", "returns", "NoHazard", "." ]

[ "AMDGPU", "SI", "AMDGPU::V_ACCVGPR_WRITE_B32", "AMDGPU::V_ACCVGPR_READ_B32", "16" ]

[]

[ "<s>", "void", "add_output_operand", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "create_output_operand", "(", "&", "m_ops", "[", "m_opno", "++", "]", ",", "x", ",", "mode", ")", ";", "gcc_assert", "(", "m_opno", "<=", "MAX_OPERANDS", ")", ";", "}", "</s>" ]

[ "Create", "output", "and", "add", "it", "into", "M_OPS", "and", "increase", "OPNO", "." ]

[ "riscv" ]

[]

[ "<s>", "unsigned", "M68kTargetLowering", "::", "getJumpTableEncoding", "(", ")", "const", "{", "return", "Subtarget", ".", "getJumpTableEncoding", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "entry", "encoding", "for", "a", "jump", "table", "in", "the", "current", "function", "." ]

[ "M68k", "M68k" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "PPC", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_ppc_br24\"", ",", "6", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ppc_brcond14\"", ",", "16", ",", "14", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ppc_lo16\"", ",", "16", ",", "16", ",", "0", "}", ",", "{", "\"fixup_ppc_ha16\"", ",", "16", ",", "16", ",", "0", "}", ",", "{", "\"fixup_ppc_lo14\"", ",", "16", ",", "14", ",", "0", "}", ",", "{", "\"fixup_ppc_toc\"", ",", "0", ",", "64", ",", "0", "}", ",", "{", "\"fixup_ppc_toc16\"", ",", "16", ",", "16", ",", "0", "}", ",", "{", "\"fixup_ppc_toc16_ds\"", ",", "16", ",", "14", ",", "0", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "PowerPC", "PPC::NumTargetFixupKinds", "\"fixup_ppc_br24\"", "6", "24", "\"fixup_ppc_brcond14\"", "16", "14", "\"fixup_ppc_lo16\"", "16", "16", "0", "\"fixup_ppc_ha16\"", "16", "16", "0", "\"fixup_ppc_lo14\"", "16", "14", "0", "\"fixup_ppc_toc\"", "0", "64", "0", "\"fixup_ppc_toc16\"", "16", "16", "0", "\"fixup_ppc_toc16_ds\"", "16", "14", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "bool", "MipsPassConfig", "::", "addPreEmitPass", "(", ")", "{", "MipsTargetMachine", "&", "TM", "=", "getMipsTargetMachine", "(", ")", ";", "const", "MipsSubtarget", "&", "Subtarget", "=", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "addPass", "(", "createMipsDelaySlotFillerPass", "(", "TM", ")", ")", ";", "if", "(", "Subtarget", ".", "enableLongBranchPass", "(", ")", ")", "addPass", "(", "createMipsLongBranchPass", "(", "TM", ")", ")", ";", "if", "(", "Subtarget", ".", "inMips16Mode", "(", ")", "||", "Subtarget", ".", "allowMixed16_32", "(", ")", ")", "addPass", "(", "createMipsConstantIslandPass", "(", "TM", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "override", "{", "MCInst", "Inst", ";", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "{", "ensureLocals", "(", "Out", ")", ";", "auto", "Align", "=", "WebAssembly", "::", "GetDefaultP2AlignAny", "(", "Inst", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "Align", "!=", "-", "1U", ")", "{", "auto", "&", "Op0", "=", "Inst", ".", "getOperand", "(", "0", ")", ";", "if", "(", "Op0", ".", "getImm", "(", ")", "==", "-", "1", ")", "Op0", ".", "setImm", "(", "Align", ")", ";", "}", "if", "(", "getSTI", "(", ")", ".", "getTargetTriple", "(", ")", ".", "isArch64Bit", "(", ")", ")", "{", "auto", "Opc64", "=", "WebAssembly", "::", "getWasm64Opcode", "(", "static_cast", "<", "uint16_t", ">", "(", "Inst", ".", "getOpcode", "(", ")", ")", ")", ";", "if", "(", "Opc64", ">=", "0", ")", "{", "Inst", ".", "setOpcode", "(", "Opc64", ")", ";", "}", "}", "Out", ".", "emitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "if", "(", "CurrentState", "==", "EndFunction", ")", "{", "onEndOfFunction", "(", ")", ";", "}", "else", "{", "CurrentState", "=", "Instructions", ";", "}", "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"instruction requires a WASM feature not currently enabled\"", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ")", ";", "case", "Match_NearMisses", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"ambiguous instruction\"", ")", ";", "case", "Match_InvalidTiedOperand", ":", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "Operands", "[", "ErrorInfo", "]", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Parser", ".", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "WebAssembly", "WebAssembly::GetDefaultP2AlignAny", "1U", "0", "1", "WebAssembly::getWasm64Opcode", "0", "\"instruction requires a WASM feature not currently enabled\"", "\"invalid instruction\"", "\"ambiguous instruction\"", "0ULL", "\"too few operands for instruction\"", "\"invalid operand for instruction\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "static", "int", "cg_magic_constant", "(", "HOST_WIDE_INT", "c", ")", "{", "switch", "(", "c", ")", "{", "case", "0xffff", ":", "case", "-", "1", ":", "case", "0", ":", "case", "1", ":", "case", "2", ":", "case", "4", ":", "case", "8", ":", "return", "1", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "These", "constants", "are", "really", "register", "reads", ",", "which", "are", "faster", "than", "regular", "constants", "." ]

[ "msp430", "0xffff", "1", "0", "1", "2", "4", "8", "1", "0" ]

[]

[ "<s>", "unsigned", "getMask", "(", ")", "const", "{", "assert", "(", "!", "Items", ".", "empty", "(", ")", ")", ";", "assert", "(", "Mask", "!=", "0", ")", ";", "return", "Mask", ";", "}", "</s>" ]

[ "Return", "the", "mask", "used", "by", "this", "recipe", "." ]

[ "TPC", "0" ]

[]

[ "<s>", "bool", "PTXTargetMachine", "::", "addInstSelector", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "PM", ".", "add", "(", "createPTXISelDag", "(", "*", "this", ",", "OptLevel", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "PTX", "PTX", "PTX" ]

[]

[ "<s>", "static", "machine_mode", "rs6000_preferred_simd_mode", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_VSX", ")", "switch", "(", "mode", ")", "{", "case", "DFmode", ":", "return", "V2DFmode", ";", "default", ":", ";", "}", "if", "(", "TARGET_ALTIVEC", "||", "TARGET_VSX", ")", "switch", "(", "mode", ")", "{", "case", "SFmode", ":", "return", "V4SFmode", ";", "case", "TImode", ":", "return", "V1TImode", ";", "case", "DImode", ":", "return", "V2DImode", ";", "case", "SImode", ":", "return", "V4SImode", ";", "case", "HImode", ":", "return", "V8HImode", ";", "case", "QImode", ":", "return", "V16QImode", ";", "default", ":", ";", "}", "if", "(", "TARGET_SPE", ")", "switch", "(", "mode", ")", "{", "case", "SFmode", ":", "return", "V2SFmode", ";", "case", "SImode", ":", "return", "V2SImode", ";", "default", ":", ";", "}", "if", "(", "TARGET_PAIRED_FLOAT", "&&", "mode", "==", "SFmode", ")", "return", "V2SFmode", ";", "return", "word_mode", ";", "}", "</s>" ]

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

[ "rs6000" ]

[]

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

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

[ "ARM", "ARM", "ARM", "ARM::GPRRegClass", "ARM::GPRRegClass", "ARM::DPRRegClass", "ARM::DPRRegClass", "\"Unexpected register class in CSRsViaCopy!\"", "\"Function should be nounwind in insertCopiesSplitCSR!\"" ]

[]

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

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

[ "gcn" ]

[]

[ "<s>", "SDValue", "Cpu0TargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ",", "const", "SDNode", "*", "CallNode", ",", "const", "Type", "*", "RetTy", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Cpu0CC", "Cpu0CCInfo", "(", "CallConv", ",", "ABI", ".", "IsO32", "(", ")", ",", "CCInfo", ")", ";", "Cpu0CCInfo", ".", "analyzeCallResult", "(", "Ins", ",", "Subtarget", ".", "abiUsesSoftFloat", "(", ")", ",", "CallNode", ",", "RetTy", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ",", "InFlag", ")", ";", "Chain", "=", "Val", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Val", ".", "getValue", "(", "2", ")", ";", "if", "(", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", "!=", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "InVals", ".", "push_back", "(", "Val", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "Cpu0", "Cpu0", "ISD::InputArg", "16", "Cpu0", "Cpu0", "Cpu0", "0", "1", "2", "ISD::BITCAST" ]

[]

[ "<s>", "void", "ix86_expand_rint", "(", "rtx", "operand0", ",", "rtx", "operand1", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operand0", ")", ";", "rtx", "res", ",", "xa", ",", "TWO52", ",", "mask", ";", "rtx_code_label", "*", "label", ";", "res", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_move_insn", "(", "res", ",", "operand1", ")", ";", "xa", "=", "ix86_expand_sse_fabs", "(", "res", ",", "&", "mask", ")", ";", "TWO52", "=", "ix86_gen_TWO52", "(", "mode", ")", ";", "label", "=", "ix86_expand_sse_compare_and_jump", "(", "UNLE", ",", "TWO52", ",", "xa", ",", "false", ")", ";", "xa", "=", "expand_simple_binop", "(", "mode", ",", "PLUS", ",", "xa", ",", "TWO52", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "xa", "=", "expand_simple_binop", "(", "mode", ",", "MINUS", ",", "xa", ",", "TWO52", ",", "xa", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "ix86_sse_copysign_to_positive", "(", "res", ",", "xa", ",", "res", ",", "mask", ")", ";", "emit_label", "(", "label", ")", ";", "LABEL_NUSES", "(", "label", ")", "=", "1", ";", "emit_move_insn", "(", "operand0", ",", "res", ")", ";", "}", "</s>" ]

[ "Expand", "rint", "(", "IEEE", "round", "to", "nearest", ")", "rounding", "OPERAND1", "and", "storing", "the", "result", "in", "OPERAND0", "." ]

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

[]

[ "<s>", "static", "void", "tilepro_conditional_register_usage", "(", "void", ")", "{", "global_regs", "[", "TILEPRO_NETORDER_REGNUM", "]", "=", "1", ";", "if", "(", "TILEPRO_PIC_TEXT_LABEL_REGNUM", "!=", "INVALID_REGNUM", ")", "fixed_regs", "[", "TILEPRO_PIC_TEXT_LABEL_REGNUM", "]", "=", "1", ";", "if", "(", "PIC_OFFSET_TABLE_REGNUM", "!=", "INVALID_REGNUM", ")", "fixed_regs", "[", "PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "}", "</s>" ]

[ "Implemnet", "TARGET_CONDITIONAL_REGISTER_USAGE", "." ]

[ "tilepro", "1", "1", "1" ]

[]

[ "<s>", "static", "void", "loongarch_block_move_straight", "(", "rtx", "dest", ",", "rtx", "src", ",", "HOST_WIDE_INT", "length", ")", "{", "HOST_WIDE_INT", "offset", ",", "delta", ";", "unsigned", "HOST_WIDE_INT", "bits", ";", "int", "i", ";", "machine_mode", "mode", ";", "rtx", "*", "regs", ";", "bits", "=", "MIN", "(", "BITS_PER_WORD", ",", "MIN", "(", "MEM_ALIGN", "(", "src", ")", ",", "MEM_ALIGN", "(", "dest", ")", ")", ")", ";", "mode", "=", "int_mode_for_size", "(", "bits", ",", "0", ")", ".", "require", "(", ")", ";", "delta", "=", "bits", "/", "BITS_PER_UNIT", ";", "regs", "=", "XALLOCAVEC", "(", "rtx", ",", "length", "/", "delta", ")", ";", "for", "(", "offset", "=", "0", ",", "i", "=", "0", ";", "offset", "+", "delta", "<=", "length", ";", "offset", "+=", "delta", ",", "i", "++", ")", "{", "regs", "[", "i", "]", "=", "gen_reg_rtx", "(", "mode", ")", ";", "loongarch_emit_move", "(", "regs", "[", "i", "]", ",", "adjust_address", "(", "src", ",", "mode", ",", "offset", ")", ")", ";", "}", "for", "(", "offset", "=", "0", ",", "i", "=", "0", ";", "offset", "+", "delta", "<=", "length", ";", "offset", "+=", "delta", ",", "i", "++", ")", "loongarch_emit_move", "(", "adjust_address", "(", "dest", ",", "mode", ",", "offset", ")", ",", "regs", "[", "i", "]", ")", ";", "if", "(", "offset", "<", "length", ")", "{", "src", "=", "adjust_address", "(", "src", ",", "BLKmode", ",", "offset", ")", ";", "dest", "=", "adjust_address", "(", "dest", ",", "BLKmode", ",", "offset", ")", ";", "move_by_pieces", "(", "dest", ",", "src", ",", "length", "-", "offset", ",", "MIN", "(", "MEM_ALIGN", "(", "src", ")", ",", "MEM_ALIGN", "(", "dest", ")", ")", ",", "(", "enum", "memop_ret", ")", "0", ")", ";", "}", "}", "</s>" ]

[ "Emit", "straight-line", "code", "to", "move", "LENGTH", "bytes", "from", "SRC", "to", "DEST", ".", "Assume", "that", "the", "areas", "do", "not", "overlap", "." ]

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

[]

[ "<s>", "static", "void", "nvptx_assemble_decl_begin", "(", "FILE", "*", "file", ",", "const", "char", "*", "name", ",", "const", "char", "*", "section", ",", "const_tree", "type", ",", "HOST_WIDE_INT", "size", ",", "unsigned", "align", ",", "bool", "undefined", "=", "false", ")", "{", "bool", "atype", "=", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "&&", "(", "TYPE_DOMAIN", "(", "type", ")", "==", "NULL_TREE", ")", ";", "if", "(", "undefined", "&&", "flexible_array_member_type_p", "(", "type", ")", ")", "{", "size", "=", "0", ";", "atype", "=", "true", ";", "}", "while", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "type", "=", "TREE_TYPE", "(", "type", ")", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "COMPLEX_TYPE", ")", "type", "=", "TREE_TYPE", "(", "type", ")", ";", "unsigned", "HOST_WIDE_INT", "elt_size", "=", "int_size_in_bytes", "(", "type", ")", ";", "machine_mode", "elt_mode", "=", "TYPE_MODE", "(", "type", ")", "==", "BLKmode", "?", "Pmode", ":", "DImode", ";", "elt_size", "|=", "GET_MODE_SIZE", "(", "elt_mode", ")", ";", "elt_size", "&=", "-", "elt_size", ";", "init_frag", ".", "size", "=", "elt_size", ";", "init_frag", ".", "mask", "=", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "2", "<<", "(", "elt_size", "*", "BITS_PER_UNIT", "-", "1", ")", ")", "-", "1", ";", "init_frag", ".", "val", "=", "0", ";", "init_frag", ".", "offset", "=", "0", ";", "init_frag", ".", "started", "=", "false", ";", "init_frag", ".", "remaining", "=", "(", "size", "+", "elt_size", "-", "1", ")", "/", "elt_size", ";", "fprintf", "(", "file", ",", "\"%s .align %d .u\"", "HOST_WIDE_INT_PRINT_UNSIGNED", "\" \"", ",", "section", ",", "align", "/", "BITS_PER_UNIT", ",", "elt_size", "*", "BITS_PER_UNIT", ")", ";", "assemble_name", "(", "file", ",", "name", ")", ";", "if", "(", "size", ")", "fprintf", "(", "file", ",", "\"[\"", "HOST_WIDE_INT_PRINT_UNSIGNED", "\"]\"", ",", "init_frag", ".", "remaining", ")", ";", "else", "if", "(", "atype", ")", "fprintf", "(", "file", ",", "\"[]\"", ")", ";", "}", "</s>" ]

[ "Emit", "a", "PTX", "variable", "decl", "and", "prepare", "for", "emission", "of", "its", "initializer", ".", "NAME", "is", "the", "symbol", "name", "and", "SETION", "the", "PTX", "data", "area", ".", "The", "type", "is", "TYPE", ",", "object", "size", "SIZE", "and", "alignment", "is", "ALIGN", ".", "The", "caller", "has", "already", "emitted", "any", "indentation", "and", "linkage", "specifier", ".", "It", "is", "responsible", "for", "any", "initializer", ",", "terminating", ";", "and", "newline", ".", "SIZE", "is", "in", "bytes", ",", "ALIGN", "is", "in", "bits", "--", "confusingly", "this", "is", "the", "opposite", "way", "round", "that", "PTX", "wants", "them", "!" ]

[ "nvptx", "0", "2", "1", "1", "0", "0", "1", "\"%s .align %d .u\"", "\" \"", "\"[\"", "\"]\"", "\"[]\"" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "epiphany_starting_frame_offset", "(", "void", ")", "{", "return", "epiphany_stack_offset", ";", "}", "</s>" ]

[ "Implement", "TARGET_STARTING_FRAME_OFFSET", "." ]

[ "epiphany" ]

[]

[ "<s>", "EVT", "MandarinTargetLowering", "::", "getSetCCResultType", "(", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "MVT", "::", "i32", ";", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "Mandarin", "MVT::i32" ]

[]

[ "<s>", "void", "setupMF", "(", "MachineFunction", "&", "MF", ",", "GISelKnownBits", "*", "KB", ",", "CodeGenCoverage", "&", "CoverageInfo", ",", "ProfileSummaryInfo", "*", "PSI", ",", "BlockFrequencyInfo", "*", "BFI", ")", "override", "{", "InstructionSelector", "::", "setupMF", "(", "MF", ",", "KB", ",", "CoverageInfo", ",", "PSI", ",", "BFI", ")", ";", "MIB", ".", "setMF", "(", "MF", ")", ";", "ProduceNonFlagSettingCondBr", "=", "!", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "SpeculativeLoadHardening", ")", ";", "MFReturnAddr", "=", "Register", "(", ")", ";", "processPHIs", "(", "MF", ")", ";", "}", "</s>" ]

[ "Setup", "per-MF", "executor", "state", "." ]

[ "AArch64" ]

[]

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

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

[ "Mips" ]

[]

[ "<s>", "bool", "X86TargetMachine", "::", "addPreRegAlloc", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "PM", ".", "add", "(", "createX86MaxStackAlignmentHeuristicPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "rtx", "F", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "!=", "CLOBBER", ")", "RTX_FRAME_RELATED_P", "(", "x", ")", "=", "1", ";", "return", "x", ";", "}", "</s>" ]

[ "We", "use", "this", "to", "wrap", "all", "emitted", "insns", "in", "the", "prologue", ",", "so", "they", "get", "the", "``", "frame-related", "''", "(", "/f", ")", "flag", "set", "." ]

[ "v850", "1" ]

[]

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

[ "Stack", "slot", "size", "(", "4", "bytes", ")" ]

[ "SHUXI", "4" ]

[]

[ "<s>", "static", "void", "pdp11_asm_print_operand", "(", "FILE", "*", "file", ",", "rtx", "x", ",", "int", "code", ")", "{", "long", "sval", "[", "2", "]", ";", "if", "(", "code", "==", "'#'", ")", "{", "if", "(", "TARGET_DEC_ASM", ")", "putc", "(", "'#'", ",", "file", ")", ";", "else", "putc", "(", "'$'", ",", "file", ")", ";", "}", "else", "if", "(", "code", "==", "'@'", ")", "{", "if", "(", "TARGET_UNIX_ASM", ")", "fprintf", "(", "file", ",", "\"*\"", ")", ";", "else", "fprintf", "(", "file", ",", "\"@\"", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", ")", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", ")", "output_address", "(", "GET_MODE", "(", "x", ")", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", "&&", "FLOAT_MODE_P", "(", "GET_MODE", "(", "x", ")", ")", ")", "{", "REAL_VALUE_TO_TARGET_DOUBLE", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "x", ")", ",", "sval", ")", ";", "if", "(", "TARGET_DEC_ASM", ")", "fprintf", "(", "file", ",", "\"#%lo\"", ",", "(", "sval", "[", "0", "]", ">>", "16", ")", "&", "0xffff", ")", ";", "else", "fprintf", "(", "file", ",", "\"$%#lo\"", ",", "(", "sval", "[", "0", "]", ">>", "16", ")", "&", "0xffff", ")", ";", "}", "else", "{", "if", "(", "code", "!=", "'o'", ")", "{", "if", "(", "TARGET_DEC_ASM", ")", "putc", "(", "'#'", ",", "file", ")", ";", "else", "putc", "(", "'$'", ",", "file", ")", ";", "}", "output_addr_const_pdp11", "(", "file", ",", "x", ")", ";", "}", "}", "</s>" ]

[ "Special", "format", "operators", "handled", "here", ":", "#", "--", "output", "the", "correct", "immediate", "operand", "marker", "for", "the", "assembler", "dialect", ".", "@", "--", "output", "the", "correct", "indirect", "marker", "for", "the", "assembler", "dialect", ".", "o", "--", "emit", "a", "constant", "value", "as", "a", "number", "(", "not", "an", "immediate", "operand", ")", "in", "octal", "." ]

[ "pdp11", "2", "\"*\"", "\"@\"", "\"%s\"", "0", "\"#%lo\"", "0", "16", "0xffff", "\"$%#lo\"", "0", "16", "0xffff" ]

[]

[ "<s>", "static", "void", "sh_output_function_epilogue", "(", "FILE", "*", ")", "{", "}", "</s>" ]

[ "Clear", "variables", "at", "function", "end", "." ]

[ "sh" ]

[]

[ "<s>", "void", "AArch64TargetLowering", "::", "initializeSplitCSR", "(", "MachineBasicBlock", "*", "Entry", ")", "const", "{", "AArch64FunctionInfo", "*", "AFI", "=", "Entry", "->", "getParent", "(", ")", "->", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "AFI", "->", "setIsSplitCSR", "(", "true", ")", ";", "}", "</s>" ]

[ "Perform", "necessary", "initialization", "to", "handle", "a", "subset", "of", "CSRs", "explicitly", "via", "copies", "." ]

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

[]

[ "<s>", "static", "Expected", "<", "std", "::", "unique_ptr", "<", "HSACodeObject", ">>", "create", "(", "MemoryBufferRef", "Wrapper", ")", "{", "auto", "Obj", "=", "object", "::", "ELF64LEObjectFile", "::", "create", "(", "Wrapper", ")", ";", "if", "(", "auto", "E", "=", "Obj", ".", "takeError", "(", ")", ")", "return", "std", "::", "move", "(", "E", ")", ";", "std", "::", "unique_ptr", "<", "HSACodeObject", ">", "Ret", "(", "new", "HSACodeObject", "(", "std", "::", "move", "(", "*", "Obj", ")", ")", ")", ";", "return", "std", "::", "move", "(", "Ret", ")", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]