Datasets:

docz-ict

/

ComBack

like 1

[ "<s>", "bool", "PIC16Cloner", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "CallGraph", "&", "CG", "=", "getAnalysis", "<", "CallGraph", ">", "(", ")", ";", "CallGraphNode", "*", "mainCGN", "=", "NULL", ",", "*", "isrCGN", "=", "NULL", ";", "for", "(", "CallGraph", "::", "iterator", "it", "=", "CG", ".", "begin", "(", ")", ";", "it", "!=", "CG", ".", "end", "(", ")", ";", "it", "++", ")", "{", "if", "(", "!", "it", "->", "first", ")", "continue", ";", "if", "(", "it", "->", "first", "->", "getName", "(", ")", ".", "str", "(", ")", "==", "\"main\"", ")", "{", "mainCGN", "=", "it", "->", "second", ";", "}", "if", "(", "PAN", "::", "isISR", "(", "it", "->", "first", "->", "getSection", "(", ")", ")", ")", "{", "isrCGN", "=", "it", "->", "second", ";", "}", "if", "(", "mainCGN", "&&", "isrCGN", ")", "break", ";", "}", "if", "(", "!", "mainCGN", "||", "!", "isrCGN", ")", "return", "false", ";", "if", "(", "PAN", "::", "isISR", "(", "mainCGN", "->", "getFunction", "(", ")", "->", "getSection", "(", ")", ")", ")", "{", "reportError", "(", "\"Function 'main' can't be interrupt function\"", ")", ";", "}", "markCallGraph", "(", "mainCGN", ",", "\"ML\"", ")", ";", "cloneSharedFunctions", "(", "isrCGN", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "PIC16", "PIC16", "\"main\"", "\"Function 'main' can't be interrupt function\"", "\"ML\"" ]

[]

[ "<s>", "void", "ARCPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createARCBranchFinalizePass", "(", ")", ")", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "ARC" ]

[]

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

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

[ "TL45", "TL45" ]

[]

[ "<s>", "void", "s390_expand_logical_operator", "(", "enum", "rtx_code", "code", ",", "enum", "machine_mode", "mode", ",", "rtx", "*", "operands", ")", "{", "enum", "machine_mode", "wmode", "=", "mode", ";", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "src1", "=", "operands", "[", "1", "]", ";", "rtx", "src2", "=", "operands", "[", "2", "]", ";", "rtx", "op", ",", "clob", ",", "tem", ";", "if", "(", "!", "s390_logical_operator_ok_p", "(", "operands", ")", ")", "dst", "=", "gen_reg_rtx", "(", "mode", ")", ";", "if", "(", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", "&&", "GET_CODE", "(", "dst", ")", "!=", "MEM", ")", "wmode", "=", "SImode", ";", "if", "(", "mode", "!=", "wmode", ")", "{", "if", "(", "GET_CODE", "(", "dst", ")", "==", "SUBREG", "&&", "(", "tem", "=", "simplify_subreg", "(", "wmode", ",", "dst", ",", "mode", ",", "0", ")", ")", "!=", "0", ")", "dst", "=", "tem", ";", "else", "if", "(", "REG_P", "(", "dst", ")", ")", "dst", "=", "gen_rtx_SUBREG", "(", "wmode", ",", "dst", ",", "0", ")", ";", "else", "dst", "=", "gen_reg_rtx", "(", "wmode", ")", ";", "if", "(", "GET_CODE", "(", "src1", ")", "==", "SUBREG", "&&", "(", "tem", "=", "simplify_subreg", "(", "wmode", ",", "src1", ",", "mode", ",", "0", ")", ")", "!=", "0", ")", "src1", "=", "tem", ";", "else", "if", "(", "GET_MODE", "(", "src1", ")", "!=", "VOIDmode", ")", "src1", "=", "gen_rtx_SUBREG", "(", "wmode", ",", "force_reg", "(", "mode", ",", "src1", ")", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "src2", ")", "==", "SUBREG", "&&", "(", "tem", "=", "simplify_subreg", "(", "wmode", ",", "src2", ",", "mode", ",", "0", ")", ")", "!=", "0", ")", "src2", "=", "tem", ";", "else", "if", "(", "GET_MODE", "(", "src2", ")", "!=", "VOIDmode", ")", "src2", "=", "gen_rtx_SUBREG", "(", "wmode", ",", "force_reg", "(", "mode", ",", "src2", ")", ",", "0", ")", ";", "}", "op", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "dst", ",", "gen_rtx_fmt_ee", "(", "code", ",", "wmode", ",", "src1", ",", "src2", ")", ")", ";", "clob", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "CCmode", ",", "CC_REGNUM", ")", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "op", ",", "clob", ")", ")", ")", ";", "if", "(", "dst", "!=", "operands", "[", "0", "]", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "gen_lowpart", "(", "mode", ",", "dst", ")", ")", ";", "}", "</s>" ]

[ "Expand", "logical", "operator", "CODE", "in", "mode", "MODE", "with", "operands", "OPERANDS", "." ]

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

[]

[ "<s>", "void", "assignValueToAddress", "(", "const", "CallLowering", "::", "ArgInfo", "&", "Arg", ",", "unsigned", "ValRegIndex", ",", "Register", "Addr", ",", "uint64_t", "MemSize", ",", "MachinePointerInfo", "&", "MPO", ",", "CCValAssign", "&", "VA", ")", "override", "{", "Register", "ValVReg", "=", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "LocInfo", "::", "FPExt", "?", "extendRegister", "(", "Arg", ".", "Regs", "[", "ValRegIndex", "]", ",", "VA", ")", ":", "Arg", ".", "Regs", "[", "ValRegIndex", "]", ";", "const", "LLT", "RegTy", "=", "MRI", ".", "getType", "(", "ValVReg", ")", ";", "MemSize", "=", "std", "::", "min", "(", "MemSize", ",", "(", "uint64_t", ")", "RegTy", ".", "getSizeInBytes", "(", ")", ")", ";", "assignValueToAddress", "(", "ValVReg", ",", "Addr", ",", "MemSize", ",", "MPO", ",", "VA", ")", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]

[ "<s>", "int", "store_update_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", "||", "GET_MODE", "(", "op", ")", "!=", "mode", ")", "return", "0", ";", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "PLUS", "||", "GET_MODE", "(", "op", ")", "!=", "Pmode", "||", "!", "register_operand", "(", "XEXP", "(", "op", ",", "0", ")", ",", "Pmode", ")", "||", "!", "(", "GET_CODE", "(", "XEXP", "(", "op", ",", "1", ")", ")", "==", "CONST_INT", "&&", "SMALL_INT", "(", "INTVAL", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "valid", "store", "with", "update", "operand", "." ]

[ "arc", "0", "0", "0", "1", "1", "0", "1" ]

[]

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

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

[ "MINA32" ]

[]

[ "<s>", "SDValue", "PTXTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "if", "(", "isVarArg", ")", "llvm_unreachable", "(", "\"PTX does not support varargs\"", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "PTXMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "PTXMachineFunctionInfo", ">", "(", ")", ";", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "break", ";", "case", "CallingConv", "::", "PTX_Kernel", ":", "MFI", "->", "setKernel", "(", "true", ")", ";", "break", ";", "case", "CallingConv", "::", "PTX_Device", ":", "MFI", "->", "setKernel", "(", "false", ")", ";", "break", ";", "}", "if", "(", "MFI", "->", "isDoneAddArg", "(", ")", ")", "llvm_unreachable", "(", "\"cannot add argument registers twice\"", ")", ";", "for", "(", "struct", "argmap_entry", "*", "i", "=", "argmap", ",", "*", "e", "=", "argmap", "+", "array_lengthof", "(", "argmap", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "i", "->", "reset", "(", ")", ";", "for", "(", "int", "i", "=", "0", ",", "e", "=", "Ins", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MVT", "::", "SimpleValueType", "VT", "=", "Ins", "[", "i", "]", ".", "VT", ".", "SimpleTy", ";", "struct", "argmap_entry", "*", "entry", "=", "std", "::", "find", "(", "argmap", ",", "argmap", "+", "array_lengthof", "(", "argmap", ")", ",", "VT", ")", ";", "if", "(", "entry", "==", "argmap", "+", "array_lengthof", "(", "argmap", ")", ")", "llvm_unreachable", "(", "\"Type of argument is not supported\"", ")", ";", "if", "(", "MFI", "->", "isKernel", "(", ")", "&&", "entry", "->", "RC", "==", "PTX", "::", "PredsRegisterClass", ")", "llvm_unreachable", "(", "\"cannot pass preds to kernel\"", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ";", "unsigned", "preg", "=", "*", "++", "(", "entry", "->", "loc", ")", ";", "unsigned", "vreg", "=", "RegInfo", ".", "createVirtualRegister", "(", "entry", "->", "RC", ")", ";", "RegInfo", ".", "addLiveIn", "(", "preg", ",", "vreg", ")", ";", "MFI", "->", "addArgReg", "(", "preg", ")", ";", "SDValue", "inval", ";", "if", "(", "MFI", "->", "isKernel", "(", ")", ")", "inval", "=", "DAG", ".", "getNode", "(", "PTXISD", "::", "READ_PARAM", ",", "dl", ",", "VT", ",", "Chain", ",", "DAG", ".", "getTargetConstant", "(", "i", ",", "MVT", "::", "i32", ")", ")", ";", "else", "inval", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "vreg", ",", "VT", ")", ";", "InVals", ".", "push_back", "(", "inval", ")", ";", "}", "MFI", "->", "doneAddArg", "(", ")", ";", "return", "Chain", ";", "}", "</s>" ]

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

[ "PTX", "PTX", "ISD::InputArg", "\"PTX does not support varargs\"", "PTX", "PTX", "\"Unsupported calling convention\"", "PTX", "PTX", "\"cannot add argument registers twice\"", "0", "MVT::SimpleValueType", "\"Type of argument is not supported\"", "PTX::PredsRegisterClass", "\"cannot pass preds to kernel\"", "PTXISD::READ_PARAM", "MVT::i32" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "SrcReg2", ",", "int", "&", "Mask", ",", "int", "&", "Value", ")", "const", "{", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "Hexagon", "::", "C2_cmpeqp", ":", "case", "Hexagon", "::", "C2_cmpeqi", ":", "case", "Hexagon", "::", "C2_cmpeq", ":", "case", "Hexagon", "::", "C2_cmpgtp", ":", "case", "Hexagon", "::", "C2_cmpgtup", ":", "case", "Hexagon", "::", "C2_cmpgtui", ":", "case", "Hexagon", "::", "C2_cmpgtu", ":", "case", "Hexagon", "::", "C2_cmpgti", ":", "case", "Hexagon", "::", "C2_cmpgt", ":", "SrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Mask", "=", "~", "0", ";", "break", ";", "case", "Hexagon", "::", "A4_cmpbeqi", ":", "case", "Hexagon", "::", "A4_cmpbeq", ":", "case", "Hexagon", "::", "A4_cmpbgtui", ":", "case", "Hexagon", "::", "A4_cmpbgtu", ":", "case", "Hexagon", "::", "A4_cmpbgt", ":", "SrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Mask", "=", "0xFF", ";", "break", ";", "case", "Hexagon", "::", "A4_cmpheqi", ":", "case", "Hexagon", "::", "A4_cmpheq", ":", "case", "Hexagon", "::", "A4_cmphgtui", ":", "case", "Hexagon", "::", "A4_cmphgtu", ":", "case", "Hexagon", "::", "A4_cmphgt", ":", "SrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Mask", "=", "0xFFFF", ";", "break", ";", "}", "switch", "(", "Opc", ")", "{", "case", "Hexagon", "::", "C2_cmpeqp", ":", "case", "Hexagon", "::", "C2_cmpeq", ":", "case", "Hexagon", "::", "C2_cmpgtp", ":", "case", "Hexagon", "::", "C2_cmpgtup", ":", "case", "Hexagon", "::", "C2_cmpgtu", ":", "case", "Hexagon", "::", "C2_cmpgt", ":", "case", "Hexagon", "::", "A4_cmpbeq", ":", "case", "Hexagon", "::", "A4_cmpbgtu", ":", "case", "Hexagon", "::", "A4_cmpbgt", ":", "case", "Hexagon", "::", "A4_cmpheq", ":", "case", "Hexagon", "::", "A4_cmphgtu", ":", "case", "Hexagon", "::", "A4_cmphgt", ":", "SrcReg2", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "return", "true", ";", "case", "Hexagon", "::", "C2_cmpeqi", ":", "case", "Hexagon", "::", "C2_cmpgtui", ":", "case", "Hexagon", "::", "C2_cmpgti", ":", "case", "Hexagon", "::", "A4_cmpbeqi", ":", "case", "Hexagon", "::", "A4_cmpbgtui", ":", "case", "Hexagon", "::", "A4_cmpheqi", ":", "case", "Hexagon", "::", "A4_cmphgtui", ":", "SrcReg2", "=", "0", ";", "Value", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "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", "." ]

[ "Hexagon", "Hexagon", "Hexagon::C2_cmpeqp", "Hexagon::C2_cmpeqi", "Hexagon::C2_cmpeq", "Hexagon::C2_cmpgtp", "Hexagon::C2_cmpgtup", "Hexagon::C2_cmpgtui", "Hexagon::C2_cmpgtu", "Hexagon::C2_cmpgti", "Hexagon::C2_cmpgt", "1", "0", "Hexagon::A4_cmpbeqi", "Hexagon::A4_cmpbeq", "Hexagon::A4_cmpbgtui", "Hexagon::A4_cmpbgtu", "Hexagon::A4_cmpbgt", "1", "0xFF", "Hexagon::A4_cmpheqi", "Hexagon::A4_cmpheq", "Hexagon::A4_cmphgtui", "Hexagon::A4_cmphgtu", "Hexagon::A4_cmphgt", "1", "0xFFFF", "Hexagon::C2_cmpeqp", "Hexagon::C2_cmpeq", "Hexagon::C2_cmpgtp", "Hexagon::C2_cmpgtup", "Hexagon::C2_cmpgtu", "Hexagon::C2_cmpgt", "Hexagon::A4_cmpbeq", "Hexagon::A4_cmpbgtu", "Hexagon::A4_cmpbgt", "Hexagon::A4_cmpheq", "Hexagon::A4_cmphgtu", "Hexagon::A4_cmphgt", "2", "Hexagon::C2_cmpeqi", "Hexagon::C2_cmpgtui", "Hexagon::C2_cmpgti", "Hexagon::A4_cmpbeqi", "Hexagon::A4_cmpbgtui", "Hexagon::A4_cmpheqi", "Hexagon::A4_cmphgtui", "0", "2" ]

[]

[ "<s>", "static", "void", "ix86_emit_probe_stack_range", "(", "HOST_WIDE_INT", "first", ",", "HOST_WIDE_INT", "size", ")", "{", "if", "(", "size", "<=", "7", "*", "PROBE_INTERVAL", ")", "{", "HOST_WIDE_INT", "i", ";", "for", "(", "i", "=", "PROBE_INTERVAL", ";", "i", "<", "size", ";", "i", "+=", "PROBE_INTERVAL", ")", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "first", "+", "i", ")", ")", ")", ";", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "first", "+", "size", ")", ")", ")", ";", "}", "else", "{", "HOST_WIDE_INT", "rounded_size", ",", "last", ";", "struct", "scratch_reg", "sr", ";", "get_scratch_register_on_entry", "(", "&", "sr", ")", ";", "rounded_size", "=", "size", "&", "-", "PROBE_INTERVAL", ";", "emit_move_insn", "(", "sr", ".", "reg", ",", "GEN_INT", "(", "-", "first", ")", ")", ";", "last", "=", "first", "+", "rounded_size", ";", "emit_insn", "(", "ix86_gen_probe_stack_range", "(", "sr", ".", "reg", ",", "sr", ".", "reg", ",", "GEN_INT", "(", "-", "last", ")", ")", ")", ";", "if", "(", "size", "!=", "rounded_size", ")", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "sr", ".", "reg", ")", ",", "rounded_size", "-", "size", ")", ")", ";", "release_scratch_register_on_entry", "(", "&", "sr", ")", ";", "}", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "probe", "a", "range", "of", "stack", "addresses", "from", "FIRST", "to", "FIRST+SIZE", ",", "inclusive", ".", "These", "are", "offsets", "from", "the", "current", "stack", "pointer", "." ]

[ "i386", "7" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "swapOperands", "(", "MachineInstr", "&", "Inst", ")", "const", "{", "assert", "(", "Inst", ".", "getNumExplicitOperands", "(", ")", "==", "3", ")", ";", "MachineOperand", "Op1", "=", "Inst", ".", "getOperand", "(", "1", ")", ";", "Inst", ".", "removeOperand", "(", "1", ")", ";", "Inst", ".", "addOperand", "(", "Op1", ")", ";", "}", "</s>" ]

[ "Exchange", "the", "two", "operands", "to", "this", "instruction", "in", "such", "a", "way", "that", "it", "does", "not", "modify", "the", "semantics", "of", "the", "instruction", "." ]

[ "AMDGPU", "SI", "3", "1", "1" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "SHUXIFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "SHUXIInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "SHUXIInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "&", "Old", "=", "*", "I", ";", "uint64_t", "Amount", "=", "Old", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "Amount", "=", "(", "Amount", "+", "StackAlign", "-", "1", ")", "/", "StackAlign", "*", "StackAlign", ";", "MachineInstr", "*", "New", "=", "nullptr", ";", "if", "(", "Old", ".", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", "{", "New", "=", "BuildMI", "(", "MF", ",", "Old", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "SHUXI", "::", "SUBri", ")", ",", "SHUXI", "::", "SP", ")", ".", "addReg", "(", "SHUXI", "::", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Old", ".", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "uint64_t", "CalleeAmt", "=", "Old", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "Amount", "-=", "CalleeAmt", ";", "if", "(", "Amount", ")", "New", "=", "BuildMI", "(", "MF", ",", "Old", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "SHUXI", "::", "ADDri", ")", ",", "SHUXI", "::", "SP", ")", ".", "addReg", "(", "SHUXI", "::", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "if", "(", "New", ")", "{", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "}", "else", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", "{", "if", "(", "uint64_t", "CalleeAmt", "=", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", "{", "MachineInstr", "&", "Old", "=", "*", "I", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MF", ",", "Old", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "SHUXI", "::", "SUBri", ")", ",", "SHUXI", "::", "SP", ")", ".", "addReg", "(", "SHUXI", "::", "SP", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "SHUXI", "SHUXI", "SHUXI", "SHUXI", "0", "0", "1", "SHUXI::SUBri", "SHUXI::SP", "SHUXI::SP", "1", "SHUXI::ADDri", "SHUXI::SP", "SHUXI::SP", "3", "1", "SHUXI::SUBri", "SHUXI::SP", "SHUXI::SP", "3" ]

[]

[ "<s>", "static", "rtx", "rs6000_adjust_atomic_subword", "(", "rtx", "orig_mem", ",", "rtx", "*", "pshift", ",", "rtx", "*", "pmask", ")", "{", "rtx", "addr", ",", "align", ",", "shift", ",", "mask", ",", "mem", ";", "HOST_WIDE_INT", "shift_mask", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "orig_mem", ")", ";", "shift_mask", "=", "(", "mode", "==", "QImode", "?", "0x18", ":", "0x10", ")", ";", "addr", "=", "XEXP", "(", "orig_mem", ",", "0", ")", ";", "addr", "=", "force_reg", "(", "GET_MODE", "(", "addr", ")", ",", "addr", ")", ";", "align", "=", "expand_simple_binop", "(", "Pmode", ",", "AND", ",", "addr", ",", "GEN_INT", "(", "-", "4", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "SImode", ",", "align", ")", ";", "MEM_VOLATILE_P", "(", "mem", ")", "=", "MEM_VOLATILE_P", "(", "orig_mem", ")", ";", "if", "(", "MEM_ALIAS_SET", "(", "orig_mem", ")", "==", "ALIAS_SET_MEMORY_BARRIER", ")", "set_mem_alias_set", "(", "mem", ",", "ALIAS_SET_MEMORY_BARRIER", ")", ";", "shift", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "addr", "=", "gen_lowpart", "(", "SImode", ",", "addr", ")", ";", "rtx", "tmp", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_ashlsi3", "(", "tmp", ",", "addr", ",", "GEN_INT", "(", "3", ")", ")", ")", ";", "emit_insn", "(", "gen_andsi3", "(", "shift", ",", "tmp", ",", "GEN_INT", "(", "shift_mask", ")", ")", ")", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "shift", "=", "expand_simple_binop", "(", "SImode", ",", "XOR", ",", "shift", ",", "GEN_INT", "(", "shift_mask", ")", ",", "shift", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "*", "pshift", "=", "shift", ";", "mask", "=", "expand_simple_binop", "(", "SImode", ",", "ASHIFT", ",", "GEN_INT", "(", "GET_MODE_MASK", "(", "mode", ")", ")", ",", "shift", ",", "NULL_RTX", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "*", "pmask", "=", "mask", ";", "return", "mem", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "the", "various", "atomic", "expanders", ".", "For", "sub-word", "operations", ",", "we", "must", "adjust", "things", "to", "operate", "on", "SImode", ".", "Given", "the", "original", "MEM", ",", "return", "a", "new", "aligned", "memory", ".", "Also", "build", "and", "return", "the", "quantities", "by", "which", "to", "shift", "and", "mask", "." ]

[ "powerpcspe", "0x18", "0x10", "0", "4", "1", "3", "1", "1" ]

[]

[ "<s>", "bool", "MSP430FrameInfo", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "POP16r", ")", ",", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "0", "MSP430::POP16r" ]

[]

[ "<s>", "bool", "SIMemoryLegalizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changed", "=", "false", ";", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "const", "IsaInfo", "::", "IsaVersion", "IV", "=", "IsaInfo", "::", "getIsaVersion", "(", "ST", ".", "getFeatureBits", "(", ")", ")", ";", "MMI", "=", "&", "MF", ".", "getMMI", "(", ")", ".", "getObjFileInfo", "<", "AMDGPUMachineModuleInfo", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "Vmcnt0Immediate", "=", "AMDGPU", "::", "encodeWaitcnt", "(", "IV", ",", "0", ",", "getExpcntBitMask", "(", "IV", ")", ",", "getLgkmcntBitMask", "(", "IV", ")", ")", ";", "Wbinvl1Opcode", "=", "ST", ".", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", "?", "AMDGPU", "::", "BUFFER_WBINVL1", ":", "AMDGPU", "::", "BUFFER_WBINVL1_VOL", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "MI", "=", "MBB", ".", "begin", "(", ")", ";", "MI", "!=", "MBB", ".", "end", "(", ")", ";", "++", "MI", ")", "{", "if", "(", "!", "(", "MI", "->", "getDesc", "(", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "maybeAtomic", ")", ")", "continue", ";", "if", "(", "const", "auto", "&", "MOI", "=", "SIMemOpInfo", "::", "getLoadInfo", "(", "MI", ")", ")", "Changed", "|=", "expandLoad", "(", "MOI", ".", "getValue", "(", ")", ",", "MI", ")", ";", "else", "if", "(", "const", "auto", "&", "MOI", "=", "SIMemOpInfo", "::", "getStoreInfo", "(", "MI", ")", ")", "Changed", "|=", "expandStore", "(", "MOI", ".", "getValue", "(", ")", ",", "MI", ")", ";", "else", "if", "(", "const", "auto", "&", "MOI", "=", "SIMemOpInfo", "::", "getAtomicFenceInfo", "(", "MI", ")", ")", "Changed", "|=", "expandAtomicFence", "(", "MOI", ".", "getValue", "(", ")", ",", "MI", ")", ";", "else", "if", "(", "const", "auto", "&", "MOI", "=", "SIMemOpInfo", "::", "getAtomicCmpxchgInfo", "(", "MI", ")", ")", "Changed", "|=", "expandAtomicCmpxchg", "(", "MOI", ".", "getValue", "(", ")", ",", "MI", ")", ";", "else", "if", "(", "const", "auto", "&", "MOI", "=", "SIMemOpInfo", "::", "getAtomicRmwInfo", "(", "MI", ")", ")", "Changed", "|=", "expandAtomicRmw", "(", "MOI", ".", "getValue", "(", ")", ",", "MI", ")", ";", "}", "}", "Changed", "|=", "removeAtomicPseudoMIs", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU", "AMDGPU::encodeWaitcnt", "0", "AMDGPU", "AMDGPU::BUFFER_WBINVL1", "AMDGPU::BUFFER_WBINVL1_VOL", "SIInstrFlags::maybeAtomic", "SI", "SI", "SI", "SI", "SI" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "setPreservesAll", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineModuleInfo", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "X86" ]

[]

[ "<s>", "int", "easy_df_const", "(", "rtx", "op", ")", "{", "long", "l", "[", "2", "]", ";", "REAL_VALUE_TO_TARGET_DOUBLE", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "op", ")", ",", "l", ")", ";", "if", "(", "l", "[", "0", "]", "==", "0", "&&", "l", "[", "1", "]", "==", "0", ")", "return", "1", ";", "if", "(", "(", "l", "[", "0", "]", "&", "0xffff", ")", "==", "0", "&&", "l", "[", "1", "]", "==", "0", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "if", "OP", "is", "a", "DFmode", "const", "we", "want", "to", "handle", "inline", ".", "This", "must", "match", "the", "code", "in", "the", "movdf", "pattern", ".", "It", "is", "used", "by", "the", "'", "H", "'", "CONST_DOUBLE_OK_FOR_LETTER", "." ]

[ "m32r", "2", "0", "0", "1", "0", "1", "0", "0xffff", "0", "1", "0", "1", "0" ]

[]

[ "<s>", "void", "output_pop_multiple", "(", "rtx", "insn", ",", "rtx", "*", "operands", ")", "{", "char", "buf", "[", "80", "]", ";", "int", "ok", ";", "ok", "=", "pop_multiple_operation", "(", "PATTERN", "(", "insn", ")", ",", "VOIDmode", ")", ";", "gcc_assert", "(", "ok", ")", ";", "if", "(", "first_dreg_to_save", "==", "8", ")", "sprintf", "(", "buf", ",", "\"( p5:%d ) = [sp++];\\n\"", ",", "first_preg_to_save", ")", ";", "else", "if", "(", "first_preg_to_save", "==", "6", ")", "sprintf", "(", "buf", ",", "\"( r7:%d ) = [sp++];\\n\"", ",", "first_dreg_to_save", ")", ";", "else", "sprintf", "(", "buf", ",", "\"( r7:%d, p5:%d ) = [sp++];\\n\"", ",", "first_dreg_to_save", ",", "first_preg_to_save", ")", ";", "output_asm_insn", "(", "buf", ",", "operands", ")", ";", "}", "</s>" ]

[ "Emit", "assembly", "code", "for", "one", "multi-register", "pop", "described", "by", "INSN", ",", "with", "operands", "in", "OPERANDS", "." ]

[ "bfin", "80", "8", "\"( p5:%d ) = [sp++];\\n\"", "6", "\"( r7:%d ) = [sp++];\\n\"", "\"( r7:%d, p5:%d ) = [sp++];\\n\"" ]

[]

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

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

[ "Blackfin" ]

[]

[ "<s>", "void", "avr_expand_prologue", "(", "void", ")", "{", "HARD_REG_SET", "set", ";", "HOST_WIDE_INT", "size", ";", "size", "=", "get_frame_size", "(", ")", "+", "avr_outgoing_args_size", "(", ")", ";", "cfun", "->", "machine", "->", "stack_usage", "=", "0", ";", "if", "(", "cfun", "->", "machine", "->", "is_naked", ")", "{", "return", ";", "}", "avr_regs_to_save", "(", "&", "set", ")", ";", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", "||", "cfun", "->", "machine", "->", "is_signal", ")", "{", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", ")", "emit_insn", "(", "gen_enable_interrupt", "(", ")", ")", ";", "emit_push_byte", "(", "AVR_ZERO_REGNO", ",", "true", ")", ";", "emit_push_byte", "(", "AVR_TMP_REGNO", ",", "true", ")", ";", "emit_push_sfr", "(", "sreg_rtx", ",", "false", ",", "false", ")", ";", "emit_move_insn", "(", "zero_reg_rtx", ",", "const0_rtx", ")", ";", "emit_use", "(", "zero_reg_rtx", ")", ";", "if", "(", "AVR_HAVE_RAMPD", ")", "emit_push_sfr", "(", "rampd_rtx", ",", "false", ",", "true", ")", ";", "if", "(", "AVR_HAVE_RAMPX", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_X", ")", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_X", "+", "1", ")", ")", "{", "emit_push_sfr", "(", "rampx_rtx", ",", "false", ",", "true", ")", ";", "}", "if", "(", "AVR_HAVE_RAMPY", "&&", "(", "frame_pointer_needed", "||", "(", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Y", ")", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Y", "+", "1", ")", ")", ")", ")", "{", "emit_push_sfr", "(", "rampy_rtx", ",", "false", ",", "true", ")", ";", "}", "if", "(", "AVR_HAVE_RAMPZ", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Z", ")", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Z", "+", "1", ")", ")", "{", "emit_push_sfr", "(", "rampz_rtx", ",", "false", ",", "AVR_HAVE_RAMPD", ")", ";", "}", "}", "avr_prologue_setup_frame", "(", "size", ",", "set", ")", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "cfun", "->", "machine", "->", "stack_usage", ";", "}", "</s>" ]

[ "Output", "function", "prologue", "." ]

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

[]

[ "<s>", "void", "AVRPassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAVRShiftExpandPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "HexagonBitSimplify", "::", "isEqual", "(", "const", "BitTracker", "::", "RegisterCell", "&", "RC1", ",", "uint16_t", "B1", ",", "const", "BitTracker", "::", "RegisterCell", "&", "RC2", ",", "uint16_t", "B2", ",", "uint16_t", "W", ")", "{", "for", "(", "uint16_t", "i", "=", "0", ";", "i", "<", "W", ";", "++", "i", ")", "{", "if", "(", "RC1", "[", "B1", "+", "i", "]", ".", "Type", "==", "BitTracker", "::", "BitValue", "::", "Ref", "&&", "RC1", "[", "B1", "+", "i", "]", ".", "RefI", ".", "Reg", "==", "0", ")", "return", "false", ";", "if", "(", "RC2", "[", "B2", "+", "i", "]", ".", "Type", "==", "BitTracker", "::", "BitValue", "::", "Ref", "&&", "RC2", "[", "B2", "+", "i", "]", ".", "RefI", ".", "Reg", "==", "0", ")", "return", "false", ";", "if", "(", "RC1", "[", "B1", "+", "i", "]", "!=", "RC2", "[", "B2", "+", "i", "]", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "isEqual", "-", "Compares", "two", "trees", "for", "structural", "equality", "and", "returns", "true", "if", "they", "are", "equal", "." ]

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

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "RISCVRegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "auto", "*", "RVFI", "=", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "Register", "FPReg", "=", "getFPReg", "(", "STI", ")", ";", "Register", "SPReg", "=", "getSPReg", "(", "STI", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "end", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "{", "MBBI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "if", "(", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "!", "MBBI", "->", "isTerminator", "(", ")", ")", "MBBI", "=", "std", "::", "next", "(", "MBBI", ")", ";", "}", "auto", "LastFrameDestroy", "=", "std", "::", "prev", "(", "MBBI", ",", "MFI", ".", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "uint64_t", "FPOffset", "=", "StackSize", "-", "RVFI", "->", "getVarArgsSaveSize", "(", ")", ";", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "{", "assert", "(", "hasFP", "(", "MF", ")", "&&", "\"frame pointer should not have been eliminated\"", ")", ";", "adjustReg", "(", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "SPReg", ",", "FPReg", ",", "-", "FPOffset", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "uint64_t", "FirstSPAdjustAmount", "=", "getFirstSPAdjustAmount", "(", "MF", ")", ";", "if", "(", "FirstSPAdjustAmount", ")", "{", "uint64_t", "SecondSPAdjustAmount", "=", "MFI", ".", "getStackSize", "(", ")", "-", "FirstSPAdjustAmount", ";", "assert", "(", "SecondSPAdjustAmount", ">", "0", "&&", "\"SecondSPAdjustAmount should be greater than zero\"", ")", ";", "adjustReg", "(", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "SecondSPAdjustAmount", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "if", "(", "FirstSPAdjustAmount", ")", "StackSize", "=", "FirstSPAdjustAmount", ";", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "StackSize", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "RISCV", "\"frame pointer should not have been eliminated\"", "0", "\"SecondSPAdjustAmount should be greater than zero\"" ]

[]

[ "<s>", "SDValue", "R600TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "R600MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "R600MachineFunctionInfo", ">", "(", ")", ";", "SmallVector", "<", "ISD", "::", "InputArg", ",", "8", ">", "LocalIns", ";", "getOriginalFunctionArgs", "(", "DAG", ",", "MF", ".", "getFunction", "(", ")", ",", "Ins", ",", "LocalIns", ")", ";", "AnalyzeFormalArguments", "(", "CCInfo", ",", "LocalIns", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Ins", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "const", "ISD", "::", "InputArg", "&", "In", "=", "Ins", "[", "i", "]", ";", "EVT", "VT", "=", "In", ".", "VT", ";", "EVT", "MemVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "if", "(", "!", "VT", ".", "isVector", "(", ")", "&&", "MemVT", ".", "isVector", "(", ")", ")", "{", "MemVT", "=", "MemVT", ".", "getVectorElementType", "(", ")", ";", "}", "if", "(", "AMDGPU", "::", "isShader", "(", "CallConv", ")", ")", "{", "unsigned", "Reg", "=", "MF", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "&", "AMDGPU", "::", "R600_Reg128RegClass", ")", ";", "SDValue", "Register", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "VT", ")", ";", "InVals", ".", "push_back", "(", "Register", ")", ";", "continue", ";", "}", "PointerType", "*", "PtrTy", "=", "PointerType", "::", "get", "(", "VT", ".", "getTypeForEVT", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "AMDGPUAS", "::", "CONSTANT_BUFFER_0", ")", ";", "ISD", "::", "LoadExtType", "Ext", "=", "ISD", "::", "NON_EXTLOAD", ";", "if", "(", "MemVT", ".", "getScalarSizeInBits", "(", ")", "!=", "VT", ".", "getScalarSizeInBits", "(", ")", ")", "{", "Ext", "=", "ISD", "::", "SEXTLOAD", ";", "}", "unsigned", "ValBase", "=", "ArgLocs", "[", "In", ".", "getOrigArgIndex", "(", ")", "]", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "PartOffset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "Offset", "=", "36", "+", "VA", ".", "getLocMemOffset", "(", ")", ";", "MachinePointerInfo", "PtrInfo", "(", "UndefValue", "::", "get", "(", "PtrTy", ")", ",", "PartOffset", "-", "ValBase", ")", ";", "SDValue", "Arg", "=", "DAG", ".", "getLoad", "(", "ISD", "::", "UNINDEXED", ",", "Ext", ",", "VT", ",", "DL", ",", "Chain", ",", "DAG", ".", "getConstant", "(", "Offset", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getUNDEF", "(", "MVT", "::", "i32", ")", ",", "PtrInfo", ",", "MemVT", ",", "4", ",", "MachineMemOperand", "::", "MONonTemporal", "|", "MachineMemOperand", "::", "MOInvariant", ")", ";", "InVals", ".", "push_back", "(", "Arg", ")", ";", "MFI", "->", "ABIArgOffset", "=", "Offset", "+", "MemVT", ".", "getStoreSize", "(", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "ISD::InputArg", "16", "R600", "R600", "ISD::InputArg", "8", "0", "ISD::InputArg", "AMDGPU::isShader", "AMDGPU::R600_Reg128RegClass", "AMDGPU", "ISD::LoadExtType", "ISD::NON_EXTLOAD", "ISD::SEXTLOAD", "36", "ISD::UNINDEXED", "MVT::i32", "MVT::i32", "4" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Lower pointer arguments of CUDA kernels\"", ";", "}", "</s>" ]

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

[ "NVPTX", "\"Lower pointer arguments of CUDA kernels\"" ]

[]

[ "<s>", "static", "void", "aarch64_emit_load_exclusive", "(", "machine_mode", "mode", ",", "rtx", "rval", ",", "rtx", "mem", ",", "rtx", "model_rtx", ")", "{", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "gen", "=", "gen_aarch64_load_exclusiveqi", ";", "break", ";", "case", "E_HImode", ":", "gen", "=", "gen_aarch64_load_exclusivehi", ";", "break", ";", "case", "E_SImode", ":", "gen", "=", "gen_aarch64_load_exclusivesi", ";", "break", ";", "case", "E_DImode", ":", "gen", "=", "gen_aarch64_load_exclusivedi", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "gen", "(", "rval", ",", "mem", ",", "model_rtx", ")", ")", ";", "}", "</s>" ]

[ "Emit", "load", "exclusive", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "PatmosAsmPrinter", "::", "isBlockOnlyReachableByFallthrough", "(", "const", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "if", "(", "MBB", "->", "isEHPad", "(", ")", "||", "MBB", "->", "pred_empty", "(", ")", "||", "MBB", "->", "hasAddressTaken", "(", ")", ")", "return", "false", ";", "MachineBasicBlock", "::", "const_pred_iterator", "PI", "=", "MBB", "->", "pred_begin", "(", ")", ",", "PI2", "=", "PI", ";", "if", "(", "++", "PI2", "!=", "MBB", "->", "pred_end", "(", ")", ")", "return", "false", ";", "const", "MachineBasicBlock", "*", "Pred", "=", "*", "PI", ";", "if", "(", "!", "Pred", "->", "isLayoutSuccessor", "(", "MBB", ")", ")", "return", "false", ";", "if", "(", "isFStart", "(", "MBB", ")", ")", "return", "false", ";", "if", "(", "Pred", "->", "empty", "(", ")", ")", "return", "true", ";", "MachineBasicBlock", "::", "const_iterator", "I", "=", "Pred", "->", "end", "(", ")", ";", "while", "(", "I", "!=", "Pred", "->", "begin", "(", ")", "&&", "!", "(", "--", "I", ")", "->", "isTerminator", "(", ")", ")", ";", "return", "I", "==", "Pred", "->", "end", "(", ")", "||", "!", "I", "->", "isBarrier", "(", ")", ";", "}", "</s>" ]

[ "isBlockOnlyReachableByFallthough", "-", "Return", "true", "if", "the", "basic", "block", "has", "exactly", "one", "predecessor", "and", "the", "control", "transfer", "mechanism", "between", "the", "predecessor", "and", "this", "block", "is", "a", "fall-through", "." ]

[ "Patmos", "Patmos" ]

[]

[ "<s>", "bool", "DCPU16FrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "!", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]

[ "Dcpu16", "DCPU16" ]

[]

[ "<s>", "void", "R600InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "AMDGPU", "::", "R600_Reg128RegClass", ".", "contains", "(", "DestReg", ")", "&&", "AMDGPU", "::", "R600_Reg128RegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "4", ";", "I", "++", ")", "{", "unsigned", "SubRegIndex", "=", "RI", ".", "getSubRegFromChannel", "(", "I", ")", ";", "buildDefaultInstruction", "(", "MBB", ",", "MI", ",", "AMDGPU", "::", "MOV", ",", "RI", ".", "getSubReg", "(", "DestReg", ",", "SubRegIndex", ")", ",", "RI", ".", "getSubReg", "(", "SrcReg", ",", "SubRegIndex", ")", ")", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", "|", "RegState", "::", "Implicit", ")", ";", "}", "}", "else", "{", "assert", "(", "!", "AMDGPU", "::", "R600_Reg128RegClass", ".", "contains", "(", "DestReg", ")", "&&", "!", "AMDGPU", "::", "R600_Reg128RegClass", ".", "contains", "(", "SrcReg", ")", ")", ";", "MachineInstr", "*", "NewMI", "=", "buildDefaultInstruction", "(", "MBB", ",", "MI", ",", "AMDGPU", "::", "MOV", ",", "DestReg", ",", "SrcReg", ")", ";", "NewMI", "->", "getOperand", "(", "getOperandIdx", "(", "*", "NewMI", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ")", ".", "setIsKill", "(", "KillSrc", ")", ";", "}", "}", "</s>" ]

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

[ "R600", "0", "4" ]

[]

[ "<s>", "static", "bool", "bpf_pass_by_reference", "(", "cumulative_args_t", "cum", "ATTRIBUTE_UNUSED", ",", "const", "function_arg_info", "&", "arg", ")", "{", "unsigned", "num_bytes", "=", "arg", ".", "type_size_in_bytes", "(", ")", ";", "return", "(", "arg", ".", "aggregate_type_p", "(", ")", "||", "(", "num_bytes", ">", "8", "*", "5", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "argument", "at", "the", "position", "indicated", "by", "CUM", "should", "be", "passed", "by", "reference", ".", "If", "the", "hook", "returns", "true", ",", "a", "copy", "of", "that", "argument", "is", "made", "in", "memory", "and", "a", "pointer", "to", "the", "argument", "is", "passed", "instead", "of", "the", "argument", "itself", "." ]

[ "bpf", "8", "5" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isInlineConstant", "(", "const", "MachineOperand", "&", "MO", ",", "uint8_t", "OperandType", ")", "const", "{", "if", "(", "!", "MO", ".", "isImm", "(", ")", "||", "OperandType", "<", "AMDGPU", "::", "OPERAND_SRC_FIRST", "||", "OperandType", ">", "AMDGPU", "::", "OPERAND_SRC_LAST", ")", "return", "false", ";", "int64_t", "Imm", "=", "MO", ".", "getImm", "(", ")", ";", "switch", "(", "OperandType", ")", "{", "case", "AMDGPU", "::", "OPERAND_REG_IMM_INT32", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP32", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_INT32", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP32", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_V2FP32", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_V2FP32", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_V2INT32", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_V2INT32", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_AC_INT32", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_AC_FP32", ":", "{", "int32_t", "Trunc", "=", "static_cast", "<", "int32_t", ">", "(", "Imm", ")", ";", "return", "AMDGPU", "::", "isInlinableLiteral32", "(", "Trunc", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "case", "AMDGPU", "::", "OPERAND_REG_IMM_INT64", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP64", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_INT64", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP64", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_AC_FP64", ":", "return", "AMDGPU", "::", "isInlinableLiteral64", "(", "MO", ".", "getImm", "(", ")", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "case", "AMDGPU", "::", "OPERAND_REG_IMM_INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_AC_INT16", ":", "return", "AMDGPU", "::", "isInlinableIntLiteral", "(", "Imm", ")", ";", "case", "AMDGPU", "::", "OPERAND_REG_IMM_V2INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_V2INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_AC_V2INT16", ":", "return", "AMDGPU", "::", "isInlinableIntLiteralV216", "(", "Imm", ")", ";", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_AC_FP16", ":", "{", "if", "(", "isInt", "<", "16", ">", "(", "Imm", ")", "||", "isUInt", "<", "16", ">", "(", "Imm", ")", ")", "{", "int16_t", "Trunc", "=", "static_cast", "<", "int16_t", ">", "(", "Imm", ")", ";", "return", "ST", ".", "has16BitInsts", "(", ")", "&&", "AMDGPU", "::", "isInlinableLiteral16", "(", "Trunc", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "return", "false", ";", "}", "case", "AMDGPU", "::", "OPERAND_REG_IMM_V2FP16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_V2FP16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_AC_V2FP16", ":", "{", "uint32_t", "Trunc", "=", "static_cast", "<", "uint32_t", ">", "(", "Imm", ")", ";", "return", "AMDGPU", "::", "isInlinableLiteralV216", "(", "Trunc", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "default", ":", "llvm_unreachable", "(", "\"invalid bitwidth\"", ")", ";", "}", "}", "</s>" ]

[ "returns", "true", "if", "the", "operand", "OpIdx", "in", "MI", "is", "a", "valid", "inline", "immediate", "." ]

[ "AMDGPU", "SI", "AMDGPU::OPERAND_SRC_FIRST", "AMDGPU::OPERAND_SRC_LAST", "AMDGPU::OPERAND_REG_IMM_INT32", "AMDGPU::OPERAND_REG_IMM_FP32", "AMDGPU::OPERAND_REG_INLINE_C_INT32", "AMDGPU::OPERAND_REG_INLINE_C_FP32", "AMDGPU::OPERAND_REG_IMM_V2FP32", "AMDGPU::OPERAND_REG_INLINE_C_V2FP32", "AMDGPU::OPERAND_REG_IMM_V2INT32", "AMDGPU::OPERAND_REG_INLINE_C_V2INT32", "AMDGPU::OPERAND_REG_INLINE_AC_INT32", "AMDGPU::OPERAND_REG_INLINE_AC_FP32", "AMDGPU::isInlinableLiteral32", "AMDGPU::OPERAND_REG_IMM_INT64", "AMDGPU::OPERAND_REG_IMM_FP64", "AMDGPU::OPERAND_REG_INLINE_C_INT64", "AMDGPU::OPERAND_REG_INLINE_C_FP64", "AMDGPU::OPERAND_REG_INLINE_AC_FP64", "AMDGPU::isInlinableLiteral64", "AMDGPU::OPERAND_REG_IMM_INT16", "AMDGPU::OPERAND_REG_INLINE_C_INT16", "AMDGPU::OPERAND_REG_INLINE_AC_INT16", "AMDGPU::isInlinableIntLiteral", "AMDGPU::OPERAND_REG_IMM_V2INT16", "AMDGPU::OPERAND_REG_INLINE_C_V2INT16", "AMDGPU::OPERAND_REG_INLINE_AC_V2INT16", "AMDGPU::isInlinableIntLiteralV216", "AMDGPU::OPERAND_REG_IMM_FP16", "AMDGPU::OPERAND_REG_INLINE_C_FP16", "AMDGPU::OPERAND_REG_INLINE_AC_FP16", "16", "16", "AMDGPU::isInlinableLiteral16", "AMDGPU::OPERAND_REG_IMM_V2FP16", "AMDGPU::OPERAND_REG_INLINE_C_V2FP16", "AMDGPU::OPERAND_REG_INLINE_AC_V2FP16", "AMDGPU::isInlinableLiteralV216", "\"invalid bitwidth\"" ]

[]

[ "<s>", "static", "bool", "arm_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", ")", "return", "(", "regno", "==", "CC_REGNUM", "||", "(", "TARGET_HARD_FLOAT", "&&", "regno", "==", "VFPCC_REGNUM", ")", ")", ";", "if", "(", "regno", "==", "CC_REGNUM", "&&", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_CC", ")", "return", "false", ";", "if", "(", "TARGET_THUMB1", ")", "return", "(", "ARM_NUM_REGS", "(", "mode", ")", "<", "2", ")", "||", "(", "regno", "<", "LAST_LO_REGNUM", ")", ";", "if", "(", "TARGET_HARD_FLOAT", "&&", "IS_VFP_REGNUM", "(", "regno", ")", ")", "{", "if", "(", "mode", "==", "SFmode", "||", "mode", "==", "SImode", ")", "return", "VFP_REGNO_OK_FOR_SINGLE", "(", "regno", ")", ";", "if", "(", "mode", "==", "DFmode", ")", "return", "VFP_REGNO_OK_FOR_DOUBLE", "(", "regno", ")", ";", "if", "(", "mode", "==", "HFmode", ")", "return", "VFP_REGNO_OK_FOR_SINGLE", "(", "regno", ")", ";", "if", "(", "mode", "==", "HImode", ")", "return", "VFP_REGNO_OK_FOR_SINGLE", "(", "regno", ")", ";", "if", "(", "TARGET_NEON", ")", "return", "(", "VALID_NEON_DREG_MODE", "(", "mode", ")", "&&", "VFP_REGNO_OK_FOR_DOUBLE", "(", "regno", ")", ")", "||", "(", "VALID_NEON_QREG_MODE", "(", "mode", ")", "&&", "NEON_REGNO_OK_FOR_QUAD", "(", "regno", ")", ")", "||", "(", "mode", "==", "TImode", "&&", "NEON_REGNO_OK_FOR_NREGS", "(", "regno", ",", "2", ")", ")", "||", "(", "mode", "==", "EImode", "&&", "NEON_REGNO_OK_FOR_NREGS", "(", "regno", ",", "3", ")", ")", "||", "(", "mode", "==", "OImode", "&&", "NEON_REGNO_OK_FOR_NREGS", "(", "regno", ",", "4", ")", ")", "||", "(", "mode", "==", "CImode", "&&", "NEON_REGNO_OK_FOR_NREGS", "(", "regno", ",", "6", ")", ")", "||", "(", "mode", "==", "XImode", "&&", "NEON_REGNO_OK_FOR_NREGS", "(", "regno", ",", "8", ")", ")", ";", "return", "false", ";", "}", "if", "(", "TARGET_REALLY_IWMMXT", ")", "{", "if", "(", "IS_IWMMXT_GR_REGNUM", "(", "regno", ")", ")", "return", "mode", "==", "SImode", ";", "if", "(", "IS_IWMMXT_REGNUM", "(", "regno", ")", ")", "return", "VALID_IWMMXT_REG_MODE", "(", "mode", ")", ";", "}", "if", "(", "regno", "<=", "LAST_ARM_REGNUM", ")", "{", "if", "(", "ARM_NUM_REGS", "(", "mode", ")", ">", "4", ")", "return", "false", ";", "if", "(", "TARGET_THUMB2", ")", "return", "true", ";", "return", "!", "(", "TARGET_LDRD", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "4", "&&", "(", "regno", "&", "1", ")", "!=", "0", ")", ";", "}", "if", "(", "regno", "==", "FRAME_POINTER_REGNUM", "||", "regno", "==", "ARG_POINTER_REGNUM", ")", "return", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "REGNO", "is", "a", "valid", "register", "for", "holding", "a", "quantity", "of", "type", "MODE", "." ]

[ "arm", "2", "2", "3", "4", "6", "8", "4", "4", "1", "0" ]

[]

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

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

[ "PowerPC" ]

[]

[ "<s>", "const", "uint16_t", "*", "RISCVRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "if", "(", "Subtarget", ".", "isRV64", "(", ")", ")", "if", "(", "Subtarget", ".", "hasD", "(", ")", ")", "return", "CSR_RV64D_SaveList", ";", "else", "if", "(", "Subtarget", ".", "hasF", "(", ")", ")", "return", "CSR_RV64F_SaveList", ";", "else", "return", "CSR_RV64_SaveList", ";", "else", "if", "(", "Subtarget", ".", "hasD", "(", ")", ")", "return", "CSR_RV32D_SaveList", ";", "else", "if", "(", "Subtarget", ".", "hasF", "(", ")", ")", "return", "CSR_RV32F_SaveList", ";", "else", "return", "CSR_RV32_SaveList", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "void", "M88kMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "uint64_t", "Bits", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "assert", "(", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ".", "getSize", "(", ")", "==", "4", "&&", "\"Unexpected instr length\"", ")", ";", "for", "(", "int", "I", "=", "(", "4", "-", "1", ")", "*", "8", ";", "I", ">=", "0", ";", "I", "-=", "8", ")", "OS", "<<", "static_cast", "<", "uint8_t", ">", "(", "(", "Bits", ">>", "I", ")", "&", "0xff", ")", ";", "}", "</s>" ]

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

[ "M88k", "M88k", "4", "\"Unexpected instr length\"", "4", "1", "8", "0", "8", "0xff" ]

[]

[ "<s>", "virtual", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addPreservedID", "(", "MachineLoopInfoID", ")", ";", "AU", ".", "addPreservedID", "(", "MachineDominatorsID", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "PIC16" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequiredID", "(", "LoopSimplifyID", ")", ";", "AU", ".", "addRequired", "<", "LoopInfoWrapperPass", ">", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64" ]

[]

[ "<s>", "bool", "HexagonAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "if", "(", "(", "IDVal", ".", "lower", "(", ")", "==", "\".word\"", ")", "||", "(", "IDVal", ".", "lower", "(", ")", "==", "\".4byte\"", ")", ")", "return", "ParseDirectiveValue", "(", "4", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "if", "(", "IDVal", ".", "lower", "(", ")", "==", "\".short\"", "||", "IDVal", ".", "lower", "(", ")", "==", "\".hword\"", "||", "IDVal", ".", "lower", "(", ")", "==", "\".half\"", ")", "return", "ParseDirectiveValue", "(", "2", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "if", "(", "IDVal", ".", "lower", "(", ")", "==", "\".falign\"", ")", "return", "ParseDirectiveFalign", "(", "256", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "if", "(", "(", "IDVal", ".", "lower", "(", ")", "==", "\".lcomm\"", ")", "||", "(", "IDVal", ".", "lower", "(", ")", "==", "\".lcommon\"", ")", ")", "return", "ParseDirectiveComm", "(", "true", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "if", "(", "(", "IDVal", ".", "lower", "(", ")", "==", "\".comm\"", ")", "||", "(", "IDVal", ".", "lower", "(", ")", "==", "\".common\"", ")", ")", "return", "ParseDirectiveComm", "(", "false", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "if", "(", "IDVal", ".", "lower", "(", ")", "==", "\".subsection\"", ")", "return", "ParseDirectiveSubsection", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "\".word\"", "\".4byte\"", "4", "\".short\"", "\".hword\"", "\".half\"", "2", "\".falign\"", "256", "\".lcomm\"", "\".lcommon\"", "\".comm\"", "\".common\"", "\".subsection\"" ]

[]

[ "<s>", "InstructionCost", "SystemZTTIImpl", "::", "getIntImmCost", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "BitSize", ">", "64", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "Imm", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", ")", "{", "if", "(", "isInt", "<", "32", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Basic", ";", "if", "(", "isUInt", "<", "32", ">", "(", "Imm", ".", "getZExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Basic", ";", "if", "(", "(", "Imm", ".", "getZExtValue", "(", ")", "&", "0xffffffff", ")", "==", "0", ")", "return", "TTI", "::", "TCC_Basic", ";", "return", "2", "*", "TTI", "::", "TCC_Basic", ";", "}", "return", "4", "*", "TTI", "::", "TCC_Basic", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "materializing", "a", "64-bit", "value", "." ]

[ "SystemZ", "SystemZ", "0", "64", "0", "64", "32", "32", "0xffffffff", "0", "2", "4" ]

[]

[ "<s>", "std", "::", "pair", "<", "uint16_t", ",", "uint16_t", ">", "X86InstrInfo", "::", "getExecutionDomain", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "uint16_t", "domain", "=", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", ">>", "X86II", "::", "SSEDomainShift", ")", "&", "3", ";", "bool", "hasAVX2", "=", "Subtarget", ".", "hasAVX2", "(", ")", ";", "uint16_t", "validDomains", "=", "0", ";", "if", "(", "domain", "&&", "lookup", "(", "MI", ".", "getOpcode", "(", ")", ",", "domain", ")", ")", "validDomains", "=", "0xe", ";", "else", "if", "(", "domain", "&&", "lookupAVX2", "(", "MI", ".", "getOpcode", "(", ")", ",", "domain", ")", ")", "validDomains", "=", "hasAVX2", "?", "0xe", ":", "0x6", ";", "return", "std", "::", "make_pair", "(", "domain", ",", "validDomains", ")", ";", "}", "</s>" ]

[ "Return", "the", "current", "execution", "domain", "and", "bit", "mask", "of", "possible", "domains", "for", "instruction", "." ]

[ "X86", "X86", "X86II::SSEDomainShift", "3", "0", "0xe", "0xe", "0x6" ]

[]

[ "<s>", "bool", "mips_split_move_p", "(", "rtx", "dest", ",", "rtx", "src", ",", "enum", "mips_split_type", "split_type", ")", "{", "if", "(", "mips_mult_move_p", "(", "dest", ",", "src", ",", "split_type", ")", ")", "return", "false", ";", "unsigned", "int", "size", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "dest", ")", ")", ";", "if", "(", "size", "==", "8", "&&", "FP_REG_RTX_P", "(", "src", ")", "&&", "FP_REG_RTX_P", "(", "dest", ")", ")", "return", "false", ";", "if", "(", "size", "==", "8", "&&", "ISA_HAS_LDC1_SDC1", ")", "{", "if", "(", "FP_REG_RTX_P", "(", "dest", ")", "&&", "MEM_P", "(", "src", ")", ")", "return", "false", ";", "if", "(", "FP_REG_RTX_P", "(", "src", ")", "&&", "MEM_P", "(", "dest", ")", ")", "return", "false", ";", "}", "return", "size", ">", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "move", "from", "SRC", "to", "DEST", "should", "be", "split", "into", "two", ".", "SPLIT_TYPE", "describes", "the", "split", "condition", "." ]

[ "mips", "8", "8" ]

[]

[ "<s>", "void", "AArch64PreLegalizerCombiner", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "TargetPassConfig", ">", "(", ")", ";", "AU", ".", "setPreservesCFG", "(", ")", ";", "getSelectionDAGFallbackAnalysisUsage", "(", "AU", ")", ";", "AU", ".", "addRequired", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "Alignment", "=", "RC", "->", "getSize", "(", ")", "==", "32", "?", "32", ":", "16", ";", "bool", "isAligned", "=", "(", "TM", ".", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ">=", "Alignment", ")", "||", "RI", ".", "canRealignStack", "(", "MF", ")", ";", "unsigned", "Opc", "=", "getLoadRegOpcode", "(", "DestReg", ",", "RC", ",", "isAligned", ",", "TM", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ",", "FrameIdx", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "WebAssemblyPassConfig", "::", "addPreISel", "(", ")", "{", "TargetPassConfig", "::", "addPreISel", "(", ")", ";", "addPass", "(", "createWebAssemblyLowerRefTypesIntPtrConv", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "SITargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", "AddrSpace", ",", "unsigned", "Alignment", ",", "MachineMemOperand", "::", "Flags", "Flags", ",", "bool", "*", "IsFast", ")", "const", "{", "if", "(", "IsFast", ")", "*", "IsFast", "=", "false", ";", "if", "(", "VT", "==", "MVT", "::", "Other", "||", "(", "VT", "!=", "MVT", "::", "Other", "&&", "VT", ".", "getSizeInBits", "(", ")", ">", "1024", "&&", "VT", ".", "getStoreSize", "(", ")", ">", "16", ")", ")", "{", "return", "false", ";", "}", "return", "allowsMisalignedMemoryAccessesImpl", "(", "VT", ".", "getSizeInBits", "(", ")", ",", "AddrSpace", ",", "Align", "(", "Alignment", ")", ",", "Flags", ",", "IsFast", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "allows", "unaligned", "memory", "accesses", "of", "the", "specified", "type", "." ]

[ "AMDGPU", "SI", "MVT::Other", "MVT::Other", "1024", "16" ]

[]

[ "<s>", "unsigned", "ARCInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "int", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "isLoad", "(", "Opcode", ")", ")", "{", "if", "(", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "&&", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "&&", "(", "isZeroImm", "(", "MI", ".", "getOperand", "(", "2", ")", ")", ")", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "ARC", "ARC", "1", "2", "2", "1", "0", "0" ]

[]

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

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

[ "X86", "X86", "X86", "X86::GR64RegClass", "X86::GR64RegClass", "\"Unexpected register class in CSRsViaCopy!\"", "\"Function should be nounwind in insertCopiesSplitCSR!\"" ]

[]

[ "<s>", "bool", "MipsAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ")", "{", "StringRef", "Mnemonic", ";", "if", "(", "requestsDoubleOperand", "(", "Name", ")", ")", "{", "setFpFormat", "(", "FP_FORMAT_D", ")", ";", "Operands", ".", "push_back", "(", "MipsOperand", "::", "CreateToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "Mnemonic", "=", "Name", ";", "}", "else", "{", "setDefaultFpFormat", "(", ")", ";", "size_t", "Start", "=", "0", ",", "Next", "=", "Name", ".", "find", "(", "'.'", ")", ";", "Mnemonic", "=", "Name", ".", "slice", "(", "Start", ",", "Next", ")", ";", "Operands", ".", "push_back", "(", "MipsOperand", "::", "CreateToken", "(", "Mnemonic", ",", "NameLoc", ")", ")", ";", "if", "(", "Next", "!=", "StringRef", "::", "npos", ")", "{", "size_t", "Dot", "=", "Name", ".", "find", "(", "'.'", ",", "Next", "+", "1", ")", ";", "StringRef", "Format", "=", "Name", ".", "slice", "(", "Next", ",", "Dot", ")", ";", "if", "(", "Dot", "==", "StringRef", "::", "npos", ")", "Operands", ".", "push_back", "(", "MipsOperand", "::", "CreateToken", "(", "Format", ",", "NameLoc", ")", ")", ";", "else", "{", "if", "(", "Name", ".", "startswith", "(", "\"c.\"", ")", ")", "{", "Operands", ".", "push_back", "(", "MipsOperand", "::", "CreateToken", "(", "\".\"", ",", "NameLoc", ")", ")", ";", "int", "Cc", "=", "ConvertCcString", "(", "Format", ")", ";", "if", "(", "Cc", "==", "-", "1", ")", "{", "return", "Error", "(", "NameLoc", ",", "\"Invalid conditional code\"", ")", ";", "}", "SMLoc", "E", "=", "SMLoc", "::", "getFromPointer", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ".", "getPointer", "(", ")", "-", "1", ")", ";", "Operands", ".", "push_back", "(", "MipsOperand", "::", "CreateImm", "(", "MCConstantExpr", "::", "Create", "(", "Cc", ",", "getContext", "(", ")", ")", ",", "NameLoc", ",", "E", ")", ")", ";", "}", "else", "{", "return", "parseMathOperation", "(", "Name", ",", "NameLoc", ",", "Operands", ")", ";", "}", "Format", "=", "Name", ".", "slice", "(", "Dot", ",", "StringRef", "::", "npos", ")", ";", "Operands", ".", "push_back", "(", "MipsOperand", "::", "CreateToken", "(", "Format", ",", "NameLoc", ")", ")", ";", "}", "setFpFormat", "(", "Format", ")", ";", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "ParseOperand", "(", "Operands", ",", "Mnemonic", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "ParseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "MipsOperand::CreateToken", "0", "MipsOperand::CreateToken", "1", "MipsOperand::CreateToken", "\"c.\"", "MipsOperand::CreateToken", "\".\"", "1", "\"Invalid conditional code\"", "1", "MipsOperand::CreateImm", "MipsOperand::CreateToken", "\"unexpected token in argument list\"", "\"unexpected token in argument list\"", "\"unexpected token in argument list\"" ]

[]

[ "<s>", "ARMBaseTargetMachine", "::", "ARMBaseTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "isLittle", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ",", "CPU", ",", "Options", ",", "isLittle", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "TT", ",", "RM", ")", ",", "getEffectiveCodeModel", "(", "CM", ",", "CodeModel", "::", "Small", ")", ",", "OL", ")", ",", "TargetABI", "(", "computeTargetABI", "(", "TT", ",", "CPU", ",", "Options", ")", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", ",", "isLittle", "(", "isLittle", ")", "{", "if", "(", "Options", ".", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "{", "if", "(", "isTargetHardFloat", "(", ")", ")", "this", "->", "Options", ".", "FloatABIType", "=", "FloatABI", "::", "Hard", ";", "else", "this", "->", "Options", ".", "FloatABIType", "=", "FloatABI", "::", "Soft", ";", "}", "if", "(", "Options", ".", "EABIVersion", "==", "EABI", "::", "Default", "||", "Options", ".", "EABIVersion", "==", "EABI", "::", "Unknown", ")", "{", "if", "(", "(", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "GNUEABI", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "GNUEABIHF", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "MuslEABI", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "MuslEABIHF", ")", "&&", "!", "(", "TargetTriple", ".", "isOSWindows", "(", ")", "||", "TargetTriple", ".", "isOSDarwin", "(", ")", ")", ")", "this", "->", "Options", ".", "EABIVersion", "=", "EABI", "::", "GNU", ";", "else", "this", "->", "Options", ".", "EABIVersion", "=", "EABI", "::", "EABI5", ";", "}", "if", "(", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "this", "->", "Options", ".", "NoTrapAfterNoreturn", "=", "true", ";", "}", "setSupportsDebugEntryValues", "(", "true", ")", ";", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "char", "*", "make_name", "(", "tree", "decl", ",", "const", "char", "*", "suffix", ",", "bool", "make_unique", ")", "{", "char", "*", "global_var_name", ";", "int", "name_len", ";", "const", "char", "*", "name", ";", "const", "char", "*", "unique_name", "=", "NULL", ";", "name", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ";", "if", "(", "make_unique", ")", "unique_name", "=", "IDENTIFIER_POINTER", "(", "get_file_function_name", "(", "\"\\0\"", ")", ")", ";", "name_len", "=", "strlen", "(", "name", ")", "+", "strlen", "(", "suffix", ")", "+", "2", ";", "if", "(", "make_unique", ")", "name_len", "+=", "strlen", "(", "unique_name", ")", "+", "1", ";", "global_var_name", "=", "XNEWVEC", "(", "char", ",", "name_len", ")", ";", "if", "(", "make_unique", ")", "snprintf", "(", "global_var_name", ",", "name_len", ",", "\"%s.%s.%s\"", ",", "name", ",", "unique_name", ",", "suffix", ")", ";", "else", "snprintf", "(", "global_var_name", ",", "name_len", ",", "\"%s.%s\"", ",", "name", ",", "suffix", ")", ";", "return", "global_var_name", ";", "}", "</s>" ]

[ "Return", "a", "new", "name", "by", "appending", "SUFFIX", "to", "the", "DECL", "name", ".", "If", "make_unique", "is", "true", ",", "append", "the", "full", "path", "name", "of", "the", "source", "file", "." ]

[ "i386", "\"\\0\"", "2", "1", "\"%s.%s.%s\"", "\"%s.%s\"" ]

[]

[ "<s>", "void", "AMDGPUUnifyDivergentExitNodes", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "if", "(", "RequireAndPreserveDomTree", ")", "AU", ".", "addRequired", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "PostDominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "LegacyDivergenceAnalysis", ">", "(", ")", ";", "if", "(", "RequireAndPreserveDomTree", ")", "{", "AU", ".", "addPreserved", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "}", "AU", ".", "addPreserved", "<", "LegacyDivergenceAnalysis", ">", "(", ")", ";", "AU", ".", "addPreservedID", "(", "BreakCriticalEdgesID", ")", ";", "AU", ".", "addPreservedID", "(", "LowerSwitchID", ")", ";", "FunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "AU", ".", "addRequired", "<", "TargetTransformInfoWrapperPass", ">", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "void", "dump", "(", "const", "GCNRegBankReassign", "*", "P", ")", "const", "{", "MI", "->", "dump", "(", ")", ";", "dbgs", "(", ")", "<<", "P", "->", "printReg", "(", "Reg", ")", "<<", "\" to banks \"", ";", "dumpFreeBanks", "(", "FreeBanks", ")", ";", "dbgs", "(", ")", "<<", "\" weight \"", "<<", "Weight", "<<", "'\\n'", ";", "}", "</s>" ]

[ "Dump", "the", "plan", "to", "stderr", "(", "for", "debugging", ")", "." ]

[ "AMDGPU", "\" to banks \"", "\" weight \"" ]

[]

[ "<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "override", "{", "return", "Patmos", "::", "NumTargetFixupKinds", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "Patmos", "Patmos::NumTargetFixupKinds" ]

[]

[ "<s>", "static", "void", "fold_mergehl_helper", "(", "gimple_stmt_iterator", "*", "gsi", ",", "gimple", "*", "stmt", ",", "int", "use_high", ")", "{", "tree", "arg0", "=", "gimple_call_arg", "(", "stmt", ",", "0", ")", ";", "tree", "arg1", "=", "gimple_call_arg", "(", "stmt", ",", "1", ")", ";", "tree", "lhs", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "tree", "lhs_type", "=", "TREE_TYPE", "(", "lhs", ")", ";", "tree", "lhs_type_type", "=", "TREE_TYPE", "(", "lhs_type", ")", ";", "int", "n_elts", "=", "TYPE_VECTOR_SUBPARTS", "(", "lhs_type", ")", ";", "int", "midpoint", "=", "n_elts", "/", "2", ";", "int", "offset", "=", "0", ";", "if", "(", "use_high", "==", "1", ")", "offset", "=", "midpoint", ";", "tree_vector_builder", "elts", "(", "lhs_type", ",", "VECTOR_CST_NELTS", "(", "arg0", ")", ",", "1", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "midpoint", ";", "i", "++", ")", "{", "elts", ".", "safe_push", "(", "build_int_cst", "(", "lhs_type_type", ",", "offset", "+", "i", ")", ")", ";", "elts", ".", "safe_push", "(", "build_int_cst", "(", "lhs_type_type", ",", "offset", "+", "n_elts", "+", "i", ")", ")", ";", "}", "tree", "permute", "=", "elts", ".", "build", "(", ")", ";", "gimple", "*", "g", "=", "gimple_build_assign", "(", "lhs", ",", "VEC_PERM_EXPR", ",", "arg0", ",", "arg1", ",", "permute", ")", ";", "gimple_set_location", "(", "g", ",", "gimple_location", "(", "stmt", ")", ")", ";", "gsi_replace", "(", "gsi", ",", "g", ",", "true", ")", ";", "}", "</s>" ]

[ "Helper", "function", "to", "handle", "the", "vector", "merge", "[", "hl", "]", "built-ins", ".", "The", "implementation", "difference", "between", "h", "and", "l", "versions", "for", "this", "code", "are", "in", "the", "values", "used", "when", "building", "of", "the", "permute", "vector", "for", "high", "word", "versus", "low", "word", "merge", ".", "The", "variance", "is", "keyed", "off", "the", "use_high", "parameter", "." ]

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

[]

[ "<s>", "bool", "GCNPassConfig", "::", "addLegalizeMachineIR", "(", ")", "{", "addPass", "(", "new", "Legalizer", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "a", "legalize", "pass", ",", "which", "converts", "the", "instruction", "sequence", "into", "one", "that", "can", "be", "selected", "by", "the", "target", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "AArch64AsmPrinter", "::", "emitStartOfAsmFile", "(", "Module", "&", "M", ")", "{", "if", "(", "!", "TM", ".", "getTargetTriple", "(", ")", ".", "isOSBinFormatELF", "(", ")", ")", "return", ";", "unsigned", "Flags", "=", "0", ";", "if", "(", "const", "auto", "*", "BTE", "=", "mdconst", "::", "extract_or_null", "<", "ConstantInt", ">", "(", "M", ".", "getModuleFlag", "(", "\"branch-target-enforcement\"", ")", ")", ")", "if", "(", "BTE", "->", "getZExtValue", "(", ")", ")", "Flags", "|=", "ELF", "::", "GNU_PROPERTY_AARCH64_FEATURE_1_BTI", ";", "if", "(", "const", "auto", "*", "Sign", "=", "mdconst", "::", "extract_or_null", "<", "ConstantInt", ">", "(", "M", ".", "getModuleFlag", "(", "\"sign-return-address\"", ")", ")", ")", "if", "(", "Sign", "->", "getZExtValue", "(", ")", ")", "Flags", "|=", "ELF", "::", "GNU_PROPERTY_AARCH64_FEATURE_1_PAC", ";", "if", "(", "Flags", "==", "0", ")", "return", ";", "if", "(", "auto", "*", "TS", "=", "static_cast", "<", "AArch64TargetStreamer", "*", ">", "(", "OutStreamer", "->", "getTargetStreamer", "(", ")", ")", ")", "TS", "->", "emitNoteSection", "(", "Flags", ")", ";", "}", "</s>" ]

[ "This", "virtual", "method", "can", "be", "overridden", "by", "targets", "that", "want", "to", "emit", "something", "at", "the", "start", "of", "their", "file", "." ]

[ "AArch64", "AArch64", "0", "\"branch-target-enforcement\"", "\"sign-return-address\"", "0", "AArch64" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "canRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "const", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "RealignStack", ")", "return", "false", ";", "if", "(", "AFI", "->", "isThumb1OnlyFunction", "(", ")", ")", "return", "false", ";", "if", "(", "!", "MRI", "->", "canReserveReg", "(", "FramePtr", ")", ")", "return", "false", ";", "if", "(", "!", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "return", "true", ";", "if", "(", "!", "EnableBasePointer", ")", "return", "false", ";", "return", "MRI", "->", "canReserveReg", "(", "BasePtr", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "PatmosInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "TBB", "&&", "\"InsertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "2", "||", "Cond", ".", "size", "(", ")", "==", "0", ")", "&&", "\"Patmos branch conditions should have two components (reg+imm)!\"", ")", ";", "if", "(", "FBB", "==", "0", ")", "{", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Patmos", "::", "BRu", ")", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "}", "else", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Patmos", "::", "BR", ")", ")", ".", "add", "(", "Cond", "[", "0", "]", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ".", "addMBB", "(", "TBB", ")", ";", "}", "return", "1", ";", "}", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Patmos", "::", "BR", ")", ")", ".", "add", "(", "Cond", "[", "0", "]", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ".", "addMBB", "(", "TBB", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Patmos", "::", "BRu", ")", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "return", "2", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "\"InsertBranch must not be told to insert a fallthrough\"", "2", "0", "\"Patmos branch conditions should have two components (reg+imm)!\"", "0", "Patmos::BRu", "Patmos::BR", "0", "1", "1", "Patmos::BR", "0", "1", "Patmos::BRu", "2" ]

[]

[ "<s>", "static", "tree", "xstormy16_handle_interrupt_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_TYPE", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qs attribute only applies to functions\"", ",", "IDENTIFIER_POINTER", "(", "name", ")", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "an", "``", "interrupt", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "stormy16", "\"%qs attribute only applies to functions\"" ]

[]

[ "<s>", "static", "enum", "tls_model", "tls_symbolic_operand_type", "(", "rtx", "addr", ")", "{", "enum", "tls_model", "tls_kind", "=", "TLS_MODEL_NONE", ";", "poly_int64", "offset", ";", "addr", "=", "strip_offset_and_salt", "(", "addr", ",", "&", "offset", ")", ";", "if", "(", "SYMBOL_REF_P", "(", "addr", ")", ")", "tls_kind", "=", "SYMBOL_REF_TLS_MODEL", "(", "addr", ")", ";", "return", "tls_kind", ";", "}", "</s>" ]

[ "Return", "the", "TLS", "model", "to", "use", "for", "SYMBOL", "." ]

[ "aarch64" ]

[]

[ "<s>", "virtual", "bool", "isProfitableToDupForIfCvt", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "NumCyles", ",", "float", "Probability", ",", "float", "Confidence", ")", "const", "{", "return", "NumCyles", "==", "1", ";", "}", "</s>" ]

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

[ "ARM", "1" ]

[]

[ "<s>", "bool", "FixupLEAPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "X86Subtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "bool", "IsSlowLEA", "=", "ST", ".", "slowLEA", "(", ")", ";", "bool", "IsSlow3OpsLEA", "=", "ST", ".", "slow3OpsLEA", "(", ")", ";", "bool", "LEAUsesAG", "=", "ST", ".", "LEAusesAG", "(", ")", ";", "bool", "OptIncDec", "=", "!", "ST", ".", "slowIncDec", "(", ")", "||", "MF", ".", "getFunction", "(", ")", ".", "hasOptSize", "(", ")", ";", "bool", "UseLEAForSP", "=", "ST", ".", "useLeaForSP", "(", ")", ";", "TSM", ".", "init", "(", "&", "ST", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Start X86FixupLEAs\\n\"", ";", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "++", "I", ")", "{", "if", "(", "!", "isLEA", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "continue", ";", "if", "(", "optTwoAddrLEA", "(", "I", ",", "MBB", ",", "OptIncDec", ",", "UseLEAForSP", ")", ")", "continue", ";", "if", "(", "IsSlowLEA", ")", "{", "processInstructionForSlowLEA", "(", "I", ",", "MBB", ")", ";", "}", "else", "if", "(", "IsSlow3OpsLEA", ")", "{", "if", "(", "auto", "*", "NewMI", "=", "processInstrForSlow3OpLEA", "(", "*", "I", ",", "MBB", ")", ")", "{", "MBB", ".", "erase", "(", "I", ")", ";", "I", "=", "NewMI", ";", "}", "}", "}", "if", "(", "LEAUsesAG", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "++", "I", ")", "processInstruction", "(", "I", ",", "MBB", ")", ";", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"End X86FixupLEAs\\n\"", ";", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"Start X86FixupLEAs\\n\"", "\"End X86FixupLEAs\\n\"" ]

[]

[ "<s>", "static", "tree", "v850_handle_interrupt_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute only applies to functions\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "an", "``", "interrupt", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "v850", "\"%qE attribute only applies to functions\"" ]

[]

[ "<s>", "int", "AMDGPUInstrInfo", "::", "pseudoToMCOpcode", "(", "int", "Opcode", ")", "const", "{", "SIEncodingFamily", "Gen", "=", "subtargetEncodingFamily", "(", "ST", ")", ";", "if", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "SDWA", ")", "Gen", "=", "ST", ".", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "GFX9", "?", "SIEncodingFamily", "::", "SDWA9", ":", "SIEncodingFamily", "::", "SDWA", ";", "int", "MCOp", "=", "AMDGPU", "::", "getMCOpcode", "(", "Opcode", ",", "Gen", ")", ";", "if", "(", "MCOp", "==", "-", "1", ")", "return", "Opcode", ";", "if", "(", "MCOp", "==", "(", "uint16_t", ")", "-", "1", ")", "return", "-", "1", ";", "return", "MCOp", ";", "}", "</s>" ]

[ "Return", "a", "target-specific", "opcode", "if", "Opcode", "is", "a", "pseudo", "instruction", "." ]

[ "AMDGPU", "AMDGPU", "SI", "SIInstrFlags::SDWA", "AMDGPU", "SIEncodingFamily::SDWA9", "SIEncodingFamily::SDWA", "AMDGPU::getMCOpcode", "1", "1", "1" ]

[]

[ "<s>", "static", "int", "getMemScale", "(", "MachineInstr", "*", "MI", ")", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Opcode has unknown scale!\"", ")", ";", "case", "AArch64", "::", "LDRBBui", ":", "case", "AArch64", "::", "STRBBui", ":", "return", "1", ";", "case", "AArch64", "::", "LDRHHui", ":", "case", "AArch64", "::", "LDURHHi", ":", "case", "AArch64", "::", "STRHHui", ":", "return", "2", ";", "case", "AArch64", "::", "LDRSui", ":", "case", "AArch64", "::", "LDURSi", ":", "case", "AArch64", "::", "LDRSWui", ":", "case", "AArch64", "::", "LDURSWi", ":", "case", "AArch64", "::", "LDRWui", ":", "case", "AArch64", "::", "LDURWi", ":", "case", "AArch64", "::", "STRSui", ":", "case", "AArch64", "::", "STURSi", ":", "case", "AArch64", "::", "STRWui", ":", "case", "AArch64", "::", "STURWi", ":", "case", "AArch64", "::", "LDPSi", ":", "case", "AArch64", "::", "LDPSWi", ":", "case", "AArch64", "::", "LDPWi", ":", "case", "AArch64", "::", "STPSi", ":", "case", "AArch64", "::", "STPWi", ":", "return", "4", ";", "case", "AArch64", "::", "LDRDui", ":", "case", "AArch64", "::", "LDURDi", ":", "case", "AArch64", "::", "LDRXui", ":", "case", "AArch64", "::", "LDURXi", ":", "case", "AArch64", "::", "STRDui", ":", "case", "AArch64", "::", "STURDi", ":", "case", "AArch64", "::", "STRXui", ":", "case", "AArch64", "::", "STURXi", ":", "case", "AArch64", "::", "LDPDi", ":", "case", "AArch64", "::", "LDPXi", ":", "case", "AArch64", "::", "STPDi", ":", "case", "AArch64", "::", "STPXi", ":", "return", "8", ";", "case", "AArch64", "::", "LDRQui", ":", "case", "AArch64", "::", "LDURQi", ":", "case", "AArch64", "::", "STRQui", ":", "case", "AArch64", "::", "STURQi", ":", "case", "AArch64", "::", "LDPQi", ":", "case", "AArch64", "::", "STPQi", ":", "return", "16", ";", "}", "}", "</s>" ]

[ "Scaling", "factor", "for", "(", "scaled", "or", "unscaled", ")", "load", "or", "store", "." ]

[ "AArch64", "\"Opcode has unknown scale!\"", "AArch64::LDRBBui", "AArch64::STRBBui", "1", "AArch64::LDRHHui", "AArch64::LDURHHi", "AArch64::STRHHui", "2", "AArch64::LDRSui", "AArch64::LDURSi", "AArch64::LDRSWui", "AArch64::LDURSWi", "AArch64::LDRWui", "AArch64::LDURWi", "AArch64::STRSui", "AArch64::STURSi", "AArch64::STRWui", "AArch64::STURWi", "AArch64::LDPSi", "AArch64::LDPSWi", "AArch64::LDPWi", "AArch64::STPSi", "AArch64::STPWi", "4", "AArch64::LDRDui", "AArch64::LDURDi", "AArch64::LDRXui", "AArch64::LDURXi", "AArch64::STRDui", "AArch64::STURDi", "AArch64::STRXui", "AArch64::STURXi", "AArch64::LDPDi", "AArch64::LDPXi", "AArch64::STPDi", "AArch64::STPXi", "8", "AArch64::LDRQui", "AArch64::LDURQi", "AArch64::STRQui", "AArch64::STURQi", "AArch64::LDPQi", "AArch64::STPQi", "16" ]

[]

[ "<s>", "static", "unsigned", "HOST_WIDE_INT", "arm_asan_shadow_offset", "(", "void", ")", "{", "return", "HOST_WIDE_INT_1U", "<<", "29", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_ASAN_SHADOW_OFFSET", "hook", "." ]

[ "arm", "29" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "get_probe_interval", "(", "void", ")", "{", "if", "(", "flag_stack_clash_protection", ")", "return", "(", "HOST_WIDE_INT_1U", "<<", "param_stack_clash_protection_probe_interval", ")", ";", "else", "return", "(", "HOST_WIDE_INT_1U", "<<", "STACK_CHECK_PROBE_INTERVAL_EXP", ")", ";", "}", "</s>" ]

[ "Return", "the", "probing", "interval", "for", "-fstack-clash-protection", "." ]

[ "i386" ]

[]

[ "<s>", "void", "output_addr_const_pdp11", "(", "FILE", "*", "file", ",", "rtx", "x", ")", "{", "char", "buf", "[", "256", "]", ";", "int", "i", ";", "restart", ":", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "PC", ":", "gcc_assert", "(", "flag_pic", ")", ";", "putc", "(", "'.'", ",", "file", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "assemble_name", "(", "file", ",", "XSTR", "(", "x", ",", "0", ")", ")", ";", "break", ";", "case", "LABEL_REF", ":", "ASM_GENERATE_INTERNAL_LABEL", "(", "buf", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ";", "assemble_name", "(", "file", ",", "buf", ")", ";", "break", ";", "case", "CODE_LABEL", ":", "ASM_GENERATE_INTERNAL_LABEL", "(", "buf", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "x", ")", ")", ";", "assemble_name", "(", "file", ",", "buf", ")", ";", "break", ";", "case", "CONST_INT", ":", "i", "=", "INTVAL", "(", "x", ")", ";", "if", "(", "i", "<", "0", ")", "{", "i", "=", "-", "i", ";", "fprintf", "(", "file", ",", "\"-\"", ")", ";", "}", "fprintf", "(", "file", ",", "\"%#o\"", ",", "i", "&", "0xffff", ")", ";", "break", ";", "case", "CONST", ":", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "break", ";", "case", "CONST_DOUBLE", ":", "if", "(", "GET_MODE", "(", "x", ")", "==", "VOIDmode", ")", "{", "gcc_assert", "(", "!", "CONST_DOUBLE_HIGH", "(", "x", ")", ")", ";", "fprintf", "(", "file", ",", "\"%#ho\"", ",", "(", "unsigned", "short", ")", "CONST_DOUBLE_LOW", "(", "x", ")", ")", ";", "}", "else", "output_operand_lossage", "(", "\"floating constant misused\"", ")", ";", "break", ";", "case", "PLUS", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "CONST_INT", ")", "{", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "if", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "0", ")", ")", ">=", "0", ")", "fprintf", "(", "file", ",", "\"+\"", ")", ";", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "}", "else", "{", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "if", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">=", "0", ")", "fprintf", "(", "file", ",", "\"+\"", ")", ";", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "}", "break", ";", "case", "MINUS", ":", "x", "=", "simplify_subtraction", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "MINUS", ")", "goto", "restart", ";", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">=", "0", ")", "fprintf", "(", "file", ",", "\"-\"", ")", ";", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "break", ";", "case", "ZERO_EXTEND", ":", "case", "SIGN_EXTEND", ":", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "break", ";", "default", ":", "output_operand_lossage", "(", "\"invalid expression as operand\"", ")", ";", "}", "}", "</s>" ]

[ "A", "copy", "of", "output_addr_const", "modified", "for", "pdp11", "expression", "syntax", ".", "output_addr_const", "also", "gets", "called", "for", "%", "cDIGIT", "and", "%", "nDIGIT", ",", "which", "we", "do", "n't", "use", ",", "and", "for", "debugging", "output", ",", "which", "we", "do", "n't", "support", "with", "this", "port", "either", ".", "So", "this", "copy", "should", "get", "called", "whenever", "needed", "." ]

[ "pdp11", "256", "0", "\"L\"", "0", "\"L\"", "0", "\"-\"", "\"%#o\"", "0xffff", "0", "\"%#ho\"", "\"floating constant misused\"", "0", "1", "0", "0", "\"+\"", "0", "0", "1", "0", "\"+\"", "1", "0", "1", "1", "0", "\"-\"", "1", "0", "\"invalid expression as operand\"" ]

[]

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

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

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

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"MIPS DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "Mips", "\"MIPS DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "static", "void", "rs6000_darwin64_record_arg_flush", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "HOST_WIDE_INT", "bitpos", ",", "rtx", "rvec", "[", "]", ",", "int", "*", "k", ")", "{", "machine_mode", "mode", ";", "unsigned", "int", "regno", ";", "unsigned", "int", "startbit", ",", "endbit", ";", "int", "this_regno", ",", "intregs", ",", "intoffset", ";", "rtx", "reg", ";", "if", "(", "cum", "->", "intoffset", "==", "-", "1", ")", "return", ";", "intoffset", "=", "cum", "->", "intoffset", ";", "cum", "->", "intoffset", "=", "-", "1", ";", "if", "(", "intoffset", "%", "BITS_PER_WORD", "!=", "0", ")", "{", "mode", "=", "mode_for_size", "(", "BITS_PER_WORD", "-", "intoffset", "%", "BITS_PER_WORD", ",", "MODE_INT", ",", "0", ")", ";", "if", "(", "mode", "==", "BLKmode", ")", "{", "intoffset", "=", "intoffset", "&", "-", "BITS_PER_WORD", ";", "mode", "=", "word_mode", ";", "}", "}", "else", "mode", "=", "word_mode", ";", "startbit", "=", "intoffset", "&", "-", "BITS_PER_WORD", ";", "endbit", "=", "(", "bitpos", "+", "BITS_PER_WORD", "-", "1", ")", "&", "-", "BITS_PER_WORD", ";", "intregs", "=", "(", "endbit", "-", "startbit", ")", "/", "BITS_PER_WORD", ";", "this_regno", "=", "cum", "->", "words", "+", "intoffset", "/", "BITS_PER_WORD", ";", "if", "(", "intregs", ">", "0", "&&", "intregs", ">", "GP_ARG_NUM_REG", "-", "this_regno", ")", "cum", "->", "use_stack", "=", "1", ";", "intregs", "=", "MIN", "(", "intregs", ",", "GP_ARG_NUM_REG", "-", "this_regno", ")", ";", "if", "(", "intregs", "<=", "0", ")", "return", ";", "intoffset", "/=", "BITS_PER_UNIT", ";", "do", "{", "regno", "=", "GP_ARG_MIN_REG", "+", "this_regno", ";", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "rvec", "[", "(", "*", "k", ")", "++", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg", ",", "GEN_INT", "(", "intoffset", ")", ")", ";", "this_regno", "+=", "1", ";", "intoffset", "=", "(", "intoffset", "|", "(", "UNITS_PER_WORD", "-", "1", ")", ")", "+", "1", ";", "mode", "=", "word_mode", ";", "intregs", "-=", "1", ";", "}", "while", "(", "intregs", ">", "0", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "rs6000_darwin64_record_arg", ".", "Assign", "the", "bits", "of", "the", "structure", "between", "cum-", ">", "intoffset", "and", "bitpos", "to", "integer", "registers", "." ]

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

[]

[ "<s>", "static", "inline", "bool", "save_global_or_fp_reg_p", "(", "unsigned", "int", "regno", ",", "int", "leaf_function", "ATTRIBUTE_UNUSED", ")", "{", "return", "!", "call_used_regs", "[", "regno", "]", "&&", "df_regs_ever_live_p", "(", "regno", ")", ";", "}", "</s>" ]

[ "Return", "whether", "REGNO", ",", "a", "global", "or", "FP", "register", ",", "must", "be", "saved/restored", "." ]

[ "sparc" ]

[]

[ "<s>", "rtx", "mips_return_addr", "(", "int", "count", ",", "rtx", "frame", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "count", "!=", "0", ")", "return", "const0_rtx", ";", "return", "get_hard_reg_initial_val", "(", "Pmode", ",", "GP_REG_FIRST", "+", "31", ")", ";", "}", "</s>" ]

[ "Implement", "RETURN_ADDR_RTX", ".", "Note", ",", "we", "do", "not", "support", "moving", "back", "to", "a", "previous", "frame", "." ]

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

[]

[ "<s>", "bool", "WebAssemblyFastISel", "::", "fastLowerArguments", "(", ")", "{", "if", "(", "!", "FuncInfo", ".", "CanLowerReturn", ")", "return", "false", ";", "const", "Function", "*", "F", "=", "FuncInfo", ".", "Fn", ";", "if", "(", "F", "->", "isVarArg", "(", ")", ")", "return", "false", ";", "unsigned", "i", "=", "0", ";", "for", "(", "auto", "const", "&", "Arg", ":", "F", "->", "args", "(", ")", ")", "{", "const", "AttributeList", "&", "Attrs", "=", "F", "->", "getAttributes", "(", ")", ";", "if", "(", "Attrs", ".", "hasParamAttribute", "(", "i", ",", "Attribute", "::", "ByVal", ")", "||", "Attrs", ".", "hasParamAttribute", "(", "i", ",", "Attribute", "::", "SwiftSelf", ")", "||", "Attrs", ".", "hasParamAttribute", "(", "i", ",", "Attribute", "::", "SwiftError", ")", "||", "Attrs", ".", "hasParamAttribute", "(", "i", ",", "Attribute", "::", "InAlloca", ")", "||", "Attrs", ".", "hasParamAttribute", "(", "i", ",", "Attribute", "::", "Nest", ")", ")", "return", "false", ";", "Type", "*", "ArgTy", "=", "Arg", ".", "getType", "(", ")", ";", "if", "(", "ArgTy", "->", "isStructTy", "(", ")", "||", "ArgTy", "->", "isArrayTy", "(", ")", ")", "return", "false", ";", "if", "(", "!", "Subtarget", "->", "hasSIMD128", "(", ")", "&&", "ArgTy", "->", "isVectorTy", "(", ")", ")", "return", "false", ";", "unsigned", "Opc", ";", "const", "TargetRegisterClass", "*", "RC", ";", "switch", "(", "getSimpleType", "(", "ArgTy", ")", ")", "{", "case", "MVT", "::", "i1", ":", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "Opc", "=", "WebAssembly", "::", "ARGUMENT_I32", ";", "RC", "=", "&", "WebAssembly", "::", "I32RegClass", ";", "break", ";", "case", "MVT", "::", "i64", ":", "Opc", "=", "WebAssembly", "::", "ARGUMENT_I64", ";", "RC", "=", "&", "WebAssembly", "::", "I64RegClass", ";", "break", ";", "case", "MVT", "::", "f32", ":", "Opc", "=", "WebAssembly", "::", "ARGUMENT_F32", ";", "RC", "=", "&", "WebAssembly", "::", "F32RegClass", ";", "break", ";", "case", "MVT", "::", "f64", ":", "Opc", "=", "WebAssembly", "::", "ARGUMENT_F64", ";", "RC", "=", "&", "WebAssembly", "::", "F64RegClass", ";", "break", ";", "case", "MVT", "::", "v16i8", ":", "Opc", "=", "WebAssembly", "::", "ARGUMENT_v16i8", ";", "RC", "=", "&", "WebAssembly", "::", "V128RegClass", ";", "break", ";", "case", "MVT", "::", "v8i16", ":", "Opc", "=", "WebAssembly", "::", "ARGUMENT_v8i16", ";", "RC", "=", "&", "WebAssembly", "::", "V128RegClass", ";", "break", ";", "case", "MVT", "::", "v4i32", ":", "Opc", "=", "WebAssembly", "::", "ARGUMENT_v4i32", ";", "RC", "=", "&", "WebAssembly", "::", "V128RegClass", ";", "break", ";", "case", "MVT", "::", "v4f32", ":", "Opc", "=", "WebAssembly", "::", "ARGUMENT_v4f32", ";", "RC", "=", "&", "WebAssembly", "::", "V128RegClass", ";", "break", ";", "default", ":", "return", "false", ";", "}", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", ")", ".", "addImm", "(", "i", ")", ";", "updateValueMap", "(", "&", "Arg", ",", "ResultReg", ")", ";", "++", "i", ";", "}", "MRI", ".", "addLiveIn", "(", "WebAssembly", "::", "ARGUMENTS", ")", ";", "auto", "*", "MFI", "=", "MF", "->", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "for", "(", "auto", "const", "&", "Arg", ":", "F", "->", "args", "(", ")", ")", "MFI", "->", "addParam", "(", "getLegalType", "(", "getSimpleType", "(", "Arg", ".", "getType", "(", ")", ")", ")", ")", ";", "if", "(", "!", "F", "->", "getReturnType", "(", ")", "->", "isVoidTy", "(", ")", ")", "MFI", "->", "addResult", "(", "getLegalType", "(", "getSimpleType", "(", "F", "->", "getReturnType", "(", ")", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "to", "do", "target-", "specific", "argument", "lowering", "." ]

[ "WebAssembly", "WebAssembly", "0", "MVT::i1", "MVT::i8", "MVT::i16", "MVT::i32", "WebAssembly::ARGUMENT_I32", "WebAssembly::I32RegClass", "MVT::i64", "WebAssembly::ARGUMENT_I64", "WebAssembly::I64RegClass", "MVT::f32", "WebAssembly::ARGUMENT_F32", "WebAssembly::F32RegClass", "MVT::f64", "WebAssembly::ARGUMENT_F64", "WebAssembly::F64RegClass", "MVT::v16i8", "WebAssembly::ARGUMENT_v16i8", "WebAssembly::V128RegClass", "MVT::v8i16", "WebAssembly::ARGUMENT_v8i16", "WebAssembly::V128RegClass", "MVT::v4i32", "WebAssembly::ARGUMENT_v4i32", "WebAssembly::V128RegClass", "MVT::v4f32", "WebAssembly::ARGUMENT_v4f32", "WebAssembly::V128RegClass", "WebAssembly::ARGUMENTS", "WebAssembly" ]

[]

[ "<s>", "static", "MachineInstr", "*", "findLoopInstr", "(", "MachineBasicBlock", "*", "BB", ",", "unsigned", "EndLoopOp", ",", "MachineBasicBlock", "*", "TargetBB", ",", "SmallPtrSet", "<", "MachineBasicBlock", "*", ",", "8", ">", "&", "Visited", ")", "{", "unsigned", "LOOPi", ";", "unsigned", "LOOPr", ";", "if", "(", "EndLoopOp", "==", "Hexagon", "::", "ENDLOOP0", ")", "{", "LOOPi", "=", "Hexagon", "::", "J2_loop0i", ";", "LOOPr", "=", "Hexagon", "::", "J2_loop0r", ";", "}", "else", "{", "LOOPi", "=", "Hexagon", "::", "J2_loop1i", ";", "LOOPr", "=", "Hexagon", "::", "J2_loop1r", ";", "}", "for", "(", "MachineBasicBlock", "*", "PB", ":", "BB", "->", "predecessors", "(", ")", ")", "{", "if", "(", "!", "Visited", ".", "insert", "(", "PB", ")", ".", "second", ")", "continue", ";", "if", "(", "PB", "==", "BB", ")", "continue", ";", "for", "(", "auto", "I", "=", "PB", "->", "instr_rbegin", "(", ")", ",", "E", "=", "PB", "->", "instr_rend", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "LOOPi", "||", "Opc", "==", "LOOPr", ")", "return", "&", "*", "I", ";", "if", "(", "Opc", "==", "EndLoopOp", "&&", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", "!=", "TargetBB", ")", "return", "nullptr", ";", "}", "if", "(", "MachineInstr", "*", "Loop", "=", "findLoopInstr", "(", "PB", ",", "EndLoopOp", ",", "TargetBB", ",", "Visited", ")", ")", "return", "Loop", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "Find", "the", "hardware", "loop", "instruction", "used", "to", "set-up", "the", "specified", "loop", "." ]

[ "Hexagon", "8", "Hexagon::ENDLOOP0", "Hexagon::J2_loop0i", "Hexagon::J2_loop0r", "Hexagon::J2_loop1i", "Hexagon::J2_loop1r", "0" ]

[]

[ "<s>", "Optional", "<", "MCFixupKind", ">", "MipsAsmBackend", "::", "getFixupKind", "(", "StringRef", "Name", ")", "const", "{", "return", "StringSwitch", "<", "Optional", "<", "MCFixupKind", ">>", "(", "Name", ")", ".", "Case", "(", "\"R_MIPS_NONE\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_NONE", ")", ".", "Case", "(", "\"R_MIPS_32\"", ",", "FK_Data_4", ")", ".", "Case", "(", "\"R_MIPS_GOT_PAGE\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_GOT_PAGE", ")", ".", "Case", "(", "\"R_MIPS_CALL_HI16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_CALL_HI16", ")", ".", "Case", "(", "\"R_MIPS_CALL_LO16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_CALL_LO16", ")", ".", "Case", "(", "\"R_MIPS_CALL16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_CALL16", ")", ".", "Case", "(", "\"R_MIPS_GOT16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_GOT", ")", ".", "Case", "(", "\"R_MIPS_GOT_PAGE\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_GOT_PAGE", ")", ".", "Case", "(", "\"R_MIPS_GOT_OFST\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_GOT_OFST", ")", ".", "Case", "(", "\"R_MIPS_GOT_DISP\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_GOT_DISP", ")", ".", "Case", "(", "\"R_MIPS_GOT_HI16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_GOT_HI16", ")", ".", "Case", "(", "\"R_MIPS_GOT_LO16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_GOT_LO16", ")", ".", "Case", "(", "\"R_MIPS_TLS_GOTTPREL\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_GOTTPREL", ")", ".", "Case", "(", "\"R_MIPS_TLS_DTPREL_HI16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_DTPREL_HI", ")", ".", "Case", "(", "\"R_MIPS_TLS_DTPREL_LO16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_DTPREL_LO", ")", ".", "Case", "(", "\"R_MIPS_TLS_GD\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_TLSGD", ")", ".", "Case", "(", "\"R_MIPS_TLS_LDM\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_TLSLDM", ")", ".", "Case", "(", "\"R_MIPS_TLS_TPREL_HI16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_TPREL_HI", ")", ".", "Case", "(", "\"R_MIPS_TLS_TPREL_LO16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_TPREL_LO", ")", ".", "Case", "(", "\"R_MICROMIPS_CALL16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_CALL16", ")", ".", "Case", "(", "\"R_MICROMIPS_GOT_DISP\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_GOT_DISP", ")", ".", "Case", "(", "\"R_MICROMIPS_GOT_PAGE\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_GOT_PAGE", ")", ".", "Case", "(", "\"R_MICROMIPS_GOT_OFST\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_GOT_OFST", ")", ".", "Case", "(", "\"R_MICROMIPS_GOT16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_GOT16", ")", ".", "Case", "(", "\"R_MICROMIPS_TLS_GOTTPREL\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_GOTTPREL", ")", ".", "Case", "(", "\"R_MICROMIPS_TLS_DTPREL_HI16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_TLS_DTPREL_HI16", ")", ".", "Case", "(", "\"R_MICROMIPS_TLS_DTPREL_LO16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_TLS_DTPREL_LO16", ")", ".", "Case", "(", "\"R_MICROMIPS_TLS_GD\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_TLS_GD", ")", ".", "Case", "(", "\"R_MICROMIPS_TLS_LDM\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_TLS_LDM", ")", ".", "Case", "(", "\"R_MICROMIPS_TLS_TPREL_HI16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_TLS_TPREL_HI16", ")", ".", "Case", "(", "\"R_MICROMIPS_TLS_TPREL_LO16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_TLS_TPREL_LO16", ")", ".", "Default", "(", "MCAsmBackend", "::", "getFixupKind", "(", "Name", ")", ")", ";", "}", "</s>" ]

[ "getFixupKind", "-", "Get", "the", "fixup", "kind", "of", "this", "expression", "." ]

[ "Mips", "Mips", "\"R_MIPS_NONE\"", "Mips::fixup_Mips_NONE", "\"R_MIPS_32\"", "\"R_MIPS_GOT_PAGE\"", "Mips::fixup_Mips_GOT_PAGE", "\"R_MIPS_CALL_HI16\"", "Mips::fixup_Mips_CALL_HI16", "\"R_MIPS_CALL_LO16\"", "Mips::fixup_Mips_CALL_LO16", "\"R_MIPS_CALL16\"", "Mips::fixup_Mips_CALL16", "\"R_MIPS_GOT16\"", "Mips::fixup_Mips_GOT", "\"R_MIPS_GOT_PAGE\"", "Mips::fixup_Mips_GOT_PAGE", "\"R_MIPS_GOT_OFST\"", "Mips::fixup_Mips_GOT_OFST", "\"R_MIPS_GOT_DISP\"", "Mips::fixup_Mips_GOT_DISP", "\"R_MIPS_GOT_HI16\"", "Mips::fixup_Mips_GOT_HI16", "\"R_MIPS_GOT_LO16\"", "Mips::fixup_Mips_GOT_LO16", "\"R_MIPS_TLS_GOTTPREL\"", "Mips::fixup_Mips_GOTTPREL", "\"R_MIPS_TLS_DTPREL_HI16\"", "Mips::fixup_Mips_DTPREL_HI", "\"R_MIPS_TLS_DTPREL_LO16\"", "Mips::fixup_Mips_DTPREL_LO", "\"R_MIPS_TLS_GD\"", "Mips::fixup_Mips_TLSGD", "\"R_MIPS_TLS_LDM\"", "Mips::fixup_Mips_TLSLDM", "\"R_MIPS_TLS_TPREL_HI16\"", "Mips::fixup_Mips_TPREL_HI", "\"R_MIPS_TLS_TPREL_LO16\"", "Mips::fixup_Mips_TPREL_LO", "\"R_MICROMIPS_CALL16\"", "Mips::fixup_MICROMIPS_CALL16", "\"R_MICROMIPS_GOT_DISP\"", "Mips::fixup_MICROMIPS_GOT_DISP", "\"R_MICROMIPS_GOT_PAGE\"", "Mips::fixup_MICROMIPS_GOT_PAGE", "\"R_MICROMIPS_GOT_OFST\"", "Mips::fixup_MICROMIPS_GOT_OFST", "\"R_MICROMIPS_GOT16\"", "Mips::fixup_MICROMIPS_GOT16", "\"R_MICROMIPS_TLS_GOTTPREL\"", "Mips::fixup_MICROMIPS_GOTTPREL", "\"R_MICROMIPS_TLS_DTPREL_HI16\"", "Mips::fixup_MICROMIPS_TLS_DTPREL_HI16", "\"R_MICROMIPS_TLS_DTPREL_LO16\"", "Mips::fixup_MICROMIPS_TLS_DTPREL_LO16", "\"R_MICROMIPS_TLS_GD\"", "Mips::fixup_MICROMIPS_TLS_GD", "\"R_MICROMIPS_TLS_LDM\"", "Mips::fixup_MICROMIPS_TLS_LDM", "\"R_MICROMIPS_TLS_TPREL_HI16\"", "Mips::fixup_MICROMIPS_TLS_TPREL_HI16", "\"R_MICROMIPS_TLS_TPREL_LO16\"", "Mips::fixup_MICROMIPS_TLS_TPREL_LO16" ]

[]

[ "<s>", "bool", "X86RegisterInfo", "::", "hasReservedSpillSlot", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Reg", ",", "int", "&", "FrameIdx", ")", "const", "{", "if", "(", "Reg", "==", "FramePtr", "&&", "hasFP", "(", "MF", ")", ")", "{", "FrameIdx", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectIndexBegin", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "target", "has", "reserved", "a", "spill", "slot", "in", "the", "stack", "frame", "of", "the", "given", "function", "for", "the", "specified", "register", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "std", "::", "string", "getDataLayout", "(", ")", "const", "{", "return", "\"e-p:32:32-i:32:32-f:32:32\"", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "Mandarin", "\"e-p:32:32-i:32:32-f:32:32\"" ]

[]

[ "<s>", "FunctionPass", "*", "NVPTXPassConfig", "::", "createTargetRegisterAllocator", "(", "bool", ")", "{", "return", "0", ";", "}", "</s>" ]

[ "createTargetRegisterAllocator", "-", "Create", "the", "register", "allocator", "pass", "for", "this", "target", "at", "the", "current", "optimization", "level", "." ]

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

[]

[ "<s>", "static", "bool", "pdp11_legitimate_constant_p", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "return", "GET_CODE", "(", "x", ")", "!=", "CONST_DOUBLE", "||", "legitimate_const_double_p", "(", "x", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMATE_CONSTANT_P", "." ]

[ "pdp11" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "ARMTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'l'", ":", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "tGPRRegisterClass", ")", ";", "else", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "GPRRegisterClass", ")", ";", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "GPRRegisterClass", ")", ";", "case", "'w'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "SPRRegisterClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "DPRRegisterClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "QPRRegisterClass", ")", ";", "break", ";", "}", "}", "if", "(", "StringRef", "(", "\"{cc}\"", ")", ".", "equals_lower", "(", "Constraint", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "CCRRegisterClass", ")", ";", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "1", "0", "0U", "ARM::tGPRRegisterClass", "0U", "ARM::GPRRegisterClass", "0U", "ARM::GPRRegisterClass", "MVT::f32", "0U", "ARM::SPRRegisterClass", "64", "0U", "ARM::DPRRegisterClass", "128", "0U", "ARM::QPRRegisterClass", "\"{cc}\"", "0U", "ARM::CCRRegisterClass" ]

[]

[ "<s>", "void", "WebAssemblyFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "auto", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "assert", "(", "MFI", "->", "getCalleeSavedInfo", "(", ")", ".", "empty", "(", ")", "&&", "\"WebAssembly should not have callee-saved registers\"", ")", ";", "if", "(", "!", "needsSP", "(", "MF", ",", "*", "MFI", ")", ")", "return", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "InsertPt", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "const", "TargetRegisterClass", "*", "PtrRC", "=", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getPointerRegClass", "(", "MF", ")", ";", "unsigned", "Zero", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "unsigned", "SPReg", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "const", "char", "*", "ES", "=", "\"__stack_pointer\"", ";", "auto", "*", "SPSymbol", "=", "MF", ".", "createExternalSymbolName", "(", "ES", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "CONST_I32", ")", ",", "Zero", ")", ".", "addImm", "(", "0", ")", ";", "auto", "*", "LoadMMO", "=", "new", "MachineMemOperand", "(", "MachinePointerInfo", "(", "MF", ".", "getPSVManager", "(", ")", ".", "getExternalSymbolCallEntry", "(", "ES", ")", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "4", ",", "4", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "LOAD_I32", ")", ",", "StackSize", "?", "SPReg", ":", "(", "unsigned", ")", "WebAssembly", "::", "SP32", ")", ".", "addExternalSymbol", "(", "SPSymbol", ")", ".", "addReg", "(", "Zero", ")", ".", "addImm", "(", "2", ")", ".", "addMemOperand", "(", "LoadMMO", ")", ";", "if", "(", "StackSize", ")", "{", "unsigned", "OffsetReg", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "CONST_I32", ")", ",", "OffsetReg", ")", ".", "addImm", "(", "StackSize", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "SUB_I32", ")", ",", "WebAssembly", "::", "SP32", ")", ".", "addReg", "(", "SPReg", ")", ".", "addReg", "(", "OffsetReg", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "COPY", ")", ",", "WebAssembly", "::", "FP32", ")", ".", "addReg", "(", "WebAssembly", "::", "SP32", ")", ";", "}", "if", "(", "StackSize", "&&", "needsSPWriteback", "(", "MF", ",", "*", "MFI", ")", ")", "{", "writeSPToMemory", "(", "WebAssembly", "::", "SP32", ",", "MF", ",", "MBB", ",", "InsertPt", ",", "InsertPt", ",", "DL", ")", ";", "}", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"WebAssembly should not have callee-saved registers\"", "WebAssembly", "\"__stack_pointer\"", "WebAssembly::CONST_I32", "0", "4", "4", "WebAssembly::LOAD_I32", "WebAssembly::SP32", "2", "WebAssembly::CONST_I32", "WebAssembly::SUB_I32", "WebAssembly::SP32", "WebAssembly::COPY", "WebAssembly::FP32", "WebAssembly::SP32", "WebAssembly::SP32" ]

[]

[ "<s>", "void", "TPCHazardRecognizer", "::", "EmitInstruction", "(", "MachineInstr", "*", "MI", ")", "{", "if", "(", "!", "MI", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" *** Start new cycle\\n\"", ")", ";", "return", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"TPCHazardRecognizer :: EmitInstruction: \"", "<<", "*", "MI", ")", ";", "if", "(", "MI", "->", "isPseudo", "(", ")", ")", "{", "return", ";", "}", "if", "(", "Resources", "->", "canReserveResources", "(", "*", "MI", ")", ")", "{", "Resources", "->", "reserveResources", "(", "*", "MI", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" *** Added to packet\\n\"", ")", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" *** Start new cycle\\n\"", ")", ";", "}", "}", "</s>" ]

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

[ "TPC", "TPC", "\" *** Start new cycle\\n\"", "\"TPCHazardRecognizer :: EmitInstruction: \"", "\" *** Added to packet\\n\"", "\" *** Start new cycle\\n\"" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "TBB", "&&", "\"insertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "1", "||", "Cond", ".", "size", "(", ")", "==", "0", ")", "&&", "\"X86 branch conditions have one component!\"", ")", ";", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "assert", "(", "!", "FBB", "&&", "\"Unconditional branch with multiple successors!\"", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "X86", "::", "JMP_1", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "bool", "FallThru", "=", "FBB", "==", "nullptr", ";", "unsigned", "Count", "=", "0", ";", "X86", "::", "CondCode", "CC", "=", "(", "X86", "::", "CondCode", ")", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "switch", "(", "CC", ")", "{", "case", "X86", "::", "COND_NE_OR_P", ":", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "X86", "::", "JNE_1", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "++", "Count", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "X86", "::", "JP_1", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "++", "Count", ";", "break", ";", "case", "X86", "::", "COND_E_AND_NP", ":", "if", "(", "FBB", "==", "nullptr", ")", "{", "FBB", "=", "getFallThroughMBB", "(", "&", "MBB", ",", "TBB", ")", ";", "assert", "(", "FBB", "&&", "\"MBB cannot be the last block in function when the false \"", "\"body is a fall-through.\"", ")", ";", "}", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "X86", "::", "JNE_1", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "++", "Count", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "X86", "::", "JNP_1", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "++", "Count", ";", "break", ";", "default", ":", "{", "unsigned", "Opc", "=", "GetCondBranchFromCond", "(", "CC", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Opc", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "++", "Count", ";", "}", "}", "if", "(", "!", "FallThru", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "X86", "::", "JMP_1", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"insertBranch must not be told to insert a fallthrough\"", "1", "0", "\"X86 branch conditions have one component!\"", "\"code size not handled\"", "\"Unconditional branch with multiple successors!\"", "X86::JMP_1", "1", "0", "X86::CondCode", "X86::CondCode", "0", "X86::COND_NE_OR_P", "X86::JNE_1", "X86::JP_1", "X86::COND_E_AND_NP", "\"MBB cannot be the last block in function when the false \"", "\"body is a fall-through.\"", "X86::JNE_1", "X86::JNP_1", "X86::JMP_1" ]

[]

[ "<s>", "bool", "HexagonPassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "!", "DisableHardwareLoops", ")", "{", "addPass", "(", "createHexagonFixupHwLoops", "(", ")", ")", ";", "}", "addPass", "(", "createHexagonNewValueJump", "(", ")", ")", ";", "addPass", "(", "createHexagonExpandPredSpillCode", "(", "getHexagonTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createHexagonSplitTFRCondSets", "(", "getHexagonTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createHexagonPacketizer", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "ix86_emit_restore_sse_regs_using_mov", "(", "HOST_WIDE_INT", "cfa_offset", ",", "bool", "maybe_eh_return", ")", "{", "unsigned", "int", "regno", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "SSE_REGNO_P", "(", "regno", ")", "&&", "ix86_save_reg", "(", "regno", ",", "maybe_eh_return", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "V4SFmode", ",", "regno", ")", ";", "rtx", "mem", ";", "mem", "=", "choose_baseaddr", "(", "cfa_offset", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "V4SFmode", ",", "mem", ")", ";", "set_mem_align", "(", "mem", ",", "128", ")", ";", "emit_move_insn", "(", "reg", ",", "mem", ")", ";", "ix86_add_cfa_restore_note", "(", "NULL_RTX", ",", "reg", ",", "cfa_offset", ")", ";", "cfa_offset", "-=", "16", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "tree", "alpha_fold_builtin_zapnot", "(", "tree", "*", "op", ",", "unsigned", "HOST_WIDE_INT", "opint", "[", "]", ",", "long", "op_const", ")", "{", "if", "(", "op_const", "&", "2", ")", "{", "unsigned", "HOST_WIDE_INT", "mask", "=", "0", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "++", "i", ")", "if", "(", "(", "opint", "[", "1", "]", ">>", "i", ")", "&", "1", ")", "mask", "|=", "(", "unsigned", "HOST_WIDE_INT", ")", "0xff", "<<", "(", "i", "*", "8", ")", ";", "if", "(", "op_const", "&", "1", ")", "return", "build_int_cst", "(", "long_integer_type_node", ",", "opint", "[", "0", "]", "&", "mask", ")", ";", "if", "(", "op", ")", "return", "fold", "(", "build2", "(", "BIT_AND_EXPR", ",", "long_integer_type_node", ",", "op", "[", "0", "]", ",", "build_int_cst", "(", "long_integer_type_node", ",", "mask", ")", ")", ")", ";", "}", "else", "if", "(", "(", "op_const", "&", "1", ")", "&&", "opint", "[", "0", "]", "==", "0", ")", "return", "build_int_cst", "(", "long_integer_type_node", ",", "0", ")", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Fold", "the", "builtin", "for", "the", "ZAPNOT", "instruction", ".", "This", "is", "essentially", "a", "specialized", "form", "of", "an", "AND", "operation", ".", "Other", "byte", "manipulation", "instructions", "are", "defined", "in", "terms", "of", "this", "instruction", ",", "so", "this", "is", "also", "used", "as", "a", "subroutine", "for", "other", "builtins", ".", "OP", "contains", "the", "tree", "operands", ";", "OPINT", "contains", "the", "extracted", "integer", "values", ".", "Bit", "N", "of", "OP_CONST", "it", "set", "if", "OPINT", "[", "N", "]", "is", "valid", ".", "OP", "may", "be", "null", "if", "only", "OPINT", "may", "be", "considered", "." ]

[ "alpha", "2", "0", "0", "8", "1", "1", "0xff", "8", "1", "0", "0", "1", "0", "0", "0" ]

[]

[ "<s>", "bool", "TGSICFGStructurizer", "::", "isReturnBlock", "(", "MachineBasicBlock", "*", "MBB", ")", "{", "MachineInstr", "*", "MI", "=", "getReturnInstr", "(", "MBB", ")", ";", "bool", "IsReturn", "=", "(", "MBB", "->", "succ_size", "(", ")", "==", "0", ")", ";", "if", "(", "MI", ")", "assert", "(", "IsReturn", ")", ";", "else", "if", "(", "IsReturn", ")", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"BB\"", "<<", "MBB", "->", "getNumber", "(", ")", "<<", "\" is return block without RET instr\\n\"", ";", ")", ";", "return", "IsReturn", ";", "}", "</s>" ]

[ "Convenience", "function", "that", "returns", "true", "if", "the", "block", "ends", "in", "a", "return", "instruction", "." ]

[ "TGSI", "TGSI", "0", "\"BB\"", "\" is return block without RET instr\\n\"" ]

[]

[ "<s>", "const", "BitTracker", "::", "RegisterCell", "&", "lookup", "(", "unsigned", "VR", ")", "{", "unsigned", "RInd", "=", "Register", "::", "virtReg2Index", "(", "VR", ")", ";", "if", "(", "RInd", ">=", "CVect", ".", "size", "(", ")", ")", "CVect", ".", "resize", "(", "std", "::", "max", "(", "RInd", "+", "16", ",", "32U", ")", ",", "nullptr", ")", ";", "const", "BitTracker", "::", "RegisterCell", "*", "CP", "=", "CVect", "[", "RInd", "]", ";", "if", "(", "CP", "==", "nullptr", ")", "CP", "=", "CVect", "[", "RInd", "]", "=", "&", "BT", ".", "lookup", "(", "VR", ")", ";", "return", "*", "CP", ";", "}", "</s>" ]

[ "This", "method", "finds", "the", "value", "with", "the", "given", "Name", "in", "the", "the", "symbol", "table", "." ]

[ "Hexagon", "16", "32U" ]

[]

[ "<s>", "XCoreTargetMachine", "::", "XCoreTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ")", ",", "Subtarget", "(", "TT", ",", "FS", ")", ",", "DataLayout", "(", "\"e-p:32:32:32-a0:0:32-f32:32:32-f64:32:32-i1:8:32-i8:8:32-\"", "\"i16:16:32-i32:32:32-i64:32:32-n32\"", ")", ",", "InstrInfo", "(", ")", ",", "FrameInfo", "(", "*", "this", ")", ",", "TLInfo", "(", "*", "this", ")", "{", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "MCPhysReg", "*", "X86RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "bool", "HasSSE", "=", "Subtarget", ".", "hasSSE1", "(", ")", ";", "bool", "HasAVX", "=", "Subtarget", ".", "hasAVX", "(", ")", ";", "bool", "HasAVX512", "=", "Subtarget", ".", "hasAVX512", "(", ")", ";", "bool", "CallsEHReturn", "=", "MF", "->", "getMMI", "(", ")", ".", "callsEHReturn", "(", ")", ";", "assert", "(", "MF", "&&", "\"MachineFunction required\"", ")", ";", "switch", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ")", "{", "case", "CallingConv", "::", "GHC", ":", "case", "CallingConv", "::", "HiPE", ":", "return", "CSR_NoRegs_SaveList", ";", "case", "CallingConv", "::", "AnyReg", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_SaveList", ";", "return", "CSR_64_AllRegs_SaveList", ";", "case", "CallingConv", "::", "PreserveMost", ":", "return", "CSR_64_RT_MostRegs_SaveList", ";", "case", "CallingConv", "::", "PreserveAll", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_RT_AllRegs_AVX_SaveList", ";", "return", "CSR_64_RT_AllRegs_SaveList", ";", "case", "CallingConv", "::", "CXX_FAST_TLS", ":", "if", "(", "Is64Bit", ")", "return", "MF", "->", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "isSplitCSR", "(", ")", "?", "CSR_64_CXX_TLS_Darwin_PE_SaveList", ":", "CSR_64_TLS_Darwin_SaveList", ";", "break", ";", "case", "CallingConv", "::", "Intel_OCL_BI", ":", "{", "if", "(", "HasAVX512", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX512_SaveList", ";", "if", "(", "HasAVX512", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX512_SaveList", ";", "if", "(", "HasAVX", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX_SaveList", ";", "if", "(", "HasAVX", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX_SaveList", ";", "if", "(", "!", "HasAVX", "&&", "!", "IsWin64", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_SaveList", ";", "break", ";", "}", "case", "CallingConv", "::", "HHVM", ":", "return", "CSR_64_HHVM_SaveList", ";", "case", "CallingConv", "::", "Cold", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_MostRegs_SaveList", ";", "break", ";", "case", "CallingConv", "::", "X86_64_Win64", ":", "return", "CSR_Win64_SaveList", ";", "case", "CallingConv", "::", "X86_64_SysV", ":", "if", "(", "CallsEHReturn", ")", "return", "CSR_64EHRet_SaveList", ";", "return", "CSR_64_SaveList", ";", "case", "CallingConv", "::", "X86_INTR", ":", "if", "(", "Is64Bit", ")", "{", "if", "(", "HasAVX512", ")", "return", "CSR_64_AllRegs_AVX512_SaveList", ";", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_SaveList", ";", "return", "CSR_64_AllRegs_SaveList", ";", "}", "else", "{", "if", "(", "HasAVX512", ")", "return", "CSR_32_AllRegs_AVX512_SaveList", ";", "if", "(", "HasAVX", ")", "return", "CSR_32_AllRegs_AVX_SaveList", ";", "if", "(", "HasSSE", ")", "return", "CSR_32_AllRegs_SSE_SaveList", ";", "return", "CSR_32_AllRegs_SaveList", ";", "}", "default", ":", "break", ";", "}", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "return", "CSR_Win64_SaveList", ";", "if", "(", "CallsEHReturn", ")", "return", "CSR_64EHRet_SaveList", ";", "if", "(", "Subtarget", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", "->", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_64_SwiftError_SaveList", ";", "return", "CSR_64_SaveList", ";", "}", "if", "(", "CallsEHReturn", ")", "return", "CSR_32EHRet_SaveList", ";", "return", "CSR_32_SaveList", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "\"MachineFunction required\"", "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "static", "bool", "mips_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "V2SFmode", ":", "return", "TARGET_PAIRED_SINGLE_FLOAT", ";", "case", "V2HImode", ":", "case", "V4QImode", ":", "case", "V2HQmode", ":", "case", "V2UHQmode", ":", "case", "V2HAmode", ":", "case", "V2UHAmode", ":", "case", "V4QQmode", ":", "case", "V4UQQmode", ":", "return", "TARGET_DSP", ";", "case", "V2SImode", ":", "case", "V4HImode", ":", "case", "V8QImode", ":", "return", "TARGET_LOONGSON_VECTORS", ";", "default", ":", "return", "MSA_SUPPORTED_MODE_P", "(", "mode", ")", ";", "}", "}", "</s>" ]

[ "Target", "hook", "for", "vector_mode_supported_p", "." ]

[ "mips" ]

[]

[ "<s>", "static", "void", "alpha_atomic_assign_expand_fenv", "(", "tree", "*", "hold", ",", "tree", "*", "clear", ",", "tree", "*", "update", ")", "{", "const", "unsigned", "HOST_WIDE_INT", "SWCR_STATUS_MASK", "=", "(", "0x3fUL", "<<", "17", ")", ";", "tree", "fenv_var", ",", "get_fpscr", ",", "set_fpscr", ",", "mask", ",", "ld_fenv", ",", "masked_fenv", ";", "tree", "new_fenv_var", ",", "reload_fenv", ",", "restore_fnenv", ";", "tree", "update_call", ",", "atomic_feraiseexcept", ",", "hold_fnclex", ";", "if", "(", "!", "TARGET_ABI_OSF", ")", "return", ";", "fenv_var", "=", "create_tmp_var", "(", "long_unsigned_type_node", ")", ";", "get_fpscr", "=", "build_fn_decl", "(", "\"__ieee_get_fp_control\"", ",", "build_function_type_list", "(", "long_unsigned_type_node", ",", "NULL", ")", ")", ";", "set_fpscr", "=", "build_fn_decl", "(", "\"__ieee_set_fp_control\"", ",", "build_function_type_list", "(", "void_type_node", ",", "NULL", ")", ")", ";", "mask", "=", "build_int_cst", "(", "long_unsigned_type_node", ",", "~", "SWCR_STATUS_MASK", ")", ";", "ld_fenv", "=", "build2", "(", "MODIFY_EXPR", ",", "long_unsigned_type_node", ",", "fenv_var", ",", "build_call_expr", "(", "get_fpscr", ",", "0", ")", ")", ";", "masked_fenv", "=", "build2", "(", "BIT_AND_EXPR", ",", "long_unsigned_type_node", ",", "fenv_var", ",", "mask", ")", ";", "hold_fnclex", "=", "build_call_expr", "(", "set_fpscr", ",", "1", ",", "masked_fenv", ")", ";", "*", "hold", "=", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "masked_fenv", ",", "ld_fenv", ")", ",", "hold_fnclex", ")", ";", "*", "clear", "=", "build_call_expr", "(", "set_fpscr", ",", "1", ",", "masked_fenv", ")", ";", "new_fenv_var", "=", "create_tmp_var", "(", "long_unsigned_type_node", ")", ";", "reload_fenv", "=", "build2", "(", "MODIFY_EXPR", ",", "long_unsigned_type_node", ",", "new_fenv_var", ",", "build_call_expr", "(", "get_fpscr", ",", "0", ")", ")", ";", "restore_fnenv", "=", "build_call_expr", "(", "set_fpscr", ",", "1", ",", "fenv_var", ")", ";", "atomic_feraiseexcept", "=", "builtin_decl_implicit", "(", "BUILT_IN_ATOMIC_FERAISEEXCEPT", ")", ";", "update_call", "=", "build_call_expr", "(", "atomic_feraiseexcept", ",", "1", ",", "fold_convert", "(", "integer_type_node", ",", "new_fenv_var", ")", ")", ";", "*", "update", "=", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "reload_fenv", ",", "restore_fnenv", ")", ",", "update_call", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ATOMIC_ASSIGN_EXPAND_FENV", "." ]

[ "alpha", "0x3fUL", "17", "\"__ieee_get_fp_control\"", "\"__ieee_set_fp_control\"", "0", "1", "1", "0", "1", "1" ]

[]

[ "<s>", "static", "bool", "arm_slowmul_rtx_costs", "(", "rtx", "x", ",", "enum", "rtx_code", "code", ",", "enum", "rtx_code", "outer_code", ",", "int", "*", "total", ",", "bool", "speed", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "TARGET_THUMB", ")", "{", "*", "total", "=", "thumb1_rtx_costs", "(", "x", ",", "code", ",", "outer_code", ")", ";", "return", "true", ";", "}", "switch", "(", "code", ")", "{", "case", "MULT", ":", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "||", "mode", "==", "DImode", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "20", ")", ";", "return", "false", ";", "}", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "unsigned", "HOST_WIDE_INT", "i", "=", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&", "(", "unsigned", "HOST_WIDE_INT", ")", "0xffffffff", ")", ";", "int", "cost", ",", "const_ok", "=", "const_ok_for_arm", "(", "i", ")", ";", "int", "j", ",", "booth_unit_size", ";", "cost", "=", "const_ok", "?", "4", ":", "8", ";", "booth_unit_size", "=", "2", ";", "for", "(", "j", "=", "0", ";", "i", "&&", "j", "<", "32", ";", "j", "+=", "booth_unit_size", ")", "{", "i", ">>=", "booth_unit_size", ";", "cost", "++", ";", "}", "*", "total", "=", "COSTS_N_INSNS", "(", "cost", ")", ";", "*", "total", "+=", "rtx_cost", "(", "XEXP", "(", "x", ",", "0", ")", ",", "mode", ",", "code", ",", "0", ",", "speed", ")", ";", "return", "true", ";", "}", "*", "total", "=", "COSTS_N_INSNS", "(", "20", ")", ";", "return", "false", ";", "default", ":", "return", "arm_rtx_costs_1", "(", "x", ",", "outer_code", ",", "total", ",", "speed", ")", ";", ";", "}", "}", "</s>" ]

[ "RTX", "costs", "for", "cores", "with", "a", "slow", "MUL", "implementation", ".", "Thumb-2", "is", "not", "supported", "on", "any", "``", "slowmul", "''", "cores", ",", "so", "it", "can", "be", "ignored", "." ]

[ "arm", "20", "1", "1", "0xffffffff", "4", "8", "2", "0", "32", "0", "0", "20" ]

[]

[ "<s>", "static", "machine_mode", "select_block_compare_mode", "(", "unsigned", "HOST_WIDE_INT", "offset", ",", "unsigned", "HOST_WIDE_INT", "bytes", ",", "unsigned", "HOST_WIDE_INT", "align", ",", "bool", "word_mode_ok", ")", "{", "unsigned", "HOST_WIDE_INT", "maxread", "=", "ROUND_UP", "(", "bytes", ",", "align", ")", ";", "if", "(", "word_mode_ok", "&&", "bytes", ">=", "UNITS_PER_WORD", ")", "return", "word_mode", ";", "else", "if", "(", "bytes", "==", "GET_MODE_SIZE", "(", "SImode", ")", ")", "return", "SImode", ";", "else", "if", "(", "bytes", "==", "GET_MODE_SIZE", "(", "HImode", ")", ")", "return", "HImode", ";", "else", "if", "(", "bytes", "==", "GET_MODE_SIZE", "(", "QImode", ")", ")", "return", "QImode", ";", "else", "if", "(", "bytes", "<", "GET_MODE_SIZE", "(", "SImode", ")", "&&", "offset", ">=", "GET_MODE_SIZE", "(", "SImode", ")", "-", "bytes", ")", "return", "SImode", ";", "else", "if", "(", "word_mode_ok", "&&", "bytes", "<", "UNITS_PER_WORD", "&&", "offset", ">=", "UNITS_PER_WORD", "-", "bytes", ")", "return", "word_mode", ";", "else", "if", "(", "word_mode_ok", "&&", "maxread", ">=", "UNITS_PER_WORD", ")", "return", "word_mode", ";", "else", "if", "(", "maxread", ">=", "GET_MODE_SIZE", "(", "SImode", ")", ")", "return", "SImode", ";", "else", "if", "(", "bytes", ">", "GET_MODE_SIZE", "(", "SImode", ")", ")", "return", "SImode", ";", "else", "if", "(", "bytes", ">", "GET_MODE_SIZE", "(", "HImode", ")", ")", "return", "HImode", ";", "return", "QImode", ";", "}", "</s>" ]

[ "Select", "the", "mode", "to", "be", "used", "for", "reading", "the", "next", "chunk", "of", "bytes", "in", "the", "compare", ".", "OFFSET", "is", "the", "current", "read", "offset", "from", "the", "beginning", "of", "the", "block", ".", "BYTES", "is", "the", "number", "of", "bytes", "remaining", "to", "be", "read", ".", "ALIGN", "is", "the", "minimum", "alignment", "of", "the", "memory", "blocks", "being", "compared", "in", "bytes", "." ]

[ "rs6000" ]

[]

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

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

[ "IA64", "IA64" ]

[]

[ "<s>", "unsigned", "MCS51MCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "Ctx", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "if", "(", "MO", ".", "isDFPImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "bit_cast", "<", "double", ">", "(", "MO", ".", "getDFPImm", "(", ")", ")", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", ")", ";", "return", "getExprOpValue", "(", "MO", ".", "getExpr", "(", ")", ",", "Fixups", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "MCS51", "MCS51" ]

[]

[ "<s>", "static", "unsigned", "int", "xtensa_hard_regno_nregs", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "FP_REG_P", "(", "regno", ")", ")", "return", "CEIL", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "UNITS_PER_FPREG", ")", ";", "return", "CEIL", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_NREGS", "." ]

[ "xtensa" ]

[]

[ "<s>", "unsigned", "HSAILRegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "RC", "==", "&", "HSAIL", "::", "GPR32RegClass", ")", "{", "return", "HSAILReg32PressureLimit", ";", "}", "if", "(", "RC", "==", "&", "HSAIL", "::", "GPR64RegClass", ")", "{", "return", "HSAILReg64PressureLimit", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "HSAIL", "HSAIL", "HSAIL::GPR32RegClass", "HSAIL", "HSAIL::GPR64RegClass", "HSAIL", "0" ]

[]

[ "<s>", "DecodeStatus", "RISCVDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "OS", ",", "raw_ostream", "&", "CS", ")", "const", "{", "uint32_t", "Insn", ";", "DecodeStatus", "Result", ";", "if", "(", "(", "Bytes", "[", "0", "]", "&", "0x3", ")", "==", "0x3", ")", "{", "Insn", "=", "support", "::", "endian", "::", "read32le", "(", "Bytes", ".", "data", "(", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying RISCV32 table :\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable32", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "Size", "=", "4", ";", "}", "else", "{", "Insn", "=", "support", "::", "endian", "::", "read16le", "(", "Bytes", ".", "data", "(", ")", ")", ";", "if", "(", "!", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "Feature64Bit", "]", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying RISCV32Only_16 table (16-bit Instruction):\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableRISCV32Only_16", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "2", ";", "return", "Result", ";", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying RISCV_C table (16-bit Instruction):\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable16", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "Size", "=", "2", ";", "}", "return", "Result", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "RISCV", "RISCV", "0", "0x3", "0x3", "support::endian", "\"Trying RISCV32 table :\\n\"", "4", "support::endian", "RISCV::Feature64Bit", "\"Trying RISCV32Only_16 table (16-bit Instruction):\\n\"", "RISCV", "2", "\"Trying RISCV_C table (16-bit Instruction):\\n\"", "2" ]

[]