Datasets:

docz1105

/

ComBack_Plus_Plus

like 0

[ "static", "void", "aarch64_init_fpsr_fpcr_builtins", "(", "void", ")", "{", "tree", "ftype_set", "=", "build_function_type_list", "(", "void_type_node", ",", "unsigned_type_node", ",", "NULL", ")", ";", "tree", "ftype_get", "=", "build_function_type_list", "(", "unsigned_type_node", ",", "NULL", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_GET_FPCR", "]", "=", "aarch64_general_add_builtin", "(", "<STR_LIT>", "__builtin_aarch64_get_fpcr", "<STR_LIT>", ",", "ftype_get", ",", "AARCH64_BUILTIN_GET_FPCR", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_SET_FPCR", "]", "=", "aarch64_general_add_builtin", "(", "<STR_LIT>", "__builtin_aarch64_set_fpcr", "<STR_LIT>", ",", "ftype_set", ",", "AARCH64_BUILTIN_SET_FPCR", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_GET_FPSR", "]", "=", "aarch64_general_add_builtin", "(", "<STR_LIT>", "__builtin_aarch64_get_fpsr", "<STR_LIT>", ",", "ftype_get", ",", "AARCH64_BUILTIN_GET_FPSR", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_SET_FPSR", "]", "=", "aarch64_general_add_builtin", "(", "<STR_LIT>", "__builtin_aarch64_set_fpsr", "<STR_LIT>", ",", "ftype_set", ",", "AARCH64_BUILTIN_SET_FPSR", ")", ";", "ftype_set", "=", "build_function_type_list", "(", "void_type_node", ",", "long_long_unsigned_type_node", ",", "NULL", ")", ";", "ftype_get", "=", "build_function_type_list", "(", "long_long_unsigned_type_node", ",", "NULL", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_GET_FPCR64", "]", "=", "aarch64_general_add_builtin", "(", "<STR_LIT>", "__builtin_aarch64_get_fpcr64", "<STR_LIT>", ",", "ftype_get", ",", "AARCH64_BUILTIN_GET_FPCR64", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_SET_FPCR64", "]", "=", "aarch64_general_add_builtin", "(", "<STR_LIT>", "__builtin_aarch64_set_fpcr64", "<STR_LIT>", ",", "ftype_set", ",", "AARCH64_BUILTIN_SET_FPCR64", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_GET_FPSR64", "]", "=", "aarch64_general_add_builtin", "(", "<STR_LIT>", "__builtin_aarch64_get_fpsr64", "<STR_LIT>", ",", "ftype_get", ",", "AARCH64_BUILTIN_GET_FPSR64", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_SET_FPSR64", "]", "=", "aarch64_general_add_builtin", "(", "<STR_LIT>", "__builtin_aarch64_set_fpsr64", "<STR_LIT>", ",", "ftype_set", ",", "AARCH64_BUILTIN_SET_FPSR64", ")", ";", "}" ]

[ "Initialize", "fpsr", "fpcr", "getters", "and", "setters", "." ]

[ "getOperand", "(", "OpNum", "+", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "O", ")", ";" ]

[ "printAddress", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", ",", "MI", "->", "getOperand", "(", "OpNum", "+", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ",", "MI", "->" ]

[ "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";" ]

[ "let", "SrcB", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Switches", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Dest", "=", "dst", ";", "let", "HasImm", "=", "<NUM_LIT>", ";", "let", "OperandType", "=", "optype", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ ";" ]

[ "if", "(", "(", "(", "I", "+", "<NUM_LIT>", ")", ">=", "EndIdx", ")", "||", "(", "(", "NumGradients", "/", "<NUM_LIT>", ")", "%", "<NUM_LIT>", "==", "<NUM_LIT>", "&&", "(", "I", "==", "DimIdx", "+", "(", "NumGradients", "/", "<NUM_LIT>", ")", "-", "<NUM_LIT>", "||", "I", "==", "DimIdx", "+", "NumGradients", "-", "<NUM_LIT>", ")", ")", ")", "{", "if", "(", "Addr", ".", "getValueType", "(", ")", "!=", "MVT", "::", "i16", ")", "Addr", "=", "DAG", ".", "getBitcast", "(", "MVT", "::", "i16", ",", "Addr", ")", ";", "Addr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "DL", ",", "MVT", "::", "i32", ",", "Addr", ")", ";", "}", "else", "{", "Addr", "=", "DAG", ".", "getBuildVector", "(", "PackVectorVT", ",", "DL", ",", "{", "Addr", ",", "Op", ".", "getOperand", "(", "I", "+", "<NUM_LIT>", ")", "}", ")", ";", "I", "++" ]

[ "MSA128WOpnd", ">", ";" ]

[ "class", "FSNE_W_DESC", ":", "MSA_3RF_DESC_BASE", "<", "<STR_LIT>", ",", "int_mips_fsne_w", "," ]

[ "}" ]

[ "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";" ]

[ "DONE" ]

[ "(", "clobber", "(", "scratch", ":", "SI", ")", ")", "]", ")", "]", "<STR_LIT>", "{", "emit_insn", "(", "gen_ic_invalidate_line_sh4a", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")" ]

[ ")", ")", ")" ]

[ "(", "ior", "(", "match_code", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>" ]

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

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

[ "let", "isExtendable", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";" ]

[ ")" ]

[ "(", "match_operand", ":", "BND", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "{", "ix86_expand_move", "(", "<", "MODE", ">", "mode", ",", "operands" ]

[ "unsigned", "Z80MCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "unsigned", "RegNo", "=", "Ctx", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "Reg", ")", ";", "return", "RegNo", ";", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isExpr", "(", ")", ")", "{", "if", "(", "hasRegPrefix", "(", ")", ")", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "<NUM_LIT>", ",", "MO", ".", "getExpr", "(", ")", ",", "FK_Data_2", ")", ")", ";", "else", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "<NUM_LIT>", ",", "MO", ".", "getExpr", "(", ")", ",", "FK_Data_2", ")", ")", ";", "}", "return", "<NUM_LIT>", ";", "}" ]

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

[ "<FIXS>", "Sched", "[", "WriteFMove", "]", ">", ";", "<FIXE>", "<FIXS>", "Sched", "[", "WriteFLoad", "]", ">", ";", "<FIXE>" ]

[ "let", "hasSideEffects", "=", "<NUM_LIT>", "indef", "rr", ":", "PI", "opc", ",", "MRMSrcReg", ",", "(", "outs", "RC", ":", "$", "dst", ")", ",", "(", "ins", "RC", ":", "$", "src", ")", ",", "!", "strconcat", "(", "asm", ",", "<STR_LIT>", ")", ",", "[", "]", ",", "itins", ".", "rr", ",", "d", ">", ",", "<BUGS>", "Sched", "[", "WriteFShuffle", "]", ">", ";", "<BUGE>", "let", "canFoldAsLoad", "=", "<NUM_LIT>", ",", "isReMaterializable", "=", "<NUM_LIT>", "indef", "rm", ":", "PI", "opc", ",", "MRMSrcMem", ",", "(", "outs", "RC", ":", "$", "dst", ")", ",", "(", "ins", "x86memop", ":", "$", "src", ")", ",", "!", "strconcat", "(", "asm", ",", "<STR_LIT>", ")", ",", "[", "(", "set", "RC", ":", "$", "dst", ",", "(", "ld_frag", "addr", ":", "$", "src", ")", ")", "]", ",", "itins", ".", "rm", ",", "d", ">", ",", "<BUGS>", "Sched", "[", "WriteLoad", "]", ">", ";", "<BUGE>", "}", "let", "Predicates", "=", "[", "HasAVX", ",", "NoVLX", "]", "in", "{" ]

[ "return", "false", ";" ]

[ "case", "M68k", "::", "COND_LS", ":", "case", "M68k", "::", "COND_CC", ":", "return", "true", ";", "case", "M68k", "::", "COND_GT", ":", "case", "M68k", "::", "COND_GE", ":", "case", "M68k", "::", "COND_LT", ":", "case", "M68k", "::", "COND_LE", ":" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "addr", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "offset", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

[ "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";" ]

[ "SDValue", "Value", "=", "SD", "->", "getValue", "(", ")", ",", "Chain", "=", "SD", "->", "getChain", "(", ")", ";", "EVT", "VT", "=", "Value", ".", "getValueType", "(", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "i32", ")", "||", "SD", "->", "isTruncatingStore", "(", ")", ")", "{", "SDValue", "SWL", "=", "createStoreLR", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DAG", ",", "SD", ",", "Chain", ",", "IsLittle", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "return", "createStoreLR", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DAG", ",", "SD", ",", "SWL", ",", "IsLittle" ]

[ "}" ]

[ "return", "C_Immediate", ";", "case", "'", "C", "'", ":", "if", "(", "Constraint", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "switch", "(", "Constraint", "[", "<NUM_LIT>", "]", ")", "{", "case", "'", "<NUM_LIT>", "'", ":", "case", "'", "i", "'", ":", "case", "'", "j", "'", ":", "return", "C_Immediate", ";", "default", ":", "break", ";", "}", "break", ";", "case", "'", "Q", "'", ":", "case", "'", "U", "'", ":", "return", "C_Memory", ";", "default", ":", "break", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";" ]

[ "getParent", "(", ")", "->", "getParent", "(", ")", ";" ]

[ "Register", "Dest", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", "." ]

[ "let", "isExtendable", "=", "<NUM_LIT>", ";" ]

[ "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";" ]

[ "++", "i", ")", "{" ]

[ "for", "(", "auto", "&", "Arg", ":", "Args", ")", "{", "EVT", "VT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "Arg", ".", "Ty", ")", ";", "MVT", "RegisterVT", "=", "TLI", ".", "getRegisterTypeForCallingConv", "(", "F", ".", "getContext", "(", ")", ",", "F", ".", "getCallingConv", "(", ")", ",", "VT", ")", ";", "unsigned", "NumRegs", "=", "TLI", ".", "getNumRegistersForCallingConv", "(", "F", ".", "getContext", "(", ")", ",", "F", ".", "getCallingConv", "(", ")", ",", "VT", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "NumRegs", ";" ]

[ "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "prefersSlot3", "=" ]

[ "}" ]

[ "if", "(", "Arg", ".", "Flags", ".", "isByVal", "(", ")", ")", "return", "false", ";", "splitToValueTypes", "(", "Arg", ",", "ArgInfos", ",", "MF", ",", "[", "&", "]", "(", "Register", "Reg", ")", "{", "llvm_unreachable", "(", "<STR_LIT>", "Function args should already be split", "<STR_LIT>", ")", ";", "}", ")", ";", "}", "auto", "ArgAssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "CallConv", ",", "IsVarArg", ")", ";", "OutgoingValueHandler", "ArgHandler", "(", "MIRBuilder", ",", "MRI", ",", "MIB", ",", "ArgAssignFn", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "ArgInfos", ",", "ArgHandler", ")", ")", "return", "false", ";", "MIRBuilder", ".", "insertInstr", "(", "MIB", ")", ";", "if", "(", "!", "OrigRet", ".", "Ty", "->", "isVoidTy", "(", ")", ")", "{", "if", "(", "!", "isSupportedType", "(", "DL", ",", "TLI", ",", "OrigRet", ".", "Ty", ")", ")", "return", "false", ";", "ArgInfos", ".", "clear", "(", ")", ";", "splitToValueTypes", "(", "OrigRet", ",", "ArgInfos", ",", "MF", ",", "[", "&", "]", "(", "Register", "Reg", ")", "{", "llvm_unreachable", "(", "<STR_LIT>", "Call results should already be split", "<STR_LIT>", ")", ";", "}", ")", ";", "auto", "RetAssignFn", "=", "TLI", ".", "CCAssignFnForReturn", "(", "CallConv", ",", "IsVarArg", ")", ";", "CallReturnHandler", "RetHandler", "(", "MIRBuilder", ",", "MRI", ",", "MIB", ",", "RetAssignFn", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "ArgInfos", ",", "RetHandler", ")", ")", "return", "false", ";", "}", "CallSeqStart", ".", "addImm", "(", "ArgHandler", ".", "StackSize", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "MIRBuilder", ".", "buildInstr", "(", "ARM", "::", "ADJCALLSTACKUP", ")", ".", "addImm", "(", "ArgHandler", ".", "StackSize", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "return", "true", ";" ]

[ "default", ":" ]

[ "if", "(", "Cond", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_CNDMASK_B32_e64", ")", ",", "DstReg", ")", ".", "addReg", "(", "FalseReg", ")", ".", "addReg", "(", "TrueReg", ")", ".", "add", "(", "Cond", "[", "<NUM_LIT>", "]", ")", ";", "}", "else", "if", "(", "Cond", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "{", "assert", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "isImm", "(", ")", "&&", "<STR_LIT>", "Cond[0] is not an immediate", "<STR_LIT>", ")", ";", "switch", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ")", "{", "case", "SIInstrInfo", "::", "SCC_TRUE", ":", "{", "unsigned", "SReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_CSELECT_B64", ")", ",", "SReg", ")", ".", "addImm", "(", "-", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_CNDMASK_B32_e64", ")", ",", "DstReg", ")", ".", "addReg", "(", "FalseReg", ")", ".", "addReg", "(", "TrueReg", ")", ".", "addReg", "(", "SReg", ")", ";", "break", ";", "}", "case", "SIInstrInfo", "::", "SCC_FALSE", ":", "{", "unsigned", "SReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_CSELECT_B64", ")", ",", "SReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "-", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_CNDMASK_B32_e64", ")", ",", "DstReg", ")", ".", "addReg", "(", "FalseReg", ")", ".", "addReg", "(", "TrueReg", ")", ".", "addReg", "(", "SReg", ")", ";", "break", ";", "}", "case", "SIInstrInfo", "::", "VCCNZ", ":", "{", "MachineOperand", "RegOp", "=", "Cond", "[", "<NUM_LIT>", "]", ";", "RegOp", ".", "setImplicit", "(", "false", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_CNDMASK_B32_e64", ")", ",", "DstReg", ")", ".", "addReg", "(", "FalseReg", ")", ".", "addReg", "(", "TrueReg", ")", ".", "add", "(", "RegOp", ")", ";", "break", ";", "}", "case", "SIInstrInfo", "::", "VCCZ", ":", "{", "MachineOperand", "RegOp", "=", "Cond", "[", "<NUM_LIT>", "]", ";", "RegOp", ".", "setImplicit", "(", "false", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_CNDMASK_B32_e64", ")", ",", "DstReg", ")", ".", "addReg", "(", "TrueReg", ")", ".", "addReg", "(", "FalseReg", ")", ".", "add", "(", "RegOp", ")", ";", "break", ";", "}", "case", "SIInstrInfo", "::", "EXECNZ", ":", "{", "unsigned", "SReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "unsigned", "SReg2", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_OR_SAVEEXEC_B64", ")", ",", "SReg2", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_CSELECT_B64", ")", ",", "SReg", ")", ".", "addImm", "(", "-", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_CNDMASK_B32_e64", ")", ",", "DstReg", ")", ".", "addReg", "(", "FalseReg", ")", ".", "addReg", "(", "TrueReg", ")", ".", "addReg", "(", "SReg", ")", ";", "break", ";", "}", "case", "SIInstrInfo", "::", "EXECZ", ":", "{", "unsigned", "SReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "unsigned", "SReg2", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_OR_SAVEEXEC_B64", ")", ",", "SReg2", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_CSELECT_B64", ")", ",", "SReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "-", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_CNDMASK_B32_e64", ")", ",", "DstReg", ")", ".", "addReg", "(", "FalseReg", ")", ".", "addReg", "(", "TrueReg", ")", ".", "addReg", "(", "SReg", ")", ";", "llvm_unreachable", "(", "<STR_LIT>", "Unhandled branch predicate EXECZ", "<STR_LIT>", ")", ";", "break", ";", "}" ]

[ "ReplNewPtr", ")", ";" ]

[ "Value", "*", "Ptr", "=", "getPointerOperandAndType", "(", "Element", ".", "Instr", ")", ";", "assert", "(", "Ptr", "&&", "<STR_LIT>", "No pointer operand", "<STR_LIT>", ")", ";", "Instruction", "*", "RealNewPtr", ";", "if", "(", "!", "Element", ".", "Offset", "||", "(", "isa", "<", "SCEVConstant", ">", "(", "Element", ".", "Offset", ")", "&&", "cast", "<", "SCEVConstant", ">", "(", "Element", ".", "Offset", ")", "->", "getValue", "(", ")", "->", "isZero", "(", ")", ")", ")", "{", "RealNewPtr", "=", "NewBasePtr", ";", "}", "else", "{", "Instruction", "*", "PtrIP", "=", "dyn_cast", "<", "Instruction", ">", "(", "Ptr", ")", ";", "if", "(", "PtrIP", "&&", "isa", "<", "Instruction", ">", "(", "NewBasePtr", ")", "&&", "cast", "<", "Instruction", ">", "(", "NewBasePtr", ")", "->", "getParent", "(", ")", "==", "PtrIP", "->", "getParent", "(", ")", ")", "PtrIP", "=", "nullptr", ";", "else", "if", "(", "PtrIP", "&&", "isa", "<", "PHINode", ">", "(", "PtrIP", ")", ")", "PtrIP", "=", "&", "*", "PtrIP", "->", "getParent", "(", ")", "->", "getFirstInsertionPt", "(", ")", ";", "else", "if", "(", "!", "PtrIP", ")", "PtrIP", "=", "Element", ".", "Instr", ";", "assert", "(", "OffToBase", "&&", "<STR_LIT>", "There should be an offset for non base element!\\n", "<STR_LIT>", ")", ";", "GetElementPtrInst", "*", "NewPtr", "=", "GetElementPtrInst", "::", "Create", "(", "I8Ty", ",", "PtrInc", ",", "OffToBase", ",", "getInstrName", "(", "Element", ".", "Instr", ",", "GEPNodeOffNameSuffix", ")", ",", "PtrIP", ")", ";", "if", "(", "!", "PtrIP", ")", "NewPtr", "->", "insertAfter", "(", "cast", "<", "Instruction", ">", "(", "PtrInc", ")", ")", ";", "NewPtr", "->", "setIsInBounds", "(", "IsPtrInBounds", "(", "Ptr", ")", ")", ";", "RealNewPtr", "=", "NewPtr", ";", "}", "Instruction", "*", "ReplNewPtr", ";", "if", "(", "Ptr", "->", "getType", "(", ")", "!=", "RealNewPtr", "->", "getType", "(", ")", ")", "{", "ReplNewPtr", "=", "new", "BitCastInst", "(", "RealNewPtr", ",", "Ptr", "->", "getType", "(", ")", ",", "getInstrName", "(", "Ptr", ",", "CastNodeNameSuffix", ")", ")", ";", "ReplNewPtr", "->", "insertAfter", "(", "RealNewPtr", ")", ";", "}", "else", "ReplNewPtr", "=", "RealNewPtr", ";", "Ptr", "->", "replaceAllUsesWith", "(" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "wb", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";" ]

[ "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "void", "ARMTargetAsmStreamer", "::", "switchVendor", "(", "StringRef", "Vendor", ")", "{", "}", "<FIXE>" ]

[ "OS", "<<", "<STR_LIT>", "}\\n", "<STR_LIT>", ";", "}", "<BUGS>", "void", "ARMTargetAsmStreamer", "::", "switchVendor", "(", "StringRef", "Vendor", ")", "{", "}", "<BUGE>", "void", "ARMTargetAsmStreamer", "::", "emitAttribute", "(", "unsigned", "Attribute", ",", "unsigned", "Value", ")", "{", "OS", "<<", "<STR_LIT>", "\\t.eabi_attribute\\t", "<STR_LIT>", "<<", "Attribute", "<<", "<STR_LIT>", ", ", "<STR_LIT>", "<<", "Twine", "(", "Value", ")", ";", "if", "(", "IsVerboseAsm", ")", "{" ]

[ "const", "char", "*", "mt_asm_output_opcode", "(", "FILE", "*", "f", "ATTRIBUTE_UNUSED", ",", "const", "char", "*", "ptr", ")", "{", "if", "(", "mt_nops_required", ")", "fprintf", "(", "f", ",", "<STR_LIT>", ";# need %d nops because of %s\\n\\t", "<STR_LIT>", ",", "mt_nops_required", ",", "mt_nop_reasons", ")", ";", "while", "(", "mt_nops_required", ")", "{", "fprintf", "(", "f", ",", "<STR_LIT>", "nop\\n\\t", "<STR_LIT>", ")", ";", "--", "mt_nops_required", ";", "}", "return", "ptr", ";", "}" ]

[ "Implement", "ASM_OUTPUT_OPCODE", "." ]

[ "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "pstate_field", ")", ")", ";" ]

[ "uint64_t", "crm", "=", "fieldFromInstruction", "(", "insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "uint64_t", "pstate_field", "=", "(", "op1", "<<", "<NUM_LIT>", ")", "|", "op2", ";", "switch", "(", "pstate_field", ")", "{", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "return", "Fail", ";", "}", "if", "(", "(", "pstate_field", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "pstate_field", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "pstate_field", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "crm", ">", "<NUM_LIT>", ")", "return", "Fail", ";" ]

[ "}" ]

[ "def", "J4_cmpgti_tp1_jump_nt", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "GeneralSubRegs", ":", "$", "Rs16", ",", "u5_0Imm", ":", "$", "II", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_3d495a39", ",", "TypeCJ", ">", ",", "Enc_14d27a", ",", "PredRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "U", ";" ]

[ "MustSaveLR", "=" ]

[ "B", "->", "getInstList", "(", ")", ";" ]

[ "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "BO", ".", "size", "(", ")", ";", "++", "i", ")", "{", "BasicBlock", "*", "B", "=", "cast", "<", "BasicBlock", ">", "(", "BO", "[", "i", "]", ")", ";", "DomTreeNode", "*", "N", "=", "DT", "->", "getNode", "(", "B", ")", ";", "typedef", "GraphTraits", "<", "DomTreeNode", "*", ">", "GTN", ";", "typedef", "GTN", "::", "ChildIteratorType", "Iter", ";", "for", "(", "Iter", "I", "=", "GTN", "::", "child_begin", "(", "N", ")", ",", "E", "=", "GTN", "::", "child_end", "(", "N", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "BO", ".", "push_back", "(", "(", "*", "I", ")", "->", "getBlock", "(", ")", ")", ";", "}", "for", "(", "unsigned", "i", "=", "BO", ".", "size", "(", ")", ";", "i", ">", "<NUM_LIT>", ";", "--", "i", ")", "{", "BasicBlock", "*", "B", "=", "cast", "<", "BasicBlock", ">", "(", "BO", "[", "i", "-", "<NUM_LIT>", "]", ")", ";", "BasicBlock", "::", "InstListType", "&", "IL", "=" ]

[ "<FIXS>", "(", "sequence", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "PC", ",", "GP", ")", ">", "{", "<FIXE>" ]

[ "def", "CRRegs", ":", "RegisterClass", "<STR_LIT>", ",", "[", "i32", "]", ",", "<NUM_LIT>", ",", "(", "add", "(", "sequence", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "<BUGS>", "(", "sequence", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "(", "sequence", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "PC", ",", "GP", ")", ">", "{", "<BUGE>", "let", "Size", "=", "<NUM_LIT>", ";", "}" ]

[ ")", "return", "NewTy", ";" ]

[ "if", "(", "Type", "*", "NewTy", "=", "applyWrappers", "(", "Ty", ")", ";", "NewTy", "!=", "Ty" ]

[ ")", "{" ]

[ "unsigned", "MipsAsmParser", "::", "getGPR", "(", "int", "RegNo" ]

[ ")", ";" ]

[ "static", "void", "c4x_add_gc_roots", "(", ")", "{", "ggc_add_rtx_root", "(", "&", "c4x_compare_op0", ",", "<NUM_LIT>", ")", ";", "ggc_add_rtx_root", "(", "&", "c4x_compare_op1", ",", "<NUM_LIT>", ")", ";", "ggc_add_tree_root", "(", "&", "code_tree", ",", "<NUM_LIT>", ")", ";", "ggc_add_tree_root", "(", "&", "data_tree", ",", "<NUM_LIT>", ")", ";", "ggc_add_tree_root", "(", "&", "pure_tree", ",", "<NUM_LIT>", ")", ";", "ggc_add_tree_root", "(", "&", "noreturn_tree", ",", "<NUM_LIT>", ")", ";", "ggc_add_tree_root", "(", "&", "interrupt_tree", ",", "<NUM_LIT>", ")", ";", "ggc_add_rtx_root", "(", "&", "smulhi3_libfunc", ",", "<NUM_LIT>", ")", ";", "ggc_add_rtx_root", "(", "&", "umulhi3_libfunc", ",", "<NUM_LIT>", ")", ";", "ggc_add_rtx_root", "(", "&", "fix_truncqfhi2_libfunc", ",", "<NUM_LIT>", ")", ";", "ggc_add_rtx_root", "(", "&", "fixuns_truncqfhi2_libfunc", ",", "<NUM_LIT>", ")", ";", "ggc_add_rtx_root", "(", "&", "fix_trunchfhi2_libfunc", ",", "<NUM_LIT>", ")", ";", "ggc_add_rtx_root", "(", "&", "fixuns_trunchfhi2_libfunc", ",", "<NUM_LIT>", ")", ";", "ggc_add_rtx_root", "(", "&", "floathiqf2_libfunc", ",", "<NUM_LIT>", ")", ";", "ggc_add_rtx_root", "(", "&", "floatunshiqf2_libfunc", ",", "<NUM_LIT>" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "SDValue", "MipsTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "RVLocs", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "MipsCC", "MipsCCInfo", "(", "CallConv", ",", "Subtarget", "->", "isABI_O32", "(", ")", ",", "Subtarget", "->", "isFP64bit", "(", ")", ",", "CCInfo", ")", ";", "MipsCCInfo", ".", "analyzeReturn", "(", "Outs", ",", "Subtarget", "->", "mipsSEUsesSoftFloat", "(", ")", ",", "MF", ".", "getFunction", "(", ")", "->", "getReturnType", "(", ")", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "RetOps", "(", "<NUM_LIT>", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "SDValue", "Val", "=", "OutVals", "[", "i", "]", ";", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "<STR_LIT>", "Can only return in registers!", "<STR_LIT>", ")", ";", "if", "(", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", "!=", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ",", "Val", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "unsigned", "Reg", "=", "MipsFI", "->", "getSRetReturnReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "llvm_unreachable", "(", "<STR_LIT>", "sret virtual register not created in the entry block", "<STR_LIT>", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "getPointerTy", "(", ")", ")", ";", "unsigned", "V0", "=", "Subtarget", "->", "isABI_N64", "(", ")", "?", "Mips", "::", "V0_64", ":", "Mips", "::", "V0", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "V0", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "V0", ",", "getPointerTy", "(", ")", ")", ")", ";", "}", "RetOps", "[", "<NUM_LIT>", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}" ]

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

[ "void", "MBlazeInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addFrameIndex", "(", "FI", ")", ";", "}" ]

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

[ "<FIXS>", "fixup_arm_uncondbl", ",", "fixup_arm_condbl", ",", "<FIXE>" ]

[ "fixup_arm_thumb_br", ",", "<BUGS>", "fixup_arm_bl", ",", "<BUGE>", "fixup_arm_blx", "," ]

[ "(", "XVECEXP", "(", "x", ",", "i", ",", "j", ")", ",", "code_label", ")", ")", "return", "<NUM_LIT>", ";" ]

[ "code", "=", "GET_CODE", "(", "x", ")", ";", "if", "(", "code", "==", "LABEL_REF", ")", "return", "INSN_UID", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "INSN_UID", "(", "code_label", ")", ";", "fmt", "=", "GET_RTX_FORMAT", "(", "code", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "code", ")", "-", "<NUM_LIT>", ";", "i", ">=", "<NUM_LIT>", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'", "e", "'", ")", "{", "if", "(", "c4x_label_ref_used_p", "(", "XEXP", "(", "x", ",", "i", ")", ",", "code_label", ")", ")", "return", "<NUM_LIT>", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'", "E", "'", ")", "for", "(", "j", "=", "XVECLEN", "(", "x", ",", "i", ")", "-", "<NUM_LIT>", ";", "j", ">=", "<NUM_LIT>", ";", "j", "--", ")", "if", "(", "c4x_label_ref_used_p" ]

[ ";", "MI", "!=", "ME", ";", "MI", "++", ")", "if", "(", "MI", "->", "isReturn", "(", ")", ")", "return", "true", ";" ]

[ "static", "bool", "isReturnBlock", "(", "const", "MachineBasicBlock", "*", "MBB", ")", "{", "for", "(", "auto", "MI", "=", "MBB", "->", "begin", "(", ")", ",", "ME", "=", "MBB", "->", "end", "(", ")" ]

[ "}" ]

[ "assert", "(", "N", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid number of operands!", "<STR_LIT>", ")", ";", "const", "MCConstantExpr", "*", "MCE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "getImm", "(", ")", ")", ";", "assert", "(", "MCE", "&&", "<STR_LIT>", "Invalid constant immediate operand!", "<STR_LIT>", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "MCE", "->", "getValue", "(", ")", "/", "<NUM_LIT>", ")", ")", ";" ]

[ ")", "{" ]

[ "}", ")", ";", "PB", ".", "registerPeepholeEPCallback", "(", "[", "=", "]", "(", "FunctionPassManager", "&", "FPM", ",", "PassBuilder", "::", "OptimizationLevel", "Level", ")", "{", "FPM", ".", "addPass", "(", "SimplifyCFGPass", "(", "SimplifyCFGOptions", "(", ")", ".", "hoistCommonInsts", "(", "true", ")", ")", ")", ";", "}", ")", ";", "PB", ".", "registerPipelineEarlySimplificationEPCallback", "(", "[", "=", "]", "(", "ModulePassManager", "&", "MPM", ",", "PassBuilder", "::", "OptimizationLevel" ]

[ "<FIXS>", "if", "(", "TRI", "->", "isVectorRegister", "(", "*", "MRI", ",", "PHIRes", ")", "||", "RC0", "==", "&", "AMDGPU", "::", "VReg_1RegClass", ")", "{", "<FIXE>" ]

[ "}", "}", "<BUGS>", "bool", "hasVGPRInput", "=", "false", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "MI", ".", "getNumOperands", "(", ")", ";", "i", "+=", "<NUM_LIT>", ")", "{", "Register", "InputReg", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getReg", "(", ")", ";", "MachineInstr", "*", "Def", "=", "MRI", "->", "getVRegDef", "(", "InputReg", ")", ";", "if", "(", "TRI", "->", "isVectorRegister", "(", "*", "MRI", ",", "InputReg", ")", ")", "{", "if", "(", "Def", "->", "isCopy", "(", ")", ")", "{", "Register", "SrcReg", "=", "Def", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getRegClassForReg", "(", "*", "MRI", ",", "SrcReg", ")", ";", "if", "(", "TRI", "->", "isSGPRClass", "(", "RC", ")", ")", "continue", ";", "}", "hasVGPRInput", "=", "true", ";", "break", ";", "}", "else", "if", "(", "Def", "->", "isCopy", "(", ")", "&&", "TRI", "->", "isVectorRegister", "(", "*", "MRI", ",", "Def", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", "{", "Register", "SrcReg", "=", "Def", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "MachineInstr", "*", "SrcDef", "=", "MRI", "->", "getVRegDef", "(", "SrcReg", ")", ";", "unsigned", "SMovOp", ";", "int64_t", "Imm", ";", "if", "(", "!", "isSafeToFoldImmIntoCopy", "(", "Def", ",", "SrcDef", ",", "TII", ",", "SMovOp", ",", "Imm", ")", ")", "{", "hasVGPRInput", "=", "true", ";", "break", ";", "}", "else", "{", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "Def", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "ChangeToImmediate", "(", "Imm", ")", ";", "Def", "->", "addImplicitDefUseOperands", "(", "*", "MF", ")", ";", "Def", "->", "setDesc", "(", "TII", "->", "get", "(", "SMovOp", ")", ")", ";", "}", "}", "}", "if", "(", "(", "!", "TRI", "->", "isVectorRegister", "(", "*", "MRI", ",", "PHIRes", ")", "&&", "RC0", "!=", "&", "AMDGPU", "::", "VReg_1RegClass", ")", "&&", "(", "hasVGPRInput", "||", "numVGPRUses", ">", "<NUM_LIT>", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Fixing PHI: ", "<STR_LIT>", "<<", "MI", ")", ";", "CreatedBB", "=", "TII", "->", "moveToVALU", "(", "MI", ")", ";", "}", "else", "{", "<BUGE>", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Legalizing PHI: ", "<STR_LIT>", "<<", "MI", ")", ";", "TII", "->", "legalizeOperands", "(", "MI", ",", "MDT", ")", ";", "}" ]

[ "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";" ]

[ ",", "mode", ">", ";" ]

[ "def", "<STR_LIT>", ":", "CondStoreRSY", "<", "mnemonic", ",", "opcode", ",", "cls", ",", "bytes" ]

[ "<FIXS>", "TOC_REGNUM", ",", "frame_off", "+", "RS6000_TOC_SAVE_SLOT", ",", "<FIXE>" ]

[ "LABEL_NUSES", "(", "toc_save_done", ")", "+=", "<NUM_LIT>", ";", "save_insn", "=", "emit_frame_save", "(", "frame_reg_rtx", ",", "reg_mode", ",", "<BUGS>", "TOC_REGNUM", ",", "frame_off", "+", "<NUM_LIT>", "*", "reg_size", ",", "<BUGE>", "sp_off", "-", "frame_off", ")", ";", "emit_label", "(", "toc_save_done", ")", ";" ]

[ "}" ]

[ "SDValue", "LoongArchTargetLowering", "::", "lowerConstantPool", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "return", "getAddr", "(", "cast", "<", "ConstantPoolSDNode", ">", "(", "Op", ")", ",", "DAG", ",", "DAG", ".", "getTarget", "(", ")", ".", "getCodeModel", "(", ")", ")", ";" ]

[ "int", "SW_CNVRT_INT32", "=", "<NUM_LIT>", ";" ]

[ "int", "RM_RHNE", "=", "<NUM_LIT>", ";", "int", "RM_RZ", "=", "<NUM_LIT>", ";", "int", "RM_RU", "=", "<NUM_LIT>", ";", "int", "RM_RD", "=", "<NUM_LIT>", ";", "int", "RM_SR", "=", "<NUM_LIT>", ";", "int", "RM_RHAZ", "=", "<NUM_LIT>", ";", "int", "TO_FP32", "=", "<NUM_LIT>", ";", "int", "TO_BF16", "=", "<NUM_LIT>", ";", "int", "TO_INT32", "=", "<NUM_LIT>", ";", "int", "TO_UINT32", "=", "<NUM_LIT>", ";", "int", "TO_INT8", "=", "<NUM_LIT>", ";", "int", "TO_UINT8", "=", "<NUM_LIT>", ";", "int", "TO_INT16", "=", "<NUM_LIT>", ";", "int", "TO_UINT16", "=", "<NUM_LIT>", ";", "int", "TO_INT4", "=", "<NUM_LIT>", ";", "int", "TO_UINT4", "=", "<NUM_LIT>", ";", "int", "TO_FP16", "=", "<NUM_LIT>", ";", "int", "TO_FP8_152", "=", "<NUM_LIT>", ";", "int", "TO_FP8_143", "=", "<NUM_LIT>", ";", "int", "SW_CNVRT", "=", "<NUM_LIT>", ";" ]

[ ")", ";" ]

[ "TargetRegistry", "::", "RegisterMCSubtargetInfo", "(", "TheHexagonTarget", ",", "createHexagonMCSubtargetInfo", ")", ";", "TargetRegistry", "::", "RegisterMCCodeEmitter", "(", "TheHexagonTarget", ",", "createHexagonMCCodeEmitter", ")", ";", "TargetRegistry", "::", "RegisterMCInstPrinter", "(", "TheHexagonTarget", ",", "createHexagonMCInstPrinter" ]

[ "}" ]

[ "extern", "_", "_", "inline", "void", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "wrssd", "(", "unsigned", "int", "_", "_", "B", ",", "void", "*", "_", "_", "C", ")", "{", "_", "_", "builtin_ia32_wrssd", "(", "_", "_", "B", ",", "_", "_", "C", ")", ";" ]

[ "void", "xstormy16_split_move", "(", "machine_mode", "mode", ",", "rtx", "dest", ",", "rtx", "src", ")", "{", "int", "num_words", "=", "GET_MODE_BITSIZE", "(", "mode", ")", "/", "BITS_PER_WORD", ";", "int", "direction", ",", "end", ",", "i", ";", "int", "src_modifies", "=", "<NUM_LIT>", ";", "int", "dest_modifies", "=", "<NUM_LIT>", ";", "int", "src_volatile", "=", "<NUM_LIT>", ";", "int", "dest_volatile", "=", "<NUM_LIT>", ";", "rtx", "mem_operand", ";", "rtx", "auto_inc_reg_rtx", "=", "NULL_RTX", ";", "gcc_assert", "(", "reload_completed", "&&", "mode", "!=", "QImode", "&&", "mode", "!=", "HImode", "&&", "nonimmediate_operand", "(", "dest", ",", "mode", ")", "&&", "general_operand", "(", "src", ",", "mode", ")", ")", ";", "gcc_assert", "(", "!", "MEM_P", "(", "dest", ")", "||", "!", "MEM_P", "(", "src", ")", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "dest", ")", "!=", "SUBREG", "&&", "GET_CODE", "(", "src", ")", "!=", "SUBREG", ")", ";", "direction", "=", "<NUM_LIT>", ";", "if", "(", "MEM_P", "(", "dest", ")", ")", "{", "mem_operand", "=", "XEXP", "(", "dest", ",", "<NUM_LIT>", ")", ";", "dest_modifies", "=", "side_effects_p", "(", "mem_operand", ")", ";", "if", "(", "auto_inc_p", "(", "mem_operand", ")", ")", "auto_inc_reg_rtx", "=", "XEXP", "(", "mem_operand", ",", "<NUM_LIT>", ")", ";", "dest_volatile", "=", "MEM_VOLATILE_P", "(", "dest", ")", ";", "if", "(", "dest_volatile", ")", "{", "dest", "=", "copy_rtx", "(", "dest", ")", ";", "MEM_VOLATILE_P", "(", "dest", ")", "=", "<NUM_LIT>", ";", "}", "}", "else", "if", "(", "MEM_P", "(", "src", ")", ")", "{", "mem_operand", "=", "XEXP", "(", "src", ",", "<NUM_LIT>", ")", ";", "src_modifies", "=", "side_effects_p", "(", "mem_operand", ")", ";", "if", "(", "auto_inc_p", "(", "mem_operand", ")", ")", "auto_inc_reg_rtx", "=", "XEXP", "(", "mem_operand", ",", "<NUM_LIT>", ")", ";", "src_volatile", "=", "MEM_VOLATILE_P", "(", "src", ")", ";", "if", "(", "src_volatile", ")", "{", "src", "=", "copy_rtx", "(", "src", ")", ";", "MEM_VOLATILE_P", "(", "src", ")", "=", "<NUM_LIT>", ";", "}", "}", "else", "mem_operand", "=", "NULL_RTX", ";", "if", "(", "mem_operand", "==", "NULL_RTX", ")", "{", "if", "(", "REG_P", "(", "src", ")", "&&", "REG_P", "(", "dest", ")", "&&", "reg_overlap_mentioned_p", "(", "dest", ",", "src", ")", "&&", "REGNO", "(", "dest", ")", ">", "REGNO", "(", "src", ")", ")", "direction", "=", "-", "<NUM_LIT>", ";", "}", "else", "if", "(", "GET_CODE", "(", "mem_operand", ")", "==", "PRE_DEC", "||", "(", "GET_CODE", "(", "mem_operand", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "mem_operand", ",", "<NUM_LIT>", ")", ")", "==", "PRE_DEC", ")", ")", "direction", "=", "-", "<NUM_LIT>", ";", "else", "if", "(", "MEM_P", "(", "src", ")", "&&", "reg_overlap_mentioned_p", "(", "dest", ",", "src", ")", ")", "{", "int", "regno", ";", "gcc_assert", "(", "REG_P", "(", "dest", ")", ")", ";", "regno", "=", "REGNO", "(", "dest", ")", ";", "gcc_assert", "(", "refers_to_regno_p", "(", "regno", ",", "regno", "+", "num_words", ",", "mem_operand", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "refers_to_regno_p", "(", "regno", ",", "mem_operand", ")", ")", "direction", "=", "-", "<NUM_LIT>", ";", "else", "if", "(", "refers_to_regno_p", "(", "regno", "+", "num_words", "-", "<NUM_LIT>", ",", "regno", "+", "num_words", ",", "mem_operand", ",", "<NUM_LIT>", ")", ")", "direction", "=", "<NUM_LIT>", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "end", "=", "direction", "<", "<NUM_LIT>", "?", "-", "<NUM_LIT>", ":", "num_words", ";", "for", "(", "i", "=", "direction", "<", "<NUM_LIT>", "?", "num_words", "-", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "i", "!=", "end", ";", "i", "+=", "direction", ")", "{", "rtx", "w_src", ",", "w_dest", ",", "insn", ";", "if", "(", "src_modifies", ")", "w_src", "=", "gen_rtx_MEM", "(", "word_mode", ",", "mem_operand", ")", ";", "else", "w_src", "=", "simplify_gen_subreg", "(", "word_mode", ",", "src", ",", "mode", ",", "i", "*", "UNITS_PER_WORD", ")", ";", "if", "(", "src_volatile", ")", "MEM_VOLATILE_P", "(", "w_src", ")", "=", "<NUM_LIT>", ";", "if", "(", "dest_modifies", ")", "w_dest", "=", "gen_rtx_MEM", "(", "word_mode", ",", "mem_operand", ")", ";", "else", "w_dest", "=", "simplify_gen_subreg", "(", "word_mode", ",", "dest", ",", "mode", ",", "i", "*", "UNITS_PER_WORD", ")", ";", "if", "(", "dest_volatile", ")", "MEM_VOLATILE_P", "(", "w_dest", ")", "=", "<NUM_LIT>", ";", "gcc_assert", "(", "GET_CODE", "(", "w_src", ")", "!=", "SUBREG", "&&", "GET_CODE", "(", "w_dest", ")", "!=", "SUBREG", ")", ";", "insn", "=", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "w_dest", ",", "w_src", ")", ")", ";", "if", "(", "auto_inc_reg_rtx", ")", "REG_NOTES", "(", "insn", ")", "=", "alloc_EXPR_LIST", "(", "REG_INC", ",", "auto_inc_reg_rtx", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "}", "}" ]

[ "Splitter", "for", "the", "'move", "'", "patterns", ",", "for", "modes", "not", "directly", "implemeted", "by", "hardware", ".", "Emit", "insns", "to", "copy", "a", "value", "of", "mode", "MODE", "from", "SRC", "to", "DEST", ".", "This", "function", "is", "only", "called", "when", "reload_completed", "." ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Q", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "U", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "fixed_imm", ";" ]

[ "_", "m512i", "_", "_", "B", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m512i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_mask_sub_epi8", "(", "_", "_", "m512i", "_", "_", "W", ",", "_", "_", "mmask64", "_", "_", "U", ",", "_", "_", "m512i", "_", "_", "A", ",", "_" ]

[ "if", "(", "I", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "Or", ")", "return", "std", "::", "optional", "<", "int64_t", ">", "{", "*", "Op0", "|", "*", "Op1", "}", ";" ]

[ "if", "(", "!", "Op0", "||", "!", "Op1", ")", "return", "std", "::", "optional", "<", "int64_t", ">", "{", "}", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "Add", ")", "return", "std", "::", "optional", "<", "int64_t", ">", "{", "*", "Op0", "+", "*", "Op1", "}", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "Mul", ")", "return", "std", "::", "optional", "<", "int64_t", ">", "{", "*", "Op0", "*", "*", "Op1", "}", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "Shl", ")", "return", "std", "::", "optional", "<", "int64_t", ">", "{", "*", "Op0", "<<", "*", "Op1", "}", ";" ]

[ "<FIXS>", "SmallVector", "std", "::", "pair", "MachineInstr", "*", ",", "unsigned", ">", ",", "<NUM_LIT>", ">", "ReturnInstructions", ";", "SmallVector", "std", "::", "pair", "MachineInstr", "*", ",", "unsigned", ">", ",", "<NUM_LIT>", ">", "CallInstructions", ";", "bool", "TmpRegisterNotAvailableEverywhere", "=", "false", ";", "RegScavenger", "RS", ";", "RS", ".", "enterBasicBlock", "(", "MBB", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "++", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "if", "(", "!", "MI", ".", "isReturn", "(", ")", "&&", "!", "MI", ".", "isCall", "(", ")", ")", "continue", ";", "<FIXE>", "<FIXS>", "if", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "RS", ".", "forward", "(", "std", "::", "prev", "(", "I", ")", ")", ";", "unsigned", "TmpReg", "=", "RS", ".", "FindUnusedReg", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "RS finds ", "<STR_LIT>", "<<", "(", "(", "TmpReg", "==", "<NUM_LIT>", ")", "?", "<STR_LIT>", "no register ", "<STR_LIT>", ":", "<STR_LIT>", "register ", "<STR_LIT>", ")", ";", "if", "(", "TmpReg", "!=", "<NUM_LIT>", ")", "dbgs", "(", ")", "<<", "printReg", "(", "TmpReg", ",", "TRI", ")", "<<", "<STR_LIT>", "<STR_LIT>", ";", "dbgs", "(", ")", "<<", "<STR_LIT>", "to be available at MI ", "<STR_LIT>", "<<", "MI", ")", ";", "if", "(", "TmpReg", "==", "<NUM_LIT>", ")", "TmpRegisterNotAvailableEverywhere", "=", "true", ";", "if", "(", "MI", ".", "isReturn", "(", ")", ")", "ReturnInstructions", ".", "push_back", "(", "{", "&", "MI", ",", "TmpReg", "}", ")", ";", "else", "if", "(", "MI", ".", "isCall", "(", ")", ")", "CallInstructions", ".", "push_back", "(", "{", "&", "MI", ",", "TmpReg", "}", ")", ";", "}", "<FIXE>", "<FIXS>", "if", "(", "TmpRegisterNotAvailableEverywhere", ")", "{", "insertFullSpeculationBarrier", "(", "MBB", ",", "MBB", ".", "begin", "(", ")", ",", "(", "MBB", ".", "begin", "(", ")", ")", "->", "getDebugLoc", "(", ")", ")", ";", "UsesFullSpeculationBarrier", "=", "true", ";", "Modified", "=", "true", ";", "}", "else", "{", "for", "(", "auto", "MI_Reg", ":", "ReturnInstructions", ")", "{", "assert", "(", "MI_Reg", ".", "second", "!=", "<NUM_LIT>", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " About to insert Reg to SP taint propagation with temp register ", "<STR_LIT>", "<<", "printReg", "(", "MI_Reg", ".", "second", ",", "TRI", ")", "<<", "<STR_LIT>", " on instruction: ", "<STR_LIT>", "<<", "*", "MI_Reg", ".", "first", ")", ";", "insertRegToSPTaintPropagation", "(", "MBB", ",", "MI_Reg", ".", "first", ",", "MI_Reg", ".", "second", ")", ";", "Modified", "=", "true", ";", "}", "<FIXE>", "<FIXS>", "for", "(", "auto", "MI_Reg", ":", "CallInstructions", ")", "{", "assert", "(", "MI_Reg", ".", "second", "!=", "<NUM_LIT>", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " About to insert Reg to SP and back taint ", "<STR_LIT>", "<STR_LIT>", "propagation with temp register ", "<STR_LIT>", "<<", "printReg", "(", "MI_Reg", ".", "second", ",", "TRI", ")", "<<", "<STR_LIT>", " around instruction: ", "<STR_LIT>", "<<", "*", "MI_Reg", ".", "first", ")", ";", "<FIXE>", "<FIXS>", "insertSPToRegTaintPropagation", "(", "MBB", ",", "std", "::", "next", "(", "(", "MachineBasicBlock", "::", "iterator", ")", "MI_Reg", ".", "first", ")", ")", ";", "<FIXE>", "<FIXS>", "insertRegToSPTaintPropagation", "(", "MBB", ",", "MI_Reg", ".", "first", ",", "MI_Reg", ".", "second", ")", ";", "Modified", "=", "true", ";", "<FIXE>", "<FIXS>", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ")", "const", "{", "<FIXE>", "<FIXS>", "insertFullSpeculationBarrier", "(", "MBB", ",", "MBBI", ",", "DebugLoc", "(", ")", ")", ";", "<FIXE>", "<FIXS>", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "<FIXE>", "<FIXS>", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "<FIXE>" ]

[ "}", "<BUGS>", "{", "SmallVector", "MachineInstr", "*", ",", "<NUM_LIT>", ">", "ReturnInstructions", ";", "SmallVector", "MachineInstr", "*", ",", "<NUM_LIT>", ">", "CallInstructions", ";", "<BUGE>", "<BUGS>", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "if", "(", "MI", ".", "isReturn", "(", ")", ")", "ReturnInstructions", ".", "push_back", "(", "&", "MI", ")", ";", "else", "if", "(", "MI", ".", "isCall", "(", ")", ")", "CallInstructions", ".", "push_back", "(", "&", "MI", ")", ";", "}", "<BUGE>", "<BUGS>", "Modified", "|=", "(", "ReturnInstructions", ".", "size", "(", ")", ">", "<NUM_LIT>", ")", "||", "(", "CallInstructions", ".", "size", "(", ")", ">", "<NUM_LIT>", ")", ";", "<BUGE>", "<BUGS>", "for", "(", "MachineInstr", "*", "Return", ":", "ReturnInstructions", ")", "insertRegToSPTaintPropagation", "(", "Return", "->", "getParent", "(", ")", ",", "Return", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "for", "(", "MachineInstr", "*", "Call", ":", "CallInstructions", ")", "{", "<BUGE>", "<BUGS>", "MachineBasicBlock", "::", "iterator", "i", "=", "Call", ";", "i", "++", ";", "insertSPToRegTaintPropagation", "(", "Call", "->", "getParent", "(", ")", ",", "i", ")", ";", "<BUGE>", "<BUGS>", "insertRegToSPTaintPropagation", "(", "Call", "->", "getParent", "(", ")", ",", "Call", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "<BUGE>", "}", "}", "return", "Modified", ";", "}", "void", "AArch64SpeculationHardening", "::", "insertSPToRegTaintPropagation", "(", "<BUGS>", "MachineBasicBlock", "*", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ")", "const", "{", "<BUGE>", "if", "(", "UseControlFlowSpeculationBarrier", ")", "{", "<BUGS>", "BuildMI", "(", "*", "MBB", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "*", "MBB", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "<BUGE>", "return", ";", "}", "<BUGS>", "BuildMI", "(", "*", "MBB", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "<BUGE>", ".", "addDef", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addUse", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "<BUGS>", "BuildMI", "(", "*", "MBB", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "<BUGE>", ".", "addDef", "(", "MisspeculatingTaintReg", ")", ".", "addUse", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addUse", "(", "<STR_LIT>", "::", "<STR_LIT>", ")" ]

[ "sub", ",", "vsplati32_uimm5", ",", "MSA128WOpnd", ">", ";" ]

[ "class", "SUBVI_W_DESC", ":", "MSA_I5_DESC_BASE", "<", "<STR_LIT>", "," ]

[ "<FIXS>", "(", "unspec", ":", "SI", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<FIXE>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "SI", "T_REG", ")", "<BUGS>", "(", "unspec", ":", "SI", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_SP_TEST", ")", ")", "(", "set", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")" ]

[ ")", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ "return", "(", "_", "_", "m128", ")", "_", "_", "builtin_ia32_unpckhps128_mask", "(", "(", "_", "_", "v4sf", ")", "_", "_", "A", ",", "(", "_", "_", "v4sf", ")", "_", "_", "B", ",", "(", "_", "_", "v4sf", ")", "_", "mm_setzero_ps", "(" ]

[ "else", "FB", "&=", "~", "ComputeAvailableFeatures", "(", "Extensions", "[", "EI", "]", ".", "Features", ")", ";" ]

[ "if", "(", "Extensions", "[", "EI", "]", ".", "Extension", "!=", "Extension", ")", "continue", ";", "unsigned", "FB", "=", "getAvailableFeatures", "(", ")", ";", "if", "(", "(", "FB", "&", "Extensions", "[", "EI", "]", ".", "ArchCheck", ")", "!=", "Extensions", "[", "EI", "]", ".", "ArchCheck", ")", "{", "Error", "(", "ExtLoc", ",", "<STR_LIT>", "architectural extension '", "<STR_LIT>", "+", "Extension", "+", "<STR_LIT>", "' is not ", "<STR_LIT>", "<STR_LIT>", "allowed for the current base architecture", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "if", "(", "!", "Extensions", "[", "EI", "]", ".", "Features", ")", "report_fatal_error", "(", "<STR_LIT>", "unsupported architectural extension: ", "<STR_LIT>", "+", "Extension", ")", ";", "if", "(", "EnableFeature", ")", "FB", "|=", "ComputeAvailableFeatures", "(", "Extensions", "[", "EI", "]", ".", "Features", ")", ";" ]

[ "SDValue", "HiAnd", "=", "DAG", ".", "getNode", "(", "Opc", ",", "SL", ",", "MVT", "::", "i32", ",", "Hi", ",", "HiRHS", ")", ";" ]

[ "SDValue", "LoRHS", "=", "DAG", ".", "getConstant", "(", "ValLo", ",", "SL", ",", "MVT", "::", "i32", ")", ";", "SDValue", "HiRHS", "=", "DAG", ".", "getConstant", "(", "ValHi", ",", "SL", ",", "MVT", "::", "i32", ")", ";", "SDValue", "LoAnd", "=", "DAG", ".", "getNode", "(", "Opc", ",", "SL", ",", "MVT", "::", "i32", ",", "Lo", ",", "LoRHS", ")", ";" ]

[ "return", "ELF", "::", "R_MICROMIPS_GOT_PAGE", ";" ]

[ "case", "Mips", "::", "fixup_Mips_TPREL_HI", ":", "return", "ELF", "::", "R_MIPS_TLS_TPREL_HI16", ";", "case", "Mips", "::", "fixup_Mips_TPREL_LO", ":", "return", "ELF", "::", "R_MIPS_TLS_TPREL_LO16", ";", "case", "Mips", "::", "fixup_Mips_TLSLDM", ":", "return", "ELF", "::", "R_MIPS_TLS_LDM", ";", "case", "Mips", "::", "fixup_Mips_DTPREL_HI", ":", "return", "ELF", "::", "R_MIPS_TLS_DTPREL_HI16", ";", "case", "Mips", "::", "fixup_Mips_DTPREL_LO", ":", "return", "ELF", "::", "R_MIPS_TLS_DTPREL_LO16", ";", "case", "Mips", "::", "fixup_Mips_GOT_PAGE", ":", "return", "ELF", "::", "R_MIPS_GOT_PAGE", ";", "case", "Mips", "::", "fixup_Mips_GOT_OFST", ":", "return", "ELF", "::", "R_MIPS_GOT_OFST", ";", "case", "Mips", "::", "fixup_Mips_GOT_DISP", ":", "return", "ELF", "::", "R_MIPS_GOT_DISP", ";", "case", "Mips", "::", "fixup_Mips_GPOFF_HI", ":", "{", "unsigned", "Type", "=", "(", "unsigned", ")", "ELF", "::", "R_MIPS_NONE", ";", "Type", "=", "setRType", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_GPREL16", ",", "Type", ")", ";", "Type", "=", "setRType2", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_SUB", ",", "Type", ")", ";", "Type", "=", "setRType3", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_HI16", ",", "Type", ")", ";", "return", "Type", ";", "}", "case", "Mips", "::", "fixup_Mips_GPOFF_LO", ":", "{", "unsigned", "Type", "=", "(", "unsigned", ")", "ELF", "::", "R_MIPS_NONE", ";", "Type", "=", "setRType", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_GPREL16", ",", "Type", ")", ";", "Type", "=", "setRType2", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_SUB", ",", "Type", ")", ";", "Type", "=", "setRType3", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_LO16", ",", "Type", ")", ";", "return", "Type", ";", "}", "case", "Mips", "::", "fixup_Mips_HIGHER", ":", "return", "ELF", "::", "R_MIPS_HIGHER", ";", "case", "Mips", "::", "fixup_Mips_HIGHEST", ":", "return", "ELF", "::", "R_MIPS_HIGHEST", ";", "case", "Mips", "::", "fixup_Mips_GOT_HI16", ":", "return", "ELF", "::", "R_MIPS_GOT_HI16", ";", "case", "Mips", "::", "fixup_Mips_GOT_LO16", ":", "return", "ELF", "::", "R_MIPS_GOT_LO16", ";", "case", "Mips", "::", "fixup_Mips_CALL_HI16", ":", "return", "ELF", "::", "R_MIPS_CALL_HI16", ";", "case", "Mips", "::", "fixup_Mips_CALL_LO16", ":", "return", "ELF", "::", "R_MIPS_CALL_LO16", ";", "case", "Mips", "::", "fixup_MICROMIPS_26_S1", ":", "return", "ELF", "::", "R_MICROMIPS_26_S1", ";", "case", "Mips", "::", "fixup_MICROMIPS_HI16", ":", "return", "ELF", "::", "R_MICROMIPS_HI16", ";", "case", "Mips", "::", "fixup_MICROMIPS_LO16", ":", "return", "ELF", "::", "R_MICROMIPS_LO16", ";", "case", "Mips", "::", "fixup_MICROMIPS_GOT16", ":", "return", "ELF", "::", "R_MICROMIPS_GOT16", ";", "case", "Mips", "::", "fixup_MICROMIPS_CALL16", ":", "return", "ELF", "::", "R_MICROMIPS_CALL16", ";", "case", "Mips", "::", "fixup_MICROMIPS_GOT_DISP", ":", "return", "ELF", "::", "R_MICROMIPS_GOT_DISP", ";", "case", "Mips", "::", "fixup_MICROMIPS_GOT_PAGE", ":" ]

[ ";" ]

[ "if", "(", "ZExtReg", "==", "<NUM_LIT>", ")", "return", "false", ";", "ResultReg", "=", "createResultReg", "(", "&", "X86", "::", "GR8RegClass", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "X86", "::", "NEG8r", ")", ",", "ResultReg", ")", ".", "addReg", "(", "ZExtReg", ")", ";", "SrcVT", "=", "MVT", "::", "i8", ";", "}", "if", "(", "DstVT", "==", "MVT", "::", "i16", ")", "{", "unsigned", "Result32", "=", "createResultReg", "(", "&", "X86", "::", "GR32RegClass", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "X86", "::", "MOVSX32rr8", ")", ",", "Result32", ")", ".", "addReg", "(", "ResultReg", ")", ";", "ResultReg", "=", "fastEmitInst_extractsubreg", "(", "MVT", "::", "i16", ",", "Result32", ",", "true", ",", "X86", "::", "sub_16bit", ")", ";", "}", "else", "if", "(", "DstVT", "!=", "MVT", "::", "i8", ")", "{", "ResultReg", "=", "fastEmit_r", "(", "MVT", "::", "i8", ",", "DstVT", ".", "getSimpleVT", "(", ")", ",", "ISD", "::", "SIGN_EXTEND", ",", "ResultReg", ",", "true", ")", ";", "if", "(", "ResultReg", "==", "<NUM_LIT>", ")", "return", "false", ";", "}", "updateValueMap", "(", "I", ",", "ResultReg", ")", ";", "return", "true" ]

[ "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "(", "and", ":", "VT", "(", "match_operand", ":", "VT", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VT", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "}" ]

[ "bool", "CopyPropagation", "::", "isCopyReg", "(", "unsigned", "Opc", ",", "bool", "NoConv", ")", "{", "switch", "(", "Opc", ")", "{", "case", "TargetOpcode", "::", "COPY", ":", "case", "TargetOpcode", "::", "REG_SEQUENCE", ":", "case", "Hexagon", "::", "A4_combineir", ":", "case", "Hexagon", "::", "A4_combineri", ":", "return", "true", ";", "case", "Hexagon", "::", "A2_tfr", ":", "case", "Hexagon", "::", "A2_tfrp", ":", "case", "Hexagon", "::", "A2_combinew", ":", "case", "Hexagon", "::", "V6_vcombine", ":", "return", "NoConv", ";", "default", ":", "break", ";", "}", "return", "false", ";" ]

[ "bool", "XCoreInstrInfo", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "{", "return", "true", ";", "}", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineModuleInfo", "*", "MMI", "=", "MFI", "->", "getMachineModuleInfo", "(", ")", ";", "XCoreFunctionInfo", "*", "XFI", "=", "MF", "->", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "bool", "emitFrameMoves", "=", "XCoreRegisterInfo", "::", "needsFrameMoves", "(", "*", "MF", ")", ";", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "for", "(", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "::", "const_iterator", "it", "=", "CSI", ".", "begin", "(", ")", ";", "it", "!=", "CSI", ".", "end", "(", ")", ";", "++", "it", ")", "{", "MBB", ".", "addLiveIn", "(", "it", "->", "getReg", "(", ")", ")", ";", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "it", "->", "getReg", "(", ")", ",", "true", ",", "it", "->", "getFrameIdx", "(", ")", ",", "it", "->", "getRegClass", "(", ")", ")", ";", "if", "(", "emitFrameMoves", ")", "{", "MCSymbol", "*", "SaveLabel", "=", "MMI", "->", "getContext", "(", ")", ".", "CreateTempSymbol", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addSym", "(", "SaveLabel", ")", ";", "XFI", "->", "getSpillLabels", "(", ")", ".", "push_back", "(", "std", "::", "make_pair", "(", "SaveLabel", ",", "*", "it", ")", ")", ";", "}", "}", "return", "true", ";", "}" ]

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

[ "_", "_", "cpuid", "(", "_", "_", "leaf", ",", "*", "_", "_", "eax", ",", "*", "_", "_", "ebx", ",", "*", "_", "_", "ecx", ",", "*", "_", "_", "edx", ")", ";" ]

[ "unsigned", "int", "_", "_", "ext", "=", "_", "_", "leaf", "&", "<NUM_LIT>", ";", "unsigned", "int", "_", "_", "maxlevel", "=", "_", "_", "get_cpuid_max", "(", "_", "_", "ext", ",", "<NUM_LIT>", ")", ";", "if", "(", "_", "_", "maxlevel", "==", "<NUM_LIT>", "||", "_", "_", "maxlevel", "<", "_", "_", "leaf", ")", "return", "<NUM_LIT>", ";" ]

[ "static", "void", "pdp11_conditional_register_usage", "(", "void", ")", "{", "int", "i", ";", "HARD_REG_SET", "x", ";", "if", "(", "!", "TARGET_FPU", ")", "{", "COPY_HARD_REG_SET", "(", "x", ",", "reg_class_contents", "[", "(", "int", ")", "FPU_REGS", "]", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "x", ",", "i", ")", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "<NUM_LIT>", ";", "}", "if", "(", "TARGET_AC0", ")", "call_used_regs", "[", "AC0_REGNUM", "]", "=", "<NUM_LIT>", ";", "if", "(", "TARGET_UNIX_ASM", ")", "{", "reg_names", "[", "<NUM_LIT>", "]", "=", "<STR_LIT>", "fr0", "<STR_LIT>", ";", "reg_names", "[", "<NUM_LIT>", "]", "=", "<STR_LIT>", "fr1", "<STR_LIT>", ";", "reg_names", "[", "<NUM_LIT>", "]", "=", "<STR_LIT>", "fr2", "<STR_LIT>", ";", "reg_names", "[", "<NUM_LIT>", "]", "=", "<STR_LIT>", "fr3", "<STR_LIT>", ";", "reg_names", "[", "<NUM_LIT>", "]", "=", "<STR_LIT>", "fr4", "<STR_LIT>", ";", "reg_names", "[", "<NUM_LIT>", "]", "=", "<STR_LIT>", "fr5", "<STR_LIT>", ";", "}", "}" ]

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

[ "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

[ "def", "J2_loop1r", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "b30_2Imm", ":", "$", "Ii", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_df3319ed", ",", "TypeCR", ">", ",", "Enc_864a5a", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "LC1", ",", "SA1", "]", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

[ "<NUM_LIT>", ";" ]

[ "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "DebugLoc", "dl", ";", "BuildMI", "(", "&", "MBB", ",", "dl", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "}", "return", "<NUM_LIT>", ";", "}", "return" ]

[ ")", ")", ";" ]

[ "WaitStates", "=", "std", "::", "max", "(", "WaitStates", ",", "checkFPAtomicToDenormModeHazard", "(", "MI", ")", ")", ";", "if", "(", "ST", ".", "hasNoDataDepHazard", "(", ")", ")", "return", "WaitStates", ";", "if", "(", "SIInstrInfo", "::", "isVALU", "(", "*", "MI", ")", ")", "WaitStates", "=", "std", "::", "max", "(", "WaitStates", ",", "checkVALUHazards", "(", "MI", ")", ")", ";", "if", "(", "SIInstrInfo", "::", "isDPP", "(", "*", "MI", ")", ")", "WaitStates", "=", "std", "::", "max", "(", "WaitStates", ",", "checkDPPHazards", "(", "MI", ")", ")", ";", "if", "(", "isDivFMas", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "WaitStates", "=", "std", "::", "max", "(", "WaitStates", ",", "checkDivFMasHazards", "(", "MI", ")", ")", ";", "if", "(", "isRWLane", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "WaitStates", "=", "std", "::", "max", "(", "WaitStates", ",", "checkRWLaneHazards", "(", "MI", ")", ")", ";", "if", "(", "MI", "->", "isInlineAsm", "(", ")", ")", "return", "std", "::", "max", "(", "WaitStates", ",", "checkInlineAsmHazards", "(", "MI", ")", ")", ";", "if", "(", "isSGetReg", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "return", "std", "::", "max", "(", "WaitStates", ",", "checkGetRegHazards", "(", "MI", ")", ")", ";", "if", "(", "isSSetReg", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "return", "std", "::", "max", "(", "WaitStates", ",", "checkSetRegHazards", "(", "MI" ]

[ "BitVector", "TOYRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Reserved", ".", "set", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Reserved", ".", "set", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Reserved", ".", "set", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", "Reserved", ";", "}" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "if", "(", "IdxVal", ">=", "<NUM_LIT>", "&&", "IdxVal", "<", "int64_t", "(", "<NUM_LIT>", "/", "Ty", ".", "getVectorElementType", "(", ")", ".", "getSizeInBits", "(", ")", ")", ")", "return", "Op", ";" ]

[ "EVT", "PredVT", "=", "Ty", ".", "changeVectorElementType", "(", "MVT", "::", "i1", ")", ";", "SDValue", "Pred", "=", "getPTrue", "(", "DAG", ",", "DL", ",", "PredVT", ",", "*", "PredPattern", ")", ";", "Pred", "=", "DAG", ".", "getNode", "(", "ISD", "::", "VECTOR_REVERSE", ",", "DL", ",", "PredVT", ",", "Pred", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "Ty", ",", "Pred", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "}" ]

[ "static", "void", "output_stack_adjust", "(", "int", "size", ",", "rtx", "reg", ",", "int", "epilogue_p", ",", "HARD_REG_SET", "*", "live_regs_mask", ",", "bool", "frame_p", ")", "{", "rtx_insn", "*", "(", "*", "emit_fn", ")", "(", "rtx", ")", "=", "frame_p", "?", "&", "frame_insn", ":", "&", "emit_insn", ";", "if", "(", "size", ")", "{", "HOST_WIDE_INT", "align", "=", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ";", "gcc_assert", "(", "!", "(", "size", "%", "align", ")", ")", ";", "if", "(", "CONST_OK_FOR_ADD", "(", "size", ")", ")", "emit_fn", "(", "GEN_ADD3", "(", "reg", ",", "reg", ",", "GEN_INT", "(", "size", ")", ")", ")", ";", "else", "if", "(", "CONST_OK_FOR_ADD", "(", "size", "/", "<NUM_LIT>", "&", "-", "align", ")", "&&", "CONST_OK_FOR_ADD", "(", "size", "-", "(", "size", "/", "<NUM_LIT>", "&", "-", "align", ")", ")", ")", "{", "emit_fn", "(", "GEN_ADD3", "(", "reg", ",", "reg", ",", "GEN_INT", "(", "size", "/", "<NUM_LIT>", "&", "-", "align", ")", ")", ")", ";", "emit_fn", "(", "GEN_ADD3", "(", "reg", ",", "reg", ",", "GEN_INT", "(", "size", "-", "(", "size", "/", "<NUM_LIT>", "&", "-", "align", ")", ")", ")", ")", ";", "}", "else", "{", "rtx", "const_reg", ";", "rtx", "insn", ";", "int", "temp", "=", "epilogue_p", "?", "<NUM_LIT>", ":", "(", "TARGET_SH5", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "int", "i", ";", "if", "(", "epilogue_p", "<", "<NUM_LIT>", "||", "current_function_interrupt", "||", "!", "call_really_used_regs", "[", "temp", "]", "||", "fixed_regs", "[", "temp", "]", ")", "temp", "=", "-", "<NUM_LIT>", ";", "if", "(", "temp", "<", "<NUM_LIT>", "&&", "!", "current_function_interrupt", "&&", "(", "TARGET_SHMEDIA", "||", "epilogue_p", ">=", "<NUM_LIT>", ")", ")", "{", "HARD_REG_SET", "temps", ";", "COPY_HARD_REG_SET", "(", "temps", ",", "call_used_reg_set", ")", ";", "AND_COMPL_HARD_REG_SET", "(", "temps", ",", "call_fixed_reg_set", ")", ";", "if", "(", "epilogue_p", ">", "<NUM_LIT>", ")", "{", "int", "nreg", "=", "<NUM_LIT>", ";", "if", "(", "crtl", "->", "return_rtx", ")", "{", "machine_mode", "mode", ";", "mode", "=", "GET_MODE", "(", "crtl", "->", "return_rtx", ")", ";", "if", "(", "BASE_RETURN_VALUE_REG", "(", "mode", ")", "==", "FIRST_RET_REG", ")", "nreg", "=", "HARD_REGNO_NREGS", "(", "FIRST_RET_REG", ",", "mode", ")", ";", "}", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "nreg", ";", "i", "++", ")", "CLEAR_HARD_REG_BIT", "(", "temps", ",", "FIRST_RET_REG", "+", "i", ")", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "{", "CLEAR_HARD_REG_BIT", "(", "temps", ",", "EH_RETURN_STACKADJ_REGNO", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<=", "<NUM_LIT>", ";", "i", "++", ")", "CLEAR_HARD_REG_BIT", "(", "temps", ",", "EH_RETURN_DATA_REGNO", "(", "i", ")", ")", ";", "}", "}", "if", "(", "TARGET_SHMEDIA", "&&", "epilogue_p", "<", "<NUM_LIT>", ")", "for", "(", "i", "=", "FIRST_TARGET_REG", ";", "i", "<=", "LAST_TARGET_REG", ";", "i", "++", ")", "CLEAR_HARD_REG_BIT", "(", "temps", ",", "i", ")", ";", "if", "(", "epilogue_p", "<=", "<NUM_LIT>", ")", "{", "for", "(", "i", "=", "FIRST_PARM_REG", ";", "i", "<", "FIRST_PARM_REG", "+", "NPARM_REGS", "(", "SImode", ")", ";", "i", "++", ")", "CLEAR_HARD_REG_BIT", "(", "temps", ",", "i", ")", ";", "if", "(", "cfun", "->", "static_chain_decl", "!=", "NULL", ")", "CLEAR_HARD_REG_BIT", "(", "temps", ",", "STATIC_CHAIN_REGNUM", ")", ";", "}", "temp", "=", "scavenge_reg", "(", "&", "temps", ")", ";", "}", "if", "(", "temp", "<", "<NUM_LIT>", "&&", "live_regs_mask", ")", "{", "HARD_REG_SET", "temps", ";", "COPY_HARD_REG_SET", "(", "temps", ",", "*", "live_regs_mask", ")", ";", "CLEAR_HARD_REG_BIT", "(", "temps", ",", "REGNO", "(", "reg", ")", ")", ";", "temp", "=", "scavenge_reg", "(", "&", "temps", ")", ";", "}", "if", "(", "temp", "<", "<NUM_LIT>", ")", "{", "rtx", "adj_reg", ",", "tmp_reg", ",", "mem", ";", "gcc_assert", "(", "!", "TARGET_SHMEDIA", "&&", "epilogue_p", ")", ";", "gcc_assert", "(", "!", "fixed_regs", "[", "<NUM_LIT>", "]", "&&", "!", "fixed_regs", "[", "<NUM_LIT>", "]", "&&", "!", "global_regs", "[", "<NUM_LIT>", "]", "&&", "!", "global_regs", "[", "<NUM_LIT>", "]", ")", ";", "adj_reg", "=", "gen_rtx_REG", "(", "GET_MODE", "(", "reg", ")", ",", "<NUM_LIT>", ")", ";", "tmp_reg", "=", "gen_rtx_REG", "(", "GET_MODE", "(", "reg", ")", ",", "<NUM_LIT>", ")", ";", "emit_move_insn", "(", "gen_tmp_stack_mem", "(", "Pmode", ",", "reg", ")", ",", "adj_reg", ")", ";", "emit_insn", "(", "GEN_MOV", "(", "adj_reg", ",", "GEN_INT", "(", "size", ")", ")", ")", ";", "emit_insn", "(", "GEN_ADD3", "(", "adj_reg", ",", "adj_reg", ",", "reg", ")", ")", ";", "mem", "=", "gen_tmp_stack_mem", "(", "Pmode", ",", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "adj_reg", ")", ")", ";", "emit_move_insn", "(", "mem", ",", "tmp_reg", ")", ";", "emit_move_insn", "(", "tmp_reg", ",", "gen_tmp_stack_mem", "(", "Pmode", ",", "reg", ")", ")", ";", "mem", "=", "gen_tmp_stack_mem", "(", "Pmode", ",", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "adj_reg", ")", ")", ";", "emit_move_insn", "(", "mem", ",", "tmp_reg", ")", ";", "emit_move_insn", "(", "reg", ",", "adj_reg", ")", ";", "mem", "=", "gen_tmp_stack_mem", "(", "Pmode", ",", "gen_rtx_POST_INC", "(", "Pmode", ",", "reg", ")", ")", ";", "emit_move_insn", "(", "adj_reg", ",", "mem", ")", ";", "mem", "=", "gen_tmp_stack_mem", "(", "Pmode", ",", "gen_rtx_POST_INC", "(", "Pmode", ",", "reg", ")", ")", ";", "emit_move_insn", "(", "tmp_reg", ",", "mem", ")", ";", "emit_use", "(", "tmp_reg", ")", ";", "emit_use", "(", "adj_reg", ")", ";", "return", ";", "}", "const_reg", "=", "gen_rtx_REG", "(", "GET_MODE", "(", "reg", ")", ",", "temp", ")", ";", "if", "(", "size", "<", "<NUM_LIT>", ")", "{", "emit_insn", "(", "GEN_MOV", "(", "const_reg", ",", "GEN_INT", "(", "-", "size", ")", ")", ")", ";", "insn", "=", "emit_fn", "(", "GEN_SUB3", "(", "reg", ",", "reg", ",", "const_reg", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "GEN_MOV", "(", "const_reg", ",", "GEN_INT", "(", "size", ")", ")", ")", ";", "insn", "=", "emit_fn", "(", "GEN_ADD3", "(", "reg", ",", "reg", ",", "const_reg", ")", ")", ";", "}", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "reg", ",", "gen_rtx_PLUS", "(", "SImode", ",", "reg", ",", "GEN_INT", "(", "size", ")", ")", ")", ")", ";", "}", "}", "}" ]

[ "Adjust", "the", "stack", "and", "return", "the", "number", "of", "bytes", "taken", "to", "do", "it" ]

[ "<FIXS>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "<FIXE>", "<FIXS>", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "fix", ":", "DI", "(", "fix", ":", "DF", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", ")", "<FIXE>", "<FIXS>", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", "<FIXE>", "<FIXS>", "operands", "[", "<NUM_LIT>", "]", "=", "gen_reg_rtx", "(", "DImode", ")", "operands", "[", "<NUM_LIT>", "]", "=", "gen_lowpart", "(", "SImode", ",", "operands", "[", "<NUM_LIT>", "]", ")", "operands", "[", "<NUM_LIT>", "]", "=", "gen_reg_rtx", "(", "DFmode", ")", "operands", "[", "<NUM_LIT>", "]", "=", "(", "rtx", ")", "assign_386_stack_local", "(", "SImode", ",", "<NUM_LIT>", ")", "operands", "[", "<NUM_LIT>", "]", "=", "(", "rtx", ")", "assign_386_stack_local", "(", "SImode", ",", "<NUM_LIT>", ")", "<FIXE>", "<FIXS>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "<FIXE>", "<FIXS>", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "fix", ":", "DI", "(", "fix", ":", "SF", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", ")", "<FIXE>", "<FIXS>", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", "<FIXE>", "<FIXS>", "operands", "[", "<NUM_LIT>", "]", "=", "gen_reg_rtx", "(", "DImode", ")", "operands", "[", "<NUM_LIT>", "]", "=", "gen_lowpart", "(", "SImode", ",", "operands", "[", "<NUM_LIT>", "]", ")", "operands", "[", "<NUM_LIT>", "]", "=", "gen_reg_rtx", "(", "SFmode", ")", "operands", "[", "<NUM_LIT>", "]", "=", "(", "rtx", ")", "assign_386_stack_local", "(", "SImode", ",", "<NUM_LIT>", ")", "operands", "[", "<NUM_LIT>", "]", "=", "(", "rtx", ")", "assign_386_stack_local", "(", "SImode", ",", "<NUM_LIT>", ")", "<FIXE>", "<FIXS>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "<FIXE>", "<FIXS>", "(", "fix", ":", "DI", "(", "fix", ":", "DF", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", ")", "]", "<FIXE>", "<FIXS>", "operands", "[", "<NUM_LIT>", "]", "=", "gen_reg_rtx", "(", "DFmode", ")", "operands", "[", "<NUM_LIT>", "]", "=", "(", "rtx", ")", "assign_386_stack_local", "(", "SImode", ",", "<NUM_LIT>", ")", "operands", "[", "<NUM_LIT>", "]", "=", "(", "rtx", ")", "assign_386_stack_local", "(", "SImode", ",", "<NUM_LIT>", ")", "<FIXE>", "<FIXS>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "<FIXE>", "<FIXS>", "(", "fix", ":", "DI", "(", "fix", ":", "SF", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", ")", "]", "<FIXE>", "<FIXS>", "operands", "[", "<NUM_LIT>", "]", "=", "gen_reg_rtx", "(", "SFmode", ")", "operands", "[", "<NUM_LIT>", "]", "=", "(", "rtx", ")", "assign_386_stack_local", "(", "SImode", ",", "<NUM_LIT>", ")", "operands", "[", "<NUM_LIT>", "]", "=", "(", "rtx", ")", "assign_386_stack_local", "(", "SImode", ",", "<NUM_LIT>", ")", "<FIXE>" ]

[ "(", "define_expand", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "<BUGE>", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<BUGS>", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "fix", ":", "DI", "(", "fix", ":", "DF", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "match_scratch", ":", "HI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", ")", "<BUGE>", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", ")", "(", "define_expand", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "<BUGE>", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<BUGS>", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "fix", ":", "DI", "(", "fix", ":", "SF", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "match_scratch", ":", "HI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", ")", "<BUGE>", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", ")", "(", "define_expand", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "<BUGE>", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "parallel", "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "fix", ":", "DI", "(", "fix", ":", "DF", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "match_scratch", ":", "HI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", ")", "(", "define_expand", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "<BUGE>", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "parallel", "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "fix", ":", "DI", "(", "fix", ":", "SF", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "match_scratch", ":", "HI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ ";" ]

[ "virtual", "MachineInstr", "*", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "Ops", ",", "MachineInstr", "*", "LoadMI", ")", "const", "{", "return", "<NUM_LIT>" ]

[ "(", "set", "(", "ResTy", "VPR128", ":", "$", "Rd", ")", ",", "(", "ResTy", "(", "opnode", "(", "OpTy", "VPR128", ":", "$", "Rn", ")", ",", "(", "OpTy", "VPR128", ":", "$", "Rm", ")", ")", ")", ")", "]", ",", "NoItinerary", ">", ";" ]

[ "class", "NeonI_3VDL2_2Op_mull", "<", "bit", "q", ",", "bit", "u", ",", "bits", "<", "<NUM_LIT>", ">", "size", ",", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "string", "asmop", ",", "string", "ResS", ",", "string", "OpS", ",", "SDPatternOperator", "opnode", ",", "ValueType", "ResTy", ",", "ValueType", "OpTy", ">", ":", "NeonI_3VDiff", "<", "q", ",", "u", ",", "size", ",", "opcode", ",", "(", "outs", "VPR128", ":", "$", "Rd", ")", ",", "(", "ins", "VPR128", ":", "$", "Rn", ",", "VPR128", ":", "$", "Rm", ")", ",", "asmop", "#", "<STR_LIT>", "#", "ResS", "#", "<STR_LIT>", "#", "OpS", "#", "<STR_LIT>", "#", "OpS", ",", "[" ]

[ "MI", ",", "MachineBasicBlock", "*", "MBB", ")", "{" ]

[ "void", "TGSICFGStructurizer", "::", "setTrueBranch", "(", "MachineInstr", "*" ]

[ "_", "W", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_pavgw128_mask", "(", "(", "_", "_", "v8hi", ")", "_", "_", "A", ",", "(", "_", "_", "v8hi", ")", "_", "_", "B", ",", "(", "_", "_", "v8hi", ")", "_" ]

[ "return", "<NUM_LIT>", ";" ]

[ "return", "<NUM_LIT>", ";", "case", "MVT", "::", "i16", ":", "return", "<NUM_LIT>", ";", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "f32", ":", "return", "<NUM_LIT>", ";", "case", "MVT", "::", "i64", ":", "case", "MVT", "::", "f64", ":" ]

[ "}" ]

[ "def", "KryoWrite_2cyc_XY_noRSV_234ln", ":", "SchedWriteRes", "<", "[", "KryoUnitXY", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";" ]

[ ")" ]

[ "(", "define_bypass", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>" ]

[ "unsigned", "Idx", "=", "IsLittleEndian", "?", "i", ":", "(", "NumBytes", "-", "<NUM_LIT>", "-", "i", ")", ";" ]

[ "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{" ]

[ "(", ")", "{" ]

[ "LLVM_EXTERNAL_VISIBILITY", "void", "LLVMInitializeHexagonAsmPrinter" ]

[ ",", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";" ]

[ "def", "USAX", ":", "AAI", "<", "<NUM_LIT>" ]

[ "}" ]

[ "if", "(", "size", "<=", "<NUM_LIT>", ")", ";", "else", "if", "(", "size", "<=", "small_memory_max", "[", "(", "int", ")", "SMALL_MEMORY_TDA", "]", ")", "v850_set_data_area", "(", "decl", ",", "DATA_AREA_TDA", ")", ";", "else", "if", "(", "size", "<=", "small_memory_max", "[", "(", "int", ")", "SMALL_MEMORY_SDA", "]", ")", "v850_set_data_area", "(", "decl", ",", "DATA_AREA_SDA", ")", ";", "else", "if", "(", "size", "<=", "small_memory_max", "[", "(", "int", ")", "SMALL_MEMORY_ZDA", "]", ")", "v850_set_data_area", "(", "decl", ",", "DATA_AREA_ZDA", ")", ";", "}", "if", "(", "v850_get_data_area", "(", "decl", ")", "==", "DATA_AREA_NORMAL", ")", "return", ";", "}", "flags", "=", "SYMBOL_REF_FLAGS", "(", "symbol", ")", ";", "switch", "(", "v850_get_data_area", "(", "decl", ")", ")", "{", "case", "DATA_AREA_ZDA", ":", "flags", "|=", "SYMBOL_FLAG_ZDA", ";", "break", ";", "case", "DATA_AREA_TDA", ":", "flags", "|=", "SYMBOL_FLAG_TDA", ";", "break", ";", "case", "DATA_AREA_SDA", ":", "flags", "|=", "SYMBOL_FLAG_SDA", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "SYMBOL_REF_FLAGS", "(", "symbol", ")", "=", "flags", ";" ]

[ ")", ")", ")", ")" ]

[ "(", "if_then_else", "(", "ne", "(", "symbol_ref", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "const_string", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>" ]

[ "<STR_LIT>", ")" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "zero_extend", ":", "SI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>" ]

[ "}" ]

[ "HexagonGenExtract", "(", ")", ":", "FunctionPass", "(", "ID", ")", ",", "ExtractCount", "(", "<NUM_LIT>", ")", "{", "initializeHexagonGenExtractPass", "(", "*", "PassRegistry", "::", "getPassRegistry", "(", ")", ")", ";" ]

[ "rtx", "par", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "store", ",", "stvx", ")", ")", ";" ]

[ "rtx", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rtx", "store", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "op0", ",", "tmp", ")", ";", "rtx", "stvx", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "const0_rtx", ")", ",", "unspec", ")", ";" ]

[ "}" ]

[ "void", "X86ATTInstPrinter", "::", "print_pcrel_imm", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ")", "{", "const", "MCOperand", "&", "Op", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "O", "<<", "(", "int", ")", "Op", ".", "getImm", "(", ")", ";", "else", "{", "assert", "(", "Op", ".", "isExpr", "(", ")", "&&", "<STR_LIT>", "unknown pcrel immediate operand", "<STR_LIT>", ")", ";", "O", "<<", "*", "Op", ".", "getExpr", "(", ")", ";" ]

[ ")", ")" ]

[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ ",", "SubVectorOps", ")", ")", "{" ]

[ "return", "DAG", ".", "getNode", "(", "ISD", "::", "INSERT_SUBVECTOR", ",", "dl", ",", "OpVT", ",", "getZeroVector", "(", "OpVT", ",", "Subtarget", ",", "DAG", ",", "dl", ")", ",", "SubVec", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getIntPtrConstant", "(", "IdxVal", "+", "Idx2Val", ",", "dl", ")", ")", ";", "}", "if", "(", "SubVec", ".", "getOpcode", "(", ")", "==", "ISD", "::", "EXTRACT_SUBVECTOR", "&&", "IdxVal", "==", "<NUM_LIT>", "&&", "isNullConstant", "(", "SubVec", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "&&", "SubVec", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "INSERT_SUBVECTOR", ")", "{", "SDValue", "Ins", "=", "SubVec", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "isNullConstant", "(", "Ins", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "&&", "ISD", "::", "isBuildVectorAllZeros", "(", "Ins", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ")", "&&", "Ins", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueSizeInBits", "(", ")", "<=", "SubVecVT", ".", "getSizeInBits", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "ISD", "::", "INSERT_SUBVECTOR", ",", "dl", ",", "OpVT", ",", "getZeroVector", "(", "OpVT", ",", "Subtarget", ",", "DAG", ",", "dl", ")", ",", "Ins", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "}", "}", "if", "(", "IsI1Vector", ")", "return", "SDValue", "(", ")", ";", "if", "(", "SubVec", ".", "getOpcode", "(", ")", "==", "ISD", "::", "EXTRACT_SUBVECTOR", "&&", "SubVec", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getSimpleValueType", "(", ")", "==", "OpVT", "&&", "(", "IdxVal", "!=", "<NUM_LIT>", "||", "!", "Vec", ".", "isUndef", "(", ")", ")", ")", "{", "int", "ExtIdxVal", "=", "SubVec", ".", "getConstantOperandVal", "(", "<NUM_LIT>", ")", ";", "if", "(", "ExtIdxVal", "!=", "<NUM_LIT>", ")", "{", "int", "VecNumElts", "=", "OpVT", ".", "getVectorNumElements", "(", ")", ";", "int", "SubVecNumElts", "=", "SubVecVT", ".", "getVectorNumElements", "(", ")", ";", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "Mask", "(", "VecNumElts", ")", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "!=", "VecNumElts", ";", "++", "i", ")", "Mask", "[", "i", "]", "=", "i", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "!=", "SubVecNumElts", ";", "++", "i", ")", "Mask", "[", "i", "+", "IdxVal", "]", "=", "i", "+", "ExtIdxVal", "+", "VecNumElts", ";", "return", "DAG", ".", "getVectorShuffle", "(", "OpVT", ",", "dl", ",", "Vec", ",", "SubVec", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Mask", ")", ";", "}", "}", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "SubVectorOps", ";", "if", "(", "collectConcatOps", "(", "N" ]

[ "us_minus", "]", ")" ]

[ "(", "define_code_iterator", "sat_plusminus", "[", "ss_plus", "us_plus", "ss_minus" ]

[ "(", "void", ")", "FrameIdx", ";" ]

[ "void", "MSP430FrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", ")", "const", "{", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "int", "FrameIdx", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateFixedObject", "(", "<NUM_LIT>", ",", "-", "<NUM_LIT>", ",", "true", ")", ";" ]

[ "return", "false", ";" ]

[ "bool", "AMDGPUTargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "getScalarType", "(", ")", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", "==", "MVT", "::", "f32", "||", "VT", ".", "getScalarType", "(", ")", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", "==", "MVT", "::", "f64", ")", "{", "return", "true", ";", "}", "else", "{" ]

[ "(", "and", "(", "match_code", "<STR_LIT>", ")" ]

[ "(", "define_constraint", "<STR_LIT>", "<STR_LIT>" ]

[ "}" ]

[ "virtual", "bool", "gate", "(", "function", "*", ")", "{", "return", "TARGET_OLDABI", "&&", "flag_frame_header_optimization", "&&", "optimize", ">", "<NUM_LIT>", ";" ]