src/mesa/drivers/dri/r300/r300_context.c

   1 /*
   2 Copyright (C) The Weather Channel, Inc.  2002.  All Rights Reserved.
   3
   4 The Weather Channel (TM) funded Tungsten Graphics to develop the
   5 initial release of the Radeon 8500 driver under the XFree86 license.
   6 This notice must be preserved.
   7
   8 Permission is hereby granted, free of charge, to any person obtaining
   9 a copy of this software and associated documentation files (the
  10 "Software"), to deal in the Software without restriction, including
  11 without limitation the rights to use, copy, modify, merge, publish,
  12 distribute, sublicense, and/or sell copies of the Software, and to
  13 permit persons to whom the Software is furnished to do so, subject to
  14 the following conditions:
  15
  16 The above copyright notice and this permission notice (including the
  17 next paragraph) shall be included in all copies or substantial
  18 portions of the Software.
  19
  20 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  23 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  24 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27
  28 **************************************************************************/
  29
  30 /*
  31  * Authors:
  32  *   Keith Whitwell <keith@tungstengraphics.com>
  33  *   Nicolai Haehnle <prefect_@gmx.net>
  34  */
  35 #include "glheader.h"
  36 #include "api_arrayelt.h"
  37 #include "context.h"
  38 #include "simple_list.h"
  39 #include "imports.h"
  40 #include "matrix.h"
  41 #include "extensions.h"
  42 #include "state.h"
  43 #include "bufferobj.h"
  44
  45 #include "swrast/swrast.h"
  46 #include "swrast_setup/swrast_setup.h"
  47 #include "vbo/vbo.h"
  48
  49 #include "tnl/tnl.h"
  50 #include "tnl/t_pipeline.h"
  51 #include "tnl/t_vp_build.h"
  52
  53 #include "drivers/common/driverfuncs.h"
  54
  55 #include "radeon_ioctl.h"
  56 #include "radeon_span.h"
  57 #include "r300_context.h"
  58 #include "r300_cmdbuf.h"
  59 #include "r300_state.h"
  60 #include "r300_ioctl.h"
  61 #include "r300_tex.h"
  62 #include "r300_maos.h"
  63
  64 #ifdef USER_BUFFERS
  65 #include "radeon_mm.h"
  66 #endif
  67
  68 #include "vblank.h"
  69 #include "utils.h"
  70 #include "xmlpool.h"            /* for symbolic values of enum-type options */
  71
  72 /* hw_tcl_on derives from future_hw_tcl_on when its safe to change it. */
  73 int future_hw_tcl_on=1;
  74 int hw_tcl_on=1;
  75
  76 #define need_GL_EXT_stencil_two_side
  77 #define need_GL_ARB_multisample
  78 #define need_GL_ARB_texture_compression
  79 #define need_GL_ARB_vertex_buffer_object
  80 #define need_GL_ARB_vertex_program
  81 #define need_GL_EXT_blend_minmax
  82 //#define need_GL_EXT_fog_coord
  83 #define need_GL_EXT_secondary_color
  84 #define need_GL_EXT_blend_equation_separate
  85 #define need_GL_EXT_blend_func_separate
  86 #define need_GL_EXT_gpu_program_parameters
  87 #define need_GL_NV_vertex_program
  88 #include "extension_helper.h"
  89
  90 const struct dri_extension card_extensions[] = {
  91   {"GL_ARB_multisample",                GL_ARB_multisample_functions},
  92   {"GL_ARB_multitexture",               NULL},
  93   {"GL_ARB_texture_border_clamp",       NULL},
  94   {"GL_ARB_texture_compression",        GL_ARB_texture_compression_functions},
  95   {"GL_ARB_texture_cube_map",           NULL},
  96   {"GL_ARB_texture_env_add",            NULL},
  97   {"GL_ARB_texture_env_combine",        NULL},
  98   {"GL_ARB_texture_env_crossbar",       NULL},
  99   {"GL_ARB_texture_env_dot3",           NULL},
 100   {"GL_ARB_texture_mirrored_repeat",    NULL},
 101   {"GL_ARB_vertex_buffer_object",       GL_ARB_vertex_buffer_object_functions},
 102   {"GL_ARB_vertex_program",             GL_ARB_vertex_program_functions},
 103   {"GL_ARB_fragment_program",           NULL},
 104   {"GL_EXT_blend_equation_separate",    GL_EXT_blend_equation_separate_functions},
 105   {"GL_EXT_blend_func_separate",        GL_EXT_blend_func_separate_functions},
 106   {"GL_EXT_blend_minmax",               GL_EXT_blend_minmax_functions},
 107   {"GL_EXT_blend_subtract",             NULL},
 108 //  {"GL_EXT_fog_coord",                        GL_EXT_fog_coord_functions },
 109   {"GL_EXT_gpu_program_parameters",     GL_EXT_gpu_program_parameters_functions},
 110   {"GL_EXT_secondary_color",            GL_EXT_secondary_color_functions},
 111   {"GL_EXT_stencil_two_side",           GL_EXT_stencil_two_side_functions},
 112   {"GL_EXT_stencil_wrap",               NULL},
 113   {"GL_EXT_texture_edge_clamp",         NULL},
 114   {"GL_EXT_texture_env_combine",        NULL},
 115   {"GL_EXT_texture_env_dot3",           NULL},
 116   {"GL_EXT_texture_filter_anisotropic", NULL},
 117   {"GL_EXT_texture_lod_bias",           NULL},
 118   {"GL_EXT_texture_mirror_clamp",       NULL},
 119   {"GL_EXT_texture_rectangle",          NULL},
 120   {"GL_ATI_texture_env_combine3",       NULL},
 121   {"GL_ATI_texture_mirror_once",        NULL},
 122   {"GL_MESA_pack_invert",               NULL},
 123   {"GL_MESA_ycbcr_texture",             NULL},
 124   {"GL_MESAX_texture_float",            NULL},
 125   {"GL_NV_blend_square",                NULL},
 126   {"GL_NV_vertex_program",              GL_NV_vertex_program_functions},
 127   {"GL_SGIS_generate_mipmap",           NULL},
 128   {NULL,                                NULL}
 129 };
 130
 131 extern struct tnl_pipeline_stage _r300_render_stage;
 132 extern const struct tnl_pipeline_stage _r300_tcl_stage;
 133
 134 static const struct tnl_pipeline_stage *r300_pipeline[] = {
 135
 136         /* Try and go straight to t&l
 137          */
 138         &_r300_tcl_stage,
 139
 140         /* Catch any t&l fallbacks
 141          */
 142         &_tnl_vertex_transform_stage,
 143         &_tnl_normal_transform_stage,
 144         &_tnl_lighting_stage,
 145         &_tnl_fog_coordinate_stage,
 146         &_tnl_texgen_stage,
 147         &_tnl_texture_transform_stage,
 148         &_tnl_vertex_program_stage,
 149
 150         /* Try again to go to tcl?
 151          *     - no good for asymmetric-twoside (do with multipass)
 152          *     - no good for asymmetric-unfilled (do with multipass)
 153          *     - good for material
 154          *     - good for texgen
 155          *     - need to manipulate a bit of state
 156          *
 157          * - worth it/not worth it?
 158          */
 159
 160         /* Else do them here.
 161          */
 162         &_r300_render_stage,
 163         &_tnl_render_stage,     /* FALLBACK  */
 164         0,
 165 };
 166
 167
 168 /* Create the device specific rendering context.
 169  */
 170 GLboolean r300CreateContext(const __GLcontextModes * glVisual,
 171                             __DRIcontextPrivate * driContextPriv,
 172                             void *sharedContextPrivate)
 173 {
 174         __DRIscreenPrivate *sPriv = driContextPriv->driScreenPriv;
 175         radeonScreenPtr screen = (radeonScreenPtr) (sPriv->private);
 176         struct dd_function_table functions;
 177         r300ContextPtr r300;
 178         GLcontext *ctx;
 179         int tcl_mode, i;
 180
 181         assert(glVisual);
 182         assert(driContextPriv);
 183         assert(screen);
 184
 185         /* Allocate the R300 context */
 186         r300 = (r300ContextPtr)CALLOC(sizeof(*r300));
 187         if (!r300)
 188                 return GL_FALSE;
 189
 190         if (!(screen->chip_flags & RADEON_CHIPSET_TCL))
 191                 hw_tcl_on = future_hw_tcl_on = 0;
 192
 193         /* Parse configuration files.
 194          * Do this here so that initialMaxAnisotropy is set before we create
 195          * the default textures.
 196          */
 197         driParseConfigFiles(&r300->radeon.optionCache, &screen->optionCache,
 198                             screen->driScreen->myNum, "r300");
 199         r300->initialMaxAnisotropy = driQueryOptionf(&r300->radeon.optionCache,
 200                                                      "def_max_anisotropy");
 201
 202         //r300->texmicrotile = GL_TRUE;
 203
 204         /* Init default driver functions then plug in our R300-specific functions
 205          * (the texture functions are especially important)
 206          */
 207         _mesa_init_driver_functions(&functions);
 208         r300InitIoctlFuncs(&functions);
 209         r300InitStateFuncs(&functions);
 210         r300InitTextureFuncs(&functions);
 211         r300InitShaderFuncs(&functions);
 212
 213 #ifdef USER_BUFFERS
 214         radeon_mm_init(r300);
 215 #endif
 216 #ifdef HW_VBOS
 217         if (hw_tcl_on) {
 218                 r300InitVBOFuncs(&functions);
 219         }
 220 #endif
 221         if (!radeonInitContext(&r300->radeon, &functions,
 222                                glVisual, driContextPriv, sharedContextPrivate)) {
 223                 FREE(r300);
 224                 return GL_FALSE;
 225         }
 226
 227         /* Init r300 context data */
 228         r300->dma.buf0_address = r300->radeon.radeonScreen->buffers->list[0].address;
 229
 230         (void)memset(r300->texture_heaps, 0, sizeof(r300->texture_heaps));
 231         make_empty_list(&r300->swapped);
 232
 233         r300->nr_heaps = 1 /* screen->numTexHeaps */ ;
 234         assert(r300->nr_heaps < RADEON_NR_TEX_HEAPS);
 235         for (i = 0; i < r300->nr_heaps; i++) {
 236                 r300->texture_heaps[i] = driCreateTextureHeap(i, r300,
 237                                                                screen->
 238                                                                texSize[i], 12,
 239                                                                RADEON_NR_TEX_REGIONS,
 240                                                                (drmTextureRegionPtr)
 241                                                                r300->radeon.sarea->
 242                                                                tex_list[i],
 243                                                                &r300->radeon.sarea->
 244                                                                tex_age[i],
 245                                                                &r300->swapped,
 246                                                                sizeof
 247                                                                (r300TexObj),
 248                                                                (destroy_texture_object_t
 249                                                                 *)
 250                                                                r300DestroyTexObj);
 251         }
 252         r300->texture_depth = driQueryOptioni(&r300->radeon.optionCache,
 253                                                "texture_depth");
 254         if (r300->texture_depth == DRI_CONF_TEXTURE_DEPTH_FB)
 255                 r300->texture_depth = (screen->cpp == 4) ?
 256                     DRI_CONF_TEXTURE_DEPTH_32 : DRI_CONF_TEXTURE_DEPTH_16;
 257
 258         /* Set the maximum texture size small enough that we can guarentee that
 259          * all texture units can bind a maximal texture and have them both in
 260          * texturable memory at once.
 261          */
 262
 263         ctx = r300->radeon.glCtx;
 264
 265         ctx->Const.MaxTextureImageUnits = driQueryOptioni(&r300->radeon.optionCache,
 266                                                      "texture_image_units");
 267         ctx->Const.MaxTextureCoordUnits = driQueryOptioni(&r300->radeon.optionCache,
 268                                                      "texture_coord_units");
 269         ctx->Const.MaxTextureUnits = MIN2(ctx->Const.MaxTextureImageUnits,
 270                                           ctx->Const.MaxTextureCoordUnits);
 271         ctx->Const.MaxTextureMaxAnisotropy = 16.0;
 272
 273         ctx->Const.MinPointSize = 1.0;
 274         ctx->Const.MinPointSizeAA = 1.0;
 275         ctx->Const.MaxPointSize = R300_POINTSIZE_MAX;
 276         ctx->Const.MaxPointSizeAA = R300_POINTSIZE_MAX;
 277
 278         ctx->Const.MinLineWidth = 1.0;
 279         ctx->Const.MinLineWidthAA = 1.0;
 280         ctx->Const.MaxLineWidth = R300_LINESIZE_MAX;
 281         ctx->Const.MaxLineWidthAA = R300_LINESIZE_MAX;
 282
 283 #ifdef USER_BUFFERS
 284         /* Needs further modifications */
 285 #if 0
 286         ctx->Const.MaxArrayLockSize = (/*512*/RADEON_BUFFER_SIZE*16*1024) / (4*4);
 287 #endif
 288 #endif
 289
 290         /* Initialize the software rasterizer and helper modules.
 291          */
 292         _swrast_CreateContext(ctx);
 293         _vbo_CreateContext(ctx);
 294         _tnl_CreateContext(ctx);
 295         _swsetup_CreateContext(ctx);
 296         _swsetup_Wakeup(ctx);
 297         _ae_create_context(ctx);
 298
 299         /* Install the customized pipeline:
 300          */
 301         _tnl_destroy_pipeline(ctx);
 302         _tnl_install_pipeline(ctx, r300_pipeline);
 303
 304         /* Try and keep materials and vertices separate:
 305          */
 306 /*      _tnl_isolate_materials(ctx, GL_TRUE); */
 307
 308         /* Configure swrast and TNL to match hardware characteristics:
 309          */
 310         _swrast_allow_pixel_fog(ctx, GL_FALSE);
 311         _swrast_allow_vertex_fog(ctx, GL_TRUE);
 312         _tnl_allow_pixel_fog(ctx, GL_FALSE);
 313         _tnl_allow_vertex_fog(ctx, GL_TRUE);
 314
 315         /* currently bogus data */
 316         ctx->Const.VertexProgram.MaxInstructions=VSF_MAX_FRAGMENT_LENGTH/4;
 317         ctx->Const.VertexProgram.MaxNativeInstructions=VSF_MAX_FRAGMENT_LENGTH/4;
 318         ctx->Const.VertexProgram.MaxNativeAttribs=16; /* r420 */
 319         ctx->Const.VertexProgram.MaxTemps=32;
 320         ctx->Const.VertexProgram.MaxNativeTemps=/*VSF_MAX_FRAGMENT_TEMPS*/32;
 321         ctx->Const.VertexProgram.MaxNativeParameters=256; /* r420 */
 322         ctx->Const.VertexProgram.MaxNativeAddressRegs=1;
 323
 324         ctx->Const.FragmentProgram.MaxNativeTemps = PFS_NUM_TEMP_REGS;
 325         ctx->Const.FragmentProgram.MaxNativeAttribs = 11; /* copy i915... */
 326         ctx->Const.FragmentProgram.MaxNativeParameters = PFS_NUM_CONST_REGS;
 327         ctx->Const.FragmentProgram.MaxNativeAluInstructions = PFS_MAX_ALU_INST;
 328         ctx->Const.FragmentProgram.MaxNativeTexInstructions = PFS_MAX_TEX_INST;
 329         ctx->Const.FragmentProgram.MaxNativeInstructions = PFS_MAX_ALU_INST+PFS_MAX_TEX_INST;
 330         ctx->Const.FragmentProgram.MaxNativeTexIndirections = PFS_MAX_TEX_INDIRECT;
 331         ctx->Const.FragmentProgram.MaxNativeAddressRegs = 0; /* and these are?? */
 332         _tnl_ProgramCacheInit(ctx);
 333         ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
 334
 335         driInitExtensions(ctx, card_extensions, GL_TRUE);
 336
 337         if (driQueryOptionb(&r300->radeon.optionCache, "disable_stencil_two_side"))
 338            _mesa_disable_extension(ctx, "GL_EXT_stencil_two_side");
 339
 340         if (r300->radeon.glCtx->Mesa_DXTn && !driQueryOptionb (&r300->radeon.optionCache, "disable_s3tc")) {
 341           _mesa_enable_extension( ctx, "GL_EXT_texture_compression_s3tc" );
 342           _mesa_enable_extension( ctx, "GL_S3_s3tc" );
 343         }
 344         else if (driQueryOptionb (&r300->radeon.optionCache, "force_s3tc_enable")) {
 345           _mesa_enable_extension( ctx, "GL_EXT_texture_compression_s3tc" );
 346         }
 347
 348         r300->disable_lowimpact_fallback = driQueryOptionb(&r300->radeon.optionCache, "disable_lowimpact_fallback");
 349
 350         radeonInitSpanFuncs(ctx);
 351         r300InitCmdBuf(r300);
 352         r300InitState(r300);
 353
 354 #ifdef RADEON_VTXFMT_A
 355         radeon_init_vtxfmt_a(r300);
 356 #endif
 357
 358         TNL_CONTEXT(ctx)->Driver.RunPipeline = _tnl_run_pipeline;
 359
 360         tcl_mode = driQueryOptioni(&r300->radeon.optionCache, "tcl_mode");
 361         if (driQueryOptionb(&r300->radeon.optionCache, "no_rast")) {
 362                 fprintf(stderr, "disabling 3D acceleration\n");
 363 #if R200_MERGED
 364                 FALLBACK(&r300->radeon, RADEON_FALLBACK_DISABLE, 1);
 365 #endif
 366         }
 367         if (tcl_mode == DRI_CONF_TCL_SW ||
 368             !(r300->radeon.radeonScreen->chip_flags & RADEON_CHIPSET_TCL)) {
 369                 if (r300->radeon.radeonScreen->chip_flags & RADEON_CHIPSET_TCL) {
 370                         r300->radeon.radeonScreen->chip_flags &= ~RADEON_CHIPSET_TCL;
 371                         fprintf(stderr, "Disabling HW TCL support\n");
 372                 }
 373                 TCL_FALLBACK(r300->radeon.glCtx, RADEON_TCL_FALLBACK_TCL_DISABLE, 1);
 374         }
 375
 376         return GL_TRUE;
 377 }
 378
 379 static void r300FreeGartAllocations(r300ContextPtr r300)
 380 {
 381         int i, ret, tries=0, done_age, in_use=0;
 382         drm_radeon_mem_free_t memfree;
 383
 384         memfree.region = RADEON_MEM_REGION_GART;
 385
 386 #ifdef USER_BUFFERS
 387         for (i = r300->rmm->u_last; i > 0; i--) {
 388                 if (r300->rmm->u_list[i].ptr == NULL) {
 389                         continue;
 390                 }
 391
 392                 /* check whether this buffer is still in use */
 393                 if (r300->rmm->u_list[i].pending) {
 394                         in_use++;
 395                 }
 396         }
 397         /* Cannot flush/lock if no context exists. */
 398         if (in_use)
 399                 r300FlushCmdBuf(r300, __FUNCTION__);
 400
 401         done_age = radeonGetAge((radeonContextPtr)r300);
 402
 403         for (i = r300->rmm->u_last; i > 0; i--) {
 404                 if (r300->rmm->u_list[i].ptr == NULL) {
 405                         continue;
 406                 }
 407
 408                 /* check whether this buffer is still in use */
 409                 if (!r300->rmm->u_list[i].pending) {
 410                         continue;
 411                 }
 412
 413                 assert(r300->rmm->u_list[i].h_pending == 0);
 414
 415                 tries = 0;
 416                 while(r300->rmm->u_list[i].age > done_age && tries++ < 1000) {
 417                         usleep(10);
 418                         done_age = radeonGetAge((radeonContextPtr)r300);
 419                 }
 420                 if (tries >= 1000) {
 421                         WARN_ONCE("Failed to idle region!");
 422                 }
 423
 424                 memfree.region_offset = (char *)r300->rmm->u_list[i].ptr -
 425                         (char *)r300->radeon.radeonScreen->gartTextures.map;
 426
 427                 ret = drmCommandWrite(r300->radeon.radeonScreen->driScreen->fd,
 428                                 DRM_RADEON_FREE, &memfree, sizeof(memfree));
 429                 if (ret) {
 430                         fprintf(stderr, "Failed to free at %p\nret = %s\n",
 431                                 r300->rmm->u_list[i].ptr, strerror(-ret));
 432                 } else {
 433                         if (i == r300->rmm->u_last)
 434                                 r300->rmm->u_last--;
 435
 436                         r300->rmm->u_list[i].pending = 0;
 437                         r300->rmm->u_list[i].ptr = NULL;
 438                         if (r300->rmm->u_list[i].fb) {
 439                                 LOCK_HARDWARE(&(r300->radeon));
 440                                 ret = mmFreeMem(r300->rmm->u_list[i].fb);
 441                                 UNLOCK_HARDWARE(&(r300->radeon));
 442                                 if (ret) fprintf(stderr, "failed to free!\n");
 443                                 r300->rmm->u_list[i].fb = NULL;
 444                         }
 445                         r300->rmm->u_list[i].ref_count = 0;
 446                 }
 447         }
 448     r300->rmm->u_head = i;
 449 #endif /* USER_BUFFERS */
 450 }
 451
 452 /* Destroy the device specific context.
 453  */
 454 void r300DestroyContext(__DRIcontextPrivate * driContextPriv)
 455 {
 456         GET_CURRENT_CONTEXT(ctx);
 457         r300ContextPtr r300 = (r300ContextPtr) driContextPriv->driverPrivate;
 458         radeonContextPtr radeon = (radeonContextPtr) r300;
 459         radeonContextPtr current = ctx ? RADEON_CONTEXT(ctx) : NULL;
 460
 461         if (RADEON_DEBUG & DEBUG_DRI) {
 462                 fprintf(stderr, "Destroying context !\n");
 463         }
 464
 465         /* check if we're deleting the currently bound context */
 466         if (&r300->radeon == current) {
 467                 radeonFlush(r300->radeon.glCtx);
 468                 _mesa_make_current(NULL, NULL, NULL);
 469         }
 470
 471         /* Free r300 context resources */
 472         assert(r300);           /* should never be null */
 473
 474         if (r300) {
 475                 GLboolean release_texture_heaps;
 476
 477                 release_texture_heaps = (r300->radeon.glCtx->Shared->RefCount == 1);
 478                 _swsetup_DestroyContext(r300->radeon.glCtx);
 479                 _tnl_ProgramCacheDestroy(r300->radeon.glCtx);
 480                 _tnl_DestroyContext(r300->radeon.glCtx);
 481                 _vbo_DestroyContext(r300->radeon.glCtx);
 482                 _swrast_DestroyContext(r300->radeon.glCtx);
 483
 484                 if (r300->dma.current.buf) {
 485                         r300ReleaseDmaRegion(r300, &r300->dma.current, __FUNCTION__ );
 486 #ifndef USER_BUFFERS
 487                         r300FlushCmdBuf(r300, __FUNCTION__);
 488 #endif
 489                 }
 490                 r300FreeGartAllocations(r300);
 491                 r300DestroyCmdBuf(r300);
 492
 493                 if (radeon->state.scissor.pClipRects) {
 494                         FREE(radeon->state.scissor.pClipRects);
 495                         radeon->state.scissor.pClipRects = NULL;
 496                 }
 497
 498                 if (release_texture_heaps) {
 499                         /* This share group is about to go away, free our private
 500                          * texture object data.
 501                          */
 502                         int i;
 503
 504                         for (i = 0; i < r300->nr_heaps; i++) {
 505                                 driDestroyTextureHeap(r300->texture_heaps[i]);
 506                                 r300->texture_heaps[i] = NULL;
 507                         }
 508
 509                         assert(is_empty_list(&r300->swapped));
 510                 }
 511
 512                 radeonCleanupContext(&r300->radeon);
 513
 514 #ifdef USER_BUFFERS
 515                 /* the memory manager might be accessed when Mesa frees the shared
 516                  * state, so don't destroy it earlier
 517                  */
 518                 radeon_mm_destroy(r300);
 519 #endif
 520
 521                 /* free the option cache */
 522                 driDestroyOptionCache(&r300->radeon.optionCache);
 523
 524                 FREE(r300);
 525         }
 526 }