Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "int", "legitimate_constant_p", "(", "rtx", "op", ")", "{", "if", "(", "!", "SYMBOLIC_CONST", "(", "op", ")", ")", "return", "1", ";", "if", "(", "TARGET_CPU_ZARCH", "&&", "larl_operand", "(", "op", ",", "VOIDmode", ")", ")", "return", "1", ";", "if", "(", "TLS_SYMBOLIC_CONST", "(", "op", ")", ")", "return", "0", ";", "if", "(", "flag_pic", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Nonzero", "if", "the", "constant", "value", "X", "is", "a", "legitimate", "general", "operand", ".", "It", "is", "given", "that", "X", "satisfies", "CONSTANT_P", "or", "is", "a", "CONST_DOUBLE", "." ]

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

[]

[ "<s>", "MCFragment", "*", "findAssociatedFragment", "(", ")", "const", "override", "{", "return", "getSubExpr", "(", ")", "->", "findAssociatedFragment", "(", ")", ";", "}", "</s>" ]

[ "Find", "the", "``", "associated", "section", "''", "for", "this", "expression", ",", "which", "is", "currently", "defined", "as", "the", "absolute", "section", "for", "constants", ",", "or", "otherwise", "the", "section", "associated", "with", "the", "first", "defined", "symbol", "in", "the", "expression", "." ]

[ "RISCV" ]

[]

[ "<s>", "static", "bool", "s390_match_ccmode_set", "(", "rtx", "set", ",", "machine_mode", "req_mode", ")", "{", "machine_mode", "set_mode", ";", "gcc_assert", "(", "GET_CODE", "(", "set", ")", "==", "SET", ")", ";", "gcc_assert", "(", "req_mode", "!=", "CCVIALLmode", "&&", "req_mode", "!=", "CCVIANYmode", "&&", "req_mode", "!=", "CCVFALLmode", "&&", "req_mode", "!=", "CCVFANYmode", ")", ";", "if", "(", "GET_CODE", "(", "SET_DEST", "(", "set", ")", ")", "!=", "REG", "||", "!", "CC_REGNO_P", "(", "REGNO", "(", "SET_DEST", "(", "set", ")", ")", ")", ")", "return", "1", ";", "set_mode", "=", "GET_MODE", "(", "SET_DEST", "(", "set", ")", ")", ";", "switch", "(", "set_mode", ")", "{", "case", "E_CCZ1mode", ":", "case", "E_CCSmode", ":", "case", "E_CCSRmode", ":", "case", "E_CCSFPSmode", ":", "case", "E_CCUmode", ":", "case", "E_CCURmode", ":", "case", "E_CCOmode", ":", "case", "E_CCLmode", ":", "case", "E_CCL1mode", ":", "case", "E_CCL2mode", ":", "case", "E_CCL3mode", ":", "case", "E_CCT1mode", ":", "case", "E_CCT2mode", ":", "case", "E_CCT3mode", ":", "case", "E_CCVEQmode", ":", "case", "E_CCVIHmode", ":", "case", "E_CCVIHUmode", ":", "case", "E_CCVFHmode", ":", "case", "E_CCVFHEmode", ":", "if", "(", "req_mode", "!=", "set_mode", ")", "return", "0", ";", "break", ";", "case", "E_CCZmode", ":", "if", "(", "req_mode", "!=", "CCSmode", "&&", "req_mode", "!=", "CCUmode", "&&", "req_mode", "!=", "CCTmode", "&&", "req_mode", "!=", "CCSRmode", "&&", "req_mode", "!=", "CCURmode", "&&", "req_mode", "!=", "CCZ1mode", ")", "return", "0", ";", "break", ";", "case", "E_CCAPmode", ":", "case", "E_CCANmode", ":", "if", "(", "req_mode", "!=", "CCAmode", ")", "return", "0", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "(", "GET_MODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "set_mode", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "SET", "either", "does", "n't", "set", "the", "CC", "register", ",", "or", "else", "the", "source", "and", "destination", "have", "matching", "CC", "modes", "and", "that", "CC", "mode", "is", "at", "least", "as", "constrained", "as", "REQ_MODE", "." ]

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

[]

[ "<s>", "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "LC3" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "TriCore", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_leg_mov_hi16_pcrel\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_leg_mov_lo16_pcrel\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "{", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "}", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "TriCore", "TriCore::NumTargetFixupKinds", "\"fixup_leg_mov_hi16_pcrel\"", "0", "32", "\"fixup_leg_mov_lo16_pcrel\"", "0", "32", "\"Invalid kind!\"" ]

[]

[ "<s>", "static", "MachineInstr", "*", "getDef", "(", "unsigned", "Reg", ",", "const", "MachineRegisterInfo", "*", "MRI", ")", "{", "if", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "Reg", ")", ")", "return", "0", ";", "return", "MRI", "->", "getUniqueVRegDef", "(", "Reg", ")", ";", "}", "</s>" ]

[ "Get", "the", "concrete", "record", "with", "the", "specified", "name", "." ]

[ "SystemZ", "0" ]

[]

[ "<s>", "const", "char", "*", "AMDGPUTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "NODE_NAME_CASE", "(", "CALL", ")", ";", "NODE_NAME_CASE", "(", "UMUL", ")", ";", "NODE_NAME_CASE", "(", "DIV_INF", ")", ";", "NODE_NAME_CASE", "(", "RET_FLAG", ")", ";", "NODE_NAME_CASE", "(", "BRANCH_COND", ")", ";", "NODE_NAME_CASE", "(", "DWORDADDR", ")", "NODE_NAME_CASE", "(", "FRACT", ")", "NODE_NAME_CASE", "(", "FMAX", ")", "NODE_NAME_CASE", "(", "SMAX", ")", "NODE_NAME_CASE", "(", "UMAX", ")", "NODE_NAME_CASE", "(", "FMIN", ")", "NODE_NAME_CASE", "(", "SMIN", ")", "NODE_NAME_CASE", "(", "UMIN", ")", "NODE_NAME_CASE", "(", "URECIP", ")", "NODE_NAME_CASE", "(", "DOT4", ")", "NODE_NAME_CASE", "(", "EXPORT", ")", "NODE_NAME_CASE", "(", "CONST_ADDRESS", ")", "NODE_NAME_CASE", "(", "REGISTER_LOAD", ")", "NODE_NAME_CASE", "(", "REGISTER_STORE", ")", "NODE_NAME_CASE", "(", "LOAD_CONSTANT", ")", "NODE_NAME_CASE", "(", "LOAD_INPUT", ")", "NODE_NAME_CASE", "(", "SAMPLE", ")", "NODE_NAME_CASE", "(", "SAMPLEB", ")", "NODE_NAME_CASE", "(", "SAMPLED", ")", "NODE_NAME_CASE", "(", "SAMPLEL", ")", "NODE_NAME_CASE", "(", "STORE_MSKOR", ")", "NODE_NAME_CASE", "(", "TBUFFER_STORE_FORMAT", ")", "}", "}", "</s>" ]

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

[ "R600", "0" ]

[]

[ "<s>", "void", "apply", "(", "ScheduleDAGInstrs", "*", "DAG", ")", "override", "{", "SUnit", "*", "SUa", "=", "nullptr", ";", "for", "(", "SUnit", "&", "SU", ":", "DAG", "->", "SUnits", ")", "{", "MachineInstr", "&", "MI2", "=", "*", "SU", ".", "getInstr", "(", ")", ";", "if", "(", "!", "MI2", ".", "mayLoad", "(", ")", "&&", "!", "MI2", ".", "mayStore", "(", ")", ")", "{", "SUa", "=", "nullptr", ";", "continue", ";", "}", "if", "(", "!", "SUa", ")", "{", "SUa", "=", "&", "SU", ";", "continue", ";", "}", "MachineInstr", "&", "MI1", "=", "*", "SUa", "->", "getInstr", "(", ")", ";", "if", "(", "(", "TII", "->", "isVMEM", "(", "MI1", ")", "&&", "TII", "->", "isVMEM", "(", "MI2", ")", ")", "||", "(", "TII", "->", "isFLAT", "(", "MI1", ")", "&&", "TII", "->", "isFLAT", "(", "MI2", ")", ")", "||", "(", "TII", "->", "isSMRD", "(", "MI1", ")", "&&", "TII", "->", "isSMRD", "(", "MI2", ")", ")", "||", "(", "TII", "->", "isDS", "(", "MI1", ")", "&&", "TII", "->", "isDS", "(", "MI2", ")", ")", ")", "{", "SU", ".", "addPredBarrier", "(", "SUa", ")", ";", "for", "(", "const", "SDep", "&", "SI", ":", "SU", ".", "Preds", ")", "{", "if", "(", "SI", ".", "getSUnit", "(", ")", "!=", "SUa", ")", "SUa", "->", "addPred", "(", "SDep", "(", "SI", ".", "getSUnit", "(", ")", ",", "SDep", "::", "Artificial", ")", ")", ";", "}", "if", "(", "&", "SU", "!=", "&", "DAG", "->", "ExitSU", ")", "{", "for", "(", "const", "SDep", "&", "SI", ":", "SUa", "->", "Succs", ")", "{", "if", "(", "SI", ".", "getSUnit", "(", ")", "!=", "&", "SU", ")", "SI", ".", "getSUnit", "(", ")", "->", "addPred", "(", "SDep", "(", "&", "SU", ",", "SDep", "::", "Artificial", ")", ")", ";", "}", "}", "}", "SUa", "=", "&", "SU", ";", "}", "}", "</s>" ]

[ "Apply", "the", "profile", "inference", "algorithm", "for", "a", "given", "function", "." ]

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

[]

[ "<s>", "void", "Warning", "(", "SMLoc", "L", ",", "const", "Twine", "&", "Msg", ")", "{", "Parser", ".", "Warning", "(", "L", ",", "Msg", ")", ";", "}", "</s>" ]

[ "Emit", "a", "warning", "at", "the", "location", "L", ",", "with", "the", "message", "Msg", "." ]

[ "ARM64" ]

[]

[ "<s>", "unsigned", "long", "arm_current_func_type", "(", "void", ")", "{", "if", "(", "ARM_FUNC_TYPE", "(", "cfun", "->", "machine", "->", "func_type", ")", "==", "ARM_FT_UNKNOWN", ")", "cfun", "->", "machine", "->", "func_type", "=", "arm_compute_func_type", "(", ")", ";", "return", "cfun", "->", "machine", "->", "func_type", ";", "}", "</s>" ]

[ "Returns", "the", "type", "of", "the", "current", "function", "." ]

[ "arm" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "const", "PPCSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "!", "STI", ".", "hasVSX", "(", ")", ")", "return", "false", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ";", "I", "!=", "MF", ".", "end", "(", ")", ";", ")", "{", "MachineBasicBlock", "&", "B", "=", "*", "I", "++", ";", "if", "(", "processBlock", "(", "B", ")", ")", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "pa_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "chain_value", ")", "{", "rtx", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "rtx", "start_addr", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "rtx", "end_addr", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "rtx", "line_length", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "rtx", "r_tramp", ",", "tmp", ";", "emit_block_move", "(", "m_tramp", ",", "assemble_trampoline_template", "(", ")", ",", "GEN_INT", "(", "TRAMPOLINE_SIZE", ")", ",", "BLOCK_OP_NORMAL", ")", ";", "r_tramp", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "m_tramp", ",", "0", ")", ")", ";", "if", "(", "!", "TARGET_64BIT", ")", "{", "tmp", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "36", ")", ";", "emit_move_insn", "(", "tmp", ",", "fnaddr", ")", ";", "tmp", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "40", ")", ";", "emit_move_insn", "(", "tmp", ",", "chain_value", ")", ";", "tmp", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "44", ")", ";", "emit_move_insn", "(", "tmp", ",", "r_tramp", ")", ";", "tmp", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "48", ")", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_REG", "(", "Pmode", ",", "19", ")", ")", ";", "emit_insn", "(", "gen_andsi3", "(", "start_addr", ",", "r_tramp", ",", "GEN_INT", "(", "-", "MIN_CACHELINE_SIZE", ")", ")", ")", ";", "tmp", "=", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "r_tramp", ",", "TRAMPOLINE_CODE_SIZE", "-", "1", ")", ")", ";", "emit_insn", "(", "gen_andsi3", "(", "end_addr", ",", "tmp", ",", "GEN_INT", "(", "-", "MIN_CACHELINE_SIZE", ")", ")", ")", ";", "emit_move_insn", "(", "line_length", ",", "GEN_INT", "(", "MIN_CACHELINE_SIZE", ")", ")", ";", "emit_insn", "(", "gen_dcacheflushsi", "(", "start_addr", ",", "end_addr", ",", "line_length", ")", ")", ";", "emit_insn", "(", "gen_icacheflushsi", "(", "start_addr", ",", "end_addr", ",", "line_length", ",", "gen_reg_rtx", "(", "Pmode", ")", ",", "gen_reg_rtx", "(", "Pmode", ")", ")", ")", ";", "}", "else", "{", "tmp", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "56", ")", ";", "emit_move_insn", "(", "tmp", ",", "fnaddr", ")", ";", "tmp", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "64", ")", ";", "emit_move_insn", "(", "tmp", ",", "chain_value", ")", ";", "tmp", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "16", ")", ";", "emit_move_insn", "(", "tmp", ",", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "r_tramp", ",", "32", ")", ")", ")", ";", "tmp", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "24", ")", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_REG", "(", "Pmode", ",", "27", ")", ")", ";", "tmp", "=", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "r_tramp", ",", "32", ")", ")", ";", "emit_insn", "(", "gen_anddi3", "(", "start_addr", ",", "tmp", ",", "GEN_INT", "(", "-", "MIN_CACHELINE_SIZE", ")", ")", ")", ";", "tmp", "=", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "tmp", ",", "TRAMPOLINE_CODE_SIZE", "-", "1", ")", ")", ";", "emit_insn", "(", "gen_anddi3", "(", "end_addr", ",", "tmp", ",", "GEN_INT", "(", "-", "MIN_CACHELINE_SIZE", ")", ")", ")", ";", "emit_move_insn", "(", "line_length", ",", "GEN_INT", "(", "MIN_CACHELINE_SIZE", ")", ")", ";", "emit_insn", "(", "gen_dcacheflushdi", "(", "start_addr", ",", "end_addr", ",", "line_length", ")", ")", ";", "emit_insn", "(", "gen_icacheflushdi", "(", "start_addr", ",", "end_addr", ",", "line_length", ",", "gen_reg_rtx", "(", "Pmode", ")", ",", "gen_reg_rtx", "(", "Pmode", ")", ")", ")", ";", "}", "</s>" ]

[ "Emit", "RTL", "insns", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", ".", "FNADDR", "is", "an", "RTX", "for", "the", "address", "of", "the", "function", "'s", "pure", "code", ".", "CXT", "is", "an", "RTX", "for", "the", "static", "chain", "value", "for", "the", "function", ".", "Move", "the", "function", "address", "to", "the", "trampoline", "template", "at", "offset", "36", ".", "Move", "the", "static", "chain", "value", "to", "trampoline", "template", "at", "offset", "40", ".", "Move", "the", "trampoline", "address", "to", "trampoline", "template", "at", "offset", "44", ".", "Move", "r19", "to", "trampoline", "template", "at", "offset", "48", ".", "The", "latter", "two", "words", "create", "a", "plabel", "for", "the", "indirect", "call", "to", "the", "trampoline", ".", "A", "similar", "sequence", "is", "used", "for", "the", "64-bit", "port", "but", "the", "plabel", "is", "at", "the", "beginning", "of", "the", "trampoline", ".", "Finally", ",", "the", "cache", "entries", "for", "the", "trampoline", "code", "are", "flushed", ".", "This", "is", "necessary", "to", "ensure", "that", "the", "trampoline", "instruction", "sequence", "is", "written", "to", "memory", "prior", "to", "any", "attempts", "at", "prefetching", "the", "code", "sequence", "." ]

[ "pa", "0", "0", "36", "40", "44", "48", "19", "1", "56", "64", "16", "32", "24", "27", "32", "1" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "breakPartialRegDependency", "(", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "OpNum", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", ";", "if", "(", "MI", "->", "killsRegister", "(", "Reg", ",", "TRI", ")", ")", "return", ";", "if", "(", "X86", "::", "VR128RegClass", ".", "contains", "(", "Reg", ")", ")", "{", "unsigned", "Opc", "=", "Subtarget", ".", "hasAVX", "(", ")", "?", "X86", "::", "VXORPSrr", ":", "X86", "::", "XORPSrr", ";", "BuildMI", "(", "*", "MI", "->", "getParent", "(", ")", ",", "MI", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ",", "Reg", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Undef", ")", ";", "MI", "->", "addRegisterKilled", "(", "Reg", ",", "TRI", ",", "true", ")", ";", "}", "else", "if", "(", "X86", "::", "VR256RegClass", ".", "contains", "(", "Reg", ")", ")", "{", "unsigned", "XReg", "=", "TRI", "->", "getSubReg", "(", "Reg", ",", "X86", "::", "sub_xmm", ")", ";", "BuildMI", "(", "*", "MI", "->", "getParent", "(", ")", ",", "MI", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "X86", "::", "VXORPSrr", ")", ",", "XReg", ")", ".", "addReg", "(", "XReg", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "XReg", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "MI", "->", "addRegisterKilled", "(", "Reg", ",", "TRI", ",", "true", ")", ";", "}", "}", "</s>" ]

[ "Insert", "a", "dependency-breaking", "instruction", "before", "MI", "to", "eliminate", "an", "unwanted", "dependency", "on", "OpNum", "." ]

[ "X86", "X86", "X86::VR128RegClass", "X86::VXORPSrr", "X86::XORPSrr", "X86::VR256RegClass", "X86::sub_xmm", "X86::VXORPSrr" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "WebAssemblyTargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "AI", ")", "const", "{", "switch", "(", "AI", "->", "getOperation", "(", ")", ")", "{", "case", "AtomicRMWInst", "::", "Add", ":", "case", "AtomicRMWInst", "::", "Sub", ":", "case", "AtomicRMWInst", "::", "And", ":", "case", "AtomicRMWInst", "::", "Or", ":", "case", "AtomicRMWInst", "::", "Xor", ":", "case", "AtomicRMWInst", "::", "Xchg", ":", "return", "AtomicExpansionKind", "::", "None", ";", "default", ":", "break", ";", "}", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "}", "</s>" ]

[ "Returns", "how", "the", "IR-level", "AtomicExpand", "pass", "should", "expand", "the", "given", "AtomicRMW", ",", "if", "at", "all", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "int", "X86FrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "bool", "IsFixed", "=", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", ";", "if", "(", "TRI", "->", "hasBasePointer", "(", "MF", ")", ")", "FrameReg", "=", "IsFixed", "?", "TRI", "->", "getFramePtr", "(", ")", ":", "TRI", "->", "getBaseRegister", "(", ")", ";", "else", "if", "(", "TRI", "->", "needsStackRealignment", "(", "MF", ")", ")", "FrameReg", "=", "IsFixed", "?", "TRI", "->", "getFramePtr", "(", ")", ":", "TRI", "->", "getStackRegister", "(", ")", ";", "else", "FrameReg", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", "-", "getOffsetOfLocalArea", "(", ")", ";", "const", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "CSSize", "=", "X86FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "bool", "IsWin64Prologue", "=", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", "->", "usesWindowsCFI", "(", ")", ";", "int64_t", "FPDelta", "=", "0", ";", "if", "(", "IsWin64Prologue", ")", "{", "assert", "(", "!", "MFI", ".", "hasCalls", "(", ")", "||", "(", "StackSize", "%", "16", ")", "==", "8", ")", ";", "uint64_t", "FrameSize", "=", "StackSize", "-", "SlotSize", ";", "if", "(", "X86FI", "->", "getRestoreBasePointer", "(", ")", ")", "FrameSize", "+=", "SlotSize", ";", "uint64_t", "NumBytes", "=", "FrameSize", "-", "CSSize", ";", "uint64_t", "SEHFrameOffset", "=", "calculateSetFPREG", "(", "NumBytes", ")", ";", "if", "(", "FI", "&&", "FI", "==", "X86FI", "->", "getFAIndex", "(", ")", ")", "return", "-", "SEHFrameOffset", ";", "FPDelta", "=", "FrameSize", "-", "SEHFrameOffset", ";", "assert", "(", "(", "!", "MFI", ".", "hasCalls", "(", ")", "||", "(", "FPDelta", "%", "16", ")", "==", "0", ")", "&&", "\"FPDelta isn't aligned per the Win64 ABI!\"", ")", ";", "}", "if", "(", "TRI", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "assert", "(", "HasFP", "&&", "\"VLAs and dynamic stack realign, but no FP?!\"", ")", ";", "if", "(", "FI", "<", "0", ")", "{", "return", "Offset", "+", "SlotSize", "+", "FPDelta", ";", "}", "else", "{", "assert", "(", "(", "-", "(", "Offset", "+", "StackSize", ")", ")", "%", "MFI", ".", "getObjectAlignment", "(", "FI", ")", "==", "0", ")", ";", "return", "Offset", "+", "StackSize", ";", "}", "}", "else", "if", "(", "TRI", "->", "needsStackRealignment", "(", "MF", ")", ")", "{", "if", "(", "FI", "<", "0", ")", "{", "return", "Offset", "+", "SlotSize", "+", "FPDelta", ";", "}", "else", "{", "assert", "(", "(", "-", "(", "Offset", "+", "StackSize", ")", ")", "%", "MFI", ".", "getObjectAlignment", "(", "FI", ")", "==", "0", ")", ";", "return", "Offset", "+", "StackSize", ";", "}", "}", "else", "{", "if", "(", "!", "HasFP", ")", "return", "Offset", "+", "StackSize", ";", "Offset", "+=", "SlotSize", ";", "int", "TailCallReturnAddrDelta", "=", "X86FI", "->", "getTCReturnAddrDelta", "(", ")", ";", "if", "(", "TailCallReturnAddrDelta", "<", "0", ")", "Offset", "-=", "TailCallReturnAddrDelta", ";", "}", "return", "Offset", "+", "FPDelta", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "X86", "0", "16", "8", "X86", "X86", "16", "0", "\"FPDelta isn't aligned per the Win64 ABI!\"", "\"VLAs and dynamic stack realign, but no FP?!\"", "0", "0", "0", "0", "X86", "0" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "csky_constant_alignment", "(", "const_tree", "exp", ",", "HOST_WIDE_INT", "align", ")", "{", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "STRING_CST", "&&", "!", "optimize_size", "&&", "align", "<", "BITS_PER_WORD", ")", "return", "BITS_PER_WORD", ";", "return", "align", ";", "}", "</s>" ]

[ "Implement", "TARGET_CONSTANT_ALIGNMENT", ".", "Make", "strings", "word-aligned", "so", "strcpy", "from", "constants", "will", "be", "faster", "." ]

[ "csky" ]

[]

[ "<s>", "void", "M88kIncomingValueHandler", "::", "assignValueToAddress", "(", "Register", "ValVReg", ",", "Register", "Addr", ",", "LLT", "MemTy", ",", "MachinePointerInfo", "&", "MPO", ",", "CCValAssign", "&", "VA", ")", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "auto", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MPO", ",", "MachineMemOperand", "::", "MOLoad", ",", "MemTy", ",", "inferAlignFromPtrInfo", "(", "MF", ",", "MPO", ")", ")", ";", "MIRBuilder", ".", "buildLoad", "(", "ValVReg", ",", "Addr", ",", "*", "MMO", ")", ";", "}", "</s>" ]

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

[ "M88k", "M88k" ]

[]

[ "<s>", "bool", "NyuziAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "AsmVariant", ",", "ExtraCode", ",", "O", ")", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "getType", "(", ")", "==", "MachineOperand", "::", "MO_Register", ")", "{", "O", "<<", "NyuziInstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", ";", "return", "false", ";", "}", "else", "if", "(", "MO", ".", "getType", "(", ")", "==", "MachineOperand", "::", "MO_Immediate", ")", "{", "O", "<<", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Nyuzi", "Nyuzi", "0", "Nyuzi" ]

[]

[ "<s>", "int", "TPCFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "const", "TPCTargetLowering", "&", "TL", "=", "*", "MF", ".", "getSubtarget", "<", "TPCSubtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", ";", "FrameReg", "=", "TL", ".", "getZeroReg", "(", ")", ";", "if", "(", "static_cast", "<", "unsigned", ">", "(", "FI", ")", "<", "FrameObjects", ".", "size", "(", ")", "&&", "!", "FrameObjects", "[", "FI", "]", ".", "isEmpty", "(", ")", ")", "return", "getFrameObjectOffset", "(", "FI", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "MFI", ".", "getObjectOffset", "(", "FI", ")", ";", "}", "</s>" ]

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

[ "TPC", "TPC", "TPC", "TPC" ]

[]

[ "<s>", "bool", "MSP430AsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "{", "EmitInterruptVectorSection", "(", "MF", ")", ";", "}", "SetupMachineFunction", "(", "MF", ")", ";", "EmitFunctionBody", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "\"interrupt\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "bool", ">", "AArch64FastISel", "::", "getRegForGEPIndex", "(", "const", "Value", "*", "Idx", ")", "{", "unsigned", "IdxN", "=", "getRegForValue", "(", "Idx", ")", ";", "if", "(", "IdxN", "==", "0", ")", "return", "std", "::", "pair", "<", "unsigned", ",", "bool", ">", "(", "0", ",", "false", ")", ";", "bool", "IdxNIsKill", "=", "hasTrivialKill", "(", "Idx", ")", ";", "MVT", "PtrVT", "=", "TLI", ".", "getPointerTy", "(", "DL", ")", ";", "EVT", "IdxVT", "=", "EVT", "::", "getEVT", "(", "Idx", "->", "getType", "(", ")", ",", "false", ")", ";", "if", "(", "IdxVT", ".", "bitsLT", "(", "PtrVT", ")", ")", "{", "IdxN", "=", "emitIntExt", "(", "IdxVT", ".", "getSimpleVT", "(", ")", ",", "IdxN", ",", "PtrVT", ",", "false", ")", ";", "IdxNIsKill", "=", "true", ";", "}", "else", "if", "(", "IdxVT", ".", "bitsGT", "(", "PtrVT", ")", ")", "llvm_unreachable", "(", "\"AArch64 FastISel doesn't support types larger than i64\"", ")", ";", "return", "std", "::", "pair", "<", "unsigned", ",", "bool", ">", "(", "IdxN", ",", "IdxNIsKill", ")", ";", "}", "</s>" ]

[ "This", "is", "a", "wrapper", "around", "getRegForValue", "that", "also", "takes", "care", "of", "truncating", "or", "sign-extending", "the", "given", "getelementptr", "index", "value", "." ]

[ "AArch64", "AArch64", "0", "0", "\"AArch64 FastISel doesn't support types larger than i64\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "AArch64TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "<=", "32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "GPR32RegClass", ")", ";", "else", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "GPR64RegClass", ")", ";", "break", ";", "case", "'w'", ":", "if", "(", "VT", "==", "MVT", "::", "f16", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "FPR16RegClass", ")", ";", "else", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "FPR32RegClass", ")", ";", "else", "if", "(", "VT", "==", "MVT", "::", "f64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "FPR64RegClass", ")", ";", "else", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "VPR64RegClass", ")", ";", "else", "if", "(", "VT", "==", "MVT", "::", "f128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "FPR128RegClass", ")", ";", "else", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "VPR128RegClass", ")", ";", "break", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "1", "0", "32", "0U", "AArch64::GPR32RegClass", "MVT::i64", "0U", "AArch64::GPR64RegClass", "MVT::f16", "0U", "AArch64::FPR16RegClass", "MVT::f32", "0U", "AArch64::FPR32RegClass", "MVT::f64", "0U", "AArch64::FPR64RegClass", "64", "0U", "AArch64::VPR64RegClass", "MVT::f128", "0U", "AArch64::FPR128RegClass", "128", "0U", "AArch64::VPR128RegClass" ]

[]

[ "<s>", "static", "char", "*", "match_identifier", "(", "void", ")", "{", "int", "lastpos", "=", "pos", "-", "1", ";", "while", "(", "lastpos", "<", "LINELEN", "-", "1", "&&", "(", "isalnum", "(", "linebuf", "[", "lastpos", "+", "1", "]", ")", "||", "linebuf", "[", "lastpos", "+", "1", "]", "==", "'_'", ")", ")", "++", "lastpos", ";", "if", "(", "lastpos", ">=", "LINELEN", "-", "1", ")", "{", "diag", "(", "lastpos", ",", "\"line length overrun.\\n\"", ")", ";", "exit", "(", "1", ")", ";", "}", "if", "(", "lastpos", "<", "pos", ")", "return", "0", ";", "char", "*", "buf", "=", "(", "char", "*", ")", "malloc", "(", "lastpos", "-", "pos", "+", "2", ")", ";", "memcpy", "(", "buf", ",", "&", "linebuf", "[", "pos", "]", ",", "lastpos", "-", "pos", "+", "1", ")", ";", "buf", "[", "lastpos", "-", "pos", "+", "1", "]", "=", "'\\0'", ";", "pos", "=", "lastpos", "+", "1", ";", "return", "buf", ";", "}", "</s>" ]

[ "Match", "an", "identifier", ",", "returning", "NULL", "on", "failure", ",", "else", "a", "pointer", "to", "a", "buffer", "containing", "the", "identifier", "." ]

[ "rs6000", "1", "1", "1", "1", "1", "\"line length overrun.\\n\"", "1", "0", "2", "1", "1", "1" ]

[]

[ "<s>", "bool", "WebAssemblyInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", ")", "const", "{", "bool", "HaveCond", "=", "false", ";", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ".", "terminators", "(", ")", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "true", ";", "case", "WebAssembly", "::", "BR_IF", ":", "if", "(", "HaveCond", ")", "return", "true", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "0", ")", ".", "isMBB", "(", ")", ")", "return", "true", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "true", ")", ")", ";", "Cond", ".", "push_back", "(", "MI", ".", "getOperand", "(", "1", ")", ")", ";", "TBB", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "HaveCond", "=", "true", ";", "break", ";", "case", "WebAssembly", "::", "BR_UNLESS", ":", "if", "(", "HaveCond", ")", "return", "true", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "0", ")", ".", "isMBB", "(", ")", ")", "return", "true", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "false", ")", ")", ";", "Cond", ".", "push_back", "(", "MI", ".", "getOperand", "(", "1", ")", ")", ";", "TBB", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "HaveCond", "=", "true", ";", "break", ";", "case", "WebAssembly", "::", "BR", ":", "if", "(", "!", "MI", ".", "getOperand", "(", "0", ")", ".", "isMBB", "(", ")", ")", "return", "true", ";", "if", "(", "!", "HaveCond", ")", "TBB", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "else", "FBB", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "break", ";", "case", "WebAssembly", "::", "BR_ON_EXN", ":", "if", "(", "HaveCond", ")", "return", "true", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "0", ")", ".", "isMBB", "(", ")", ")", "return", "true", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "true", ")", ")", ";", "Cond", ".", "push_back", "(", "MI", ".", "getOperand", "(", "2", ")", ")", ";", "TBB", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "HaveCond", "=", "true", ";", "break", ";", "}", "if", "(", "MI", ".", "isBarrier", "(", ")", ")", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly::BR_IF", "0", "1", "0", "WebAssembly::BR_UNLESS", "0", "1", "0", "WebAssembly::BR", "0", "0", "0", "WebAssembly::BR_ON_EXN", "0", "2", "0" ]

[]

[ "<s>", "static", "void", "arm_set_default_type_attributes", "(", "tree", "type", ")", "{", "if", "(", "TREE_CODE", "(", "type", ")", "==", "FUNCTION_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "METHOD_TYPE", ")", "{", "tree", "type_attr_list", ",", "attr_name", ";", "type_attr_list", "=", "TYPE_ATTRIBUTES", "(", "type", ")", ";", "if", "(", "arm_pragma_long_calls", "==", "LONG", ")", "attr_name", "=", "get_identifier", "(", "\"long_call\"", ")", ";", "else", "if", "(", "arm_pragma_long_calls", "==", "SHORT", ")", "attr_name", "=", "get_identifier", "(", "\"short_call\"", ")", ";", "else", "return", ";", "type_attr_list", "=", "tree_cons", "(", "attr_name", ",", "NULL_TREE", ",", "type_attr_list", ")", ";", "TYPE_ATTRIBUTES", "(", "type", ")", "=", "type_attr_list", ";", "}", "}", "</s>" ]

[ "Assigns", "default", "attributes", "to", "newly", "defined", "type", ".", "This", "is", "used", "to", "set", "short_call/long_call", "attributes", "for", "function", "types", "of", "functions", "defined", "inside", "corresponding", "#", "pragma", "scopes", "." ]

[ "arm", "\"long_call\"", "\"short_call\"" ]

[]

[ "<s>", "unsigned", "DLXMCCodeEmitter", "::", "getBranchTargetOpValue", "(", "const", "MCInst", "&", "Inst", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "SubtargetInfo", ")", "const", "{", "const", "MCOperand", "&", "MCOp", "=", "Inst", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MCOp", ".", "isReg", "(", ")", "||", "MCOp", ".", "isImm", "(", ")", ")", "return", "getMachineOpValue", "(", "Inst", ",", "MCOp", ",", "Fixups", ",", "SubtargetInfo", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "MCOp", ".", "getExpr", "(", ")", ",", "static_cast", "<", "MCFixupKind", ">", "(", "DLX", "::", "FIXUP_DLX_25", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getBranchTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "branch", "target", "operand", "." ]

[ "DLX", "DLX", "0", "DLX::FIXUP_DLX_25", "0" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "override", "{", "uint8_t", "OSABI", "=", "MCELFObjectTargetWriter", "::", "getOSABI", "(", "OSType", ")", ";", "return", "createSparcELFObjectWriter", "(", "OS", ",", "Is64Bit", ",", "IsLittleEndian", ",", "OSABI", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc" ]

[]

[ "<s>", "bool", "SIRegisterInfo", "::", "eliminateSGPRToVGPRSpillFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "MI", ",", "int", "FI", ",", "RegScavenger", "*", "RS", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_SPILL_S512_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S256_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S128_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S64_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S32_SAVE", ":", "return", "spillSGPR", "(", "MI", ",", "FI", ",", "RS", ",", "true", ")", ";", "case", "AMDGPU", "::", "SI_SPILL_S512_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S256_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S128_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S64_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S32_RESTORE", ":", "return", "restoreSGPR", "(", "MI", ",", "FI", ",", "RS", ",", "true", ")", ";", "default", ":", "llvm_unreachable", "(", "\"not an SGPR spill instruction\"", ")", ";", "}", "}", "</s>" ]

[ "Special", "case", "of", "eliminateFrameIndex", "." ]

[ "AMDGPU", "SI", "AMDGPU::SI_SPILL_S512_SAVE", "AMDGPU::SI_SPILL_S256_SAVE", "AMDGPU::SI_SPILL_S128_SAVE", "AMDGPU::SI_SPILL_S64_SAVE", "AMDGPU::SI_SPILL_S32_SAVE", "AMDGPU::SI_SPILL_S512_RESTORE", "AMDGPU::SI_SPILL_S256_RESTORE", "AMDGPU::SI_SPILL_S128_RESTORE", "AMDGPU::SI_SPILL_S64_RESTORE", "AMDGPU::SI_SPILL_S32_RESTORE", "\"not an SGPR spill instruction\"" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "orderFrameObjects", "(", "const", "MachineFunction", "&", "MF", ",", "SmallVectorImpl", "<", "int", ">", "&", "ObjectsToAllocate", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "ObjectsToAllocate", ".", "empty", "(", ")", ")", "return", ";", "std", "::", "vector", "<", "X86FrameSortingObject", ">", "SortingObjects", "(", "MFI", ".", "getObjectIndexEnd", "(", ")", ")", ";", "for", "(", "auto", "&", "Obj", ":", "ObjectsToAllocate", ")", "{", "SortingObjects", "[", "Obj", "]", ".", "IsValid", "=", "true", ";", "SortingObjects", "[", "Obj", "]", ".", "ObjectIndex", "=", "Obj", ";", "SortingObjects", "[", "Obj", "]", ".", "ObjectAlignment", "=", "MFI", ".", "getObjectAlign", "(", "Obj", ")", ";", "int", "ObjectSize", "=", "MFI", ".", "getObjectSize", "(", "Obj", ")", ";", "if", "(", "ObjectSize", "==", "0", ")", "SortingObjects", "[", "Obj", "]", ".", "ObjectSize", "=", "4", ";", "else", "SortingObjects", "[", "Obj", "]", ".", "ObjectSize", "=", "ObjectSize", ";", "}", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "MI", ".", "isDebugInstr", "(", ")", ")", "continue", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "{", "if", "(", "!", "MO", ".", "isFI", "(", ")", ")", "continue", ";", "int", "Index", "=", "MO", ".", "getIndex", "(", ")", ";", "if", "(", "Index", ">=", "0", "&&", "Index", "<", "MFI", ".", "getObjectIndexEnd", "(", ")", "&&", "SortingObjects", "[", "Index", "]", ".", "IsValid", ")", "SortingObjects", "[", "Index", "]", ".", "ObjectNumUses", "++", ";", "}", "}", "}", "llvm", "::", "stable_sort", "(", "SortingObjects", ",", "X86FrameSortingComparator", "(", ")", ")", ";", "int", "i", "=", "0", ";", "for", "(", "auto", "&", "Obj", ":", "SortingObjects", ")", "{", "if", "(", "!", "Obj", ".", "IsValid", ")", "break", ";", "ObjectsToAllocate", "[", "i", "++", "]", "=", "Obj", ".", "ObjectIndex", ";", "}", "if", "(", "!", "TRI", "->", "needsStackRealignment", "(", "MF", ")", "&&", "hasFP", "(", "MF", ")", ")", "std", "::", "reverse", "(", "ObjectsToAllocate", ".", "begin", "(", ")", ",", "ObjectsToAllocate", ".", "end", "(", ")", ")", ";", "}", "</s>" ]

[ "Order", "the", "symbols", "in", "the", "local", "stack", "." ]

[ "X86", "X86", "X86", "0", "4", "0", "X86", "0" ]

[]

[ "<s>", "static", "unsigned", "s390_loop_unroll_adjust", "(", "unsigned", "nunroll", ",", "struct", "loop", "*", "loop", ")", "{", "basic_block", "*", "bbs", ";", "rtx_insn", "*", "insn", ";", "unsigned", "i", ";", "unsigned", "mem_count", "=", "0", ";", "if", "(", "s390_tune", "<", "PROCESSOR_2097_Z10", ")", "return", "nunroll", ";", "bbs", "=", "get_loop_body", "(", "loop", ")", ";", "subrtx_iterator", "::", "array_type", "array", ";", "for", "(", "i", "=", "0", ";", "i", "<", "loop", "->", "num_nodes", ";", "i", "++", ")", "FOR_BB_INSNS", "(", "bbs", "[", "i", "]", ",", "insn", ")", "if", "(", "INSN_P", "(", "insn", ")", "&&", "INSN_CODE", "(", "insn", ")", "!=", "-", "1", ")", "{", "rtx", "set", ";", "if", "(", "s390_tune", ">=", "PROCESSOR_2964_Z13", "&&", "loop", "->", "ninsns", "<=", "BLOCK_MEM_OPS_LOOP_INSNS", "&&", "(", "(", "set", "=", "single_set", "(", "insn", ")", ")", "!=", "NULL_RTX", ")", "&&", "(", "(", "GET_MODE", "(", "SET_DEST", "(", "set", ")", ")", "==", "BLKmode", "&&", "(", "GET_MODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "BLKmode", "||", "SET_SRC", "(", "set", ")", "==", "const0_rtx", ")", ")", "||", "(", "GET_CODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "COMPARE", "&&", "GET_MODE", "(", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "0", ")", ")", "==", "BLKmode", "&&", "GET_MODE", "(", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", ")", "==", "BLKmode", ")", ")", ")", "{", "free", "(", "bbs", ")", ";", "return", "1", ";", "}", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "PATTERN", "(", "insn", ")", ",", "NONCONST", ")", "if", "(", "MEM_P", "(", "*", "iter", ")", ")", "mem_count", "+=", "1", ";", "}", "free", "(", "bbs", ")", ";", "if", "(", "mem_count", "==", "0", ")", "return", "nunroll", ";", "switch", "(", "loop_depth", "(", "loop", ")", ")", "{", "case", "1", ":", "return", "MIN", "(", "nunroll", ",", "28", "/", "mem_count", ")", ";", "case", "2", ":", "return", "MIN", "(", "nunroll", ",", "22", "/", "mem_count", ")", ";", "default", ":", "return", "MIN", "(", "nunroll", ",", "16", "/", "mem_count", ")", ";", "}", "}", "</s>" ]

[ "This", "target", "hook", "implementation", "for", "TARGET_LOOP_UNROLL_ADJUST", "calculates", "a", "new", "number", "struct", "loop", "*", "loop", "should", "be", "unrolled", "if", "tuned", "for", "cpus", "with", "a", "built-in", "stride", "prefetcher", ".", "The", "loop", "is", "analyzed", "for", "memory", "accesses", "by", "calling", "check_dpu", "for", "each", "rtx", "of", "the", "loop", ".", "Depending", "on", "the", "loop_depth", "and", "the", "amount", "of", "memory", "accesses", "a", "new", "number", "<", "=nunroll", "is", "returned", "to", "improve", "the", "behaviour", "of", "the", "hardware", "prefetch", "unit", "." ]

[ "s390", "0", "0", "1", "0", "1", "1", "1", "0", "1", "28", "2", "22", "16" ]

[]

[ "<s>", "int", "log2constp", "(", "unsigned", "HOST_WIDE_INT", "c", ")", "{", "c", "&=", "0xFFFFFFFF", ";", "return", "c", "!=", "0", "&&", "(", "c", "&", "(", "c", "-", "1", ")", ")", "==", "0", ";", "}", "</s>" ]

[ "Return", "nonzero", "iff", "C", "has", "exactly", "one", "bit", "set", "if", "it", "is", "interpreted", "as", "a", "32", "bit", "constant", "." ]

[ "bfin", "0xFFFFFFFF", "0", "1", "0" ]

[]

[ "<s>", "void", "ARMCallLowering", "::", "splitToValueTypes", "(", "const", "ArgInfo", "&", "OrigArg", ",", "SmallVectorImpl", "<", "ArgInfo", ">", "&", "SplitArgs", ",", "const", "DataLayout", "&", "DL", ",", "MachineRegisterInfo", "&", "MRI", ")", "const", "{", "const", "ARMTargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "ARMTargetLowering", ">", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "OrigArg", ".", "Ty", "->", "getContext", "(", ")", ";", "SmallVector", "<", "EVT", ",", "4", ">", "SplitVTs", ";", "SmallVector", "<", "uint64_t", ",", "4", ">", "Offsets", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "OrigArg", ".", "Ty", ",", "SplitVTs", ",", "&", "Offsets", ",", "0", ")", ";", "assert", "(", "SplitVTs", ".", "size", "(", ")", "==", "1", "&&", "\"Unsupported type\"", ")", ";", "SplitArgs", ".", "emplace_back", "(", "OrigArg", ".", "Reg", ",", "SplitVTs", "[", "0", "]", ".", "getTypeForEVT", "(", "Ctx", ")", ",", "OrigArg", ".", "Flags", ",", "OrigArg", ".", "IsFixed", ")", ";", "}", "</s>" ]

[ "Break", "OrigArgInfo", "into", "one", "or", "more", "pieces", "the", "calling", "convention", "can", "process", ",", "returned", "in", "SplitArgs", "." ]

[ "ARM", "ARM", "ARM", "ARM", "4", "4", "0", "1", "\"Unsupported type\"", "0" ]

[]

[ "<s>", "unsigned", "HexagonRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "return", "Hexagon", "::", "R30", ";", "}", "return", "Hexagon", "::", "R29", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "Hexagon", "Hexagon", "Hexagon::R30", "Hexagon::R29" ]

[]

[ "<s>", "const", "char", "*", "standard_sse_constant_opcode", "(", "rtx_insn", "*", "insn", ",", "rtx", "x", ")", "{", "machine_mode", "mode", ";", "gcc_assert", "(", "TARGET_SSE", ")", ";", "mode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "x", "==", "const0_rtx", "||", "const0_operand", "(", "x", ",", "mode", ")", ")", "{", "switch", "(", "get_attr_mode", "(", "insn", ")", ")", "{", "case", "MODE_XI", ":", "return", "\"vpxord\\t%g0, %g0, %g0\"", ";", "case", "MODE_OI", ":", "return", "(", "TARGET_AVX512VL", "?", "\"vpxord\\t%x0, %x0, %x0\"", ":", "\"vpxor\\t%x0, %x0, %x0\"", ")", ";", "case", "MODE_TI", ":", "return", "(", "TARGET_AVX512VL", "?", "\"vpxord\\t%t0, %t0, %t0\"", ":", "\"%vpxor\\t%0, %d0\"", ")", ";", "case", "MODE_V8DF", ":", "return", "(", "TARGET_AVX512DQ", "?", "\"vxorpd\\t%g0, %g0, %g0\"", ":", "\"vpxorq\\t%g0, %g0, %g0\"", ")", ";", "case", "MODE_V4DF", ":", "return", "\"vxorpd\\t%x0, %x0, %x0\"", ";", "case", "MODE_V2DF", ":", "return", "\"%vxorpd\\t%0, %d0\"", ";", "case", "MODE_V16SF", ":", "return", "(", "TARGET_AVX512DQ", "?", "\"vxorps\\t%g0, %g0, %g0\"", ":", "\"vpxord\\t%g0, %g0, %g0\"", ")", ";", "case", "MODE_V8SF", ":", "return", "\"vxorps\\t%x0, %x0, %x0\"", ";", "case", "MODE_V4SF", ":", "return", "\"%vxorps\\t%0, %d0\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "if", "(", "x", "==", "constm1_rtx", "||", "vector_all_ones_operand", "(", "x", ",", "mode", ")", ")", "{", "enum", "attr_mode", "insn_mode", "=", "get_attr_mode", "(", "insn", ")", ";", "switch", "(", "insn_mode", ")", "{", "case", "MODE_XI", ":", "case", "MODE_V8DF", ":", "case", "MODE_V16SF", ":", "gcc_assert", "(", "TARGET_AVX512F", ")", ";", "return", "\"vpternlogd\\t{$0xFF, %g0, %g0, %g0|%g0, %g0, %g0, 0xFF}\"", ";", "case", "MODE_OI", ":", "case", "MODE_V4DF", ":", "case", "MODE_V8SF", ":", "gcc_assert", "(", "TARGET_AVX2", ")", ";", "case", "MODE_TI", ":", "case", "MODE_V2DF", ":", "case", "MODE_V4SF", ":", "gcc_assert", "(", "TARGET_SSE2", ")", ";", "return", "(", "TARGET_AVX", "?", "\"vpcmpeqd\\t%0, %0, %0\"", ":", "\"pcmpeqd\\t%0, %0\"", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "opcode", "of", "the", "special", "instruction", "to", "be", "used", "to", "load", "the", "constant", "X", "." ]

[ "i386", "\"vpxord\\t%g0, %g0, %g0\"", "\"vpxord\\t%x0, %x0, %x0\"", "\"vpxor\\t%x0, %x0, %x0\"", "\"vpxord\\t%t0, %t0, %t0\"", "\"%vpxor\\t%0, %d0\"", "\"vxorpd\\t%g0, %g0, %g0\"", "\"vpxorq\\t%g0, %g0, %g0\"", "\"vxorpd\\t%x0, %x0, %x0\"", "\"%vxorpd\\t%0, %d0\"", "\"vxorps\\t%g0, %g0, %g0\"", "\"vpxord\\t%g0, %g0, %g0\"", "\"vxorps\\t%x0, %x0, %x0\"", "\"%vxorps\\t%0, %d0\"", "\"vpternlogd\\t{$0xFF, %g0, %g0, %g0|%g0, %g0, %g0, 0xFF}\"", "\"vpcmpeqd\\t%0, %0, %0\"", "\"pcmpeqd\\t%0, %0\"" ]

[]

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

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

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

[]

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

[ "True", "if", "the", "target", "uses", "physical", "regs", "(", "as", "nearly", "all", "targets", "do", ")", "." ]

[ "SPIRV" ]

[]

[ "<s>", "void", "print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "rtx", "breg", ";", "rtx", "offset", ";", "int", "again", "=", "0", ";", "retry", ":", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "MEM", ":", "if", "(", "TARGET_UNIX_ASM", ")", "fprintf", "(", "file", ",", "\"*\"", ")", ";", "else", "fprintf", "(", "file", ",", "\"@\"", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "again", "=", "1", ";", "goto", "retry", ";", "case", "REG", ":", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "addr", ")", "]", ")", ";", "break", ";", "case", "PRE_MODIFY", ":", "case", "PRE_DEC", ":", "fprintf", "(", "file", ",", "\"-(%s)\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "]", ")", ";", "break", ";", "case", "POST_MODIFY", ":", "case", "POST_INC", ":", "fprintf", "(", "file", ",", "\"(%s)+\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "]", ")", ";", "break", ";", "case", "PLUS", ":", "breg", "=", "0", ";", "offset", "=", "0", ";", "if", "(", "CONSTANT_ADDRESS_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "||", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "MEM", ")", "{", "offset", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "}", "else", "if", "(", "CONSTANT_ADDRESS_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "||", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "MEM", ")", "{", "offset", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "PLUS", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "REG", ")", "{", "breg", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "REG", ")", "{", "breg", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "addr", ")", "==", "REG", ")", "{", "gcc_assert", "(", "breg", "==", "0", ")", ";", "breg", "=", "addr", ";", "addr", "=", "0", ";", "}", "if", "(", "offset", "!=", "0", ")", "{", "gcc_assert", "(", "addr", "==", "0", ")", ";", "addr", "=", "offset", ";", "}", "if", "(", "addr", "!=", "0", ")", "output_addr_const_pdp11", "(", "file", ",", "addr", ")", ";", "if", "(", "breg", "!=", "0", ")", "{", "gcc_assert", "(", "GET_CODE", "(", "breg", ")", "==", "REG", ")", ";", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "breg", ")", "]", ")", ";", "}", "break", ";", "default", ":", "if", "(", "!", "again", "&&", "GET_CODE", "(", "addr", ")", "==", "CONST_INT", ")", "{", "if", "(", "TARGET_DEC_ASM", ")", "fprintf", "(", "file", ",", "\"@#\"", ")", ";", "else", "if", "(", "!", "TARGET_UNIX_ASM", ")", "fprintf", "(", "file", ",", "\"@$\"", ")", ";", "}", "output_addr_const_pdp11", "(", "file", ",", "addr", ")", ";", "}", "}", "</s>" ]

[ "Print", "the", "operand", "address", "represented", "by", "the", "rtx", "addr" ]

[ "pdp11", "0", "\"*\"", "\"@\"", "0", "1", "\"(%s)\"", "\"-(%s)\"", "0", "\"(%s)+\"", "0", "0", "0", "0", "0", "0", "1", "1", "1", "1", "0", "0", "0", "1", "1", "1", "0", "0", "0", "0", "0", "0", "0", "\"(%s)\"", "\"@#\"", "\"@$\"" ]

[]

[ "<s>", "static", "void", "ix86_emit_restore_regs_using_mov", "(", "HOST_WIDE_INT", "cfa_offset", ",", "bool", "maybe_eh_return", ")", "{", "struct", "machine_function", "*", "m", "=", "cfun", "->", "machine", ";", "unsigned", "int", "regno", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "GENERAL_REGNO_P", "(", "regno", ")", "&&", "ix86_save_reg", "(", "regno", ",", "maybe_eh_return", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "word_mode", ",", "regno", ")", ";", "rtx", "mem", ";", "rtx_insn", "*", "insn", ";", "mem", "=", "choose_baseaddr", "(", "cfa_offset", ")", ";", "mem", "=", "gen_frame_mem", "(", "word_mode", ",", "mem", ")", ";", "insn", "=", "emit_move_insn", "(", "reg", ",", "mem", ")", ";", "if", "(", "m", "->", "fs", ".", "cfa_reg", "==", "crtl", "->", "drap_reg", "&&", "regno", "==", "REGNO", "(", "crtl", "->", "drap_reg", ")", ")", "{", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "m", "->", "fs", ".", "drap_valid", "=", "true", ";", "}", "else", "ix86_add_cfa_restore_note", "(", "NULL", ",", "reg", ",", "cfa_offset", ")", ";", "cfa_offset", "-=", "UNITS_PER_WORD", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "restore", "saved", "registers", "using", "MOV", "insns", ".", "First", "register", "is", "restored", "from", "POINTER", "+", "OFFSET", "." ]

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

[]

[ "<s>", "rtx", "mips_subword", "(", "rtx", "op", ",", "int", "high_p", ")", "{", "unsigned", "int", "byte", ";", "enum", "machine_mode", "mode", ";", "mode", "=", "GET_MODE", "(", "op", ")", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "DImode", ";", "if", "(", "TARGET_BIG_ENDIAN", "?", "!", "high_p", ":", "high_p", ")", "byte", "=", "UNITS_PER_WORD", ";", "else", "byte", "=", "0", ";", "if", "(", "REG_P", "(", "op", ")", ")", "{", "if", "(", "FP_REG_P", "(", "REGNO", "(", "op", ")", ")", ")", "return", "gen_rtx_REG", "(", "word_mode", ",", "high_p", "?", "REGNO", "(", "op", ")", "+", "1", ":", "REGNO", "(", "op", ")", ")", ";", "if", "(", "ACC_HI_REG_P", "(", "REGNO", "(", "op", ")", ")", ")", "return", "gen_rtx_REG", "(", "word_mode", ",", "high_p", "?", "REGNO", "(", "op", ")", ":", "REGNO", "(", "op", ")", "+", "1", ")", ";", "}", "if", "(", "MEM_P", "(", "op", ")", ")", "return", "mips_rewrite_small_data", "(", "adjust_address", "(", "op", ",", "word_mode", ",", "byte", ")", ")", ";", "return", "simplify_gen_subreg", "(", "word_mode", ",", "op", ",", "mode", ",", "byte", ")", ";", "}", "</s>" ]

[ "Return", "one", "word", "of", "double-word", "value", "OP", ",", "taking", "into", "account", "the", "fixed", "endianness", "of", "certain", "registers", ".", "HIGH_P", "is", "true", "to", "select", "the", "high", "part", ",", "false", "to", "select", "the", "low", "part", "." ]

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

[]

[ "<s>", "bool", "NVPTXSplitBBatBar", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "SmallVector", "<", "Instruction", "*", ",", "4", ">", "SplitPoints", ";", "bool", "changed", "=", "false", ";", "for", "(", "Function", "::", "iterator", "BI", "=", "F", ".", "begin", "(", ")", ",", "BE", "=", "F", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "BasicBlock", "::", "iterator", "IB", "=", "BI", "->", "begin", "(", ")", ";", "BasicBlock", "::", "iterator", "II", "=", "IB", ";", "BasicBlock", "::", "iterator", "IE", "=", "BI", "->", "end", "(", ")", ";", "while", "(", "II", "!=", "IE", ")", "{", "if", "(", "IntrinsicInst", "*", "inst", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "II", ")", ")", "{", "Intrinsic", "::", "ID", "id", "=", "inst", "->", "getIntrinsicID", "(", ")", ";", "if", "(", "llvm", "::", "isBarrierIntrinsic", "(", "id", ")", ")", "{", "if", "(", "II", "!=", "IB", ")", "SplitPoints", ".", "push_back", "(", "II", ")", ";", "II", "++", ";", "if", "(", "(", "II", "!=", "IE", ")", "&&", "(", "!", "II", "->", "isTerminator", "(", ")", ")", ")", "{", "SplitPoints", ".", "push_back", "(", "II", ")", ";", "II", "++", ";", "}", "continue", ";", "}", "}", "II", "++", ";", "}", "}", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "SplitPoints", ".", "size", "(", ")", ";", "i", "++", ")", "{", "changed", "=", "true", ";", "Instruction", "*", "inst", "=", "SplitPoints", "[", "i", "]", ";", "inst", "->", "getParent", "(", ")", "->", "splitBasicBlock", "(", "inst", ",", "\"bar_split\"", ")", ";", "}", "return", "changed", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "4", "Intrinsic::ID", "0", "\"bar_split\"" ]

[]

[ "<s>", "bool", "AVRAsmParser", "::", "emit", "(", "MCInst", "&", "Inst", ",", "SMLoc", "const", "&", "Loc", ",", "MCStreamer", "&", "Out", ")", "const", "{", "Inst", ".", "setLoc", "(", "Loc", ")", ";", "Out", ".", "emitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Output", "the", "remark", "via", "the", "diagnostic", "handler", "and", "to", "the", "optimization", "record", "file", "." ]

[ "AVR", "AVR" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "isPredicable", "(", "MachineInstr", "*", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "TM", ".", "getSubtargetImpl", "(", ")", "->", "hasLoadStoreOnCond", "(", ")", "&&", "getConditionalMove", "(", "Opcode", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "instruction", "can", "be", "predicated", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "PreservedAnalyses", "BPFAbstractMemberAccessPass", "::", "run", "(", "Function", "&", "F", ",", "FunctionAnalysisManager", "&", "AM", ")", "{", "return", "BPFAbstractMemberAccess", "(", "TM", ")", ".", "run", "(", "F", ")", "?", "PreservedAnalyses", "::", "none", "(", ")", ":", "PreservedAnalyses", "::", "all", "(", ")", ";", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

[ "BPF", "BPF", "BPF" ]

[]

[ "<s>", "static", "void", "emit_movsi", "(", "rtx", "operands", "[", "2", "]", ")", "{", "operands", "[", "0", "]", "=", "copy_operand", "(", "operands", "[", "0", "]", ",", "SImode", ")", ";", "operands", "[", "1", "]", "=", "copy_operand", "(", "operands", "[", "1", "]", ",", "SImode", ")", ";", "emit_insn", "(", "gen_movsi", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", ";", "}", "</s>" ]

[ "Emit", "rtl", "code", "for", "moving", "operands", "[", "1", "]", "into", "operands", "[", "0", "]", "as", "a", "fullword", "." ]

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

[]

[ "<s>", "unsigned", "getPointerSize", "(", ")", "const", "{", "return", "2", ";", "}", "</s>" ]

[ "Layout", "pointer", "size", "in", "bytes", ",", "rounded", "up", "to", "a", "whole", "number", "of", "bytes", "." ]

[ "Teak", "2" ]

[]

[ "<s>", "static", "void", "ix86_reorg", "(", "void", ")", "{", "if", "(", "TARGET_ATHLON_K8", "&&", "optimize", "&&", "!", "optimize_size", ")", "ix86_pad_returns", "(", ")", ";", "if", "(", "TARGET_FOUR_JUMP_LIMIT", "&&", "optimize", "&&", "!", "optimize_size", ")", "ix86_avoid_jump_misspredicts", "(", ")", ";", "}", "</s>" ]

[ "Implement", "machine", "specific", "optimizations", ".", "We", "implement", "padding", "of", "returns", "for", "K8", "CPUs", "and", "pass", "to", "avoid", "4", "jumps", "in", "the", "single", "16", "byte", "window", "." ]

[ "i386" ]

[]

[ "<s>", "static", "void", "loongarch_adjust_block_mem", "(", "rtx", "mem", ",", "HOST_WIDE_INT", "length", ",", "rtx", "*", "loop_reg", ",", "rtx", "*", "loop_mem", ")", "{", "*", "loop_reg", "=", "copy_addr_to_reg", "(", "XEXP", "(", "mem", ",", "0", ")", ")", ";", "*", "loop_mem", "=", "change_address", "(", "mem", ",", "BLKmode", ",", "*", "loop_reg", ")", ";", "set_mem_align", "(", "*", "loop_mem", ",", "MIN", "(", "MEM_ALIGN", "(", "mem", ")", ",", "length", "*", "BITS_PER_UNIT", ")", ")", ";", "}", "</s>" ]

[ "Helper", "function", "for", "doing", "a", "loop-based", "block", "operation", "on", "memory", "reference", "MEM", ".", "Each", "iteration", "of", "the", "loop", "will", "operate", "on", "LENGTH", "bytes", "of", "MEM", ".", "Create", "a", "new", "base", "register", "for", "use", "within", "the", "loop", "and", "point", "it", "to", "the", "start", "of", "MEM", ".", "Create", "a", "new", "memory", "reference", "that", "uses", "this", "register", ".", "Store", "them", "in", "*", "LOOP_REG", "and", "*", "LOOP_MEM", "respectively", "." ]

[ "loongarch", "0" ]

[]

[ "<s>", "ARMSubtarget", "::", "ARMSubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "ARMBaseTargetMachine", "&", "TM", ",", "bool", "IsLittle", ")", ":", "ARMGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "UseMulOps", "(", "UseFusedMulOps", ")", ",", "GenExecuteOnly", "(", "EnableExecuteOnly", ")", ",", "CPUString", "(", "CPU", ")", ",", "IsLittle", "(", "IsLittle", ")", ",", "TargetTriple", "(", "TT", ")", ",", "Options", "(", "TM", ".", "Options", ")", ",", "TM", "(", "TM", ")", ",", "FrameLowering", "(", "initializeFrameLowering", "(", "CPU", ",", "FS", ")", ")", ",", "InstrInfo", "(", "isThumb1Only", "(", ")", "?", "(", "ARMBaseInstrInfo", "*", ")", "new", "Thumb1InstrInfo", "(", "*", "this", ")", ":", "!", "isThumb", "(", ")", "?", "(", "ARMBaseInstrInfo", "*", ")", "new", "ARMInstrInfo", "(", "*", "this", ")", ":", "(", "ARMBaseInstrInfo", "*", ")", "new", "Thumb2InstrInfo", "(", "*", "this", ")", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", ",", "GISel", "(", ")", "{", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "int", "get_epiphany_condition_code", "(", "rtx", "comparison", ")", "{", "switch", "(", "GET_MODE", "(", "XEXP", "(", "comparison", ",", "0", ")", ")", ")", "{", "case", "E_CCmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "EQ", ":", "return", "0", ";", "case", "NE", ":", "return", "1", ";", "case", "LTU", ":", "return", "2", ";", "case", "GEU", ":", "return", "3", ";", "case", "GT", ":", "return", "4", ";", "case", "LE", ":", "return", "5", ";", "case", "GE", ":", "return", "6", ";", "case", "LT", ":", "return", "7", ";", "case", "GTU", ":", "return", "8", ";", "case", "LEU", ":", "return", "9", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "E_CC_N_NEmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "EQ", ":", "return", "6", ";", "case", "NE", ":", "return", "7", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "E_CC_C_LTUmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "GEU", ":", "return", "2", ";", "case", "LTU", ":", "return", "3", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "E_CC_C_GTUmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "LEU", ":", "return", "3", ";", "case", "GTU", ":", "return", "2", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "E_CC_FPmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "EQ", ":", "return", "10", ";", "case", "NE", ":", "return", "11", ";", "case", "LT", ":", "return", "12", ";", "case", "LE", ":", "return", "13", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "E_CC_FP_EQmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "EQ", ":", "return", "0", ";", "case", "NE", ":", "return", "1", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "E_CC_FP_GTEmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "EQ", ":", "return", "0", ";", "case", "NE", ":", "return", "1", ";", "case", "GT", ":", "return", "4", ";", "case", "GE", ":", "return", "6", ";", "case", "UNLE", ":", "return", "5", ";", "case", "UNLT", ":", "return", "7", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "E_CC_FP_ORDmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "ORDERED", ":", "return", "9", ";", "case", "UNORDERED", ":", "return", "8", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "E_CC_FP_UNEQmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "UNEQ", ":", "return", "9", ";", "case", "LTGT", ":", "return", "8", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "(", "42", ")", ";", "}", "</s>" ]

[ "Returns", "the", "index", "of", "the", "EPIPHANY", "condition", "code", "string", "in", "`", "epiphany_condition_codes", "'", ".", "COMPARISON", "should", "be", "an", "rtx", "like", "`", "(", "eq", "(", "...", ")", "(", "...", ")", ")", "'", "." ]

[ "epiphany", "0", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "6", "7", "2", "3", "3", "2", "10", "11", "12", "13", "0", "1", "0", "1", "4", "6", "5", "7", "9", "8", "9", "8", "42" ]

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "MipsOperand", ">", "CreateReg", "(", "unsigned", "Index", ",", "StringRef", "Str", ",", "RegKind", "RegKind", ",", "const", "MCRegisterInfo", "*", "RegInfo", ",", "SMLoc", "S", ",", "SMLoc", "E", ",", "MipsAsmParser", "&", "Parser", ")", "{", "auto", "Op", "=", "std", "::", "make_unique", "<", "MipsOperand", ">", "(", "k_RegisterIndex", ",", "Parser", ")", ";", "Op", "->", "RegIdx", ".", "Index", "=", "Index", ";", "Op", "->", "RegIdx", ".", "RegInfo", "=", "RegInfo", ";", "Op", "->", "RegIdx", ".", "Kind", "=", "RegKind", ";", "Op", "->", "RegIdx", ".", "Tok", ".", "Data", "=", "Str", ".", "data", "(", ")", ";", "Op", "->", "RegIdx", ".", "Tok", ".", "Length", "=", "Str", ".", "size", "(", ")", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]

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

[]

[ "<s>", "unsigned", "AMDGPUSubtarget", "::", "getMaxLocalMemSizeWithWaveCount", "(", "unsigned", "NWaves", ",", "const", "Function", "&", "F", ")", "const", "{", "if", "(", "NWaves", "==", "1", ")", "return", "getLocalMemorySize", "(", ")", ";", "unsigned", "WorkGroupSize", "=", "getFlatWorkGroupSizes", "(", "F", ")", ".", "second", ";", "unsigned", "WorkGroupsPerCu", "=", "getMaxWorkGroupsPerCU", "(", "WorkGroupSize", ")", ";", "unsigned", "MaxWaves", "=", "getMaxWavesPerEU", "(", ")", ";", "return", "getLocalMemorySize", "(", ")", "*", "MaxWaves", "/", "WorkGroupsPerCu", "/", "NWaves", ";", "}", "</s>" ]

[ "Return", "the", "amount", "of", "LDS", "that", "can", "be", "used", "that", "will", "not", "restrict", "the", "occupancy", "lower", "than", "WaveCount", "." ]

[ "AMDGPU", "AMDGPU", "1" ]

[]

[ "<s>", "static", "void", "find_constant", "(", "rtx", "in_rtx", ",", "imm_info", "*", "imm_values", ")", "{", "if", "(", "INSN_P", "(", "in_rtx", ")", ")", "in_rtx", "=", "PATTERN", "(", "in_rtx", ")", ";", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "in_rtx", ",", "ALL", ")", "if", "(", "const_rtx", "x", "=", "*", "iter", ")", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "case", "CONST_INT", ":", "(", "imm_values", "->", "imm", ")", "++", ";", "if", "(", "x86_64_immediate_operand", "(", "CONST_CAST_RTX", "(", "x", ")", ",", "SImode", ")", ")", "(", "imm_values", "->", "imm32", ")", "++", ";", "else", "(", "imm_values", "->", "imm64", ")", "++", ";", "break", ";", "case", "CONST_DOUBLE", ":", "(", "imm_values", "->", "imm", ")", "++", ";", "(", "imm_values", "->", "imm64", ")", "++", ";", "break", ";", "case", "CODE_LABEL", ":", "if", "(", "LABEL_KIND", "(", "x", ")", "==", "LABEL_NORMAL", ")", "{", "(", "imm_values", "->", "imm", ")", "++", ";", "(", "imm_values", "->", "imm32", ")", "++", ";", "}", "break", ";", "default", ":", "break", ";", "}", "}", "</s>" ]

[ "Compute", "number", "of", "immediate", "operands", "of", "an", "instruction", "." ]

[ "i386" ]

[]

[ "<s>", "static", "void", "rs6000_split_logical_inner", "(", "rtx", "dest", ",", "rtx", "op1", ",", "rtx", "op2", ",", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ",", "bool", "complement_final_p", ",", "bool", "complement_op1_p", ",", "bool", "complement_op2_p", ")", "{", "rtx", "bool_rtx", ";", "if", "(", "op2", "&&", "GET_CODE", "(", "op2", ")", "==", "CONST_INT", "&&", "(", "mode", "==", "SImode", "||", "(", "mode", "==", "DImode", "&&", "TARGET_POWERPC64", ")", ")", "&&", "!", "complement_final_p", "&&", "!", "complement_op1_p", "&&", "!", "complement_op2_p", ")", "{", "HOST_WIDE_INT", "mask", "=", "GET_MODE_MASK", "(", "mode", ")", ";", "HOST_WIDE_INT", "value", "=", "INTVAL", "(", "op2", ")", "&", "mask", ";", "if", "(", "code", "==", "AND", ")", "{", "if", "(", "value", "==", "0", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "const0_rtx", ")", ")", ";", "return", ";", "}", "else", "if", "(", "value", "==", "mask", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "dest", ",", "op1", ")", ")", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "op1", ")", ")", ";", "return", ";", "}", "}", "else", "if", "(", "code", "==", "IOR", "||", "code", "==", "XOR", ")", "{", "if", "(", "value", "==", "0", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "dest", ",", "op1", ")", ")", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "op1", ")", ")", ";", "return", ";", "}", "}", "}", "if", "(", "code", "==", "AND", "&&", "mode", "==", "SImode", "&&", "!", "complement_final_p", "&&", "!", "complement_op1_p", "&&", "!", "complement_op2_p", ")", "{", "emit_insn", "(", "gen_andsi3", "(", "dest", ",", "op1", ",", "op2", ")", ")", ";", "return", ";", "}", "if", "(", "complement_op1_p", ")", "op1", "=", "gen_rtx_NOT", "(", "mode", ",", "op1", ")", ";", "if", "(", "complement_op2_p", ")", "op2", "=", "gen_rtx_NOT", "(", "mode", ",", "op2", ")", ";", "if", "(", "!", "complement_op1_p", "&&", "complement_op2_p", ")", "std", "::", "swap", "(", "op1", ",", "op2", ")", ";", "bool_rtx", "=", "(", "(", "code", "==", "NOT", ")", "?", "gen_rtx_NOT", "(", "mode", ",", "op1", ")", ":", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "op1", ",", "op2", ")", ")", ";", "if", "(", "complement_final_p", ")", "bool_rtx", "=", "gen_rtx_NOT", "(", "mode", ",", "bool_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "bool_rtx", ")", ")", ";", "}", "</s>" ]

[ "Helper", "function", "for", "rs6000_split_logical", "to", "emit", "a", "logical", "instruction", "after", "spliting", "the", "operation", "to", "single", "GPR", "registers", ".", "DEST", "is", "the", "destination", "register", ".", "OP1", "and", "OP2", "are", "the", "input", "source", "registers", ".", "CODE", "is", "the", "base", "operation", "(", "AND", ",", "IOR", ",", "XOR", ",", "NOT", ")", ".", "MODE", "is", "the", "machine", "mode", ".", "If", "COMPLEMENT_FINAL_P", "is", "true", ",", "wrap", "the", "whole", "operation", "with", "NOT", ".", "If", "COMPLEMENT_OP1_P", "is", "true", ",", "wrap", "operand1", "with", "NOT", ".", "If", "COMPLEMENT_OP2_P", "is", "true", ",", "wrap", "operand2", "with", "NOT", "." ]

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

[]

[ "<s>", "void", "PPCPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createPPCBoolRetToIntPass", "(", ")", ")", ";", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "bool", "UsePrefetching", "=", "TM", "->", "getTargetTriple", "(", ")", ".", "getVendor", "(", ")", "==", "Triple", "::", "BGQ", "&&", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ";", "if", "(", "EnablePrefetch", ".", "getNumOccurrences", "(", ")", ">", "0", ")", "UsePrefetching", "=", "EnablePrefetch", ";", "if", "(", "UsePrefetching", ")", "addPass", "(", "createLoopDataPrefetchPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", ">=", "CodeGenOpt", "::", "Default", "&&", "EnableGEPOpt", ")", "{", "addPass", "(", "createSeparateConstOffsetFromGEPPass", "(", "TM", ",", "true", ")", ")", ";", "addPass", "(", "createEarlyCSEPass", "(", ")", ")", ";", "addPass", "(", "createLICMPass", "(", ")", ")", ";", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

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

[]

[ "<s>", "bool", "SIInstrInfo", "::", "usesConstantBus", "(", "const", "MachineRegisterInfo", "&", "MRI", ",", "const", "MachineOperand", "&", "MO", ")", "const", "{", "if", "(", "isLiteralConstant", "(", "MO", ")", ")", "return", "true", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "isUse", "(", ")", ")", "return", "false", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", "return", "RI", ".", "isSGPRClass", "(", "MRI", ".", "getRegClass", "(", "MO", ".", "getReg", "(", ")", ")", ")", ";", "if", "(", "!", "MO", ".", "isImplicit", "(", ")", "&&", "(", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "FLAT_SCR", ")", ")", "return", "true", ";", "if", "(", "!", "MO", ".", "isImplicit", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "EXEC", ")", "return", "true", ";", "if", "(", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "M0", "||", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "VCC", "||", "(", "!", "MO", ".", "isImplicit", "(", ")", "&&", "(", "AMDGPU", "::", "SGPR_32RegClass", ".", "contains", "(", "MO", ".", "getReg", "(", ")", ")", "||", "AMDGPU", "::", "SGPR_64RegClass", ".", "contains", "(", "MO", ".", "getReg", "(", ")", ")", ")", ")", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "operand", "uses", "the", "constant", "bus", "." ]

[ "R600", "SI" ]

[]

[ "<s>", "void", "PatmosInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "Opc", ";", "if", "(", "Patmos", "::", "RRegsRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "Opc", "=", "Patmos", "::", "MOV", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "if", "(", "Patmos", "::", "PRegsRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "Opc", "=", "Patmos", "::", "PMOV", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addImm", "(", "0", ")", ";", "}", "else", "if", "(", "Patmos", "::", "SRegsRegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "assert", "(", "Patmos", "::", "RRegsRegClass", ".", "contains", "(", "SrcReg", ")", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Patmos", "::", "MTS", ")", ",", "DestReg", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "if", "(", "Patmos", "::", "SRegsRegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "assert", "(", "Patmos", "::", "RRegsRegClass", ".", "contains", "(", "DestReg", ")", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Patmos", "::", "MFS", ")", ",", "DestReg", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "}", "</s>" ]

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

[ "Patmos", "Patmos", "Patmos::RRegsRegClass", "Patmos::MOV", "Patmos::PRegsRegClass", "Patmos::PMOV", "0", "Patmos::SRegsRegClass", "Patmos::RRegsRegClass", "Patmos::MTS", "Patmos::SRegsRegClass", "Patmos::RRegsRegClass", "Patmos::MFS", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "bool", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "override", "{", "uint64_t", "NumNops", "=", "Count", "/", "4", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "!=", "NumNops", ";", "++", "i", ")", "OW", "->", "Write32", "(", "0x60000000", ")", ";", "switch", "(", "Count", "%", "4", ")", "{", "default", ":", "break", ";", "case", "1", ":", "OW", "->", "Write8", "(", "0", ")", ";", "break", ";", "case", "2", ":", "OW", "->", "Write16", "(", "0", ")", ";", "break", ";", "case", "3", ":", "OW", "->", "Write16", "(", "0", ")", ";", "OW", "->", "Write8", "(", "0", ")", ";", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "PowerPC", "4", "0", "0x60000000", "4", "1", "0", "2", "0", "3", "0", "0" ]

[]

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

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

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

[]

[ "<s>", "TargetLoweringBase", "::", "LegalizeTypeAction", "X86TargetLowering", "::", "getPreferredVectorAction", "(", "MVT", "VT", ")", "const", "{", "if", "(", "(", "VT", "==", "MVT", "::", "v32i1", "||", "VT", "==", "MVT", "::", "v64i1", ")", "&&", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", ")", "return", "TypeSplitVector", ";", "if", "(", "!", "VT", ".", "isScalableVector", "(", ")", "&&", "VT", ".", "getVectorNumElements", "(", ")", "!=", "1", "&&", "VT", ".", "getVectorElementType", "(", ")", "!=", "MVT", "::", "i1", ")", "return", "TypeWidenVector", ";", "return", "TargetLoweringBase", "::", "getPreferredVectorAction", "(", "VT", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "MVT::v32i1", "MVT::v64i1", "1", "MVT::i1" ]

[]

[ "<s>", "bool", "NVPTXReplaceImageHandles", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changed", "=", "false", ";", "InstrsToRemove", ".", "clear", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "(", "*", "BI", ")", ".", "begin", "(", ")", ",", "E", "=", "(", "*", "BI", ")", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "Changed", "|=", "processInstr", "(", "MI", ")", ";", "}", "}", "for", "(", "DenseSet", "<", "MachineInstr", "*", ">", "::", "iterator", "I", "=", "InstrsToRemove", ".", "begin", "(", ")", ",", "E", "=", "InstrsToRemove", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "(", "*", "I", ")", "->", "eraseFromParent", "(", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "bool", "rs6000_emit_set_const", "(", "rtx", "dest", ",", "rtx", "source", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "rtx", "temp", ",", "set", ";", "rtx_insn", "*", "insn", ";", "HOST_WIDE_INT", "c", ";", "gcc_checking_assert", "(", "CONST_INT_P", "(", "source", ")", ")", ";", "c", "=", "INTVAL", "(", "source", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "case", "E_HImode", ":", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "source", ")", ")", ";", "return", "true", ";", "case", "E_SImode", ":", "temp", "=", "!", "can_create_pseudo_p", "(", ")", "?", "dest", ":", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "copy_rtx", "(", "temp", ")", ",", "GEN_INT", "(", "c", "&", "~", "(", "HOST_WIDE_INT", ")", "0xffff", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "gen_rtx_IOR", "(", "SImode", ",", "copy_rtx", "(", "temp", ")", ",", "GEN_INT", "(", "c", "&", "0xffff", ")", ")", ")", ")", ";", "break", ";", "case", "E_DImode", ":", "if", "(", "!", "TARGET_POWERPC64", ")", "{", "rtx", "hi", ",", "lo", ";", "hi", "=", "operand_subword_force", "(", "copy_rtx", "(", "dest", ")", ",", "WORDS_BIG_ENDIAN", "==", "0", ",", "DImode", ")", ";", "lo", "=", "operand_subword_force", "(", "dest", ",", "WORDS_BIG_ENDIAN", "!=", "0", ",", "DImode", ")", ";", "emit_move_insn", "(", "hi", ",", "GEN_INT", "(", "c", ">>", "32", ")", ")", ";", "c", "=", "(", "(", "c", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "emit_move_insn", "(", "lo", ",", "GEN_INT", "(", "c", ")", ")", ";", "}", "else", "rs6000_emit_set_long_const", "(", "dest", ",", "c", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "insn", "=", "get_last_insn", "(", ")", ";", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "!", "CONSTANT_P", "(", "SET_SRC", "(", "set", ")", ")", ")", "set_unique_reg_note", "(", "insn", ",", "REG_EQUAL", ",", "GEN_INT", "(", "c", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Try", "to", "output", "insns", "to", "set", "TARGET", "equal", "to", "the", "constant", "C", "if", "it", "can", "be", "done", "in", "less", "than", "N", "insns", ".", "Do", "all", "computations", "in", "MODE", ".", "Returns", "the", "place", "where", "the", "output", "has", "been", "placed", "if", "it", "can", "be", "done", "and", "the", "insns", "have", "been", "emitted", ".", "If", "it", "would", "take", "more", "than", "N", "insns", ",", "zero", "is", "returned", "and", "no", "insns", "and", "emitted", "." ]

[ "powerpcspe", "0xffff", "0xffff", "0", "0", "32", "0xffffffff", "0x80000000", "0x80000000" ]

[]

[ "<s>", "void", "SystemZInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "unsigned", "LoadOpcode", ",", "StoreOpcode", ";", "getLoadStoreOpcodes", "(", "RC", ",", "LoadOpcode", ",", "StoreOpcode", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "LoadOpcode", ")", ",", "DestReg", ")", ",", "FrameIdx", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "Register", "&", "SrcReg", ",", "Register", "&", "SrcReg2", ",", "int64_t", "&", "CmpMask", ",", "int64_t", "&", "CmpValue", ")", "const", "{", "assert", "(", "MI", ".", "getNumOperands", "(", ")", ">=", "2", "&&", "\"All AArch64 cmps should have 2 operands\"", ")", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", ")", "return", "false", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64", "::", "PTEST_PP", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "AArch64", "::", "SUBSWrr", ":", "case", "AArch64", "::", "SUBSWrs", ":", "case", "AArch64", "::", "SUBSWrx", ":", "case", "AArch64", "::", "SUBSXrr", ":", "case", "AArch64", "::", "SUBSXrs", ":", "case", "AArch64", "::", "SUBSXrx", ":", "case", "AArch64", "::", "ADDSWrr", ":", "case", "AArch64", "::", "ADDSWrs", ":", "case", "AArch64", "::", "ADDSWrx", ":", "case", "AArch64", "::", "ADDSXrr", ":", "case", "AArch64", "::", "ADDSXrs", ":", "case", "AArch64", "::", "ADDSXrx", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "AArch64", "::", "SUBSWri", ":", "case", "AArch64", "::", "ADDSWri", ":", "case", "AArch64", "::", "SUBSXri", ":", "case", "AArch64", "::", "ADDSXri", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "case", "AArch64", "::", "ANDSWri", ":", "case", "AArch64", "::", "ANDSXri", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "AArch64_AM", "::", "decodeLogicalImmediate", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ",", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "ANDSWri", "?", "32", ":", "64", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "2", "\"All AArch64 cmps should have 2 operands\"", "1", "AArch64::PTEST_PP", "0", "1", "0", "0", "AArch64::SUBSWrr", "AArch64::SUBSWrs", "AArch64::SUBSWrx", "AArch64::SUBSXrr", "AArch64::SUBSXrs", "AArch64::SUBSXrx", "AArch64::ADDSWrr", "AArch64::ADDSWrs", "AArch64::ADDSWrx", "AArch64::ADDSXrr", "AArch64::ADDSXrs", "AArch64::ADDSXrx", "1", "2", "0", "0", "AArch64::SUBSWri", "AArch64::ADDSWri", "AArch64::SUBSXri", "AArch64::ADDSXri", "1", "0", "0", "2", "AArch64::ANDSWri", "AArch64::ANDSXri", "1", "0", "0", "AArch64_AM::decodeLogicalImmediate", "2", "AArch64::ANDSWri", "32", "64" ]

[]

[ "<s>", "void", "arm_split_atomic_op", "(", "enum", "rtx_code", "code", ",", "rtx", "old_out", ",", "rtx", "new_out", ",", "rtx", "mem", ",", "rtx", "value", ",", "rtx", "model_rtx", ",", "rtx", "cond", ")", "{", "enum", "memmodel", "model", "=", "(", "enum", "memmodel", ")", "INTVAL", "(", "model_rtx", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "machine_mode", "wmode", "=", "(", "mode", "==", "DImode", "?", "DImode", ":", "SImode", ")", ";", "rtx_code_label", "*", "label", ";", "rtx", "x", ";", "bool", "use_acquire", "=", "TARGET_HAVE_LDACQ", "&&", "!", "(", "model", "==", "MEMMODEL_RELAXED", "||", "model", "==", "MEMMODEL_CONSUME", "||", "model", "==", "MEMMODEL_RELEASE", ")", ";", "bool", "use_release", "=", "TARGET_HAVE_LDACQ", "&&", "!", "(", "model", "==", "MEMMODEL_RELAXED", "||", "model", "==", "MEMMODEL_CONSUME", "||", "model", "==", "MEMMODEL_ACQUIRE", ")", ";", "if", "(", "!", "(", "use_acquire", "||", "use_release", ")", ")", "arm_pre_atomic_barrier", "(", "model", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "if", "(", "new_out", ")", "new_out", "=", "gen_lowpart", "(", "wmode", ",", "new_out", ")", ";", "if", "(", "old_out", ")", "old_out", "=", "gen_lowpart", "(", "wmode", ",", "old_out", ")", ";", "else", "old_out", "=", "new_out", ";", "value", "=", "simplify_gen_subreg", "(", "wmode", ",", "value", ",", "mode", ",", "0", ")", ";", "arm_emit_load_exclusive", "(", "mode", ",", "old_out", ",", "mem", ",", "use_acquire", ")", ";", "switch", "(", "code", ")", "{", "case", "SET", ":", "new_out", "=", "value", ";", "break", ";", "case", "NOT", ":", "x", "=", "gen_rtx_AND", "(", "wmode", ",", "old_out", ",", "value", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "new_out", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_NOT", "(", "wmode", ",", "new_out", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "new_out", ",", "x", ")", ")", ";", "break", ";", "case", "MINUS", ":", "if", "(", "CONST_INT_P", "(", "value", ")", ")", "{", "value", "=", "GEN_INT", "(", "-", "INTVAL", "(", "value", ")", ")", ";", "code", "=", "PLUS", ";", "}", "case", "PLUS", ":", "if", "(", "mode", "==", "DImode", ")", "{", "emit_move_insn", "(", "new_out", ",", "old_out", ")", ";", "if", "(", "code", "==", "PLUS", ")", "x", "=", "gen_adddi3", "(", "new_out", ",", "new_out", ",", "value", ")", ";", "else", "x", "=", "gen_subdi3", "(", "new_out", ",", "new_out", ",", "value", ")", ";", "emit_insn", "(", "x", ")", ";", "break", ";", "}", "default", ":", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "wmode", ",", "old_out", ",", "value", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "new_out", ",", "x", ")", ")", ";", "break", ";", "}", "arm_emit_store_exclusive", "(", "mode", ",", "cond", ",", "mem", ",", "gen_lowpart", "(", "mode", ",", "new_out", ")", ",", "use_release", ")", ";", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "gen_cbranchsi4", "(", "x", ",", "cond", ",", "const0_rtx", ",", "label", ")", ")", ";", "if", "(", "!", "(", "use_acquire", "||", "use_release", ")", ")", "arm_post_atomic_barrier", "(", "model", ")", ";", "}", "</s>" ]

[ "Split", "an", "atomic", "operation", "pattern", ".", "Operation", "is", "given", "by", "CODE", "and", "is", "one", "of", "PLUS", ",", "MINUS", ",", "IOR", ",", "XOR", ",", "SET", "(", "for", "an", "exchange", "operation", ")", "or", "NOT", "(", "for", "a", "nand", "operation", ")", ".", "Operation", "is", "performed", "on", "the", "content", "at", "MEM", "and", "on", "VALUE", "following", "the", "memory", "model", "MODEL_RTX", ".", "The", "content", "at", "MEM", "before", "and", "after", "the", "operation", "is", "returned", "in", "OLD_OUT", "and", "NEW_OUT", "respectively", "while", "the", "success", "of", "the", "operation", "is", "returned", "in", "COND", ".", "Using", "a", "scratch", "register", "or", "an", "operand", "register", "for", "these", "determines", "what", "result", "is", "returned", "for", "that", "pattern", "." ]

[ "arm", "0" ]

[]

[ "<s>", "void", "GBZ80FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "CallingConv", "::", "ID", "CallConv", "=", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "DebugLoc", "DL", "=", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "const", "GBZ80Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "GBZ80Subtarget", ">", "(", ")", ";", "const", "GBZ80InstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "GBZ80MachineFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "GBZ80MachineFunctionInfo", ">", "(", ")", ";", "int", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", "-", "AFI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "while", "(", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "&&", "MBBI", "->", "getFlag", "(", "MachineInstr", "::", "FrameSetup", ")", "&&", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "GB", "::", "PUSH", ")", ")", "{", "++", "MBBI", ";", "}", "if", "(", "!", "FrameSize", ")", "{", "return", ";", "}", "while", "(", "FrameSize", "!=", "0", ")", "{", "int", "ToSubtract", "=", "std", "::", "min", "(", "128", ",", "FrameSize", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "GB", "::", "ADD_SP_e", ")", ")", ".", "addImm", "(", "-", "ToSubtract", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "MI", "->", "findRegisterDefOperand", "(", "GB", "::", "RF", ")", "->", "setIsDead", "(", ")", ";", "FrameSize", "-=", "ToSubtract", ";", "}", "}", "</s>" ]

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

[ "GBZ80", "GB", "GB", "GB", "GB", "GB", "GB", "GB::PUSH", "0", "128", "GB::ADD_SP_e", "GB::RF" ]

[]

[ "<s>", "const", "char", "*", "vax_output_int_move", "(", "rtx", "insn", "ATTRIBUTE_UNUSED", ",", "rtx", "*", "operands", ",", "enum", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "SImode", ":", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST", ")", "{", "if", "(", "push_operand", "(", "operands", "[", "0", "]", ",", "SImode", ")", ")", "return", "\"pushab %a1\"", ";", "return", "\"movab %a1,%0\"", ";", "}", "if", "(", "operands", "[", "1", "]", "==", "const0_rtx", ")", "return", "\"clrl %0\"", ";", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST_INT", "&&", "(", "unsigned", ")", "INTVAL", "(", "operands", "[", "1", "]", ")", ">=", "64", ")", "{", "int", "i", "=", "INTVAL", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "(", "unsigned", ")", "(", "~", "i", ")", "<", "64", ")", "return", "\"mcoml %N1,%0\"", ";", "if", "(", "(", "unsigned", ")", "i", "<", "0x100", ")", "return", "\"movzbl %1,%0\"", ";", "if", "(", "i", ">=", "-", "0x80", "&&", "i", "<", "0", ")", "return", "\"cvtbl %1,%0\"", ";", "if", "(", "(", "unsigned", ")", "i", "<", "0x10000", ")", "return", "\"movzwl %1,%0\"", ";", "if", "(", "i", ">=", "-", "0x8000", "&&", "i", "<", "0", ")", "return", "\"cvtwl %1,%0\"", ";", "}", "if", "(", "push_operand", "(", "operands", "[", "0", "]", ",", "SImode", ")", ")", "return", "\"pushl %1\"", ";", "return", "\"movl %1,%0\"", ";", "case", "HImode", ":", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST_INT", ")", "{", "int", "i", "=", "INTVAL", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "i", "==", "0", ")", "return", "\"clrw %0\"", ";", "else", "if", "(", "(", "unsigned", "int", ")", "i", "<", "64", ")", "return", "\"movw %1,%0\"", ";", "else", "if", "(", "(", "unsigned", "int", ")", "~", "i", "<", "64", ")", "return", "\"mcomw %H1,%0\"", ";", "else", "if", "(", "(", "unsigned", "int", ")", "i", "<", "256", ")", "return", "\"movzbw %1,%0\"", ";", "}", "return", "\"movw %1,%0\"", ";", "case", "QImode", ":", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST_INT", ")", "{", "int", "i", "=", "INTVAL", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "i", "==", "0", ")", "return", "\"clrb %0\"", ";", "else", "if", "(", "(", "unsigned", "int", ")", "~", "i", "<", "64", ")", "return", "\"mcomb %B1,%0\"", ";", "}", "return", "\"movb %1,%0\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Output", "integer", "move", "instructions", "." ]

[ "vax", "1", "1", "0", "\"pushab %a1\"", "\"movab %a1,%0\"", "1", "\"clrl %0\"", "1", "1", "64", "1", "64", "\"mcoml %N1,%0\"", "0x100", "\"movzbl %1,%0\"", "0x80", "0", "\"cvtbl %1,%0\"", "0x10000", "\"movzwl %1,%0\"", "0x8000", "0", "\"cvtwl %1,%0\"", "0", "\"pushl %1\"", "\"movl %1,%0\"", "1", "1", "0", "\"clrw %0\"", "64", "\"movw %1,%0\"", "64", "\"mcomw %H1,%0\"", "256", "\"movzbw %1,%0\"", "\"movw %1,%0\"", "1", "1", "0", "\"clrb %0\"", "64", "\"mcomb %B1,%0\"", "\"movb %1,%0\"" ]

[]

[ "<s>", "int", "mips_class_max_nregs", "(", "enum", "reg_class", "rclass", ",", "machine_mode", "mode", ")", "{", "int", "size", ";", "HARD_REG_SET", "left", ";", "size", "=", "0x8000", ";", "left", "=", "reg_class_contents", "[", "rclass", "]", ";", "if", "(", "hard_reg_set_intersect_p", "(", "left", ",", "reg_class_contents", "[", "(", "int", ")", "ST_REGS", "]", ")", ")", "{", "if", "(", "mips_hard_regno_mode_ok", "(", "ST_REG_FIRST", ",", "mode", ")", ")", "size", "=", "MIN", "(", "size", ",", "4", ")", ";", "left", "&=", "~", "reg_class_contents", "[", "ST_REGS", "]", ";", "}", "if", "(", "hard_reg_set_intersect_p", "(", "left", ",", "reg_class_contents", "[", "(", "int", ")", "FP_REGS", "]", ")", ")", "{", "if", "(", "mips_hard_regno_mode_ok", "(", "FP_REG_FIRST", ",", "mode", ")", ")", "{", "if", "(", "MSA_SUPPORTED_MODE_P", "(", "mode", ")", ")", "size", "=", "MIN", "(", "size", ",", "UNITS_PER_MSA_REG", ")", ";", "else", "size", "=", "MIN", "(", "size", ",", "UNITS_PER_FPREG", ")", ";", "}", "left", "&=", "~", "reg_class_contents", "[", "FP_REGS", "]", ";", "}", "if", "(", "!", "hard_reg_set_empty_p", "(", "left", ")", ")", "size", "=", "MIN", "(", "size", ",", "UNITS_PER_WORD", ")", ";", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "size", "-", "1", ")", "/", "size", ";", "}", "</s>" ]

[ "Implement", "CLASS_MAX_NREGS", ".", "Usually", "all", "registers", "are", "word-sized", ".", "The", "only", "supported", "exception", "is", "-mgp64", "-msingle-float", ",", "which", "has", "64-bit", "words", "but", "32-bit", "float", "registers", ".", "A", "word-based", "calculation", "is", "correct", "even", "in", "that", "case", ",", "since", "-msingle-float", "disallows", "multi-FPR", "values", ".", "The", "FP", "status", "registers", "are", "an", "exception", "to", "this", "rule", ".", "They", "are", "always", "4", "bytes", "wide", "as", "they", "only", "hold", "condition", "code", "modes", ",", "and", "CCmode", "is", "always", "considered", "to", "be", "4", "bytes", "wide", "." ]

[ "mips", "0x8000", "4", "1" ]

[]

[ "<s>", "static", "void", "x86_print_call_or_nop", "(", "FILE", "*", "file", ",", "const", "char", "*", "target", ")", "{", "if", "(", "flag_nop_mcount", ")", "fprintf", "(", "file", ",", "\"1:\\tnopl 0x00(%%eax,%%eax,1)\\n\"", ")", ";", "else", "fprintf", "(", "file", ",", "\"1:\\tcall\\t%s\\n\"", ",", "target", ")", ";", "}", "</s>" ]

[ "Print", "call", "to", "TARGET", "to", "FILE", "." ]

[ "i386", "\"1:\\tnopl 0x00(%%eax,%%eax,1)\\n\"", "\"1:\\tcall\\t%s\\n\"" ]

[]

[ "<s>", "const", "char", "*", "mips_output_jump", "(", "rtx", "*", "operands", ",", "int", "target_opno", ",", "int", "size_opno", ",", "bool", "link_p", ")", "{", "static", "char", "buffer", "[", "300", "]", ";", "char", "*", "s", "=", "buffer", ";", "bool", "reg_p", "=", "REG_P", "(", "operands", "[", "target_opno", "]", ")", ";", "const", "char", "*", "and_link", "=", "link_p", "?", "\"al\"", ":", "\"\"", ";", "const", "char", "*", "reg", "=", "reg_p", "?", "\"r\"", ":", "\"\"", ";", "const", "char", "*", "compact", "=", "\"\"", ";", "const", "char", "*", "nop", "=", "\"%/\"", ";", "const", "char", "*", "short_delay", "=", "link_p", "?", "\"%!\"", ":", "\"\"", ";", "const", "char", "*", "insn_name", "=", "TARGET_CB_NEVER", "||", "reg_p", "?", "\"j\"", ":", "\"b\"", ";", "if", "(", "!", "final_sequence", "&&", "(", "TARGET_CB_MAYBE", "||", "(", "ISA_HAS_JRC", "&&", "!", "link_p", "&&", "reg_p", ")", ")", ")", "{", "compact", "=", "\"c\"", ";", "nop", "=", "\"\"", ";", "}", "if", "(", "TARGET_USE_GOT", "&&", "!", "TARGET_EXPLICIT_RELOCS", ")", "sprintf", "(", "s", ",", "\"%%*%s%s\\t%%%d%%/\"", ",", "insn_name", ",", "and_link", ",", "target_opno", ")", ";", "else", "{", "if", "(", "!", "reg_p", "&&", "TARGET_ABICALLS_PIC2", ")", "s", "+=", "sprintf", "(", "s", ",", "\".option\\tpic0\\n\\t\"", ")", ";", "if", "(", "reg_p", "&&", "mips_get_pic_call_symbol", "(", "operands", ",", "size_opno", ")", ")", "{", "s", "+=", "sprintf", "(", "s", ",", "\"%%*.reloc\\t1f,R_MIPS_JALR,%%%d\\n1:\\t\"", ",", "size_opno", ")", ";", "short_delay", "=", "\"\"", ";", "}", "else", "s", "+=", "sprintf", "(", "s", ",", "\"%%*\"", ")", ";", "s", "+=", "sprintf", "(", "s", ",", "\"%s%s%s%s%s\\t%%%d%s\"", ",", "insn_name", ",", "and_link", ",", "reg", ",", "compact", ",", "short_delay", ",", "target_opno", ",", "nop", ")", ";", "if", "(", "!", "reg_p", "&&", "TARGET_ABICALLS_PIC2", ")", "s", "+=", "sprintf", "(", "s", ",", "\"\\n\\t.option\\tpic2\"", ")", ";", "}", "return", "buffer", ";", "}", "</s>" ]

[ "Return", "the", "asm", "template", "for", "a", "call", ".", "OPERANDS", "are", "the", "operands", ",", "TARGET_OPNO", "is", "the", "operand", "number", "of", "the", "target", ".", "SIZE_OPNO", "is", "the", "operand", "number", "of", "the", "argument", "size", "operand", "that", "can", "optionally", "hold", "the", "call", "attributes", ".", "If", "SIZE_OPNO", "is", "not", "-1", "and", "the", "call", "is", "indirect", ",", "use", "the", "function", "symbol", "from", "the", "call", "attributes", "to", "attach", "a", "R_MIPS_JALR", "relocation", "to", "the", "call", ".", "LINK_P", "indicates", "whether", "the", "jump", "is", "a", "call", "and", "needs", "to", "set", "the", "link", "register", ".", "When", "generating", "GOT", "code", "without", "explicit", "relocation", "operators", ",", "all", "calls", "should", "use", "assembly", "macros", ".", "Otherwise", ",", "all", "indirect", "calls", "should", "use", "``", "jr", "''", "or", "``", "jalr", "''", ";", "we", "will", "arrange", "to", "restore", "$", "gp", "afterwards", "if", "necessary", ".", "Finally", ",", "we", "can", "only", "generate", "direct", "calls", "for", "-mabicalls", "by", "temporarily", "switching", "to", "non-PIC", "mode", ".", "For", "microMIPS", "jal", "(", "r", ")", ",", "we", "try", "to", "generate", "jal", "(", "r", ")", "s", "when", "a", "16-bit", "instruction", "is", "in", "the", "delay", "slot", "of", "jal", "(", "r", ")", ".", "Where", "compact", "branches", "are", "available", ",", "we", "try", "to", "use", "them", "if", "the", "delay", "slot", "has", "a", "NOP", "(", "or", "equivalently", "delay", "slots", "were", "not", "enabled", "for", "the", "instruction", "anyway", ")", "." ]

[ "mips", "300", "\"al\"", "\"\"", "\"r\"", "\"\"", "\"\"", "\"%/\"", "\"%!\"", "\"\"", "\"j\"", "\"b\"", "\"c\"", "\"\"", "\"%%*%s%s\\t%%%d%%/\"", "\".option\\tpic0\\n\\t\"", "\"%%*.reloc\\t1f,R_MIPS_JALR,%%%d\\n1:\\t\"", "\"\"", "\"%%*\"", "\"%s%s%s%s%s\\t%%%d%s\"", "\"\\n\\t.option\\tpic2\"" ]

[]

[ "<s>", "int", "direct_return", "(", "void", ")", "{", "if", "(", "reload_completed", ")", "{", "rs6000_stack_t", "*", "info", "=", "rs6000_stack_info", "(", ")", ";", "if", "(", "info", "->", "first_gp_reg_save", "==", "32", "&&", "info", "->", "first_fp_reg_save", "==", "64", "&&", "info", "->", "first_altivec_reg_save", "==", "LAST_ALTIVEC_REGNO", "+", "1", "&&", "!", "info", "->", "lr_save_p", "&&", "!", "info", "->", "cr_save_p", "&&", "info", "->", "vrsave_size", "==", "0", "&&", "!", "info", "->", "push_p", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "this", "function", "is", "known", "to", "have", "a", "null", "epilogue", "." ]

[ "rs6000", "32", "64", "1", "0", "1", "0" ]

[]

[ "<s>", "rtx", "nvptx_expand_compare", "(", "rtx", "compare", ")", "{", "rtx", "pred", "=", "gen_reg_rtx", "(", "BImode", ")", ";", "rtx", "cmp", "=", "gen_rtx_fmt_ee", "(", "GET_CODE", "(", "compare", ")", ",", "BImode", ",", "XEXP", "(", "compare", ",", "0", ")", ",", "XEXP", "(", "compare", ",", "1", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "pred", ",", "cmp", ")", ")", ";", "return", "gen_rtx_NE", "(", "BImode", ",", "pred", ",", "const0_rtx", ")", ";", "}", "</s>" ]

[ "Emit", "a", "comparison", "COMPARE", ",", "and", "return", "the", "new", "test", "to", "be", "used", "in", "the", "jump", "." ]

[ "nvptx", "0", "1" ]

[]

[ "<s>", "bool", "ix86_match_ccmode", "(", "rtx", "insn", ",", "machine_mode", "req_mode", ")", "{", "rtx", "set", ";", "machine_mode", "set_mode", ";", "set", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "set", ")", "==", "PARALLEL", ")", "set", "=", "XVECEXP", "(", "set", ",", "0", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "set", ")", "==", "SET", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "COMPARE", ")", ";", "set_mode", "=", "GET_MODE", "(", "SET_DEST", "(", "set", ")", ")", ";", "switch", "(", "set_mode", ")", "{", "case", "CCNOmode", ":", "if", "(", "req_mode", "!=", "CCNOmode", "&&", "(", "req_mode", "!=", "CCmode", "||", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", "!=", "const0_rtx", ")", ")", "return", "false", ";", "break", ";", "case", "CCmode", ":", "if", "(", "req_mode", "==", "CCGCmode", ")", "return", "false", ";", "case", "CCGCmode", ":", "if", "(", "req_mode", "==", "CCGOCmode", "||", "req_mode", "==", "CCNOmode", ")", "return", "false", ";", "case", "CCGOCmode", ":", "if", "(", "req_mode", "==", "CCZmode", ")", "return", "false", ";", "case", "CCZmode", ":", "break", ";", "case", "CCAmode", ":", "case", "CCCmode", ":", "case", "CCOmode", ":", "case", "CCSmode", ":", "if", "(", "set_mode", "!=", "req_mode", ")", "return", "false", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "GET_MODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "set_mode", ";", "}", "</s>" ]

[ "Return", "TRUE", "or", "FALSE", "depending", "on", "whether", "the", "first", "SET", "in", "INSN", "has", "source", "and", "destination", "with", "matching", "CC", "modes", ",", "and", "that", "the", "CC", "mode", "is", "at", "least", "as", "constrained", "as", "REQ_MODE", "." ]

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

[]

[ "<s>", "static", "rtx", "altivec_expand_vec_set_builtin", "(", "tree", "arglist", ")", "{", "enum", "machine_mode", "tmode", ",", "mode1", ";", "tree", "arg0", ",", "arg1", ",", "arg2", ";", "int", "elt", ";", "rtx", "op0", ",", "op1", ";", "arg0", "=", "TREE_VALUE", "(", "arglist", ")", ";", "arg1", "=", "TREE_VALUE", "(", "TREE_CHAIN", "(", "arglist", ")", ")", ";", "arg2", "=", "TREE_VALUE", "(", "TREE_CHAIN", "(", "TREE_CHAIN", "(", "arglist", ")", ")", ")", ";", "tmode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "arg0", ")", ")", ";", "mode1", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "arg0", ")", ")", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "tmode", ")", ")", ";", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "tmode", ",", "0", ")", ";", "op1", "=", "expand_expr", "(", "arg1", ",", "NULL_RTX", ",", "mode1", ",", "0", ")", ";", "elt", "=", "get_element_number", "(", "TREE_TYPE", "(", "arg0", ")", ",", "arg2", ")", ";", "if", "(", "GET_MODE", "(", "op1", ")", "!=", "mode1", "&&", "GET_MODE", "(", "op1", ")", "!=", "VOIDmode", ")", "op1", "=", "convert_modes", "(", "mode1", ",", "GET_MODE", "(", "op1", ")", ",", "op1", ",", "true", ")", ";", "op0", "=", "force_reg", "(", "tmode", ",", "op0", ")", ";", "op1", "=", "force_reg", "(", "mode1", ",", "op1", ")", ";", "rs6000_expand_vector_set", "(", "op0", ",", "op1", ",", "elt", ")", ";", "return", "op0", ";", "}", "</s>" ]

[ "Expand", "vec_set", "builtin", "." ]

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

[]

[ "<s>", "void", "MipsSEInstrInfo", "::", "adjustStackPtr", "(", "unsigned", "SP", ",", "int64_t", "Amount", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "MipsSubtarget", "&", "STI", "=", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "DebugLoc", "DL", "=", "I", "!=", "MBB", ".", "end", "(", ")", "?", "I", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "unsigned", "ADDu", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "DADDu", ":", "Mips", "::", "ADDu", ";", "unsigned", "ADDiu", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "DADDiu", ":", "Mips", "::", "ADDiu", ";", "if", "(", "isInt", "<", "16", ">", "(", "Amount", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ADDiu", ")", ",", "SP", ")", ".", "addReg", "(", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "else", "{", "MBB", ".", "getParent", "(", ")", "->", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", "->", "setEmitNOAT", "(", ")", ";", "unsigned", "Reg", "=", "loadImmediate", "(", "Amount", ",", "MBB", ",", "I", ",", "DL", ",", "0", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ADDu", ")", ",", "SP", ")", ".", "addReg", "(", "SP", ")", ".", "addReg", "(", "Reg", ")", ";", "}", "}", "</s>" ]

[ "Adjust", "SP", "by", "Amount", "bytes", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips::DADDu", "Mips::ADDu", "Mips::DADDiu", "Mips::ADDiu", "16", "Mips", "0" ]

[]

[ "<s>", "int", "riscv_const_insns", "(", "rtx", "x", ")", "{", "enum", "riscv_symbol_type", "symbol_type", ";", "rtx", "offset", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "HIGH", ":", "if", "(", "!", "riscv_symbolic_constant_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "&", "symbol_type", ")", "||", "!", "riscv_split_symbol_type", "(", "symbol_type", ")", ")", "return", "0", ";", "return", "1", ";", "case", "CONST_INT", ":", "{", "int", "cost", "=", "riscv_integer_cost", "(", "INTVAL", "(", "x", ")", ")", ";", "return", "cost", "<", "4", "?", "cost", ":", "0", ";", "}", "case", "CONST_DOUBLE", ":", "case", "CONST_VECTOR", ":", "return", "x", "==", "CONST0_RTX", "(", "GET_MODE", "(", "x", ")", ")", "?", "1", ":", "0", ";", "case", "CONST", ":", "if", "(", "riscv_symbolic_constant_p", "(", "x", ",", "&", "symbol_type", ")", ")", "return", "riscv_symbol_insns", "(", "symbol_type", ")", ";", "split_const", "(", "x", ",", "&", "x", ",", "&", "offset", ")", ";", "if", "(", "offset", "!=", "0", ")", "{", "int", "n", "=", "riscv_const_insns", "(", "x", ")", ";", "if", "(", "n", "!=", "0", ")", "return", "n", "+", "riscv_integer_cost", "(", "INTVAL", "(", "offset", ")", ")", ";", "}", "return", "0", ";", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "return", "riscv_symbol_insns", "(", "riscv_classify_symbol", "(", "x", ")", ")", ";", "case", "CONST_POLY_INT", ":", "return", "4", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "needed", "to", "load", "constant", "X", ".", "Return", "0", "if", "X", "is", "n't", "a", "valid", "constant", "." ]

[ "riscv", "0", "0", "1", "4", "0", "1", "0", "0", "0", "0", "4", "0" ]

[]

[ "<s>", "PatmosTargetLowering", "::", "ConstraintType", "PatmosTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'R'", ":", "case", "'S'", ":", "case", "'P'", ":", "return", "C_RegisterClass", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "Patmos", "1", "0" ]

[]

[ "<s>", "void", "ARMBaseRegisterInfo", "::", "emitLoadConstPool", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "DebugLoc", "dl", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "int", "Val", ",", "ARMCC", "::", "CondCodes", "Pred", ",", "unsigned", "PredReg", ",", "unsigned", "MIFlags", ")", "const", "{", "assert", "(", "!", "FlagSfiDisableCP", "&&", "\"unexpected call to emitLoadConstPool\"", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineConstantPool", "*", "ConstantPool", "=", "MF", ".", "getConstantPool", "(", ")", ";", "const", "Constant", "*", "C", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "MF", ".", "getFunction", "(", ")", "->", "getContext", "(", ")", ")", ",", "Val", ")", ";", "unsigned", "Idx", "=", "ConstantPool", "->", "getConstantPoolIndex", "(", "C", ",", "4", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "LDRcp", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ",", "SubIdx", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "Pred", ")", ".", "addReg", "(", "PredReg", ")", ".", "setMIFlags", "(", "MIFlags", ")", ";", "}", "</s>" ]

[ "emitLoadConstPool", "-", "Emits", "a", "load", "from", "constpool", "to", "materialize", "the", "specified", "immediate", "." ]

[ "ARM", "ARM", "ARMCC::CondCodes", "\"unexpected call to emitLoadConstPool\"", "4", "ARM::LDRcp", "0" ]

[]

[ "<s>", "Register", "MCS51RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "return", "MCS51", "::", "R28", ";", "}", "return", "MCS51", "::", "SP", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "MCS51", "MCS51", "MCS51::R28", "MCS51::SP" ]

[]

[ "<s>", "MachineInstr", "*", "ARMBaseInstrInfo", "::", "duplicate", "(", "MachineInstr", "&", "Orig", ",", "MachineFunction", "&", "MF", ")", "const", "{", "MachineInstr", "*", "MI", "=", "TargetInstrInfo", "::", "duplicate", "(", "Orig", ",", "MF", ")", ";", "switch", "(", "Orig", ".", "getOpcode", "(", ")", ")", "{", "case", "ARM", "::", "tLDRpci_pic", ":", "case", "ARM", "::", "t2LDRpci_pic", ":", "{", "unsigned", "CPI", "=", "Orig", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "unsigned", "PCLabelId", "=", "duplicateCPV", "(", "MF", ",", "CPI", ")", ";", "Orig", ".", "getOperand", "(", "1", ")", ".", "setIndex", "(", "CPI", ")", ";", "Orig", ".", "getOperand", "(", "2", ")", ".", "setImm", "(", "PCLabelId", ")", ";", "break", ";", "}", "}", "return", "MI", ";", "}", "</s>" ]

[ "Clones", "instruction", "or", "the", "whole", "instruction", "bundle", "Orig", "and", "insert", "into", "MBB", "before", "InsertBefore", "." ]

[ "ARM", "ARM", "ARM::tLDRpci_pic", "ARM::t2LDRpci_pic", "1", "1", "2" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "X86InstrInfo", "::", "decomposeMachineOperandsTargetFlags", "(", "unsigned", "TF", ")", "const", "{", "return", "std", "::", "make_pair", "(", "TF", ",", "0u", ")", ";", "}", "</s>" ]

[ "Decompose", "the", "machine", "operand", "'s", "target", "flags", "into", "two", "values", "-", "the", "direct", "target", "flag", "value", "and", "any", "of", "bit", "flags", "that", "are", "applied", "." ]

[ "X86", "X86", "0u" ]

[]

[ "<s>", "MCFragment", "*", "Z80BrCCMCExpr", "::", "findAssociatedFragment", "(", ")", "const", "{", "return", "nullptr", ";", "}", "</s>" ]

[ "Find", "the", "``", "associated", "section", "''", "for", "this", "expression", ",", "which", "is", "currently", "defined", "as", "the", "absolute", "section", "for", "constants", ",", "or", "otherwise", "the", "section", "associated", "with", "the", "first", "defined", "symbol", "in", "the", "expression", "." ]

[ "Z80", "Z80" ]

[]

[ "<s>", "DLXSubtarget", "&", "DLXSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "initSubtargetFeatures", "(", "CPU", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

[ "DLX", "DLX", "DLX" ]

[]

[ "<s>", "void", "MipsInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ")", "{", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "writeNopData", "(", "uint64_t", ",", "MCObjectWriter", "*", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "bool", "MBlazeFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "rounded_frame_size", "(", "int", "pushed", ")", "{", "HOST_WIDE_INT", "size", "=", "get_frame_size", "(", ")", ";", "HOST_WIDE_INT", "align", "=", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ";", "if", "(", "ACCUMULATE_OUTGOING_ARGS", ")", "size", "+=", "crtl", "->", "outgoing_args_size", ";", "return", "(", "(", "size", "+", "pushed", "+", "align", "-", "1", ")", "&", "-", "align", ")", "-", "pushed", ";", "}", "</s>" ]

[ "PUSHED", "is", "the", "number", "of", "bytes", "that", "are", "bing", "pushed", "on", "the", "stack", "for", "register", "saves", ".", "Return", "the", "frame", "size", ",", "padded", "appropriately", "so", "that", "the", "stack", "stays", "properly", "aligned", "." ]

[ "sh", "1" ]

[]

[ "<s>", "static", "void", "ix86_autovectorize_vector_sizes", "(", "vector_sizes", "*", "sizes", ")", "{", "if", "(", "TARGET_AVX512F", "&&", "!", "TARGET_PREFER_AVX256", ")", "{", "sizes", "->", "safe_push", "(", "64", ")", ";", "sizes", "->", "safe_push", "(", "32", ")", ";", "sizes", "->", "safe_push", "(", "16", ")", ";", "}", "else", "if", "(", "TARGET_AVX", "&&", "!", "TARGET_PREFER_AVX128", ")", "{", "sizes", "->", "safe_push", "(", "32", ")", ";", "sizes", "->", "safe_push", "(", "16", ")", ";", "}", "}", "</s>" ]

[ "If", "AVX", "is", "enabled", "then", "try", "vectorizing", "with", "both", "256bit", "and", "128bit", "vectors", ".", "If", "AVX512F", "is", "enabled", "then", "try", "vectorizing", "with", "512bit", ",", "256bit", "and", "128bit", "vectors", "." ]

[ "i386", "64", "32", "16", "32", "16" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI Load Store Optimizer\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"SI Load Store Optimizer\"" ]

[]

[ "<s>", "void", "BlackfinInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "I", "!=", "MBB", ".", "end", "(", ")", "?", "I", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "if", "(", "inClass", "(", "BF", "::", "DPRegClass", ",", "SrcReg", ",", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BF", "::", "STORE32fi", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "if", "(", "inClass", "(", "BF", "::", "D16RegClass", ",", "SrcReg", ",", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BF", "::", "STORE16fi", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "if", "(", "inClass", "(", "BF", "::", "AnyCCRegClass", ",", "SrcReg", ",", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BF", "::", "STORE8fi", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "llvm_unreachable", "(", "(", "std", "::", "string", "(", "\"Cannot store regclass to stack slot: \"", ")", "+", "RC", "->", "getName", "(", ")", ")", ".", "c_str", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Blackfin", "BF::DPRegClass", "BF::STORE32fi", "0", "BF::D16RegClass", "BF::STORE16fi", "0", "BF::AnyCCRegClass", "BF::STORE8fi", "0", "\"Cannot store regclass to stack slot: \"" ]

[]

[ "<s>", "bool", "NEONMoveFixPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "ARMFunctionInfo", "*", "AFI", "=", "Fn", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "const", "TargetMachine", "&", "TM", "=", "Fn", ".", "getTarget", "(", ")", ";", "if", "(", "AFI", "->", "isThumb1OnlyFunction", "(", ")", ")", "return", "false", ";", "TRI", "=", "TM", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "TM", ".", "getInstrInfo", "(", ")", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "Fn", ".", "begin", "(", ")", ",", "E", "=", "Fn", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MFI", ";", "Modified", "|=", "InsertMoves", "(", "MBB", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "Emitter", "<", "CodeEmitter", ">", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MMI", "=", "&", "getAnalysis", "<", "MachineModuleInfo", ">", "(", ")", ";", "MCE", ".", "setModuleInfo", "(", "MMI", ")", ";", "II", "=", "TM", ".", "getInstrInfo", "(", ")", ";", "TD", "=", "TM", ".", "getTargetData", "(", ")", ";", "Is64BitMode", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ";", "IsPIC", "=", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ";", "do", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"JITTing function '\"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"'\\n\"", ")", ";", "MCE", ".", "startFunction", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MBB", "!=", "E", ";", "++", "MBB", ")", "{", "MCE", ".", "StartMachineBasicBlock", "(", "MBB", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", "->", "begin", "(", ")", ",", "E", "=", "MBB", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "const", "MCInstrDesc", "&", "Desc", "=", "I", "->", "getDesc", "(", ")", ";", "emitInstruction", "(", "*", "I", ",", "&", "Desc", ")", ";", "if", "(", "Desc", ".", "getOpcode", "(", ")", "==", "X86", "::", "MOVPC32r", ")", "emitInstruction", "(", "*", "I", ",", "&", "II", "->", "get", "(", "X86", "::", "POP32r", ")", ")", ";", "++", "NumEmitted", ";", "}", "}", "}", "while", "(", "MCE", ".", "finishFunction", "(", "MF", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"JITTing function '\"", "\"'\\n\"", "X86::MOVPC32r", "X86::POP32r" ]

[]

[ "<s>", "static", "void", "visium_setup_incoming_varargs", "(", "cumulative_args_t", "pcum_v", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", "pretend_size", "ATTRIBUTE_UNUSED", ",", "int", "no_rtl", ")", "{", "cumulative_args_t", "local_args_so_far", ";", "CUMULATIVE_ARGS", "local_copy", ";", "CUMULATIVE_ARGS", "*", "locargs", ";", "int", "gp_saved", ",", "fp_saved", ",", "size", ";", "local_args_so_far", ".", "p", "=", "&", "local_copy", ";", "locargs", "=", "get_cumulative_args", "(", "pcum_v", ")", ";", "local_args_so_far", ".", "magic", "=", "CUMULATIVE_ARGS_MAGIC", ";", "local_copy", ".", "grcount", "=", "locargs", "->", "grcount", ";", "local_copy", ".", "frcount", "=", "locargs", "->", "frcount", ";", "local_copy", ".", "stack_words", "=", "locargs", "->", "stack_words", ";", "TARGET_FUNCTION_ARG_ADVANCE", "(", "local_args_so_far", ",", "mode", ",", "type", ",", "1", ")", ";", "locargs", "=", "get_cumulative_args", "(", "local_args_so_far", ")", ";", "gp_saved", "=", "MAX_ARGS_IN_GP_REGISTERS", "-", "locargs", "->", "grcount", ";", "fp_saved", "=", "(", "TARGET_FPU", "?", "MAX_ARGS_IN_FP_REGISTERS", "-", "locargs", "->", "frcount", ":", "0", ")", ";", "size", "=", "(", "gp_saved", "*", "UNITS_PER_WORD", ")", "+", "(", "fp_saved", "*", "UNITS_PER_HWFPVALUE", ")", ";", "if", "(", "!", "no_rtl", "&&", "size", ">", "0", ")", "{", "rtx", "ptr", "=", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "-", "size", ")", ")", ";", "if", "(", "gp_saved", ">", "0", ")", "{", "rtx", "mem", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "Pmode", ",", "ptr", ",", "fp_saved", "*", "UNITS_PER_HWFPVALUE", ")", ")", ";", "MEM_NOTRAP_P", "(", "mem", ")", "=", "1", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "move_block_from_reg", "(", "locargs", "->", "grcount", "+", "GP_ARG_FIRST", ",", "mem", ",", "gp_saved", ")", ";", "}", "if", "(", "fp_saved", ">", "0", ")", "{", "rtx", "mem", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "ptr", ")", ";", "MEM_NOTRAP_P", "(", "mem", ")", "=", "1", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "gcc_assert", "(", "UNITS_PER_WORD", "==", "UNITS_PER_HWFPVALUE", ")", ";", "move_block_from_reg", "(", "locargs", "->", "frcount", "+", "FP_ARG_FIRST", ",", "mem", ",", "fp_saved", ")", ";", "}", "}", "visium_reg_parm_save_area_size", "=", "size", ";", "}", "</s>" ]

[ "Store", "the", "anonymous", "register", "arguments", "into", "the", "stack", "so", "that", "all", "the", "arguments", "appear", "to", "have", "been", "passed", "consecutively", "on", "the", "stack", "." ]

[ "visium", "1", "0", "0", "0", "1", "0", "1" ]

[]

[ "<s>", "static", "void", "aarch64_expand_builtin_va_start", "(", "tree", "valist", ",", "rtx", "nextarg", "ATTRIBUTE_UNUSED", ")", "{", "const", "CUMULATIVE_ARGS", "*", "cum", ";", "tree", "f_stack", ",", "f_grtop", ",", "f_vrtop", ",", "f_groff", ",", "f_vroff", ";", "tree", "stack", ",", "grtop", ",", "vrtop", ",", "groff", ",", "vroff", ";", "tree", "t", ";", "int", "gr_save_area_size", ";", "int", "vr_save_area_size", ";", "int", "vr_offset", ";", "cum", "=", "&", "crtl", "->", "args", ".", "info", ";", "gr_save_area_size", "=", "(", "NUM_ARG_REGS", "-", "cum", "->", "aapcs_ncrn", ")", "*", "UNITS_PER_WORD", ";", "vr_save_area_size", "=", "(", "NUM_FP_ARG_REGS", "-", "cum", "->", "aapcs_nvrn", ")", "*", "UNITS_PER_VREG", ";", "if", "(", "TARGET_GENERAL_REGS_ONLY", ")", "{", "if", "(", "cum", "->", "aapcs_nvrn", ">", "0", ")", "sorry", "(", "\"%qs and floating point or vector arguments\"", ",", "\"-mgeneral-regs-only\"", ")", ";", "vr_save_area_size", "=", "0", ";", "}", "f_stack", "=", "TYPE_FIELDS", "(", "va_list_type_node", ")", ";", "f_grtop", "=", "DECL_CHAIN", "(", "f_stack", ")", ";", "f_vrtop", "=", "DECL_CHAIN", "(", "f_grtop", ")", ";", "f_groff", "=", "DECL_CHAIN", "(", "f_vrtop", ")", ";", "f_vroff", "=", "DECL_CHAIN", "(", "f_groff", ")", ";", "stack", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_stack", ")", ",", "valist", ",", "f_stack", ",", "NULL_TREE", ")", ";", "grtop", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_grtop", ")", ",", "valist", ",", "f_grtop", ",", "NULL_TREE", ")", ";", "vrtop", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_vrtop", ")", ",", "valist", ",", "f_vrtop", ",", "NULL_TREE", ")", ";", "groff", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_groff", ")", ",", "valist", ",", "f_groff", ",", "NULL_TREE", ")", ";", "vroff", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_vroff", ")", ",", "valist", ",", "f_vroff", ",", "NULL_TREE", ")", ";", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "stack", ")", ",", "virtual_incoming_args_rtx", ")", ";", "if", "(", "cum", "->", "aapcs_stack_size", ">", "0", ")", "t", "=", "fold_build_pointer_plus_hwi", "(", "t", ",", "cum", "->", "aapcs_stack_size", "*", "UNITS_PER_WORD", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "stack", ")", ",", "stack", ",", "t", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "grtop", ")", ",", "virtual_incoming_args_rtx", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "grtop", ")", ",", "grtop", ",", "t", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "vrtop", ")", ",", "virtual_incoming_args_rtx", ")", ";", "vr_offset", "=", "AARCH64_ROUND_UP", "(", "gr_save_area_size", ",", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ";", "if", "(", "vr_offset", ")", "t", "=", "fold_build_pointer_plus_hwi", "(", "t", ",", "-", "vr_offset", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "vrtop", ")", ",", "vrtop", ",", "t", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "groff", ")", ",", "groff", ",", "build_int_cst", "(", "TREE_TYPE", "(", "groff", ")", ",", "-", "gr_save_area_size", ")", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "vroff", ")", ",", "vroff", ",", "build_int_cst", "(", "TREE_TYPE", "(", "vroff", ")", ",", "-", "vr_save_area_size", ")", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_EXPAND_BUILTIN_VA_START", "." ]

[ "aarch64", "0", "\"%qs and floating point or vector arguments\"", "\"-mgeneral-regs-only\"", "0", "0" ]

[]

[ "<s>", "bool", "SPUTargetLowering", "::", "isLegalICmpImmediate", "(", "int64_t", "Imm", ")", "const", "{", "return", "isInt", "<", "10", ">", "(", "Imm", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "immediate", "is", "legal", "icmp", "immediate", ",", "that", "is", "the", "target", "has", "icmp", "instructions", "which", "can", "compare", "a", "register", "against", "the", "immediate", "without", "having", "to", "materialize", "the", "immediate", "into", "a", "register", "." ]

[ "CellSPU", "SPU", "10" ]

[]

[ "<s>", "static", "SDValue", "getTargetNode", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ",", "unsigned", "Flag", ")", "{", "EVT", "Ty", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "GlobalAddressSDNode", "*", "N", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Op", ")", ")", "return", "DAG", ".", "getTargetGlobalAddress", "(", "N", "->", "getGlobal", "(", ")", ",", "Op", ".", "getDebugLoc", "(", ")", ",", "Ty", ",", "0", ",", "Flag", ")", ";", "if", "(", "ExternalSymbolSDNode", "*", "N", "=", "dyn_cast", "<", "ExternalSymbolSDNode", ">", "(", "Op", ")", ")", "return", "DAG", ".", "getTargetExternalSymbol", "(", "N", "->", "getSymbol", "(", ")", ",", "Ty", ",", "Flag", ")", ";", "if", "(", "BlockAddressSDNode", "*", "N", "=", "dyn_cast", "<", "BlockAddressSDNode", ">", "(", "Op", ")", ")", "return", "DAG", ".", "getTargetBlockAddress", "(", "N", "->", "getBlockAddress", "(", ")", ",", "Ty", ",", "0", ",", "Flag", ")", ";", "if", "(", "JumpTableSDNode", "*", "N", "=", "dyn_cast", "<", "JumpTableSDNode", ">", "(", "Op", ")", ")", "return", "DAG", ".", "getTargetJumpTable", "(", "N", "->", "getIndex", "(", ")", ",", "Ty", ",", "Flag", ")", ";", "if", "(", "ConstantPoolSDNode", "*", "N", "=", "dyn_cast", "<", "ConstantPoolSDNode", ">", "(", "Op", ")", ")", "return", "DAG", ".", "getTargetConstantPool", "(", "N", "->", "getConstVal", "(", ")", ",", "Ty", ",", "N", "->", "getAlignment", "(", ")", ",", "N", "->", "getOffset", "(", ")", ",", "Flag", ")", ";", "llvm_unreachable", "(", "\"Unexpected node type.\"", ")", ";", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Retrieve", "the", "target", "node", "this", "edge", "connects", "to", "." ]

[ "Cpu0", "0", "0", "\"Unexpected node type.\"" ]

[]

[ "<s>", "int", "aarch64_host_wide_int_compare", "(", "const", "void", "*", "x", ",", "const", "void", "*", "y", ")", "{", "return", "wi", "::", "cmps", "(", "*", "(", "(", "const", "HOST_WIDE_INT", "*", ")", "x", ")", ",", "*", "(", "(", "const", "HOST_WIDE_INT", "*", ")", "y", ")", ")", ";", "}", "</s>" ]

[ "Taking", "X", "and", "Y", "to", "be", "HOST_WIDE_INT", "pointers", ",", "return", "the", "result", "of", "a", "comparison", "between", "the", "two", "." ]

[ "aarch64" ]

[]

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

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

[ "Hexagon", "\"Hexagon Assembly Printer\"" ]

[]

[ "<s>", "MachineBasicBlock", "*", "OR1KTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "(", "Opc", "==", "OR1K", "::", "Select", "||", "Opc", "==", "OR1K", "::", "Selectf32", ")", "&&", "\"Unexpected instr type to insert\"", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "I", "=", "BB", ";", "++", "I", ";", "MachineBasicBlock", "*", "thisMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "copy0MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "copy1MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "F", "->", "insert", "(", "I", ",", "copy0MBB", ")", ";", "F", "->", "insert", "(", "I", ",", "copy1MBB", ")", ";", "copy1MBB", "->", "splice", "(", "copy1MBB", "->", "begin", "(", ")", ",", "BB", ",", "llvm", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "BB", "->", "end", "(", ")", ")", ";", "copy1MBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "BB", ")", ";", "BB", "->", "addSuccessor", "(", "copy0MBB", ")", ";", "BB", "->", "addSuccessor", "(", "copy1MBB", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", ".", "get", "(", "OR1K", "::", "BF", ")", ")", ".", "addMBB", "(", "copy1MBB", ")", ";", "BB", "=", "copy0MBB", ";", "BB", "->", "addSuccessor", "(", "copy1MBB", ")", ";", "BB", "=", "copy1MBB", ";", "BuildMI", "(", "*", "BB", ",", "BB", "->", "begin", "(", ")", ",", "dl", ",", "TII", ".", "get", "(", "OR1K", "::", "PHI", ")", ",", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "copy0MBB", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "thisMBB", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "BB", ";", "}", "</s>" ]

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

[ "OR1K", "OR1K", "OR1K::Select", "OR1K::Selectf32", "\"Unexpected instr type to insert\"", "OR1K::BF", "OR1K::PHI", "0", "2", "1" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerCall", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "SDLoc", "&", "dl", "=", "CLI", ".", "DL", ";", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", "=", "CLI", ".", "Outs", ";", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", "=", "CLI", ".", "OutVals", ";", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "SDValue", "Chain", "=", "CLI", ".", "Chain", ";", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "bool", "&", "isTailCall", "=", "CLI", ".", "IsTailCall", ";", "CallingConv", "::", "ID", "CallConv", "=", "CLI", ".", "CallConv", ";", "bool", "isVarArg", "=", "CLI", ".", "IsVarArg", ";", "if", "(", "isTailCall", ")", "isTailCall", "=", "IsEligibleForTailCallOptimization", "(", "Callee", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "DAG", ")", ";", "if", "(", "!", "isTailCall", "&&", "CLI", ".", "CS", "&&", "CLI", ".", "CS", "->", "isMustTailCall", "(", ")", ")", "report_fatal_error", "(", "\"failed to perform tail call elimination on a call \"", "\"site marked musttail\"", ")", ";", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "LowerCall_64SVR4", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "else", "return", "LowerCall_32SVR4", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "return", "LowerCall_Darwin", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "PowerPC", "PPC", "ISD::OutputArg", "ISD::InputArg", "\"failed to perform tail call elimination on a call \"", "\"site marked musttail\"", "PPC" ]

[]

[ "<s>", "static", "void", "aarch64_set_current_function", "(", "tree", "fndecl", ")", "{", "if", "(", "!", "fndecl", "||", "fndecl", "==", "aarch64_previous_fndecl", ")", "return", ";", "tree", "old_tree", "=", "(", "aarch64_previous_fndecl", "?", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "aarch64_previous_fndecl", ")", ":", "NULL_TREE", ")", ";", "tree", "new_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", ";", "if", "(", "!", "new_tree", "&&", "old_tree", ")", "new_tree", "=", "target_option_default_node", ";", "if", "(", "old_tree", "==", "new_tree", ")", "return", ";", "aarch64_previous_fndecl", "=", "fndecl", ";", "cl_target_option_restore", "(", "&", "global_options", ",", "TREE_TARGET_OPTION", "(", "new_tree", ")", ")", ";", "aarch64_save_restore_target_globals", "(", "new_tree", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_SET_CURRENT_FUNCTION", ".", "Unpack", "the", "codegen", "decisions", "like", "tuning", "and", "ISA", "features", "from", "the", "DECL_FUNCTION_SPECIFIC_TARGET", "of", "the", "function", ",", "if", "such", "exists", ".", "This", "function", "may", "be", "called", "multiple", "times", "on", "a", "single", "function", "so", "use", "aarch64_previous_fndecl", "to", "avoid", "setting", "up", "identical", "state", "." ]

[ "aarch64" ]

[]