1//===-- X86InstComments.cpp - Generate verbose-asm comments for instrs ----===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This defines functionality used to emit comments about X86 instructions to 11// an output stream for -fverbose-asm. 12// 13//===----------------------------------------------------------------------===// 14 15#include "X86InstComments.h" 16#include "MCTargetDesc/X86MCTargetDesc.h" 17#include "Utils/X86ShuffleDecode.h" 18#include "llvm/MC/MCInst.h" 19#include "llvm/CodeGen/MachineValueType.h" 20#include "llvm/Support/raw_ostream.h" 21 22using namespace llvm; 23 24//===----------------------------------------------------------------------===// 25// Top Level Entrypoint 26//===----------------------------------------------------------------------===// 27 28/// EmitAnyX86InstComments - This function decodes x86 instructions and prints 29/// newline terminated strings to the specified string if desired. This 30/// information is shown in disassembly dumps when verbose assembly is enabled. 31void llvm::EmitAnyX86InstComments(const MCInst *MI, raw_ostream &OS, 32 const char *(*getRegName)(unsigned)) { 33 // If this is a shuffle operation, the switch should fill in this state. 34 SmallVector<int, 8> ShuffleMask; 35 const char *DestName = nullptr, *Src1Name = nullptr, *Src2Name = nullptr; 36 37 switch (MI->getOpcode()) { 38 case X86::INSERTPSrr: 39 case X86::VINSERTPSrr: 40 DestName = getRegName(MI->getOperand(0).getReg()); 41 Src1Name = getRegName(MI->getOperand(1).getReg()); 42 Src2Name = getRegName(MI->getOperand(2).getReg()); 43 if(MI->getOperand(3).isImm()) 44 DecodeINSERTPSMask(MI->getOperand(3).getImm(), ShuffleMask); 45 break; 46 47 case X86::MOVLHPSrr: 48 case X86::VMOVLHPSrr: 49 Src2Name = getRegName(MI->getOperand(2).getReg()); 50 Src1Name = getRegName(MI->getOperand(1).getReg()); 51 DestName = getRegName(MI->getOperand(0).getReg()); 52 DecodeMOVLHPSMask(2, ShuffleMask); 53 break; 54 55 case X86::MOVHLPSrr: 56 case X86::VMOVHLPSrr: 57 Src2Name = getRegName(MI->getOperand(2).getReg()); 58 Src1Name = getRegName(MI->getOperand(1).getReg()); 59 DestName = getRegName(MI->getOperand(0).getReg()); 60 DecodeMOVHLPSMask(2, ShuffleMask); 61 break; 62 63 case X86::PALIGNR128rr: 64 case X86::VPALIGNR128rr: 65 Src1Name = getRegName(MI->getOperand(2).getReg()); 66 // FALL THROUGH. 67 case X86::PALIGNR128rm: 68 case X86::VPALIGNR128rm: 69 Src2Name = getRegName(MI->getOperand(1).getReg()); 70 DestName = getRegName(MI->getOperand(0).getReg()); 71 if(MI->getOperand(MI->getNumOperands()-1).isImm()) 72 DecodePALIGNRMask(MVT::v16i8, 73 MI->getOperand(MI->getNumOperands()-1).getImm(), 74 ShuffleMask); 75 break; 76 case X86::VPALIGNR256rr: 77 Src1Name = getRegName(MI->getOperand(2).getReg()); 78 // FALL THROUGH. 79 case X86::VPALIGNR256rm: 80 Src2Name = getRegName(MI->getOperand(1).getReg()); 81 DestName = getRegName(MI->getOperand(0).getReg()); 82 if(MI->getOperand(MI->getNumOperands()-1).isImm()) 83 DecodePALIGNRMask(MVT::v32i8, 84 MI->getOperand(MI->getNumOperands()-1).getImm(), 85 ShuffleMask); 86 break; 87 88 case X86::PSHUFDri: 89 case X86::VPSHUFDri: 90 Src1Name = getRegName(MI->getOperand(1).getReg()); 91 // FALL THROUGH. 92 case X86::PSHUFDmi: 93 case X86::VPSHUFDmi: 94 DestName = getRegName(MI->getOperand(0).getReg()); 95 if(MI->getOperand(MI->getNumOperands()-1).isImm()) 96 DecodePSHUFMask(MVT::v4i32, 97 MI->getOperand(MI->getNumOperands()-1).getImm(), 98 ShuffleMask); 99 break; 100 case X86::VPSHUFDYri: 101 Src1Name = getRegName(MI->getOperand(1).getReg()); 102 // FALL THROUGH. 103 case X86::VPSHUFDYmi: 104 DestName = getRegName(MI->getOperand(0).getReg()); 105 if(MI->getOperand(MI->getNumOperands()-1).isImm()) 106 DecodePSHUFMask(MVT::v8i32, 107 MI->getOperand(MI->getNumOperands()-1).getImm(), 108 ShuffleMask); 109 break; 110 111 112 case X86::PSHUFHWri: 113 case X86::VPSHUFHWri: 114 Src1Name = getRegName(MI->getOperand(1).getReg()); 115 // FALL THROUGH. 116 case X86::PSHUFHWmi: 117 case X86::VPSHUFHWmi: 118 DestName = getRegName(MI->getOperand(0).getReg()); 119 if(MI->getOperand(MI->getNumOperands()-1).isImm()) 120 DecodePSHUFHWMask(MVT::v8i16, 121 MI->getOperand(MI->getNumOperands()-1).getImm(), 122 ShuffleMask); 123 break; 124 case X86::VPSHUFHWYri: 125 Src1Name = getRegName(MI->getOperand(1).getReg()); 126 // FALL THROUGH. 127 case X86::VPSHUFHWYmi: 128 DestName = getRegName(MI->getOperand(0).getReg()); 129 if(MI->getOperand(MI->getNumOperands()-1).isImm()) 130 DecodePSHUFHWMask(MVT::v16i16, 131 MI->getOperand(MI->getNumOperands()-1).getImm(), 132 ShuffleMask); 133 break; 134 case X86::PSHUFLWri: 135 case X86::VPSHUFLWri: 136 Src1Name = getRegName(MI->getOperand(1).getReg()); 137 // FALL THROUGH. 138 case X86::PSHUFLWmi: 139 case X86::VPSHUFLWmi: 140 DestName = getRegName(MI->getOperand(0).getReg()); 141 if(MI->getOperand(MI->getNumOperands()-1).isImm()) 142 DecodePSHUFLWMask(MVT::v8i16, 143 MI->getOperand(MI->getNumOperands()-1).getImm(), 144 ShuffleMask); 145 break; 146 case X86::VPSHUFLWYri: 147 Src1Name = getRegName(MI->getOperand(1).getReg()); 148 // FALL THROUGH. 149 case X86::VPSHUFLWYmi: 150 DestName = getRegName(MI->getOperand(0).getReg()); 151 if(MI->getOperand(MI->getNumOperands()-1).isImm()) 152 DecodePSHUFLWMask(MVT::v16i16, 153 MI->getOperand(MI->getNumOperands()-1).getImm(), 154 ShuffleMask); 155 break; 156 157 case X86::PUNPCKHBWrr: 158 case X86::VPUNPCKHBWrr: 159 Src2Name = getRegName(MI->getOperand(2).getReg()); 160 // FALL THROUGH. 161 case X86::PUNPCKHBWrm: 162 case X86::VPUNPCKHBWrm: 163 Src1Name = getRegName(MI->getOperand(1).getReg()); 164 DestName = getRegName(MI->getOperand(0).getReg()); 165 DecodeUNPCKHMask(MVT::v16i8, ShuffleMask); 166 break; 167 case X86::VPUNPCKHBWYrr: 168 Src2Name = getRegName(MI->getOperand(2).getReg()); 169 // FALL THROUGH. 170 case X86::VPUNPCKHBWYrm: 171 Src1Name = getRegName(MI->getOperand(1).getReg()); 172 DestName = getRegName(MI->getOperand(0).getReg()); 173 DecodeUNPCKHMask(MVT::v32i8, ShuffleMask); 174 break; 175 case X86::PUNPCKHWDrr: 176 case X86::VPUNPCKHWDrr: 177 Src2Name = getRegName(MI->getOperand(2).getReg()); 178 // FALL THROUGH. 179 case X86::PUNPCKHWDrm: 180 case X86::VPUNPCKHWDrm: 181 Src1Name = getRegName(MI->getOperand(1).getReg()); 182 DestName = getRegName(MI->getOperand(0).getReg()); 183 DecodeUNPCKHMask(MVT::v8i16, ShuffleMask); 184 break; 185 case X86::VPUNPCKHWDYrr: 186 Src2Name = getRegName(MI->getOperand(2).getReg()); 187 // FALL THROUGH. 188 case X86::VPUNPCKHWDYrm: 189 Src1Name = getRegName(MI->getOperand(1).getReg()); 190 DestName = getRegName(MI->getOperand(0).getReg()); 191 DecodeUNPCKHMask(MVT::v16i16, ShuffleMask); 192 break; 193 case X86::PUNPCKHDQrr: 194 case X86::VPUNPCKHDQrr: 195 Src2Name = getRegName(MI->getOperand(2).getReg()); 196 // FALL THROUGH. 197 case X86::PUNPCKHDQrm: 198 case X86::VPUNPCKHDQrm: 199 Src1Name = getRegName(MI->getOperand(1).getReg()); 200 DestName = getRegName(MI->getOperand(0).getReg()); 201 DecodeUNPCKHMask(MVT::v4i32, ShuffleMask); 202 break; 203 case X86::VPUNPCKHDQYrr: 204 Src2Name = getRegName(MI->getOperand(2).getReg()); 205 // FALL THROUGH. 206 case X86::VPUNPCKHDQYrm: 207 Src1Name = getRegName(MI->getOperand(1).getReg()); 208 DestName = getRegName(MI->getOperand(0).getReg()); 209 DecodeUNPCKHMask(MVT::v8i32, ShuffleMask); 210 break; 211 case X86::PUNPCKHQDQrr: 212 case X86::VPUNPCKHQDQrr: 213 Src2Name = getRegName(MI->getOperand(2).getReg()); 214 // FALL THROUGH. 215 case X86::PUNPCKHQDQrm: 216 case X86::VPUNPCKHQDQrm: 217 Src1Name = getRegName(MI->getOperand(1).getReg()); 218 DestName = getRegName(MI->getOperand(0).getReg()); 219 DecodeUNPCKHMask(MVT::v2i64, ShuffleMask); 220 break; 221 case X86::VPUNPCKHQDQYrr: 222 Src2Name = getRegName(MI->getOperand(2).getReg()); 223 // FALL THROUGH. 224 case X86::VPUNPCKHQDQYrm: 225 Src1Name = getRegName(MI->getOperand(1).getReg()); 226 DestName = getRegName(MI->getOperand(0).getReg()); 227 DecodeUNPCKHMask(MVT::v4i64, ShuffleMask); 228 break; 229 230 case X86::PUNPCKLBWrr: 231 case X86::VPUNPCKLBWrr: 232 Src2Name = getRegName(MI->getOperand(2).getReg()); 233 // FALL THROUGH. 234 case X86::PUNPCKLBWrm: 235 case X86::VPUNPCKLBWrm: 236 Src1Name = getRegName(MI->getOperand(1).getReg()); 237 DestName = getRegName(MI->getOperand(0).getReg()); 238 DecodeUNPCKLMask(MVT::v16i8, ShuffleMask); 239 break; 240 case X86::VPUNPCKLBWYrr: 241 Src2Name = getRegName(MI->getOperand(2).getReg()); 242 // FALL THROUGH. 243 case X86::VPUNPCKLBWYrm: 244 Src1Name = getRegName(MI->getOperand(1).getReg()); 245 DestName = getRegName(MI->getOperand(0).getReg()); 246 DecodeUNPCKLMask(MVT::v32i8, ShuffleMask); 247 break; 248 case X86::PUNPCKLWDrr: 249 case X86::VPUNPCKLWDrr: 250 Src2Name = getRegName(MI->getOperand(2).getReg()); 251 // FALL THROUGH. 252 case X86::PUNPCKLWDrm: 253 case X86::VPUNPCKLWDrm: 254 Src1Name = getRegName(MI->getOperand(1).getReg()); 255 DestName = getRegName(MI->getOperand(0).getReg()); 256 DecodeUNPCKLMask(MVT::v8i16, ShuffleMask); 257 break; 258 case X86::VPUNPCKLWDYrr: 259 Src2Name = getRegName(MI->getOperand(2).getReg()); 260 // FALL THROUGH. 261 case X86::VPUNPCKLWDYrm: 262 Src1Name = getRegName(MI->getOperand(1).getReg()); 263 DestName = getRegName(MI->getOperand(0).getReg()); 264 DecodeUNPCKLMask(MVT::v16i16, ShuffleMask); 265 break; 266 case X86::PUNPCKLDQrr: 267 case X86::VPUNPCKLDQrr: 268 Src2Name = getRegName(MI->getOperand(2).getReg()); 269 // FALL THROUGH. 270 case X86::PUNPCKLDQrm: 271 case X86::VPUNPCKLDQrm: 272 Src1Name = getRegName(MI->getOperand(1).getReg()); 273 DestName = getRegName(MI->getOperand(0).getReg()); 274 DecodeUNPCKLMask(MVT::v4i32, ShuffleMask); 275 break; 276 case X86::VPUNPCKLDQYrr: 277 Src2Name = getRegName(MI->getOperand(2).getReg()); 278 // FALL THROUGH. 279 case X86::VPUNPCKLDQYrm: 280 Src1Name = getRegName(MI->getOperand(1).getReg()); 281 DestName = getRegName(MI->getOperand(0).getReg()); 282 DecodeUNPCKLMask(MVT::v8i32, ShuffleMask); 283 break; 284 case X86::PUNPCKLQDQrr: 285 case X86::VPUNPCKLQDQrr: 286 Src2Name = getRegName(MI->getOperand(2).getReg()); 287 // FALL THROUGH. 288 case X86::PUNPCKLQDQrm: 289 case X86::VPUNPCKLQDQrm: 290 Src1Name = getRegName(MI->getOperand(1).getReg()); 291 DestName = getRegName(MI->getOperand(0).getReg()); 292 DecodeUNPCKLMask(MVT::v2i64, ShuffleMask); 293 break; 294 case X86::VPUNPCKLQDQYrr: 295 Src2Name = getRegName(MI->getOperand(2).getReg()); 296 // FALL THROUGH. 297 case X86::VPUNPCKLQDQYrm: 298 Src1Name = getRegName(MI->getOperand(1).getReg()); 299 DestName = getRegName(MI->getOperand(0).getReg()); 300 DecodeUNPCKLMask(MVT::v4i64, ShuffleMask); 301 break; 302 303 case X86::SHUFPDrri: 304 case X86::VSHUFPDrri: 305 Src2Name = getRegName(MI->getOperand(2).getReg()); 306 // FALL THROUGH. 307 case X86::SHUFPDrmi: 308 case X86::VSHUFPDrmi: 309 if(MI->getOperand(MI->getNumOperands()-1).isImm()) 310 DecodeSHUFPMask(MVT::v2f64, 311 MI->getOperand(MI->getNumOperands()-1).getImm(), 312 ShuffleMask); 313 Src1Name = getRegName(MI->getOperand(1).getReg()); 314 DestName = getRegName(MI->getOperand(0).getReg()); 315 break; 316 case X86::VSHUFPDYrri: 317 Src2Name = getRegName(MI->getOperand(2).getReg()); 318 // FALL THROUGH. 319 case X86::VSHUFPDYrmi: 320 if(MI->getOperand(MI->getNumOperands()-1).isImm()) 321 DecodeSHUFPMask(MVT::v4f64, 322 MI->getOperand(MI->getNumOperands()-1).getImm(), 323 ShuffleMask); 324 Src1Name = getRegName(MI->getOperand(1).getReg()); 325 DestName = getRegName(MI->getOperand(0).getReg()); 326 break; 327 328 case X86::SHUFPSrri: 329 case X86::VSHUFPSrri: 330 Src2Name = getRegName(MI->getOperand(2).getReg()); 331 // FALL THROUGH. 332 case X86::SHUFPSrmi: 333 case X86::VSHUFPSrmi: 334 if(MI->getOperand(MI->getNumOperands()-1).isImm()) 335 DecodeSHUFPMask(MVT::v4f32, 336 MI->getOperand(MI->getNumOperands()-1).getImm(), 337 ShuffleMask); 338 Src1Name = getRegName(MI->getOperand(1).getReg()); 339 DestName = getRegName(MI->getOperand(0).getReg()); 340 break; 341 case X86::VSHUFPSYrri: 342 Src2Name = getRegName(MI->getOperand(2).getReg()); 343 // FALL THROUGH. 344 case X86::VSHUFPSYrmi: 345 if(MI->getOperand(MI->getNumOperands()-1).isImm()) 346 DecodeSHUFPMask(MVT::v8f32, 347 MI->getOperand(MI->getNumOperands()-1).getImm(), 348 ShuffleMask); 349 Src1Name = getRegName(MI->getOperand(1).getReg()); 350 DestName = getRegName(MI->getOperand(0).getReg()); 351 break; 352 353 case X86::UNPCKLPDrr: 354 case X86::VUNPCKLPDrr: 355 Src2Name = getRegName(MI->getOperand(2).getReg()); 356 // FALL THROUGH. 357 case X86::UNPCKLPDrm: 358 case X86::VUNPCKLPDrm: 359 DecodeUNPCKLMask(MVT::v2f64, ShuffleMask); 360 Src1Name = getRegName(MI->getOperand(1).getReg()); 361 DestName = getRegName(MI->getOperand(0).getReg()); 362 break; 363 case X86::VUNPCKLPDYrr: 364 Src2Name = getRegName(MI->getOperand(2).getReg()); 365 // FALL THROUGH. 366 case X86::VUNPCKLPDYrm: 367 DecodeUNPCKLMask(MVT::v4f64, ShuffleMask); 368 Src1Name = getRegName(MI->getOperand(1).getReg()); 369 DestName = getRegName(MI->getOperand(0).getReg()); 370 break; 371 case X86::UNPCKLPSrr: 372 case X86::VUNPCKLPSrr: 373 Src2Name = getRegName(MI->getOperand(2).getReg()); 374 // FALL THROUGH. 375 case X86::UNPCKLPSrm: 376 case X86::VUNPCKLPSrm: 377 DecodeUNPCKLMask(MVT::v4f32, ShuffleMask); 378 Src1Name = getRegName(MI->getOperand(1).getReg()); 379 DestName = getRegName(MI->getOperand(0).getReg()); 380 break; 381 case X86::VUNPCKLPSYrr: 382 Src2Name = getRegName(MI->getOperand(2).getReg()); 383 // FALL THROUGH. 384 case X86::VUNPCKLPSYrm: 385 DecodeUNPCKLMask(MVT::v8f32, ShuffleMask); 386 Src1Name = getRegName(MI->getOperand(1).getReg()); 387 DestName = getRegName(MI->getOperand(0).getReg()); 388 break; 389 case X86::UNPCKHPDrr: 390 case X86::VUNPCKHPDrr: 391 Src2Name = getRegName(MI->getOperand(2).getReg()); 392 // FALL THROUGH. 393 case X86::UNPCKHPDrm: 394 case X86::VUNPCKHPDrm: 395 DecodeUNPCKHMask(MVT::v2f64, ShuffleMask); 396 Src1Name = getRegName(MI->getOperand(1).getReg()); 397 DestName = getRegName(MI->getOperand(0).getReg()); 398 break; 399 case X86::VUNPCKHPDYrr: 400 Src2Name = getRegName(MI->getOperand(2).getReg()); 401 // FALL THROUGH. 402 case X86::VUNPCKHPDYrm: 403 DecodeUNPCKHMask(MVT::v4f64, ShuffleMask); 404 Src1Name = getRegName(MI->getOperand(1).getReg()); 405 DestName = getRegName(MI->getOperand(0).getReg()); 406 break; 407 case X86::UNPCKHPSrr: 408 case X86::VUNPCKHPSrr: 409 Src2Name = getRegName(MI->getOperand(2).getReg()); 410 // FALL THROUGH. 411 case X86::UNPCKHPSrm: 412 case X86::VUNPCKHPSrm: 413 DecodeUNPCKHMask(MVT::v4f32, ShuffleMask); 414 Src1Name = getRegName(MI->getOperand(1).getReg()); 415 DestName = getRegName(MI->getOperand(0).getReg()); 416 break; 417 case X86::VUNPCKHPSYrr: 418 Src2Name = getRegName(MI->getOperand(2).getReg()); 419 // FALL THROUGH. 420 case X86::VUNPCKHPSYrm: 421 DecodeUNPCKHMask(MVT::v8f32, ShuffleMask); 422 Src1Name = getRegName(MI->getOperand(1).getReg()); 423 DestName = getRegName(MI->getOperand(0).getReg()); 424 break; 425 case X86::VPERMILPSri: 426 Src1Name = getRegName(MI->getOperand(1).getReg()); 427 // FALL THROUGH. 428 case X86::VPERMILPSmi: 429 if(MI->getOperand(MI->getNumOperands()-1).isImm()) 430 DecodePSHUFMask(MVT::v4f32, 431 MI->getOperand(MI->getNumOperands()-1).getImm(), 432 ShuffleMask); 433 DestName = getRegName(MI->getOperand(0).getReg()); 434 break; 435 case X86::VPERMILPSYri: 436 Src1Name = getRegName(MI->getOperand(1).getReg()); 437 // FALL THROUGH. 438 case X86::VPERMILPSYmi: 439 if(MI->getOperand(MI->getNumOperands()-1).isImm()) 440 DecodePSHUFMask(MVT::v8f32, 441 MI->getOperand(MI->getNumOperands()-1).getImm(), 442 ShuffleMask); 443 DestName = getRegName(MI->getOperand(0).getReg()); 444 break; 445 case X86::VPERMILPDri: 446 Src1Name = getRegName(MI->getOperand(1).getReg()); 447 // FALL THROUGH. 448 case X86::VPERMILPDmi: 449 if(MI->getOperand(MI->getNumOperands()-1).isImm()) 450 DecodePSHUFMask(MVT::v2f64, 451 MI->getOperand(MI->getNumOperands()-1).getImm(), 452 ShuffleMask); 453 DestName = getRegName(MI->getOperand(0).getReg()); 454 break; 455 case X86::VPERMILPDYri: 456 Src1Name = getRegName(MI->getOperand(1).getReg()); 457 // FALL THROUGH. 458 case X86::VPERMILPDYmi: 459 if(MI->getOperand(MI->getNumOperands()-1).isImm()) 460 DecodePSHUFMask(MVT::v4f64, 461 MI->getOperand(MI->getNumOperands()-1).getImm(), 462 ShuffleMask); 463 DestName = getRegName(MI->getOperand(0).getReg()); 464 break; 465 case X86::VPERM2F128rr: 466 case X86::VPERM2I128rr: 467 Src2Name = getRegName(MI->getOperand(2).getReg()); 468 // FALL THROUGH. 469 case X86::VPERM2F128rm: 470 case X86::VPERM2I128rm: 471 // For instruction comments purpose, assume the 256-bit vector is v4i64. 472 if(MI->getOperand(MI->getNumOperands()-1).isImm()) 473 DecodeVPERM2X128Mask(MVT::v4i64, 474 MI->getOperand(MI->getNumOperands()-1).getImm(), 475 ShuffleMask); 476 Src1Name = getRegName(MI->getOperand(1).getReg()); 477 DestName = getRegName(MI->getOperand(0).getReg()); 478 break; 479 case X86::VPERMQYri: 480 case X86::VPERMPDYri: 481 Src1Name = getRegName(MI->getOperand(1).getReg()); 482 // FALL THROUGH. 483 case X86::VPERMQYmi: 484 case X86::VPERMPDYmi: 485 if(MI->getOperand(MI->getNumOperands()-1).isImm()) 486 DecodeVPERMMask(MI->getOperand(MI->getNumOperands()-1).getImm(), 487 ShuffleMask); 488 DestName = getRegName(MI->getOperand(0).getReg()); 489 break; 490 } 491 492 493 // If this was a shuffle operation, print the shuffle mask. 494 if (!ShuffleMask.empty()) { 495 if (!DestName) DestName = Src1Name; 496 OS << (DestName ? DestName : "mem") << " = "; 497 498 // If the two sources are the same, canonicalize the input elements to be 499 // from the first src so that we get larger element spans. 500 if (Src1Name == Src2Name) { 501 for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) { 502 if ((int)ShuffleMask[i] >= 0 && // Not sentinel. 503 ShuffleMask[i] >= (int)e) // From second mask. 504 ShuffleMask[i] -= e; 505 } 506 } 507 508 // The shuffle mask specifies which elements of the src1/src2 fill in the 509 // destination, with a few sentinel values. Loop through and print them 510 // out. 511 for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) { 512 if (i != 0) 513 OS << ','; 514 if (ShuffleMask[i] == SM_SentinelZero) { 515 OS << "zero"; 516 continue; 517 } 518 519 // Otherwise, it must come from src1 or src2. Print the span of elements 520 // that comes from this src. 521 bool isSrc1 = ShuffleMask[i] < (int)ShuffleMask.size(); 522 const char *SrcName = isSrc1 ? Src1Name : Src2Name; 523 OS << (SrcName ? SrcName : "mem") << '['; 524 bool IsFirst = true; 525 while (i != e && 526 (int)ShuffleMask[i] >= 0 && 527 (ShuffleMask[i] < (int)ShuffleMask.size()) == isSrc1) { 528 if (!IsFirst) 529 OS << ','; 530 else 531 IsFirst = false; 532 OS << ShuffleMask[i] % ShuffleMask.size(); 533 ++i; 534 } 535 OS << ']'; 536 --i; // For loop increments element #. 537 } 538 //MI->print(OS, 0); 539 OS << "\n"; 540 } 541 542} 543