src/gallium/drivers/r300/compiler/radeon_compiler_util.c

   1 /*
   2  * Copyright 2010 Tom Stellard <tstellar@gmail.com>
   3  *
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining
   7  * a copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sublicense, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial
  16  * portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  19  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  21  * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  22  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  23  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  24  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  */
  27
  28 /**
  29  * \file
  30  */
  31
  32 #include "radeon_compiler_util.h"
  33
  34 #include "radeon_compiler.h"
  35 #include "radeon_dataflow.h"
  36 /**
  37  */
  38 unsigned int rc_swizzle_to_writemask(unsigned int swz)
  39 {
  40         unsigned int mask = 0;
  41         unsigned int i;
  42
  43         for(i = 0; i < 4; i++) {
  44                 mask |= 1 << GET_SWZ(swz, i);
  45         }
  46         mask &= RC_MASK_XYZW;
  47
  48         return mask;
  49 }
  50
  51 rc_swizzle get_swz(unsigned int swz, rc_swizzle idx)
  52 {
  53         if (idx & 0x4)
  54                 return idx;
  55         return GET_SWZ(swz, idx);
  56 }
  57
  58 /**
  59  * The purpose of this function is to standardize the number channels used by
  60  * swizzles.  All swizzles regardless of what instruction they are a part of
  61  * should have 4 channels initialized with values.
  62  * @param channels The number of channels in initial_value that have a
  63  * meaningful value.
  64  * @return An initialized swizzle that has all of the unused channels set to
  65  * RC_SWIZZLE_UNUSED.
  66  */
  67 unsigned int rc_init_swizzle(unsigned int initial_value, unsigned int channels)
  68 {
  69         unsigned int i;
  70         for (i = channels; i < 4; i++) {
  71                 SET_SWZ(initial_value, i, RC_SWIZZLE_UNUSED);
  72         }
  73         return initial_value;
  74 }
  75
  76 unsigned int combine_swizzles4(unsigned int src,
  77                 rc_swizzle swz_x, rc_swizzle swz_y, rc_swizzle swz_z, rc_swizzle swz_w)
  78 {
  79         unsigned int ret = 0;
  80
  81         ret |= get_swz(src, swz_x);
  82         ret |= get_swz(src, swz_y) << 3;
  83         ret |= get_swz(src, swz_z) << 6;
  84         ret |= get_swz(src, swz_w) << 9;
  85
  86         return ret;
  87 }
  88
  89 unsigned int combine_swizzles(unsigned int src, unsigned int swz)
  90 {
  91         unsigned int ret = 0;
  92
  93         ret |= get_swz(src, GET_SWZ(swz, RC_SWIZZLE_X));
  94         ret |= get_swz(src, GET_SWZ(swz, RC_SWIZZLE_Y)) << 3;
  95         ret |= get_swz(src, GET_SWZ(swz, RC_SWIZZLE_Z)) << 6;
  96         ret |= get_swz(src, GET_SWZ(swz, RC_SWIZZLE_W)) << 9;
  97
  98         return ret;
  99 }
 100
 101 /**
 102  * @param mask Must be either RC_MASK_X, RC_MASK_Y, RC_MASK_Z, or RC_MASK_W
 103  */
 104 rc_swizzle rc_mask_to_swizzle(unsigned int mask)
 105 {
 106         switch (mask) {
 107         case RC_MASK_X: return RC_SWIZZLE_X;
 108         case RC_MASK_Y: return RC_SWIZZLE_Y;
 109         case RC_MASK_Z: return RC_SWIZZLE_Z;
 110         case RC_MASK_W: return RC_SWIZZLE_W;
 111         }
 112         return RC_SWIZZLE_UNUSED;
 113 }
 114
 115 /* Reorder mask bits according to swizzle. */
 116 unsigned swizzle_mask(unsigned swizzle, unsigned mask)
 117 {
 118         unsigned ret = 0;
 119         for (unsigned chan = 0; chan < 4; ++chan) {
 120                 unsigned swz = GET_SWZ(swizzle, chan);
 121                 if (swz < 4)
 122                         ret |= GET_BIT(mask, swz) << chan;
 123         }
 124         return ret;
 125 }
 126
 127 static unsigned int srcs_need_rewrite(const struct rc_opcode_info * info)
 128 {
 129         if (info->HasTexture) {
 130                 return 0;
 131         }
 132         switch (info->Opcode) {
 133                 case RC_OPCODE_DP2:
 134                 case RC_OPCODE_DP3:
 135                 case RC_OPCODE_DP4:
 136                 case RC_OPCODE_DDX:
 137                 case RC_OPCODE_DDY:
 138                         return 0;
 139                 default:
 140                         return 1;
 141         }
 142 }
 143
 144 /**
 145  * @return A swizzle the results from converting old_swizzle using
 146  * conversion_swizzle
 147  */
 148 unsigned int rc_adjust_channels(
 149         unsigned int old_swizzle,
 150         unsigned int conversion_swizzle)
 151 {
 152         unsigned int i;
 153         unsigned int new_swizzle = rc_init_swizzle(RC_SWIZZLE_UNUSED, 0);
 154         for (i = 0; i < 4; i++) {
 155                 unsigned int new_chan = get_swz(conversion_swizzle, i);
 156                 if (new_chan == RC_SWIZZLE_UNUSED) {
 157                         continue;
 158                 }
 159                 SET_SWZ(new_swizzle, new_chan, GET_SWZ(old_swizzle, i));
 160         }
 161         return new_swizzle;
 162 }
 163
 164 static unsigned int rewrite_writemask(
 165         unsigned int old_mask,
 166         unsigned int conversion_swizzle)
 167 {
 168         unsigned int new_mask = 0;
 169         unsigned int i;
 170
 171         for (i = 0; i < 4; i++) {
 172                 if (!GET_BIT(old_mask, i)
 173                    || GET_SWZ(conversion_swizzle, i) == RC_SWIZZLE_UNUSED) {
 174                         continue;
 175                 }
 176                 new_mask |= (1 << GET_SWZ(conversion_swizzle, i));
 177         }
 178
 179         return new_mask;
 180 }
 181
 182 /**
 183  * This function rewrites the writemask of sub and adjusts the swizzles
 184  * of all its source registers based on the conversion_swizzle.
 185  * conversion_swizzle represents a mapping of the old writemask to the
 186  * new writemask.  For a detailed description of how conversion swizzles
 187  * work see rc_rewrite_swizzle().
 188  */
 189 void rc_pair_rewrite_writemask(
 190         struct rc_pair_sub_instruction * sub,
 191         unsigned int conversion_swizzle)
 192 {
 193         const struct rc_opcode_info * info = rc_get_opcode_info(sub->Opcode);
 194         unsigned int i;
 195
 196         sub->WriteMask = rewrite_writemask(sub->WriteMask, conversion_swizzle);
 197
 198         if (!srcs_need_rewrite(info)) {
 199                 return ;
 200         }
 201
 202         for (i = 0; i < info->NumSrcRegs; i++) {
 203                 sub->Arg[i].Swizzle =
 204                         rc_adjust_channels(sub->Arg[i].Swizzle,
 205                                                 conversion_swizzle);
 206         }
 207 }
 208
 209 static void normal_rewrite_writemask_cb(
 210         void * userdata,
 211         struct rc_instruction * inst,
 212         struct rc_src_register * src)
 213 {
 214         unsigned int * conversion_swizzle = (unsigned int *)userdata;
 215         src->Swizzle = rc_adjust_channels(src->Swizzle, *conversion_swizzle);
 216 }
 217
 218 /**
 219  * This function is the same as rc_pair_rewrite_writemask() except it
 220  * operates on normal instructions.
 221  */
 222 void rc_normal_rewrite_writemask(
 223         struct rc_instruction * inst,
 224         unsigned int conversion_swizzle)
 225 {
 226         struct rc_sub_instruction * sub = &inst->U.I;
 227         const struct rc_opcode_info * info = rc_get_opcode_info(sub->Opcode);
 228         sub->DstReg.WriteMask =
 229                 rewrite_writemask(sub->DstReg.WriteMask, conversion_swizzle);
 230
 231         if (info->HasTexture) {
 232                 unsigned int i;
 233                 assert(sub->TexSwizzle == RC_SWIZZLE_XYZW);
 234                 for (i = 0; i < 4; i++) {
 235                         unsigned int swz = GET_SWZ(conversion_swizzle, i);
 236                         if (swz > 3)
 237                                 continue;
 238                         SET_SWZ(sub->TexSwizzle, swz, i);
 239                 }
 240         }
 241
 242         if (!srcs_need_rewrite(info)) {
 243                 return;
 244         }
 245
 246         rc_for_all_reads_src(inst, normal_rewrite_writemask_cb,
 247                                                         &conversion_swizzle);
 248 }
 249
 250 /**
 251  * This function replaces each value 'swz' in swizzle with the value of
 252  * GET_SWZ(conversion_swizzle, swz).  So, if you want to change all the X's
 253  * in swizzle to Y, then conversion_swizzle should be Y___ (0xff9).  If you want
 254  * to change all the Y's in swizzle to X, then conversion_swizzle should be
 255  * _X__ (0xfc7).  If you want to change the Y's to X and the X's to Y, then
 256  * conversion swizzle should be YX__ (0xfc1).
 257  * @param swizzle The swizzle to change
 258  * @param conversion_swizzle Describes the conversion to perform on the swizzle
 259  * @return A converted swizzle
 260  */
 261 unsigned int rc_rewrite_swizzle(
 262         unsigned int swizzle,
 263         unsigned int conversion_swizzle)
 264 {
 265         unsigned int chan;
 266         unsigned int out_swizzle = swizzle;
 267
 268         for (chan = 0; chan < 4; chan++) {
 269                 unsigned int swz = GET_SWZ(swizzle, chan);
 270                 unsigned int new_swz;
 271                 if (swz > 3) {
 272                         SET_SWZ(out_swizzle, chan, swz);
 273                 } else {
 274                         new_swz = GET_SWZ(conversion_swizzle, swz);
 275                         if (new_swz != RC_SWIZZLE_UNUSED) {
 276                                 SET_SWZ(out_swizzle, chan, new_swz);
 277                         } else {
 278                                 SET_SWZ(out_swizzle, chan, swz);
 279                         }
 280                 }
 281         }
 282         return out_swizzle;
 283 }
 284
 285 /**
 286  * Left multiplication of a register with a swizzle
 287  */
 288 struct rc_src_register lmul_swizzle(unsigned int swizzle, struct rc_src_register srcreg)
 289 {
 290         struct rc_src_register tmp = srcreg;
 291         int i;
 292         tmp.Swizzle = 0;
 293         tmp.Negate = 0;
 294         for(i = 0; i < 4; ++i) {
 295                 rc_swizzle swz = GET_SWZ(swizzle, i);
 296                 if (swz < 4) {
 297                         tmp.Swizzle |= GET_SWZ(srcreg.Swizzle, swz) << (i*3);
 298                         tmp.Negate |= GET_BIT(srcreg.Negate, swz) << i;
 299                 } else {
 300                         tmp.Swizzle |= swz << (i*3);
 301                 }
 302         }
 303         return tmp;
 304 }
 305
 306 void reset_srcreg(struct rc_src_register* reg)
 307 {
 308         memset(reg, 0, sizeof(struct rc_src_register));
 309         reg->Swizzle = RC_SWIZZLE_XYZW;
 310 }
 311
 312 unsigned int rc_src_reads_dst_mask(
 313                 rc_register_file src_file,
 314                 unsigned int src_idx,
 315                 unsigned int src_swz,
 316                 rc_register_file dst_file,
 317                 unsigned int dst_idx,
 318                 unsigned int dst_mask)
 319 {
 320         if (src_file != dst_file || src_idx != dst_idx) {
 321                 return RC_MASK_NONE;
 322         }
 323         return dst_mask & rc_swizzle_to_writemask(src_swz);
 324 }
 325
 326 /**
 327  * @return A bit mask specifying whether this swizzle will select from an RGB
 328  * source, an Alpha source, or both.
 329  */
 330 unsigned int rc_source_type_swz(unsigned int swizzle)
 331 {
 332         unsigned int chan;
 333         unsigned int swz = RC_SWIZZLE_UNUSED;
 334         unsigned int ret = RC_SOURCE_NONE;
 335
 336         for(chan = 0; chan < 4; chan++) {
 337                 swz = GET_SWZ(swizzle, chan);
 338                 if (swz == RC_SWIZZLE_W) {
 339                         ret |= RC_SOURCE_ALPHA;
 340                 } else if (swz == RC_SWIZZLE_X || swz == RC_SWIZZLE_Y
 341                                                 || swz == RC_SWIZZLE_Z) {
 342                         ret |= RC_SOURCE_RGB;
 343                 }
 344         }
 345         return ret;
 346 }
 347
 348 unsigned int rc_source_type_mask(unsigned int mask)
 349 {
 350         unsigned int ret = RC_SOURCE_NONE;
 351
 352         if (mask & RC_MASK_XYZ)
 353                 ret |= RC_SOURCE_RGB;
 354
 355         if (mask & RC_MASK_W)
 356                 ret |= RC_SOURCE_ALPHA;
 357
 358         return ret;
 359 }
 360
 361 struct src_select {
 362         rc_register_file File;
 363         int Index;
 364         unsigned int SrcType;
 365 };
 366
 367 struct can_use_presub_data {
 368         struct src_select Selects[5];
 369         unsigned int SelectCount;
 370         const struct rc_src_register * ReplaceReg;
 371         unsigned int ReplaceRemoved;
 372 };
 373
 374 static void can_use_presub_data_add_select(
 375         struct can_use_presub_data * data,
 376         rc_register_file file,
 377         unsigned int index,
 378         unsigned int src_type)
 379 {
 380         struct src_select * select;
 381
 382         select = &data->Selects[data->SelectCount++];
 383         select->File = file;
 384         select->Index = index;
 385         select->SrcType = src_type;
 386 }
 387
 388 /**
 389  * This callback function counts the number of sources in inst that are
 390  * different from the sources in can_use_presub_data->RemoveSrcs.
 391  */
 392 static void can_use_presub_read_cb(
 393         void * userdata,
 394         struct rc_instruction * inst,
 395         struct rc_src_register * src)
 396 {
 397         struct can_use_presub_data * d = userdata;
 398
 399         if (!d->ReplaceRemoved && src == d->ReplaceReg) {
 400                 d->ReplaceRemoved = 1;
 401                 return;
 402         }
 403
 404         if (src->File == RC_FILE_NONE)
 405                 return;
 406
 407         can_use_presub_data_add_select(d, src->File, src->Index,
 408                                         rc_source_type_swz(src->Swizzle));
 409 }
 410
 411 unsigned int rc_inst_can_use_presub(
 412         struct rc_instruction * inst,
 413         rc_presubtract_op presub_op,
 414         unsigned int presub_writemask,
 415         const struct rc_src_register * replace_reg,
 416         const struct rc_src_register * presub_src0,
 417         const struct rc_src_register * presub_src1)
 418 {
 419         struct can_use_presub_data d;
 420         unsigned int num_presub_srcs;
 421         unsigned int i;
 422         const struct rc_opcode_info * info =
 423                                         rc_get_opcode_info(inst->U.I.Opcode);
 424         int rgb_count = 0, alpha_count = 0;
 425         unsigned int src_type0, src_type1;
 426
 427         if (presub_op == RC_PRESUB_NONE) {
 428                 return 1;
 429         }
 430
 431         if (info->HasTexture) {
 432                 return 0;
 433         }
 434
 435         /* We can't use more than one presubtract value in an
 436          * instruction, unless the two prsubtract operations
 437          * are the same and read from the same registers.
 438          * XXX For now we will limit instructions to only one presubtract
 439          * value.*/
 440         if (inst->U.I.PreSub.Opcode != RC_PRESUB_NONE) {
 441                 return 0;
 442         }
 443
 444         memset(&d, 0, sizeof(d));
 445         d.ReplaceReg = replace_reg;
 446
 447         rc_for_all_reads_src(inst, can_use_presub_read_cb, &d);
 448
 449         num_presub_srcs = rc_presubtract_src_reg_count(presub_op);
 450
 451         src_type0 = rc_source_type_swz(presub_src0->Swizzle);
 452         can_use_presub_data_add_select(&d,
 453                 presub_src0->File,
 454                 presub_src0->Index,
 455                 src_type0);
 456
 457         if (num_presub_srcs > 1) {
 458                 src_type1 = rc_source_type_swz(presub_src1->Swizzle);
 459                 can_use_presub_data_add_select(&d,
 460                         presub_src1->File,
 461                         presub_src1->Index,
 462                         src_type1);
 463
 464                 /* Even if both of the presub sources read from the same
 465                  * register, we still need to use 2 different source selects
 466                  * for them, so we need to increment the count to compensate.
 467                  */
 468                 if (presub_src0->File == presub_src1->File
 469                     && presub_src0->Index == presub_src1->Index) {
 470                         if (src_type0 & src_type1 & RC_SOURCE_RGB) {
 471                                 rgb_count++;
 472                         }
 473                         if (src_type0 & src_type1 & RC_SOURCE_ALPHA) {
 474                                 alpha_count++;
 475                         }
 476                 }
 477         }
 478
 479         /* Count the number of source selects for Alpha and RGB.  If we
 480          * encounter two of the same source selects then we can ignore the
 481          * first one. */
 482         for (i = 0; i < d.SelectCount; i++) {
 483                 unsigned int j;
 484                 unsigned int src_type = d.Selects[i].SrcType;
 485                 for (j = i + 1; j < d.SelectCount; j++) {
 486                         if (d.Selects[i].File == d.Selects[j].File
 487                             && d.Selects[i].Index == d.Selects[j].Index) {
 488                                 src_type &= ~d.Selects[j].SrcType;
 489                         }
 490                 }
 491                 if (src_type & RC_SOURCE_RGB) {
 492                         rgb_count++;
 493                 }
 494
 495                 if (src_type & RC_SOURCE_ALPHA) {
 496                         alpha_count++;
 497                 }
 498         }
 499
 500         if (rgb_count > 3 || alpha_count > 3) {
 501                 return 0;
 502         }
 503
 504         return 1;
 505 }
 506
 507 struct max_data {
 508         unsigned int Max;
 509         unsigned int HasFileType;
 510         rc_register_file File;
 511 };
 512
 513 static void max_callback(
 514         void * userdata,
 515         struct rc_instruction * inst,
 516         rc_register_file file,
 517         unsigned int index,
 518         unsigned int mask)
 519 {
 520         struct max_data * d = (struct max_data*)userdata;
 521         if (file == d->File && (!d->HasFileType || index > d->Max)) {
 522                 d->Max = index;
 523                 d->HasFileType = 1;
 524         }
 525 }
 526
 527 /**
 528  * @return The maximum index of the specified register file used by the
 529  * program.
 530  */
 531 int rc_get_max_index(
 532         struct radeon_compiler * c,
 533         rc_register_file file)
 534 {
 535         struct max_data data;
 536         struct rc_instruction * inst;
 537         data.Max = 0;
 538         data.HasFileType = 0;
 539         data.File = file;
 540         for (inst = c->Program.Instructions.Next;
 541                                         inst != &c->Program.Instructions;
 542                                         inst = inst->Next) {
 543                 rc_for_all_reads_mask(inst, max_callback, &data);
 544                 rc_for_all_writes_mask(inst, max_callback, &data);
 545         }
 546         if (!data.HasFileType) {
 547                 return -1;
 548         } else {
 549                 return data.Max;
 550         }
 551 }
 552
 553 static unsigned int get_source_readmask(
 554         struct rc_pair_sub_instruction * sub,
 555         unsigned int source,
 556         unsigned int src_type)
 557 {
 558         unsigned int i;
 559         unsigned int readmask = 0;
 560         const struct rc_opcode_info * info = rc_get_opcode_info(sub->Opcode);
 561
 562         for (i = 0; i < info->NumSrcRegs; i++) {
 563                 if (sub->Arg[i].Source != source
 564                     || src_type != rc_source_type_swz(sub->Arg[i].Swizzle)) {
 565                         continue;
 566                 }
 567                 readmask |= rc_swizzle_to_writemask(sub->Arg[i].Swizzle);
 568         }
 569         return readmask;
 570 }
 571
 572 /**
 573  * This function attempts to remove a source from a pair instructions.
 574  * @param inst
 575  * @param src_type RC_SOURCE_RGB, RC_SOURCE_ALPHA, or both bitwise or'd
 576  * @param source The index of the source to remove
 577  * @param new_readmask A mask representing the components that are read by
 578  * the source that is intended to replace the one you are removing.  If you
 579  * want to remove a source only and not replace it, this parameter should be
 580  * zero.
 581  * @return 1 if the source was successfully removed, 0 if it was not
 582  */
 583 unsigned int rc_pair_remove_src(
 584         struct rc_instruction * inst,
 585         unsigned int src_type,
 586         unsigned int source,
 587         unsigned int new_readmask)
 588 {
 589         unsigned int readmask = 0;
 590
 591         readmask |= get_source_readmask(&inst->U.P.RGB, source, src_type);
 592         readmask |= get_source_readmask(&inst->U.P.Alpha, source, src_type);
 593
 594         if ((new_readmask & readmask) != readmask)
 595                 return 0;
 596
 597         if (src_type & RC_SOURCE_RGB) {
 598                 memset(&inst->U.P.RGB.Src[source], 0,
 599                         sizeof(struct rc_pair_instruction_source));
 600         }
 601
 602         if (src_type & RC_SOURCE_ALPHA) {
 603                 memset(&inst->U.P.Alpha.Src[source], 0,
 604                         sizeof(struct rc_pair_instruction_source));
 605         }
 606
 607         return 1;
 608 }
 609
 610 /**
 611  * @return RC_OPCODE_NOOP if inst is not a flow control instruction.
 612  * @return The opcode of inst if it is a flow control instruction.
 613  */
 614 rc_opcode rc_get_flow_control_inst(struct rc_instruction * inst)
 615 {
 616         const struct rc_opcode_info * info;
 617         if (inst->Type == RC_INSTRUCTION_NORMAL) {
 618                 info = rc_get_opcode_info(inst->U.I.Opcode);
 619         } else {
 620                 info = rc_get_opcode_info(inst->U.P.RGB.Opcode);
 621                 /*A flow control instruction shouldn't have an alpha
 622                  * instruction.*/
 623                 assert(!info->IsFlowControl ||
 624                                 inst->U.P.Alpha.Opcode == RC_OPCODE_NOP);
 625         }
 626
 627         if (info->IsFlowControl)
 628                 return info->Opcode;
 629         else
 630                 return RC_OPCODE_NOP;
 631
 632 }
 633
 634 /**
 635  * @return The BGNLOOP instruction that starts the loop ended by endloop.
 636  */
 637 struct rc_instruction * rc_match_endloop(struct rc_instruction * endloop)
 638 {
 639         unsigned int endloop_count = 0;
 640         struct rc_instruction * inst;
 641         for (inst = endloop->Prev; inst != endloop; inst = inst->Prev) {
 642                 rc_opcode op = rc_get_flow_control_inst(inst);
 643                 if (op == RC_OPCODE_ENDLOOP) {
 644                         endloop_count++;
 645                 } else if (op == RC_OPCODE_BGNLOOP) {
 646                         if (endloop_count == 0) {
 647                                 return inst;
 648                         } else {
 649                                 endloop_count--;
 650                         }
 651                 }
 652         }
 653         return NULL;
 654 }
 655
 656 /**
 657  * @return The ENDLOOP instruction that ends the loop started by bgnloop.
 658  */
 659 struct rc_instruction * rc_match_bgnloop(struct rc_instruction * bgnloop)
 660 {
 661         unsigned int bgnloop_count = 0;
 662         struct rc_instruction * inst;
 663         for (inst = bgnloop->Next; inst!=bgnloop; inst = inst->Next) {
 664                 rc_opcode op = rc_get_flow_control_inst(inst);
 665                 if (op == RC_OPCODE_BGNLOOP) {
 666                         bgnloop_count++;
 667                 } else if (op == RC_OPCODE_ENDLOOP) {
 668                         if (bgnloop_count == 0) {
 669                                 return inst;
 670                         } else {
 671                                 bgnloop_count--;
 672                         }
 673                 }
 674         }
 675         return NULL;
 676 }
 677
 678 /**
 679  * @return A conversion swizzle for converting from old_mask->new_mask
 680  */
 681 unsigned int rc_make_conversion_swizzle(
 682         unsigned int old_mask,
 683         unsigned int new_mask)
 684 {
 685         unsigned int conversion_swizzle = rc_init_swizzle(RC_SWIZZLE_UNUSED, 0);
 686         unsigned int old_idx;
 687         unsigned int new_idx = 0;
 688         for (old_idx = 0; old_idx < 4; old_idx++) {
 689                 if (!GET_BIT(old_mask, old_idx))
 690                         continue;
 691                 for ( ; new_idx < 4; new_idx++) {
 692                         if (GET_BIT(new_mask, new_idx)) {
 693                                 SET_SWZ(conversion_swizzle, old_idx, new_idx);
 694                                 new_idx++;
 695                                 break;
 696                         }
 697                 }
 698         }
 699         return conversion_swizzle;
 700 }
 701
 702 /**
 703  * @return 1 if the register contains an immediate value, 0 otherwise.
 704  */
 705 unsigned int rc_src_reg_is_immediate(
 706         struct radeon_compiler * c,
 707         unsigned int file,
 708         unsigned int index)
 709 {
 710         return file == RC_FILE_CONSTANT &&
 711         c->Program.Constants.Constants[index].Type == RC_CONSTANT_IMMEDIATE;
 712 }
 713
 714 /**
 715  * @return The immediate value in the specified register.
 716  */
 717 float rc_get_constant_value(
 718         struct radeon_compiler * c,
 719         unsigned int index,
 720         unsigned int swizzle,
 721         unsigned int negate,
 722         unsigned int chan)
 723 {
 724         float base = 1.0f;
 725         int swz = GET_SWZ(swizzle, chan);
 726         if(swz >= 4 || index >= c->Program.Constants.Count ){
 727                 rc_error(c, "get_constant_value: Can't find a value.\n");
 728                 return 0.0f;
 729         }
 730         if(GET_BIT(negate, chan)){
 731                 base = -1.0f;
 732         }
 733         return base *
 734                 c->Program.Constants.Constants[index].u.Immediate[swz];
 735 }
 736
 737 /**
 738  * This function returns the component value (RC_SWIZZLE_*) of the first used
 739  * channel in the swizzle.  This is only useful for scalar instructions that are
 740  * known to use only one channel of the swizzle.
 741  */
 742 unsigned int rc_get_scalar_src_swz(unsigned int swizzle)
 743 {
 744         unsigned int swz, chan;
 745         for (chan = 0; chan < 4; chan++) {
 746                 swz = GET_SWZ(swizzle, chan);
 747                 if (swz != RC_SWIZZLE_UNUSED) {
 748                         break;
 749                 }
 750         }
 751         assert(swz != RC_SWIZZLE_UNUSED);
 752         return swz;
 753 }