![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cgen.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jerq / sgs / comp|
Return to cgen.c CVS log | Up to [Research Unix] / researchv9 / jerq / sgs / comp |
1.1 root 1: /* @(#) cgen.c: 1.3 4/26/84 */
2:
3: # include "mfile2.h"
4: # define istnode(p) (p->in.op==REG && istreg(p->tn.rval))
5:
6: /*
7: ** For God's workes are, like him, all infinite
8: ** And curious search but craftie sin's delight.
9: */
10:
11: rewcom( p, goal )
12: NODE *p;
13:
14: {
15: /* find all , ops, move as high as is legal */
16: /* rewrite p in place; this takes some doing! */
17: /* while we are at it, take care of setting the goal field */
18: int o, ty, g1, g2;
19: NODE *l, *r, *ql, *qr;
20:
21: o = p->tn.op;
22: g1 = g2 = NRGS;
23: p->tn.goal = goal;
24:
25: /* special cases for subtrees:
26: ** GENBR has left as Condition codes
27: ** COMOP has left as Effects
28: ** COLON, GENUBR, CM, GENLAB have descendents = node
29: ** CALL, STCALL, FORTCALL has right as Effects
30: ** All others use registers
31: */
32:
33: switch( o )
34: {
35:
36: case FREE:
37: cerror( "rewcom(%d) is FREE", p-node );
38:
39: case GENBR:
40: g1 = CCC;
41: break;
42:
43: case COMOP:
44: g1 = CEFF;
45: g2 = goal;
46: break;
47:
48: case COLON:
49: case GENUBR:
50: case CM:
51: case GENLAB:
52: g1 = g2 = goal;
53: break;
54:
55: case CALL:
56: case STCALL:
57: case FORTCALL:
58: g2 = CEFF;
59: break;
60: }
61:
62:
63: switch( ty = optype(o) )
64: {
65:
66: case BITYPE:
67: rewcom( r = p->in.right, g2 );
68: case UTYPE:
69: rewcom( l = p->in.left, g1 );
70: break;
71: case LTYPE:
72: return;
73: }
74:
75: if( o==COMOP || o==COLON || o==GENLAB ) return;
76:
77: /* look for (A,B) op C and A op (B,C), and rewrite */
78: /* A,B if A headed by GENBR can't be rewritten */
79: /* the assumption is that B is executed immediately after A, */
80: /* and this won't necessarily be true if op is commutative */
81:
82: if( l->tn.op == COMOP && l->in.left->tn.op != GENBR )
83: {
84: /* rewrite it... */
85: /* (A,B) op C => A,(B op C) */
86: /* also, for unary ops, op (A,B) => A , (op B) */
87: ql = l->in.left;
88: qr = l->in.right;
89: *l = *p; /* copies op, and other stuff if op is unary */
90: l->in.left = qr;
91: p->in.right = l;
92: p->in.left = ql;
93: p->tn.op = COMOP;
94: rewcom( p, p->tn.goal );
95: }
96: if( ty == UTYPE ) return;
97: if( r->tn.op == COMOP && r->in.right->tn.op != GENBR )
98: {
99: /* rewrite, again */
100: /* A op (B,C) => B,(A op C) */
101: /* op is not unary now */
102: ql = r->in.left;
103: qr = r->in.right;
104: *r = *p;
105: p->tn.op = COMOP;
106: p->in.left = ql;
107: r->in.right = qr;
108: rewcom( p, p->tn.goal );
109: }
110: }
111:
112: rewlhs(p)
113: NODE *p;
114:
115: {
116: /* rewrite x op= y as (x op= y),x */
117: /* it would be really nice to optimize after doing this . . . */
118: NODE *q, *t;
119: q = talloc();
120: *q = *p;
121: t = tcopy( p->in.left );
122: p->in.left = q;
123: p->in.right = t;
124: p->tn.op = COMOP;
125: return;
126: }
127:
128: rewsto(p)
129: NODE *p;
130: {
131: /* a temp, t, is generated, and p is rewritten as ((t=p),t) */
132: /* if p has the form x op= A, and x is of the right form, rewrite
133: /* as ((x op= A), x) */
134:
135: int o, ao;
136: NODE *t, *q;
137: /* probably not perfect for structs: CHECK UP.. */
138:
139: while( (o=p->tn.op) == COMOP ) p = p->in.right;
140: if( o == TEMP ) return(0); /* nothing to do */
141: if( o == STARG )
142: {
143: /* store a structure argument */ /* like storing a usual argument, but we have addresses */
144:
145: t = talloc();
146: *t = *p->in.left; /* copy contents, mainly for type, etc. */
147: q = talloc();
148: *q = *t;
149: t->tn.op = TEMP;
150: t->tn.lval = freetemp(argsize(p)/SZINT );
151: t->tn.lval = BITOOR(t->tn.lval);
152: t->tn.name = (char *) 0;
153: t->tn.type = TSTRUCT;
154: q->tn.op = UNARY AND;
155: q->in.left = t;
156: /* now, q has & TEMP */
157: t = talloc();
158: *t = *p;
159: t->in.left = q;
160: t->in.right = p->in.left;
161: t->tn.op = STASG;
162: /* now, t has (&TEMP) = struct */
163: p->in.left = talloc();
164: p->in.left->tn.op = COMOP;
165: p->in.left->in.left = t;
166: p->in.left->in.right = t = talloc(); /* copy q here */
167: *t = *q;
168: t->in.left = talloc();
169: *t->in.left = *q->in.left;
170: /* finally, have (&TEMP = struct),(&TEMP) */
171: /* this should do it: whew! */
172: #ifndef NODBG
173: if( odebug>1 ) e2print( p );
174: #endif
175: return( 1 );
176: }
177:
178: #ifndef NODBG
179: if( odebug>1 )
180: {
181: e2print( p );
182: printf( "\nrewritten by rewsto as:\n" );
183: }
184: #endif
185: if( asgop(o) && o!=INCR && o!=DECR && lhsok( p->in.left ) ) {
186: /* x op= y turns into (x op= y), x */
187: rewlhs( p );
188: return( 1 );
189: }
190: ao = ASG o;
191: if( asgbinop(ao) )
192: {
193: if( p->in.left->tn.op == TEMP )
194: {
195: p->tn.op = ao;
196: rewlhs( p );
197: #ifndef NODBG
198: if( odebug>1 ) e2print( p );
199: #endif
200: return( 1 );
201: }
202: }
203:
204: /* to rewrite in place, p becomes a COMOP; rhs is the temp, lsh
205: ** /* is t = p, where p has been converted to the intermediate type
206: */
207: /* after some debate, the type of the temp will be the type of p */
208:
209: t = talloc();
210: *t = *p; /* copy contents, mainly for type, etc. */
211: q = talloc();
212: *q = *p;
213: t->tn.op = TEMP;
214: t->tn.lval = freetemp(argsize(p)/SZINT );
215: t->tn.lval = BITOOR(t->tn.lval);
216: t->tn.name = (char *) 0;
217: q->tn.op = ASSIGN;
218: q->in.left = t;
219: q->in.right = talloc();
220: *(q->in.right) = *p;
221: /* now, q has (t=p) */
222: p->in.right = talloc();
223: *(p->in.right) = *t;
224: p->tn.op = COMOP;
225: p->in.left = q;
226: /* this should do it: whew! */
227: #ifndef NODBG
228: if( odebug>1 ) e2print( p );
229: #endif
230: return( 1 );
231: }
232:
233: iseff( p )
234: NODE *p;
235:
236: {
237: /* return 1 if p has some side effects, 0 otherwise */
238: int o;
239: o = p->tn.op;
240: if( callop(o) || asgop(o) ) return( 1 );
241: switch( optype( o ) )
242: {
243: case BITYPE:
244: if( iseff( p->in.right ) ) return( 1 );
245: case UTYPE:
246: return( iseff( p->in.left ) );
247: }
248: return( 0 );
249: }
250:
251: NODE *
252: lhsto( p )
253: NODE *p;
254:
255: {
256: /* find a piece of the LHS to be stored */
257: /* if found, rewrite tree */
258: NODE *q;
259: int o;
260:
261: for( q = p->in.left; (o=q->tn.op)!=STAR; q=q->in.left )
262: {
263: if( optype(o) == LTYPE ) return( (NODE *)0);
264: }
265: /* q is now the * node, if there one */
266: q = q->in.left;
267: o = q->tn.op;
268: if( optype(o) == LTYPE ) return( (NODE *)0 );
269: else return( q );
270: }
271:
272: static int
273: c2bigger( p ) NODE *p; {
274: /* p is a conversion op; does it make things bigger */
275: register TWORD t, tl;
276:
277: t = p->tn.type;
278: tl = p->in.left->tn.type;
279:
280: if( (t|tl)&TPOINT ) return( 0 ); /* pointers are funny */
281: if( t&TDOUBLE ) return( 1 );
282: if( tl&TDOUBLE ) return( 0 );
283: if( t&TFLOAT ) return( 1 );
284: if( tl&TFLOAT ) return( 0 );
285: if( t&(TLONG|TULONG) ) return( 1 );
286: if( tl&(TLONG|TULONG) ) return( 0 );
287: if( t&(TINT|TUNSIGNED) ) return( 1 );
288: if( tl&(TINT|TUNSIGNED) ) return( 0 );
289: if( t &(TSHORT|TUSHORT) ) return( 1 );
290: return( 0 );
291: }
292:
293: NODE *
294: ind2type( p )
295: register NODE *p;
296:
297: {
298: /* make the type of p be the appropriate type for an argument */
299: register TWORD t;
300: NODE *q;
301:
302: if ( !p )
303: return( p );
304: t = p->tn.type;
305: if( t == TCHAR || t == TSHORT ) t = TINT;
306: else if( t == TUCHAR || t == TUSHORT ) t = TUNSIGNED;
307: else if( t == TFLOAT ) t = TDOUBLE;
308: else return( p );
309:
310: if( p->tn.op == CONV && c2bigger(p) )
311: {
312: p->tn.type = t;
313: return( p );
314: }
315: q = talloc();
316: q->tn.op = CONV;
317: q->in.left = p;
318: q->in.right = 0;
319: q->tn.name = (char *) 0;
320: q->tn.type = t;
321: q->tn.goal = NRGS;
322: return( q );
323: }
324:
325: NODE *
326: reweop( p )
327: register NODE *p;
328:
329: {
330: /* rewrite A op= B as A = A op B */
331: /* also, rewrite (CONV A) op= B as A = (CONV ( (CONV A) op B ) ) */
332: /* rewritten in place */
333: /* on input, the type of the op= equals the type of A */
334: /* the type of the op node on output is the type of B */
335: /* the type of the = node on output is the type of A */
336:
337: register NODE *q, *t;
338: register TWORD ty;
339:
340: #ifndef NODBG
341: if( odebug>1 )
342: {
343: e2print( p );
344: printf( "\nrewritten by reweop as:\n" );
345: }
346: #endif
347: /* rewrite tree with duplicate left subtree in new right subtree */
348: /* there is an implicit q->in.right = p->in.right in *q = *p */
349: q = talloc();
350: *q = *p;
351: q->in.left = tcopy( p->in.left );
352: if( p->in.left->tn.op == CONV )
353: {
354: /* ( CONV (A) ) op= B becomes A = CONV ( CONV(A) op B ) */
355: /* the op is done to the type of B */
356: /* the assignment is done to the type of A */
357: t = p->in.left;
358: ty = t->in.left->tn.type;
359: p->in.left = t->in.left;
360: p->in.right = t;
361: t->in.left = q;
362: /* now, have the tree built; fix the types */
363: t->tn.type = ty;
364: }
365: else
366: {
367: p->in.right = q;
368: }
369: /* NOTE: no =ops for structures... */
370: p->tn.op = ASSIGN;
371: q->tn.op = NOASG q->tn.op;
372: p->tn.type = p->in.left->tn.type;
373: q->tn.type = q->in.right->tn.type;
374: #ifndef NODBG
375: if( odebug>1 ) e2print( p );
376: #endif
377: }
378:
379: rewass( p )
380: NODE *p;
381:
382: {
383: NODE *q;
384: int o;
385: /* look for =ops to be rewritten */
386:
387: #ifndef NODBG
388: if( odebug )
389: {
390: printf( "rewass called with:\n" );
391: e2print( p );
392: }
393: #endif
394: o = p->tn.op;
395: if( o == UNARY AND )
396: {
397: if( p->in.left->tn.op == RNODE )
398: {
399: /* this should happen only with structure returns */
400: q = p->in.left;
401: q->tn.op = ICON;
402: *p = *q;
403: q->tn.op = FREE;
404: return(0); /* keep going in costs */
405: }
406: /* this case should happen only with short structures */
407: rewsto( p->in.left );
408: /* & f() has turned into & ( t=f(),t) */
409: #ifndef NODBG
410: if( odebug )
411: {
412: printf( "\nrewritten by rewass as:\n" );
413: e2print( p );
414: }
415: #endif
416: return(1);
417: }
418: if( !asgop(o) || o==ASSIGN )
419: {
420: if( o==ASSIGN )
421: {
422: /* look for funny nodes on lhs */
423: o = p->in.left->tn.op;
424: if( o==RNODE || o==QNODE || o==SNODE )
425: {
426: /* force into r0 */
427: p->in.left->tn.op = REG;
428: p->in.left->tn.rval = callreg( p->in.right );
429: #ifndef NODBG
430: if( odebug )
431: {
432: printf( "funny node redone\n" );
433: e2print(p);
434: }
435: #endif
436: return(0);
437: }
438: }
439: else
440: {
441: TWORD t = p->in.left->tn.type;
442: /* this case is, for example,
443: unsigned char a, b;
444: ... a*b
445: /* we convert both to a reasonable type */
446: /* the result is assumed to be automatically
447: /* converted downwards if it should be... */
448:
449: p->in.left = ind2type( p->in.left );
450: p->in.right = ind2type( p->in.right );
451: #ifndef NODBG
452: if( odebug ) {
453: printf( "conversions inserted" );
454: e2print(p);
455: }
456: #endif
457: /* if this didn't work, we are in trouble */
458: if( t != p->in.left->tn.type ) {
459: /* we have changed something */
460: return( 0 );
461: }
462: }
463: e2print(p);
464: cerror( "can't deal with op %s", opst[o] );
465: }
466: if( o == INCR || o == DECR )
467: {
468: /* very crude: a++ becomes (a+=1)-1 */
469: #ifndef NODBG
470: if( odebug>1 )
471: {
472: e2print( p );
473: printf( "\nrewritten by rewass as:\n" );
474: }
475: #endif
476: if( p->in.goal == CEFF )
477: {
478: p->in.op = ((o==INCR)?ASG PLUS:ASG MINUS);
479: }
480: else
481: {
482: /* rewrite tree with duplicate left subree in new
483: /* right subtree...
484: /* there is an implict q->in.left = p->in.left in *q = * p
485: */
486: q = talloc();
487: *q = *p;
488: q->in.right = tcopy( p->in.right );
489: p->in.left = q;
490: q->tn.op = ((o==INCR)?ASG PLUS:ASG MINUS);
491: p->tn.op = ((o==INCR)?MINUS:PLUS);
492: }
493: #ifndef NODBG
494: if( odebug )
495: {
496: printf( "\nrewritten by rewass as:\n" );
497: e2print( p );
498: }
499: #endif
500: return(1);
501: }
502: /* find out if some subtree has to be stored into a temp... */
503: if( q = lhsto(p) )
504: {
505: if( !rewsto( q ) ) cerror( "rewass0" ); /* q => t=q,t */
506: rewcom( p, p->tn.goal ); /* move COMOP to the top */
507: if( p->tn.op != COMOP ) cerror( "rewass1" );
508: if( !asgop( p->in.right->tn.op ) ) cerror( "rewass2" );
509: reweop( p->in.right );
510: }
511: else reweop( p ); /* rewrite p as an =OP */
512: return(1);
513: }
514:
515: # ifdef NONEST
516: subcall( p )
517: register NODE *p;
518:
519: {
520: /* return 1 if p contains a callop */
521: register o, t;
522:
523: o = p->tn.op;
524: if( callop(o)
525: # ifndef UCALLBAD
526: && o!=UNARY CALL
527: # endif
528: # ifndef STCALLBAD
529: && o!=UNARY STCALL
530: # endif
531: # ifndef UFCALLBAD
532: && o!=UNARY FORTCALL
533: # endif
534: ) return( 1 );
535: t = optype( o );
536: if( t==BITYPE && subcall(p->in.right) ) return( 1 );
537: if( t!=LTYPE ) return( subcall( p->in.left ) );
538: return( 0 );
539: }
540:
541: nonest( p )
542: register NODE *p;
543:
544: {
545: register o, t;
546: /* right now, this is very crude */
547: /* find arguments below a call; store them */
548: /* nonest is called up to a call; stocm is called within args */
549:
550: o = p->tn.op;
551: t = optype( o );
552: if( o==CALL || o==STCALL || o==FORTCALL)
553: {
554: stocm( p->in.right );
555: nonest( p->in.left );
556: return;
557: }
558: if( t == BITYPE ) nonest( p->in.right );
559: if( t != LTYPE ) nonest( p->in.left );
560: }
561:
562: stocm( p )
563: register NODE *p;
564:
565: {
566: /* all call arguments below p must be stored */
567: register NODE *q;
568: register o;
569:
570: while( (o=p->tn.op) == CM )
571: {
572: stocm( p->in.right );
573: p = p->in.left;
574: }
575: if( o != STARG && o != FUNARG ) cerror( "stocm" );
576:
577: q = p->in.left;
578: if( subcall( q ) )
579: {
580: if( o == FUNARG ) rewsto( q );
581: else
582: {
583: /* structure argument with call beneath */
584: rewsto( p );
585: }
586: /* now q will be done outside of a call, so use nonest */
587: nonest( q );
588: }
589: }
590: # endif
591:
592: outshp( pp )
593: SHAPE **pp;
594:
595: {
596: SHAPE *p;
597:
598: if (pp == 0)
599: return;
600:
601: for( ; p = *pp; ++pp )
602: {
603: printf("\t\t");
604: shpr(p);
605: printf( " (%d)\n", p->sc );
606: }
607: }
608:
609: tabpr()
610: {
611: register OPTAB *p;
612: for (p =table; ;p++)
613: {
614: printf("Dump of table[%d] (stinline %d)\n", p-table, p->stinline );
615: printf("\top = %s\n", opst[p->op]);
616: printf("\tnextop = %d\n", p->nextop?p->nextop-table:-1 );
617: printf("\tlshape = %d\n", p->lshape-pshape);
618: printf("\tltype = 0%o\n", p->ltype);
619: printf("\trshape = %d\n", p->rshape-pshape);
620: printf("\trtype = 0%o\n", p->rtype);
621: printf("\tneeds = %d\n", p->needs);
622: printf("\trewrite = %d\n", p->rewrite);
623: printf("\tcstring = %s", p->cstring);
624: printf("\tcost = %d\n", p->cost);
625: printf("\tLeft:\n");
626: outshp(p->lshape);
627: printf("\tRight:\n");
628: outshp(p->rshape);
629: printf("\n");
630: }
631: }
632:
633: codgen( p )
634: NODE *p;
635:
636: {
637:
638: /* generate the code for p; */
639: int i, flag;
640:
641: #ifndef NODBG
642: if (odebug > 5)
643: {
644: tabpr();
645: /* NOTREACHED */
646: }
647: #endif
648:
649: # ifdef NONEST
650: nonest(p);
651: # endif
652:
653: /* if we make drastic changes to the tree (e.g., introduce temps)
654: ** /* we will go back and do the whole thing again
655: */
656: /* statistics indicate that this happens about 10% of the time */
657: /* if the percentage rises, there are many things that can be done to
658: ** /* improve matters
659: */
660: /* for example, RNODE, etc., could be removed by reader, and some of
661: ** /* the op rewriting could be discovered by reader as well
662: */
663:
664: again:
665:
666: /* move the comma ops as high as practical */
667:
668: rewcom( p, CEFF );
669:
670: #ifndef NODBG
671: if( odebug )
672: {
673: printf( "After goals are computed:" );
674: e2print( p );
675: }
676: #endif
677:
678: /* compute the costs */
679:
680: if( costs( p ) ) goto again; /* if rewritten, do again */
681:
682: #ifndef NODBG
683: if( odebug )
684: {
685: printf( "After costs are computed:" );
686: e2print( p );
687: }
688: #endif
689:
690: /* do a trial code generation */
691: nins = 0;
692: insout( p, CEFF );
693:
694: /* rewrite stored subtrees as assignments to temps, with COMOP's */
695: flag = 0;
696: for( i=0; i<nins; ++i )
697: {
698: if( inst[i].goal == CTEMP )
699: {
700: #ifndef NODBG
701: if( odebug )
702: {
703: printf( "subtree is stored in temp:\n" );
704: e2print( inst[i].p );
705: }
706: #endif
707: if( rewsto( inst[i].p ) ) {
708: if( !fast ) goto again;
709: /* otherwise, rewrite all temps now */
710: flag = 1;
711: }
712: }
713: }
714: if( flag ) goto again;
715:
716: #ifndef NODBG
717: if( odebug ) e2print(p);
718: #endif
719: /* output the actual instructions */
720: insprt();
721: }
722:
723: INST inst[NINS];
724: int nins;
725:
726: insprt()
727: {
728: int i;
729: register INST *pi;
730: register NODE *p;
731: register OPTAB *q;
732: register c, goal;
733:
734: for( pi=inst,i=0; i<nins; ++i,++pi )
735: {
736: p = pi->p;
737: q = pi->q;
738: c = pi->goal;
739: if( c == CCC && (q->rewrite&RESCC) ) goal = FORCC;
740: else if( c == CEFF ) goal = FOREFF;
741: else goal = INREG;
742: #ifndef NODEBUG
743: if(odebug > 4)
744: {
745: printf("INSOUT: %d c=",i);
746: preff(c);
747: printf(" goal=");
748: prgoal(goal);
749: printf("\n");
750: e2print(p);
751: }
752: #endif
753:
754: allo( p, q );
755: # ifdef TMPSRET
756: /* not the best place in the world, but... */
757: if (p->in.op == STCALL || p->in.op == UNARY STCALL)
758: expand(p, goal, TMPSRET, q);
759: #endif
760: expand( p, goal, q->cstring, q );
761: reclaim( p, q->rewrite, goal );
762:
763: /* now, if condition codes needed, test */
764: if( c == CCC && p->tn.op != CCODES )
765: {
766: cfix( p, CCC );
767: if( p->tn.op != CCODES ) cerror( "ctest fails" );
768: }
769: if( c>=0 && c<=NRGS && !istnode( p ) )
770: {
771: cfix( p, NRGS );
772: }
773: }
774: }
775:
776: SHTABLE sha;
777: int odebug = 0;
778:
779: cfix( p, goal )
780: NODE *p;
781: {
782: /* p is to be fixed according to goal (CCC or NRGS) */
783: OPTAB *q;
784: NODE *pp;
785: int r;
786:
787: #ifndef NODBG
788: if(odebug > 4)
789: {
790: printf("CFIX: goal=");
791: prgoal(goal);
792: printf("\n");
793: e2print(p);
794: }
795: #endif
796: if( goal == CCC )
797: {
798: r = RESCC;
799: p->tn.goal = CCC;
800: }
801: else
802: {
803: r = (RESC1|RESC2|RESC3);
804: pp = getl( p );
805: if( istnode( pp ) ) r |= RLEFT;
806: pp = getr( p );
807: if( istnode( pp ) ) r |= RRIGHT;
808: }
809:
810: if( goal == CCC ) goal = FORCC;
811: else goal = INREG;
812:
813: for( q=0; q = match( p, q ); )
814: {
815: /* takes the first match (may not be cheapest) */
816: /* template writers, take note! */
817: if( q->rewrite & r )
818: {
819: /* generate the code on the spot */
820: allo( p, q );
821: # ifdef TMPSRET
822: /* likewise */
823: if (p->in.op == STCALL || p->in.op == UNARY STCALL)
824: expand(p, goal, TMPSRET, q);
825: #endif
826: expand( p, goal, q->cstring, q );
827: reclaim( p, q->rewrite, goal );
828: return;
829: }
830: }
831: e2print(p);
832: cerror( "cfix trouble" );
833: }
834:
835:
836: preff(c)
837: {
838: char buf[20];
839: register char *p;
840:
841: p = c==CCC ? "CCC" : c==CTEMP ? "CTEMP" : c==CEFF ? "CEFF" : 0;
842: if(!p)
843: {
844: sprintf(buf,"0%o",c);
845: p = buf;
846: }
847: printf("%s",p);
848: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.