Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "int", "sh_dwarf_calling_convention", "(", "tree", "func", ")", "{", "if", "(", "sh_attr_renesas_p", "(", "func", ")", ")", "return", "DW_CC_GNU_renesas_sh", ";", "return", "DW_CC_normal", ";", "}", "</s>" ]

[ "Implements", "target", "hook", "dwarf_calling_convention", ".", "Return", "an", "enum", "of", "dwarf_calling_convention", "." ]

[ "sh" ]

[]

[ "<s>", "static", "rtx", "ix86_get_arg_address_for_bt", "(", "rtx", "slot", ",", "rtx", "slot_no", ",", "rtx", "special_base", ")", "{", "rtx", "addr", "=", "NULL", ";", "if", "(", "!", "slot", "||", "REG_P", "(", "slot", ")", ")", "{", "gcc_assert", "(", "CONST_INT_P", "(", "slot_no", ")", ")", ";", "addr", "=", "plus_constant", "(", "Pmode", ",", "special_base", ",", "-", "(", "INTVAL", "(", "slot_no", ")", "+", "1", ")", "*", "GET_MODE_SIZE", "(", "Pmode", ")", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "slot", ")", ")", "{", "addr", "=", "XEXP", "(", "slot", ",", "0", ")", ";", "if", "(", "!", "register_operand", "(", "addr", ",", "Pmode", ")", ")", "addr", "=", "copy_addr_to_reg", "(", "addr", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "return", "addr", ";", "}", "</s>" ]

[ "Helper", "function", "for", "ix86_load_bounds", "and", "ix86_store_bounds", ".", "Return", "an", "address", "to", "be", "used", "to", "load/store", "bounds", "for", "pointer", "passed", "in", "SLOT", ".", "SLOT_NO", "is", "an", "integer", "constant", "holding", "number", "of", "a", "target", "dependent", "special", "slot", "to", "be", "used", "in", "case", "SLOT", "is", "not", "a", "memory", ".", "SPECIAL_BASE", "is", "a", "pointer", "to", "be", "used", "as", "a", "base", "of", "fake", "address", "to", "access", "special", "slots", "in", "Bounds", "Table", ".", "SPECIAL_BASE", "[", "-1", "]", ",", "SPECIAL_BASE", "[", "-2", "]", "etc", ".", "will", "be", "used", "as", "fake", "pointer", "locations", "." ]

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

[]

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

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "bool", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "override", "{", "if", "(", "Count", "==", "0", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "LC3", "0" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"AArch64 Store Pair Suppression\"", ";", "}", "</s>" ]

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

[ "AArch64", "\"AArch64 Store Pair Suppression\"" ]

[]

[ "<s>", "void", "PPCRegisterInfo", "::", "lowerACCSpilling", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "unsigned", "FrameIndex", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "Register", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "bool", "IsKilled", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "isKill", "(", ")", ";", "bool", "IsPrimed", "=", "PPC", "::", "ACCRCRegClass", ".", "contains", "(", "SrcReg", ")", ";", "Register", "Reg", "=", "PPC", "::", "VSRp0", "+", "(", "SrcReg", "-", "(", "IsPrimed", "?", "PPC", "::", "ACC0", ":", "PPC", "::", "UACC0", ")", ")", "*", "2", ";", "bool", "IsLittleEndian", "=", "Subtarget", ".", "isLittleEndian", "(", ")", ";", "emitAccSpillRestoreInfo", "(", "MBB", ",", "IsPrimed", ",", "false", ")", ";", "if", "(", "IsPrimed", ")", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "XXMFACC", ")", ",", "SrcReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "STXVP", ")", ")", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "IsKilled", ")", ")", ",", "FrameIndex", ",", "IsLittleEndian", "?", "32", ":", "0", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "STXVP", ")", ")", ".", "addReg", "(", "Reg", "+", "1", ",", "getKillRegState", "(", "IsKilled", ")", ")", ",", "FrameIndex", ",", "IsLittleEndian", "?", "0", ":", "32", ")", ";", "if", "(", "IsPrimed", "&&", "!", "IsKilled", ")", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "XXMTACC", ")", ",", "SrcReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "MBB", ".", "erase", "(", "II", ")", ";", "}", "</s>" ]

[ "lowerACCSpilling", "-", "Generate", "the", "code", "for", "spilling", "the", "accumulator", "register", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "0", "0", "PPC::ACCRCRegClass", "PPC::VSRp0", "PPC::ACC0", "PPC::UACC0", "2", "PPC::XXMFACC", "PPC::STXVP", "32", "0", "PPC::STXVP", "1", "0", "32", "PPC::XXMTACC" ]

[]

[ "<s>", "static", "void", "s390_conditional_register_usage", "(", "void", ")", "{", "int", "i", ";", "if", "(", "flag_pic", ")", "{", "fixed_regs", "[", "PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "call_used_regs", "[", "PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "}", "fixed_regs", "[", "BASE_REGNUM", "]", "=", "0", ";", "call_used_regs", "[", "BASE_REGNUM", "]", "=", "0", ";", "fixed_regs", "[", "RETURN_REGNUM", "]", "=", "0", ";", "call_used_regs", "[", "RETURN_REGNUM", "]", "=", "0", ";", "if", "(", "TARGET_64BIT", ")", "{", "for", "(", "i", "=", "FPR8_REGNUM", ";", "i", "<=", "FPR15_REGNUM", ";", "i", "++", ")", "call_used_regs", "[", "i", "]", "=", "call_really_used_regs", "[", "i", "]", "=", "0", ";", "}", "else", "{", "call_used_regs", "[", "FPR4_REGNUM", "]", "=", "call_really_used_regs", "[", "FPR4_REGNUM", "]", "=", "0", ";", "call_used_regs", "[", "FPR6_REGNUM", "]", "=", "call_really_used_regs", "[", "FPR6_REGNUM", "]", "=", "0", ";", "}", "if", "(", "TARGET_SOFT_FLOAT", ")", "{", "for", "(", "i", "=", "FPR0_REGNUM", ";", "i", "<=", "FPR15_REGNUM", ";", "i", "++", ")", "call_used_regs", "[", "i", "]", "=", "fixed_regs", "[", "i", "]", "=", "1", ";", "}", "if", "(", "!", "TARGET_VX", ")", "{", "for", "(", "i", "=", "VR16_REGNUM", ";", "i", "<=", "VR31_REGNUM", ";", "i", "++", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "call_really_used_regs", "[", "i", "]", "=", "1", ";", "}", "}", "</s>" ]

[ "Implement", "CONDITIONAL_REGISTER_USAGE", "." ]

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

[]

[ "<s>", "static", "machine_mode", "spu_addr_space_address_mode", "(", "addr_space_t", "addrspace", ")", "{", "switch", "(", "addrspace", ")", "{", "case", "ADDR_SPACE_GENERIC", ":", "return", "Pmode", ";", "case", "ADDR_SPACE_EA", ":", "return", "EAmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "appropriate", "mode", "for", "a", "named", "address", "address", "." ]

[ "spu" ]

[]

[ "<s>", "int", "const_ok_for_dimode_op", "(", "HOST_WIDE_INT", "i", ",", "enum", "rtx_code", "code", ")", "{", "HOST_WIDE_INT", "hi_val", "=", "(", "i", ">>", "32", ")", "&", "0xFFFFFFFF", ";", "HOST_WIDE_INT", "lo_val", "=", "i", "&", "0xFFFFFFFF", ";", "rtx", "hi", "=", "GEN_INT", "(", "hi_val", ")", ";", "rtx", "lo", "=", "GEN_INT", "(", "lo_val", ")", ";", "if", "(", "TARGET_THUMB1", ")", "return", "0", ";", "switch", "(", "code", ")", "{", "case", "AND", ":", "case", "IOR", ":", "case", "XOR", ":", "return", "(", "const_ok_for_op", "(", "hi_val", ",", "code", ")", "||", "hi_val", "==", "0xFFFFFFFF", ")", "&&", "(", "const_ok_for_op", "(", "lo_val", ",", "code", ")", "||", "lo_val", "==", "0xFFFFFFFF", ")", ";", "case", "PLUS", ":", "return", "arm_not_operand", "(", "hi", ",", "SImode", ")", "&&", "arm_add_operand", "(", "lo", ",", "SImode", ")", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "I", "is", "a", "valid", "di", "mode", "constant", "for", "the", "operation", "CODE", "." ]

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

[]

[ "<s>", "void", "PPCPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createPPCPreEmitPeepholePass", "(", ")", ")", ";", "addPass", "(", "createPPCExpandISELPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createPPCEarlyReturnPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "char", "*", "SystemZTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "SystemZISD", "::", "RET_FLAG", ":", "return", "\"SystemZISD::RET_FLAG\"", ";", "case", "SystemZISD", "::", "CALL", ":", "return", "\"SystemZISD::CALL\"", ";", "case", "SystemZISD", "::", "BRCOND", ":", "return", "\"SystemZISD::BRCOND\"", ";", "case", "SystemZISD", "::", "CMP", ":", "return", "\"SystemZISD::CMP\"", ";", "case", "SystemZISD", "::", "UCMP", ":", "return", "\"SystemZISD::UCMP\"", ";", "case", "SystemZISD", "::", "SELECT", ":", "return", "\"SystemZISD::SELECT\"", ";", "case", "SystemZISD", "::", "PCRelativeWrapper", ":", "return", "\"SystemZISD::PCRelativeWrapper\"", ";", "default", ":", "return", "NULL", ";", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZISD::RET_FLAG", "\"SystemZISD::RET_FLAG\"", "SystemZISD::CALL", "\"SystemZISD::CALL\"", "SystemZISD::BRCOND", "\"SystemZISD::BRCOND\"", "SystemZISD::CMP", "\"SystemZISD::CMP\"", "SystemZISD::UCMP", "\"SystemZISD::UCMP\"", "SystemZISD::SELECT", "\"SystemZISD::SELECT\"", "SystemZISD::PCRelativeWrapper", "\"SystemZISD::PCRelativeWrapper\"" ]

[]

[ "<s>", "void", "XCoreTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "DataSection", "=", "Ctx", ".", "getELFSection", "(", "\".dp.data\"", ",", "MCSectionELF", "::", "SHT_PROGBITS", ",", "MCSectionELF", "::", "SHF_ALLOC", "|", "MCSectionELF", "::", "SHF_WRITE", "|", "MCSectionELF", "::", "XCORE_SHF_DP_SECTION", ",", "SectionKind", "::", "getDataRel", "(", ")", ",", "false", ")", ";", "BSSSection", "=", "Ctx", ".", "getELFSection", "(", "\".dp.bss\"", ",", "MCSectionELF", "::", "SHT_NOBITS", ",", "MCSectionELF", "::", "SHF_ALLOC", "|", "MCSectionELF", "::", "SHF_WRITE", "|", "MCSectionELF", "::", "XCORE_SHF_DP_SECTION", ",", "SectionKind", "::", "getBSS", "(", ")", ",", "false", ")", ";", "MergeableConst4Section", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata.cst4\"", ",", "MCSectionELF", "::", "SHT_PROGBITS", ",", "MCSectionELF", "::", "SHF_ALLOC", "|", "MCSectionELF", "::", "SHF_MERGE", "|", "MCSectionELF", "::", "XCORE_SHF_CP_SECTION", ",", "SectionKind", "::", "getMergeableConst4", "(", ")", ",", "false", ")", ";", "MergeableConst8Section", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata.cst8\"", ",", "MCSectionELF", "::", "SHT_PROGBITS", ",", "MCSectionELF", "::", "SHF_ALLOC", "|", "MCSectionELF", "::", "SHF_MERGE", "|", "MCSectionELF", "::", "XCORE_SHF_CP_SECTION", ",", "SectionKind", "::", "getMergeableConst8", "(", ")", ",", "false", ")", ";", "MergeableConst16Section", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata.cst16\"", ",", "MCSectionELF", "::", "SHT_PROGBITS", ",", "MCSectionELF", "::", "SHF_ALLOC", "|", "MCSectionELF", "::", "SHF_MERGE", "|", "MCSectionELF", "::", "XCORE_SHF_CP_SECTION", ",", "SectionKind", "::", "getMergeableConst16", "(", ")", ",", "false", ")", ";", "TLSDataSection", "=", "DataSection", ";", "TLSBSSSection", "=", "BSSSection", ";", "ReadOnlySection", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata\"", ",", "MCSectionELF", "::", "SHT_PROGBITS", ",", "MCSectionELF", "::", "SHF_ALLOC", "|", "MCSectionELF", "::", "XCORE_SHF_CP_SECTION", ",", "SectionKind", "::", "getReadOnlyWithRel", "(", ")", ",", "false", ")", ";", "DataRelSection", "=", "DataRelLocalSection", "=", "DataSection", ";", "DataRelROSection", "=", "DataRelROLocalSection", "=", "ReadOnlySection", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "\".dp.data\"", "\".dp.bss\"", "\".cp.rodata.cst4\"", "\".cp.rodata.cst8\"", "\".cp.rodata.cst16\"", "\".cp.rodata\"" ]

[]

[ "<s>", "static", "bool", "rs6000_parm_needs_stack", "(", "cumulative_args_t", "args_so_far", ",", "tree", "type", ")", "{", "machine_mode", "mode", ";", "int", "unsignedp", ";", "rtx", "entry_parm", ";", "if", "(", "type", "==", "NULL", "||", "type", "==", "error_mark_node", ")", "return", "true", ";", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "VOIDmode", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "COMPLEX_TYPE", ")", "return", "(", "rs6000_parm_needs_stack", "(", "args_so_far", ",", "TREE_TYPE", "(", "type", ")", ")", "||", "rs6000_parm_needs_stack", "(", "args_so_far", ",", "TREE_TYPE", "(", "type", ")", ")", ")", ";", "if", "(", "(", "TREE_CODE", "(", "type", ")", "==", "UNION_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", ")", "&&", "TYPE_TRANSPARENT_AGGR", "(", "type", ")", ")", "type", "=", "TREE_TYPE", "(", "first_field", "(", "type", ")", ")", ";", "if", "(", "pass_by_reference", "(", "get_cumulative_args", "(", "args_so_far", ")", ",", "TYPE_MODE", "(", "type", ")", ",", "type", ",", "true", ")", ")", "type", "=", "build_pointer_type", "(", "type", ")", ";", "unsignedp", "=", "TYPE_UNSIGNED", "(", "type", ")", ";", "mode", "=", "promote_mode", "(", "type", ",", "TYPE_MODE", "(", "type", ")", ",", "&", "unsignedp", ")", ";", "if", "(", "rs6000_must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "true", ";", "entry_parm", "=", "rs6000_function_arg", "(", "args_so_far", ",", "mode", ",", "type", ",", "true", ")", ";", "if", "(", "entry_parm", "==", "NULL", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "entry_parm", ")", "==", "PARALLEL", "&&", "XEXP", "(", "XVECEXP", "(", "entry_parm", ",", "0", ",", "0", ")", ",", "0", ")", "==", "NULL_RTX", ")", "return", "true", ";", "if", "(", "rs6000_arg_partial_bytes", "(", "args_so_far", ",", "mode", ",", "type", ",", "true", ")", "!=", "0", ")", "return", "true", ";", "rs6000_function_arg_advance", "(", "args_so_far", ",", "mode", ",", "type", ",", "true", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Process", "parameter", "of", "type", "TYPE", "after", "ARGS_SO_FAR", "parameters", "were", "already", "processes", ".", "Return", "true", "if", "the", "parameter", "must", "be", "passed", "(", "fully", "or", "partially", ")", "on", "the", "stack", "." ]

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

[]

[ "<s>", "void", "Cpu0SEInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "Opc", "=", "0", ",", "ZeroReg", "=", "0", ";", "if", "(", "Cpu0", "::", "CPURegsRegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "if", "(", "Cpu0", "::", "CPURegsRegClass", ".", "contains", "(", "SrcReg", ")", ")", "Opc", "=", "Cpu0", "::", "ADDu", ",", "ZeroReg", "=", "Cpu0", "::", "ZERO", ";", "else", "if", "(", "SrcReg", "==", "Cpu0", "::", "HI", ")", "Opc", "=", "Cpu0", "::", "MFHI", ",", "SrcReg", "=", "0", ";", "else", "if", "(", "SrcReg", "==", "Cpu0", "::", "LO", ")", "Opc", "=", "Cpu0", "::", "MFLO", ",", "SrcReg", "=", "0", ";", "}", "else", "if", "(", "Cpu0", "::", "CPURegsRegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "if", "(", "DestReg", "==", "Cpu0", "::", "HI", ")", "Opc", "=", "Cpu0", "::", "MTHI", ",", "DestReg", "=", "0", ";", "else", "if", "(", "DestReg", "==", "Cpu0", "::", "LO", ")", "Opc", "=", "Cpu0", "::", "MTLO", ",", "DestReg", "=", "0", ";", "}", "assert", "(", "Opc", "&&", "\"Cannot copy registers\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ")", ";", "if", "(", "DestReg", ")", "MIB", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", ")", ";", "if", "(", "ZeroReg", ")", "MIB", ".", "addReg", "(", "ZeroReg", ")", ";", "if", "(", "SrcReg", ")", "MIB", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "0", "0", "Cpu0::CPURegsRegClass", "Cpu0::CPURegsRegClass", "Cpu0::ADDu", "Cpu0::ZERO", "Cpu0::HI", "Cpu0::MFHI", "0", "Cpu0::LO", "Cpu0::MFLO", "0", "Cpu0::CPURegsRegClass", "Cpu0::HI", "Cpu0::MTHI", "0", "Cpu0::LO", "Cpu0::MTLO", "0", "\"Cannot copy registers\"" ]

[]

[ "<s>", "static", "rtx", "mips_frame_set", "(", "rtx", "mem", ",", "rtx", "reg", ")", "{", "rtx", "set", ";", "set", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "mem", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "set", ")", "=", "1", ";", "return", "set", ";", "}", "</s>" ]

[ "Return", "a", "frame-related", "rtx", "that", "stores", "register", "REGNO", "at", "(", "SP", "+", "OFFSET", ")", ".", "The", "expression", "should", "only", "be", "used", "to", "store", "single", "registers", "." ]

[ "mips", "1" ]

[]

[ "<s>", "SMLoc", "getStartLoc", "(", ")", "const", "override", "{", "return", "Start", ";", "}", "</s>" ]

[ "getStartLoc", "-", "Get", "the", "location", "of", "the", "first", "token", "of", "this", "operand", "." ]

[ "M68k" ]

[]

[ "<s>", "bool", "ia64_const_double_ok_for_letter_p", "(", "rtx", "value", ",", "char", "c", ")", "{", "switch", "(", "c", ")", "{", "case", "'G'", ":", "return", "CONST_DOUBLE_OK_FOR_G", "(", "value", ")", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Implement", "CONST_DOUBLE_OK_FOR_LETTER_P", "." ]

[ "ia64" ]

[]

[ "<s>", "static", "void", "xtensa_conditional_register_usage", "(", "void", ")", "{", "unsigned", "i", ",", "c_mask", ";", "c_mask", "=", "TARGET_WINDOWED_ABI", "?", "(", "1", "<<", "1", ")", ":", "(", "1", "<<", "2", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "{", "if", "(", "call_used_regs", "[", "i", "]", ">", "1", ")", "call_used_regs", "[", "i", "]", "=", "!", "!", "(", "call_used_regs", "[", "i", "]", "&", "c_mask", ")", ";", "}", "CLEAR_HARD_REG_BIT", "(", "reg_class_contents", "[", "(", "int", ")", "RL_REGS", "]", ",", "HARD_FRAME_POINTER_REGNUM", ")", ";", "}", "</s>" ]

[ "Update", "register", "usage", "after", "having", "seen", "the", "compiler", "flags", "." ]

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

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreRegBankSelect", "(", ")", "{", "bool", "IsOptNone", "=", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ";", "if", "(", "!", "IsOptNone", ")", "{", "addPass", "(", "createAArch64PostLegalizerCombiner", "(", "IsOptNone", ")", ")", ";", "if", "(", "EnableGISelLoadStoreOptPostLegal", ")", "addPass", "(", "new", "LoadStoreOpt", "(", ")", ")", ";", "}", "addPass", "(", "createAArch64PostLegalizerLowering", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "PIC16TargetMachine", "::", "addPostRegAlloc", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "PM", ".", "add", "(", "createPIC16MemSelOptimizerPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "register", "allocation", "pass", "pipeline", "but", "before", "prolog-epilog", "insertion", "." ]

[ "PIC16", "PIC16", "PIC16" ]

[]

[ "<s>", "static", "tree", "alpha_fold_builtin_insxx", "(", "tree", "op", "[", "]", ",", "unsigned", "HOST_WIDE_INT", "opint", "[", "]", ",", "long", "op_const", ",", "unsigned", "HOST_WIDE_INT", "bytemask", ",", "bool", "is_high", ")", "{", "if", "(", "(", "op_const", "&", "1", ")", "&&", "opint", "[", "0", "]", "==", "0", ")", "return", "build_int_cst", "(", "alpha_dimode_u", ",", "0", ")", ";", "if", "(", "op_const", "&", "2", ")", "{", "unsigned", "HOST_WIDE_INT", "temp", ",", "loc", ",", "byteloc", ";", "tree", "*", "zap_op", "=", "NULL", ";", "loc", "=", "opint", "[", "1", "]", "&", "7", ";", "bytemask", "<<=", "loc", ";", "temp", "=", "opint", "[", "0", "]", ";", "if", "(", "is_high", ")", "{", "byteloc", "=", "(", "64", "-", "(", "loc", "*", "8", ")", ")", "&", "0x3f", ";", "if", "(", "byteloc", "==", "0", ")", "zap_op", "=", "op", ";", "else", "temp", ">>=", "byteloc", ";", "bytemask", ">>=", "8", ";", "}", "else", "{", "byteloc", "=", "loc", "*", "8", ";", "if", "(", "byteloc", "==", "0", ")", "zap_op", "=", "op", ";", "else", "temp", "<<=", "byteloc", ";", "}", "opint", "[", "0", "]", "=", "temp", ";", "opint", "[", "1", "]", "=", "bytemask", ";", "return", "alpha_fold_builtin_zapnot", "(", "zap_op", ",", "opint", ",", "op_const", ")", ";", "}", "return", "NULL", ";", "}", "</s>" ]

[ "Fold", "the", "builtins", "for", "the", "INS", "family", "of", "instructions", "." ]

[ "alpha", "1", "0", "0", "0", "2", "1", "7", "0", "64", "8", "0x3f", "0", "8", "8", "0", "0", "1" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "*", "PPCInstrInfo", "::", "CreateTargetHazardRecognizer", "(", "const", "TargetSubtargetInfo", "*", "STI", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "unsigned", "Directive", "=", "static_cast", "<", "const", "PPCSubtarget", "*", ">", "(", "STI", ")", "->", "getDarwinDirective", "(", ")", ";", "if", "(", "Directive", "==", "PPC", "::", "DIR_440", "||", "Directive", "==", "PPC", "::", "DIR_A2", "||", "Directive", "==", "PPC", "::", "DIR_E500mc", "||", "Directive", "==", "PPC", "::", "DIR_E5500", ")", "{", "const", "InstrItineraryData", "*", "II", "=", "static_cast", "<", "const", "PPCSubtarget", "*", ">", "(", "STI", ")", "->", "getInstrItineraryData", "(", ")", ";", "return", "new", "ScoreboardHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "}", "return", "TargetInstrInfo", "::", "CreateTargetHazardRecognizer", "(", "STI", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Allocate", "and", "return", "a", "hazard", "recognizer", "to", "use", "for", "this", "target", "when", "scheduling", "the", "machine", "instructions", "before", "register", "allocation", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::DIR_440", "PPC::DIR_A2", "PPC::DIR_E500mc", "PPC::DIR_E5500", "PPC" ]

[]

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

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

[ "Teak", "Teak" ]

[]

[ "<s>", "unsigned", "SITargetLowering", "::", "getNumRegistersForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ")", "const", "{", "if", "(", "CC", "!=", "CallingConv", "::", "AMDGPU_KERNEL", "&&", "VT", ".", "isVector", "(", ")", ")", "{", "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "EVT", "ScalarVT", "=", "VT", ".", "getScalarType", "(", ")", ";", "unsigned", "Size", "=", "ScalarVT", ".", "getSizeInBits", "(", ")", ";", "if", "(", "Size", "==", "32", ")", "return", "NumElts", ";", "if", "(", "Size", "==", "64", ")", "return", "2", "*", "NumElts", ";", "if", "(", "Size", "==", "16", "&&", "Subtarget", "->", "has16BitInsts", "(", ")", "&&", "isPowerOf2_32", "(", "NumElts", ")", ")", "return", "VT", ".", "getVectorNumElements", "(", ")", "/", "2", ";", "}", "return", "TargetLowering", "::", "getNumRegistersForCallingConv", "(", "Context", ",", "CC", ",", "VT", ")", ";", "}", "</s>" ]

[ "Certain", "targets", "require", "unusual", "breakdowns", "of", "certain", "types", "." ]

[ "AMDGPU", "SI", "AMDGPU", "32", "64", "2", "16", "2" ]

[]

[ "<s>", "static", "rtx", "moxie_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", "fun", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "mode", ",", "MOXIE_R0", ")", ";", "}", "</s>" ]

[ "Define", "how", "to", "find", "the", "value", "returned", "by", "a", "library", "function", ".", "We", "always", "return", "values", "in", "register", "$", "r0", "for", "moxie", "." ]

[ "moxie" ]

[]

[ "<s>", "bool", "avr_addr_space_supported_p", "(", "addr_space_t", "as", ",", "location_t", "loc", ")", "{", "if", "(", "AVR_TINY", ")", "{", "if", "(", "loc", "!=", "UNKNOWN_LOCATION", ")", "error_at", "(", "loc", ",", "\"address spaces are not supported for reduced \"", "\"Tiny devices\"", ")", ";", "return", "false", ";", "}", "else", "if", "(", "avr_addrspace", "[", "as", "]", ".", "segment", ">=", "avr_n_flash", ")", "{", "if", "(", "loc", "!=", "UNKNOWN_LOCATION", ")", "error_at", "(", "loc", ",", "\"address space %qs not supported for devices with \"", "\"flash size up to %d KiB\"", ",", "avr_addrspace", "[", "as", "]", ".", "name", ",", "64", "*", "avr_n_flash", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "support", "address", "space", "AS", "for", "the", "architecture", "in", "effect", "and", "false", ",", "otherwise", ".", "If", "LOC", "is", "not", "UNKNOWN_LOCATION", "then", "also", "issue", "a", "respective", "error", "." ]

[ "avr", "\"address spaces are not supported for reduced \"", "\"Tiny devices\"", "\"address space %qs not supported for devices with \"", "\"flash size up to %d KiB\"", "64" ]

[]

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

[ "addGCPasses", "-", "Add", "late", "codegen", "passes", "that", "analyze", "code", "for", "garbage", "collection", "." ]

[ "JVM" ]

[]

[ "<s>", "static", "rtx", "sparc_function_arg_1", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ",", "bool", "incoming", ")", "{", "const", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "regbase", "=", "(", "incoming", "?", "SPARC_INCOMING_INT_ARG_FIRST", ":", "SPARC_OUTGOING_INT_ARG_FIRST", ")", ";", "int", "slotno", ",", "regno", ",", "padding", ";", "enum", "mode_class", "mclass", "=", "GET_MODE_CLASS", "(", "mode", ")", ";", "slotno", "=", "function_arg_slotno", "(", "cum", ",", "mode", ",", "type", ",", "named", ",", "incoming", ",", "&", "regno", ",", "&", "padding", ")", ";", "if", "(", "slotno", "==", "-", "1", ")", "return", "0", ";", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "(", "TARGET_ARCH32", "&&", "size", "<=", "8", ")", "||", "(", "TARGET_ARCH64", "&&", "size", "<=", "16", ")", ")", ";", "if", "(", "mode", "==", "BLKmode", ")", "return", "function_arg_vector_value", "(", "size", ",", "SPARC_FP_ARG_FIRST", "+", "2", "*", "slotno", ")", ";", "mclass", "=", "MODE_FLOAT", ";", "}", "if", "(", "TARGET_ARCH32", ")", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "size", "<=", "16", ")", ";", "return", "function_arg_record_value", "(", "type", ",", "mode", ",", "slotno", ",", "named", ",", "regbase", ")", ";", "}", "else", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "UNION_TYPE", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "size", "<=", "16", ")", ";", "return", "function_arg_union_value", "(", "size", ",", "mode", ",", "slotno", ",", "regno", ")", ";", "}", "else", "if", "(", "(", "mclass", "==", "MODE_FLOAT", "||", "mclass", "==", "MODE_COMPLEX_FLOAT", ")", "&&", "SPARC_FP_REG_P", "(", "regno", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "if", "(", "cum", "->", "prototype_p", "||", "cum", "->", "libcall_p", ")", "return", "reg", ";", "else", "{", "rtx", "v0", ",", "v1", ";", "if", "(", "(", "regno", "-", "SPARC_FP_ARG_FIRST", ")", "<", "SPARC_INT_ARG_MAX", "*", "2", ")", "{", "int", "intreg", ";", "if", "(", "incoming", ")", "return", "reg", ";", "intreg", "=", "(", "SPARC_OUTGOING_INT_ARG_FIRST", "+", "(", "regno", "-", "SPARC_FP_ARG_FIRST", ")", "/", "2", ")", ";", "v0", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg", ",", "const0_rtx", ")", ";", "v1", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "intreg", ")", ",", "const0_rtx", ")", ";", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "v0", ",", "v1", ")", ")", ";", "}", "else", "{", "v0", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "NULL_RTX", ",", "const0_rtx", ")", ";", "v1", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg", ",", "const0_rtx", ")", ";", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "v0", ",", "v1", ")", ")", ";", "}", "}", "}", "else", "if", "(", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "size", "<=", "16", ")", ";", "mode", "=", "mode_for_size", "(", "size", "*", "BITS_PER_UNIT", ",", "MODE_INT", ",", "0", ")", ";", "}", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}", "</s>" ]

[ "Determine", "where", "to", "put", "an", "argument", "to", "a", "function", ".", "Value", "is", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "NAMED", "is", "true", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "INCOMING_P", "is", "false", "for", "TARGET_FUNCTION_ARG", ",", "true", "for", "TARGET_FUNCTION_INCOMING_ARG", "." ]

[ "sparc", "1", "0", "8", "16", "2", "16", "16", "2", "2", "2", "2", "16", "0" ]

[]

[ "<s>", "enum", "rtx_code", "ix86_fp_compare_code_to_integer", "(", "enum", "rtx_code", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "GT", ":", "return", "GTU", ";", "case", "GE", ":", "return", "GEU", ";", "case", "ORDERED", ":", "case", "UNORDERED", ":", "return", "code", ";", "break", ";", "case", "UNEQ", ":", "return", "EQ", ";", "break", ";", "case", "UNLT", ":", "return", "LTU", ";", "break", ";", "case", "UNLE", ":", "return", "LEU", ";", "break", ";", "case", "LTGT", ":", "return", "NE", ";", "break", ";", "default", ":", "return", "UNKNOWN", ";", "}", "}", "</s>" ]

[ "Convert", "comparison", "codes", "we", "use", "to", "represent", "FP", "comparison", "to", "integer", "code", "that", "will", "result", "in", "proper", "branch", ".", "Return", "UNKNOWN", "if", "no", "such", "code", "is", "available", "." ]

[ "i386" ]

[]

[ "<s>", "int", "h8300_funcvec_function_p", "(", "tree", "func", ")", "{", "tree", "a", ";", "if", "(", "TREE_CODE", "(", "func", ")", "!=", "FUNCTION_DECL", ")", "return", "0", ";", "a", "=", "lookup_attribute", "(", "\"function_vector\"", ",", "DECL_ATTRIBUTES", "(", "func", ")", ")", ";", "return", "a", "!=", "NULL_TREE", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "FUNC", "is", "a", "function", "that", "should", "be", "called", "through", "the", "function", "vector", "." ]

[ "h8300", "0", "\"function_vector\"" ]

[]

[ "<s>", "pure_scalable_type_info", "::", "analysis_result", "pure_scalable_type_info", "::", "analyze_record", "(", "const_tree", "type", ")", "{", "for", "(", "tree", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "field", ";", "field", "=", "TREE_CHAIN", "(", "field", ")", ")", "{", "if", "(", "TREE_CODE", "(", "field", ")", "!=", "FIELD_DECL", ")", "continue", ";", "if", "(", "DECL_SIZE", "(", "field", ")", "&&", "integer_zerop", "(", "DECL_SIZE", "(", "field", ")", ")", ")", "continue", ";", "pure_scalable_type_info", "field_info", ";", "analysis_result", "subresult", "=", "field_info", ".", "analyze", "(", "TREE_TYPE", "(", "field", ")", ")", ";", "if", "(", "subresult", "==", "NO_ABI_IDENTITY", ")", "continue", ";", "if", "(", "subresult", "!=", "IS_PST", ")", "return", "subresult", ";", "tree", "bitpos", "=", "bit_position", "(", "field", ")", ";", "gcc_assert", "(", "poly_int_tree_p", "(", "bitpos", ")", ")", ";", "poly_widest_int", "wide_bytepos", "=", "exact_div", "(", "wi", "::", "to_poly_widest", "(", "bitpos", ")", ",", "BITS_PER_UNIT", ")", ";", "poly_uint64", "bytepos", ";", "if", "(", "!", "wide_bytepos", ".", "to_uhwi", "(", "&", "bytepos", ")", "||", "pieces", ".", "length", "(", ")", "+", "field_info", ".", "pieces", ".", "length", "(", ")", ">", "MAX_PIECES", ")", "return", "DOESNT_MATTER", ";", "gcc_assert", "(", "!", "field_info", ".", "pieces", ".", "is_empty", "(", ")", ")", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "field_info", ".", "pieces", ".", "length", "(", ")", ";", "++", "i", ")", "{", "piece", "p", "=", "field_info", ".", "pieces", "[", "i", "]", ";", "p", ".", "offset", "+=", "bytepos", ";", "add_piece", "(", "p", ")", ";", "}", "}", "return", "pieces", ".", "is_empty", "(", ")", "?", "NO_ABI_IDENTITY", ":", "IS_PST", ";", "}", "</s>" ]

[ "Subroutine", "of", "analyze", "for", "handling", "RECORD_TYPEs", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "optimizeCompareInstr", "(", "MachineInstr", "*", "CmpInstr", ",", "unsigned", "SrcReg", ",", "unsigned", "SrcReg2", ",", "int", "CmpMask", ",", "int", "CmpValue", ",", "const", "MachineRegisterInfo", "*", "MRI", ")", "const", "{", "assert", "(", "CmpInstr", ")", ";", "assert", "(", "CmpInstr", "->", "getParent", "(", ")", ")", ";", "assert", "(", "MRI", ")", ";", "int", "DeadNZCVIdx", "=", "CmpInstr", "->", "findRegisterDefOperandIdx", "(", "AArch64", "::", "NZCV", ",", "true", ")", ";", "if", "(", "DeadNZCVIdx", "!=", "-", "1", ")", "{", "if", "(", "CmpInstr", "->", "definesRegister", "(", "AArch64", "::", "WZR", ")", "||", "CmpInstr", "->", "definesRegister", "(", "AArch64", "::", "XZR", ")", ")", "{", "CmpInstr", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "unsigned", "Opc", "=", "CmpInstr", "->", "getOpcode", "(", ")", ";", "unsigned", "NewOpc", "=", "convertFlagSettingOpcode", "(", "CmpInstr", ")", ";", "if", "(", "NewOpc", "==", "Opc", ")", "return", "false", ";", "const", "MCInstrDesc", "&", "MCID", "=", "get", "(", "NewOpc", ")", ";", "CmpInstr", "->", "setDesc", "(", "MCID", ")", ";", "CmpInstr", "->", "RemoveOperand", "(", "DeadNZCVIdx", ")", ";", "bool", "succeeded", "=", "UpdateOperandRegClass", "(", "CmpInstr", ")", ";", "(", "void", ")", "succeeded", ";", "assert", "(", "succeeded", "&&", "\"Some operands reg class are incompatible!\"", ")", ";", "return", "true", ";", "}", "assert", "(", "(", "CmpValue", "==", "0", "||", "CmpValue", "==", "1", ")", "&&", "\"CmpValue must be 0 or 1!\"", ")", ";", "if", "(", "CmpValue", "!=", "0", "||", "SrcReg2", "!=", "0", ")", "return", "false", ";", "if", "(", "!", "MRI", "->", "use_nodbg_empty", "(", "CmpInstr", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", "return", "false", ";", "return", "substituteCmpToZero", "(", "CmpInstr", ",", "SrcReg", ",", "MRI", ")", ";", "}", "</s>" ]

[ "optimizeCompareInstr", "-", "Check", "if", "there", "exists", "an", "earlier", "instruction", "that", "operates", "on", "the", "same", "source", "operands", "and", "sets", "flags", "in", "the", "same", "way", "as", "Compare", ";", "remove", "Compare", "if", "possible", "." ]

[ "AArch64", "AArch64", "AArch64::NZCV", "1", "AArch64::WZR", "AArch64::XZR", "\"Some operands reg class are incompatible!\"", "0", "1", "\"CmpValue must be 0 or 1!\"", "0", "0", "0" ]

[]

[ "<s>", "bool", "AArch64Subtarget", "::", "useAA", "(", ")", "const", "{", "return", "UseAA", ";", "}", "</s>" ]

[ "Enable", "use", "of", "alias", "analysis", "during", "code", "generation", "(", "during", "MI", "scheduling", ",", "DAGCombine", ",", "etc", ".", ")", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "void", "add_compiler_branch_island", "(", "tree", "label_name", ",", "tree", "function_name", ",", "int", "line_number", ")", "{", "branch_island", "bi", "=", "{", "function_name", ",", "label_name", ",", "line_number", "}", ";", "vec_safe_push", "(", "branch_islands", ",", "bi", ")", ";", "}", "</s>" ]

[ "Remember", "to", "generate", "a", "branch", "island", "for", "far", "calls", "to", "the", "given", "function", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "bool", "HexagonGenMux", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "HII", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "HRI", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "I", ":", "MF", ")", "Changed", "|=", "genMuxInBlock", "(", "I", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "int", "mips_hard_regno_nregs", "(", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "ST_REG_P", "(", "regno", ")", ")", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "3", ")", "/", "4", ";", "if", "(", "FP_REG_P", "(", "regno", ")", ")", "{", "if", "(", "MSA_SUPPORTED_MODE_P", "(", "mode", ")", ")", "return", "1", ";", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_FPREG", "-", "1", ")", "/", "UNITS_PER_FPREG", ";", "}", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Implement", "HARD_REGNO_NREGS", "." ]

[ "mips", "3", "4", "1", "1", "1" ]

[]

[ "<s>", "void", "EmitInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "bool", ")", "override", "{", "if", "(", "isIndirectJump", "(", "Inst", ")", ")", "{", "if", "(", "PendingCall", ")", "report_fatal_error", "(", "\"Dangerous instruction in branch delay slot!\"", ")", ";", "sandboxIndirectJump", "(", "Inst", ",", "STI", ")", ";", "return", ";", "}", "unsigned", "AddrIdx", ";", "bool", "IsStore", ";", "bool", "IsMemAccess", "=", "isBasePlusOffsetMemoryAccess", "(", "Inst", ".", "getOpcode", "(", ")", ",", "&", "AddrIdx", ",", "&", "IsStore", ")", ";", "bool", "IsSPFirstOperand", "=", "isStackPointerFirstOperand", "(", "Inst", ")", ";", "if", "(", "IsMemAccess", "||", "IsSPFirstOperand", ")", "{", "bool", "MaskBefore", "=", "(", "IsMemAccess", "&&", "baseRegNeedsLoadStoreMask", "(", "Inst", ".", "getOperand", "(", "AddrIdx", ")", ".", "getReg", "(", ")", ")", ")", ";", "bool", "MaskAfter", "=", "IsSPFirstOperand", "&&", "!", "IsStore", ";", "if", "(", "MaskBefore", "||", "MaskAfter", ")", "{", "if", "(", "PendingCall", ")", "report_fatal_error", "(", "\"Dangerous instruction in branch delay slot!\"", ")", ";", "sandboxLoadStoreStackChange", "(", "Inst", ",", "AddrIdx", ",", "STI", ",", "MaskBefore", ",", "MaskAfter", ")", ";", "return", ";", "}", "}", "bool", "IsIndirectCall", ";", "if", "(", "isCall", "(", "Inst", ",", "&", "IsIndirectCall", ")", ")", "{", "if", "(", "PendingCall", ")", "report_fatal_error", "(", "\"Dangerous instruction in branch delay slot!\"", ")", ";", "EmitBundleLock", "(", "true", ")", ";", "if", "(", "IsIndirectCall", ")", "{", "unsigned", "TargetReg", "=", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "emitMask", "(", "TargetReg", ",", "IndirectBranchMaskReg", ",", "STI", ")", ";", "}", "MipsELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "PendingCall", "=", "true", ";", "return", ";", "}", "if", "(", "PendingCall", ")", "{", "MipsELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "EmitBundleUnlock", "(", ")", ";", "PendingCall", "=", "false", ";", "return", ";", "}", "MipsELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "Mips", "\"Dangerous instruction in branch delay slot!\"", "\"Dangerous instruction in branch delay slot!\"", "\"Dangerous instruction in branch delay slot!\"", "1", "Mips", "Mips", "Mips" ]

[]

[ "<s>", "static", "unsigned", "long", "thumb1_compute_save_reg_mask", "(", "void", ")", "{", "unsigned", "long", "mask", ";", "unsigned", "reg", ";", "mask", "=", "0", ";", "for", "(", "reg", "=", "0", ";", "reg", "<", "12", ";", "reg", "++", ")", "if", "(", "df_regs_ever_live_p", "(", "reg", ")", "&&", "callee_saved_reg_p", "(", "reg", ")", ")", "mask", "|=", "1", "<<", "reg", ";", "if", "(", "frame_pointer_needed", ")", "mask", "|=", "1", "<<", "HARD_FRAME_POINTER_REGNUM", ";", "if", "(", "flag_pic", "&&", "!", "TARGET_SINGLE_PIC_BASE", "&&", "arm_pic_register", "!=", "INVALID_REGNUM", "&&", "crtl", "->", "uses_pic_offset_table", ")", "mask", "|=", "1", "<<", "PIC_OFFSET_TABLE_REGNUM", ";", "if", "(", "!", "frame_pointer_needed", "&&", "CALLER_INTERWORKING_SLOT_SIZE", ">", "0", ")", "mask", "|=", "1", "<<", "ARM_HARD_FRAME_POINTER_REGNUM", ";", "if", "(", "mask", "&", "0xff", "||", "thumb_force_lr_save", "(", ")", ")", "mask", "|=", "(", "1", "<<", "LR_REGNUM", ")", ";", "if", "(", "(", "mask", "&", "0xff", ")", "==", "0", "&&", "(", "(", "mask", "&", "0x0f00", ")", "||", "TARGET_BACKTRACE", ")", ")", "{", "reg", "=", "thumb_find_work_register", "(", "1", "<<", "LAST_LO_REGNUM", ")", ";", "if", "(", "reg", "*", "UNITS_PER_WORD", "<=", "(", "unsigned", ")", "arm_size_return_regs", "(", ")", ")", "reg", "=", "LAST_LO_REGNUM", ";", "if", "(", "callee_saved_reg_p", "(", "reg", ")", ")", "mask", "|=", "1", "<<", "reg", ";", "}", "if", "(", "(", "CALLER_INTERWORKING_SLOT_SIZE", "+", "ROUND_UP_WORD", "(", "get_frame_size", "(", ")", ")", "+", "crtl", "->", "outgoing_args_size", ")", ">=", "504", ")", "{", "for", "(", "reg", "=", "LAST_ARG_REGNUM", "+", "1", ";", "reg", "<=", "LAST_LO_REGNUM", ";", "reg", "++", ")", "if", "(", "mask", "&", "(", "1", "<<", "reg", ")", ")", "break", ";", "if", "(", "reg", ">", "LAST_LO_REGNUM", ")", "{", "mask", "|=", "1", "<<", "LAST_LO_REGNUM", ";", "}", "}", "return", "mask", ";", "}", "</s>" ]

[ "Compute", "a", "bit", "mask", "of", "which", "registers", "need", "to", "be", "saved", "on", "the", "stack", "for", "the", "current", "function", "." ]

[ "arm", "0", "0", "12", "1", "1", "1", "0", "1", "0xff", "1", "0xff", "0", "0x0f00", "1", "1", "504", "1", "1", "1" ]

[]

[ "<s>", "const", "char", "*", "arm_output_shift", "(", "rtx", "*", "operands", ",", "int", "set_flags", ")", "{", "char", "pattern", "[", "100", "]", ";", "static", "const", "char", "flag_chars", "[", "3", "]", "=", "{", "'?'", ",", "'.'", ",", "'!'", "}", ";", "const", "char", "*", "shift", ";", "HOST_WIDE_INT", "val", ";", "char", "c", ";", "c", "=", "flag_chars", "[", "set_flags", "]", ";", "shift", "=", "shift_op", "(", "operands", "[", "3", "]", ",", "&", "val", ")", ";", "if", "(", "shift", ")", "{", "if", "(", "val", "!=", "-", "1", ")", "operands", "[", "2", "]", "=", "GEN_INT", "(", "val", ")", ";", "sprintf", "(", "pattern", ",", "\"%s%%%c\\t%%0, %%1, %%2\"", ",", "shift", ",", "c", ")", ";", "}", "else", "sprintf", "(", "pattern", ",", "\"mov%%%c\\t%%0, %%1\"", ",", "c", ")", ";", "output_asm_insn", "(", "pattern", ",", "operands", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "assembly", "for", "a", "shift", "instruction", ".", "SET_FLAGS", "determines", "how", "the", "instruction", "modifies", "the", "condition", "codes", ".", "0", "-", "Do", "not", "set", "condition", "codes", ".", "1", "-", "Set", "condition", "codes", ".", "2", "-", "Use", "smallest", "instruction", "." ]

[ "arm", "100", "3", "3", "1", "2", "\"%s%%%c\\t%%0, %%1, %%2\"", "\"mov%%%c\\t%%0, %%1\"", "\"\"" ]

[]

[ "<s>", "rtx", "gen_datalabel_ref", "(", "rtx", "sym", ")", "{", "const", "char", "*", "str", ";", "if", "(", "GET_CODE", "(", "sym", ")", "==", "LABEL_REF", ")", "return", "gen_rtx_CONST", "(", "GET_MODE", "(", "sym", ")", ",", "gen_rtx_UNSPEC", "(", "GET_MODE", "(", "sym", ")", ",", "gen_rtvec", "(", "1", ",", "sym", ")", ",", "UNSPEC_DATALABEL", ")", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "sym", ")", "==", "SYMBOL_REF", ")", ";", "str", "=", "XSTR", "(", "sym", ",", "0", ")", ";", "str", "=", "IDENTIFIER_POINTER", "(", "get_identifier", "(", "str", ")", ")", ";", "XSTR", "(", "sym", ",", "0", ")", "=", "str", ";", "return", "sym", ";", "}", "</s>" ]

[ "Prefix", "a", "symbol_ref", "name", "with", "``", "datalabel", "''", "." ]

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

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "assert", "(", "!", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", "&&", "\"No stack realignment on AArch64!\"", ")", ";", "return", "(", "MFI", "->", "hasCalls", "(", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", "||", "MFI", "->", "hasStackMap", "(", ")", "||", "MFI", "->", "hasPatchPoint", "(", ")", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"No stack realignment on AArch64!\"" ]

[]

[ "<s>", "static", "bool", "c6x_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "int", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "return", "size", ">", "2", "*", "UNITS_PER_WORD", "||", "size", "==", "-", "1", ";", "}", "</s>" ]

[ "Decide", "whether", "a", "type", "should", "be", "returned", "in", "memory", "(", "true", ")", "or", "in", "a", "register", "(", "false", ")", ".", "This", "is", "called", "by", "the", "macro", "TARGET_RETURN_IN_MEMORY", "." ]

[ "c6x", "2", "1" ]

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "buildOutlinedFrame", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineFunction", "&", "MF", ",", "const", "outliner", "::", "OutlinedFunction", "&", "OF", ")", "const", "{", "bool", "Changed", "=", "true", ";", "while", "(", "Changed", ")", "{", "Changed", "=", "false", ";", "auto", "I", "=", "MBB", ".", "begin", "(", ")", ";", "auto", "E", "=", "MBB", ".", "end", "(", ")", ";", "for", "(", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "isCFIInstruction", "(", ")", ")", "{", "I", "->", "removeFromParent", "(", ")", ";", "Changed", "=", "true", ";", "break", ";", "}", "}", "}", "MBB", ".", "addLiveIn", "(", "RISCV", "::", "X5", ")", ";", "MBB", ".", "insert", "(", "MBB", ".", "end", "(", ")", ",", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "RISCV", "::", "JALR", ")", ")", ".", "addReg", "(", "RISCV", "::", "X0", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "RISCV", "::", "X5", ")", ".", "addImm", "(", "0", ")", ")", ";", "}", "</s>" ]

[ "Insert", "a", "custom", "frame", "for", "outlined", "functions", "." ]

[ "RI5CY", "RISCV", "RISCV::X5", "RISCV::JALR", "RISCV::X0", "RISCV::X5", "0" ]

[]

[ "<s>", "void", "recordRelocation", "(", "MCAssembler", "&", "Asm", ",", "const", "MCAsmLayout", "&", "Layout", ",", "const", "MCFragment", "*", "Fragment", ",", "const", "MCFixup", "&", "Fixup", ",", "MCValue", "Target", ",", "bool", "&", "IsPCRel", ",", "uint64_t", "&", "FixedValue", ")", "override", "{", "assert", "(", "!", "\"Not implemented\"", ")", ";", "}", "</s>" ]

[ "Record", "a", "relocation", "entry", "." ]

[ "R600", "\"Not implemented\"" ]

[]

[ "<s>", "void", "PPCAIXAsmPrinter", "::", "emitGlobalVariable", "(", "const", "GlobalVariable", "*", "GV", ")", "{", "ValidateGV", "(", "GV", ")", ";", "if", "(", "isSpecialLLVMGlobalArrayForStaticInit", "(", "GV", ")", ")", "return", ";", "MCSymbolXCOFF", "*", "GVSym", "=", "cast", "<", "MCSymbolXCOFF", ">", "(", "getSymbol", "(", "GV", ")", ")", ";", "GVSym", "->", "setStorageClass", "(", "TargetLoweringObjectFileXCOFF", "::", "getStorageClassForGlobal", "(", "GV", ")", ")", ";", "SectionKind", "GVKind", ";", "MCSectionXCOFF", "*", "Csect", "=", "cast", "<", "MCSectionXCOFF", ">", "(", "GV", "->", "isDeclaration", "(", ")", "?", "getObjFileLowering", "(", ")", ".", "getSectionForExternalReference", "(", "GV", ",", "TM", ")", ":", "getObjFileLowering", "(", ")", ".", "SectionForGlobal", "(", "GV", ",", "GVKind", "=", "getObjFileLowering", "(", ")", ".", "getKindForGlobal", "(", "GV", ",", "TM", ")", ",", "TM", ")", ")", ";", "if", "(", "GV", "->", "isDeclaration", "(", ")", ")", "return", ";", "if", "(", "!", "GVKind", ".", "isGlobalWriteableData", "(", ")", "&&", "!", "GVKind", ".", "isReadOnly", "(", ")", ")", "report_fatal_error", "(", "\"Encountered a global variable kind that is \"", "\"not supported yet.\"", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "Csect", ")", ";", "const", "DataLayout", "&", "DL", "=", "GV", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "if", "(", "GVKind", ".", "isCommon", "(", ")", "||", "GVKind", ".", "isBSSLocal", "(", ")", ")", "{", "unsigned", "Align", "=", "GV", "->", "getAlignment", "(", ")", "?", "GV", "->", "getAlignment", "(", ")", ":", "DL", ".", "getPreferredAlignment", "(", "GV", ")", ";", "uint64_t", "Size", "=", "DL", ".", "getTypeAllocSize", "(", "GV", "->", "getType", "(", ")", "->", "getElementType", "(", ")", ")", ";", "if", "(", "GVKind", ".", "isBSSLocal", "(", ")", ")", "OutStreamer", "->", "emitXCOFFLocalCommonSymbol", "(", "GVSym", ",", "Size", ",", "Csect", "->", "getQualNameSymbol", "(", ")", ",", "Align", ")", ";", "else", "OutStreamer", "->", "emitCommonSymbol", "(", "Csect", "->", "getQualNameSymbol", "(", ")", ",", "Size", ",", "Align", ")", ";", "return", ";", "}", "MCSymbol", "*", "EmittedInitSym", "=", "GVSym", ";", "emitLinkage", "(", "GV", ",", "EmittedInitSym", ")", ";", "emitAlignment", "(", "getGVAlignment", "(", "GV", ",", "DL", ")", ",", "GV", ")", ";", "OutStreamer", "->", "emitLabel", "(", "EmittedInitSym", ")", ";", "emitGlobalConstant", "(", "GV", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ",", "GV", "->", "getInitializer", "(", ")", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"Encountered a global variable kind that is \"", "\"not supported yet.\"" ]

[]

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

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

[ "CAHP", "CAHP" ]

[]

[ "<s>", "bool", "TVMPassConfig", "::", "addInstSelector", "(", ")", "{", "(", "void", ")", "TargetPassConfig", "::", "addInstSelector", "(", ")", ";", "addPass", "(", "createTVMISelDag", "(", "getTVMTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "addPass", "(", "createTVMArgumentMove", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "TVM", "TVM", "TVM", "TVM", "TVM" ]

[]

[ "<s>", "static", "bool", "csky_allocate_stack_slots_for_args", "(", "void", ")", "{", "return", "!", "CSKY_FUNCTION_IS_NAKED", "(", "get_csky_current_func_type", "(", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ALLOCATE_STACK_SLOTS_FOR_ARGS", "." ]

[ "csky" ]

[]

[ "<s>", "void", "aarch64_expand_mov_immediate", "(", "rtx", "dest", ",", "rtx", "imm", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "gcc_assert", "(", "mode", "==", "SImode", "||", "mode", "==", "DImode", ")", ";", "if", "(", "GET_CODE", "(", "imm", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "imm", ")", "==", "LABEL_REF", "||", "GET_CODE", "(", "imm", ")", "==", "CONST", ")", "{", "rtx", "mem", ",", "base", ",", "offset", ";", "enum", "aarch64_symbol_type", "sty", ";", "split_const", "(", "imm", ",", "&", "base", ",", "&", "offset", ")", ";", "sty", "=", "aarch64_classify_symbol", "(", "base", ",", "offset", ",", "SYMBOL_CONTEXT_ADR", ")", ";", "switch", "(", "sty", ")", "{", "case", "SYMBOL_FORCE_TO_MEM", ":", "if", "(", "offset", "!=", "const0_rtx", "&&", "targetm", ".", "cannot_force_const_mem", "(", "mode", ",", "imm", ")", ")", "{", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "base", "=", "aarch64_force_temporary", "(", "mode", ",", "dest", ",", "base", ")", ";", "base", "=", "aarch64_add_offset", "(", "mode", ",", "NULL", ",", "base", ",", "INTVAL", "(", "offset", ")", ")", ";", "aarch64_emit_move", "(", "dest", ",", "base", ")", ";", "return", ";", "}", "mem", "=", "force_const_mem", "(", "ptr_mode", ",", "imm", ")", ";", "gcc_assert", "(", "mem", ")", ";", "if", "(", "mode", "!=", "ptr_mode", ")", "mem", "=", "gen_rtx_ZERO_EXTEND", "(", "mode", ",", "mem", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "mem", ")", ")", ";", "return", ";", "case", "SYMBOL_SMALL_TLSGD", ":", "case", "SYMBOL_SMALL_TLSDESC", ":", "case", "SYMBOL_SMALL_GOTTPREL", ":", "case", "SYMBOL_SMALL_GOT", ":", "case", "SYMBOL_TINY_GOT", ":", "if", "(", "offset", "!=", "const0_rtx", ")", "{", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "base", "=", "aarch64_force_temporary", "(", "mode", ",", "dest", ",", "base", ")", ";", "base", "=", "aarch64_add_offset", "(", "mode", ",", "NULL", ",", "base", ",", "INTVAL", "(", "offset", ")", ")", ";", "aarch64_emit_move", "(", "dest", ",", "base", ")", ";", "return", ";", "}", "case", "SYMBOL_SMALL_TPREL", ":", "case", "SYMBOL_SMALL_ABSOLUTE", ":", "case", "SYMBOL_TINY_ABSOLUTE", ":", "aarch64_load_symref_appropriately", "(", "dest", ",", "imm", ",", "sty", ")", ";", "return", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "!", "CONST_INT_P", "(", "imm", ")", ")", "{", "if", "(", "GET_CODE", "(", "imm", ")", "==", "HIGH", ")", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "imm", ")", ")", ";", "else", "{", "rtx", "mem", "=", "force_const_mem", "(", "mode", ",", "imm", ")", ";", "gcc_assert", "(", "mem", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "mem", ")", ")", ";", "}", "return", ";", "}", "aarch64_internal_mov_immediate", "(", "dest", ",", "imm", ",", "true", ",", "GET_MODE", "(", "dest", ")", ")", ";", "}", "</s>" ]

[ "Set", "DEST", "to", "immediate", "IMM", ".", "For", "SVE", "vector", "modes", ",", "GEN_VEC_DUPLICATE", "is", "a", "pattern", "that", "can", "be", "used", "to", "set", "DEST", "to", "a", "replicated", "scalar", "element", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "func_fma_steering", "::", "rename_fma_trees", "(", ")", "{", "this", "->", "dfs", "(", "dispatch_forest", ",", "NULL", ",", "rename_fma_node", ",", "true", ")", ";", "if", "(", "dump_file", "&&", "!", "this", "->", "m_fma_forests", ".", "empty", "(", ")", ")", "{", "fprintf", "(", "dump_file", ",", "\"Function %s has \"", ",", "current_function_name", "(", ")", ")", ";", "if", "(", "this", "->", "m_fpu_balance", "==", "0", ")", "fprintf", "(", "dump_file", ",", "\"perfect balance of FMUL/FMA chains between the \"", "\"two FPU pipelines\\n\"", ")", ";", "else", "if", "(", "this", "->", "m_fpu_balance", ">", "0", ")", "fprintf", "(", "dump_file", ",", "\"%d more FMUL/FMA chains scheduled on the second \"", "\"FPU pipeline\\n\"", ",", "this", "->", "m_fpu_balance", ")", ";", "else", "fprintf", "(", "dump_file", ",", "\"%d more FMUL/FMA chains scheduled on the first \"", "\"FPU pipeline\\n\"", ",", "-", "this", "->", "m_fpu_balance", ")", ";", "}", "}", "</s>" ]

[ "Perform", "the", "renaming", "of", "all", "chains", "with", "FMUL", "or", "FMADD/FMSUB", "involved", "with", "the", "objective", "of", "keeping", "FPU", "pipeline", "balanced", "in", "term", "of", "instructions", "and", "having", "FMADD/FMSUB", "with", "dependencies", "on", "previous", "FMUL", "or", "FMADD/FMSUB", "be", "scheduled", "on", "the", "same", "pipeline", "." ]

[ "aarch64", "\"Function %s has \"", "0", "\"perfect balance of FMUL/FMA chains between the \"", "\"two FPU pipelines\\n\"", "0", "\"%d more FMUL/FMA chains scheduled on the second \"", "\"FPU pipeline\\n\"", "\"%d more FMUL/FMA chains scheduled on the first \"", "\"FPU pipeline\\n\"" ]

[]

[ "<s>", "bool", "Z80PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createZ80ISelDag", "(", "getZ80TargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "Z80", "Z80" ]

[]

[ "<s>", "bool", "M680x0DAGToDAGISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "static_cast", "<", "const", "M680x0Subtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "M680x0", "M680x0", "M680x0" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "isUnpredicatedTerminator", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "!", "MI", "->", "isTerminator", "(", ")", ")", "return", "false", ";", "if", "(", "MI", "->", "isBranch", "(", ")", "&&", "!", "MI", "->", "isBarrier", "(", ")", ")", "return", "true", ";", "return", "!", "isPredicated", "(", "MI", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "is", "a", "terminator", "instruction", "that", "has", "not", "been", "predicated", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "void", "MipsSETargetLowering", "::", "addMSAFloatType", "(", "MVT", "::", "SimpleValueType", "Ty", ",", "const", "TargetRegisterClass", "*", "RC", ")", "{", "addRegisterClass", "(", "Ty", ",", "RC", ")", ";", "for", "(", "unsigned", "Opc", "=", "0", ";", "Opc", "<", "ISD", "::", "BUILTIN_OP_END", ";", "++", "Opc", ")", "setOperationAction", "(", "Opc", ",", "Ty", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "LOAD", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "STORE", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "BITCAST", ",", "Ty", ",", "Legal", ")", ";", "if", "(", "Ty", "!=", "MVT", "::", "v8f16", ")", "{", "setOperationAction", "(", "ISD", "::", "FADD", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "FDIV", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "FLOG2", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "FMUL", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "FRINT", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "FSQRT", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "FSUB", ",", "Ty", ",", "Legal", ")", ";", "}", "}", "</s>" ]

[ "Enable", "MSA", "support", "for", "the", "given", "floating-point", "type", "and", "Register", "class", "." ]

[ "Mips", "Mips", "MVT::SimpleValueType", "0", "ISD::BUILTIN_OP_END", "ISD::LOAD", "ISD::STORE", "ISD::BITCAST", "MVT::v8f16", "ISD::FADD", "ISD::FDIV", "ISD::FLOG2", "ISD::FMUL", "ISD::FRINT", "ISD::FSQRT", "ISD::FSUB" ]

[]

[ "<s>", "static", "bool", "v2df_reduction_p", "(", "rtx", "op", ")", "{", "if", "(", "GET_MODE", "(", "op", ")", "!=", "V2DFmode", ")", "return", "false", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "op", ")", ";", "if", "(", "code", "!=", "PLUS", "&&", "code", "!=", "SMIN", "&&", "code", "!=", "SMAX", ")", "return", "false", ";", "rtx", "concat", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "concat", ")", "!=", "VEC_CONCAT", ")", "return", "false", ";", "rtx", "select0", "=", "XEXP", "(", "concat", ",", "0", ")", ";", "rtx", "select1", "=", "XEXP", "(", "concat", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "select0", ")", "!=", "VEC_SELECT", "||", "GET_CODE", "(", "select1", ")", "!=", "VEC_SELECT", ")", "return", "false", ";", "rtx", "reg0", "=", "XEXP", "(", "select0", ",", "0", ")", ";", "rtx", "reg1", "=", "XEXP", "(", "select1", ",", "0", ")", ";", "if", "(", "!", "rtx_equal_p", "(", "reg0", ",", "reg1", ")", "||", "!", "REG_P", "(", "reg0", ")", ")", "return", "false", ";", "rtx", "parallel0", "=", "XEXP", "(", "select0", ",", "1", ")", ";", "rtx", "parallel1", "=", "XEXP", "(", "select1", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "parallel0", ")", "!=", "PARALLEL", "||", "GET_CODE", "(", "parallel1", ")", "!=", "PARALLEL", ")", "return", "false", ";", "if", "(", "!", "rtx_equal_p", "(", "XVECEXP", "(", "parallel0", ",", "0", ",", "0", ")", ",", "const1_rtx", ")", "||", "!", "rtx_equal_p", "(", "XVECEXP", "(", "parallel1", ",", "0", ",", "0", ")", ",", "const0_rtx", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "TRUE", "iff", "OP", "matches", "a", "V2DF", "reduction", "pattern", ".", "See", "the", "definition", "of", "vsx_reduc_", "<", "VEC_reduc_name", ">", "_v2df", "in", "vsx.md", "." ]

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

[]

[ "<s>", "static", "bool", "mips_offset_within_alignment_p", "(", "rtx", "x", ",", "HOST_WIDE_INT", "offset", ")", "{", "HOST_WIDE_INT", "align", ";", "align", "=", "SYMBOL_REF_DECL", "(", "x", ")", "?", "DECL_ALIGN_UNIT", "(", "SYMBOL_REF_DECL", "(", "x", ")", ")", ":", "1", ";", "return", "IN_RANGE", "(", "offset", ",", "0", ",", "align", "-", "1", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "OFFSET", "is", "within", "the", "range", "[", "0", ",", "ALIGN", ")", ",", "where", "ALIGN", "is", "the", "alignment", "in", "bytes", "of", "SYMBOL_REF", "X", "." ]

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

[]

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

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

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

[]

[ "<s>", "static", "void", "mips_init_print_operand_punct", "(", "void", ")", "{", "const", "char", "*", "p", ";", "for", "(", "p", "=", "\"()[]<>*#/?~.@^+$:!\"", ";", "*", "p", ";", "p", "++", ")", "mips_print_operand_punct", "[", "(", "unsigned", "char", ")", "*", "p", "]", "=", "true", ";", "}", "</s>" ]

[ "Initialize", "mips_print_operand_punct", "." ]

[ "mips", "\"()[]<>*#/?~.@^+$:!\"" ]

[]

[ "<s>", "const", "XtensaInstrInfo", "*", "XtensaSubtarget", "::", "getInstrInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa", "Xtensa" ]

[]

[ "<s>", "bool", "RISCVAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "!", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "OS", ")", ")", "return", "false", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'z'", ":", "if", "(", "MO", ".", "isImm", "(", ")", "&&", "MO", ".", "getImm", "(", ")", "==", "0", ")", "{", "OS", "<<", "RISCVInstPrinter", "::", "getRegisterName", "(", "RISCV", "::", "X0", ")", ";", "return", "false", ";", "}", "break", ";", "case", "'i'", ":", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "OS", "<<", "'i'", ";", "return", "false", ";", "}", "}", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "case", "MachineOperand", "::", "MO_Immediate", ":", "OS", "<<", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_Register", ":", "OS", "<<", "RISCVInstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "PrintSymbolOperand", "(", "MO", ",", "OS", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "{", "MCSymbol", "*", "Sym", "=", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ";", "Sym", "->", "print", "(", "OS", ",", "MAI", ")", ";", "return", "false", ";", "}", "default", ":", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "0", "1", "0", "0", "0", "RISCV", "RISCV::X0", "RISCV" ]

[]

[ "<s>", "bool", "HexagonEvaluator", "::", "evaluate", "(", "const", "MachineInstr", "&", "BI", ",", "const", "CellMapType", "&", "Inputs", ",", "BranchTargetList", "&", "Targets", ",", "bool", "&", "FallsThru", ")", "const", "{", "unsigned", "Opc", "=", "BI", ".", "getOpcode", "(", ")", ";", "bool", "SimpleBranch", "=", "false", ";", "bool", "Negated", "=", "false", ";", "switch", "(", "Opc", ")", "{", "case", "Hexagon", "::", "J2_jumpf", ":", "case", "Hexagon", "::", "J2_jumpfpt", ":", "case", "Hexagon", "::", "J2_jumpfnew", ":", "case", "Hexagon", "::", "J2_jumpfnewpt", ":", "Negated", "=", "true", ";", "case", "Hexagon", "::", "J2_jumpt", ":", "case", "Hexagon", "::", "J2_jumptpt", ":", "case", "Hexagon", "::", "J2_jumptnew", ":", "case", "Hexagon", "::", "J2_jumptnewpt", ":", "SimpleBranch", "=", "true", ";", "break", ";", "case", "Hexagon", "::", "J2_jump", ":", "Targets", ".", "insert", "(", "BI", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ";", "FallsThru", "=", "false", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}", "if", "(", "!", "SimpleBranch", ")", "return", "false", ";", "RegisterRef", "PR", "=", "BI", ".", "getOperand", "(", "0", ")", ";", "RegisterCell", "PC", "=", "getCell", "(", "PR", ",", "Inputs", ")", ";", "const", "BT", "::", "BitValue", "&", "Test", "=", "PC", "[", "0", "]", ";", "if", "(", "!", "Test", ".", "is", "(", "0", ")", "&&", "!", "Test", ".", "is", "(", "1", ")", ")", "return", "false", ";", "if", "(", "!", "Test", ".", "is", "(", "!", "Negated", ")", ")", "{", "FallsThru", "=", "true", ";", "return", "true", ";", "}", "Targets", ".", "insert", "(", "BI", ".", "getOperand", "(", "1", ")", ".", "getMBB", "(", ")", ")", ";", "FallsThru", "=", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "evaluate", "-", "Evaluate", "Expr", "and", "append", "the", "resulting", "set", "to", "Elts", "." ]

[ "Hexagon", "Hexagon", "Hexagon::J2_jumpf", "Hexagon::J2_jumpfpt", "Hexagon::J2_jumpfnew", "Hexagon::J2_jumpfnewpt", "Hexagon::J2_jumpt", "Hexagon::J2_jumptpt", "Hexagon::J2_jumptnew", "Hexagon::J2_jumptnewpt", "Hexagon::J2_jump", "0", "0", "0", "0", "1", "1" ]

[]

[ "<s>", "void", "function_expander", "::", "add_fixed_operand", "(", "rtx", "x", ")", "{", "m_ops", ".", "safe_grow", "(", "m_ops", ".", "length", "(", ")", "+", "1", ",", "true", ")", ";", "create_fixed_operand", "(", "&", "m_ops", ".", "last", "(", ")", ",", "x", ")", ";", "}", "</s>" ]

[ "Add", "an", "operand", "that", "must", "be", "X", ".", "The", "only", "way", "of", "legitimizing", "an", "invalid", "X", "is", "to", "reload", "the", "address", "of", "a", "MEM", "." ]

[ "aarch64", "1" ]

[]

[ "<s>", "static", "tree", "sh_build_builtin_va_list", "(", "void", ")", "{", "tree", "f_next_o", ",", "f_next_o_limit", ",", "f_next_fp", ",", "f_next_fp_limit", ",", "f_next_stack", ";", "tree", "record", ",", "type_decl", ";", "if", "(", "TARGET_SH5", "||", "(", "!", "TARGET_SH2E", "&&", "!", "TARGET_SH4", ")", "||", "TARGET_HITACHI", "||", "sh_cfun_attr_renesas_p", "(", ")", ")", "return", "ptr_type_node", ";", "record", "=", "(", "*", "lang_hooks", ".", "types", ".", "make_type", ")", "(", "RECORD_TYPE", ")", ";", "type_decl", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "TYPE_DECL", ",", "get_identifier", "(", "\"__va_list_tag\"", ")", ",", "record", ")", ";", "f_next_o", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__va_next_o\"", ")", ",", "ptr_type_node", ")", ";", "f_next_o_limit", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__va_next_o_limit\"", ")", ",", "ptr_type_node", ")", ";", "f_next_fp", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__va_next_fp\"", ")", ",", "ptr_type_node", ")", ";", "f_next_fp_limit", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__va_next_fp_limit\"", ")", ",", "ptr_type_node", ")", ";", "f_next_stack", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__va_next_stack\"", ")", ",", "ptr_type_node", ")", ";", "DECL_FIELD_CONTEXT", "(", "f_next_o", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_next_o_limit", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_next_fp", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_next_fp_limit", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_next_stack", ")", "=", "record", ";", "TYPE_STUB_DECL", "(", "record", ")", "=", "type_decl", ";", "TYPE_NAME", "(", "record", ")", "=", "type_decl", ";", "TYPE_FIELDS", "(", "record", ")", "=", "f_next_o", ";", "DECL_CHAIN", "(", "f_next_o", ")", "=", "f_next_o_limit", ";", "DECL_CHAIN", "(", "f_next_o_limit", ")", "=", "f_next_fp", ";", "DECL_CHAIN", "(", "f_next_fp", ")", "=", "f_next_fp_limit", ";", "DECL_CHAIN", "(", "f_next_fp_limit", ")", "=", "f_next_stack", ";", "layout_type", "(", "record", ")", ";", "return", "record", ";", "}", "</s>" ]

[ "Define", "the", "`", "__builtin_va_list", "'", "type", "for", "the", "ABI", "." ]

[ "sh", "\"__va_list_tag\"", "\"__va_next_o\"", "\"__va_next_o_limit\"", "\"__va_next_fp\"", "\"__va_next_fp_limit\"", "\"__va_next_stack\"" ]

[]

[ "<s>", "void", "ScheduleDAGPostRA", "::", "dumpSchedule", "(", ")", "const", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "MI", "=", "begin", "(", ")", ",", "ME", "=", "end", "(", ")", ";", "MI", "!=", "ME", ";", "++", "MI", ")", "{", "if", "(", "SUnit", "*", "SU", "=", "getSUnit", "(", "&", "(", "*", "MI", ")", ")", ")", "SU", "->", "dump", "(", "this", ")", ";", "else", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "dbgs", "(", ")", "<<", "\"Debug Value\\n\"", ";", "else", "dbgs", "(", ")", "<<", "\"Missing SUnit\\n\"", ";", "}", "}", "</s>" ]

[ "dump", "the", "scheduled", "Sequence", "." ]

[ "Patmos", "\"Debug Value\\n\"", "\"Missing SUnit\\n\"" ]

[]

[ "<s>", "static", "bool", "aarch64_composite_type_p", "(", "const_tree", "type", ",", "machine_mode", "mode", ")", "{", "if", "(", "aarch64_short_vector_p", "(", "type", ",", "mode", ")", ")", "return", "false", ";", "if", "(", "type", "&&", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "||", "TREE_CODE", "(", "type", ")", "==", "COMPLEX_TYPE", ")", ")", "return", "true", ";", "if", "(", "mode", "==", "BLKmode", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_INT", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "the", "type", ",", "as", "described", "by", "TYPE", "and", "MODE", ",", "is", "a", "composite", "type", "as", "described", "in", "AAPCS64", "\\S", "4.3", ".", "This", "includes", "aggregate", ",", "union", "and", "array", "types", ".", "The", "C99", "floating-point", "complex", "types", "are", "also", "considered", "as", "composite", "types", ",", "according", "to", "AAPCS64", "\\S", "7.1.1", ".", "The", "complex", "integer", "types", ",", "which", "are", "GCC", "extensions", "and", "out", "of", "the", "scope", "of", "AAPCS64", ",", "are", "treated", "as", "composite", "types", "here", "as", "well", ".", "Note", "that", "MODE", "itself", "is", "not", "sufficient", "in", "determining", "whether", "a", "type", "is", "such", "a", "composite", "type", "or", "not", ".", "This", "is", "because", "stor-layout.c", ":", "compute_record_mode", "may", "have", "already", "changed", "the", "MODE", "(", "BLKmode", ")", "of", "a", "RECORD_TYPE", "TYPE", "to", "some", "other", "mode", ".", "For", "example", ",", "a", "structure", "with", "only", "one", "field", "may", "have", "its", "MODE", "set", "to", "the", "mode", "of", "the", "field", ".", "Also", "an", "integer", "mode", "whose", "size", "matches", "the", "size", "of", "the", "RECORD_TYPE", "type", "may", "be", "used", "to", "substitute", "the", "original", "mode", "(", "i.e", ".", "BLKmode", ")", "in", "certain", "circumstances", ".", "In", "other", "words", ",", "MODE", "can", "not", "be", "solely", "relied", "on", "." ]

[ "aarch64" ]

[]

[ "<s>", "MCSection", "*", "MipsTargetObjectFile", "::", "getSectionForConstant", "(", "const", "DataLayout", "&", "DL", ",", "SectionKind", "Kind", ",", "const", "Constant", "*", "C", ",", "Align", "&", "Alignment", ")", "const", "{", "if", "(", "IsConstantInSmallSection", "(", "DL", ",", "C", ",", "*", "TM", ")", ")", "return", "SmallDataSection", ";", "return", "TargetLoweringObjectFileELF", "::", "getSectionForConstant", "(", "DL", ",", "Kind", ",", "C", ",", "Alignment", ")", ";", "}", "</s>" ]

[ "Given", "a", "constant", "with", "the", "SectionKind", ",", "return", "a", "section", "that", "it", "should", "be", "placed", "in", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "Sched", "::", "Preference", "ARMTargetLowering", "::", "getSchedulingPreference", "(", "SDNode", "*", "N", ")", "const", "{", "unsigned", "NumVals", "=", "N", "->", "getNumValues", "(", ")", ";", "if", "(", "!", "NumVals", ")", "return", "Sched", "::", "RegPressure", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumVals", ";", "++", "i", ")", "{", "EVT", "VT", "=", "N", "->", "getValueType", "(", "i", ")", ";", "if", "(", "VT", ".", "isFloatingPoint", "(", ")", "||", "VT", ".", "isVector", "(", ")", ")", "return", "Sched", "::", "Latency", ";", "}", "if", "(", "!", "N", "->", "isMachineOpcode", "(", ")", ")", "return", "Sched", "::", "RegPressure", ";", "const", "TargetInstrInfo", "*", "TII", "=", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "TargetInstrDesc", "&", "TID", "=", "TII", "->", "get", "(", "N", "->", "getMachineOpcode", "(", ")", ")", ";", "if", "(", "TID", ".", "mayLoad", "(", ")", ")", "return", "Sched", "::", "Latency", ";", "const", "InstrItineraryData", "&", "Itins", "=", "getTargetMachine", "(", ")", ".", "getInstrItineraryData", "(", ")", ";", "if", "(", "!", "Itins", ".", "isEmpty", "(", ")", "&&", "Itins", ".", "getStageLatency", "(", "TID", ".", "getSchedClass", "(", ")", ")", ">", "2", ")", "return", "Sched", "::", "Latency", ";", "return", "Sched", "::", "RegPressure", ";", "}", "</s>" ]

[ "Some", "scheduler", ",", "e.g", "." ]

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

[]

[ "<s>", "OperandMatchResultTy", "LanaiAsmParser", "::", "tryParseRegister", "(", "unsigned", "&", "RegNum", ",", "SMLoc", "&", "StartLoc", ",", "SMLoc", "&", "EndLoc", ")", "{", "const", "AsmToken", "&", "Tok", "=", "getParser", "(", ")", ".", "getTok", "(", ")", ";", "StartLoc", "=", "Tok", ".", "getLoc", "(", ")", ";", "EndLoc", "=", "Tok", ".", "getEndLoc", "(", ")", ";", "std", "::", "unique_ptr", "<", "LanaiOperand", ">", "Op", "=", "parseRegister", "(", "true", ")", ";", "if", "(", "Op", "==", "nullptr", ")", "return", "MatchOperand_NoMatch", ";", "RegNum", "=", "Op", "->", "getReg", "(", ")", ";", "return", "MatchOperand_Success", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "Lanai" ]

[]

[ "<s>", "static", "int", "s390_sched_score", "(", "rtx_insn", "*", "insn", ")", "{", "unsigned", "int", "mask", "=", "s390_get_sched_attrmask", "(", "insn", ")", ";", "int", "score", "=", "0", ";", "switch", "(", "sched_state", ".", "group_state", ")", "{", "case", "0", ":", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_CRACKED", ")", "!=", "0", "||", "(", "mask", "&", "S390_SCHED_ATTR_MASK_EXPANDED", ")", "!=", "0", ")", "score", "+=", "5", ";", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_GROUPALONE", ")", "!=", "0", ")", "score", "+=", "10", ";", "break", ";", "case", "1", ":", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_CRACKED", ")", "==", "0", "&&", "(", "mask", "&", "S390_SCHED_ATTR_MASK_EXPANDED", ")", "==", "0", "&&", "(", "mask", "&", "S390_SCHED_ATTR_MASK_GROUPALONE", ")", "==", "0", ")", "score", "+=", "10", ";", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_ENDGROUP", ")", "==", "0", ")", "score", "+=", "5", ";", "if", "(", "sched_state", ".", "group_of_two", "&&", "(", "mask", "&", "S390_SCHED_ATTR_MASK_GROUPOFTWO", ")", "!=", "0", ")", "score", "+=", "15", ";", "break", ";", "case", "2", ":", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_CRACKED", ")", "==", "0", "&&", "(", "mask", "&", "S390_SCHED_ATTR_MASK_EXPANDED", ")", "==", "0", "&&", "(", "mask", "&", "S390_SCHED_ATTR_MASK_GROUPALONE", ")", "==", "0", ")", "score", "+=", "10", ";", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_ENDGROUP", ")", "!=", "0", ")", "score", "+=", "10", ";", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_GROUPOFTWO", ")", "!=", "0", ")", "score", "=", "MAX", "(", "0", ",", "score", "-", "15", ")", ";", "break", ";", "}", "if", "(", "s390_tune", ">=", "PROCESSOR_2964_Z13", ")", "{", "int", "units", ",", "i", ";", "unsigned", "unit_mask", ",", "m", "=", "1", ";", "unit_mask", "=", "s390_get_unit_mask", "(", "insn", ",", "&", "units", ")", ";", "gcc_assert", "(", "units", "<=", "MAX_SCHED_UNITS", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "units", ";", "i", "++", ",", "m", "<<=", "1", ")", "if", "(", "m", "&", "unit_mask", ")", "score", "+=", "(", "last_scheduled_unit_distance", "[", "i", "]", "[", "sched_state", ".", "side", "]", "*", "MAX_SCHED_MIX_SCORE", "/", "MAX_SCHED_MIX_DISTANCE", ")", ";", "int", "other_side", "=", "1", "-", "sched_state", ".", "side", ";", "if", "(", "s390_is_longrunning", "(", "insn", ")", ")", "{", "if", "(", "s390_is_fxd", "(", "insn", ")", ")", "{", "if", "(", "fxd_longrunning", "[", "sched_state", ".", "side", "]", "&&", "fxd_longrunning", "[", "other_side", "]", "<=", "fxd_longrunning", "[", "sched_state", ".", "side", "]", ")", "score", "=", "MAX", "(", "0", ",", "score", "-", "10", ")", ";", "else", "if", "(", "fxd_longrunning", "[", "other_side", "]", ">=", "fxd_longrunning", "[", "sched_state", ".", "side", "]", ")", "score", "+=", "10", ";", "}", "if", "(", "s390_is_fpd", "(", "insn", ")", ")", "{", "if", "(", "fpd_longrunning", "[", "sched_state", ".", "side", "]", "&&", "fpd_longrunning", "[", "other_side", "]", "<=", "fpd_longrunning", "[", "sched_state", ".", "side", "]", ")", "score", "=", "MAX", "(", "0", ",", "score", "-", "10", ")", ";", "else", "if", "(", "fpd_longrunning", "[", "other_side", "]", ">=", "fpd_longrunning", "[", "sched_state", ".", "side", "]", ")", "score", "+=", "10", ";", "}", "}", "}", "return", "score", ";", "}", "</s>" ]

[ "Return", "the", "scheduling", "score", "for", "INSN", ".", "The", "higher", "the", "score", "the", "better", ".", "The", "score", "is", "calculated", "from", "the", "OOO", "scheduling", "attributes", "of", "INSN", "and", "the", "scheduling", "state", "s390_sched_state", "." ]

[ "s390", "0", "0", "0", "0", "5", "0", "10", "1", "0", "0", "0", "10", "0", "5", "0", "15", "2", "0", "0", "0", "10", "0", "10", "0", "0", "15", "1", "0", "1", "1", "0", "10", "10", "0", "10", "10" ]

[]

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

[ "Return", "true", "if", "it", "is", "cheap", "to", "speculate", "a", "call", "to", "intrinsic", "cttz", "." ]

[ "AArch64" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"SPIRV Pre-GISel Legalizer\"", ";", "}", "</s>" ]

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

[ "SPIRV", "\"SPIRV Pre-GISel Legalizer\"" ]

[]

[ "<s>", "void", "mmix_expand_epilogue", "(", "void", ")", "{", "HOST_WIDE_INT", "locals_size", "=", "get_frame_size", "(", ")", ";", "int", "regno", ";", "HOST_WIDE_INT", "stack_space_to_deallocate", "=", "(", "crtl", "->", "outgoing_args_size", "+", "crtl", "->", "args", ".", "pretend_args_size", "+", "locals_size", "+", "7", ")", "&", "~", "7", ";", "HOST_WIDE_INT", "offset", "=", "crtl", "->", "outgoing_args_size", ";", "for", "(", "regno", "=", "255", ";", "regno", ">=", "MMIX_FIRST_GLOBAL_REGNUM", ";", "regno", "--", ")", "if", "(", "(", "(", "regno", "!=", "MMIX_FRAME_POINTER_REGNUM", "||", "!", "frame_pointer_needed", ")", "&&", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", "||", "IS_MMIX_EH_RETURN_DATA_REG", "(", "regno", ")", ")", "stack_space_to_deallocate", "+=", "8", ";", "if", "(", "MMIX_CFUN_HAS_LANDING_PAD", ")", "stack_space_to_deallocate", "+=", "16", ";", "else", "if", "(", "MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS", ")", "stack_space_to_deallocate", "+=", "8", ";", "if", "(", "frame_pointer_needed", ")", "stack_space_to_deallocate", "+=", "8", ";", "if", "(", "(", "stack_space_to_deallocate", "%", "8", ")", "!=", "0", ")", "internal_error", "(", "\"stack frame not a multiple of octabyte: %wd\"", ",", "stack_space_to_deallocate", ")", ";", "for", "(", "regno", "=", "MMIX_FIRST_GLOBAL_REGNUM", ";", "regno", "<=", "255", ";", "regno", "++", ")", "if", "(", "(", "(", "regno", "!=", "MMIX_FRAME_POINTER_REGNUM", "||", "!", "frame_pointer_needed", ")", "&&", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", "||", "IS_MMIX_EH_RETURN_DATA_REG", "(", "regno", ")", ")", "{", "if", "(", "offset", ">", "255", ")", "{", "mmix_emit_sp_add", "(", "offset", ")", ";", "stack_space_to_deallocate", "-=", "offset", ";", "offset", "=", "0", ";", "}", "emit_move_insn", "(", "gen_rtx_REG", "(", "DImode", ",", "regno", ")", ",", "gen_rtx_MEM", "(", "DImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ")", ";", "offset", "+=", "8", ";", "}", "offset", "+=", "(", "locals_size", "+", "7", ")", "&", "~", "7", ";", "if", "(", "MMIX_CFUN_HAS_LANDING_PAD", ")", "offset", "+=", "16", ";", "else", "if", "(", "MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS", ")", "offset", "+=", "8", ";", "if", "(", "frame_pointer_needed", ")", "{", "if", "(", "offset", ">", "255", ")", "{", "mmix_emit_sp_add", "(", "offset", ")", ";", "stack_space_to_deallocate", "-=", "offset", ";", "offset", "=", "0", ";", "}", "emit_move_insn", "(", "hard_frame_pointer_rtx", ",", "gen_rtx_MEM", "(", "DImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ")", ";", "offset", "+=", "8", ";", "}", "if", "(", "stack_space_to_deallocate", "!=", "0", ")", "mmix_emit_sp_add", "(", "stack_space_to_deallocate", ")", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "emit_insn", "(", "gen_adddi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "gen_rtx_REG", "(", "DImode", ",", "MMIX_EH_RETURN_STACKADJ_REGNUM", ")", ")", ")", ";", "}", "</s>" ]

[ "Expands", "the", "function", "epilogue", "into", "RTX", "." ]

[ "mmix", "7", "7", "255", "8", "16", "8", "8", "8", "0", "\"stack frame not a multiple of octabyte: %wd\"", "255", "255", "0", "8", "7", "7", "16", "8", "255", "0", "8", "0" ]

[]

[ "<s>", "bool", "PatmosPostRASchedStrategy", "::", "isSchedulingBoundary", "(", "const", "MachineInstr", "*", "MI", ",", "const", "MachineBasicBlock", "*", "MBB", ",", "const", "MachineFunction", "&", "MF", ")", "{", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "return", "false", ";", "if", "(", "MI", "->", "getDesc", "(", ")", ".", "isTerminator", "(", ")", "||", "MI", "->", "isLabel", "(", ")", ")", "return", "true", ";", "if", "(", "MI", "->", "isInlineAsm", "(", ")", ")", "return", "true", ";", "return", "MI", "->", "isBarrier", "(", ")", "||", "MI", "->", "isBranch", "(", ")", "||", "MI", "->", "isCall", "(", ")", "||", "MI", "->", "isReturn", "(", ")", ";", "}", "</s>" ]

[ "isSchedulingBoundary", "-", "Overrides", "the", "isSchedulingBoundary", "from", "Codegen/TargetInstrInfo.cpp", "to", "make", "it", "capable", "of", "identifying", "ENDBR", "intructions", "and", "prevent", "it", "from", "being", "re-scheduled", "." ]

[ "Patmos", "Patmos" ]

[]

[ "<s>", "MachineInstr", "*", "Z80oldInstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "&", "MI", ",", "ArrayRef", "<", "unsigned", ">", "Ops", ",", "MachineBasicBlock", "::", "iterator", "InsertPt", ",", "MachineInstr", "&", "LoadMI", ",", "LiveIntervals", "*", "LIS", ")", "const", "{", "return", "nullptr", ";", "llvm_unreachable", "(", "\"Unimplemented\"", ")", ";", "}", "</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", "." ]

[ "Z80old", "Z80old", "\"Unimplemented\"" ]

[]

[ "<s>", "bool", "AMDGPUSubtarget", "::", "makeLIDRangeMetadata", "(", "Instruction", "*", "I", ")", "const", "{", "Function", "*", "Kernel", "=", "I", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "unsigned", "MinSize", "=", "0", ";", "unsigned", "MaxSize", "=", "getFlatWorkGroupSizes", "(", "*", "Kernel", ")", ".", "second", ";", "bool", "IdQuery", "=", "false", ";", "if", "(", "auto", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "I", ")", ")", "{", "const", "Function", "*", "F", "=", "CI", "->", "getCalledFunction", "(", ")", ";", "if", "(", "F", ")", "{", "unsigned", "Dim", "=", "UINT_MAX", ";", "switch", "(", "F", "->", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "amdgcn_workitem_id_x", ":", "case", "Intrinsic", "::", "r600_read_tidig_x", ":", "IdQuery", "=", "true", ";", "case", "Intrinsic", "::", "r600_read_local_size_x", ":", "Dim", "=", "0", ";", "break", ";", "case", "Intrinsic", "::", "amdgcn_workitem_id_y", ":", "case", "Intrinsic", "::", "r600_read_tidig_y", ":", "IdQuery", "=", "true", ";", "case", "Intrinsic", "::", "r600_read_local_size_y", ":", "Dim", "=", "1", ";", "break", ";", "case", "Intrinsic", "::", "amdgcn_workitem_id_z", ":", "case", "Intrinsic", "::", "r600_read_tidig_z", ":", "IdQuery", "=", "true", ";", "case", "Intrinsic", "::", "r600_read_local_size_z", ":", "Dim", "=", "2", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "Dim", "<=", "3", ")", "{", "if", "(", "auto", "Node", "=", "Kernel", "->", "getMetadata", "(", "\"reqd_work_group_size\"", ")", ")", "if", "(", "Node", "->", "getNumOperands", "(", ")", "==", "3", ")", "MinSize", "=", "MaxSize", "=", "mdconst", "::", "extract", "<", "ConstantInt", ">", "(", "Node", "->", "getOperand", "(", "Dim", ")", ")", "->", "getZExtValue", "(", ")", ";", "}", "}", "}", "if", "(", "!", "MaxSize", ")", "return", "false", ";", "if", "(", "IdQuery", ")", "MinSize", "=", "0", ";", "else", "++", "MaxSize", ";", "MDBuilder", "MDB", "(", "I", "->", "getContext", "(", ")", ")", ";", "MDNode", "*", "MaxWorkGroupSizeRange", "=", "MDB", ".", "createRange", "(", "APInt", "(", "32", ",", "MinSize", ")", ",", "APInt", "(", "32", ",", "MaxSize", ")", ")", ";", "I", "->", "setMetadata", "(", "LLVMContext", "::", "MD_range", ",", "MaxWorkGroupSizeRange", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Creates", "value", "range", "metadata", "on", "an", "workitemid", ".", "*", "intrinsic", "call", "or", "load", "." ]

[ "AMDGPU", "AMDGPU", "0", "Intrinsic::amdgcn_workitem_id_x", "Intrinsic::r600_read_tidig_x", "Intrinsic::r600_read_local_size_x", "0", "Intrinsic::amdgcn_workitem_id_y", "Intrinsic::r600_read_tidig_y", "Intrinsic::r600_read_local_size_y", "1", "Intrinsic::amdgcn_workitem_id_z", "Intrinsic::r600_read_tidig_z", "Intrinsic::r600_read_local_size_z", "2", "3", "\"reqd_work_group_size\"", "3", "0", "32", "32" ]

[]

[ "<s>", "unsigned", "MipsFunctionInfo", "::", "getGlobalBaseReg", "(", ")", "{", "if", "(", "GlobalBaseReg", ")", "return", "GlobalBaseReg", ";", "const", "MipsSubtarget", "&", "ST", "=", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "ST", ".", "isABI_N64", "(", ")", "?", "(", "const", "TargetRegisterClass", "*", ")", "&", "Mips", "::", "CPU64RegsRegClass", ":", "(", "const", "TargetRegisterClass", "*", ")", "&", "Mips", "::", "CPURegsRegClass", ";", "return", "GlobalBaseReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips::CPU64RegsRegClass", "Mips::CPURegsRegClass" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "getGlobalBaseReg", "(", "MachineFunction", "*", "MF", ")", "const", "{", "assert", "(", "!", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", "&&", "\"X86-64 PIC uses RIP relative addressing\"", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", "->", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "GlobalBaseReg", "=", "X86FI", "->", "getGlobalBaseReg", "(", ")", ";", "if", "(", "GlobalBaseReg", "!=", "0", ")", "return", "GlobalBaseReg", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", "->", "getRegInfo", "(", ")", ";", "GlobalBaseReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "X86", "::", "GR32RegisterClass", ")", ";", "X86FI", "->", "setGlobalBaseReg", "(", "GlobalBaseReg", ")", ";", "return", "GlobalBaseReg", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "X86", "X86", "X86", "\"X86-64 PIC uses RIP relative addressing\"", "X86", "X86", "X86", "X86", "0", "X86::GR32RegisterClass", "X86" ]

[]

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

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

[ "GBZ80", "GB" ]

[]

[ "<s>", "void", "override_options", "(", "void", ")", "{", "init_machine_status", "=", "s390_init_machine_status", ";", "if", "(", "!", "(", "target_flags_explicit", "&", "MASK_ZARCH", ")", ")", "{", "if", "(", "TARGET_64BIT", ")", "target_flags", "|=", "MASK_ZARCH", ";", "else", "target_flags", "&=", "~", "MASK_ZARCH", ";", "}", "if", "(", "!", "s390_arch_string", ")", "{", "s390_arch_string", "=", "TARGET_ZARCH", "?", "\"z900\"", ":", "\"g5\"", ";", "s390_handle_arch_option", "(", "s390_arch_string", ",", "&", "s390_arch", ",", "&", "s390_arch_flags", ")", ";", "}", "if", "(", "s390_tune", "==", "PROCESSOR_max", ")", "{", "s390_tune", "=", "s390_arch", ";", "s390_tune_flags", "=", "s390_arch_flags", ";", "}", "if", "(", "TARGET_ZARCH", "&&", "!", "(", "s390_arch_flags", "&", "PF_ZARCH", ")", ")", "error", "(", "\"z/Architecture mode not supported on %s\"", ",", "s390_arch_string", ")", ";", "if", "(", "TARGET_64BIT", "&&", "!", "TARGET_ZARCH", ")", "error", "(", "\"64-bit ABI not supported in ESA/390 mode\"", ")", ";", "if", "(", "s390_tune", "==", "PROCESSOR_2094_Z9_109", ")", "s390_cost", "=", "&", "z9_109_cost", ";", "else", "if", "(", "s390_tune", "==", "PROCESSOR_2084_Z990", ")", "s390_cost", "=", "&", "z990_cost", ";", "else", "s390_cost", "=", "&", "z900_cost", ";", "if", "(", "TARGET_BACKCHAIN", "&&", "TARGET_PACKED_STACK", "&&", "TARGET_HARD_FLOAT", ")", "error", "(", "\"-mbackchain -mpacked-stack -mhard-float are not supported \"", "\"in combination\"", ")", ";", "if", "(", "s390_stack_size", ")", "{", "if", "(", "!", "s390_stack_guard", ")", "error", "(", "\"-mstack-size implies use of -mstack-guard\"", ")", ";", "else", "if", "(", "s390_stack_guard", ">=", "s390_stack_size", ")", "error", "(", "\"stack size must be greater than the stack guard value\"", ")", ";", "else", "if", "(", "s390_stack_size", ">", "1", "<<", "16", ")", "error", "(", "\"stack size must not be greater than 64k\"", ")", ";", "}", "else", "if", "(", "s390_stack_guard", ")", "error", "(", "\"-mstack-guard implies use of -mstack-size\"", ")", ";", "}", "</s>" ]

[ "Set", "global", "variables", "as", "needed", "for", "the", "options", "enabled", "." ]

[ "s390", "\"z900\"", "\"g5\"", "\"z/Architecture mode not supported on %s\"", "\"64-bit ABI not supported in ESA/390 mode\"", "\"-mbackchain -mpacked-stack -mhard-float are not supported \"", "\"in combination\"", "\"-mstack-size implies use of -mstack-guard\"", "\"stack size must be greater than the stack guard value\"", "1", "16", "\"stack size must not be greater than 64k\"", "\"-mstack-guard implies use of -mstack-size\"" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "shouldClusterMemOps", "(", "MachineOperand", "&", "BaseOp1", ",", "MachineOperand", "&", "BaseOp2", ",", "unsigned", "NumLoads", ")", "const", "{", "MachineInstr", "&", "FirstLdSt", "=", "*", "BaseOp1", ".", "getParent", "(", ")", ";", "MachineInstr", "&", "SecondLdSt", "=", "*", "BaseOp2", ".", "getParent", "(", ")", ";", "if", "(", "BaseOp1", ".", "getType", "(", ")", "!=", "BaseOp2", ".", "getType", "(", ")", ")", "return", "false", ";", "assert", "(", "(", "BaseOp1", ".", "isReg", "(", ")", "||", "BaseOp1", ".", "isFI", "(", ")", ")", "&&", "\"Only base registers and frame indices are supported.\"", ")", ";", "if", "(", "BaseOp1", ".", "isReg", "(", ")", "&&", "BaseOp1", ".", "getReg", "(", ")", "!=", "BaseOp2", ".", "getReg", "(", ")", ")", "return", "false", ";", "if", "(", "NumLoads", ">", "1", ")", "return", "false", ";", "if", "(", "!", "isPairableLdStInst", "(", "FirstLdSt", ")", "||", "!", "isPairableLdStInst", "(", "SecondLdSt", ")", ")", "return", "false", ";", "unsigned", "FirstOpc", "=", "FirstLdSt", ".", "getOpcode", "(", ")", ";", "unsigned", "SecondOpc", "=", "SecondLdSt", ".", "getOpcode", "(", ")", ";", "if", "(", "!", "canPairLdStOpc", "(", "FirstOpc", ",", "SecondOpc", ")", ")", "return", "false", ";", "if", "(", "!", "isCandidateToMergeOrPair", "(", "FirstLdSt", ")", "||", "!", "isCandidateToMergeOrPair", "(", "SecondLdSt", ")", ")", "return", "false", ";", "int64_t", "Offset1", "=", "FirstLdSt", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "if", "(", "isUnscaledLdSt", "(", "FirstOpc", ")", "&&", "!", "scaleOffset", "(", "FirstOpc", ",", "Offset1", ")", ")", "return", "false", ";", "int64_t", "Offset2", "=", "SecondLdSt", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "if", "(", "isUnscaledLdSt", "(", "SecondOpc", ")", "&&", "!", "scaleOffset", "(", "SecondOpc", ",", "Offset2", ")", ")", "return", "false", ";", "if", "(", "Offset1", ">", "63", "||", "Offset1", "<", "-", "64", ")", "return", "false", ";", "if", "(", "BaseOp1", ".", "isFI", "(", ")", ")", "{", "assert", "(", "(", "!", "BaseOp1", ".", "isIdenticalTo", "(", "BaseOp2", ")", "||", "Offset1", ">=", "Offset2", ")", "&&", "\"Caller should have ordered offsets.\"", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "FirstLdSt", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getFrameInfo", "(", ")", ";", "return", "shouldClusterFI", "(", "MFI", ",", "BaseOp1", ".", "getIndex", "(", ")", ",", "Offset1", ",", "FirstOpc", ",", "BaseOp2", ".", "getIndex", "(", ")", ",", "Offset2", ",", "SecondOpc", ")", ";", "}", "assert", "(", "(", "!", "BaseOp1", ".", "isIdenticalTo", "(", "BaseOp2", ")", "||", "Offset1", "<=", "Offset2", ")", "&&", "\"Caller should have ordered offsets.\"", ")", ";", "return", "Offset1", "+", "1", "==", "Offset2", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "two", "given", "memory", "operations", "should", "be", "scheduled", "adjacent", "." ]

[ "AArch64", "AArch64", "\"Only base registers and frame indices are supported.\"", "1", "2", "2", "63", "64", "\"Caller should have ordered offsets.\"", "\"Caller should have ordered offsets.\"", "1" ]

[]

[ "<s>", "void", "ARMTargetStreamer", "::", "emitCurrentConstantPool", "(", ")", "{", "ConstantPools", "->", "emitForCurrentSection", "(", "Streamer", ")", ";", "}", "</s>" ]

[ "Callback", "used", "to", "implement", "the", ".ltorg", "directive", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "ARMAsmParser", "::", "ParseInstruction", "(", "const", "StringRef", "&", "Name", ",", "SMLoc", "NameLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ")", "{", "Operands", ".", "push_back", "(", "new", "ARMOperand", "(", "ARMOperand", "::", "CreateToken", "(", "Name", ")", ")", ")", ";", "SMLoc", "Loc", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "ARMOperand", "Op", ";", "if", "(", "ParseOperand", "(", "Op", ")", ")", "return", "true", ";", "Operands", ".", "push_back", "(", "new", "ARMOperand", "(", "Op", ")", ")", ";", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "ParseOperand", "(", "Op", ")", ")", "return", "true", ";", "Operands", ".", "push_back", "(", "new", "ARMOperand", "(", "Op", ")", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

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

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "RISCVInstrInfo", "::", "insertOutlinedCall", "(", "Module", "&", "M", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "It", ",", "MachineFunction", "&", "MF", ",", "const", "outliner", "::", "Candidate", "&", "C", ")", "const", "{", "It", "=", "MBB", ".", "insert", "(", "It", ",", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "RISCV", "::", "PseudoCALLReg", ")", ",", "RISCV", "::", "X5", ")", ".", "addGlobalAddress", "(", "M", ".", "getNamedValue", "(", "MF", ".", "getName", "(", ")", ")", ",", "0", ",", "RISCVII", "::", "MO_CALL", ")", ")", ";", "return", "It", ";", "}", "</s>" ]

[ "Insert", "a", "call", "to", "an", "outlined", "function", "into", "the", "program", "." ]

[ "RISCV", "RISCV", "RISCV::PseudoCALLReg", "RISCV::X5", "0", "RISCVII::MO_CALL" ]

[]

[ "<s>", "static", "void", "pdp11_conditional_register_usage", "(", "void", ")", "{", "int", "i", ";", "HARD_REG_SET", "x", ";", "if", "(", "!", "TARGET_FPU", ")", "{", "COPY_HARD_REG_SET", "(", "x", ",", "reg_class_contents", "[", "(", "int", ")", "FPU_REGS", "]", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "x", ",", "i", ")", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "1", ";", "}", "if", "(", "TARGET_AC0", ")", "call_used_regs", "[", "AC0_REGNUM", "]", "=", "1", ";", "if", "(", "TARGET_UNIX_ASM", ")", "{", "reg_names", "[", "8", "]", "=", "\"fr0\"", ";", "reg_names", "[", "9", "]", "=", "\"fr1\"", ";", "reg_names", "[", "10", "]", "=", "\"fr2\"", ";", "reg_names", "[", "11", "]", "=", "\"fr3\"", ";", "reg_names", "[", "12", "]", "=", "\"fr4\"", ";", "reg_names", "[", "13", "]", "=", "\"fr5\"", ";", "}", "}", "</s>" ]

[ "Make", "sure", "everything", "'s", "fine", "if", "we", "*", "do", "n't", "*", "have", "an", "FPU", ".", "This", "assumes", "that", "putting", "a", "register", "in", "fixed_regs", "will", "keep", "the", "compiler", "'s", "mitts", "completely", "off", "it", ".", "We", "do", "n't", "bother", "to", "zero", "it", "out", "of", "register", "classes", ".", "Also", "fix", "incompatible", "register", "naming", "with", "the", "UNIX", "assembler", "." ]

[ "pdp11", "0", "1", "1", "8", "\"fr0\"", "9", "\"fr1\"", "10", "\"fr2\"", "11", "\"fr3\"", "12", "\"fr4\"", "13", "\"fr5\"" ]

[]

[ "<s>", "int", "aarch_crypto_can_dual_issue", "(", "rtx_insn", "*", "producer_insn", ",", "rtx_insn", "*", "consumer_insn", ")", "{", "rtx", "producer_set", ",", "consumer_set", ";", "rtx", "producer_src", ",", "consumer_src", ";", "producer_set", "=", "single_set", "(", "producer_insn", ")", ";", "consumer_set", "=", "single_set", "(", "consumer_insn", ")", ";", "producer_src", "=", "producer_set", "?", "SET_SRC", "(", "producer_set", ")", ":", "NULL", ";", "consumer_src", "=", "consumer_set", "?", "SET_SRC", "(", "consumer_set", ")", ":", "NULL", ";", "if", "(", "producer_src", "&&", "consumer_src", "&&", "GET_CODE", "(", "producer_src", ")", "==", "UNSPEC", "&&", "GET_CODE", "(", "consumer_src", ")", "==", "UNSPEC", "&&", "(", "(", "XINT", "(", "producer_src", ",", "1", ")", "==", "UNSPEC_AESE", "&&", "XINT", "(", "consumer_src", ",", "1", ")", "==", "UNSPEC_AESMC", ")", "||", "(", "XINT", "(", "producer_src", ",", "1", ")", "==", "UNSPEC_AESD", "&&", "XINT", "(", "consumer_src", ",", "1", ")", "==", "UNSPEC_AESIMC", ")", ")", ")", "{", "unsigned", "int", "regno", "=", "REGNO", "(", "SET_DEST", "(", "producer_set", ")", ")", ";", "return", "(", "REGNO", "(", "SET_DEST", "(", "consumer_set", ")", ")", "==", "regno", "||", "!", "reload_completed", ")", "&&", "REGNO", "(", "XVECEXP", "(", "consumer_src", ",", "0", ",", "0", ")", ")", "==", "regno", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "In", "ARMv8-A", "there", "'s", "a", "general", "expectation", "that", "AESE/AESMC", "and", "AESD/AESIMC", "sequences", "of", "the", "form", ":", "AESE", "Vn", ",", "_", "AESMC", "Vn", ",", "Vn", "will", "issue", "both", "instructions", "in", "a", "single", "cycle", "on", "super-scalar", "implementations", ".", "This", "function", "identifies", "such", "pairs", "." ]

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

[]

[ "<s>", "bool", "ix86_dep_by_shift_count", "(", "const_rtx", "set_insn", ",", "const_rtx", "use_insn", ")", "{", "return", "ix86_dep_by_shift_count_body", "(", "PATTERN", "(", "set_insn", ")", ",", "PATTERN", "(", "use_insn", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "destination", "reg", "of", "SET_INSN", "is", "shift", "count", "of", "USE_INSN", "." ]

[ "i386" ]

[]

[ "<s>", "M68K_CONST_METHOD", "m68k_const_method", "(", "HOST_WIDE_INT", "i", ")", "{", "unsigned", "u", ";", "if", "(", "USE_MOVQ", "(", "i", ")", ")", "return", "MOVQ", ";", "if", "(", "!", "TARGET_COLDFIRE", ")", "{", "if", "(", "USE_MOVQ", "(", "i", "^", "0xff", ")", ")", "return", "NOTB", ";", "if", "(", "USE_MOVQ", "(", "i", "^", "0xffff", ")", ")", "return", "NOTW", ";", "if", "(", "i", "==", "-", "65408", ")", "return", "NEGW", ";", "}", "u", "=", "i", ";", "if", "(", "USE_MOVQ", "(", "(", "u", ">>", "16", ")", "|", "(", "u", "<<", "16", ")", ")", ")", "return", "SWAP", ";", "if", "(", "TARGET_ISAB", ")", "{", "if", "(", "i", ">=", "0", "&&", "i", "<=", "65535", ")", "return", "MVZ", ";", "if", "(", "i", ">=", "-", "32768", "&&", "i", "<=", "32767", ")", "return", "MVS", ";", "}", "return", "MOVL", ";", "}", "</s>" ]

[ "Return", "the", "type", "of", "move", "that", "should", "be", "used", "for", "integer", "I", "." ]

[ "m68k", "0xff", "0xffff", "65408", "16", "16", "0", "65535", "32768", "32767" ]

[]

[ "<s>", "int", "MipsSEFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MipsABIInfo", "ABI", "=", "STI", ".", "getABI", "(", ")", ";", "if", "(", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", ")", "FrameReg", "=", "hasFP", "(", "MF", ")", "?", "ABI", ".", "GetFramePtr", "(", ")", ":", "ABI", ".", "GetStackPtr", "(", ")", ";", "else", "FrameReg", "=", "hasBP", "(", "MF", ")", "?", "ABI", ".", "GetBasePtr", "(", ")", ":", "ABI", ".", "GetStackPtr", "(", ")", ";", "return", "MFI", ".", "getObjectOffset", "(", "FI", ")", "+", "MFI", ".", "getStackSize", "(", ")", "-", "getOffsetOfLocalArea", "(", ")", "+", "MFI", ".", "getOffsetAdjustment", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "HOST_WIDE_INT", "const_vector_elt_as_int", "(", "rtx", "op", ",", "unsigned", "int", "elt", ")", "{", "rtx", "tmp", ";", "gcc_assert", "(", "GET_MODE", "(", "op", ")", "!=", "V2DImode", "&&", "GET_MODE", "(", "op", ")", "!=", "V2DFmode", ")", ";", "tmp", "=", "CONST_VECTOR_ELT", "(", "op", ",", "elt", ")", ";", "if", "(", "GET_MODE", "(", "op", ")", "==", "V4SFmode", "||", "GET_MODE", "(", "op", ")", "==", "V2SFmode", ")", "tmp", "=", "gen_lowpart", "(", "SImode", ",", "tmp", ")", ";", "return", "INTVAL", "(", "tmp", ")", ";", "}", "</s>" ]

[ "Interpret", "element", "ELT", "of", "the", "CONST_VECTOR", "OP", "as", "an", "integer", "value", ".", "If", "the", "mode", "of", "OP", "is", "MODE_VECTOR_INT", ",", "this", "simply", "returns", "the", "corresponding", "element", "of", "the", "vector", ",", "but", "for", "V4SFmode", ",", "the", "corresponding", "``", "float", "''", "is", "interpreted", "as", "an", "SImode", "integer", "." ]

[ "rs6000" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "override", "{", "return", "0", ";", "}", "</s>" ]

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

[ "R600", "0" ]

[]

[ "<s>", "static", "void", "dimode_remove_non_convertible_regs", "(", "bitmap", "candidates", ")", "{", "bitmap_iterator", "bi", ";", "unsigned", "id", ";", "bitmap", "regs", "=", "BITMAP_ALLOC", "(", "NULL", ")", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "candidates", ",", "0", ",", "id", ",", "bi", ")", "{", "rtx", "def_set", "=", "single_set", "(", "DF_INSN_UID_GET", "(", "id", ")", "->", "insn", ")", ";", "rtx", "reg", "=", "SET_DEST", "(", "def_set", ")", ";", "if", "(", "!", "REG_P", "(", "reg", ")", "||", "bitmap_bit_p", "(", "regs", ",", "REGNO", "(", "reg", ")", ")", "||", "HARD_REGISTER_P", "(", "reg", ")", ")", "continue", ";", "for", "(", "df_ref", "def", "=", "DF_REG_DEF_CHAIN", "(", "REGNO", "(", "reg", ")", ")", ";", "def", ";", "def", "=", "DF_REF_NEXT_REG", "(", "def", ")", ")", "{", "if", "(", "!", "bitmap_bit_p", "(", "candidates", ",", "DF_REF_INSN_UID", "(", "def", ")", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"r%d has non convertible definition in insn %d\\n\"", ",", "REGNO", "(", "reg", ")", ",", "DF_REF_INSN_UID", "(", "def", ")", ")", ";", "bitmap_set_bit", "(", "regs", ",", "REGNO", "(", "reg", ")", ")", ";", "break", ";", "}", "}", "}", "EXECUTE_IF_SET_IN_BITMAP", "(", "regs", ",", "0", ",", "id", ",", "bi", ")", "{", "for", "(", "df_ref", "def", "=", "DF_REG_DEF_CHAIN", "(", "id", ")", ";", "def", ";", "def", "=", "DF_REF_NEXT_REG", "(", "def", ")", ")", "if", "(", "bitmap_bit_p", "(", "candidates", ",", "DF_REF_INSN_UID", "(", "def", ")", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Removing insn %d from candidates list\\n\"", ",", "DF_REF_INSN_UID", "(", "def", ")", ")", ";", "bitmap_clear_bit", "(", "candidates", ",", "DF_REF_INSN_UID", "(", "def", ")", ")", ";", "}", "}", "BITMAP_FREE", "(", "regs", ")", ";", "}", "</s>" ]

[ "The", "DImode", "version", "of", "remove_non_convertible_regs", "." ]

[ "i386", "0", "\"r%d has non convertible definition in insn %d\\n\"", "0", "\"Removing insn %d from candidates list\\n\"" ]

[]

[ "<s>", "void", "MipsRegisterBankInfo", "::", "applyMappingImpl", "(", "const", "OperandsMapper", "&", "OpdMapper", ")", "const", "{", "MachineInstr", "&", "MI", "=", "OpdMapper", ".", "getMI", "(", ")", ";", "InstListTy", "NewInstrs", ";", "MachineIRBuilder", "B", "(", "MI", ")", ";", "MachineFunction", "*", "MF", "=", "MI", ".", "getMF", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "OpdMapper", ".", "getMRI", "(", ")", ";", "InstManager", "NewInstrObserver", "(", "NewInstrs", ")", ";", "GISelObserverWrapper", "WrapperObserver", "(", "&", "NewInstrObserver", ")", ";", "LegalizerHelper", "Helper", "(", "*", "MF", ",", "WrapperObserver", ",", "B", ")", ";", "LegalizationArtifactCombiner", "ArtCombiner", "(", "B", ",", "MF", "->", "getRegInfo", "(", ")", ",", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getLegalizerInfo", "(", ")", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "G_LOAD", ":", "case", "TargetOpcode", "::", "G_STORE", ":", "case", "TargetOpcode", "::", "G_PHI", ":", "case", "TargetOpcode", "::", "G_SELECT", ":", "{", "Helper", ".", "narrowScalar", "(", "MI", ",", "0", ",", "LLT", "::", "scalar", "(", "32", ")", ")", ";", "while", "(", "!", "NewInstrs", ".", "empty", "(", ")", ")", "{", "MachineInstr", "*", "NewMI", "=", "NewInstrs", ".", "pop_back_val", "(", ")", ";", "if", "(", "NewMI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_UNMERGE_VALUES", ")", "{", "SmallVector", "<", "MachineInstr", "*", ",", "2", ">", "DeadInstrs", ";", "ArtCombiner", ".", "tryCombineMerges", "(", "*", "NewMI", ",", "DeadInstrs", ")", ";", "for", "(", "MachineInstr", "*", "DeadMI", ":", "DeadInstrs", ")", "DeadMI", "->", "eraseFromParent", "(", ")", ";", "}", "else", "if", "(", "NewMI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_MERGE_VALUES", ")", "continue", ";", "else", "for", "(", "auto", "Op", ":", "NewMI", "->", "operands", "(", ")", ")", "{", "if", "(", "Op", ".", "isReg", "(", ")", ")", "{", "assert", "(", "MRI", ".", "getType", "(", "Op", ".", "getReg", "(", ")", ")", ".", "getSizeInBits", "(", ")", "==", "32", "&&", "\"Only 32 bit gprb is handled here.\\n\"", ")", ";", "MRI", ".", "setRegBank", "(", "Op", ".", "getReg", "(", ")", ",", "getRegBank", "(", "Mips", "::", "GPRBRegBankID", ")", ")", ";", "}", "}", "}", "return", ";", "}", "case", "TargetOpcode", "::", "G_UNMERGE_VALUES", ":", "{", "SmallVector", "<", "MachineInstr", "*", ",", "2", ">", "DeadInstrs", ";", "ArtCombiner", ".", "tryCombineMerges", "(", "MI", ",", "DeadInstrs", ")", ";", "for", "(", "MachineInstr", "*", "DeadMI", ":", "DeadInstrs", ")", "DeadMI", "->", "eraseFromParent", "(", ")", ";", "return", ";", "}", "default", ":", "break", ";", "}", "return", "applyDefaultMapping", "(", "OpdMapper", ")", ";", "}", "</s>" ]

[ "See", "RegisterBankInfo", ":", ":applyMapping", "." ]

[ "Mips", "Mips", "0", "32", "2", "32", "\"Only 32 bit gprb is handled here.\\n\"", "Mips::GPRBRegBankID", "2" ]

[]

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

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

[ "Lanai", "Lanai" ]

[]

[ "<s>", "static", "int", "m68k_return_pops_args", "(", "tree", "fundecl", ",", "tree", "funtype", ",", "int", "size", ")", "{", "return", "(", "(", "TARGET_RTD", "&&", "(", "!", "fundecl", "||", "TREE_CODE", "(", "fundecl", ")", "!=", "IDENTIFIER_NODE", ")", "&&", "(", "!", "stdarg_p", "(", "funtype", ")", ")", ")", "?", "size", ":", "0", ")", ";", "}", "</s>" ]

[ "On", "the", "68000", ",", "the", "RTS", "insn", "can", "not", "pop", "anything", ".", "On", "the", "68010", ",", "the", "RTD", "insn", "may", "be", "used", "to", "pop", "them", "if", "the", "number", "of", "args", "is", "fixed", ",", "but", "if", "the", "number", "is", "variable", "then", "the", "caller", "must", "pop", "them", "all", ".", "RTD", "ca", "n't", "be", "used", "for", "library", "calls", "now", "because", "the", "library", "is", "compiled", "with", "the", "Unix", "compiler", ".", "Use", "of", "RTD", "is", "a", "selectable", "option", ",", "since", "it", "is", "incompatible", "with", "standard", "Unix", "calling", "sequences", ".", "If", "the", "option", "is", "not", "selected", ",", "the", "caller", "must", "always", "pop", "the", "args", "." ]

[ "m68k", "0" ]

[]

[ "<s>", "bool", "TOYPassConfig", "::", "addPreISel", "(", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

[ "TOY", "TOY" ]

[]

[ "<s>", "ARMBaseTargetMachine", "::", "ARMBaseTargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "Options", ")", ",", "JITInfo", "(", ")", ",", "InstrItins", "(", "Subtarget", ".", "getInstrItineraryData", "(", ")", ")", "{", "if", "(", "Options", ".", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "this", "->", "Options", ".", "FloatABIType", "=", "Subtarget", ".", "isTargetHardFloat", "(", ")", "?", "FloatABI", "::", "Hard", ":", "FloatABI", "::", "Soft", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Merge internal globals\"", ";", "}", "</s>" ]

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

[ "ARM", "\"Merge internal globals\"" ]

[]

[ "<s>", "unsigned", "HexagonInstrInfo", "::", "getSize", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "isDebugInstr", "(", ")", "||", "MI", ".", "isPosition", "(", ")", ")", "return", "0", ";", "unsigned", "Size", "=", "MI", ".", "getDesc", "(", ")", ".", "getSize", "(", ")", ";", "if", "(", "!", "Size", ")", "Size", "=", "HEXAGON_INSTR_SIZE", ";", "if", "(", "isConstExtended", "(", "MI", ")", "||", "isExtended", "(", "MI", ")", ")", "Size", "+=", "HEXAGON_INSTR_SIZE", ";", "if", "(", "BranchRelaxAsmLarge", "&&", "MI", ".", "getOpcode", "(", ")", "==", "Hexagon", "::", "INLINEASM", ")", "{", "const", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MCAsmInfo", "*", "MAI", "=", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ";", "unsigned", "NumDefs", "=", "0", ";", "for", "(", ";", "MI", ".", "getOperand", "(", "NumDefs", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "NumDefs", ")", ".", "isDef", "(", ")", ";", "++", "NumDefs", ")", "assert", "(", "NumDefs", "!=", "MI", ".", "getNumOperands", "(", ")", "-", "2", "&&", "\"No asm string?\"", ")", ";", "assert", "(", "MI", ".", "getOperand", "(", "NumDefs", ")", ".", "isSymbol", "(", ")", "&&", "\"No asm string?\"", ")", ";", "const", "char", "*", "AsmStr", "=", "MI", ".", "getOperand", "(", "NumDefs", ")", ".", "getSymbolName", "(", ")", ";", "Size", "=", "getInlineAsmLength", "(", "AsmStr", ",", "*", "MAI", ")", ";", "}", "return", "Size", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "bytes", "in", "the", "encoding", "of", "this", "instruction", ",", "or", "zero", "if", "the", "encoding", "size", "can", "not", "be", "known", "from", "the", "opcode", "." ]

[ "Hexagon", "Hexagon", "0", "Hexagon::INLINEASM", "0", "2", "\"No asm string?\"", "\"No asm string?\"" ]

[]

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

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

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

[]

[ "<s>", "void", "mn10300_gen_multiple_store", "(", "int", "mask", ")", "{", "if", "(", "mask", "!=", "0", ")", "{", "int", "i", ";", "int", "count", ";", "rtx", "par", ";", "int", "pari", ";", "count", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<=", "LAST_EXTENDED_REGNUM", ";", "i", "++", ")", "if", "(", "(", "mask", "&", "(", "1", "<<", "i", ")", ")", "!=", "0", ")", "count", "+=", "1", ";", "par", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "count", "+", "1", ")", ")", ";", "XVECEXP", "(", "par", ",", "0", ",", "0", ")", "=", "gen_rtx_SET", "(", "SImode", ",", "stack_pointer_rtx", ",", "gen_rtx_PLUS", "(", "SImode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "count", "*", "4", ")", ")", ")", ";", "pari", "=", "1", ";", "for", "(", "i", "=", "LAST_EXTENDED_REGNUM", ";", "i", ">=", "0", ";", "i", "--", ")", "if", "(", "(", "mask", "&", "(", "1", "<<", "i", ")", ")", "!=", "0", ")", "{", "rtx", "address", "=", "gen_rtx_PLUS", "(", "SImode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "pari", "*", "4", ")", ")", ";", "XVECEXP", "(", "par", ",", "0", ",", "pari", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_rtx_MEM", "(", "SImode", ",", "address", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "i", ")", ")", ";", "pari", "+=", "1", ";", "}", "par", "=", "emit_insn", "(", "par", ")", ";", "RTX_FRAME_RELATED_P", "(", "par", ")", "=", "1", ";", "}", "}", "</s>" ]

[ "Generate", "an", "instruction", "that", "pushes", "several", "registers", "onto", "the", "stack", ".", "Register", "K", "will", "be", "saved", "if", "bit", "K", "in", "MASK", "is", "set", ".", "The", "function", "does", "nothing", "if", "MASK", "is", "zero", ".", "To", "be", "compatible", "with", "the", "``", "movm", "''", "instruction", ",", "the", "lowest-numbered", "register", "must", "be", "stored", "in", "the", "lowest", "slot", ".", "If", "MASK", "is", "the", "set", "{", "R1", ",", "...", ",", "RN", "}", ",", "where", "R1", "...", "RN", "are", "ordered", "least", "first", ",", "the", "generated", "instruction", "will", "have", "the", "form", ":", "(", "parallel", "(", "set", "(", "reg", ":", "SI", "9", ")", "(", "plus", ":", "SI", "(", "reg", ":", "SI", "9", ")", "(", "const_int", "-N", "*", "4", ")", ")", ")", "(", "set", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "reg", ":", "SI", "9", ")", "(", "const_int", "-1", "*", "4", ")", ")", ")", "(", "reg", ":", "SI", "RN", ")", ")", "...", "(", "set", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "reg", ":", "SI", "9", ")", "(", "const_int", "-N", "*", "4", ")", ")", ")", "(", "reg", ":", "SI", "R1", ")", ")", ")" ]

[ "mn10300", "0", "0", "0", "1", "0", "1", "1", "0", "0", "4", "1", "0", "1", "0", "4", "0", "1", "1" ]

[]