Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "BitVector", "SIRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "EXEC", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "FLAT_SCR", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "M0", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_SHARED_BASE", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_SHARED_LIMIT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_PRIVATE_BASE", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_PRIVATE_LIMIT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "XNACK_MASK", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TBA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TMA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP0_TTMP1", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP2_TTMP3", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP4_TTMP5", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP6_TTMP7", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP8_TTMP9", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP10_TTMP11", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP12_TTMP13", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP14_TTMP15", ")", ";", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "unsigned", "MaxNumSGPRs", "=", "ST", ".", "getMaxNumSGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumSGPRs", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumSGPRs", ";", "i", "<", "TotalNumSGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "unsigned", "MaxNumVGPRs", "=", "ST", ".", "getMaxNumVGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumVGPRs", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumVGPRs", ";", "i", "<", "TotalNumVGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "ScratchWaveOffsetReg", "=", "MFI", "->", "getScratchWaveOffsetReg", "(", ")", ";", "if", "(", "ScratchWaveOffsetReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchWaveOffsetReg", ")", ";", "}", "unsigned", "ScratchRSrcReg", "=", "MFI", "->", "getScratchRSrcReg", "(", ")", ";", "if", "(", "ScratchRSrcReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchRSrcReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "ScratchWaveOffsetReg", ")", ")", ";", "}", "unsigned", "StackPtrReg", "=", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ";", "if", "(", "StackPtrReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "StackPtrReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "StackPtrReg", ")", ")", ";", "}", "unsigned", "FrameReg", "=", "MFI", "->", "getFrameOffsetReg", "(", ")", ";", "if", "(", "FrameReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "FrameReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "FrameReg", ")", ")", ";", "}", "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", "." ]

[ "AMDGPU", "SI", "AMDGPU::EXEC", "AMDGPU::FLAT_SCR", "AMDGPU::M0", "AMDGPU::SRC_SHARED_BASE", "AMDGPU::SRC_SHARED_LIMIT", "AMDGPU::SRC_PRIVATE_BASE", "AMDGPU::SRC_PRIVATE_LIMIT", "AMDGPU::XNACK_MASK", "AMDGPU::TBA", "AMDGPU::TMA", "AMDGPU::TTMP0_TTMP1", "AMDGPU::TTMP2_TTMP3", "AMDGPU::TTMP4_TTMP5", "AMDGPU::TTMP6_TTMP7", "AMDGPU::TTMP8_TTMP9", "AMDGPU::TTMP10_TTMP11", "AMDGPU::TTMP12_TTMP13", "AMDGPU::TTMP14_TTMP15", "SI", "SI", "AMDGPU::SGPR_32RegClass", "AMDGPU::SGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "SI", "SI", "AMDGPU::NoRegister", "AMDGPU::NoRegister", "AMDGPU::NoRegister", "AMDGPU::NoRegister" ]

[]

[ "<s>", "static", "unsigned", "HOST_WIDE_INT", "arm_shift_truncation_mask", "(", "machine_mode", "mode", ")", "{", "return", "mode", "==", "SImode", "?", "255", ":", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_SHIFT_TRUNCATION_MASK", ".", "SImode", "shifts", "use", "normal", "ARM", "insns", "and", "therefore", "guarantee", "that", "the", "shift", "count", "is", "modulo", "256", ".", "DImode", "shifts", "(", "those", "implemented", "by", "lib1funcs.asm", "or", "by", "optabs.c", ")", "guarantee", "no", "particular", "behavior", "for", "out-of-range", "counts", "." ]

[ "arm", "255", "0" ]

[]

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

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

[ "Sparc", "Sparc" ]

[]

[ "<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "TLOF", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Return", "information", "about", "object", "file", "lowering", "." ]

[ "XCore" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ")", "const", "{", "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "4", ";", "++", "i", ")", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "(", "4", "-", "i", "-", "1", ")", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "</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", "." ]

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

[]

[ "<s>", "bool", "X86TargetLowering", "::", "shouldFormOverflowOp", "(", "unsigned", "Opcode", ",", "EVT", "VT", ",", "bool", ")", "const", "{", "if", "(", "VT", ".", "isVector", "(", ")", ")", "return", "false", ";", "return", "VT", ".", "isSimple", "(", ")", "||", "!", "isOperationExpand", "(", "Opcode", ",", "VT", ")", ";", "}", "</s>" ]

[ "Overflow", "nodes", "should", "get", "combined/lowered", "to", "optimal", "instructions", "(", "they", "should", "allow", "eliminating", "explicit", "compares", "by", "getting", "flags", "from", "math", "ops", ")", "." ]

[ "X86", "X86" ]

[]

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

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

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

[]

[ "<s>", "void", "ARMInstrInfo", "::", "reMaterialize", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "const", "MachineInstr", "*", "Orig", ")", "const", "{", "DebugLoc", "dl", "=", "Orig", "->", "getDebugLoc", "(", ")", ";", "if", "(", "Orig", "->", "getOpcode", "(", ")", "==", "ARM", "::", "MOVi2pieces", ")", "{", "RI", ".", "emitLoadConstPool", "(", "MBB", ",", "I", ",", "dl", ",", "DestReg", ",", "SubIdx", ",", "Orig", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ",", "(", "ARMCC", "::", "CondCodes", ")", "Orig", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ",", "Orig", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ")", ";", "return", ";", "}", "MachineInstr", "*", "MI", "=", "MBB", ".", "getParent", "(", ")", "->", "CloneMachineInstr", "(", "Orig", ")", ";", "MI", "->", "getOperand", "(", "0", ")", ".", "setReg", "(", "DestReg", ")", ";", "MBB", ".", "insert", "(", "I", ",", "MI", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::MOVi2pieces", "1", "ARMCC::CondCodes", "2", "3", "0" ]

[]

[ "<s>", "void", "MipsSEFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "const", "MipsRegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "MipsRegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "const", "MipsSEInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MipsSEInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "SP", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "SP_64", ":", "Mips", "::", "SP", ";", "unsigned", "FP", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "FP_64", ":", "Mips", "::", "FP", ";", "unsigned", "ZERO", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "ZERO_64", ":", "Mips", "::", "ZERO", ";", "unsigned", "ADDu", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "DADDu", ":", "Mips", "::", "ADDu", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBBI", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MFI", "->", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ";", "++", "i", ")", "--", "I", ";", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "TII", ".", "get", "(", "ADDu", ")", ",", "SP", ")", ".", "addReg", "(", "FP", ")", ".", "addReg", "(", "ZERO", ")", ";", "}", "if", "(", "MipsFI", "->", "callsEhReturn", "(", ")", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "STI", ".", "isABI_N64", "(", ")", "?", "&", "Mips", "::", "CPU64RegsRegClass", ":", "&", "Mips", "::", "CPURegsRegClass", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBBI", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MFI", "->", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ";", "++", "i", ")", "--", "I", ";", "for", "(", "int", "J", "=", "0", ";", "J", "<", "4", ";", "++", "J", ")", "{", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "I", ",", "ehDataReg", "(", "J", ")", ",", "MipsFI", "->", "getEhDataRegFI", "(", "J", ")", ",", "RC", ",", "RegInfo", ")", ";", "}", "}", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "!", "StackSize", ")", "return", ";", "TII", ".", "adjustStackPtr", "(", "SP", ",", "StackSize", ",", "MBB", ",", "MBBI", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::SP_64", "Mips::SP", "Mips::FP_64", "Mips::FP", "Mips::ZERO_64", "Mips::ZERO", "Mips::DADDu", "Mips::ADDu", "0", "Mips", "Mips::CPU64RegsRegClass", "Mips::CPURegsRegClass", "0", "0", "4", "Mips" ]

[]

[ "<s>", "static", "unsigned", "int", "find_drap_reg", "(", "void", ")", "{", "tree", "decl", "=", "cfun", "->", "decl", ";", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "DECL_STATIC_CHAIN", "(", "decl", ")", "||", "crtl", "->", "tail_call_emit", ")", "return", "R13_REG", ";", "return", "R10_REG", ";", "}", "else", "{", "if", "(", "DECL_STATIC_CHAIN", "(", "decl", ")", "||", "crtl", "->", "tail_call_emit", ")", "return", "DI_REG", ";", "if", "(", "ix86_function_regparm", "(", "TREE_TYPE", "(", "decl", ")", ",", "decl", ")", "<=", "2", ")", "{", "unsigned", "int", "ccvt", "=", "ix86_get_callcvt", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "if", "(", "(", "ccvt", "&", "(", "IX86_CALLCVT_FASTCALL", "|", "IX86_CALLCVT_THISCALL", ")", ")", "==", "0", ")", "return", "CX_REG", ";", "}", "return", "DI_REG", ";", "}", "}", "</s>" ]

[ "Find", "an", "available", "register", "to", "be", "used", "as", "dynamic", "realign", "argument", "pointer", "regsiter", ".", "Such", "a", "register", "will", "be", "written", "in", "prologue", "and", "used", "in", "begin", "of", "body", ",", "so", "it", "must", "not", "be", "1.", "parameter", "passing", "register", ".", "2", ".", "GOT", "pointer", ".", "We", "reuse", "static-chain", "register", "if", "it", "is", "available", ".", "Otherwise", ",", "we", "use", "DI", "for", "i386", "and", "R13", "for", "x86-64", ".", "We", "chose", "R13", "since", "it", "has", "shorter", "encoding", ".", "Return", ":", "the", "regno", "of", "chosen", "register", "." ]

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

[]

[ "<s>", "unsigned", "pass_tiabi_check", "::", "execute", "(", "function", "*", "fun", ")", "{", "struct", "walk_stmt_info", "wi", ";", "const_tree", "fntype", "=", "TREE_TYPE", "(", "fun", "->", "decl", ")", ";", "gimple_seq", "body", "=", "gimple_body", "(", "current_function_decl", ")", ";", "memset", "(", "&", "wi", ",", "0", ",", "sizeof", "(", "wi", ")", ")", ";", "wi", ".", "info", "=", "NULL", ";", "wi", ".", "want_locations", "=", "true", ";", "walk_gimple_seq", "(", "body", ",", "NULL", ",", "check_op_callback", ",", "&", "wi", ")", ";", "chk_function_decl", "(", "fntype", ",", "fun", "->", "function_start_locus", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Main", "entry", "point", "for", "this", "pass", "." ]

[ "pru", "0", "0" ]

[]

[ "<s>", "const", "char", "*", "HexagonTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "HexagonISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "HexagonISD", "::", "ADDC", ":", "return", "\"HexagonISD::ADDC\"", ";", "case", "HexagonISD", "::", "SUBC", ":", "return", "\"HexagonISD::SUBC\"", ";", "case", "HexagonISD", "::", "ALLOCA", ":", "return", "\"HexagonISD::ALLOCA\"", ";", "case", "HexagonISD", "::", "AT_GOT", ":", "return", "\"HexagonISD::AT_GOT\"", ";", "case", "HexagonISD", "::", "AT_PCREL", ":", "return", "\"HexagonISD::AT_PCREL\"", ";", "case", "HexagonISD", "::", "BARRIER", ":", "return", "\"HexagonISD::BARRIER\"", ";", "case", "HexagonISD", "::", "CALL", ":", "return", "\"HexagonISD::CALL\"", ";", "case", "HexagonISD", "::", "CALLnr", ":", "return", "\"HexagonISD::CALLnr\"", ";", "case", "HexagonISD", "::", "CALLR", ":", "return", "\"HexagonISD::CALLR\"", ";", "case", "HexagonISD", "::", "COMBINE", ":", "return", "\"HexagonISD::COMBINE\"", ";", "case", "HexagonISD", "::", "CONST32_GP", ":", "return", "\"HexagonISD::CONST32_GP\"", ";", "case", "HexagonISD", "::", "CONST32", ":", "return", "\"HexagonISD::CONST32\"", ";", "case", "HexagonISD", "::", "CP", ":", "return", "\"HexagonISD::CP\"", ";", "case", "HexagonISD", "::", "DCFETCH", ":", "return", "\"HexagonISD::DCFETCH\"", ";", "case", "HexagonISD", "::", "EH_RETURN", ":", "return", "\"HexagonISD::EH_RETURN\"", ";", "case", "HexagonISD", "::", "TSTBIT", ":", "return", "\"HexagonISD::TSTBIT\"", ";", "case", "HexagonISD", "::", "EXTRACTU", ":", "return", "\"HexagonISD::EXTRACTU\"", ";", "case", "HexagonISD", "::", "INSERT", ":", "return", "\"HexagonISD::INSERT\"", ";", "case", "HexagonISD", "::", "JT", ":", "return", "\"HexagonISD::JT\"", ";", "case", "HexagonISD", "::", "RET_FLAG", ":", "return", "\"HexagonISD::RET_FLAG\"", ";", "case", "HexagonISD", "::", "TC_RETURN", ":", "return", "\"HexagonISD::TC_RETURN\"", ";", "case", "HexagonISD", "::", "VASL", ":", "return", "\"HexagonISD::VASL\"", ";", "case", "HexagonISD", "::", "VASR", ":", "return", "\"HexagonISD::VASR\"", ";", "case", "HexagonISD", "::", "VLSR", ":", "return", "\"HexagonISD::VLSR\"", ";", "case", "HexagonISD", "::", "VSPLAT", ":", "return", "\"HexagonISD::VSPLAT\"", ";", "case", "HexagonISD", "::", "VEXTRACTW", ":", "return", "\"HexagonISD::VEXTRACTW\"", ";", "case", "HexagonISD", "::", "VINSERTW0", ":", "return", "\"HexagonISD::VINSERTW0\"", ";", "case", "HexagonISD", "::", "VROR", ":", "return", "\"HexagonISD::VROR\"", ";", "case", "HexagonISD", "::", "READCYCLE", ":", "return", "\"HexagonISD::READCYCLE\"", ";", "case", "HexagonISD", "::", "PTRUE", ":", "return", "\"HexagonISD::PTRUE\"", ";", "case", "HexagonISD", "::", "PFALSE", ":", "return", "\"HexagonISD::PFALSE\"", ";", "case", "HexagonISD", "::", "VZERO", ":", "return", "\"HexagonISD::VZERO\"", ";", "case", "HexagonISD", "::", "VSPLATW", ":", "return", "\"HexagonISD::VSPLATW\"", ";", "case", "HexagonISD", "::", "D2P", ":", "return", "\"HexagonISD::D2P\"", ";", "case", "HexagonISD", "::", "P2D", ":", "return", "\"HexagonISD::P2D\"", ";", "case", "HexagonISD", "::", "V2Q", ":", "return", "\"HexagonISD::V2Q\"", ";", "case", "HexagonISD", "::", "Q2V", ":", "return", "\"HexagonISD::Q2V\"", ";", "case", "HexagonISD", "::", "QCAT", ":", "return", "\"HexagonISD::QCAT\"", ";", "case", "HexagonISD", "::", "QTRUE", ":", "return", "\"HexagonISD::QTRUE\"", ";", "case", "HexagonISD", "::", "QFALSE", ":", "return", "\"HexagonISD::QFALSE\"", ";", "case", "HexagonISD", "::", "TYPECAST", ":", "return", "\"HexagonISD::TYPECAST\"", ";", "case", "HexagonISD", "::", "VALIGN", ":", "return", "\"HexagonISD::VALIGN\"", ";", "case", "HexagonISD", "::", "VALIGNADDR", ":", "return", "\"HexagonISD::VALIGNADDR\"", ";", "case", "HexagonISD", "::", "VPACKL", ":", "return", "\"HexagonISD::VPACKL\"", ";", "case", "HexagonISD", "::", "VUNPACK", ":", "return", "\"HexagonISD::VUNPACK\"", ";", "case", "HexagonISD", "::", "VUNPACKU", ":", "return", "\"HexagonISD::VUNPACKU\"", ";", "case", "HexagonISD", "::", "OP_END", ":", "break", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "HexagonISD::NodeType", "HexagonISD::ADDC", "\"HexagonISD::ADDC\"", "HexagonISD::SUBC", "\"HexagonISD::SUBC\"", "HexagonISD::ALLOCA", "\"HexagonISD::ALLOCA\"", "HexagonISD::AT_GOT", "\"HexagonISD::AT_GOT\"", "HexagonISD::AT_PCREL", "\"HexagonISD::AT_PCREL\"", "HexagonISD::BARRIER", "\"HexagonISD::BARRIER\"", "HexagonISD::CALL", "\"HexagonISD::CALL\"", "HexagonISD::CALLnr", "\"HexagonISD::CALLnr\"", "HexagonISD::CALLR", "\"HexagonISD::CALLR\"", "HexagonISD::COMBINE", "\"HexagonISD::COMBINE\"", "HexagonISD::CONST32_GP", "\"HexagonISD::CONST32_GP\"", "HexagonISD::CONST32", "\"HexagonISD::CONST32\"", "HexagonISD::CP", "\"HexagonISD::CP\"", "HexagonISD::DCFETCH", "\"HexagonISD::DCFETCH\"", "HexagonISD::EH_RETURN", "\"HexagonISD::EH_RETURN\"", "HexagonISD::TSTBIT", "\"HexagonISD::TSTBIT\"", "HexagonISD::EXTRACTU", "\"HexagonISD::EXTRACTU\"", "HexagonISD::INSERT", "\"HexagonISD::INSERT\"", "HexagonISD::JT", "\"HexagonISD::JT\"", "HexagonISD::RET_FLAG", "\"HexagonISD::RET_FLAG\"", "HexagonISD::TC_RETURN", "\"HexagonISD::TC_RETURN\"", "HexagonISD::VASL", "\"HexagonISD::VASL\"", "HexagonISD::VASR", "\"HexagonISD::VASR\"", "HexagonISD::VLSR", "\"HexagonISD::VLSR\"", "HexagonISD::VSPLAT", "\"HexagonISD::VSPLAT\"", "HexagonISD::VEXTRACTW", "\"HexagonISD::VEXTRACTW\"", "HexagonISD::VINSERTW0", "\"HexagonISD::VINSERTW0\"", "HexagonISD::VROR", "\"HexagonISD::VROR\"", "HexagonISD::READCYCLE", "\"HexagonISD::READCYCLE\"", "HexagonISD::PTRUE", "\"HexagonISD::PTRUE\"", "HexagonISD::PFALSE", "\"HexagonISD::PFALSE\"", "HexagonISD::VZERO", "\"HexagonISD::VZERO\"", "HexagonISD::VSPLATW", "\"HexagonISD::VSPLATW\"", "HexagonISD::D2P", "\"HexagonISD::D2P\"", "HexagonISD::P2D", "\"HexagonISD::P2D\"", "HexagonISD::V2Q", "\"HexagonISD::V2Q\"", "HexagonISD::Q2V", "\"HexagonISD::Q2V\"", "HexagonISD::QCAT", "\"HexagonISD::QCAT\"", "HexagonISD::QTRUE", "\"HexagonISD::QTRUE\"", "HexagonISD::QFALSE", "\"HexagonISD::QFALSE\"", "HexagonISD::TYPECAST", "\"HexagonISD::TYPECAST\"", "HexagonISD::VALIGN", "\"HexagonISD::VALIGN\"", "HexagonISD::VALIGNADDR", "\"HexagonISD::VALIGNADDR\"", "HexagonISD::VPACKL", "\"HexagonISD::VPACKL\"", "HexagonISD::VUNPACK", "\"HexagonISD::VUNPACK\"", "HexagonISD::VUNPACKU", "\"HexagonISD::VUNPACKU\"", "HexagonISD::OP_END" ]

[]

[ "<s>", "void", "Nios2DAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "Nios2", "Nios2", "\"Selecting: \"", "\"\\n\"", "\"== \"", "\"\\n\"", "1" ]

[]

[ "<s>", "static", "unsigned", "findDeadCallerSavedReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "const", "TargetRegisterInfo", "&", "TRI", ",", "bool", "Is64Bit", ")", "{", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "if", "(", "!", "F", "||", "MF", "->", "getMMI", "(", ")", ".", "callsEHReturn", "(", ")", ")", "return", "0", ";", "static", "const", "unsigned", "CallerSavedRegs32Bit", "[", "]", "=", "{", "X86", "::", "EAX", ",", "X86", "::", "EDX", ",", "X86", "::", "ECX", "}", ";", "static", "const", "unsigned", "CallerSavedRegs64Bit", "[", "]", "=", "{", "X86", "::", "RAX", ",", "X86", "::", "RDX", ",", "X86", "::", "RCX", ",", "X86", "::", "RSI", ",", "X86", "::", "RDI", ",", "X86", "::", "R8", ",", "X86", "::", "R9", ",", "X86", "::", "R10", ",", "X86", "::", "R11", "}", ";", "unsigned", "Opc", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "return", "0", ";", "case", "X86", "::", "RET", ":", "case", "X86", "::", "RETI", ":", "case", "X86", "::", "TCRETURNdi", ":", "case", "X86", "::", "TCRETURNri", ":", "case", "X86", "::", "TCRETURNmi", ":", "case", "X86", "::", "TCRETURNdi64", ":", "case", "X86", "::", "TCRETURNri64", ":", "case", "X86", "::", "TCRETURNmi64", ":", "case", "X86", "::", "EH_RETURN", ":", "case", "X86", "::", "EH_RETURN64", ":", "{", "SmallSet", "<", "unsigned", ",", "8", ">", "Uses", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MBBI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "MBBI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "continue", ";", "for", "(", "const", "unsigned", "*", "AsI", "=", "TRI", ".", "getOverlaps", "(", "Reg", ")", ";", "*", "AsI", ";", "++", "AsI", ")", "Uses", ".", "insert", "(", "*", "AsI", ")", ";", "}", "const", "unsigned", "*", "CS", "=", "Is64Bit", "?", "CallerSavedRegs64Bit", ":", "CallerSavedRegs32Bit", ";", "for", "(", ";", "*", "CS", ";", "++", "CS", ")", "if", "(", "!", "Uses", ".", "count", "(", "*", "CS", ")", ")", "return", "*", "CS", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "findDeadCallerSavedReg", "-", "Return", "a", "caller-saved", "register", "that", "is", "n't", "live", "when", "it", "reaches", "the", "``", "return", "''", "instruction", "." ]

[ "X86", "0", "X86::EAX", "X86::EDX", "X86::ECX", "X86::RAX", "X86::RDX", "X86::RCX", "X86::RSI", "X86::RDI", "X86::R8", "X86::R9", "X86::R10", "X86::R11", "0", "X86::RET", "X86::RETI", "X86::TCRETURNdi", "X86::TCRETURNri", "X86::TCRETURNmi", "X86::TCRETURNdi64", "X86::TCRETURNri64", "X86::TCRETURNmi64", "X86::EH_RETURN", "X86::EH_RETURN64", "8", "0", "0" ]

[]

[ "<s>", "void", "assignValueToAddress", "(", "unsigned", "ValVReg", ",", "unsigned", "Addr", ",", "uint64_t", "Size", ",", "MachinePointerInfo", "&", "MPO", ",", "CCValAssign", "&", "VA", ")", "override", "{", "auto", "MMO", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getMachineMemOperand", "(", "MPO", ",", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOInvariant", ",", "Size", ",", "1", ")", ";", "MIRBuilder", ".", "buildLoad", "(", "ValVReg", ",", "Addr", ",", "*", "MMO", ")", ";", "}", "</s>" ]

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

[ "X86", "1" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "Result", "=", "Match_Success", ";", "for", "(", "auto", "Variant", ":", "getMatchedVariants", "(", ")", ")", "{", "uint64_t", "EI", ";", "auto", "R", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "EI", ",", "MatchingInlineAsm", ",", "Variant", ")", ";", "if", "(", "(", "R", "==", "Match_Success", ")", "||", "(", "R", "==", "Match_PreferE32", ")", "||", "(", "R", "==", "Match_MissingFeature", "&&", "Result", "!=", "Match_PreferE32", ")", "||", "(", "R", "==", "Match_InvalidOperand", "&&", "Result", "!=", "Match_MissingFeature", "&&", "Result", "!=", "Match_PreferE32", ")", "||", "(", "R", "==", "Match_MnemonicFail", "&&", "Result", "!=", "Match_InvalidOperand", "&&", "Result", "!=", "Match_MissingFeature", "&&", "Result", "!=", "Match_PreferE32", ")", ")", "{", "Result", "=", "R", ";", "ErrorInfo", "=", "EI", ";", "}", "if", "(", "R", "==", "Match_Success", ")", "break", ";", "}", "switch", "(", "Result", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "if", "(", "!", "validateInstruction", "(", "Inst", ",", "IDLoc", ")", ")", "{", "return", "true", ";", "}", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction not supported on this GPU\"", ")", ";", "case", "Match_MnemonicFail", ":", "{", "FeatureBitset", "FBS", "=", "ComputeAvailableFeatures", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", ")", ";", "std", "::", "string", "Suggestion", "=", "AMDGPUMnemonicSpellCheck", "(", "(", "(", "AMDGPUOperand", "&", ")", "*", "Operands", "[", "0", "]", ")", ".", "getToken", "(", ")", ",", "FBS", ")", ";", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", "+", "Suggestion", ",", "(", "(", "AMDGPUOperand", "&", ")", "*", "Operands", "[", "0", "]", ")", ".", "getLocRange", "(", ")", ")", ";", "}", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "{", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "}", "ErrorLoc", "=", "(", "(", "AMDGPUOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_PreferE32", ":", "return", "Error", "(", "IDLoc", ",", "\"internal error: instruction without _e64 suffix \"", "\"should be encoded as e32\"", ")", ";", "}", "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", "." ]

[ "AMDGPU", "AMDGPU", "\"instruction not supported on this GPU\"", "AMDGPU", "AMDGPU", "0", "\"invalid instruction\"", "AMDGPU", "0", "0ULL", "\"too few operands for instruction\"", "AMDGPU", "\"invalid operand for instruction\"", "\"internal error: instruction without _e64 suffix \"", "\"should be encoded as e32\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "static", "rtx", "rs6000_mixed_function_arg", "(", "machine_mode", "mode", ",", "const_tree", "type", ",", "int", "align_words", ")", "{", "int", "n_units", ";", "int", "i", ",", "k", ";", "rtx", "rvec", "[", "GP_ARG_NUM_REG", "+", "1", "]", ";", "if", "(", "align_words", ">=", "GP_ARG_NUM_REG", ")", "return", "NULL_RTX", ";", "n_units", "=", "rs6000_arg_size", "(", "mode", ",", "type", ")", ";", "if", "(", "n_units", "==", "0", "||", "(", "n_units", "==", "1", "&&", "mode", "!=", "BLKmode", ")", ")", "return", "gen_rtx_REG", "(", "mode", ",", "GP_ARG_MIN_REG", "+", "align_words", ")", ";", "k", "=", "0", ";", "if", "(", "align_words", "+", "n_units", ">", "GP_ARG_NUM_REG", ")", "rvec", "[", "k", "++", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "NULL_RTX", ",", "const0_rtx", ")", ";", "i", "=", "0", ";", "do", "{", "rtx", "r", "=", "gen_rtx_REG", "(", "SImode", ",", "GP_ARG_MIN_REG", "+", "align_words", ")", ";", "rtx", "off", "=", "GEN_INT", "(", "i", "++", "*", "4", ")", ";", "rvec", "[", "k", "++", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "r", ",", "off", ")", ";", "}", "while", "(", "++", "align_words", "<", "GP_ARG_NUM_REG", "&&", "--", "n_units", "!=", "0", ")", ";", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec_v", "(", "k", ",", "rvec", ")", ")", ";", "}", "</s>" ]

[ "Determine", "where", "to", "place", "an", "argument", "in", "64-bit", "mode", "with", "32-bit", "ABI", "." ]

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

[]

[ "<s>", "const", "MCPhysReg", "*", "RISCVRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "{", "if", "(", "MF", "->", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ".", "hasStdExtD", "(", ")", ")", "return", "CSR_XLEN_F64_Interrupt_SaveList", ";", "if", "(", "MF", "->", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ".", "hasStdExtF", "(", ")", ")", "return", "CSR_XLEN_F32_Interrupt_SaveList", ";", "return", "CSR_Interrupt_SaveList", ";", "}", "return", "CSR_SaveList", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"interrupt\"", "RISCV", "RISCV" ]

[]

[ "<s>", "void", "emitCodeAlignment", "(", "unsigned", "ByteAlignment", ",", "unsigned", "MaxBytesToEmit", "=", "0", ")", "override", "{", "}", "</s>" ]

[ "Emit", "nops", "until", "the", "byte", "alignment", "ByteAlignment", "is", "reached", "." ]

[ "Patmos", "0" ]

[]

[ "<s>", "static", "rtx", "frv_struct_value_rtx", "(", "tree", "fntype", "ATTRIBUTE_UNUSED", ",", "int", "incoming", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "Pmode", ",", "FRV_STRUCT_VALUE_REGNUM", ")", ";", "}", "</s>" ]

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

[ "frv" ]

[]

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

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

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

[]

[ "<s>", "void", "X86InstrInfo", "::", "replaceBranchWithTailCall", "(", "MachineBasicBlock", "&", "MBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "BranchCond", ",", "const", "MachineInstr", "&", "TailCall", ")", "const", "{", "assert", "(", "canMakeTailCallConditional", "(", "BranchCond", ",", "TailCall", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugInstr", "(", ")", ")", "continue", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "assert", "(", "0", "&&", "\"Can't find the branch to replace!\"", ")", ";", "X86", "::", "CondCode", "CC", "=", "X86", "::", "getCondFromBranchOpc", "(", "I", "->", "getOpcode", "(", ")", ")", ";", "assert", "(", "BranchCond", ".", "size", "(", ")", "==", "1", ")", ";", "if", "(", "CC", "!=", "BranchCond", "[", "0", "]", ".", "getImm", "(", ")", ")", "continue", ";", "break", ";", "}", "unsigned", "Opc", "=", "TailCall", ".", "getOpcode", "(", ")", "==", "X86", "::", "TCRETURNdi", "?", "X86", "::", "TCRETURNdicc", ":", "X86", "::", "TCRETURNdi64cc", ";", "auto", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "MBB", ".", "findDebugLoc", "(", "I", ")", ",", "get", "(", "Opc", ")", ")", ";", "MIB", "->", "addOperand", "(", "TailCall", ".", "getOperand", "(", "0", ")", ")", ";", "MIB", ".", "addImm", "(", "0", ")", ";", "MIB", "->", "addOperand", "(", "BranchCond", "[", "0", "]", ")", ";", "MIB", ".", "copyImplicitOps", "(", "TailCall", ")", ";", "LivePhysRegs", "LiveRegs", "(", "getRegisterInfo", "(", ")", ")", ";", "LiveRegs", ".", "addLiveOuts", "(", "MBB", ")", ";", "SmallVector", "<", "std", "::", "pair", "<", "MCPhysReg", ",", "const", "MachineOperand", "*", ">", ",", "8", ">", "Clobbers", ";", "LiveRegs", ".", "stepForward", "(", "*", "MIB", ",", "Clobbers", ")", ";", "for", "(", "const", "auto", "&", "C", ":", "Clobbers", ")", "{", "MIB", ".", "addReg", "(", "C", ".", "first", ",", "RegState", "::", "Implicit", ")", ";", "MIB", ".", "addReg", "(", "C", ".", "first", ",", "RegState", "::", "Implicit", "|", "RegState", "::", "Define", ")", ";", "}", "I", "->", "eraseFromParent", "(", ")", ";", "}", "</s>" ]

[ "Replace", "the", "conditional", "branch", "in", "MBB", "with", "a", "conditional", "tail", "call", "." ]

[ "X86", "X86", "0", "\"Can't find the branch to replace!\"", "X86::CondCode", "X86::getCondFromBranchOpc", "1", "0", "X86::TCRETURNdi", "X86::TCRETURNdicc", "X86::TCRETURNdi64cc", "0", "0", "0", "8" ]

[]

[ "<s>", "MachineInstr", "*", "X86InstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "Ops", ",", "int", "FrameIndex", ")", "const", "{", "if", "(", "NoFusing", ")", "return", "NULL", ";", "if", "(", "!", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "OptimizeForSize", ")", "&&", "hasPartialRegUpdate", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "return", "0", ";", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Size", "=", "MFI", "->", "getObjectSize", "(", "FrameIndex", ")", ";", "unsigned", "Alignment", "=", "MFI", "->", "getObjectAlignment", "(", "FrameIndex", ")", ";", "if", "(", "Ops", ".", "size", "(", ")", "==", "2", "&&", "Ops", "[", "0", "]", "==", "0", "&&", "Ops", "[", "1", "]", "==", "1", ")", "{", "unsigned", "NewOpc", "=", "0", ";", "unsigned", "RCSize", "=", "0", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "NULL", ";", "case", "X86", "::", "TEST8rr", ":", "NewOpc", "=", "X86", "::", "CMP8ri", ";", "RCSize", "=", "1", ";", "break", ";", "case", "X86", "::", "TEST16rr", ":", "NewOpc", "=", "X86", "::", "CMP16ri8", ";", "RCSize", "=", "2", ";", "break", ";", "case", "X86", "::", "TEST32rr", ":", "NewOpc", "=", "X86", "::", "CMP32ri8", ";", "RCSize", "=", "4", ";", "break", ";", "case", "X86", "::", "TEST64rr", ":", "NewOpc", "=", "X86", "::", "CMP64ri8", ";", "RCSize", "=", "8", ";", "break", ";", "}", "if", "(", "Size", "<", "RCSize", ")", "return", "NULL", ";", "MI", "->", "setDesc", "(", "get", "(", "NewOpc", ")", ")", ";", "MI", "->", "getOperand", "(", "1", ")", ".", "ChangeToImmediate", "(", "0", ")", ";", "}", "else", "if", "(", "Ops", ".", "size", "(", ")", "!=", "1", ")", "return", "NULL", ";", "SmallVector", "<", "MachineOperand", ",", "4", ">", "MOs", ";", "MOs", ".", "push_back", "(", "MachineOperand", "::", "CreateFI", "(", "FrameIndex", ")", ")", ";", "return", "foldMemoryOperandImpl", "(", "MF", ",", "MI", ",", "Ops", "[", "0", "]", ",", "MOs", ",", "Size", ",", "Alignment", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "2", "0", "0", "1", "1", "0", "0", "X86::TEST8rr", "X86::CMP8ri", "1", "X86::TEST16rr", "X86::CMP16ri8", "2", "X86::TEST32rr", "X86::CMP32ri8", "4", "X86::TEST64rr", "X86::CMP64ri8", "8", "1", "0", "1", "4", "0" ]

[]

[ "<s>", "void", "HexagonAsmPrinter", "::", "emitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MCInst", "MCB", ";", "MCB", ".", "setOpcode", "(", "Hexagon", "::", "BUNDLE", ")", ";", "MCB", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "const", "MCInstrInfo", "&", "MCII", "=", "*", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "MII", "=", "MI", "->", "getIterator", "(", ")", ";", "for", "(", "++", "MII", ";", "MII", "!=", "MBB", "->", "instr_end", "(", ")", "&&", "MII", "->", "isInsideBundle", "(", ")", ";", "++", "MII", ")", "if", "(", "!", "MII", "->", "isDebugInstr", "(", ")", "&&", "!", "MII", "->", "isImplicitDef", "(", ")", ")", "HexagonLowerToMC", "(", "MCII", ",", "&", "*", "MII", ",", "MCB", ",", "*", "this", ")", ";", "}", "else", "{", "HexagonLowerToMC", "(", "MCII", ",", "MI", ",", "MCB", ",", "*", "this", ")", ";", "}", "const", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "auto", "&", "HII", "=", "*", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "MI", "->", "isBundle", "(", ")", "&&", "HII", ".", "getBundleNoShuf", "(", "*", "MI", ")", ")", "HexagonMCInstrInfo", "::", "setMemReorderDisabled", "(", "MCB", ")", ";", "MCContext", "&", "Ctx", "=", "OutStreamer", "->", "getContext", "(", ")", ";", "bool", "Ok", "=", "HexagonMCInstrInfo", "::", "canonicalizePacket", "(", "MCII", ",", "*", "Subtarget", ",", "Ctx", ",", "MCB", ",", "nullptr", ")", ";", "assert", "(", "Ok", ")", ";", "(", "void", ")", "Ok", ";", "if", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "MCB", ")", "==", "0", ")", "return", ";", "OutStreamer", "->", "emitInstruction", "(", "MCB", ",", "getSubtargetInfo", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::BUNDLE", "0", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "0" ]

[]

[ "<s>", "unsigned", "R600InstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "TBB", "&&", "\"insertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "if", "(", "!", "FBB", ")", "{", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AMDGPU", "::", "JUMP", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "else", "{", "MachineInstr", "*", "PredSet", "=", "findFirstPredicateSetterFrom", "(", "MBB", ",", "MBB", ".", "end", "(", ")", ")", ";", "assert", "(", "PredSet", "&&", "\"No previous predicate !\"", ")", ";", "addFlag", "(", "*", "PredSet", ",", "0", ",", "MO_FLAG_PUSH", ")", ";", "PredSet", "->", "getOperand", "(", "2", ")", ".", "setImm", "(", "Cond", "[", "1", "]", ".", "getImm", "(", ")", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AMDGPU", "::", "JUMP_COND", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "addReg", "(", "AMDGPU", "::", "PREDICATE_BIT", ",", "RegState", "::", "Kill", ")", ";", "MachineBasicBlock", "::", "iterator", "CfAlu", "=", "FindLastAluClause", "(", "MBB", ")", ";", "if", "(", "CfAlu", "==", "MBB", ".", "end", "(", ")", ")", "return", "1", ";", "assert", "(", "CfAlu", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "CF_ALU", ")", ";", "CfAlu", "->", "setDesc", "(", "get", "(", "AMDGPU", "::", "CF_ALU_PUSH_BEFORE", ")", ")", ";", "return", "1", ";", "}", "}", "else", "{", "MachineInstr", "*", "PredSet", "=", "findFirstPredicateSetterFrom", "(", "MBB", ",", "MBB", ".", "end", "(", ")", ")", ";", "assert", "(", "PredSet", "&&", "\"No previous predicate !\"", ")", ";", "addFlag", "(", "*", "PredSet", ",", "0", ",", "MO_FLAG_PUSH", ")", ";", "PredSet", "->", "getOperand", "(", "2", ")", ".", "setImm", "(", "Cond", "[", "1", "]", ".", "getImm", "(", ")", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AMDGPU", "::", "JUMP_COND", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "addReg", "(", "AMDGPU", "::", "PREDICATE_BIT", ",", "RegState", "::", "Kill", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AMDGPU", "::", "JUMP", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "MachineBasicBlock", "::", "iterator", "CfAlu", "=", "FindLastAluClause", "(", "MBB", ")", ";", "if", "(", "CfAlu", "==", "MBB", ".", "end", "(", ")", ")", "return", "2", ";", "assert", "(", "CfAlu", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "CF_ALU", ")", ";", "CfAlu", "->", "setDesc", "(", "get", "(", "AMDGPU", "::", "CF_ALU_PUSH_BEFORE", ")", ")", ";", "return", "2", ";", "}", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "AMDGPU", "R600", "\"insertBranch must not be told to insert a fallthrough\"", "\"code size not handled\"", "AMDGPU::JUMP", "1", "\"No previous predicate !\"", "0", "2", "1", "AMDGPU::JUMP_COND", "AMDGPU::PREDICATE_BIT", "1", "AMDGPU::CF_ALU", "AMDGPU::CF_ALU_PUSH_BEFORE", "1", "\"No previous predicate !\"", "0", "2", "1", "AMDGPU::JUMP_COND", "AMDGPU::PREDICATE_BIT", "AMDGPU::JUMP", "2", "AMDGPU::CF_ALU", "AMDGPU::CF_ALU_PUSH_BEFORE", "2" ]

[]

[ "<s>", "static", "const", "char", "*", "output_branch", "(", "rtx", "label", ",", "const", "char", "*", "cond", ",", "rtx_insn", "*", "insn", ")", "{", "char", "str", "[", "64", "]", ";", "rtx", "operands", "[", "2", "]", ";", "gcc_assert", "(", "cond", ")", ";", "operands", "[", "0", "]", "=", "label", ";", "if", "(", "get_attr_length", "(", "insn", ")", ">", "12", ")", "{", "bool", "spilled", ";", "if", "(", "current_function_saves_lr", "(", ")", ")", "{", "operands", "[", "1", "]", "=", "regno_reg_rtx", "[", "LINK_REGNUM", "]", ";", "spilled", "=", "false", ";", "}", "else", "if", "(", "!", "df_regs_ever_live_p", "(", "long_branch_regnum", ")", ")", "{", "operands", "[", "1", "]", "=", "regno_reg_rtx", "[", "long_branch_regnum", "]", ";", "spilled", "=", "false", ";", "}", "else", "{", "operands", "[", "1", "]", "=", "regno_reg_rtx", "[", "long_branch_regnum", "]", ";", "spilled", "=", "true", ";", "gcc_assert", "(", "current_function_has_lr_slot", "(", ")", ")", ";", "}", "if", "(", "spilled", ")", "{", "if", "(", "final_sequence", ")", "{", "rtx_insn", "*", "delay", "=", "NEXT_INSN", "(", "insn", ")", ";", "gcc_assert", "(", "delay", ")", ";", "final_scan_insn", "(", "delay", ",", "asm_out_file", ",", "optimize", ",", "0", ",", "NULL", ")", ";", "PATTERN", "(", "delay", ")", "=", "gen_blockage", "(", ")", ";", "INSN_CODE", "(", "delay", ")", "=", "-", "1", ";", "}", "if", "(", "current_function_saves_fp", "(", ")", ")", "output_asm_insn", "(", "\"write.l 1(sp),%1\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\"write.l (sp),%1\"", ",", "operands", ")", ";", "}", "output_asm_insn", "(", "\"moviu %1,%%u %0\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"movil %1,%%l %0\"", ",", "operands", ")", ";", "strcpy", "(", "str", ",", "\"bra \"", ")", ";", "strcat", "(", "str", ",", "cond", ")", ";", "strcat", "(", "str", ",", "\",%1,%1\"", ")", ";", "if", "(", "!", "spilled", ")", "strcat", "(", "str", ",", "\"%#\"", ")", ";", "strcat", "(", "str", ",", "\"\\t\\t;long branch\"", ")", ";", "output_asm_insn", "(", "str", ",", "operands", ")", ";", "if", "(", "spilled", ")", "{", "if", "(", "current_function_saves_fp", "(", ")", ")", "output_asm_insn", "(", "\" read.l %1,1(sp)\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\" read.l %1,(sp)\"", ",", "operands", ")", ";", "}", "}", "else", "if", "(", "label", "==", "pc_rtx", ")", "{", "strcpy", "(", "str", ",", "\"bra \"", ")", ";", "strcat", "(", "str", ",", "cond", ")", ";", "strcat", "(", "str", ",", "\",r21,r0%#\\t\\t;return\"", ")", ";", "output_asm_insn", "(", "str", ",", "operands", ")", ";", "}", "else", "{", "strcpy", "(", "str", ",", "\"brr \"", ")", ";", "strcat", "(", "str", ",", "cond", ")", ";", "strcat", "(", "str", ",", "\",%0%#\"", ")", ";", "output_asm_insn", "(", "str", ",", "operands", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "a", "conditional/unconditional", "branch", "to", "LABEL", ".", "COND", "is", "the", "string", "condition", ".", "INSN", "is", "the", "instruction", "." ]

[ "visium", "64", "2", "0", "12", "1", "1", "1", "0", "1", "\"write.l 1(sp),%1\"", "\"write.l (sp),%1\"", "\"moviu %1,%%u %0\"", "\"movil %1,%%l %0\"", "\"bra \"", "\",%1,%1\"", "\"%#\"", "\"\\t\\t;long branch\"", "\" read.l %1,1(sp)\"", "\" read.l %1,(sp)\"", "\"bra \"", "\",r21,r0%#\\t\\t;return\"", "\"brr \"", "\",%0%#\"", "\"\"" ]

[]

[ "<s>", "static", "void", "init_alignment_context", "(", "struct", "alignment_context", "*", "ac", ",", "rtx", "mem", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "rtx", "byteoffset", "=", "NULL_RTX", ";", "bool", "aligned", "=", "(", "MEM_ALIGN", "(", "mem", ")", ">=", "GET_MODE_BITSIZE", "(", "SImode", ")", ")", ";", "if", "(", "aligned", ")", "ac", "->", "memsi", "=", "adjust_address", "(", "mem", ",", "SImode", ",", "0", ")", ";", "else", "{", "rtx", "addr", ",", "align", ";", "addr", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "mem", ",", "0", ")", ")", ";", "align", "=", "expand_simple_binop", "(", "Pmode", ",", "AND", ",", "addr", ",", "GEN_INT", "(", "-", "GET_MODE_SIZE", "(", "SImode", ")", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "ac", "->", "memsi", "=", "gen_rtx_MEM", "(", "SImode", ",", "align", ")", ";", "MEM_VOLATILE_P", "(", "ac", "->", "memsi", ")", "=", "MEM_VOLATILE_P", "(", "mem", ")", ";", "set_mem_alias_set", "(", "ac", "->", "memsi", ",", "ALIAS_SET_MEMORY_BARRIER", ")", ";", "set_mem_align", "(", "ac", "->", "memsi", ",", "GET_MODE_BITSIZE", "(", "SImode", ")", ")", ";", "byteoffset", "=", "expand_simple_binop", "(", "Pmode", ",", "AND", ",", "addr", ",", "GEN_INT", "(", "GET_MODE_SIZE", "(", "SImode", ")", "-", "1", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "}", "if", "(", "TARGET_BIG_ENDIAN", ")", "{", "ac", "->", "shift", "=", "GEN_INT", "(", "GET_MODE_SIZE", "(", "SImode", ")", "-", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "if", "(", "!", "aligned", ")", "ac", "->", "shift", "=", "expand_simple_binop", "(", "SImode", ",", "MINUS", ",", "ac", "->", "shift", ",", "byteoffset", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "}", "else", "{", "if", "(", "aligned", ")", "ac", "->", "shift", "=", "NULL_RTX", ";", "else", "ac", "->", "shift", "=", "byteoffset", ";", "}", "if", "(", "ac", "->", "shift", "!=", "NULL_RTX", ")", "{", "ac", "->", "shift", "=", "expand_simple_binop", "(", "SImode", ",", "MULT", ",", "ac", "->", "shift", ",", "GEN_INT", "(", "BITS_PER_UNIT", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "ac", "->", "modemask", "=", "expand_simple_binop", "(", "SImode", ",", "ASHIFT", ",", "GEN_INT", "(", "GET_MODE_MASK", "(", "mode", ")", ")", ",", "ac", "->", "shift", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "}", "else", "ac", "->", "modemask", "=", "GEN_INT", "(", "GET_MODE_MASK", "(", "mode", ")", ")", ";", "ac", "->", "modemaski", "=", "expand_simple_unop", "(", "SImode", ",", "NOT", ",", "ac", "->", "modemask", ",", "NULL_RTX", ",", "1", ")", ";", "}", "</s>" ]

[ "Initialize", "structure", "AC", "for", "word", "access", "to", "HI", "and", "QI", "mode", "memory", "." ]

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

[]

[ "<s>", "static", "bool", "classof", "(", "const", "CSKYConstantPoolValue", "*", "ACPV", ")", "{", "return", "ACPV", "->", "isJT", "(", ")", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY" ]

[]

[ "<s>", "virtual", "void", "Initialize", "(", "MCContext", "&", "ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TextSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getText", "(", ")", ")", ";", "DataSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "BSSSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getBSS", "(", ")", ")", ";", "ReadOnlySection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getReadOnly", "(", ")", ")", ";", "StaticCtorSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "StaticDtorSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "LSDASection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "EHFrameSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfAbbrevSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfInfoSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfLineSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfFrameSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfPubTypesSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfDebugInlineSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfStrSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfLocSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfARangesSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfRangesSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfMacroInfoSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "unsigned", "int", "arc_compute_frame_size", "(", "void", ")", "{", "int", "regno", ";", "unsigned", "int", "total_size", ",", "var_size", ",", "args_size", ",", "pretend_size", ",", "extra_size", ";", "unsigned", "int", "reg_size", ";", "unsigned", "int", "gmask", ";", "struct", "arc_frame_info", "*", "frame_info", ";", "int", "size", ";", "unsigned", "int", "extra_plus_reg_size", ";", "unsigned", "int", "extra_plus_reg_size_aligned", ";", "if", "(", "cfun", "->", "machine", "->", "frame_info", ".", "initialized", ")", "return", "cfun", "->", "machine", "->", "frame_info", ".", "total_size", ";", "frame_info", "=", "&", "cfun", "->", "machine", "->", "frame_info", ";", "size", "=", "ARC_STACK_ALIGN", "(", "get_frame_size", "(", ")", ")", ";", "var_size", "=", "size", ";", "args_size", "=", "crtl", "->", "outgoing_args_size", ";", "reg_size", "=", "0", ";", "gmask", "=", "0", ";", "for", "(", "regno", "=", "0", ";", "regno", "<=", "31", ";", "regno", "++", ")", "{", "if", "(", "arc_must_save_register", "(", "regno", ",", "cfun", ")", ")", "{", "reg_size", "+=", "UNITS_PER_WORD", ";", "gmask", "|=", "1L", "<<", "regno", ";", "}", "}", "if", "(", "crtl", "->", "calls_eh_return", ")", "for", "(", "regno", "=", "0", ";", "EH_RETURN_DATA_REGNO", "(", "regno", ")", "!=", "INVALID_REGNUM", ";", "regno", "++", ")", "{", "reg_size", "+=", "UNITS_PER_WORD", ";", "gmask", "|=", "1L", "<<", "regno", ";", "}", "frame_info", "->", "save_return_addr", "=", "(", "!", "crtl", "->", "is_leaf", "||", "df_regs_ever_live_p", "(", "RETURN_ADDR_REGNUM", ")", "||", "crtl", "->", "calls_eh_return", ")", ";", "if", "(", "TARGET_MILLICODE_THUNK_SET", "&&", "!", "crtl", "->", "calls_eh_return", ")", "{", "if", "(", "arc_compute_millicode_save_restore_regs", "(", "gmask", ",", "frame_info", ")", ")", "frame_info", "->", "save_return_addr", "=", "true", ";", "}", "extra_size", "=", "0", ";", "if", "(", "arc_must_save_return_addr", "(", "cfun", ")", ")", "extra_size", "=", "4", ";", "if", "(", "arc_frame_pointer_needed", "(", ")", ")", "extra_size", "+=", "4", ";", "pretend_size", "=", "crtl", "->", "args", ".", "pretend_args_size", ";", "extra_plus_reg_size", "=", "extra_size", "+", "reg_size", ";", "extra_plus_reg_size_aligned", "=", "ARC_STACK_ALIGN", "(", "extra_plus_reg_size", ")", ";", "reg_size", "=", "extra_plus_reg_size_aligned", "-", "extra_size", ";", "total_size", "=", "var_size", "+", "args_size", "+", "extra_size", "+", "pretend_size", "+", "reg_size", ";", "gcc_assert", "(", "total_size", "==", "ARC_STACK_ALIGN", "(", "total_size", ")", ")", ";", "frame_info", "->", "total_size", "=", "total_size", ";", "frame_info", "->", "extra_size", "=", "extra_size", ";", "frame_info", "->", "pretend_size", "=", "pretend_size", ";", "frame_info", "->", "var_size", "=", "var_size", ";", "frame_info", "->", "args_size", "=", "args_size", ";", "frame_info", "->", "reg_size", "=", "reg_size", ";", "frame_info", "->", "gmask", "=", "gmask", ";", "frame_info", "->", "initialized", "=", "reload_completed", ";", "return", "total_size", ";", "}", "</s>" ]

[ "Return", "the", "bytes", "needed", "to", "compute", "the", "frame", "pointer", "from", "the", "current", "stack", "pointer", ".", "SIZE", "is", "the", "size", "needed", "for", "local", "variables", "." ]

[ "arc", "0", "0", "0", "31", "1L", "0", "1L", "0", "4", "4" ]

[]

[ "<s>", "unsigned", "CSKYConstantIslands", "::", "getOffsetOf", "(", "MachineInstr", "*", "MI", ")", "const", "{", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "unsigned", "Offset", "=", "BBInfo", "[", "MBB", "->", "getNumber", "(", ")", "]", ".", "Offset", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", "->", "begin", "(", ")", ";", "&", "*", "I", "!=", "MI", ";", "++", "I", ")", "{", "assert", "(", "I", "!=", "MBB", "->", "end", "(", ")", "&&", "\"Didn't find MI in its own basic block?\"", ")", ";", "Offset", "+=", "TII", "->", "getInstSizeInBytes", "(", "*", "I", ")", ";", "}", "return", "Offset", ";", "}", "</s>" ]

[ "getOffsetOf", "-", "Return", "the", "current", "offset", "of", "the", "specified", "machine", "instruction", "from", "the", "start", "of", "the", "function", "." ]

[ "CSKY", "CSKY", "\"Didn't find MI in its own basic block?\"" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "return", "createMachObjectWriter", "(", "OS", ",", "false", ",", "object", "::", "mach", "::", "CTM_ARM", ",", "object", "::", "mach", "::", "CSARM_V7", ",", "true", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "rtx_insn", "*", "riscv_sr_match_prologue", "(", "rtx_insn", "*", "*", "body", ")", "{", "rtx_insn", "*", "insn", ",", "*", "bb_note", ";", "*", "body", "=", "NULL", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", "!=", "NULL", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "NOTE_P", "(", "insn", ")", "&&", "NOTE_KIND", "(", "insn", ")", "==", "NOTE_INSN_PROLOGUE_END", ")", "{", "*", "body", "=", "NEXT_INSN", "(", "insn", ")", ";", "break", ";", "}", "if", "(", "insn", "==", "NULL", "||", "PREV_INSN", "(", "insn", ")", "==", "NULL", ")", "return", "NULL", ";", "for", "(", "bb_note", "=", "PREV_INSN", "(", "PREV_INSN", "(", "insn", ")", ")", ";", "bb_note", "!=", "NULL", ";", "bb_note", "=", "PREV_INSN", "(", "bb_note", ")", ")", "{", "if", "(", "!", "NOTE_P", "(", "bb_note", ")", ")", "return", "NULL", ";", "if", "(", "NOTE_KIND", "(", "bb_note", ")", "==", "NOTE_INSN_BASIC_BLOCK", ")", "break", ";", "if", "(", "NOTE_KIND", "(", "bb_note", ")", "!=", "NOTE_INSN_DELETED", "&&", "NOTE_KIND", "(", "bb_note", ")", "!=", "NOTE_INSN_FUNCTION_BEG", ")", "return", "NULL", ";", "}", "if", "(", "bb_note", "==", "NULL", ")", "return", "NULL", ";", "insn", "=", "PREV_INSN", "(", "insn", ")", ";", "if", "(", "INSN_P", "(", "insn", ")", "&&", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_gpr_save", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "PARALLEL", "&&", "GET_CODE", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "0", ")", ")", "==", "UNSPEC_VOLATILE", "&&", "(", "GET_CODE", "(", "XVECEXP", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "0", ")", ",", "0", ",", "0", ")", ")", "==", "CONST_INT", ")", "&&", "INTVAL", "(", "XVECEXP", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "0", ")", ",", "0", ",", "0", ")", ")", "==", "0", ")", "return", "insn", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Look", "in", "the", "function", "prologue", "for", "a", "call", "to", "the", "save", "stub", ".", "Ensure", "that", "the", "instruction", "is", "as", "we", "expect", "(", "see", "detail", "below", ")", "and", "if", "the", "instruction", "matches", "return", "a", "pointer", "to", "it", ".", "Otherwise", ",", "return", "NULL", ".", "We", "expect", "the", "function", "prologue", "to", "look", "like", "this", ":", "(", "note", "NOTE_INSN_BASIC_BLOCK", ")", "(", "insn", "(", "parallel", "[", "(", "unspec_volatile", "[", "(", "const_int", "2", "[", "0x2", "]", ")", "]", "UNSPECV_GPR_SAVE", ")", "(", "clobber", "(", "reg", ":", "SI", "5", "t0", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "6", "t1", ")", ")", "]", ")", "(", "note", "NOTE_INSN_PROLOGUE_END", ")", "Between", "the", "NOTE_INSN_BASIC_BLOCK", "and", "the", "GPR_SAVE", "insn", "we", "might", "find", "other", "notes", "of", "type", "NOTE_INSN_DELETED", "and/or", "NOTE_INSN_FUNCTION_BEG", ".", "The", "parameter", "BODY", "is", "updated", "to", "point", "to", "the", "first", "instruction", "after", "the", "NOTE_INSN_PROLOGUE_END", "or", "will", "be", "updated", "to", "NULL", "if", "the", "prologue", "end", "note", "was", "not", "found", "." ]

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

[]

[ "<s>", "rtx", "riscv_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "ignore", "ATTRIBUTE_UNUSED", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "unsigned", "int", "fcode", "=", "DECL_MD_FUNCTION_CODE", "(", "fndecl", ")", ";", "const", "struct", "riscv_builtin_description", "*", "d", "=", "&", "riscv_builtins", "[", "fcode", "]", ";", "switch", "(", "d", "->", "builtin_type", ")", "{", "case", "RISCV_BUILTIN_DIRECT", ":", "return", "riscv_expand_builtin_direct", "(", "d", "->", "icode", ",", "target", ",", "exp", ",", "true", ")", ";", "case", "RISCV_BUILTIN_DIRECT_NO_TARGET", ":", "return", "riscv_expand_builtin_direct", "(", "d", "->", "icode", ",", "target", ",", "exp", ",", "false", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_EXPAND_BUILTIN", "." ]

[ "riscv", "0" ]

[]

[ "<s>", "const", "uint32_t", "*", "LanaiRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "return", "CSR_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "." ]

[ "Lanai", "Lanai" ]

[]

[ "<s>", "void", "mmix_asm_output_reg_push", "(", "FILE", "*", "stream", ",", "int", "regno", ")", "{", "fprintf", "(", "stream", ",", "\"\\tSUBU %s,%s,8\\n\\tSTOU %s,%s,0\\n\"", ",", "reg_names", "[", "MMIX_STACK_POINTER_REGNUM", "]", ",", "reg_names", "[", "MMIX_STACK_POINTER_REGNUM", "]", ",", "reg_names", "[", "MMIX_OUTPUT_REGNO", "(", "regno", ")", "]", ",", "reg_names", "[", "MMIX_STACK_POINTER_REGNUM", "]", ")", ";", "}", "</s>" ]

[ "ASM_OUTPUT_REG_PUSH", "." ]

[ "mmix", "\"\\tSUBU %s,%s,8\\n\\tSTOU %s,%s,0\\n\"" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "legalizeOpWithMove", "(", "MachineInstr", "*", "MI", ",", "unsigned", "OpIdx", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MI", ";", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpIdx", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "unsigned", "RCID", "=", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ".", "OpInfo", "[", "OpIdx", "]", ".", "RegClass", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getRegClass", "(", "RCID", ")", ";", "unsigned", "Opcode", "=", "AMDGPU", "::", "V_MOV_B32_e32", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "Opcode", "=", "AMDGPU", "::", "COPY", ";", "}", "else", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "Opcode", "=", "AMDGPU", "::", "S_MOV_B32", ";", "}", "const", "TargetRegisterClass", "*", "VRC", "=", "RI", ".", "getEquivalentVGPRClass", "(", "RC", ")", ";", "if", "(", "RI", ".", "getCommonSubClass", "(", "&", "AMDGPU", "::", "VReg_64RegClass", ",", "VRC", ")", ")", "{", "VRC", "=", "&", "AMDGPU", "::", "VReg_64RegClass", ";", "}", "else", "{", "VRC", "=", "&", "AMDGPU", "::", "VReg_32RegClass", ";", "}", "unsigned", "Reg", "=", "MRI", ".", "createVirtualRegister", "(", "VRC", ")", ";", "BuildMI", "(", "*", "MI", "->", "getParent", "(", ")", ",", "I", ",", "MI", "->", "getParent", "(", ")", "->", "findDebugLoc", "(", "I", ")", ",", "get", "(", "Opcode", ")", ",", "Reg", ")", ".", "addOperand", "(", "MO", ")", ";", "MO", ".", "ChangeToRegister", "(", "Reg", ",", "false", ")", ";", "}", "</s>" ]

[ "Legalize", "the", "OpIndex", "operand", "of", "this", "instruction", "by", "inserting", "a", "MOV", "." ]

[ "R600", "SI" ]

[]

[ "<s>", "MVT", "WebAssemblyTargetLowering", "::", "getScalarShiftAmountTy", "(", "const", "DataLayout", "&", ",", "EVT", "VT", ")", "const", "{", "unsigned", "BitWidth", "=", "NextPowerOf2", "(", "VT", ".", "getSizeInBits", "(", ")", "-", "1", ")", ";", "if", "(", "BitWidth", ">", "1", "&&", "BitWidth", "<", "8", ")", "BitWidth", "=", "8", ";", "if", "(", "BitWidth", ">", "64", ")", "{", "BitWidth", "=", "64", ";", "assert", "(", "BitWidth", ">=", "Log2_32_Ceil", "(", "VT", ".", "getSizeInBits", "(", ")", ")", "&&", "\"64-bit shift counts ought to be enough for anyone\"", ")", ";", "}", "MVT", "Result", "=", "MVT", "::", "getIntegerVT", "(", "BitWidth", ")", ";", "assert", "(", "Result", "!=", "MVT", "::", "INVALID_SIMPLE_VALUE_TYPE", "&&", "\"Unable to represent scalar shift amount type\"", ")", ";", "return", "Result", ";", "}", "</s>" ]

[ "Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "." ]

[ "WebAssembly", "WebAssembly", "1", "1", "8", "8", "64", "64", "\"64-bit shift counts ought to be enough for anyone\"", "MVT::getIntegerVT", "MVT::INVALID_SIMPLE_VALUE_TYPE", "\"Unable to represent scalar shift amount type\"" ]

[]

[ "<s>", "static", "bool", "ix86_can_inline_p", "(", "tree", "caller", ",", "tree", "callee", ")", "{", "tree", "caller_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "caller", ")", ";", "tree", "callee_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "callee", ")", ";", "const", "unsigned", "HOST_WIDE_INT", "always_inline_safe_mask", "=", "(", "MASK_USE_8BIT_IDIV", "|", "MASK_ACCUMULATE_OUTGOING_ARGS", "|", "MASK_NO_ALIGN_STRINGOPS", "|", "MASK_AVX256_SPLIT_UNALIGNED_LOAD", "|", "MASK_AVX256_SPLIT_UNALIGNED_STORE", "|", "MASK_CLD", "|", "MASK_NO_FANCY_MATH_387", "|", "MASK_IEEE_FP", "|", "MASK_INLINE_ALL_STRINGOPS", "|", "MASK_INLINE_STRINGOPS_DYNAMICALLY", "|", "MASK_RECIP", "|", "MASK_STACK_PROBE", "|", "MASK_STV", "|", "MASK_TLS_DIRECT_SEG_REFS", "|", "MASK_VZEROUPPER", "|", "MASK_NO_PUSH_ARGS", "|", "MASK_OMIT_LEAF_FRAME_POINTER", ")", ";", "if", "(", "!", "callee_tree", ")", "callee_tree", "=", "target_option_default_node", ";", "if", "(", "!", "caller_tree", ")", "caller_tree", "=", "target_option_default_node", ";", "if", "(", "callee_tree", "==", "caller_tree", ")", "return", "true", ";", "struct", "cl_target_option", "*", "caller_opts", "=", "TREE_TARGET_OPTION", "(", "caller_tree", ")", ";", "struct", "cl_target_option", "*", "callee_opts", "=", "TREE_TARGET_OPTION", "(", "callee_tree", ")", ";", "bool", "ret", "=", "false", ";", "bool", "always_inline", "=", "(", "DECL_DISREGARD_INLINE_LIMITS", "(", "callee", ")", "&&", "lookup_attribute", "(", "\"always_inline\"", ",", "DECL_ATTRIBUTES", "(", "callee", ")", ")", ")", ";", "if", "(", "(", "(", "caller_opts", "->", "x_ix86_isa_flags", "&", "callee_opts", "->", "x_ix86_isa_flags", ")", "!=", "callee_opts", "->", "x_ix86_isa_flags", ")", "||", "(", "(", "caller_opts", "->", "x_ix86_isa_flags2", "&", "callee_opts", "->", "x_ix86_isa_flags2", ")", "!=", "callee_opts", "->", "x_ix86_isa_flags2", ")", ")", "ret", "=", "false", ";", "else", "if", "(", "(", "!", "always_inline", "&&", "caller_opts", "->", "x_target_flags", "!=", "callee_opts", "->", "x_target_flags", ")", "||", "(", "caller_opts", "->", "x_target_flags", "&", "~", "always_inline_safe_mask", ")", "!=", "(", "callee_opts", "->", "x_target_flags", "&", "~", "always_inline_safe_mask", ")", ")", "ret", "=", "false", ";", "else", "if", "(", "caller_opts", "->", "arch", "!=", "callee_opts", "->", "arch", ")", "ret", "=", "false", ";", "else", "if", "(", "!", "always_inline", "&&", "caller_opts", "->", "tune", "!=", "callee_opts", "->", "tune", ")", "ret", "=", "false", ";", "else", "if", "(", "caller_opts", "->", "x_ix86_fpmath", "!=", "callee_opts", "->", "x_ix86_fpmath", "&&", "(", "!", "ipa_fn_summaries", "||", "ipa_fn_summaries", "->", "get", "(", "cgraph_node", "::", "get", "(", "callee", ")", ")", "->", "fp_expressions", ")", ")", "ret", "=", "false", ";", "else", "if", "(", "!", "always_inline", "&&", "caller_opts", "->", "branch_cost", "!=", "callee_opts", "->", "branch_cost", ")", "ret", "=", "false", ";", "else", "ret", "=", "true", ";", "return", "ret", ";", "}", "</s>" ]

[ "Hook", "to", "determine", "if", "one", "function", "can", "safely", "inline", "another", "." ]

[ "i386", "\"always_inline\"" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "unsigned", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_PPC", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "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", "(", ")", ",", "Outs", "[", "i", "]", ".", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "PPCISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "Flag", ")", ";", "else", "return", "DAG", ".", "getNode", "(", "PPCISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "ISD::OutputArg", "16", "PPC", "0", "0", "\"Can only return in registers!\"", "1", "PPCISD::RET_FLAG", "MVT::Other", "PPCISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "bool", "XCoreAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "SetupMachineFunction", "(", "MF", ")", ";", "EmitConstantPool", "(", ")", ";", "emitFunctionStart", "(", "MF", ")", ";", "DW", "->", "BeginFunction", "(", "&", "MF", ")", ";", "EmitFunctionBody", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "XCore", "XCore" ]

[]

[ "<s>", "void", "s390_emit_jump", "(", "rtx", "target", ",", "rtx", "cond", ")", "{", "rtx", "insn", ";", "target", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "target", ")", ";", "if", "(", "cond", ")", "target", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "cond", ",", "target", ",", "pc_rtx", ")", ";", "insn", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "target", ")", ";", "emit_jump_insn", "(", "insn", ")", ";", "}", "</s>" ]

[ "Emit", "a", "jump", "instruction", "to", "TARGET", ".", "If", "COND", "is", "NULL_RTX", ",", "emit", "an", "unconditional", "jump", ",", "else", "a", "conditional", "jump", "under", "condition", "COND", "." ]

[ "s390" ]

[]

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

[ "Get", "the", "number", "of", "blocks", "in", "this", "loop", "in", "constant", "time", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "static", "bool", "mips_mode_ok_for_mov_fmt_p", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "CCFmode", ":", "case", "SFmode", ":", "return", "TARGET_HARD_FLOAT", ";", "case", "DFmode", ":", "return", "TARGET_HARD_FLOAT", "&&", "TARGET_DOUBLE_FLOAT", ";", "case", "V2SFmode", ":", "return", "TARGET_HARD_FLOAT", "&&", "TARGET_PAIRED_SINGLE_FLOAT", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "moves", "in", "mode", "MODE", "can", "use", "the", "FPU", "'s", "mov.fmt", "instruction", "." ]

[ "mips" ]

[]

[ "<s>", "DFAPacketizer", "*", "PatmosInstrInfo", "::", "CreateTargetScheduleState", "(", "const", "TargetSubtargetInfo", "&", "STI", ")", "const", "{", "const", "InstrItineraryData", "*", "II", "=", "STI", ".", "getInstrItineraryData", "(", ")", ";", "return", "static_cast", "<", "const", "PatmosSubtarget", "&", ">", "(", "STI", ")", ".", "createDFAPacketizer", "(", "II", ")", ";", "}", "</s>" ]

[ "Create", "machine", "specific", "model", "for", "scheduling", "." ]

[ "Patmos", "Patmos", "Patmos" ]

[]

[ "<s>", "virtual", "void", "*", "getAdjustedAnalysisPointer", "(", "const", "void", "*", "ID", ")", "override", "{", "if", "(", "ID", "==", "&", "TargetTransformInfo", "::", "ID", ")", "return", "(", "TargetTransformInfo", "*", ")", "this", ";", "return", "this", ";", "}", "</s>" ]

[ "getAdjustedAnalysisPointer", "-", "This", "method", "is", "used", "when", "a", "pass", "implements", "an", "analysis", "interface", "through", "multiple", "inheritance", "." ]

[ "XCore" ]

[]

[ "<s>", "rtx", "expand", "(", "function_expander", "&", "e", ")", "const", "OVERRIDE", "{", "if", "(", "m_su", ")", "e", ".", "rotate_inputs_left", "(", "1", ",", "2", ")", ";", "e", ".", "rotate_inputs_left", "(", "0", ",", "3", ")", ";", "machine_mode", "mode", "=", "e", ".", "vector_mode", "(", "0", ")", ";", "insn_code", "icode", "=", "code_for_dot_prod", "(", "UNSPEC_USDOT", ",", "mode", ")", ";", "return", "e", ".", "use_exact_insn", "(", "icode", ")", ";", "}", "</s>" ]

[ "Expand", "the", "call", "and", "return", "its", "lhs", "." ]

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

[]

[ "<s>", "const", "char", "*", "HexagonTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "nullptr", ";", "case", "HexagonISD", "::", "CONST32", ":", "return", "\"HexagonISD::CONST32\"", ";", "case", "HexagonISD", "::", "CONST32_GP", ":", "return", "\"HexagonISD::CONST32_GP\"", ";", "case", "HexagonISD", "::", "CONST32_Int_Real", ":", "return", "\"HexagonISD::CONST32_Int_Real\"", ";", "case", "HexagonISD", "::", "ADJDYNALLOC", ":", "return", "\"HexagonISD::ADJDYNALLOC\"", ";", "case", "HexagonISD", "::", "CMPICC", ":", "return", "\"HexagonISD::CMPICC\"", ";", "case", "HexagonISD", "::", "CMPFCC", ":", "return", "\"HexagonISD::CMPFCC\"", ";", "case", "HexagonISD", "::", "BRICC", ":", "return", "\"HexagonISD::BRICC\"", ";", "case", "HexagonISD", "::", "BRFCC", ":", "return", "\"HexagonISD::BRFCC\"", ";", "case", "HexagonISD", "::", "SELECT_ICC", ":", "return", "\"HexagonISD::SELECT_ICC\"", ";", "case", "HexagonISD", "::", "SELECT_FCC", ":", "return", "\"HexagonISD::SELECT_FCC\"", ";", "case", "HexagonISD", "::", "Hi", ":", "return", "\"HexagonISD::Hi\"", ";", "case", "HexagonISD", "::", "Lo", ":", "return", "\"HexagonISD::Lo\"", ";", "case", "HexagonISD", "::", "FTOI", ":", "return", "\"HexagonISD::FTOI\"", ";", "case", "HexagonISD", "::", "ITOF", ":", "return", "\"HexagonISD::ITOF\"", ";", "case", "HexagonISD", "::", "CALL", ":", "return", "\"HexagonISD::CALL\"", ";", "case", "HexagonISD", "::", "RET_FLAG", ":", "return", "\"HexagonISD::RET_FLAG\"", ";", "case", "HexagonISD", "::", "BR_JT", ":", "return", "\"HexagonISD::BR_JT\"", ";", "case", "HexagonISD", "::", "TC_RETURN", ":", "return", "\"HexagonISD::TC_RETURN\"", ";", "case", "HexagonISD", "::", "EH_RETURN", ":", "return", "\"HexagonISD::EH_RETURN\"", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "HexagonISD::CONST32", "\"HexagonISD::CONST32\"", "HexagonISD::CONST32_GP", "\"HexagonISD::CONST32_GP\"", "HexagonISD::CONST32_Int_Real", "\"HexagonISD::CONST32_Int_Real\"", "HexagonISD::ADJDYNALLOC", "\"HexagonISD::ADJDYNALLOC\"", "HexagonISD::CMPICC", "\"HexagonISD::CMPICC\"", "HexagonISD::CMPFCC", "\"HexagonISD::CMPFCC\"", "HexagonISD::BRICC", "\"HexagonISD::BRICC\"", "HexagonISD::BRFCC", "\"HexagonISD::BRFCC\"", "HexagonISD::SELECT_ICC", "\"HexagonISD::SELECT_ICC\"", "HexagonISD::SELECT_FCC", "\"HexagonISD::SELECT_FCC\"", "HexagonISD::Hi", "\"HexagonISD::Hi\"", "HexagonISD::Lo", "\"HexagonISD::Lo\"", "HexagonISD::FTOI", "\"HexagonISD::FTOI\"", "HexagonISD::ITOF", "\"HexagonISD::ITOF\"", "HexagonISD::CALL", "\"HexagonISD::CALL\"", "HexagonISD::RET_FLAG", "\"HexagonISD::RET_FLAG\"", "HexagonISD::BR_JT", "\"HexagonISD::BR_JT\"", "HexagonISD::TC_RETURN", "\"HexagonISD::TC_RETURN\"", "HexagonISD::EH_RETURN", "\"HexagonISD::EH_RETURN\"" ]

[]

[ "<s>", "static", "int", "first_altivec_reg_to_save", "(", ")", "{", "int", "i", ";", "if", "(", "!", "TARGET_ALTIVEC_ABI", ")", "return", "LAST_ALTIVEC_REGNO", "+", "1", ";", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", "+", "20", ";", "i", "<=", "LAST_ALTIVEC_REGNO", ";", "++", "i", ")", "if", "(", "regs_ever_live", "[", "i", "]", ")", "break", ";", "return", "i", ";", "}", "</s>" ]

[ "Similar", ",", "for", "AltiVec", "regs", "." ]

[ "rs6000", "1", "20" ]

[]

[ "<s>", "static", "tree", "pa_d_handle_target_float_abi", "(", "void", ")", "{", "const", "char", "*", "abi", ";", "if", "(", "TARGET_DISABLE_FPREGS", "||", "TARGET_SOFT_FLOAT", ")", "abi", "=", "\"soft\"", ";", "else", "abi", "=", "\"hard\"", ";", "return", "build_string_literal", "(", "strlen", "(", "abi", ")", "+", "1", ",", "abi", ")", ";", "}", "</s>" ]

[ "Handle", "a", "call", "to", "`", "__traits", "(", "getTargetInfo", ",", "``", "floatAbi", "''", ")", "'", "." ]

[ "pa", "\"soft\"", "\"hard\"", "1" ]

[]

[ "<s>", "static", "void", "mips16_rewrite_pool_refs", "(", "rtx_insn", "*", "insn", ",", "struct", "mips16_constant_pool", "*", "pool", ")", "{", "subrtx_ptr_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX_PTR", "(", "iter", ",", "array", ",", "&", "PATTERN", "(", "insn", ")", ",", "ALL", ")", "{", "rtx", "*", "loc", "=", "*", "iter", ";", "if", "(", "force_to_mem_operand", "(", "*", "loc", ",", "Pmode", ")", ")", "{", "rtx", "mem", "=", "force_const_mem", "(", "GET_MODE", "(", "*", "loc", ")", ",", "*", "loc", ")", ";", "validate_change", "(", "insn", ",", "loc", ",", "mem", ",", "false", ")", ";", "}", "if", "(", "MEM_P", "(", "*", "loc", ")", ")", "{", "mips16_rewrite_pool_constant", "(", "pool", ",", "&", "XEXP", "(", "*", "loc", ",", "0", ")", ")", ";", "iter", ".", "skip_subrtxes", "(", ")", ";", "}", "else", "{", "if", "(", "TARGET_MIPS16_TEXT_LOADS", ")", "mips16_rewrite_pool_constant", "(", "pool", ",", "loc", ")", ";", "if", "(", "GET_CODE", "(", "*", "loc", ")", "==", "CONST", "||", "(", "GET_CODE", "(", "*", "loc", ")", "==", "UNSPEC", "&&", "XINT", "(", "*", "loc", ",", "1", ")", "==", "UNSPEC_TLS_GET_TP", ")", ")", "iter", ".", "skip_subrtxes", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "Rewrite", "*", "X", "so", "that", "constant", "pool", "references", "refer", "to", "the", "constant", "'s", "label", "instead", ".", "DATA", "points", "to", "the", "constant", "pool", "structure", "." ]

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

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "bool", "Is64Bit", "=", "Subtarget", "->", "is64Bit", "(", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_X86", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "EVT", "CopyVT", "=", "VA", ".", "getValVT", "(", ")", ";", "if", "(", "(", "CopyVT", "==", "MVT", "::", "f32", "||", "CopyVT", "==", "MVT", "::", "f64", ")", "&&", "(", "(", "Is64Bit", "||", "Ins", "[", "i", "]", ".", "Flags", ".", "isInReg", "(", ")", ")", "&&", "!", "Subtarget", "->", "hasSSE1", "(", ")", ")", ")", "{", "report_fatal_error", "(", "\"SSE register return with SSE disabled\"", ")", ";", "}", "SDValue", "Val", ";", "if", "(", "VA", ".", "getLocReg", "(", ")", "==", "X86", "::", "ST0", "||", "VA", ".", "getLocReg", "(", ")", "==", "X86", "::", "ST1", ")", "{", "if", "(", "isScalarFPTypeInSSEReg", "(", "VA", ".", "getValVT", "(", ")", ")", ")", "CopyVT", "=", "MVT", "::", "f80", ";", "SDValue", "Ops", "[", "]", "=", "{", "Chain", ",", "InFlag", "}", ";", "Chain", "=", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "X86", "::", "FpPOP_RETVAL", ",", "dl", ",", "CopyVT", ",", "MVT", "::", "Other", ",", "MVT", "::", "Glue", ",", "Ops", ")", ",", "1", ")", ";", "Val", "=", "Chain", ".", "getValue", "(", "0", ")", ";", "if", "(", "CopyVT", "!=", "VA", ".", "getValVT", "(", ")", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_ROUND", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ",", "DAG", ".", "getIntPtrConstant", "(", "1", ")", ")", ";", "}", "else", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "CopyVT", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "Val", "=", "Chain", ".", "getValue", "(", "0", ")", ";", "}", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "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", "." ]

[ "X86", "X86", "ISD::InputArg", "16", "X86", "0", "MVT::f32", "MVT::f64", "\"SSE register return with SSE disabled\"", "X86::ST0", "X86::ST1", "MVT::f80", "X86::FpPOP_RETVAL", "MVT::Other", "MVT::Glue", "1", "0", "ISD::FP_ROUND", "1", "1", "0", "2" ]

[]

[ "<s>", "void", "WebAssemblyAsmPrinter", "::", "emitGlobalVariable", "(", "const", "GlobalVariable", "*", "GV", ")", "{", "if", "(", "!", "WebAssembly", "::", "isWasmVarAddressSpace", "(", "GV", "->", "getAddressSpace", "(", ")", ")", ")", "{", "AsmPrinter", "::", "emitGlobalVariable", "(", "GV", ")", ";", "return", ";", "}", "assert", "(", "!", "GV", "->", "isThreadLocal", "(", ")", ")", ";", "MCSymbolWasm", "*", "Sym", "=", "cast", "<", "MCSymbolWasm", ">", "(", "getSymbol", "(", "GV", ")", ")", ";", "if", "(", "!", "Sym", "->", "getType", "(", ")", ")", "{", "const", "WebAssemblyTargetLowering", "&", "TLI", "=", "*", "Subtarget", "->", "getTargetLowering", "(", ")", ";", "SmallVector", "<", "EVT", ",", "1", ">", "VTs", ";", "ComputeValueVTs", "(", "TLI", ",", "GV", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ",", "GV", "->", "getValueType", "(", ")", ",", "VTs", ")", ";", "if", "(", "VTs", ".", "size", "(", ")", "!=", "1", "||", "TLI", ".", "getNumRegisters", "(", "GV", "->", "getParent", "(", ")", "->", "getContext", "(", ")", ",", "VTs", "[", "0", "]", ")", "!=", "1", ")", "report_fatal_error", "(", "\"Aggregate globals not yet implemented\"", ")", ";", "MVT", "VT", "=", "TLI", ".", "getRegisterType", "(", "GV", "->", "getParent", "(", ")", "->", "getContext", "(", ")", ",", "VTs", "[", "0", "]", ")", ";", "bool", "Mutable", "=", "true", ";", "wasm", "::", "ValType", "Type", "=", "WebAssembly", "::", "toValType", "(", "VT", ")", ";", "Sym", "->", "setType", "(", "wasm", "::", "WASM_SYMBOL_TYPE_GLOBAL", ")", ";", "Sym", "->", "setGlobalType", "(", "wasm", "::", "WasmGlobalType", "{", "uint8_t", "(", "Type", ")", ",", "Mutable", "}", ")", ";", "}", "if", "(", "Sym", "->", "isTable", "(", ")", ")", "{", "getTargetStreamer", "(", ")", "->", "emitTableType", "(", "Sym", ")", ";", "return", ";", "}", "emitVisibility", "(", "Sym", ",", "GV", "->", "getVisibility", "(", ")", ",", "!", "GV", "->", "isDeclaration", "(", ")", ")", ";", "if", "(", "GV", "->", "hasInitializer", "(", ")", ")", "{", "assert", "(", "getSymbolPreferLocal", "(", "*", "GV", ")", "==", "Sym", ")", ";", "emitLinkage", "(", "GV", ",", "Sym", ")", ";", "getTargetStreamer", "(", ")", "->", "emitGlobalType", "(", "Sym", ")", ";", "OutStreamer", "->", "emitLabel", "(", "Sym", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "}", "</s>" ]

[ "Emit", "the", "specified", "global", "variable", "to", "the", ".s", "file", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly::isWasmVarAddressSpace", "WebAssembly", "1", "1", "0", "1", "\"Aggregate globals not yet implemented\"", "0", "wasm::ValType", "WebAssembly::toValType", "wasm::WASM_SYMBOL_TYPE_GLOBAL", "wasm::WasmGlobalType" ]

[]

[ "<s>", "static", "tree", "arm_build_builtin_va_list", "(", "void", ")", "{", "tree", "va_list_name", ";", "tree", "ap_field", ";", "if", "(", "!", "TARGET_AAPCS_BASED", ")", "return", "std_build_builtin_va_list", "(", ")", ";", "va_list_type", "=", "lang_hooks", ".", "types", ".", "make_type", "(", "RECORD_TYPE", ")", ";", "va_list_name", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "TYPE_DECL", ",", "get_identifier", "(", "\"__va_list\"", ")", ",", "va_list_type", ")", ";", "DECL_ARTIFICIAL", "(", "va_list_name", ")", "=", "1", ";", "TYPE_NAME", "(", "va_list_type", ")", "=", "va_list_name", ";", "TYPE_STUB_DECL", "(", "va_list_type", ")", "=", "va_list_name", ";", "ap_field", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__ap\"", ")", ",", "ptr_type_node", ")", ";", "DECL_ARTIFICIAL", "(", "ap_field", ")", "=", "1", ";", "DECL_FIELD_CONTEXT", "(", "ap_field", ")", "=", "va_list_type", ";", "TYPE_FIELDS", "(", "va_list_type", ")", "=", "ap_field", ";", "layout_type", "(", "va_list_type", ")", ";", "return", "va_list_type", ";", "}", "</s>" ]

[ "Return", "the", "type", "to", "use", "as", "__builtin_va_list", "." ]

[ "arm", "\"__va_list\"", "1", "\"__ap\"", "1" ]

[]

[ "<s>", "static", "bool", "insn_defines_reg", "(", "unsigned", "int", "regno1", ",", "unsigned", "int", "regno2", ",", "rtx_insn", "*", "insn", ")", "{", "df_ref", "def", ";", "FOR_EACH_INSN_DEF", "(", "def", ",", "insn", ")", "if", "(", "DF_REF_REG_DEF_P", "(", "def", ")", "&&", "!", "DF_REF_IS_ARTIFICIAL", "(", "def", ")", "&&", "(", "regno1", "==", "DF_REF_REGNO", "(", "def", ")", "||", "regno2", "==", "DF_REF_REGNO", "(", "def", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Function", "checks", "if", "instruction", "INSN", "defines", "register", "number", "REGNO1", "or", "REGNO2", "." ]

[ "i386" ]

[]

[ "<s>", "void", "AlphaRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "bool", "FP", "=", "hasFP", "(", "MF", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToRegister", "(", "FP", "?", "Alpha", "::", "R15", ":", "Alpha", "::", "R30", ",", "false", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"FI: \"", "<<", "FrameIndex", "<<", "\" Offset: \"", "<<", "Offset", "<<", "\"\\n\"", ")", ";", "Offset", "+=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Corrected Offset \"", "<<", "Offset", "<<", "\" for stack size: \"", "<<", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Offset", ">", "IMM_HIGH", "||", "Offset", "<", "IMM_LOW", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"Unconditionally using R28 for evil purposes Offset: \"", "<<", "Offset", "<<", "\"\\n\"", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToRegister", "(", "Alpha", "::", "R28", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToImmediate", "(", "getLower16", "(", "Offset", ")", ")", ";", "MachineInstr", "*", "nMI", "=", "BuildMI", "(", "MF", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Alpha", "::", "LDAH", ")", ",", "Alpha", "::", "R28", ")", ".", "addImm", "(", "getUpper16", "(", "Offset", ")", ")", ".", "addReg", "(", "FP", "?", "Alpha", "::", "R15", ":", "Alpha", "::", "R30", ")", ";", "MBB", ".", "insert", "(", "II", ",", "nMI", ")", ";", "}", "else", "{", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "}", "</s>" ]

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

[ "Alpha", "Alpha", "0", "\"Unexpected\"", "0", "\"Instr doesn't have FrameIndex operand!\"", "1", "Alpha::R15", "Alpha::R30", "\"FI: \"", "\" Offset: \"", "\"\\n\"", "\"Corrected Offset \"", "\" for stack size: \"", "\"\\n\"", "\"Unconditionally using R28 for evil purposes Offset: \"", "\"\\n\"", "1", "Alpha::R28", "Alpha::LDAH", "Alpha::R28", "Alpha::R15", "Alpha::R30" ]

[]

[ "<s>", "static", "void", "arc_ccfsm_post_advance", "(", "rtx_insn", "*", "insn", ",", "struct", "arc_ccfsm", "*", "state", ")", "{", "enum", "attr_type", "type", ";", "if", "(", "LABEL_P", "(", "insn", ")", ")", "arc_ccfsm_at_label", "(", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "insn", ")", ",", "state", ")", ";", "else", "if", "(", "JUMP_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_VEC", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_DIFF_VEC", "&&", "(", "(", "type", "=", "get_attr_type", "(", "insn", ")", ")", "==", "TYPE_BRANCH", "||", "(", "(", "type", "==", "TYPE_UNCOND_BRANCH", "||", "type", "==", "TYPE_RETURN", ")", "&&", "ARC_CCFSM_BRANCH_DELETED_P", "(", "state", ")", ")", ")", ")", "{", "if", "(", "ARC_CCFSM_BRANCH_DELETED_P", "(", "state", ")", ")", "ARC_CCFSM_RECORD_BRANCH_DELETED", "(", "state", ")", ";", "else", "{", "rtx", "src", "=", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ";", "arc_ccfsm_record_condition", "(", "XEXP", "(", "src", ",", "0", ")", ",", "XEXP", "(", "src", ",", "1", ")", "==", "pc_rtx", ",", "insn", ",", "state", ")", ";", "}", "}", "else", "if", "(", "arc_ccfsm_current", ".", "state", "==", "5", ")", "arc_ccfsm_current", ".", "state", "=", "0", ";", "}", "</s>" ]

[ "Update", "*", "STATE", "as", "we", "would", "when", "we", "emit", "INSN", "." ]

[ "arc", "\"L\"", "0", "1", "5", "0" ]

[]

[ "<s>", "const", "char", "*", "rs6000_xcoff_strip_dollar", "(", "const", "char", "*", "name", ")", "{", "char", "*", "strip", ",", "*", "p", ";", "const", "char", "*", "q", ";", "size_t", "len", ";", "q", "=", "(", "const", "char", "*", ")", "strchr", "(", "name", ",", "'$'", ")", ";", "if", "(", "q", "==", "0", "||", "q", "==", "name", ")", "return", "name", ";", "len", "=", "strlen", "(", "name", ")", ";", "strip", "=", "XALLOCAVEC", "(", "char", ",", "len", "+", "1", ")", ";", "strcpy", "(", "strip", ",", "name", ")", ";", "p", "=", "strip", "+", "(", "q", "-", "name", ")", ";", "while", "(", "p", ")", "{", "*", "p", "=", "'_'", ";", "p", "=", "strchr", "(", "p", "+", "1", ",", "'$'", ")", ";", "}", "return", "ggc_alloc_string", "(", "strip", ",", "len", ")", ";", "}", "</s>" ]

[ "Return", "a", "GGC-allocated", "character", "string", "translating", "dollar", "signs", "in", "input", "NAME", "to", "underscores", ".", "Used", "by", "XCOFF", "ASM_OUTPUT_LABELREF", "." ]

[ "rs6000", "0", "1", "1" ]

[]

[ "<s>", "const", "Nios2Subtarget", "*", "Nios2TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "Nios2Subtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "Nios2", "Nios2", "Nios2", "\"target-cpu\"", "\"target-features\"", "Nios2" ]

[]

[ "<s>", "bool", "MOSCSEConfigFull", "::", "shouldCSEOpc", "(", "unsigned", "Opc", ")", "{", "switch", "(", "Opc", ")", "{", "default", ":", "return", "CSEConfigFull", "::", "shouldCSEOpc", "(", "Opc", ")", ";", "case", "MOS", "::", "G_DEC", ":", "case", "MOS", "::", "G_INC", ":", "case", "MOS", "::", "G_LSHRE", ":", "case", "MOS", "::", "G_SBC", ":", "case", "MOS", "::", "G_SHLE", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "--", "--", "--", "�", "?", "CSEConfigFull", "--", "--", "--", "-�", "?", "///" ]

[ "MOS", "MOS", "MOS::G_DEC", "MOS::G_INC", "MOS::G_LSHRE", "MOS::G_SBC", "MOS::G_SHLE" ]

[]

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

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

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

[]

[ "<s>", "SDValue", "SystemZSelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "DL", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "Align", "Alignment", ",", "bool", "IsVolatile", ",", "bool", "AlwaysInline", ",", "bool", "MustPreserveCheriCapabilities", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "if", "(", "IsVolatile", ")", "return", "SDValue", "(", ")", ";", "if", "(", "auto", "*", "CSize", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ")", "return", "emitMemMem", "(", "DAG", ",", "DL", ",", "SystemZISD", "::", "MVC", ",", "SystemZISD", "::", "MVC_LOOP", ",", "Chain", ",", "Dst", ",", "Src", ",", "CSize", "->", "getZExtValue", "(", ")", ")", ";", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memcpy", "." ]

[ "SystemZ", "SystemZ", "SystemZISD::MVC", "SystemZISD::MVC_LOOP" ]

[]

[ "<s>", "SDValue", "RISCVTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "report_fatal_error", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "break", ";", "}", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", ".", "getRegInfo", "(", ")", ";", "MVT", "XLenVT", "=", "Subtarget", ".", "getXLenVT", "(", ")", ";", "if", "(", "IsVarArg", ")", "report_fatal_error", "(", "\"VarArg not supported\"", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CC_RISCV32", ")", ";", "for", "(", "auto", "&", "VA", ":", "ArgLocs", ")", "{", "if", "(", "!", "VA", ".", "isRegLoc", "(", ")", ")", "report_fatal_error", "(", "\"Defined with too many args\"", ")", ";", "EVT", "RegVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "if", "(", "RegVT", "!=", "XLenVT", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"LowerFormalArguments Unhandled argument type: \"", "<<", "RegVT", ".", "getEVTString", "(", ")", "<<", "\"\\n\"", ")", ";", "report_fatal_error", "(", "\"unhandled argument type\"", ")", ";", "}", "const", "unsigned", "VReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "RISCV", "::", "GPRRegClass", ")", ";", "RegInfo", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "VReg", ")", ";", "SDValue", "ArgIn", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "VReg", ",", "RegVT", ")", ";", "InVals", ".", "push_back", "(", "ArgIn", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "RISCV", "RISCV", "ISD::InputArg", "\"Unsupported calling convention\"", "\"VarArg not supported\"", "16", "RISCV", "\"Defined with too many args\"", "\"LowerFormalArguments Unhandled argument type: \"", "\"\\n\"", "\"unhandled argument type\"", "RISCV::GPRRegClass" ]

[]

[ "<s>", "void", "SIFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "FuncInfo", "->", "isEntryFunction", "(", ")", ")", "return", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "DebugLoc", "DL", ";", "unsigned", "ScratchExecCopy", "=", "AMDGPU", "::", "NoRegister", ";", "for", "(", "const", "SIMachineFunctionInfo", "::", "SGPRSpillVGPRCSR", "&", "Reg", ":", "FuncInfo", "->", "getSGPRSpillVGPRs", "(", ")", ")", "{", "if", "(", "!", "Reg", ".", "FI", ".", "hasValue", "(", ")", ")", "continue", ";", "const", "SIRegisterInfo", "&", "TRI", "=", "TII", "->", "getRegisterInfo", "(", ")", ";", "if", "(", "ScratchExecCopy", "==", "AMDGPU", "::", "NoRegister", ")", "{", "LivePhysRegs", "LiveRegs", "(", "*", "ST", ".", "getRegisterInfo", "(", ")", ")", ";", "LiveRegs", ".", "addLiveIns", "(", "MBB", ")", ";", "ScratchExecCopy", "=", "findScratchNonCalleeSaveRegister", "(", "MF", ",", "LiveRegs", ",", "*", "TRI", ".", "getWaveMaskRegClass", "(", ")", ")", ";", "const", "unsigned", "OrSaveExec", "=", "ST", ".", "isWave32", "(", ")", "?", "AMDGPU", "::", "S_OR_SAVEEXEC_B32", ":", "AMDGPU", "::", "S_OR_SAVEEXEC_B64", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "OrSaveExec", ")", ",", "ScratchExecCopy", ")", ".", "addImm", "(", "-", "1", ")", ";", "}", "TII", "->", "loadRegFromStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ".", "VGPR", ",", "Reg", ".", "FI", ".", "getValue", "(", ")", ",", "&", "AMDGPU", "::", "VGPR_32RegClass", ",", "&", "TII", "->", "getRegisterInfo", "(", ")", ")", ";", "}", "if", "(", "ScratchExecCopy", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "unsigned", "ExecMov", "=", "ST", ".", "isWave32", "(", ")", "?", "AMDGPU", "::", "S_MOV_B32", ":", "AMDGPU", "::", "S_MOV_B64", ";", "unsigned", "Exec", "=", "ST", ".", "isWave32", "(", ")", "?", "AMDGPU", "::", "EXEC_LO", ":", "AMDGPU", "::", "EXEC", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "ExecMov", ")", ",", "Exec", ")", ".", "addReg", "(", "ScratchExecCopy", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "uint32_t", "NumBytes", "=", "MFI", ".", "getStackSize", "(", ")", ";", "uint32_t", "RoundedSize", "=", "FuncInfo", "->", "isStackRealigned", "(", ")", "?", "NumBytes", "+", "MFI", ".", "getMaxAlignment", "(", ")", ":", "NumBytes", ";", "const", "unsigned", "StackPtrReg", "=", "FuncInfo", "->", "getStackPtrOffsetReg", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_SUB_U32", ")", ",", "StackPtrReg", ")", ".", "addReg", "(", "StackPtrReg", ")", ".", "addImm", "(", "RoundedSize", "*", "ST", ".", "getWavefrontSize", "(", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "SI", "AMDGPU::NoRegister", "SI", "SI", "AMDGPU::NoRegister", "AMDGPU::S_OR_SAVEEXEC_B32", "AMDGPU::S_OR_SAVEEXEC_B64", "1", "AMDGPU::VGPR_32RegClass", "AMDGPU::NoRegister", "AMDGPU::S_MOV_B32", "AMDGPU::S_MOV_B64", "AMDGPU::EXEC_LO", "AMDGPU::EXEC", "AMDGPU::S_SUB_U32" ]

[]

[ "<s>", "void", "ARM64RegisterInfo", "::", "resolveFrameIndex", "(", "MachineInstr", "&", "MI", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "int", "Off", "=", "Offset", ";", "unsigned", "i", "=", "0", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "bool", "Done", "=", "rewriteARM64FrameIndex", "(", "MI", ",", "i", ",", "BaseReg", ",", "Off", ",", "TII", ")", ";", "assert", "(", "Done", "&&", "\"Unable to resolve frame index!\"", ")", ";", "(", "void", ")", "Done", ";", "}", "</s>" ]

[ "Resolve", "a", "frame", "index", "operand", "of", "an", "instruction", "to", "reference", "the", "indicated", "base", "register", "plus", "offset", "instead", "." ]

[ "ARM64", "ARM64", "0", "\"Instr doesn't have FrameIndex operand!\"", "ARM64", "\"Unable to resolve frame index!\"" ]

[]

[ "<s>", "Liveness", "(", "MachineRegisterInfo", "&", "mri", ",", "const", "DataFlowGraph", "&", "g", ")", ":", "DFG", "(", "g", ")", ",", "TRI", "(", "g", ".", "getTRI", "(", ")", ")", ",", "PRI", "(", "g", ".", "getPRI", "(", ")", ")", ",", "MDT", "(", "g", ".", "getDT", "(", ")", ")", ",", "MDF", "(", "g", ".", "getDF", "(", ")", ")", ",", "LiveMap", "(", "g", ".", "getPRI", "(", ")", ")", ",", "Empty", "(", ")", ",", "NoRegs", "(", "g", ".", "getPRI", "(", ")", ")", "{", "}", "</s>" ]

[ "During", "our", "initial", "pass", "over", "the", "program", ",", "we", "determine", "that", "things", "are", "either", "alive", "or", "maybe", "alive", ".", "More", "..." ]

[ "Hexagon" ]

[]

[ "<s>", "unsigned", "RISCVTargetLowering", "::", "getExceptionSelectorRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "{", "if", "(", "Subtarget", ".", "isRV64", "(", ")", ")", "return", "RISCV", "::", "evec_64", ";", "else", "return", "RISCV", "::", "evec", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "typeid", "on", "entry", "to", "a", "landing", "pad", "." ]

[ "RISCV", "RISCV", "RISCV::evec_64", "RISCV::evec" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "static", "bool", "rs6000_secondary_reload_move", "(", "enum", "rs6000_reg_type", "to_type", ",", "enum", "rs6000_reg_type", "from_type", ",", "machine_mode", "mode", ",", "secondary_reload_info", "*", "sri", ",", "bool", "altivec_p", ")", "{", "if", "(", "to_type", "==", "NO_REG_TYPE", "||", "from_type", "==", "NO_REG_TYPE", ")", "return", "false", ";", "if", "(", "(", "to_type", "==", "PSEUDO_REG_TYPE", "&&", "from_type", "==", "PSEUDO_REG_TYPE", ")", "||", "(", "to_type", "==", "PSEUDO_REG_TYPE", "&&", "IS_STD_REG_TYPE", "(", "from_type", ")", ")", "||", "(", "from_type", "==", "PSEUDO_REG_TYPE", "&&", "IS_STD_REG_TYPE", "(", "to_type", ")", ")", ")", "return", "true", ";", "if", "(", "to_type", "==", "from_type", "&&", "IS_STD_REG_TYPE", "(", "to_type", ")", ")", "return", "true", ";", "if", "(", "rs6000_secondary_reload_simple_move", "(", "to_type", ",", "from_type", ",", "mode", ")", ")", "{", "if", "(", "sri", ")", "{", "sri", "->", "icode", "=", "CODE_FOR_nothing", ";", "sri", "->", "extra_cost", "=", "0", ";", "}", "return", "true", ";", "}", "return", "rs6000_secondary_reload_direct_move", "(", "to_type", ",", "from_type", ",", "mode", ",", "sri", ",", "altivec_p", ")", ";", "}", "</s>" ]

[ "Return", "whether", "a", "move", "between", "two", "register", "classes", "can", "be", "done", "either", "directly", "(", "simple", "move", ")", "or", "via", "a", "pattern", "that", "uses", "a", "single", "extra", "temporary", "(", "using", "power8", "'s", "direct", "move", "in", "this", "case", "." ]

[ "powerpcspe", "0" ]

[]

[ "<s>", "AArch64DCBasicBlock", "&", "getParent", "(", ")", "{", "return", "static_cast", "<", "AArch64DCBasicBlock", "&", ">", "(", "DCInstruction", "::", "getParent", "(", ")", ")", ";", "}", "</s>" ]

[ "getParent", "-", "Return", "the", "last", "analyzed", "interval", "." ]

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

[]

[ "<s>", "const", "char", "*", "nds32_output_stack_pop", "(", "rtx", "par_rtx", "ATTRIBUTE_UNUSED", ")", "{", "char", "pattern", "[", "100", "]", ";", "rtx", "operands", "[", "3", "]", ";", "int", "rb_eh_data", "=", "cfun", "->", "machine", "->", "eh_return_data_first_regno", ";", "int", "re_eh_data", "=", "cfun", "->", "machine", "->", "eh_return_data_last_regno", ";", "int", "first_eh_data_regno", "=", "EH_RETURN_DATA_REGNO", "(", "0", ")", ";", "int", "rb_callee_saved", "=", "cfun", "->", "machine", "->", "callee_saved_first_gpr_regno", ";", "int", "re_callee_saved", "=", "cfun", "->", "machine", "->", "callee_saved_last_gpr_regno", ";", "if", "(", "reg_mentioned_p", "(", "gen_rtx_REG", "(", "SImode", ",", "first_eh_data_regno", ")", ",", "par_rtx", ")", ")", "{", "operands", "[", "0", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "rb_eh_data", ")", ";", "operands", "[", "1", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "re_eh_data", ")", ";", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "\"pop.s\\t%s\"", ",", "\"%0, %1, { }\"", ")", ";", "output_asm_insn", "(", "pattern", ",", "operands", ")", ";", "return", "\"\"", ";", "}", "if", "(", "TARGET_V3PUSH", "&&", "!", "nds32_isr_function_p", "(", "current_function_decl", ")", "&&", "(", "cfun", "->", "machine", "->", "va_args_size", "==", "0", ")", ")", "{", "int", "sp_adjust", ";", "operands", "[", "0", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "re_callee_saved", ")", ";", "sp_adjust", "=", "cfun", "->", "machine", "->", "local_size", "+", "cfun", "->", "machine", "->", "out_args_size", "+", "cfun", "->", "machine", "->", "callee_saved_area_gpr_padding_bytes", "+", "cfun", "->", "machine", "->", "callee_saved_fpr_regs_size", ";", "if", "(", "satisfies_constraint_Iu08", "(", "GEN_INT", "(", "sp_adjust", ")", ")", "&&", "NDS32_DOUBLE_WORD_ALIGN_P", "(", "sp_adjust", ")", "&&", "!", "cfun", "->", "calls_alloca", ")", "operands", "[", "1", "]", "=", "GEN_INT", "(", "sp_adjust", ")", ";", "else", "{", "if", "(", "cfun", "->", "machine", "->", "callee_saved_first_fpr_regno", "!=", "SP_REGNUM", ")", "{", "sp_adjust", "=", "cfun", "->", "machine", "->", "callee_saved_area_gpr_padding_bytes", "+", "cfun", "->", "machine", "->", "callee_saved_fpr_regs_size", ";", "operands", "[", "1", "]", "=", "GEN_INT", "(", "sp_adjust", ")", ";", "}", "else", "{", "operands", "[", "1", "]", "=", "GEN_INT", "(", "0", ")", ";", "}", "}", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "\"pop25\\t%%0, %%1\"", ")", ";", "}", "else", "{", "int", "pop_en4_only_p", "=", "0", ";", "operands", "[", "0", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "rb_callee_saved", ")", ";", "operands", "[", "1", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "re_callee_saved", ")", ";", "if", "(", "!", "cfun", "->", "machine", "->", "fp_size", "&&", "!", "cfun", "->", "machine", "->", "gp_size", "&&", "!", "cfun", "->", "machine", "->", "lp_size", "&&", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "SP_REGNUM", "&&", "REGNO", "(", "operands", "[", "1", "]", ")", "==", "SP_REGNUM", ")", "{", "return", "\"\"", ";", "}", "else", "{", "if", "(", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "SP_REGNUM", "&&", "REGNO", "(", "operands", "[", "1", "]", ")", "==", "SP_REGNUM", ")", "pop_en4_only_p", "=", "1", ";", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "\"pop.s\\t%s{%s%s%s }\"", ",", "pop_en4_only_p", "?", "\"\"", ":", "\"%0, %1, \"", ",", "cfun", "->", "machine", "->", "fp_size", "?", "\" $fp\"", ":", "\"\"", ",", "cfun", "->", "machine", "->", "gp_size", "?", "\" $gp\"", ":", "\"\"", ",", "cfun", "->", "machine", "->", "lp_size", "?", "\" $lp\"", ":", "\"\"", ")", ";", "}", "}", "output_asm_insn", "(", "pattern", ",", "operands", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Function", "to", "output", "stack", "pop", "operation", ".", "We", "need", "to", "deal", "with", "normal", "stack", "pop", "multiple", "or", "stack", "v3pop", "." ]

[ "nds32", "100", "3", "0", "0", "1", "\"pop.s\\t%s\"", "\"%0, %1, { }\"", "\"\"", "0", "0", "1", "1", "1", "0", "\"pop25\\t%%0, %%1\"", "0", "0", "1", "0", "1", "\"\"", "0", "1", "1", "\"pop.s\\t%s{%s%s%s }\"", "\"\"", "\"%0, %1, \"", "\" $fp\"", "\"\"", "\" $gp\"", "\"\"", "\" $lp\"", "\"\"", "\"\"" ]

[]

[ "<s>", "ConstantPool", "*", "AssemblerConstantPools", "::", "getConstantPool", "(", "const", "MCSection", "*", "Section", ")", "{", "ConstantPoolMapTy", "::", "iterator", "CP", "=", "ConstantPools", ".", "find", "(", "Section", ")", ";", "if", "(", "CP", "==", "ConstantPools", ".", "end", "(", ")", ")", "return", "0", ";", "return", "&", "CP", "->", "second", ";", "}", "</s>" ]

[ "Return", "a", "pseudo", "source", "value", "referencing", "the", "constant", "pool", "." ]

[ "ARM", "0" ]

[]

[ "<s>", "bool", "mem_operand_gpr", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "unsigned", "HOST_WIDE_INT", "offset", ";", "int", "extra", ";", "rtx", "addr", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "!", "rs6000_offsettable_memref_p", "(", "op", ",", "mode", ",", "false", ")", ")", "return", "false", ";", "op", "=", "address_offset", "(", "addr", ")", ";", "if", "(", "op", "==", "NULL_RTX", ")", "return", "true", ";", "offset", "=", "INTVAL", "(", "op", ")", ";", "if", "(", "TARGET_POWERPC64", "&&", "(", "offset", "&", "3", ")", "!=", "0", ")", "return", "false", ";", "extra", "=", "GET_MODE_SIZE", "(", "mode", ")", "-", "UNITS_PER_WORD", ";", "if", "(", "extra", "<", "0", ")", "extra", "=", "0", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "LO_SUM", ")", "offset", "=", "(", "(", "offset", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "return", "offset", "+", "0x8000", "<", "0x10000u", "-", "extra", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "MEM", "operand", "is", "a", "memory", "operand", "suitable", "for", "use", "with", "a", "(", "full", "width", ",", "possibly", "multiple", ")", "gpr", "load/store", ".", "On", "powerpc64", "this", "means", "the", "offset", "must", "be", "divisible", "by", "4", ".", "Implements", "'", "Y", "'", "constraint", ".", "Accept", "direct", ",", "indexed", ",", "offset", ",", "lo_sum", "and", "tocref", ".", "Since", "this", "is", "a", "constraint", "function", "we", "know", "the", "operand", "has", "satisfied", "a", "suitable", "memory", "predicate", ".", "Offsetting", "a", "lo_sum", "should", "not", "be", "allowed", ",", "except", "where", "we", "know", "by", "alignment", "that", "a", "32k", "boundary", "is", "not", "crossed", ".", "Note", "that", "by", "``", "offsetting", "''", "here", "we", "mean", "a", "further", "offset", "to", "access", "parts", "of", "the", "MEM", ".", "It", "'s", "fine", "to", "have", "a", "lo_sum", "where", "the", "inner", "address", "is", "offset", "from", "a", "sym", ",", "since", "the", "same", "sym+offset", "will", "appear", "in", "the", "high", "part", "of", "the", "address", "calculation", "." ]

[ "rs6000", "0", "3", "0", "0", "0", "0xffff", "0x8000", "0x8000", "0x8000", "0x10000u" ]

[]

[ "<s>", "virtual", "const", "HexagonInstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"PTX Register Allocator\"", ";", "}", "</s>" ]

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

[ "PTX", "\"PTX Register Allocator\"" ]

[]

[ "<s>", "bool", "RISCVMCExpr", "::", "evaluateAsConstant", "(", "int64_t", "&", "Res", ")", "const", "{", "MCValue", "Value", ";", "if", "(", "Kind", "==", "VK_RISCV_PCREL_HI", "||", "Kind", "==", "VK_RISCV_PCREL_LO", "||", "Kind", "==", "VK_RISCV_GOT_HI", "||", "Kind", "==", "VK_RISCV_CALL", ")", "return", "false", ";", "if", "(", "!", "getSubExpr", "(", ")", "->", "evaluateAsRelocatable", "(", "Value", ",", "nullptr", ",", "nullptr", ")", ")", "return", "false", ";", "if", "(", "!", "Value", ".", "isAbsolute", "(", ")", ")", "return", "false", ";", "Res", "=", "evaluateAsInt64", "(", "Value", ".", "getConstant", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Evaluates", "the", "fixup", "as", "a", "constant", "value", "." ]

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

[]

[ "<s>", "rtx", "avr_to_int_mode", "(", "rtx", "x", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "return", "VOIDmode", "==", "mode", "?", "x", ":", "simplify_gen_subreg", "(", "int_mode_for_mode", "(", "mode", ")", ".", "require", "(", ")", ",", "x", ",", "mode", ",", "0", ")", ";", "}", "</s>" ]

[ "Access", "some", "RTX", "as", "INT_MODE", ".", "If", "X", "is", "a", "CONST_FIXED", "we", "can", "get", "the", "bit", "representation", "of", "X", "by", "``", "casting", "''", "it", "to", "CONST_INT", "." ]

[ "avr", "0" ]

[]

[ "<s>", "bool", "HexagonOptAddrMode", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changed", "=", "false", ";", "auto", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "HII", "=", "HST", ".", "getInstrInfo", "(", ")", ";", "const", "auto", "&", "MDF", "=", "getAnalysis", "<", "MachineDominanceFrontier", ">", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "const", "auto", "&", "TRI", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "TargetOperandInfo", "TOI", "(", "*", "HII", ")", ";", "DataFlowGraph", "G", "(", "MF", ",", "*", "HII", ",", "TRI", ",", "*", "MDT", ",", "MDF", ",", "TOI", ")", ";", "G", ".", "build", "(", ")", ";", "DFG", "=", "&", "G", ";", "Liveness", "L", "(", "MRI", ",", "*", "DFG", ")", ";", "L", ".", "computePhiInfo", "(", ")", ";", "LV", "=", "&", "L", ";", "constructDefMap", "(", "&", "DFG", "->", "getMF", "(", ")", ".", "front", "(", ")", ")", ";", "Deleted", ".", "clear", "(", ")", ";", "NodeAddr", "<", "FuncNode", "*", ">", "FA", "=", "DFG", "->", "getFunc", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"==== [RefMap#]=====:\\n \"", "<<", "Print", "<", "NodeAddr", "<", "FuncNode", "*", ">>", "(", "FA", ",", "*", "DFG", ")", "<<", "\"\\n\"", ")", ";", "for", "(", "NodeAddr", "<", "BlockNode", "*", ">", "BA", ":", "FA", ".", "Addr", "->", "members", "(", "*", "DFG", ")", ")", "Changed", "|=", "processBlock", "(", "BA", ")", ";", "for", "(", "auto", "MI", ":", "Deleted", ")", "MI", "->", "eraseFromParent", "(", ")", ";", "if", "(", "Changed", ")", "{", "G", ".", "build", "(", ")", ";", "L", ".", "computeLiveIns", "(", ")", ";", "L", ".", "resetLiveIns", "(", ")", ";", "L", ".", "resetKills", "(", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "\"==== [RefMap#]=====:\\n \"", "\"\\n\"" ]

[]

[ "<s>", "BitVector", "MSP430RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "MSP430FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "PCB", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "SPB", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "SRB", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "CGB", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "PC", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "SR", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "CG", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "Reserved", ".", "set", "(", "MSP430", "::", "FPB", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "FP", ")", ";", "}", "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", "." ]

[ "MSP430", "MSP430", "MSP430", "MSP430::PCB", "MSP430::SPB", "MSP430::SRB", "MSP430::CGB", "MSP430::PC", "MSP430::SP", "MSP430::SR", "MSP430::CG", "MSP430::FPB", "MSP430::FP" ]

[]

[ "<s>", "HOST_WIDE_INT", "mips_debugger_offset", "(", "rtx", "addr", ",", "HOST_WIDE_INT", "offset", ")", "{", "rtx", "offset2", "=", "const0_rtx", ";", "rtx", "reg", "=", "eliminate_constant_term", "(", "addr", ",", "&", "offset2", ")", ";", "if", "(", "offset", "==", "0", ")", "offset", "=", "INTVAL", "(", "offset2", ")", ";", "if", "(", "reg", "==", "stack_pointer_rtx", "||", "reg", "==", "frame_pointer_rtx", "||", "reg", "==", "hard_frame_pointer_rtx", ")", "{", "HOST_WIDE_INT", "frame_size", "=", "(", "!", "cfun", "->", "machine", "->", "frame", ".", "initialized", ")", "?", "compute_frame_size", "(", "get_frame_size", "(", ")", ")", ":", "cfun", "->", "machine", "->", "frame", ".", "total_size", ";", "if", "(", "frame_pointer_needed", "&&", "TARGET_MIPS16", ")", "frame_size", "-=", "cfun", "->", "machine", "->", "frame", ".", "args_size", ";", "offset", "=", "offset", "-", "frame_size", ";", "}", "else", "if", "(", "reg", "!=", "arg_pointer_rtx", ")", "fatal_insn", "(", "\"mips_debugger_offset called with non stack/frame/arg pointer\"", ",", "addr", ")", ";", "return", "offset", ";", "}", "</s>" ]

[ "The", "MIPS", "debug", "format", "wants", "all", "automatic", "variables", "and", "arguments", "to", "be", "in", "terms", "of", "the", "virtual", "frame", "pointer", "(", "stack", "pointer", "before", "any", "adjustment", "in", "the", "function", ")", ",", "while", "the", "MIPS", "3.0", "linker", "wants", "the", "frame", "pointer", "to", "be", "the", "stack", "pointer", "after", "the", "initial", "adjustment", ".", "So", ",", "we", "do", "the", "adjustment", "here", ".", "The", "arg", "pointer", "(", "which", "is", "eliminated", ")", "points", "to", "the", "virtual", "frame", "pointer", ",", "while", "the", "frame", "pointer", "(", "which", "may", "be", "eliminated", ")", "points", "to", "the", "stack", "pointer", "after", "the", "initial", "adjustments", "." ]

[ "mips", "0", "\"mips_debugger_offset called with non stack/frame/arg pointer\"" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreSched2", "(", ")", "{", "if", "(", "EnableHomogeneousPrologEpilog", ")", "addPass", "(", "createAArch64LowerHomogeneousPrologEpilogPass", "(", ")", ")", ";", "addPass", "(", "createAArch64ExpandPseudoPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "EnableLoadStoreOpt", ")", "addPass", "(", "createAArch64LoadStoreOptimizationPass", "(", ")", ")", ";", "}", "addPass", "(", "createAArch64SpeculationHardeningPass", "(", ")", ")", ";", "addPass", "(", "createAArch64IndirectThunks", "(", ")", ")", ";", "addPass", "(", "createAArch64SLSHardeningPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "EnableFalkorHWPFFix", ")", "addPass", "(", "createFalkorHWPFFixPass", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

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

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isProfitableToDupForIfCvt", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "NumInstrs", ",", "BranchProbability", "Probability", ")", "const", "{", "return", "(", "NumInstrs", "<=", "4", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "profitable", "for", "if-converter", "to", "duplicate", "instructions", "of", "specified", "accumulated", "instruction", "latencies", "in", "the", "specified", "MBB", "to", "enable", "if-conversion", "." ]

[ "Hexagon", "Hexagon", "4" ]

[]

[ "<s>", "int", "frv_legitimate_memory_operand", "(", "rtx", "op", ",", "machine_mode", "mode", ",", "int", "condexec_p", ")", "{", "return", "(", "(", "GET_MODE", "(", "op", ")", "==", "mode", "||", "mode", "==", "VOIDmode", ")", "&&", "GET_CODE", "(", "op", ")", "==", "MEM", "&&", "frv_legitimate_address_p_1", "(", "mode", ",", "XEXP", "(", "op", ",", "0", ")", ",", "reload_completed", ",", "condexec_p", ",", "FALSE", ")", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "operand", "is", "a", "valid", "FRV", "address", ".", "CONDEXEC_P", "is", "true", "if", "the", "operand", "is", "used", "by", "a", "predicated", "instruction", "." ]

[ "frv", "0" ]

[]

[ "<s>", "void", "DLXAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", ",", "const", "MCSubtargetInfo", "*", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "static_cast", "<", "unsigned", ">", "(", "Kind", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "(", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", "+", "7", ")", "/", "8", ";", "unsigned", "FullSize", "=", "4", ";", "uint64_t", "CurVal", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "(", "FullSize", "-", "1", "-", "i", ")", ";", "CurVal", "|=", "static_cast", "<", "uint64_t", ">", "(", "static_cast", "<", "uint8_t", ">", "(", "Data", "[", "Offset", "+", "Idx", "]", ")", ")", "<<", "(", "i", "*", "8", ")", ";", "}", "uint64_t", "Mask", "=", "(", "static_cast", "<", "uint64_t", ">", "(", "-", "1", ")", ">>", "(", "64", "-", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ")", ")", ";", "CurVal", "|=", "Value", "&", "Mask", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "(", "FullSize", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "=", "static_cast", "<", "uint8_t", ">", "(", "(", "CurVal", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</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", "." ]

[ "DLX", "DLX", "7", "8", "4", "0", "0", "1", "8", "1", "64", "0", "1", "8", "0xff" ]

[]

[ "<s>", "static", "bool", "pdp11_can_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "reg_class_t", "rclass", ")", "{", "if", "(", "FLOAT_MODE_P", "(", "from", ")", "!=", "FLOAT_MODE_P", "(", "to", ")", ")", "return", "false", ";", "return", "!", "reg_classes_intersect_p", "(", "FPU_REGS", ",", "rclass", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_CAN_CHANGE_MODE_CLASS", "." ]

[ "pdp11" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"AMDGPU Convert to ISA\"", ";", "}", "</s>" ]

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

[ "R600", "\"AMDGPU Convert to ISA\"" ]

[]

[ "<s>", "void", "ix86_function_specific_save", "(", "struct", "cl_target_option", "*", "ptr", ",", "struct", "gcc_options", "*", "opts", ",", "struct", "gcc_options", "*", ")", "{", "ptr", "->", "arch", "=", "ix86_arch", ";", "ptr", "->", "schedule", "=", "ix86_schedule", ";", "ptr", "->", "prefetch_sse", "=", "ix86_prefetch_sse", ";", "ptr", "->", "tune", "=", "ix86_tune", ";", "ptr", "->", "branch_cost", "=", "ix86_branch_cost", ";", "ptr", "->", "tune_defaulted", "=", "ix86_tune_defaulted", ";", "ptr", "->", "arch_specified", "=", "ix86_arch_specified", ";", "ptr", "->", "x_ix86_isa_flags_explicit", "=", "opts", "->", "x_ix86_isa_flags_explicit", ";", "ptr", "->", "x_ix86_isa_flags2_explicit", "=", "opts", "->", "x_ix86_isa_flags2_explicit", ";", "ptr", "->", "x_recip_mask_explicit", "=", "opts", "->", "x_recip_mask_explicit", ";", "ptr", "->", "x_ix86_arch_string", "=", "opts", "->", "x_ix86_arch_string", ";", "ptr", "->", "x_ix86_tune_string", "=", "opts", "->", "x_ix86_tune_string", ";", "ptr", "->", "x_ix86_asm_dialect", "=", "opts", "->", "x_ix86_asm_dialect", ";", "ptr", "->", "x_ix86_branch_cost", "=", "opts", "->", "x_ix86_branch_cost", ";", "ptr", "->", "x_ix86_dump_tunes", "=", "opts", "->", "x_ix86_dump_tunes", ";", "ptr", "->", "x_ix86_force_align_arg_pointer", "=", "opts", "->", "x_ix86_force_align_arg_pointer", ";", "ptr", "->", "x_ix86_force_drap", "=", "opts", "->", "x_ix86_force_drap", ";", "ptr", "->", "x_ix86_recip_name", "=", "opts", "->", "x_ix86_recip_name", ";", "ptr", "->", "x_ix86_section_threshold", "=", "opts", "->", "x_ix86_section_threshold", ";", "ptr", "->", "x_ix86_sse2avx", "=", "opts", "->", "x_ix86_sse2avx", ";", "ptr", "->", "x_ix86_stack_protector_guard", "=", "opts", "->", "x_ix86_stack_protector_guard", ";", "ptr", "->", "x_ix86_stringop_alg", "=", "opts", "->", "x_ix86_stringop_alg", ";", "ptr", "->", "x_ix86_tls_dialect", "=", "opts", "->", "x_ix86_tls_dialect", ";", "ptr", "->", "x_ix86_tune_ctrl_string", "=", "opts", "->", "x_ix86_tune_ctrl_string", ";", "ptr", "->", "x_ix86_tune_memcpy_strategy", "=", "opts", "->", "x_ix86_tune_memcpy_strategy", ";", "ptr", "->", "x_ix86_tune_memset_strategy", "=", "opts", "->", "x_ix86_tune_memset_strategy", ";", "ptr", "->", "x_ix86_tune_no_default", "=", "opts", "->", "x_ix86_tune_no_default", ";", "gcc_assert", "(", "ptr", "->", "arch", "==", "ix86_arch", ")", ";", "gcc_assert", "(", "ptr", "->", "schedule", "==", "ix86_schedule", ")", ";", "gcc_assert", "(", "ptr", "->", "tune", "==", "ix86_tune", ")", ";", "gcc_assert", "(", "ptr", "->", "branch_cost", "==", "ix86_branch_cost", ")", ";", "}", "</s>" ]

[ "Save", "the", "current", "options" ]

[ "i386" ]

[]

[ "<s>", "const", "MOSSubtarget", "*", "getSubtargetImpl", "(", ")", "const", "{", "return", "&", "SubTarget", ";", "}", "</s>" ]

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

[ "MOS", "MOS" ]

[]

[ "<s>", "static", "void", "choose_basereg", "(", "HOST_WIDE_INT", "cfa_offset", ",", "rtx", "&", "base_reg", ",", "HOST_WIDE_INT", "&", "base_offset", ",", "unsigned", "int", "align_reqested", ",", "unsigned", "int", "*", "align", ")", "{", "const", "struct", "machine_function", "*", "m", "=", "cfun", "->", "machine", ";", "unsigned", "int", "hfp_align", ";", "unsigned", "int", "drap_align", ";", "unsigned", "int", "sp_align", ";", "bool", "hfp_ok", "=", "fp_valid_at", "(", "cfa_offset", ")", ";", "bool", "drap_ok", "=", "m", "->", "fs", ".", "drap_valid", ";", "bool", "sp_ok", "=", "sp_valid_at", "(", "cfa_offset", ")", ";", "hfp_align", "=", "drap_align", "=", "sp_align", "=", "INCOMING_STACK_BOUNDARY", ";", "if", "(", "align_reqested", ")", "{", "if", "(", "m", "->", "fs", ".", "realigned", ")", "hfp_align", "=", "drap_align", "=", "sp_align", "=", "crtl", "->", "stack_alignment_needed", ";", "else", "if", "(", "m", "->", "fs", ".", "sp_realigned", ")", "sp_align", "=", "crtl", "->", "stack_alignment_needed", ";", "hfp_ok", "=", "hfp_ok", "&&", "hfp_align", ">=", "align_reqested", ";", "drap_ok", "=", "drap_ok", "&&", "drap_align", ">=", "align_reqested", ";", "sp_ok", "=", "sp_ok", "&&", "sp_align", ">=", "align_reqested", ";", "}", "if", "(", "m", "->", "use_fast_prologue_epilogue", ")", "{", "if", "(", "hfp_ok", ")", "{", "base_reg", "=", "hard_frame_pointer_rtx", ";", "base_offset", "=", "m", "->", "fs", ".", "fp_offset", "-", "cfa_offset", ";", "}", "else", "if", "(", "drap_ok", ")", "{", "base_reg", "=", "crtl", "->", "drap_reg", ";", "base_offset", "=", "0", "-", "cfa_offset", ";", "}", "else", "if", "(", "sp_ok", ")", "{", "base_reg", "=", "stack_pointer_rtx", ";", "base_offset", "=", "m", "->", "fs", ".", "sp_offset", "-", "cfa_offset", ";", "}", "}", "else", "{", "HOST_WIDE_INT", "toffset", ";", "int", "len", "=", "16", ",", "tlen", ";", "if", "(", "sp_ok", ")", "{", "base_reg", "=", "stack_pointer_rtx", ";", "base_offset", "=", "m", "->", "fs", ".", "sp_offset", "-", "cfa_offset", ";", "len", "=", "choose_baseaddr_len", "(", "STACK_POINTER_REGNUM", ",", "base_offset", ")", ";", "}", "if", "(", "drap_ok", ")", "{", "toffset", "=", "0", "-", "cfa_offset", ";", "tlen", "=", "choose_baseaddr_len", "(", "REGNO", "(", "crtl", "->", "drap_reg", ")", ",", "toffset", ")", ";", "if", "(", "tlen", "<=", "len", ")", "{", "base_reg", "=", "crtl", "->", "drap_reg", ";", "base_offset", "=", "toffset", ";", "len", "=", "tlen", ";", "}", "}", "if", "(", "hfp_ok", ")", "{", "toffset", "=", "m", "->", "fs", ".", "fp_offset", "-", "cfa_offset", ";", "tlen", "=", "choose_baseaddr_len", "(", "HARD_FRAME_POINTER_REGNUM", ",", "toffset", ")", ";", "if", "(", "tlen", "<=", "len", ")", "{", "base_reg", "=", "hard_frame_pointer_rtx", ";", "base_offset", "=", "toffset", ";", "len", "=", "tlen", ";", "}", "}", "}", "if", "(", "align", ")", "{", "if", "(", "base_reg", "==", "stack_pointer_rtx", ")", "*", "align", "=", "sp_align", ";", "else", "if", "(", "base_reg", "==", "crtl", "->", "drap_reg", ")", "*", "align", "=", "drap_align", ";", "else", "if", "(", "base_reg", "==", "hard_frame_pointer_rtx", ")", "*", "align", "=", "hfp_align", ";", "}", "}", "</s>" ]

[ "Choose", "a", "base", "register", "based", "upon", "alignment", "requested", ",", "speed", "and/or", "size", "." ]

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

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Hexagon Expand Predicate Spill Code\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon Expand Predicate Spill Code\"" ]

[]

[ "<s>", "xlogue_layout", "::", "xlogue_layout", "(", "HOST_WIDE_INT", "stack_align_off_in", ",", "bool", "hfp", ")", ":", "m_hfp", "(", "hfp", ")", ",", "m_nregs", "(", "hfp", "?", "17", ":", "18", ")", ",", "m_stack_align_off_in", "(", "stack_align_off_in", ")", "{", "HOST_WIDE_INT", "offset", "=", "stack_align_off_in", ";", "unsigned", "i", ",", "j", ";", "for", "(", "i", "=", "j", "=", "0", ";", "i", "<", "MAX_REGS", ";", "++", "i", ")", "{", "unsigned", "regno", "=", "REG_ORDER", "[", "i", "]", ";", "if", "(", "regno", "==", "BP_REG", "&&", "hfp", ")", "continue", ";", "if", "(", "SSE_REGNO_P", "(", "regno", ")", ")", "{", "offset", "+=", "16", ";", "gcc_assert", "(", "!", "(", "(", "stack_align_off_in", "+", "offset", ")", "&", "15", ")", ")", ";", "}", "else", "offset", "+=", "8", ";", "m_regs", "[", "j", "]", ".", "regno", "=", "regno", ";", "m_regs", "[", "j", "++", "]", ".", "offset", "=", "offset", "-", "STUB_INDEX_OFFSET", ";", "}", "gcc_assert", "(", "j", "==", "m_nregs", ")", ";", "}", "</s>" ]

[ "Constructor", "for", "xlogue_layout", "." ]

[ "i386", "17", "18", "0", "16", "15", "8" ]

[]

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

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

[ "CellSPU", "SPU", "SPU::LRr128" ]

[]

[ "<s>", "void", "AAPInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DstReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFrameInfo", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MI", "!=", "MBB", ".", "end", "(", ")", "?", "MI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFrameInfo", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFrameInfo", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";", "assert", "(", "(", "RC", "==", "&", "AAP", "::", "GR8RegClass", "||", "RC", "==", "&", "AAP", "::", "GR64RegClass", ")", "&&", "\"Unknown register class to store to stack slot\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AAP", "::", "LDW", ")", ",", "DstReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "AAP", "AAP", "AAP::GR8RegClass", "AAP::GR64RegClass", "\"Unknown register class to store to stack slot\"", "AAP::LDW", "0" ]

[]

[ "<s>", "X86TargetMachine", "::", "X86TargetMachine", "(", "const", "Target", "&", "T", ",", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "is64Bit", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ")", ",", "Subtarget", "(", "TT", ",", "FS", ",", "is64Bit", ")", ",", "FrameLowering", "(", "*", "this", ",", "Subtarget", ")", ",", "ELFWriterInfo", "(", "is64Bit", ",", "true", ")", "{", "DefRelocModel", "=", "getRelocationModel", "(", ")", ";", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Default", ")", "{", "if", "(", "Subtarget", ".", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "setRelocationModel", "(", "Reloc", "::", "PIC_", ")", ";", "else", "setRelocationModel", "(", "Reloc", "::", "DynamicNoPIC", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetWin64", "(", ")", ")", "setRelocationModel", "(", "Reloc", "::", "PIC_", ")", ";", "else", "setRelocationModel", "(", "Reloc", "::", "Static", ")", ";", "}", "assert", "(", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Default", "&&", "\"Relocation mode not picked\"", ")", ";", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", "{", "if", "(", "is64Bit", ")", "setRelocationModel", "(", "Reloc", "::", "PIC_", ")", ";", "else", "if", "(", "!", "Subtarget", ".", "isTargetDarwin", "(", ")", ")", "setRelocationModel", "(", "Reloc", "::", "Static", ")", ";", "}", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", "&&", "Subtarget", ".", "isTargetDarwin", "(", ")", "&&", "is64Bit", ")", "setRelocationModel", "(", "Reloc", "::", "PIC_", ")", ";", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "RIPRel", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetCygMing", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "StubPIC", ")", ";", "else", "{", "assert", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", ";", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "StubDynamicNoPIC", ")", ";", "}", "}", "else", "if", "(", "Subtarget", ".", "isTargetELF", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "GOT", ")", ";", "}", "if", "(", "Subtarget", ".", "getPICStyle", "(", ")", "==", "PICStyles", "::", "None", ")", "setRelocationModel", "(", "Reloc", "::", "Static", ")", ";", "}", "</s>" ]

[ "Create", "an", "X86", "target", "." ]

[ "X86", "X86", "X86", "\"Relocation mode not picked\"" ]

[]

[ "<s>", "static", "rtx", "aarch64_gen_store_pair", "(", "machine_mode", "mode", ",", "rtx", "mem1", ",", "rtx", "reg1", ",", "rtx", "mem2", ",", "rtx", "reg2", ")", "{", "switch", "(", "mode", ")", "{", "case", "DImode", ":", "return", "gen_store_pairdi", "(", "mem1", ",", "reg1", ",", "mem2", ",", "reg2", ")", ";", "case", "DFmode", ":", "return", "gen_store_pairdf", "(", "mem1", ",", "reg1", ",", "mem2", ",", "reg2", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Generate", "and", "return", "a", "store", "pair", "instruction", "of", "mode", "MODE", "to", "store", "register", "REG1", "to", "MEM1", "and", "register", "REG2", "to", "MEM2", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "isLegalNTLoad", "(", "Type", "*", "DataType", ",", "llvm", "::", "Align", "Alignment", ")", "{", "unsigned", "DataSize", "=", "DL", ".", "getTypeStoreSize", "(", "DataType", ")", ";", "if", "(", "Alignment", ">=", "DataSize", "&&", "(", "DataSize", "==", "16", "||", "DataSize", "==", "32", ")", ")", "return", "DataSize", "==", "16", "?", "ST", "->", "hasSSE1", "(", ")", ":", "ST", "->", "hasAVX2", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "nontemporal", "load", "." ]

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

[]

[ "<s>", "const", "MCExpr", "*", "AArch64_MachoTargetObjectFile", "::", "getTTypeGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "unsigned", "Encoding", ",", "Mangler", "&", "Mang", ",", "const", "TargetMachine", "&", "TM", ",", "MachineModuleInfo", "*", "MMI", ",", "MCStreamer", "&", "Streamer", ")", "const", "{", "if", "(", "Encoding", "&", "(", "DW_EH_PE_indirect", "|", "DW_EH_PE_pcrel", ")", ")", "{", "const", "MCSymbol", "*", "Sym", "=", "TM", ".", "getSymbol", "(", "GV", ",", "Mang", ")", ";", "const", "MCExpr", "*", "Res", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "MCSymbolRefExpr", "::", "VK_GOT", ",", "getContext", "(", ")", ")", ";", "MCSymbol", "*", "PCSym", "=", "getContext", "(", ")", ".", "createTempSymbol", "(", ")", ";", "Streamer", ".", "EmitLabel", "(", "PCSym", ")", ";", "const", "MCExpr", "*", "PC", "=", "MCSymbolRefExpr", "::", "create", "(", "PCSym", ",", "getContext", "(", ")", ")", ";", "return", "MCBinaryExpr", "::", "createSub", "(", "Res", ",", "PC", ",", "getContext", "(", ")", ")", ";", "}", "return", "TargetLoweringObjectFileMachO", "::", "getTTypeGlobalReference", "(", "GV", ",", "Encoding", ",", "Mang", ",", "TM", ",", "MMI", ",", "Streamer", ")", ";", "}", "</s>" ]

[ "The", "mach-o", "version", "of", "this", "method", "defaults", "to", "returning", "a", "stub", "reference", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "rtx", "tilepro_text_label_symbol", "(", "void", ")", "{", "return", "cfun", "->", "machine", "->", "text_label_symbol", ";", "}", "</s>" ]

[ "Return", "the", "rtx", "containing", "SYMBOL_REF", "to", "the", "text", "label", "." ]

[ "tilepro" ]

[]

[ "<s>", "unsigned", "getExceptionPointerRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "override", "{", "return", "AArch64", "::", "X0", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "address", "on", "entry", "to", "an", "EH", "pad", "." ]

[ "AArch64", "AArch64::X0" ]

[]

[ "<s>", "static", "void", "rs6000_elf_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "first", ")", "{", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "if", "(", "first", "&&", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", "&&", "!", "TARGET_AIX", "&&", "DEFAULT_ABI", "==", "ABI_AIX", ")", "{", "rtx", "sym_ref", "=", "XEXP", "(", "rtl", ",", "0", ")", ";", "size_t", "len", "=", "strlen", "(", "XSTR", "(", "sym_ref", ",", "0", ")", ")", ";", "char", "*", "str", "=", "XALLOCAVEC", "(", "char", ",", "len", "+", "2", ")", ";", "str", "[", "0", "]", "=", "'.'", ";", "memcpy", "(", "str", "+", "1", ",", "XSTR", "(", "sym_ref", ",", "0", ")", ",", "len", "+", "1", ")", ";", "XSTR", "(", "sym_ref", ",", "0", ")", "=", "ggc_alloc_string", "(", "str", ",", "len", "+", "1", ")", ";", "}", "}", "</s>" ]

[ "For", "a", "SYMBOL_REF", ",", "set", "generic", "flags", "and", "then", "perform", "some", "target-specific", "processing", ".", "When", "the", "AIX", "ABI", "is", "requested", "on", "a", "non-AIX", "system", ",", "replace", "the", "function", "name", "with", "the", "real", "name", "(", "with", "a", "leading", ".", ")", "rather", "than", "the", "function", "descriptor", "name", ".", "This", "saves", "a", "lot", "of", "overriding", "code", "to", "read", "the", "prefixes", "." ]

[ "rs6000", "0", "0", "2", "0", "1", "0", "1", "0", "1" ]

[]